minor refactore, fix framerate limit on windows

codenamecpp · codenamecpp · commit 1068b0b1a51c · 2020-08-12T13:15:39.000+03:00
diff --git a/src/Carnage3D.vcxproj b/src/Carnage3D.vcxproj
@@ -96,7 +96,7 @@
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SDKDIR)/glew/lib/x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opengl32.lib;glew32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opengl32.lib;glew32.lib;winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
       <Command>copy "$(SDKDIR)\glew\lib\x86\glew32.dll" "$(TargetDir)"</Command>
@@ -130,7 +130,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SDKDIR)/glew/lib/x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opengl32.lib;glew32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opengl32.lib;glew32.lib;winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
       <Command>copy "$(SDKDIR)\glew\lib\x86\glew32.dll" "$(TargetDir)"</Command>
diff --git a/src/CarnageGame.cpp b/src/CarnageGame.cpp
@@ -325,7 +325,7 @@ void CarnageGame::SetupScreenLayout(int playersCount)
     // todo: what a mess
     const int MaxCols = 2;
 
-    Rectangle fullViewport = gGraphicsDevice.mViewportRect;
+    Rect fullViewport = gGraphicsDevice.mViewportRect;
 
     int numRows = (playersCount + MaxCols - 1) / MaxCols;
     debug_assert(numRows > 0);
diff --git a/src/CommonTypes.h b/src/CommonTypes.h
@@ -97,11 +97,11 @@ extern const Color32 Color32_NULL;
 using Point = glm::ivec2;
 
 // defines rectangle in 2d space
-struct Rectangle
+struct Rect
 {
 public:
-    Rectangle() = default;
-    Rectangle(int posx, int posy, int sizex, int sizey)
+    Rect() = default;
+    Rect(int posx, int posy, int sizex, int sizey)
         : x(posx)
         , y(posy)
         , w(sizex)
@@ -130,9 +130,9 @@ struct Rectangle
             point.y < (y + h - 1);
     }
     // get union area of two rectangles
-    inline Rectangle GetUnion(const Rectangle& rc) const
+    inline Rect GetUnion(const Rect& rc) const
     {
-        Rectangle rcOutput;
+        Rect rcOutput;
 
         int maxx = glm::max(x + w, rc.x + rc.w);
         int maxy = glm::max(y + h, rc.y + rc.h);
@@ -145,9 +145,9 @@ struct Rectangle
         return rcOutput;
     }
     // get intersection area of two rectangles
-    inline Rectangle GetIntersection(const Rectangle& rc) const
+    inline Rect GetIntersection(const Rect& rc) const
     {        
-        Rectangle rcOutput;
+        Rect rcOutput;
 
         int minx = glm::min(x + w, rc.x + rc.w);
         int miny = glm::min(y + h, rc.y + rc.h);
@@ -164,12 +164,12 @@ struct Rectangle
     int w, h;
 };
 
-inline bool operator == (const Rectangle& lhs, const Rectangle& rhs) 
+inline bool operator == (const Rect& lhs, const Rect& rhs) 
 { 
     return (lhs.x == rhs.x) && (lhs.y == rhs.y) && (lhs.w == rhs.w) && (lhs.h == rhs.h);
 }
 
-inline bool operator != (const Rectangle& lhs, const Rectangle& rhs)
+inline bool operator != (const Rect& lhs, const Rect& rhs)
 {
     return (lhs.x != rhs.x) || (lhs.y != rhs.y) || (lhs.w != rhs.w) || (lhs.h != rhs.h);
 }
diff --git a/src/GameCamera.h b/src/GameCamera.h
@@ -20,7 +20,7 @@ class GameCamera final
 
     eSceneCameraMode mCurrentMode;
 
-    Rectangle mViewportRect;
+    Rect mViewportRect;
 
 public:
     GameCamera();
@@ -103,7 +103,7 @@ class GameCamera2D final
 public:
     // public for convenience, should not be modified directly
     glm::mat4 mProjectionMatrix;
-    Rectangle mViewportRect;
+    Rect mViewportRect;
 
 public:
     GameCamera2D();
diff --git a/src/GameDefs.h b/src/GameDefs.h
@@ -297,13 +297,13 @@ struct TextureRegion
     {
         SetRegion(textureSize);
     }
-    TextureRegion(const Rectangle& srcRectangle, const Point& textureSize)
+    TextureRegion(const Rect& srcRectangle, const Point& textureSize)
     {
         SetRegion(srcRectangle, textureSize);
     }
 
     // init texture region to partial area
-    inline void SetRegion(const Rectangle& srcRectangle, const Point& textureSize)
+    inline void SetRegion(const Rect& srcRectangle, const Point& textureSize)
     {
         debug_assert(textureSize.x > 0);
         debug_assert(textureSize.y > 0);
@@ -334,7 +334,7 @@ struct TextureRegion
         mRectangle.SetNull();
     }
 public:
-    Rectangle mRectangle;
+    Rect mRectangle;
 
     float mU0, mV0; // texture coords
     float mU1, mV1; // texture coords
diff --git a/src/GameMapHelpers.cpp b/src/GameMapHelpers.cpp
@@ -3,7 +3,7 @@
 #include "SpriteManager.h"
 #include "GameMapManager.h"
 
-bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rectangle& area, int layerIndex, MapMeshData& meshData)
+bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rect& area, int layerIndex, MapMeshData& meshData)
 {
     debug_assert(layerIndex > -1 && layerIndex < MAP_LAYERS_COUNT);
 
@@ -30,7 +30,7 @@ bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rectangle& ar
     return true;
 }
 
-bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rectangle& area, MapMeshData& meshData)
+bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rect& area, MapMeshData& meshData)
 {
     // preallocate
     meshData.mBlocksIndices.reserve(4 * 1024 * 1024);
diff --git a/src/GameMapHelpers.h b/src/GameMapHelpers.h
@@ -11,8 +11,8 @@ class GameMapHelpers final
     // @param area: Target map rect
     // @param layerIndex: Target map layer, see MAP_LAYERS_COUNT
     // @param meshData: Output mesh data
-    static bool BuildMapMesh(GameMapManager& city, const Rectangle& area, int layerIndex, MapMeshData& meshData);
-    static bool BuildMapMesh(GameMapManager& city, const Rectangle& area, MapMeshData& meshData);
+    static bool BuildMapMesh(GameMapManager& city, const Rect& area, int layerIndex, MapMeshData& meshData);
+    static bool BuildMapMesh(GameMapManager& city, const Rect& area, MapMeshData& meshData);
 
     // compute height for specific block slope type
     // @param slope: Index
diff --git a/src/GraphicsDefs.h b/src/GraphicsDefs.h
@@ -145,7 +145,7 @@ const unsigned int Sizeof_Vertex3D_Debug = sizeof(Vertex3D_Debug);
 // @param rcSrc, rcDest: Source and destination rectangles
 // @param color: Quad vertices color
 // @param vertices: Output 4 vertices in order TOP LEFT, BOTTOM LEFT, BOTTOM RIGHT, TOP RIGHT
-inline void MakeQuad2D(const Point& textureSize, const Rectangle& rcSrc, const Rectangle& rcDest, Color32 color, Vertex2D* vertices)
+inline void MakeQuad2D(const Point& textureSize, const Rect& rcSrc, const Rect& rcDest, Color32 color, Vertex2D* vertices)
 {
     const float invx = 1.0f / textureSize.x;
     const float invy = 1.0f / textureSize.y;
@@ -180,7 +180,7 @@ inline void MakeQuad2D(const Point& textureSize, const Rectangle& rcSrc, const R
 }
 
 // same as MakeQuad2D but with 3rd dimension
-inline void MakeQuad3D(const Point& textureSize, const Rectangle& rcSrc, const Rectangle& rcDest, Color32 color, Vertex3D* vertices)
+inline void MakeQuad3D(const Point& textureSize, const Rect& rcSrc, const Rect& rcDest, Color32 color, Vertex3D* vertices)
 {
     const float invx = 1.0f / textureSize.x;
     const float invy = 1.0f / textureSize.y;
diff --git a/src/GraphicsDevice.cpp b/src/GraphicsDevice.cpp
@@ -832,7 +832,7 @@ void GraphicsDevice::ProcessGamepadsInputs()
     }
 }
 
-void GraphicsDevice::SetViewportRect(const Rectangle& sourceRectangle)
+void GraphicsDevice::SetViewportRect(const Rect& sourceRectangle)
 {
     if (!IsDeviceInited())
     {
@@ -848,7 +848,7 @@ void GraphicsDevice::SetViewportRect(const Rectangle& sourceRectangle)
     glCheckError();
 }
 
-void GraphicsDevice::SetScissorRect(const Rectangle& sourceRectangle)
+void GraphicsDevice::SetScissorRect(const Rect& sourceRectangle)
 {
     if (!IsDeviceInited())
     {
diff --git a/src/GraphicsDevice.h b/src/GraphicsDevice.h
@@ -10,8 +10,8 @@ class GraphicsDevice final: public cxx::noncopyable
 public:
     // public for convenience, don't change these fields directly
     RenderStates mCurrentStates;
-    Rectangle mViewportRect;
-    Rectangle mScissorBox;
+    Rect mViewportRect;
+    Rect mScissorBox;
     GraphicsDeviceCaps mCaps;
 
     // these params will automatically set during texture creation
@@ -136,11 +136,11 @@ class GraphicsDevice final: public cxx::noncopyable
 
     // Setup dimensions of graphic device viewport
     // @param sourceRectangle: Viewport rectangle
-    void SetViewportRect(const Rectangle& sourceRectangle);
+    void SetViewportRect(const Rect& sourceRectangle);
 
     // Setup clip rect, default is whole viewport area
     // @param sourceRectangle: Clipping rectangle
-    void SetScissorRect(const Rectangle& sourceRectangle);
+    void SetScissorRect(const Rect& sourceRectangle);
 
     // Set clear color for render revice
     // @param clearColor: Color components
diff --git a/src/ImGuiManager.cpp b/src/ImGuiManager.cpp
@@ -128,7 +128,7 @@ void ImGuiManager::RenderFrame()
             if (!should_draw)
                 continue;
 
-            Rectangle rcClip {
+            Rect rcClip {
                 static_cast<int>(clip_rect_x), static_cast<int>(fb_height - clip_rect_h), 
                 static_cast<int>(clip_rect_w - clip_rect_x), 
                 static_cast<int>(clip_rect_h - clip_rect_y)
diff --git a/src/MapRenderer.cpp b/src/MapRenderer.cpp
@@ -151,7 +151,7 @@ void MapRenderer::BuildMapMesh()
     {
         for (int batchx = 0; batchx < BlocksBatchesPerSide; ++batchx)
         {
-            Rectangle mapArea { 
+            Rect mapArea { 
                 batchx * BlocksBatchDims - ExtraBlocksPerSide, 
                 batchy * BlocksBatchDims - ExtraBlocksPerSide,
                 BlocksBatchDims,
diff --git a/src/RenderingManager.cpp b/src/RenderingManager.cpp
@@ -53,7 +53,7 @@ void RenderingManager::RenderFrame()
     gSpriteManager.RenderFrameBegin();
     mMapRenderer.RenderFrameBegin();
 
-    Rectangle viewportRectangle = gGraphicsDevice.mViewportRect;
+    Rect viewportRectangle = gGraphicsDevice.mViewportRect;
     for (RenderView* currRenderview: mActiveRenderViews)
     {
         currRenderview->DrawFrameBegin();
diff --git a/src/SpriteManager.cpp b/src/SpriteManager.cpp
@@ -604,7 +604,7 @@ void SpriteManager::GetSpriteTexture(GameObjectID objectID, int spriteIndex, int
     // upload to texture
     sourceSprite.mTexture->Upload(pixels.mData);
 
-    Rectangle srcRect;
+    Rect srcRect;
     srcRect.x = 0;
     srcRect.y = 0;
     srcRect.w = spriteStyle.mWidth;
diff --git a/src/System.cpp b/src/System.cpp
@@ -180,42 +180,15 @@ void System::Deinit()
 
 void System::Execute()
 {
-    const double MinFPS = 20.0;
-    const double MaxFrameDelta = 1.0 / MinFPS;
-
-    const double MaxFPS = 120.0f;
-    const double MinFrameDelta = 1.0 / MaxFPS;
-
     // main loop
-    double previousFrameTimestamp = GetSystemSeconds();
     for (; !mQuitRequested; )
     {
-        double currentTimestamp = GetSystemSeconds();
-        double systemDeltaTime = (currentTimestamp - previousFrameTimestamp);
-        if (systemDeltaTime < MinFrameDelta)
-        {
-            // limit fps 
-            std::chrono::duration<double> sleepTime (MinFrameDelta - systemDeltaTime);
-            std::this_thread::sleep_for(sleepTime);
-
-            currentTimestamp = GetSystemSeconds();
-            systemDeltaTime = (currentTimestamp - previousFrameTimestamp);
-        }
-
-        if (systemDeltaTime > MaxFrameDelta)
-        {
-            systemDeltaTime = MaxFrameDelta;
-        }
-
-        gTimeManager.AdvanceTime(systemDeltaTime);
-
-        gMemoryManager.FlushFrameHeapMemory();
-        // order in which subsystems gets updated is significant
+        gTimeManager.UpdateFrame();
+        gMemoryManager.FlushFrameHeapMemory();
         gImGuiManager.UpdateFrame();
         gUiManager.UpdateFrame();
         gCarnageGame.UpdateFrame();
         gRenderManager.RenderFrame();
-        previousFrameTimestamp = currentTimestamp;
     }
 }
 
@@ -296,7 +269,7 @@ bool System::SaveConfiguration()
 }
 
 double System::GetSystemSeconds() const
-{   
+{
     double currentTime = ::glfwGetTime();
     return (currentTime - mStartSystemTime);
 }
diff --git a/src/TimeManager.cpp b/src/TimeManager.cpp
diff --git a/src/TimeManager.h b/src/TimeManager.h
diff --git a/src/UiManager.cpp b/src/UiManager.cpp
diff --git a/src/path_utils.cpp b/src/path_utils.cpp
diff --git a/src/stdafx.h b/src/stdafx.h

Original file line number	Diff line number	Diff line change
`@@ -97,11 +97,11 @@ extern const Color32 Color32_NULL;`
`97`	`97`	`using Point = glm::ivec2;`
`98`	`98`
`99`	`99`	`// defines rectangle in 2d space`
`100`		`-struct Rectangle`
	`100`	`+struct Rect`
`101`	`101`	`{`
`102`	`102`	`public:`
`103`		`- Rectangle() = default;`
`104`		`- Rectangle(int posx, int posy, int sizex, int sizey)`
	`103`	`+ Rect() = default;`
	`104`	`+ Rect(int posx, int posy, int sizex, int sizey)`
`105`	`105`	`: x(posx)`
`106`	`106`	`, y(posy)`
`107`	`107`	`, w(sizex)`
`@@ -130,9 +130,9 @@ struct Rectangle`
`130`	`130`	`point.y < (y + h - 1);`
`131`	`131`	`}`
`132`	`132`	`// get union area of two rectangles`
`133`		`- inline Rectangle GetUnion(const Rectangle& rc) const`
	`133`	`+ inline Rect GetUnion(const Rect& rc) const`
`134`	`134`	`{`
`135`		`- Rectangle rcOutput;`
	`135`	`+ Rect rcOutput;`
`136`	`136`
`137`	`137`	`int maxx = glm::max(x + w, rc.x + rc.w);`
`138`	`138`	`int maxy = glm::max(y + h, rc.y + rc.h);`
`@@ -145,9 +145,9 @@ struct Rectangle`
`145`	`145`	`return rcOutput;`
`146`	`146`	`}`
`147`	`147`	`// get intersection area of two rectangles`
`148`		`- inline Rectangle GetIntersection(const Rectangle& rc) const`
	`148`	`+ inline Rect GetIntersection(const Rect& rc) const`
`149`	`149`	`{`
`150`		`- Rectangle rcOutput;`
	`150`	`+ Rect rcOutput;`
`151`	`151`
`152`	`152`	`int minx = glm::min(x + w, rc.x + rc.w);`
`153`	`153`	`int miny = glm::min(y + h, rc.y + rc.h);`
`@@ -164,12 +164,12 @@ struct Rectangle`
`164`	`164`	`int w, h;`
`165`	`165`	`};`
`166`	`166`
`167`		`-inline bool operator == (const Rectangle& lhs, const Rectangle& rhs)`
	`167`	`+inline bool operator == (const Rect& lhs, const Rect& rhs)`
`168`	`168`	`{`
`169`	`169`	`return (lhs.x == rhs.x) && (lhs.y == rhs.y) && (lhs.w == rhs.w) && (lhs.h == rhs.h);`
`170`	`170`	`}`
`171`	`171`
`172`		`-inline bool operator != (const Rectangle& lhs, const Rectangle& rhs)`
	`172`	`+inline bool operator != (const Rect& lhs, const Rect& rhs)`
`173`	`173`	`{`
`174`	`174`	`return (lhs.x != rhs.x) \|\| (lhs.y != rhs.y) \|\| (lhs.w != rhs.w) \|\| (lhs.h != rhs.h);`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -297,13 +297,13 @@ struct TextureRegion`
`297`	`297`	`{`
`298`	`298`	`SetRegion(textureSize);`
`299`	`299`	`}`
`300`		`- TextureRegion(const Rectangle& srcRectangle, const Point& textureSize)`
	`300`	`+ TextureRegion(const Rect& srcRectangle, const Point& textureSize)`
`301`	`301`	`{`
`302`	`302`	`SetRegion(srcRectangle, textureSize);`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`// init texture region to partial area`
`306`		`- inline void SetRegion(const Rectangle& srcRectangle, const Point& textureSize)`
	`306`	`+ inline void SetRegion(const Rect& srcRectangle, const Point& textureSize)`
`307`	`307`	`{`
`308`	`308`	`debug_assert(textureSize.x > 0);`
`309`	`309`	`debug_assert(textureSize.y > 0);`
`@@ -334,7 +334,7 @@ struct TextureRegion`
`334`	`334`	`mRectangle.SetNull();`
`335`	`335`	`}`
`336`	`336`	`public:`
`337`		`- Rectangle mRectangle;`
	`337`	`+ Rect mRectangle;`
`338`	`338`
`339`	`339`	`float mU0, mV0; // texture coords`
`340`	`340`	`float mU1, mV1; // texture coords`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`#include "SpriteManager.h"`
`4`	`4`	`#include "GameMapManager.h"`
`5`	`5`
`6`		`-bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rectangle& area, int layerIndex, MapMeshData& meshData)`
	`6`	`+bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rect& area, int layerIndex, MapMeshData& meshData)`
`7`	`7`	`{`
`8`	`8`	`debug_assert(layerIndex > -1 && layerIndex < MAP_LAYERS_COUNT);`
`9`	`9`
`@@ -30,7 +30,7 @@ bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rectangle& ar`
`30`	`30`	`return true;`
`31`	`31`	`}`
`32`	`32`
`33`		`-bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rectangle& area, MapMeshData& meshData)`
	`33`	`+bool GameMapHelpers::BuildMapMesh(GameMapManager& cityScape, const Rect& area, MapMeshData& meshData)`
`34`	`34`	`{`
`35`	`35`	`// preallocate`
`36`	`36`	`meshData.mBlocksIndices.reserve(4 * 1024 * 1024);`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ const unsigned int Sizeof_Vertex3D_Debug = sizeof(Vertex3D_Debug);`
`145`	`145`	`// @param rcSrc, rcDest: Source and destination rectangles`
`146`	`146`	`// @param color: Quad vertices color`
`147`	`147`	`// @param vertices: Output 4 vertices in order TOP LEFT, BOTTOM LEFT, BOTTOM RIGHT, TOP RIGHT`
`148`		`-inline void MakeQuad2D(const Point& textureSize, const Rectangle& rcSrc, const Rectangle& rcDest, Color32 color, Vertex2D* vertices)`
	`148`	`+inline void MakeQuad2D(const Point& textureSize, const Rect& rcSrc, const Rect& rcDest, Color32 color, Vertex2D* vertices)`
`149`	`149`	`{`
`150`	`150`	`const float invx = 1.0f / textureSize.x;`
`151`	`151`	`const float invy = 1.0f / textureSize.y;`
`@@ -180,7 +180,7 @@ inline void MakeQuad2D(const Point& textureSize, const Rectangle& rcSrc, const R`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`// same as MakeQuad2D but with 3rd dimension`
`183`		`-inline void MakeQuad3D(const Point& textureSize, const Rectangle& rcSrc, const Rectangle& rcDest, Color32 color, Vertex3D* vertices)`
	`183`	`+inline void MakeQuad3D(const Point& textureSize, const Rect& rcSrc, const Rect& rcDest, Color32 color, Vertex3D* vertices)`
`184`	`184`	`{`
`185`	`185`	`const float invx = 1.0f / textureSize.x;`
`186`	`186`	`const float invy = 1.0f / textureSize.y;`
Original file line number	Diff line number	Diff line change
`@@ -832,7 +832,7 @@ void GraphicsDevice::ProcessGamepadsInputs()`
`832`	`832`	`}`
`833`	`833`	`}`
`834`	`834`
`835`		`-void GraphicsDevice::SetViewportRect(const Rectangle& sourceRectangle)`
	`835`	`+void GraphicsDevice::SetViewportRect(const Rect& sourceRectangle)`
`836`	`836`	`{`
`837`	`837`	`if (!IsDeviceInited())`
`838`	`838`	`{`
`@@ -848,7 +848,7 @@ void GraphicsDevice::SetViewportRect(const Rectangle& sourceRectangle)`
`848`	`848`	`glCheckError();`
`849`	`849`	`}`
`850`	`850`
`851`		`-void GraphicsDevice::SetScissorRect(const Rectangle& sourceRectangle)`
	`851`	`+void GraphicsDevice::SetScissorRect(const Rect& sourceRectangle)`
`852`	`852`	`{`
`853`	`853`	`if (!IsDeviceInited())`
`854`	`854`	`{`