Another lowercase switching frenzy, because why not.

doc/samples/btphystest.cpp

@@ -398,9 +398,9 @@ BtPhysTest::~BtPhysTest()
 
 }
 
-void BtPhysTest::TickGame(float seconds)
+void BtPhysTest::tick_game(float seconds)
 {
-    WorldEntity::TickGame(seconds);
+    WorldEntity::tick_game(seconds);
 
     if (!m_init_status)
     {
@@ -666,9 +666,9 @@ void BtPhysTest::TickGame(float seconds)
 #endif //USE_CHARACTER
 }
 
-void BtPhysTest::TickDraw(float seconds, Scene &scene)
+void BtPhysTest::tick_draw(float seconds, Scene &scene)
 {
-    WorldEntity::TickDraw(seconds, scene);
+    WorldEntity::tick_draw(seconds, scene);
 
     if (m_init_status != 2)
         return;

doc/samples/btphystest.h

@@ -46,8 +46,8 @@ public:
     std::string GetName() const { return "<BtPhysTest>"; }
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
     void InitApp();
 

doc/samples/meshviewer/meshviewer.cpp

@@ -101,7 +101,7 @@ public:
 };
 
 //EasyMeshViewerObject --------------------------------------------------------
-void EasyMeshViewerObject::TickDraw(float seconds, Scene &scene)
+void EasyMeshViewerObject::tick_draw(float seconds, Scene &scene)
 {
     switch (m_mesh.GetMeshState().ToScalar())
     {
@@ -275,9 +275,9 @@ MeshViewerLoadJob* MeshViewer::GetLoadJob(std::string const& path)
 }
 
 //-----------------------------------------------------------------------------
-void MeshViewer::TickGame(float seconds)
+void MeshViewer::tick_game(float seconds)
 {
-    super::TickGame(seconds);
+    super::tick_game(seconds);
 
     if (!m_init && Scene::IsReady()) Start();
     if (!m_init) return;
@@ -373,13 +373,13 @@ void MeshViewer::TickGame(float seconds)
 }
 
 //-----------------------------------------------------------------------------
-void MeshViewer::TickDraw(float seconds, Scene &scene)
+void MeshViewer::tick_draw(float seconds, Scene &scene)
 {
-    super::TickDraw(seconds, scene);
+    super::tick_draw(seconds, scene);
 
     //Draw viewer objects
     if (m_menu_mesh_idx >= 0 && m_menu_mesh_idx < m_objs.count())
-        m_objs[m_menu_mesh_idx]->TickDraw(seconds, scene);
+        m_objs[m_menu_mesh_idx]->tick_draw(seconds, scene);
 
     m_text->SetText("CECI EST UN TEST\n");
 

doc/samples/meshviewer/meshviewer.h

@@ -140,7 +140,7 @@ public:
     ViewerObject(std::string const& name) : m_name(name) { }
     virtual ~ViewerObject() { }
 
-    virtual void TickDraw(float seconds, Scene &scene) { }
+    virtual void tick_draw(float seconds, Scene &scene) { }
     std::string GetName() { return m_name; }
 
 protected:
@@ -162,7 +162,7 @@ public:
     }
     virtual ~EasyMeshViewerObject() { }
 
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_draw(float seconds, Scene &scene);
 
     void Init(std::string const& name, EasyMesh const& mesh)
     {
@@ -235,8 +235,8 @@ public:
     MeshViewerLoadJob* GetLoadJob(std::string const& path);
     void AddViewerObj(ViewerObject* obj) { m_objs << obj; }
 
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
     bool KeyReleased(MVKeyboardList index);
     bool KeyPressed(MVKeyboardList index);

doc/samples/nacl_phystest.cpp

@@ -78,17 +78,17 @@ Nacl_PhysTest::Nacl_PhysTest(bool editor)
     Ticker::Ref(m_light2);
 }
 
-void Nacl_PhysTest::TickGame(float seconds)
+void Nacl_PhysTest::tick_game(float seconds)
 {
-    WorldEntity::TickGame(seconds);
+    WorldEntity::tick_game(seconds);
 
     if (m_controller->IsKeyReleased(KEY_QUIT))
         Ticker::Shutdown();
 }
 
-void Nacl_PhysTest::TickDraw(float seconds, Scene &scene)
+void Nacl_PhysTest::tick_draw(float seconds, Scene &scene)
 {
-    WorldEntity::TickDraw(seconds, scene);
+    WorldEntity::tick_draw(seconds, scene);
 
     if (!m_ready)
     {

doc/samples/nacl_phystest.h

@@ -22,8 +22,8 @@ public:
     std::string GetName() const { return "<Nacl_PhysTest>"; }
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     enum

doc/samples/physicobject.h

@@ -402,14 +402,14 @@ public:
     std::string GetName() const { return "<PhysicsObject>"; }
 
 protected:
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
 #if CAT_MODE
         if (!m_is_phys || m_custom_shader)

doc/samples/physics/easycharactercontroller.cpp

@@ -132,9 +132,9 @@ std::string EasyCharacterController::GetName()
 }
 
 //Physic Tick
-void EasyCharacterController::TickGame(float seconds)
+void EasyCharacterController::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
     //Send final velocity in Bullet
     {

doc/samples/physics/easycharactercontroller.h

@@ -75,7 +75,7 @@ protected:
     virtual std::string GetName();
 
 public:
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
 
 protected:
 

doc/samples/physics/lolphysics.h

@@ -109,9 +109,9 @@ public:
         m_dynamics_world = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collision_configuration);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        Entity::TickGame(seconds);
+        Entity::tick_game(seconds);
 
         //step the simulation
         if (m_dynamics_world)

doc/tutorial/01_triangle.cpp

@@ -32,9 +32,9 @@ public:
     {
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/02_cube.cpp

@@ -62,9 +62,9 @@ public:
         Ticker::Unref(m_camera);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         m_angle += seconds * radians(45.0f);
 
@@ -95,9 +95,9 @@ public:
         }
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/03_noise.cpp

@@ -36,9 +36,9 @@ public:
     {
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         m_time += seconds;
 

doc/tutorial/04_texture.cpp

@@ -39,9 +39,9 @@ public:
         m_heightmap.resize(TEXTURE_WIDTH * 1);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         /* Generate a new heightmap at the beginning */
         if (m_frames == 0)
@@ -60,9 +60,9 @@ public:
         ++m_frames;
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         /* Initialise GPU data */
         if (!m_ready)

doc/tutorial/05_easymesh.cpp

@@ -93,9 +93,9 @@ public:
         Ticker::Unref(m_light2);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         m_angle += seconds * radians(70.0f);
         m_mat = mat4::rotate(radians(10.0f), vec3(0, 0, 1))
@@ -123,9 +123,9 @@ public:
                       * mat4::rotate(m_gears[4].m3 - 80.0f, vec3(0, 1, 0));
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/06_sprite.cpp

@@ -53,7 +53,7 @@ public:
         Ticker::Unref(m_camera);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
         for (int i = 0; i < SPRITE_COUNT; ++i)
         {
@@ -63,12 +63,12 @@ public:
                 m_sprites[i].m1.y = (float)rand(-96, -48);
         }
 
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/07_input.cpp

@@ -102,9 +102,9 @@ public:
         Ticker::Unref(m_text);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         /* Handle keyboard */
         if (m_keyboard)
@@ -156,9 +156,9 @@ public:
         m_matrix = proj * view * model * anim;
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/08_fbo.cpp

@@ -35,9 +35,9 @@ public:
     {
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         m_time += seconds;
         m_hotspot = 0.4f * vec3(
@@ -52,9 +52,9 @@ public:
         m_color /= x;
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/09_sound.cpp

@@ -62,9 +62,9 @@ public:
         }
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         for (int i = 0; i < 2; ++i)
         {
@@ -86,9 +86,9 @@ public:
         }
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
     }
 
 private:

doc/tutorial/11_fractal.cpp

@@ -166,9 +166,9 @@ public:
         return m_view.radius * m_window2world * f128cmplx(dx, dy);
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         ivec2 mousepos = m_mouse->GetCursorPixel(0);
 
@@ -447,9 +447,9 @@ public:
         }
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         static float const vertices[] =
         {

doc/tutorial/12_voronoi.cpp

@@ -73,9 +73,9 @@ public:
         m_controller->GetKey(KEY_F3).Bind("Keyboard", "F3");
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         {
             //Shutdown logic
@@ -95,9 +95,9 @@ public:
         m_color /= x;
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         if (!m_ready)
         {

doc/tutorial/13_shader_builder.cpp

@@ -30,14 +30,14 @@ public:
     {
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
 
         File file;
         file.Open("13_shader_builder_export.txt", FileAccess::Write);

doc/tutorial/14_lol_lua.cpp

@@ -172,9 +172,9 @@ public:
     {
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         LoluaDemoLoader* demo_loader = new LoluaDemoLoader();
 
@@ -215,9 +215,9 @@ public:
         Ticker::Shutdown();
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
     }
 };
 

doc/tutorial/15_lolimgui.cpp

@@ -37,9 +37,9 @@ public:
         LolImGui::Shutdown();
     }
 
-    virtual void TickGame(float seconds)
+    virtual void tick_game(float seconds)
     {
-        WorldEntity::TickGame(seconds);
+        WorldEntity::tick_game(seconds);
 
         static float f;
         static vec3 clear_color;
@@ -88,9 +88,9 @@ public:
         ImGui::End();
     }
 
-    virtual void TickDraw(float seconds, Scene &scene)
+    virtual void tick_draw(float seconds, Scene &scene)
     {
-        WorldEntity::TickDraw(seconds, scene);
+        WorldEntity::tick_draw(seconds, scene);
     }
 };
 

src/audio/sample.cpp

@@ -81,9 +81,9 @@ sample::~sample()
     delete data;
 }
 
-void sample::TickGame(float seconds)
+void sample::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 }
 
 std::string sample::GetName() const

src/camera.cpp

@@ -232,14 +232,14 @@ float Camera::GetFOVForHeightAndDistance(float distance, float height) const
     return 2.f * lol::atan(height * .5f / distance);
 }
 
-void Camera::TickGame(float seconds)
+void Camera::tick_game(float seconds)
 {
-    WorldEntity::TickGame(seconds);
+    WorldEntity::tick_game(seconds);
 }
 
-void Camera::TickDraw(float seconds, Scene &scene)
+void Camera::tick_draw(float seconds, Scene &scene)
 {
-    WorldEntity::TickDraw(seconds, scene);
+    WorldEntity::tick_draw(seconds, scene);
 }
 
 } /* namespace lol */

src/camera.h

@@ -85,8 +85,8 @@ public:
     float GetFOVForHeightAndDistance(float distance, float height) const;
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 //private:
 public:

src/debug/fps.cpp

@@ -50,9 +50,9 @@ DebugFps::DebugFps(int x, int y)
 #endif
 }
 
-void DebugFps::TickGame(float seconds)
+void DebugFps::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
     char buf[1024];
 

src/debug/fps.h

@@ -29,7 +29,7 @@ public:
     virtual ~DebugFps();
 
 protected:
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
 
 private:
     DebugFpsData *data;

src/debug/record.cpp

@@ -59,14 +59,14 @@ DebugRecord::DebugRecord(std::string const &path, float fps)
     m_drawgroup = DRAWGROUP_CAPTURE;
 }
 
-void DebugRecord::TickGame(float seconds)
+void DebugRecord::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 }
 
-void DebugRecord::TickDraw(float seconds, Scene &scene)
+void DebugRecord::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     ivec2 size = Video::GetSize();
 

src/debug/record.h

@@ -31,8 +31,8 @@ public:
     virtual ~DebugRecord();
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     DebugRecordData *m_data;

src/debug/stats.cpp

@@ -41,9 +41,9 @@ DebugStats::DebugStats(char const *path)
     m_gamegroup = GAMEGROUP_STATS;
 }
 
-void DebugStats::TickGame(float seconds)
+void DebugStats::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
     fprintf(data->fp, "%i %f %f %f %f\n",
             Ticker::GetFrameNum(),

src/debug/stats.h

@@ -29,7 +29,7 @@ public:
     virtual ~DebugStats();
 
 protected:
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
 
 private:
     DebugStatsData *data;

src/eglapp.cpp

@@ -273,7 +273,7 @@ void EglApp::ShowPointer(bool show)
 void EglApp::Tick()
 {
     /* Tick the renderer, show the frame and clamp to desired framerate. */
-    Ticker::TickDraw();
+    Ticker::tick_draw();
 #if defined LOL_USE_EGL && !defined __ANDROID__
     eglSwapBuffers(data->egl_dpy, data->egl_surf);
 #endif

src/emitter.cpp

@@ -44,7 +44,7 @@ Emitter::Emitter(TileSet *tileset, vec3 gravity)
     data->nparticles = 0;
 }
 
-void Emitter::TickGame(float seconds)
+void Emitter::tick_game(float seconds)
 {
     for (int i = 0; i < data->nparticles; i++)
     {
@@ -61,12 +61,12 @@ void Emitter::TickGame(float seconds)
         }
     }
 
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 }
 
-void Emitter::TickDraw(float seconds, Scene &scene)
+void Emitter::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     for (int i = 0; i < data->nparticles; i++)
         scene.AddTile(data->tileset, data->particles[i],

src/emitter.h

@@ -32,8 +32,8 @@ public:
     void AddParticle(int id, vec3 pos, vec3 vel);
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     EmitterData *data;

src/engine/entity.cpp

@@ -57,7 +57,7 @@ void Entity::InitDraw()
 {
 }
 
-void Entity::TickGame(float seconds)
+void Entity::tick_game(float seconds)
 {
     UNUSED(seconds);
 #if !LOL_BUILD_RELEASE
@@ -67,7 +67,7 @@ void Entity::TickGame(float seconds)
 #endif
 }
 
-void Entity::TickDraw(float seconds, Scene &scene)
+void Entity::tick_draw(float seconds, Scene &scene)
 {
     UNUSED(seconds, scene);
 #if !LOL_BUILD_RELEASE

src/engine/entity.h

@@ -62,8 +62,8 @@ protected:
     virtual void InitGame();
     virtual void InitDraw();
 
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, class Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, class Scene &scene);
 
     enum
     {

src/engine/ticker.cpp

@@ -404,7 +404,7 @@ void TickerData::GameThreadTick()
                                e->GetName().c_str(), e);
                 e->m_tickstate = Entity::STATE_PRETICK_GAME;
 #endif
-                e->TickGame(data->deltatime);
+                e->tick_game(data->deltatime);
 #if !LOL_BUILD_RELEASE
                 if (e->m_tickstate != Entity::STATE_POSTTICK_GAME)
                     msg::error("entity %s [%p] missed super game tick\n",
@@ -458,7 +458,7 @@ void TickerData::DrawThreadTick()
                                    e->GetName().c_str(), e);
                     e->m_tickstate = Entity::STATE_PRETICK_DRAW;
 #endif
-                    e->TickDraw(data->deltatime, scene);
+                    e->tick_draw(data->deltatime, scene);
 #if !LOL_BUILD_RELEASE
                     if (e->m_tickstate != Entity::STATE_POSTTICK_DRAW)
                         msg::error("entity %s [%p] missed super draw tick\n",
@@ -510,7 +510,7 @@ void Ticker::Setup(float fps)
 #endif
 }
 
-void Ticker::TickDraw()
+void Ticker::tick_draw()
 {
 #if LOL_FEATURE_THREADS
     data->drawtick.pop();

src/engine/ticker.h

@@ -31,7 +31,7 @@ public:
     static int Unref(Entity *entity);
 
     static void Setup(float fps);
-    static void TickDraw();
+    static void tick_draw();
     static void StartBenchmark();
     static void StopBenchmark();
     static void StartRecording();

src/engine/worldentity.cpp

@@ -39,14 +39,14 @@ std::string WorldEntity::GetName() const
     return "<worldentity>";
 }
 
-void WorldEntity::TickGame(float seconds)
+void WorldEntity::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 }
 
-void WorldEntity::TickDraw(float seconds, Scene &scene)
+void WorldEntity::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 }
 
 } /* namespace lol */

src/engine/worldentity.h

@@ -40,8 +40,8 @@ protected:
     WorldEntity();
     virtual ~WorldEntity();
 
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 };
 
 } /* namespace lol */

src/font.cpp

@@ -54,9 +54,9 @@ Font::~Font()
     delete data;
 }
 
-void Font::TickDraw(float seconds, Scene &scene)
+void Font::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     if (data->tileset->GetTexture())
     {

src/font.h

@@ -33,7 +33,7 @@ public:
 protected:
     /* Inherited from Entity */
     virtual std::string GetName() const;
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 public:
     /* New methods */

src/gradient.cpp

@@ -44,14 +44,14 @@ Gradient::Gradient(vec3 aa, vec3 bb)
     data->shader = nullptr;
 }
 
-void Gradient::TickGame(float seconds)
+void Gradient::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 }
 
-void Gradient::TickDraw(float seconds, Scene &scene)
+void Gradient::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     float const vertex[] = { m_aabb.aa.x, m_aabb.aa.y, 0.0f,
                              m_aabb.bb.x, m_aabb.aa.y, 0.0f,

src/gradient.h

@@ -33,8 +33,8 @@ public:
     std::string GetName() const { return "<gradient>"; }
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     GradientData *data;

src/input/controller.cpp

@@ -449,9 +449,9 @@ void Controller::BindProfile(InputProfile const& setup)
 }
 
 //-----------------------------------------------------------------------------
-void Controller::TickGame(float seconds)
+void Controller::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
     if (m_active)
     {

src/input/controller.h

@@ -373,7 +373,7 @@ public:
     Controller(std::string const &name, InputProfile const& setup);
     virtual ~Controller();
 
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
 
     /** Activate the controller on next frame */
     void Activate();

src/light.cpp

@@ -60,14 +60,14 @@ vec4 Light::GetColor()
     return m_color;
 }
 
-void Light::TickGame(float seconds)
+void Light::tick_game(float seconds)
 {
-    WorldEntity::TickGame(seconds);
+    WorldEntity::tick_game(seconds);
 }
 
-void Light::TickDraw(float seconds, Scene &scene)
+void Light::tick_draw(float seconds, Scene &scene)
 {
-    WorldEntity::TickDraw(seconds, scene);
+    WorldEntity::tick_draw(seconds, scene);
 
     scene.AddLight(this);
 }

src/light.h

@@ -91,8 +91,8 @@ public:
     vec3 GetPosition();
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     vec4        m_color;

src/lol/audio/sample.h

@@ -36,7 +36,7 @@ public:
 protected:
     /* Inherited from Entity */
     virtual std::string GetName() const;
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
 
 public:
     /* New methods */

src/lol/sys/threadtypes.h

@@ -132,7 +132,7 @@ protected:
     //Base thread work function
     void BaseThreadWork(thread* inst);
 
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
     //Default behaviour : delete the job result
     virtual void TreatResult(ThreadJob* result) { delete(result); }
 
@@ -236,7 +236,7 @@ public:
     void UnregisterFile(FileUpdateTester::Status*& status);
     //TODO: Add directories
     //FileUpdateTester::Status* RegisterDirectory(std::string const& path, bool check_files=false);
-    virtual void TickGame(float seconds);
+    virtual void tick_game(float seconds);
     virtual void TreatResult(ThreadJob* result);
 
 private:

src/lolimgui.cpp

@@ -181,9 +181,9 @@ const char* LolImGui::GetClipboardCallback(void *data)
 }
 
 //-----------------------------------------------------------------------------
-void LolImGui::TickGame(float seconds)
+void LolImGui::tick_game(float seconds)
 {
-    super::TickGame(seconds);
+    super::tick_game(seconds);
 
     ImGuiIO& io = ImGui::GetIO();
 
@@ -281,9 +281,9 @@ void LolImGui::TickGame(float seconds)
 }
 
 //-----------------------------------------------------------------------------
-void LolImGui::TickDraw(float seconds, Scene &scene)
+void LolImGui::tick_draw(float seconds, Scene &scene)
 {
-    super::TickDraw(seconds, scene);
+    super::tick_draw(seconds, scene);
 
     scene.AddPrimitiveRenderer(this, new PrimitiveLolImGui());
 }

src/lolimgui.h

@@ -161,8 +161,8 @@ public:
     static std::string GetClipboard();
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
     static void SetClipboardCallback(void *data, const char* text);
     static const char* GetClipboardCallback(void *data);

src/platform/android/androidapp.cpp

@@ -163,7 +163,7 @@ void lol::AndroidAppData::DrawFrame()
     if (!m_display)
         return;
 
-    Ticker::TickDraw();
+    Ticker::tick_draw();
 
     eglSwapBuffers(m_display, m_surface);
 }

src/platform/d3d9/d3d9input.cpp

@@ -99,9 +99,9 @@ D3d9Input::~D3d9Input()
     delete m_data;
 }
 
-void D3d9Input::TickGame(float seconds)
+void D3d9Input::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
 #if defined LOL_USE_XINPUT
     for (int i = 0; i < m_data->m_joysticks.count(); i++)
@@ -131,9 +131,9 @@ void D3d9Input::TickGame(float seconds)
 #endif
 }
 
-void D3d9Input::TickDraw(float seconds, Scene &scene)
+void D3d9Input::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 }
 
 } /* namespace lol */

src/platform/d3d9/d3d9input.h

@@ -29,8 +29,8 @@ public:
     virtual ~D3d9Input();
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     D3d9InputData *m_data;

src/platform/nacl/nacl-instance.cpp

@@ -159,7 +159,7 @@ void NaClInstance::DrawSelf()
         return;
 
     m_opengl_ctx->MakeContextCurrent(this);
-    Ticker::TickDraw();
+    Ticker::tick_draw();
     m_opengl_ctx->FlushContext();
 }
 

src/platform/sdl/sdlapp.cpp

@@ -216,7 +216,7 @@ void SdlApp::ShowPointer(bool show)
 void SdlApp::Tick()
 {
     /* Tick the renderer, show the frame and clamp to desired framerate. */
-    Ticker::TickDraw();
+    Ticker::tick_draw();
 }
 
 SdlApp::~SdlApp()

src/platform/sdl/sdlinput.cpp

@@ -202,17 +202,17 @@ SdlInput::~SdlInput()
     delete m_data;
 }
 
-void SdlInput::TickGame(float seconds)
+void SdlInput::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
     if (!m_data->m_tick_in_draw_thread)
         m_data->Tick(seconds);
 }
 
-void SdlInput::TickDraw(float seconds, Scene &scene)
+void SdlInput::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     if (m_data->m_tick_in_draw_thread)
         m_data->Tick(seconds);

src/platform/sdl/sdlinput.h

@@ -32,8 +32,8 @@ public:
     void SetScreenResolution();
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     SdlInputData *m_data;

src/sprite.cpp

@@ -37,14 +37,14 @@ Sprite::Sprite(TileSet *tileset, int id)
     data->id = id;
 }
 
-void Sprite::TickGame(float seconds)
+void Sprite::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 }
 
-void Sprite::TickDraw(float seconds, Scene &scene)
+void Sprite::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     scene.AddTile(data->tileset, data->id, m_position, vec2(1.0f), 0.0f);
 }

src/sprite.h

@@ -30,8 +30,8 @@ public:
     virtual ~Sprite();
 
 protected:
-    virtual void TickGame(float seconds);
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_game(float seconds);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     SpriteData *data;

src/sys/thread.cpp

@@ -238,9 +238,9 @@ void BaseThreadManager::BaseThreadWork(thread* inst)
 }
 
 //-----------------------------------------------------------------------------
-void BaseThreadManager::TickGame(float seconds)
+void BaseThreadManager::tick_game(float seconds)
 {
-    Entity::TickGame(seconds);
+    Entity::tick_game(seconds);
 
     //Start if needed
     Start();

src/sys/threadtypes.cpp

@@ -125,13 +125,13 @@ void FileUpdateTester::UnregisterFile(FileUpdateTester::Status*& status)
 }
 
 //-----------------------------------------------------------------------------
-void FileUpdateTester::TickGame(float seconds)
+void FileUpdateTester::tick_game(float seconds)
 {
     // Reset update for this frame
     for (auto &kv : m_files)
         kv.second->SetUpdated(false);
 
-    super::TickGame(seconds);
+    super::tick_game(seconds);
 
     if (!GetDispatchCount() && m_job_done.count())
     {

src/t/sys/thread.cpp

@@ -98,7 +98,7 @@ lolunit_declare_fixture(thread_test)
             return results.count() > 0;
         }
 
-        virtual void TickGame(float seconds)
+        virtual void tick_game(float seconds)
         {
             switch (m_status.ToScalar())
             {
@@ -134,7 +134,7 @@ lolunit_declare_fixture(thread_test)
 #if !LOL_BUILD_RELEASE
             m_tickstate = STATE_PRETICK_GAME;
 #endif
-            super::TickGame(seconds);
+            super::tick_game(seconds);
         }
         bool IsDone() { return m_status == UnitTestStatus::DONE; }
         int Test_GetDispatchCount() { return GetDispatchCount(); }
@@ -170,7 +170,7 @@ lolunit_declare_fixture(thread_test)
         bool dispatch_check = true;
         while (!m_manager.IsDone())
         {
-            m_manager.TickGame(1.f / 60.f);
+            m_manager.tick_game(1.f / 60.f);
             if (dispatch_check)
             {
                 lolunit_assert_equal(0, m_manager.Test_GetDispatchCount());

src/text.cpp

@@ -94,9 +94,9 @@ ivec2 Text::GetFontSize()
     return font->GetSize();
 }
 
-void Text::TickDraw(float seconds, Scene &scene)
+void Text::tick_draw(float seconds, Scene &scene)
 {
-    Entity::TickDraw(seconds, scene);
+    Entity::tick_draw(seconds, scene);
 
     if (auto length = data->m_text.length())
     {

src/text.h

@@ -59,7 +59,7 @@ public:
     ivec2 GetFontSize();
 
 protected:
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 private:
     TextData *data;

src/textureimage.cpp

@@ -87,9 +87,9 @@ void TextureImage::Init(std::string const &path, image* img)
     m_drawgroup = DRAWGROUP_TEXTURE;
 }
 
-void TextureImage::TickDraw(float seconds, Scene &scene)
+void TextureImage::tick_draw(float seconds, Scene &scene)
 {
-    super::TickDraw(seconds, scene);
+    super::tick_draw(seconds, scene);
 
     if (IsDestroying())
     {

src/textureimage.h

@@ -50,7 +50,7 @@ protected:
     virtual void Init(std::string const &path, image* img);
 
 protected:
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void tick_draw(float seconds, Scene &scene);
 
 public:
     /* Inherited from Entity */