Nimbin[12]?SDL & Graphics / sdl_runtime_compiler / commits / d26abd1

sdl_runtime_compiler git · main

SDL3 game for running and compiling code at runtime

sdl3 c++ compiler dlopen cmake · first commit 2026-04-19 · last commit 2026-07-03 (3 months ago) · synced 3 days ago · upstream: git.ide3.de/hsnr/sdl-runtime-compiler

C++ 72.3% C 26.2%
git clone https://git.christianimmanuel.de/sdl-graphics/sdl_runtime_compiler.gitwget https://git.christianimmanuel.de/sdl-graphics/sdl_runtime_compiler/archive/sdl_runtime_compiler.tar.gz

Cleanup

Christian Immanuel · 2026-07-03 09:24 · d26abd1d48048a8376c20ba52aab2829db19f3a8

 blame_ai.sh               |   0
 src/states/game_state.cpp | 189 +++++++++++++++++++++++-----------------------
 src/states/game_state.hpp |  32 ++++----
 3 files changed, 112 insertions(+), 109 deletions(-)

diff --git a/blame_ai.sh b/blame_ai.sh
old mode 100644
new mode 100755
diff --git a/src/states/game_state.cpp b/src/states/game_state.cpp
index ee44773..48a24c5 100644
--- a/src/states/game_state.cpp
+++ b/src/states/game_state.cpp
@@ -55,36 +55,36 @@ GameState::GameState(size_t starting_level)
                                      Text::LayoutMode::Editing);
     _wall_editor.set_ShowNumbers(true, true);
 
-    _text_walls = { &_wall_editor };
+    _text_walls   = { &_wall_editor };
+
+    _wall_program = Text::Handler    (Wall::Role::Program, World::get_BoxScale(),
+                                      Text::LayoutMode::Display);
+    _wall_program.set_Lexing         (false);
+    _wall_program.set_ShowNumbers    (false, false);
+    _wall_program.set_DefaultStyle   (Text::Token::depth_wall, 0.003f,
+                                      static_cast<double>(ProgramSystem::line_height),
+                                      Config::Wall::free_space_dist);
+    _wall_program.set_AppendBaseline (static_cast<double>(ProgramSystem::start_y));
+    _wall_program.set_FaceMode       (Text::FaceMode::Pitch);
+
+    _wall_compiler = Text::Handler   (Wall::Role::Compiler, World::get_BoxScale(),
+                                      Text::LayoutMode::Display);
+    _wall_compiler.set_Lexing        (false);
+    _wall_compiler.set_ShowNumbers   (false, false);
+    _wall_compiler.set_DefaultStyle  (Text::Token::depth_compiler, 0.003f,
+                                      static_cast<double>(CompilerSystem::line_height),
+                                      Config::Wall::free_space_dist);
+    _wall_compiler.set_AppendBaseline(static_cast<double>(CompilerSystem::start_y));
+    _wall_compiler.set_AppendColor   (Config::Color::white);
+    _wall_compiler.set_FaceMode      (Text::FaceMode::Pitch);
 
-    _wall_program = Text::Handler(Wall::Role::Program, World::get_BoxScale(),
+    _wall_info = Text::Handler   (Wall::Role::Info, World::get_BoxScale(),
                                   Text::LayoutMode::Display);
-    _wall_program.set_Lexing      (false);
-    _wall_program.set_ShowNumbers (false, false);
-    _wall_program.set_DefaultStyle(Text::Token::depth_wall, 0.003f,
-                              static_cast<double>(ProgramSystem::line_height),
-                              Config::Wall::free_space_dist);
-    _wall_program.set_AppendBaseline(static_cast<double>(ProgramSystem::start_y));
-    _wall_program.set_FaceMode      (Text::FaceMode::Pitch);
-
-    _wall_compiler = Text::Handler(Wall::Role::Compiler, World::get_BoxScale(),
-                              Text::LayoutMode::Display);
-    _wall_compiler.set_Lexing      (false);
-    _wall_compiler.set_ShowNumbers (false, false);
-    _wall_compiler.set_DefaultStyle(Text::Token::depth_compiler, 0.003f,
-                                    static_cast<double>(CompilerSystem::line_height),
-                                    Config::Wall::free_space_dist);
-    _wall_compiler.set_AppendBaseline(static_cast<double>(CompilerSystem::start_y));
-    _wall_compiler.set_AppendColor(Config::Color::white);
-    _wall_compiler.set_FaceMode(Text::FaceMode::Pitch);
-
-    _wall_info = Text::Handler(Wall::Role::Info, World::get_BoxScale(),
-                               Text::LayoutMode::Display);
-    _wall_info.set_Lexing      (false);
-    _wall_info.set_ShowNumbers (false, false);
-    _wall_info.set_DefaultStyle(Text::Token::depth_wall, 0.003f,
-                                static_cast<double>(Config::Wall::text_line_spacing),
-                                Config::Wall::free_space_dist);
+    _wall_info.set_Lexing        (false);
+    _wall_info.set_ShowNumbers   (false, false);
+    _wall_info.set_DefaultStyle  (Text::Token::depth_wall, 0.003f,
+                                  static_cast<double>(Config::Wall::text_line_spacing),
+                                  Config::Wall::free_space_dist);
     _wall_info.set_AppendBaseline(World::get_FloorY<double>() + 1.0);
     _wall_info.set_AppendColor   (Config::Color::white);
     _wall_info.set_FaceMode      (Text::FaceMode::Pitch);
@@ -124,16 +124,14 @@ GameState::debug_SpawnWords([[maybe_unused]] size_t n)
     const double hover_y = World::get_FloorY<double>() + 1.5;
 
     for (size_t i = 0; i < tokens.size(); i++) {
-        Vec3 pos {
-            -static_cast<float>(per_row) * spacing * 0.5f
-                + static_cast<float>(i % per_row) * spacing,
-            hover_y,
-            static_cast<float>(i / per_row) * row_gap
-        };
+        Vec3 pos { -static_cast<float>(per_row) * spacing * 0.5f
+                   + static_cast<float>(i % per_row) * spacing,
+                   hover_y,
+                   static_cast<float>(i / per_row) * row_gap };
+
         Text::TokenPtr obj = Text::make_Token(tokens[i],
                                               Text::Token::depth_floor,
-                                              0.003f,
-                                              pos);
+                                              0.003f, pos);
         obj->body.hover_height = hover_y;
         _ctx.words.push_back(std::move(obj));
     }
@@ -160,7 +158,8 @@ GameState::carriedline_Update()
     const bool easing = fs.lerping && !_freelook_return_from.empty();
     double s = 1.0;
     if (easing) {
-        double t = fs.lerp_t; t = (t < 0.0) ? 0.0 : (t > 1.0 ? 1.0 : t);
+        double t = fs.lerp_t;
+        t = (t < 0.0) ? 0.0 : (t > 1.0 ? 1.0 : t);
         s = t * t * (3.0 - 2.0 * t);
     }
 
@@ -183,7 +182,7 @@ GameState::carriedline_Update()
 
 
 void
-GameState::pult_DispatchAction(PultAction act)
+GameState::pult_RunAction(PultAction act)
 {
     _level_director->record_Button(act);
 
@@ -211,11 +210,11 @@ GameState::on_Click()
         const Vec3& cam_fwd   = _ctx.camera->fwd;
 
         const double denom = cam_fwd.x*normal.x + cam_fwd.y*normal.y + cam_fwd.z*normal.z;
-        if (denom < -1e-6) { // crosshair meets the wall const double t = ((transform.position.x-cam_pos.x)*normal.x + (transform.position.y-cam_pos.y)*normal.y
+        if (denom < -1e-6) {
             const double t = ((transform.position.x-cam_pos.x)*normal.x
                            + (transform.position.y-cam_pos.y)*normal.y
                            + (transform.position.z-cam_pos.z)*normal.z) / denom;
-            if (t > 0.0) {
+            if (t > 0.0) { // crosshair points on wall
                 const Vec3 impact { cam_pos.x + cam_fwd.x*t, cam_pos.y + cam_fwd.y*t, cam_pos.z + cam_fwd.z*t };
 
                 if (_focus_role == Wall::Role::Editor) {
@@ -256,7 +255,7 @@ GameState::on_Click()
     if (result.kind == PickKind::Scenery && result.scenery_obj) {
         if (std::optional<PultAction> act =
                 _pult_sys->try_Activate(result.scenery_obj, _ctx.buttons); act)
-            pult_DispatchAction(*act);
+            pult_RunAction(*act);
     }
 }
 
@@ -268,25 +267,25 @@ GameState::on_Pick()
     if (!result.hit()) return false;
 
     if (result.kind == PickKind::WallWord && result.wall_handler && result.wall_token) {
-        Text::TokenPtr base = result.wall_handler->detach(result.wall_token);
-        if (!base) return false;
+        Text::TokenPtr picked = result.wall_handler->detach(result.wall_token);
+        if (!picked) return false;
 
-        _level_director-> record_PickedUp(base->text);
-        base->set_Look       (Config::Color::keep, Text::Token::depth_floor);
-        Wall::show_TokenInfo (_wall_info, base->text);
-        carry_BeginAnim      (std::move(base), true);
+        _level_director->record_PickedUp(picked->text);
+        picked->set_Look     (Config::Color::keep, Text::Token::depth_floor);
+        Wall::show_TokenInfo (_wall_info, picked->text);
+        carry_BeginAnim      (std::move(picked), true);
         return true;
     }
 
     if (result.kind == PickKind::Word) {
-        Text::TokenPtr word = std::move(_ctx.words[result.word_index]);
+        Text::TokenPtr picked = std::move(_ctx.words[result.word_index]);
         _ctx.words.erase(_ctx.words.begin() + static_cast<std::ptrdiff_t>(result.word_index));
-        if (!word) return false;
+        if (!picked) return false;
 
-        _level_director->record_PickedUp(word->text);
-        word->set_Look      (Config::Color::keep, Text::Token::depth_floor);
-        Wall::show_TokenInfo(_wall_info, word->text);
-        carry_BeginAnim     (std::move(word), false);
+        _level_director->record_PickedUp(picked->text);
+        picked->set_Look    (Config::Color::keep, Text::Token::depth_floor);
+        Wall::show_TokenInfo(_wall_info, picked->text);
+        carry_BeginAnim     (std::move(picked), false);
         return true;
     }
     return false;
@@ -298,16 +297,16 @@ GameState::on_DropLast()
 {
     if (_carried.empty()) return;
 
-    Text::TokenPtr word = _carried.pop_back();
-    if (!word) return;
+    Text::TokenPtr dropped = _carried.pop_back();
+    if (!dropped) return;
 
-    CarryLex::revert_ToSingle(word.get());
+    CarryLex::revert_ToSingle(dropped.get());
 
-    word->body.mode = PhysicsMode::Dynamic;
-    word->body.vel  = { _ctx.camera->fwd.x * 1.5, 0.8, _ctx.camera->fwd.z * 1.5 };
+    dropped->body.mode = PhysicsMode::Dynamic;
+    dropped->body.vel  = { _ctx.camera->fwd.x * 1.5, 0.8, _ctx.camera->fwd.z * 1.5 };
 
     WordAnim_Drop drop;
-    drop.word = std::move(word);
+    drop.word = std::move(dropped);
     _anims_drop.push_back(std::move(drop));
 
     if (!_carried.empty()) {
@@ -369,18 +368,19 @@ GameState::on_ShootAll()
     Aim::Result aim;
     if (all_words.empty())
         return;
-
     aim = Aim::crosshair_Target(*_ctx.camera, _ctx.words, _ctx.scenery,
                                  _text_walls, World::get_BoxScale());
+
     _projectiles_sys->launch(_projectiles, std::move(all_words),
                              _ctx.camera->fwd, aim);
+
     _level_director->show_Details(_ctx);
     _level_director->record_Shot ();
 }
 
 
 std::string
-GameState::editor_Source() const
+GameState::get_EditorSource() const
 {
     std::string src;
     for (const std::string& l : _wall_editor.as_Lines())
@@ -390,15 +390,16 @@ GameState::editor_Source() const
 
 
 void GameState::on_Compile() {
-    std::string src = editor_Source();
+    std::string src = get_EditorSource();
 
     if ( !_level_director->is_LevelComplete() &&
           _level_director->get_Runner().is_DynamicLib()) {
-        const std::string path = sandbox_CanonicalPath();
+        const std::string path = sandbox_GetSourcePath();
         std::string stripped;
         for (char c : src)
             if (!std::isspace((unsigned char)c))
                 { stripped = src; break; }
+
         if (!path.empty() && !stripped.empty())
             SourceTokens::write_File(path, src);
 
@@ -420,7 +421,7 @@ GameState::on_Run()
 void
 GameState::on_DebugPrint()
 {
-    std::print("TEXT::: {0}\n", editor_Source());
+    std::print("TEXT::: {0}\n", get_EditorSource());
 }
 
 void
@@ -469,6 +470,7 @@ GameState::on_NumberAdjust(int delta)
 {
     if (_carried.empty() || !_carried.last || !_carried.last->word)
         return;
+
     Text::Token::Data* word = _carried.last->word.get();
 
     const std::string& text = word->text;
@@ -516,7 +518,7 @@ GameState::on_TypingCancel(FrameInput& input)
 
 
 void
-GameState::projectile_FeedProgramInput(ProjectileResult& result)
+GameState::projectile_LandOnProgramInput(ProjectileResult& result)
 {
     std::string line;
     for (const Text::TokenPtr& word : result.words) {
@@ -797,7 +799,7 @@ GameState::update_Input(FrameInput& input, double dt)
     }
 
     _ctx.camera->sync_FromPlayer(*_ctx.player);
-    update_WallFocus(input, dt);
+    focus_UpdateWall(input, dt);
 }
 
 
@@ -824,7 +826,7 @@ GameState::update_Objects(double dt, const GlRenderer* gl)
         if (handler) handler->update(dt, *_ctx.camera);
 
     _wall_connection.update(dt, *_ctx.camera, gl->get_Aspect(), gl->get_Fov_y());
-    update_LabelFocus      (dt, *_ctx.camera, gl->get_Aspect(), gl->get_Fov_y());
+    focus_UpdateLabel      (dt, *_ctx.camera, gl->get_Aspect(), gl->get_Fov_y());
 
     DynArray<GameObject*> particle_colliders;
     particle_colliders.reserve(_ctx.scenery.size());
@@ -843,12 +845,12 @@ GameState::update_Compiler()
         _level_director->record_CompileOk();
     }
 
-    // TODO: the dyn path may still blocks the frame in dyn_Apply
+    // TODO: the dyn path may still blocks the frame in dynlib_Apply
     _dyn_loader_sys->update(_wall_compiler);
     if (_dyn_loader_sys->last_build_ok) {
         _dyn_loader_sys->last_build_ok = false;
-        dyn_Apply(_dyn_loader_sys->load_Objects());
-        SourceTokens::copy_File(sandbox_CanonicalPath(), sandbox_BackupPath());
+        dynlib_Apply(_dyn_loader_sys->load_Objects());
+        SourceTokens::copy_File(sandbox_GetSourcePath(), sandbox_BackupPath());
     }
 
     _program_sys->update(_wall_program);
@@ -1070,12 +1072,11 @@ GameState::update_Physics(double dt)
     { FP_ZONE("updateworldsim.projectile_land");
         for (ProjectileResult& result : proj_results) {
             switch (result.landing) {
-                case ProjectileLanding::Floor:    projectile_LandOnFloor     (result); break;
+                case ProjectileLanding::Floor:    projectile_LandOnFloor       (result); break;
                 case ProjectileLanding::ProgramInput:
-                                                  projectile_FeedProgramInput(result); break;
-                case ProjectileLanding::Wall:     projectile_LandOnWall      (result); break;
-                case ProjectileLanding::WallText:
-                                                  projectile_LandOnWallText  (result); break;
+                                                  projectile_LandOnProgramInput(result); break;
+                case ProjectileLanding::Wall:     projectile_LandOnWall        (result); break;
+                case ProjectileLanding::WallText: projectile_LandOnWallText    (result); break;
                 case ProjectileLanding::None:     break;
             }
         }
@@ -1083,7 +1084,7 @@ GameState::update_Physics(double dt)
         for (const ProjectileContactEvent& contact : projectile_contacts) {
             if (std::optional<PultAction> action =
                         _pult_sys->handle_ProjectileContact(contact, _ctx.buttons); action) {
-                pult_DispatchAction(*action);
+                pult_RunAction(*action);
                 continue;
             }
 
@@ -1107,7 +1108,7 @@ GameState::update_Physics(double dt)
 
         if (std::optional<PultAction> act =
                 _pult_sys->handle_PlayerContact(*_ctx.player, _ctx.buttons); act)
-            pult_DispatchAction(*act);
+            pult_RunAction(*act);
     }
 }
 
@@ -1120,7 +1121,7 @@ GameState::level_TryAdvance(double dt)
 
     if (!res.stepped) return;
 
-    dyn_Clear();
+    dynlib_Clear();
 
     if (res.reset_carry) {
         _ctx.words  .clear();
@@ -1142,7 +1143,7 @@ GameState::level_TryAdvance(double dt)
 
 
 void
-GameState::dyn_Clear()
+GameState::dynlib_Clear()
 {
     if (_dyn_scenery.empty()) { return; }
 
@@ -1150,19 +1151,19 @@ GameState::dyn_Clear()
         set(_dyn_scenery.begin(), _dyn_scenery.end());
 
     _ctx.scenery.erase( std::remove_if(_ctx.scenery.begin(), _ctx.scenery.end(),
-                           [&set](const GameObjectPtr& sp) { return set.count(sp.get()) > 0; }),
+                        [&set](const GameObjectPtr& sp) { return set.count(sp.get()) > 0; }),
                         _ctx.scenery.end() );
     _ctx.words  .erase( std::remove_if(_ctx.words.begin(), _ctx.words.end(),
-                           [&set](const Text::TokenPtr& wp) { return set.count(wp.get()) > 0; }),
+                        [&set](const Text::TokenPtr& wp) { return set.count(wp.get()) > 0; }),
                         _ctx.words.end() );
     _dyn_scenery.clear();
 }
 
 
 void
-GameState::dyn_Apply(const DynArray<DynObject>& objs)
+GameState::dynlib_Apply(const DynArray<DynObject>& objs)
 {
-    dyn_Clear();
+    dynlib_Clear();
 
     for (const DynObject& o : objs) {
         if (o.kind == DYN_BOX) {
@@ -1191,7 +1192,7 @@ GameState::dyn_Apply(const DynArray<DynObject>& objs)
 }
 
 std::string
-GameState::sandbox_CanonicalPath() const {
+GameState::sandbox_GetSourcePath() const {
     return _level_director
            ? _level_director->get_Runner().get_SourceFile()
            : std::string{};
@@ -1199,14 +1200,14 @@ GameState::sandbox_CanonicalPath() const {
 
 std::string
 GameState::sandbox_BackupPath() const {
-    std::string c = sandbox_CanonicalPath();
+    std::string c = sandbox_GetSourcePath();
     return c.empty() ? c : (c + ".last_ok");
 }
 
 void
 GameState::sandbox_LoadFileToWall()
 {
-    const std::string path = sandbox_CanonicalPath();
+    const std::string path = sandbox_GetSourcePath();
     if (path.empty()) return;
 
     std::string src;
@@ -1233,7 +1234,7 @@ void
 GameState::on_SandboxRestore() {
     if (!_level_director || !_level_director->get_Runner().is_DynamicLib())
         return;
-    if (SourceTokens::copy_File(sandbox_BackupPath(), sandbox_CanonicalPath()))
+    if (SourceTokens::copy_File(sandbox_BackupPath(), sandbox_GetSourcePath()))
         sandbox_LoadFileToWall();
 }
 
@@ -1323,7 +1324,9 @@ void
 GameState::on_WallConnectSubmit()
 {
     std::string line = _frame_input.typing_buffer;
+
     _frame_input.typing_buffer.clear();
+
     _wall_connection.clear_ProgramPreview();
 
     if (line == ":exit") { on_WallConnectExit(); return; }
@@ -1367,9 +1370,9 @@ GameState::on_EditorScroll(int8_t dt)
 
 
 Text::Handler*
-GameState::get_Handler(Wall::Role r)
+GameState::get_Handler(Wall::Role role)
 {
-    switch (r) {
+    switch (role) {
         case Wall::Role::Editor:   return &_wall_editor;
         case Wall::Role::Program:  return &_wall_program;
         case Wall::Role::Compiler: return &_wall_compiler;
@@ -1381,7 +1384,7 @@ GameState::get_Handler(Wall::Role r)
 
 
 bool
-GameState::compute_FocusTarget()
+GameState::focus_ComputeTarget()
 {
     const Camera& cam = *_ctx.camera;
     const float  ws  = World::get_BoxScale<float>();
@@ -1445,14 +1448,14 @@ GameState::compute_FocusTarget()
 
 
 void
-GameState::update_WallFocus(FrameInput& input, double dt)
+GameState::focus_UpdateWall(FrameInput& input, double dt)
 {
     const bool want = _focus_on || _focus_locked;
     constexpr double DUR = 0.25;
 
     if (want) {
         if (!_focus_active) {
-            if (!compute_FocusTarget()) return;
+            if (!focus_ComputeTarget()) return;
             _focus_active = true;
         }
         _focus_t = SDL_min(1.0, _focus_t + dt / DUR);
@@ -1515,7 +1518,7 @@ GameState::update_WallFocus(FrameInput& input, double dt)
 
 
 void
-GameState::update_LabelFocus(double dt, const Camera& cam, float aspect, float fov_y)
+GameState::focus_UpdateLabel(double dt, const Camera& cam, float aspect, float fov_y)
 {
     if (!_focus_active) { _focus_label_init = false; return; }
 
diff --git a/src/states/game_state.hpp b/src/states/game_state.hpp
index 1125764..4ea91fa 100644
--- a/src/states/game_state.hpp
+++ b/src/states/game_state.hpp
@@ -24,7 +24,7 @@
 #include "systems/wall_connection.hpp"
 #include "systems/word_ai_system.hpp"
 #include "systems/word_anim_system.hpp"
-#include "text/handler.hpp"          // Text::Handler (replaces Wall::Editor + Text::SrcView)
+#include "text/handler.hpp"
 #include "text/vim_buffer.hpp"
 #include "utils/globals.hpp"
 #include "wall/label.hpp"
@@ -87,11 +87,11 @@ class GameState : public IState
     static constexpr size_t LABEL_HIT_BASE = size_t(1) << 48;
 
     // focus wall jump START
-    Vec3   _focus_center    {};        // look-at point on the wall plane (panned by scroll)
-    Vec3   _focus_normal    {};        // inward normal of the focused wall
+    Vec3   _focus_center    {};
+    Vec3   _focus_normal    {};
     Vec3   _focus_label_pos {};
     double _focus_t       { 0.0 };
-    double _focus_dist    { 4.0 };   // camera distance from the wall plane (dolly via W/S)
+    double _focus_dist    { 4.0 };
     double _focus_yaw_r   { 0.0 };
     float  _fov_y         { 0.0f };
     float  _aspect        { 0.0f };
@@ -109,7 +109,7 @@ class GameState : public IState
     void wallconnect_BeginEditor ();
     void wallconnect_BeginProgram();
 
-    std::string editor_Source() const;
+    std::string get_EditorSource() const;
 
 
     bool on_Pick         ();
@@ -141,12 +141,12 @@ class GameState : public IState
     void typing_RebuildPreview (const std::string& s);
 
 
-    void projectile_FeedProgramInput(ProjectileResult&);
-    void projectile_LandOnFloor     (ProjectileResult&);
-    void projectile_LandOnWall      (ProjectileResult&);
-    void projectile_LandOnWallText  (ProjectileResult&);
+    void projectile_LandOnProgramInput(ProjectileResult&);
+    void projectile_LandOnFloor       (ProjectileResult&);
+    void projectile_LandOnWall        (ProjectileResult&);
+    void projectile_LandOnWallText    (ProjectileResult&);
 
-    void pult_DispatchAction(PultAction act);
+    void pult_RunAction     (PultAction act);
 
     void debug_SpawnWords   (size_t n);
 
@@ -158,17 +158,17 @@ class GameState : public IState
     void update_Progression (double dt);
 
     // dynamic-lib sandbox START
-    void dyn_Clear                   ();
-    void dyn_Apply                   (const DynArray<DynObject>& objs);
+    void dynlib_Clear                ();
+    void dynlib_Apply                (const DynArray<DynObject>& objs);
     void sandbox_LoadFileToWall      ();
-    std::string sandbox_CanonicalPath() const;
+    std::string sandbox_GetSourcePath() const;
     std::string sandbox_BackupPath   () const;
     // dynamic-lib sandbox END
 
     // focus wall jump START
-    bool compute_FocusTarget();
-    void update_WallFocus   (FrameInput& input, double dt);
-    void update_LabelFocus  (double dt, const Camera& cam, float aspect, float fov_y);
+    bool focus_ComputeTarget();
+    void focus_UpdateWall   (FrameInput& input, double dt);
+    void focus_UpdateLabel  (double dt, const Camera& cam, float aspect, float fov_y);
     // focus wall jump END
 
     Text::Handler*