Changeset 27109

Timestamp:

Oct 4, 2022, 9:32:42 PM (22 months ago)

Author:

Vladislav Belov

Message:

Removes drawing via IDeviceCommandContext from CMinimap.

Comments By: phosit

Differential Revision: ​https://code.wildfiregames.com/D4779

Location:

ps/trunk/source

Files:

• graphics/Canvas2D.cpp (modified) (3 diffs)
• graphics/Canvas2D.h (modified) (2 diffs)
• graphics/MiniMapTexture.cpp (modified) (1 diff)
• graphics/MiniMapTexture.h (modified) (2 diffs)
• gui/ObjectTypes/CMiniMap.cpp (modified) (7 diffs)

ps/trunk/source/graphics/Canvas2D.cpp

@@ -332 +332 @@
 }
 
-void CCanvas2D::DrawTexture(CTexturePtr texture, const CRect& destination)
+void CCanvas2D::DrawTexture( texture, const CRect& destination)
 {
     DrawTexture(texture,
@@ -340 +340 @@
 
 void CCanvas2D::DrawTexture(
-    CTexturePtr texture, const CRect& destination, const CRect& source,
+     texture, const CRect& destination, const CRect& source,
     const CColor& multiply, const CColor& add, const float grayscaleFactor)
 {
@@ -368 +368 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void CCanvas2D::DrawText(CTextRenderer& textRenderer)
 {

ps/trunk/source/graphics/Canvas2D.h

@@ -63 +63 @@
      * the grayscale factor.
      */
-    void DrawTexture(CTexturePtr texture,
-        const CRect& destination, const CRect& source,
+    void DrawTexture(
+        const CRect& destination, const CRect& source,
         const CColor& multiply, const CColor& add, const float grayscaleFactor);
 
@@ -71 +71 @@
      * destination rect without color modifications.
      */
-    void DrawTexture(CTexturePtr texture, const CRect& destination);
+    void DrawTexture(const CTexturePtr& texture, const CRect& destination);
+
+    /**
+     * A similar to the original one, draws the texture into the
+     * destination rect but rotates it first around the origin point by angle
+     * radians (a positive angle denotes a clockwise rotation).
+     */
+    void DrawRotatedTexture(
+        const CTexturePtr& texture, const CRect& destination, const CRect& source,
+        const CColor& multiply, const CColor& add, const float grayscaleFactor,
+        const CVector2D& origin, const float angle);
 
     /**

ps/trunk/source/graphics/MiniMapTexture.cpp

@@ -345 +345 @@
     m_TerrainData = std::make_unique<u32[]>((m_MapSize - 1) * (m_MapSize - 1));
 
-    m_FinalTexture = backendDevice->CreateTexture2D("MiniMapFinalTexture",
-        Renderer::Backend::Format::R8G8B8A8_UNORM, FINAL_TEXTURE_SIZE, FINAL_TEXTURE_SIZE, defaultSamplerDesc);
+    m_FinalTexture = g_Renderer.GetTextureManager().WrapBackendTexture(
+        backendDevice->CreateTexture2D("MiniMapFinalTexture",
+            Renderer::Backend::Format::R8G8B8A8_UNORM,
+            FINAL_TEXTURE_SIZE, FINAL_TEXTURE_SIZE, defaultSamplerDesc));
 
     m_FinalTextureFramebuffer = backendDevice->CreateFramebuffer("MiniMapFinalFramebuffer",
-        m_FinalTexture.get(), nullptr);
+        m_FinalTexture(), nullptr);
     ENSURE(m_FinalTextureFramebuffer);
 }

ps/trunk/source/graphics/MiniMapTexture.h

@@ -51 +51 @@
     void Render(Renderer::Backend::IDeviceCommandContext* deviceCommandContext);
 
-    Renderer::Backend::ITexture* GetTexture() const { return m_FinalTexture.get(); }
+    ; }
 
     /**
@@ -86 +86 @@
 
     // minimap texture handles
-    std::unique_ptr<Renderer::Backend::ITexture>
-        m_TerrainTexture, m_FinalTexture;
+    std::unique_ptr<Renderer::Backend::ITexture> m_TerrainTexture;
+
+    CTexturePtr m_FinalTexture;
 
     std::unique_ptr<Renderer::Backend::IFramebuffer>

ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp

@@ -24 +24 @@
 #include "graphics/MiniMapTexture.h"
 #include "graphics/MiniPatch.h"
-#include "graphics/ShaderManager.h"
-#include "graphics/ShaderProgramPtr.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainTextureEntry.h"
@@ -32 +30 @@
 #include "gui/CGUI.h"
 #include "gui/GUIManager.h"
-#include "gui/GUIMatrix.h"
 #include "lib/bits.h"
 #include "lib/external_libraries/libsdl.h"
@@ -39 +36 @@
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
-#include "ps/CStrInternStatic.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
@@ -46 +42 @@
 #include "ps/World.h"
 #include "renderer/Renderer.h"
-#include "renderer/RenderingOptions.h"
 #include "renderer/SceneRenderer.h"
 #include "renderer/WaterManager.h"
@@ -94 +89 @@
 }
 
-void DrawTexture(
-    Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
-    float angle, float x, float y, float x2, float y2, float mapScale)
-{
-    // Rotate the texture coordinates (0,0)-(coordMax,coordMax) around their center point (m,m)
-    // Scale square maps to fit in circular minimap area
-    const float s = sin(angle) * mapScale;
-    const float c = cos(angle) * mapScale;
-    const float m = 0.5f;
-
-    float quadTex[] =
-    {
-        m*(-c + s + 1.f), m*(-c + -s + 1.f),
-        m*(c + s + 1.f), m*(-c + s + 1.f),
-        m*(c + -s + 1.f), m*(c + s + 1.f),
-
-        m*(c + -s + 1.f), m*(c + s + 1.f),
-        m*(-c + -s + 1.f), m*(c + -s + 1.f),
-        m*(-c + s + 1.f), m*(-c + -s + 1.f)
-    };
-    float quadVerts[] =
-    {
-        x, y, 0.0f,
-        x2, y, 0.0f,
-        x2, y2, 0.0f,
-
-        x2, y2, 0.0f,
-        x, y2, 0.0f,
-        x, y, 0.0f
-    };
-
-    deviceCommandContext->SetVertexAttributeFormat(
-        Renderer::Backend::VertexAttributeStream::POSITION,
-        Renderer::Backend::Format::R32G32B32_SFLOAT, 0, 0,
-        Renderer::Backend::VertexAttributeRate::PER_VERTEX, 0);
-    deviceCommandContext->SetVertexAttributeFormat(
-        Renderer::Backend::VertexAttributeStream::UV0,
-        Renderer::Backend::Format::R32G32_SFLOAT, 0, 0,
-        Renderer::Backend::VertexAttributeRate::PER_VERTEX, 1);
-
-    deviceCommandContext->SetVertexBufferData(
-        0, quadVerts, std::size(quadVerts) * sizeof(quadVerts[0]));
-    deviceCommandContext->SetVertexBufferData(
-        1, quadTex, std::size(quadTex) * sizeof(quadTex[0]));
-
-    deviceCommandContext->Draw(0, 6);
-}
-
 } // anonymous namespace
 
@@ -403 +350 @@
         canvas.DrawRect(m_CachedActualSize, CColor(0.0f, 0.0f, 0.0f, 1.0f));
 
-    canvas.Flush();
-
     CSimulation2* sim = g_Game->GetSimulation2();
     CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);
@@ -418 +363 @@
     if (miniMapTexture.GetTexture())
     {
-        CShaderDefines baseDefines;
-        baseDefines.Add(str_MINIMAP_BASE, str_1);
-
-        CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, baseDefines);
-        Renderer::Backend::GraphicsPipelineStateDesc pipelineStateDesc =
-            tech->GetGraphicsPipelineStateDesc();
-        pipelineStateDesc.blendState.enabled = true;
-        pipelineStateDesc.blendState.srcColorBlendFactor = pipelineStateDesc.blendState.srcAlphaBlendFactor =
-            Renderer::Backend::BlendFactor::SRC_ALPHA;
-        pipelineStateDesc.blendState.dstColorBlendFactor = pipelineStateDesc.blendState.dstAlphaBlendFactor =
-            Renderer::Backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
-        pipelineStateDesc.blendState.colorBlendOp = pipelineStateDesc.blendState.alphaBlendOp =
-            Renderer::Backend::BlendOp::ADD;
-        Renderer::Backend::IDeviceCommandContext* deviceCommandContext =
-            g_Renderer.GetDeviceCommandContext();
-        deviceCommandContext->SetGraphicsPipelineState(pipelineStateDesc);
-        deviceCommandContext->BeginPass();
-
-        Renderer::Backend::IShaderProgram* shader = tech->GetShader();
-
-        deviceCommandContext->SetTexture(
-            shader->GetBindingSlot(str_baseTex), miniMapTexture.GetTexture());
-
-        const CMatrix3D baseTransform = GetDefaultGuiMatrix();
-        CMatrix3D baseTextureTransform;
-        baseTextureTransform.SetIdentity();
-
-        deviceCommandContext->SetUniform(
-            shader->GetBindingSlot(str_transform), baseTransform.AsFloatArray());
-        deviceCommandContext->SetUniform(
-            shader->GetBindingSlot(str_textureTransform), baseTextureTransform.AsFloatArray());
-
-        const float x = m_CachedActualSize.left, y = m_CachedActualSize.bottom;
-        const float x2 = m_CachedActualSize.right, y2 = m_CachedActualSize.top;
-        const float angle = GetAngle();
-        DrawTexture(deviceCommandContext, angle, x, y, x2, y2, m_MapScale);
-
-        deviceCommandContext->EndPass();
+        const CVector2D center = m_CachedActualSize.CenterPoint();
+        const CRect source(
+            0, miniMapTexture.GetTexture()->GetHeight(),
+            miniMapTexture.GetTexture()->GetWidth(), 0);
+        const CSize2D size(m_CachedActualSize.GetSize() / m_MapScale);
+        const CRect destination(center - size / 2.0f, size);
+        canvas.DrawRotatedTexture(
+            miniMapTexture.GetTexture(), destination, source,
+            CColor(1.0f, 1.0f, 1.0f, 1.0f), CColor(0.0f, 0.0f, 0.0f, 0.0f), 0.0f,
+            center, GetAngle());
     }