-

Author: codenamecpp

src/Box2D/Box2D.vcxproj

@@ -185,7 +185,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;_HAS_ITERATOR_DEBUGGING=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\third_party\Box2D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PrecompiledHeaderFile />

src/Carnage3D.vcxproj

@@ -89,7 +89,7 @@
       <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_HAS_ITERATOR_DEBUGGING=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>$(SDKDIR)\glew\include;$(SDKDIR)\GLM\include;$(SolutionDir)..\third_party\Box2D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>

src/GameCheatsWindow.cpp

@@ -5,6 +5,7 @@
 #include "PhysicsManager.h"
 #include "CarnageGame.h"
 #include "Pedestrian.h"
+#include "TimeManager.h"
 
 namespace ImGui
 {
@@ -71,9 +72,11 @@ void GameCheatsWindow::DoUI(ImGuiIO& imguiContext)
         }
         ImGui::EndMenuBar();
     }
-
+
+    ImGui::HorzSpacing();
     ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.0f, 1.0f), "Frame Time: %.3f ms (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
-    ImGui::Text("Block chunks drawn: %d", gRenderManager.mMapRenderer.mRenderStats.mBlockChunksDrawnCount);
+    ImGui::Text("Map chunks drawn: %d", gRenderManager.mMapRenderer.mRenderStats.mBlockChunksDrawnCount);
+    ImGui::Text("Sprites drawn: %d", gRenderManager.mMapRenderer.mRenderStats.mSpritesDrawnCount);
 
     // pedestrian stats
     if (Pedestrian* pedestrian = gCarnageGame.mHumanSlot[0].mCharPedestrian)
@@ -109,40 +112,44 @@ void GameCheatsWindow::DoUI(ImGuiIO& imguiContext)
         }
     }
 
-    const char* modeStrings[] = { "Follow", "Free Look" };
-    CameraController* modeControllers[] =
-    {
-        &gCarnageGame.mHumanSlot[0].mCharView.mFollowCameraController, 
-        &gCarnageGame.mHumanSlot[0].mCharView.mFreeLookCameraController,
-    }; 
-    int currentCameraMode = 0;
-    for (int i = 0; i < IM_ARRAYSIZE(modeControllers); ++i)
-    {
-        if (gCarnageGame.mHumanSlot[0].mCharView.mCameraController == modeControllers[i])
+    { // choose camera modes
+        const char* modeStrings[] = { "Follow", "Free Look" };
+        CameraController* modeControllers[] =
         {
-            currentCameraMode = i;
-            break;
-        }
-    }
-    const char* item_current = modeStrings[currentCameraMode];
-    if (ImGui::BeginCombo("Camera mode", item_current))
-    {
-        for (int n = 0; n < IM_ARRAYSIZE(modeStrings); n++)
+            &gCarnageGame.mHumanSlot[0].mCharView.mFollowCameraController, 
+            &gCarnageGame.mHumanSlot[0].mCharView.mFreeLookCameraController,
+        }; 
+        int currentCameraMode = 0;
+        for (int i = 0; i < IM_ARRAYSIZE(modeControllers); ++i)
         {
-            bool is_selected = (item_current == modeStrings[n]);
-            if (ImGui::Selectable(modeStrings[n], is_selected))
+            if (gCarnageGame.mHumanSlot[0].mCharView.mCameraController == modeControllers[i])
             {
-                item_current = modeStrings[n];
-                gCarnageGame.mHumanSlot[0].mCharView.SetCameraController(modeControllers[n]);
+                currentCameraMode = i;
+                break;
             }
-            if (is_selected)
+        }
+        const char* item_current = modeStrings[currentCameraMode];
+        if (ImGui::BeginCombo("Camera mode", item_current))
+        {
+            for (int n = 0; n < IM_ARRAYSIZE(modeStrings); n++)
             {
-                ImGui::SetItemDefaultFocus();
+                bool is_selected = (currentCameraMode == n);
+                if (ImGui::Selectable(modeStrings[n], is_selected))
+                {
+                    currentCameraMode = n;
+                    gCarnageGame.mHumanSlot[0].mCharView.SetCameraController(modeControllers[n]);
+                }
+                if (is_selected)
+                {
+                    ImGui::SetItemDefaultFocus();
+                }
             }
-        }
-        ImGui::EndCombo();
+            ImGui::EndCombo();
+        }
     }
 
+    ImGui::HorzSpacing();
+
     //if (ImGui::CollapsingHeader("Physics"))
     //{
     //    ImGui::Checkbox("Enable map collisions", &mEnableMapCollisions);
@@ -153,7 +160,6 @@ void GameCheatsWindow::DoUI(ImGuiIO& imguiContext)
     {
         ImGui::Checkbox("Enable blocks animation", &mEnableBlocksAnimation);
         ImGui::Checkbox("Enable debug draw", &mEnableDebugDraw);
-
         ImGui::Checkbox("Draw decorations", &mEnableDrawDecorations);
         ImGui::Checkbox("Draw obstacles", &mEnableDrawObstacles);
         ImGui::Checkbox("Draw pedestrians", &mEnableDrawPedestrians);
@@ -215,6 +221,31 @@ void GameCheatsWindow::DoUI(ImGuiIO& imguiContext)
             gGraphicsDevice.EnableFullscreen(gSystem.mConfig.mFullscreen);
             gGraphicsDevice.EnableVSync(gSystem.mConfig.mEnableVSync); // set vsync param as fullcreen mode changes
         }
+
+        ImGui::HorzSpacing();
+
+        { // choose desired framerate
+            static const char* framerates_str[] = {"24", "30", "60", "120", "240"};
+            static int framerates[] = {24, 30, 60, 120, 240};
+            static int framerate_index = 3;
+            if (ImGui::BeginCombo("Framerate", framerates_str[framerate_index]))
+            {
+                for (int n = 0; n < IM_ARRAYSIZE(framerates_str); ++n)
+                {
+                    bool is_selected = (n == framerate_index);
+                    if (ImGui::Selectable(framerates_str[n], is_selected))
+                    {
+                        framerate_index = n;
+                        gTimeManager.SetMaxFramerate(framerates[framerate_index] * 1.0f);
+                    }
+                    if (is_selected)
+                    {
+                        ImGui::SetItemDefaultFocus();
+                    }
+                }
+                ImGui::EndCombo();
+            }
+        }
     }
 
     ImGui::End();

src/GameObject.h

@@ -78,7 +78,10 @@ class GameObject: public cxx::noncopyable
     // drawing spricific data
     Sprite2D mDrawSprite;
 
+
 private:
     // marked object will be destroyed next game frame
     bool mMarkedForDeletion = false;
+
+    unsigned int mLastRenderFrame = 0; // render frames counter
 };

src/MapRenderer.cpp

@@ -17,6 +17,9 @@
 void MapRenderStats::FrameBegin()
 {
     mBlockChunksDrawnCount = 0;
+    mSpritesDrawnCount = 0;
+
+    ++mRenderFramesCounter;
 }
 
 void MapRenderStats::FrameEnd()
@@ -120,7 +123,23 @@ void MapRenderer::DrawGameObject(RenderView* renderview, GameObject* gameObject)
     if (!dbgSkipDraw)
     {
         gameObject->PreDrawFrame();
-        mSpriteBatch.DrawSprite(gameObject->mDrawSprite);
+
+        // detect if gameobject is visible on screen
+        static glm::vec2 points[2];
+        gameObject->mDrawSprite.GetMaxRectPoints(points);
+
+        static cxx::aabbox_t bounds;
+        bounds.clear();
+        bounds.extend(points[0].x, 1.0f, points[0].y);
+        bounds.extend(points[1].x, 1.0f, points[1].y);
+
+        if (renderview->mCamera.mFrustum.contains(bounds))
+        {
+            mSpriteBatch.DrawSprite(gameObject->mDrawSprite);
+            ++mRenderStats.mSpritesDrawnCount;
+
+            gameObject->mLastRenderFrame = mRenderStats.mRenderFramesCounter;
+        }
     }
 
     if (!gameObject->HasAttachedObjects())
@@ -140,9 +159,13 @@ void MapRenderer::DrawGameObject(RenderView* renderview, GameObject* gameObject)
 void MapRenderer::RenderDebug(RenderView* renderview, DebugRenderer& debugRender)
 {
     debug_assert(renderview);
-    for (GameObject* currGameObject: gGameObjectsManager.mAllObjectsList)
+    for (GameObject* gameObject: gGameObjectsManager.mAllObjectsList)
     {
-        currGameObject->DrawDebug(debugRender);
+        // check if gameobject was on screen in current frame
+        if (gameObject->mLastRenderFrame != mRenderStats.mRenderFramesCounter)
+            continue;
+
+        gameObject->DrawDebug(debugRender);
     }
 }
 

src/MapRenderer.h

@@ -15,7 +15,11 @@ struct MapRenderStats
     void FrameEnd();
 
 public:
-    int mBlockChunksDrawnCount = 0; // per frame
+    unsigned int mRenderFramesCounter = 0; // gets incremented on every frame
+
+    // per frame
+    int mBlockChunksDrawnCount = 0; 
+    int mSpritesDrawnCount = 0;
 };
 
 // renders map mesh, peds, cars and map objects

src/PhysicsManager.cpp

@@ -68,12 +68,7 @@ bool PhysicsManager::InitPhysicsWorld()
     mPhysicsWorld = new b2World(gravity);
     mPhysicsWorld->SetContactListener(this);
 
-    double physicsFramerate = gSystem.mConfig.mPhysicsFramerate;
-    debug_assert(physicsFramerate > 0.0);
-
-    mSimulationStepTime = (float) (1.0 / physicsFramerate);
-    debug_assert(mSimulationStepTime > 0.0);
-
+    mSimulationStepTime = 1.0f / std::max(gSystem.mConfig.mPhysicsFramerate, 1.0f);
     mGravityForce = Convert::MapUnitsToMeters(0.5f);
 
     CreateMapCollisionShape();
@@ -94,62 +89,51 @@ void PhysicsManager::UpdateFrame()
 {
     mSimulationTimeAccumulator += gTimeManager.mGameFrameDelta;
 
-    const int MaxSimulationStepsPerFrame = 5;
-    int numSimulations = static_cast<int>(mSimulationTimeAccumulator / mSimulationStepTime);
-    if (numSimulations > 0)
+    while (mSimulationTimeAccumulator >= mSimulationStepTime)
     {
-        mSimulationTimeAccumulator -= (numSimulations * mSimulationStepTime);
-        numSimulations = glm::min(numSimulations, MaxSimulationStepsPerFrame);
+        ProcessSimulationStep();
+        mSimulationTimeAccumulator -= mSimulationStepTime;
     }
-    debug_assert(numSimulations <= MaxSimulationStepsPerFrame);
-    debug_assert(mSimulationTimeAccumulator < mSimulationStepTime && mSimulationTimeAccumulator > -0.01f);
 
-    for (int icurrStep = 0; icurrStep < numSimulations; ++icurrStep)
+    if (mSimulationTimeAccumulator > 0.0f)
     {
-        ProcessSimulationStep(icurrStep == (numSimulations - 1));
+        ProcessSimulationStep();
+        mSimulationTimeAccumulator = 0.0;
     }
 
     ProcessInterpolation();
 }
 
-void PhysicsManager::ProcessSimulationStep(bool resetPreviousState)
+void PhysicsManager::ProcessSimulationStep()
 {
-    const int velocityIterations = 4;
-    const int positionIterations = 4;
+    const int velocityIterations = 6;
+    const int positionIterations = 2;
 
-    if (resetPreviousState)
+    // get previous position
+    for (PhysicsBody* currComponent: mCarsBodiesList)
     {
-        for (PhysicsBody* currComponent: mCarsBodiesList)
-        {
-            currComponent->mPreviousPosition = currComponent->mSmoothPosition = currComponent->GetPosition();
-        }
-
-        for (PhysicsBody* currComponent: mPedsBodiesList)
-        {
-            currComponent->mPreviousPosition = currComponent->mSmoothPosition = currComponent->GetPosition();
-        }
-
-        for (PhysicsBody* currComponent: mProjectileBodiesList)
-        {
-            currComponent->mPreviousPosition = currComponent->mSmoothPosition = currComponent->GetPosition();
-        }
+        currComponent->mPreviousPosition = currComponent->mSmoothPosition = currComponent->GetPosition();
+    }
+    for (PhysicsBody* currComponent: mPedsBodiesList)
+    {
+        currComponent->mPreviousPosition = currComponent->mSmoothPosition = currComponent->GetPosition();
+    }
+    for (PhysicsBody* currComponent: mProjectileBodiesList)
+    {
+        currComponent->mPreviousPosition = currComponent->mSmoothPosition = currComponent->GetPosition();
     }
 
     mPhysicsWorld->Step(mSimulationStepTime, velocityIterations, positionIterations);
 
-    // process cars physics components
+    // process physics components
     for (PhysicsBody* currComponent: mCarsBodiesList)
     {
         currComponent->SimulationStep();
     }
-
-    // process peds physics components
     for (PhysicsBody* currComponent: mPedsBodiesList)
     {
         currComponent->SimulationStep();
     }
-
-    // process projectiles
     for (PhysicsBody* currComponent: mProjectileBodiesList)
     {
         currComponent->SimulationStep();

src/PhysicsManager.h

@@ -56,7 +56,7 @@ class PhysicsManager final: private b2ContactListener
     // apply gravity forces and correct y coord for objects
     void FixedStepGravity();
 
-    void ProcessSimulationStep(bool resetPreviousState);
+    void ProcessSimulationStep();
     void ProcessInterpolation();
 
     // override b2ContactFilter

src/Sprite2D.cpp

@@ -20,17 +20,19 @@ void Sprite2D::SetNull()
 
 void Sprite2D::GetCorners(glm::vec2 positions[4]) const
 {
+    float rectw = mTextureRegion.mRectangle.w * mScale;
+    float recth = mTextureRegion.mRectangle.h * mScale;
+
     positions[0] = mOrigin;
 
-    positions[1].x = mOrigin.x + (mTextureRegion.mRectangle.w * mScale);
+    positions[1].x = mOrigin.x + rectw;
     positions[1].y = mOrigin.y;
 
     positions[2].x = mOrigin.x;
-    positions[2].y = mOrigin.y + (mTextureRegion.mRectangle.h * mScale);
-
-    positions[3].x = mOrigin.x + (mTextureRegion.mRectangle.w * mScale);
-    positions[3].y = mOrigin.y + (mTextureRegion.mRectangle.h * mScale);
+    positions[2].y = mOrigin.y + recth;
 
+    positions[3].x = positions[1].x;
+    positions[3].y = positions[2].y;
 
     if (mRotateAngle.non_zero()) // has rotation
     {
@@ -48,3 +50,14 @@ void Sprite2D::GetCorners(glm::vec2 positions[4]) const
         } 
     }
 }
+
+void Sprite2D::GetMaxRectPoints(glm::vec2 positions[2]) const
+{
+    float rectw = (mTextureRegion.mRectangle.w * mScale);
+    float recth = (mTextureRegion.mRectangle.h * mScale);
+    float maxside = std::max(rectw, recth);
+
+    positions[0] = mOrigin + mPosition;
+    positions[1].x = positions[0].x + maxside;
+    positions[1].y = positions[0].y + maxside;
+}

src/Sprite2D.h

@@ -16,8 +16,9 @@ struct Sprite2D
     }
 
     // compute corners of the sprite
-    // @param points: Output points
-    void GetCorners(glm::vec2 points[4]) const;
+    // @param positions: Output points
+    void GetCorners(glm::vec2 positions[4]) const;
+    void GetMaxRectPoints(glm::vec2 positions[2]) const;
 
     // clear sprite data
     void SetNull();