From 60c4c905b88b99cc9aa931a188afd4ddbba42f8f Mon Sep 17 00:00:00 2001
From: assiduous <assiduous@diligentgraphics.com>
Date: Tue, 22 Dec 2020 16:50:36 -0800
Subject: PSO initialization: updated shader stage initialization

---
 .../include/PipelineStateGLImpl.hpp                | 17 ++--------
 .../src/PipelineStateGLImpl.cpp                    | 38 ++++++++++------------
 2 files changed, 21 insertions(+), 34 deletions(-)

(limited to 'Graphics/GraphicsEngineOpenGL')

diff --git a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
index 0635313d..17440a4d 100644
--- a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
@@ -97,22 +97,11 @@ private:
 
     void InitImmutableSamplersInResourceCache(const GLPipelineResourceLayout& ResourceLayout, GLProgramResourceCache& Cache) const;
 
-    struct GLPipelineShaderStageInfo
-    {
-        const SHADER_TYPE   Type;
-        ShaderGLImpl* const pShader;
-        GLPipelineShaderStageInfo(SHADER_TYPE   _Type,
-                                  ShaderGLImpl* _pShader) :
-            Type{_Type},
-            pShader{_pShader}
-        {}
-    };
-
     template <typename PSOCreateInfoType>
-    void Initialize(const PSOCreateInfoType& CreateInfo, const std::vector<GLPipelineShaderStageInfo>& ShaderStages);
+    void Initialize(const PSOCreateInfoType& CreateInfo, std::vector<ShaderGLImpl*>& Shaders);
 
-    void InitResourceLayouts(const std::vector<GLPipelineShaderStageInfo>& ShaderStages,
-                             FixedLinearAllocator&                         MemPool);
+    void InitResourceLayouts(std::vector<ShaderGLImpl*>& Shaders,
+                             FixedLinearAllocator&       MemPool);
 
     void Destruct();
 
diff --git a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
index b8c0a7c0..867ea602 100644
--- a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
@@ -38,10 +38,10 @@ namespace Diligent
 
 
 template <typename PSOCreateInfoType>
-void PipelineStateGLImpl::Initialize(const PSOCreateInfoType& CreateInfo, const std::vector<GLPipelineShaderStageInfo>& ShaderStages)
+void PipelineStateGLImpl::Initialize(const PSOCreateInfoType& CreateInfo, std::vector<ShaderGLImpl*>& Shaders)
 {
     FixedLinearAllocator MemPool{GetRawAllocator()};
-    VERIFY_EXPR(m_NumShaderStages > 0 && m_NumShaderStages == ShaderStages.size());
+    VERIFY_EXPR(m_NumShaderStages > 0 && m_NumShaderStages == Shaders.size());
     if (!GetDevice()->GetDeviceCaps().Features.SeparablePrograms)
         m_NumShaderStages = 1;
 
@@ -69,7 +69,7 @@ void PipelineStateGLImpl::Initialize(const PSOCreateInfoType& CreateInfo, const
     // It is important to construct all objects before initializing them because if an exception is thrown,
     // destructors will be called for all objects
 
-    InitResourceLayouts(ShaderStages, MemPool);
+    InitResourceLayouts(Shaders, MemPool);
     InitializePipelineDesc(CreateInfo, MemPool);
 }
 
@@ -91,8 +91,8 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*
 {
     try
     {
-        std::vector<GLPipelineShaderStageInfo> ShaderStages;
-        ExtractShaders<ShaderGLImpl>(CreateInfo, ShaderStages);
+        std::vector<ShaderGLImpl*> Shaders;
+        ExtractShaders<ShaderGLImpl>(CreateInfo, Shaders);
 
         RefCntAutoPtr<ShaderGLImpl> pTempPS;
         if (CreateInfo.pPS == nullptr)
@@ -106,11 +106,11 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*
             ShaderCI.Desc.Name       = "Dummy fragment shader";
             pDeviceGL->CreateShader(ShaderCI, reinterpret_cast<IShader**>(static_cast<ShaderGLImpl**>(&pTempPS)));
 
-            ShaderStages.emplace_back(SHADER_TYPE_PIXEL, pTempPS);
+            Shaders.emplace_back(pTempPS);
             m_ShaderStageTypes[m_NumShaderStages++] = SHADER_TYPE_PIXEL;
         }
 
-        Initialize(CreateInfo, ShaderStages);
+        Initialize(CreateInfo, Shaders);
     }
     catch (...)
     {
@@ -136,10 +136,10 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*                   p
 {
     try
     {
-        std::vector<GLPipelineShaderStageInfo> ShaderStages;
-        ExtractShaders<ShaderGLImpl>(CreateInfo, ShaderStages);
+        std::vector<ShaderGLImpl*> Shaders;
+        ExtractShaders<ShaderGLImpl>(CreateInfo, Shaders);
 
-        Initialize(CreateInfo, ShaderStages);
+        Initialize(CreateInfo, Shaders);
     }
     catch (...)
     {
@@ -189,8 +189,8 @@ void PipelineStateGLImpl::Destruct()
 IMPLEMENT_QUERY_INTERFACE(PipelineStateGLImpl, IID_PipelineStateGL, TPipelineStateBase)
 
 
-void PipelineStateGLImpl::InitResourceLayouts(const std::vector<GLPipelineShaderStageInfo>& ShaderStages,
-                                              FixedLinearAllocator&                         MemPool)
+void PipelineStateGLImpl::InitResourceLayouts(std::vector<ShaderGLImpl*>& Shaders,
+                                              FixedLinearAllocator&       MemPool)
 {
     auto* const pDeviceGL  = GetDevice();
     const auto& deviceCaps = pDeviceGL->GetDeviceCaps();
@@ -210,9 +210,9 @@ void PipelineStateGLImpl::InitResourceLayouts(const std::vector<GLPipelineShader
             // Program pipelines are not shared between GL contexts, so we cannot create
             // it now
             m_ShaderResourceLayoutHash = 0;
-            for (size_t i = 0; i < ShaderStages.size(); ++i)
+            for (size_t i = 0; i < Shaders.size(); ++i)
             {
-                auto*       pShaderGL  = ShaderStages[i].pShader;
+                auto*       pShaderGL  = Shaders[i];
                 const auto& ShaderDesc = pShaderGL->GetDesc();
                 m_GLPrograms[i]        = GLProgramObj{ShaderGLImpl::LinkProgram(&pShaderGL, 1, true)};
                 // Load uniforms and assign bindings
@@ -227,14 +227,12 @@ void PipelineStateGLImpl::InitResourceLayouts(const std::vector<GLPipelineShader
         }
         else
         {
-            std::vector<ShaderGLImpl*> Shaders;
-
             SHADER_TYPE ActiveStages = SHADER_TYPE_UNKNOWN;
-            for (const auto& Stage : ShaderStages)
+            for (const auto* pShader : Shaders)
             {
-                Shaders.push_back(Stage.pShader);
-                VERIFY((ActiveStages & Stage.Type) == 0, "Shader stage ", GetShaderTypeLiteralName(Stage.Type), " is already active");
-                ActiveStages |= Stage.Type;
+                const auto ShaderType = pShader->GetDesc().ShaderType;
+                VERIFY((ActiveStages & ShaderType) == 0, "Shader stage ", GetShaderTypeLiteralName(ShaderType), " is already active");
+                ActiveStages |= ShaderType;
             }
 
             m_GLPrograms[0] = ShaderGLImpl::LinkProgram(Shaders.data(), static_cast<Uint32>(Shaders.size()), false);
-- 
cgit v1.2.3