Added GraphicsPipelineCreateInfo and ComputePipelineCreateInfo instead of single PipelineCreateInfo.

Some optimizations for dynamic memory allocations in PipelineState.

7 files changed, 177 insertions, 68 deletions

diff --git a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
index dea1d6c8..55c53c25 100644
--- a/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/PipelineStateGLImpl.hpp
@@ -37,6 +37,7 @@
 #include "GLProgramResources.hpp"
 #include "GLPipelineResourceLayout.hpp"
 #include "GLProgramResourceCache.hpp"
+#include "ShaderGLImpl.hpp"
 
 namespace Diligent
 {
@@ -49,10 +50,14 @@ class PipelineStateGLImpl final : public PipelineStateBase<IPipelineStateGL, Ren
 public:
     using TPipelineStateBase = PipelineStateBase<IPipelineStateGL, RenderDeviceGLImpl>;
 
-    PipelineStateGLImpl(IReferenceCounters*            pRefCounters,
-                        RenderDeviceGLImpl*            pDeviceGL,
-                        const PipelineStateCreateInfo& CreateInfo,
-                        bool                           IsDeviceInternal = false);
+    PipelineStateGLImpl(IReferenceCounters*                    pRefCounters,
+                        RenderDeviceGLImpl*                    pDeviceGL,
+                        const GraphicsPipelineStateCreateInfo& CreateInfo,
+                        bool                                   IsDeviceInternal = false);
+    PipelineStateGLImpl(IReferenceCounters*                   pRefCounters,
+                        RenderDeviceGLImpl*                   pDeviceGL,
+                        const ComputePipelineStateCreateInfo& CreateInfo,
+                        bool                                  IsDeviceInternal = false);
     ~PipelineStateGLImpl();
 
     /// Queries the specific interface, see IObject::QueryInterface() for details
@@ -92,10 +97,25 @@ private:
 
     void InitStaticSamplersInResourceCache(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}
+        {}
+    };
+    void InitResourceLayouts(RenderDeviceGLImpl*                           pDeviceVk,
+                             const std::vector<GLPipelineShaderStageInfo>& ShaderStages,
+                             LinearAllocator&                              MemPool);
+
     // Linked GL programs for every shader stage. Every pipeline needs to have its own programs
     // because resource bindings assigned by GLProgramResources::LoadUniforms depend on other
     // shader stages.
-    std::vector<GLObjectWrappers::GLProgramObj> m_GLPrograms;
+    using GLProgramObj         = GLObjectWrappers::GLProgramObj;
+    GLProgramObj* m_GLPrograms = nullptr; // [m_NumShaderStages]
 
     ThreadingTools::LockFlag m_ProgPipelineLockFlag;
 
@@ -113,14 +133,15 @@ private:
     GLProgramResourceCache m_StaticResourceCache;
 
     // Program resources for all shader stages in the pipeline
-    std::vector<GLProgramResources> m_ProgramResources;
+    GLProgramResources* m_ProgramResources = nullptr; // [m_NumShaderStages]
 
     Uint32 m_TotalUniformBufferBindings = 0;
     Uint32 m_TotalSamplerBindings       = 0;
     Uint32 m_TotalImageBindings         = 0;
     Uint32 m_TotalStorageBufferBindings = 0;
 
-    std::vector<RefCntAutoPtr<ISampler>> m_StaticSamplers;
+    using SamplerPtr             = RefCntAutoPtr<ISampler>;
+    SamplerPtr* m_StaticSamplers = nullptr; // [m_Desc.ResourceLayout.NumStaticSamplers]
 };
 
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp
index afb46edb..d23142e0 100644
--- a/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp
+++ b/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp
@@ -86,12 +86,20 @@ public:
     virtual void DILIGENT_CALL_TYPE CreateSampler(const SamplerDesc& SamplerDesc,
                                                   ISampler**         ppSampler) override final;
 
-    /// Implementation of IRenderDevice::CreatePipelineState() in OpenGL backend.
-    void                            CreatePipelineState(const PipelineStateCreateInfo& PSOCreateInfo,
-                                                        IPipelineState**               ppPipelineState,
-                                                        bool                           bIsDeviceInternal);
-    virtual void DILIGENT_CALL_TYPE CreatePipelineState(const PipelineStateCreateInfo& PSOCreateInfo,
-                                                        IPipelineState**               ppPipelineState) override final;
+    /// Implementation of IRenderDevice::CreateGraphicsPipelineState() in OpenGL backend.
+    virtual void CreateGraphicsPipelineState(const GraphicsPipelineStateCreateInfo& PSOCreateInfo,
+                                             IPipelineState**                       ppPipelineState) override final;
+
+    /// Implementation of IRenderDevice::CreateComputePipelineState() in OpenGL backend.
+    virtual void CreateComputePipelineState(const ComputePipelineStateCreateInfo& PSOCreateInfo,
+                                            IPipelineState**                      ppPipelineState) override final;
+
+    void CreateGraphicsPipelineState(const GraphicsPipelineStateCreateInfo& PSOCreateInfo,
+                                     IPipelineState**                       ppPipelineState,
+                                     bool                                   bIsDeviceInternal);
+    void CreateComputePipelineState(const ComputePipelineStateCreateInfo& PSOCreateInfo,
+                                    IPipelineState**                      ppPipelineState,
+                                    bool                                  bIsDeviceInternal);
 
     /// Implementation of IRenderDevice::CreateFence() in OpenGL backend.
     virtual void DILIGENT_CALL_TYPE CreateFence(const FenceDesc& Desc, IFence** ppFence) override final;
diff --git a/Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp
index f4ef1136..d8af2feb 100644
--- a/Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp
@@ -85,12 +85,12 @@ void DeviceContextGLImpl::SetPipelineState(IPipelineState* pPipelineState)
     TDeviceContextBase::SetPipelineState(pPipelineStateGLImpl, 0 /*Dummy*/);
 
     const auto& Desc = pPipelineStateGLImpl->GetDesc();
-    if (Desc.IsComputePipeline())
+    if (Desc.PipelineType == PIPELINE_TYPE_COMPUTE)
     {
     }
     else if (Desc.PipelineType == PIPELINE_TYPE_GRAPHICS)
     {
-        const auto& GraphicsPipeline = Desc.GraphicsPipeline;
+        const auto& GraphicsPipeline = pPipelineStateGLImpl->GetGraphicsPipelineDesc();
         // Set rasterizer state
         {
             const auto& RasterizerDesc = GraphicsPipeline.RasterizerDesc;
@@ -896,7 +896,7 @@ void DeviceContextGLImpl::PrepareForDraw(DRAW_FLAGS Flags, bool IsIndexed, GLenu
     m_pPipelineState->CommitProgram(m_ContextState);
 
     auto        CurrNativeGLContext = m_pDevice->m_GLContext.GetCurrentNativeGLContext();
-    const auto& PipelineDesc        = m_pPipelineState->GetDesc().GraphicsPipeline;
+    const auto& PipelineDesc        = m_pPipelineState->GetGraphicsPipelineDesc();
     if (!m_ContextState.IsValidVAOBound())
     {
         auto&    VAOCache     = m_pDevice->GetVAOCache(CurrNativeGLContext);
diff --git a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
index 8590e203..4ac36396 100644
--- a/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/PipelineStateGLImpl.cpp
@@ -36,10 +36,10 @@
 namespace Diligent
 {
 
-PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCounters,
-                                         RenderDeviceGLImpl*            pDeviceGL,
-                                         const PipelineStateCreateInfo& CreateInfo,
-                                         bool                           bIsDeviceInternal) :
+PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*                    pRefCounters,
+                                         RenderDeviceGLImpl*                    pDeviceGL,
+                                         const GraphicsPipelineStateCreateInfo& CreateInfo,
+                                         bool                                   bIsDeviceInternal) :
     // clang-format off
     TPipelineStateBase
     {
@@ -52,8 +52,11 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCoun
     m_StaticResourceLayout{*this}
 // clang-format on
 {
+    std::vector<GLPipelineShaderStageInfo> ShaderStages;
+    ExtractShaders<ShaderGLImpl>(CreateInfo, ShaderStages);
+
     RefCntAutoPtr<ShaderGLImpl> pTempPS;
-    if (m_Desc.IsAnyGraphicsPipeline() && m_Desc.GraphicsPipeline.pPS == nullptr)
+    if (CreateInfo.pPS == nullptr)
     {
         // Some OpenGL implementations fail if fragment shader is not present, so
         // create a dummy one.
@@ -64,22 +67,92 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCoun
         ShaderCI.Desc.Name       = "Dummy fragment shader";
         pDeviceGL->CreateShader(ShaderCI, reinterpret_cast<IShader**>(static_cast<ShaderGLImpl**>(&pTempPS)));
 
-        m_Desc.GraphicsPipeline.pPS = pTempPS;
+        ShaderStages.emplace_back(SHADER_TYPE_PIXEL, pTempPS);
+        m_ShaderStageTypes[m_NumShaderStages++] = SHADER_TYPE_PIXEL;
     }
 
-    struct GLPipelineShaderStageInfo
+    // Memory must be released if an exception is thrown.
+    LinearAllocator MemPool{GetRawAllocator()};
+
+    MemPool.AddRequiredSize<GLProgramObj>(GetNumShaderStages());
+    MemPool.AddRequiredSize<GLProgramResources>(GetNumShaderStages());
+    MemPool.AddRequiredSize<SamplerPtr>(m_Desc.ResourceLayout.NumStaticSamplers);
+
+    ValidateAndReserveSpace(CreateInfo, MemPool);
+
+    MemPool.Reserve();
+
+    InitResourceLayouts(pDeviceGL, ShaderStages, MemPool);
+    InitGraphicsPipeline(CreateInfo, MemPool);
+
+    void* Ptr = MemPool.Release();
+    VERIFY_EXPR(Ptr == m_GLPrograms);
+}
+
+PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*                   pRefCounters,
+                                         RenderDeviceGLImpl*                   pDeviceGL,
+                                         const ComputePipelineStateCreateInfo& CreateInfo,
+                                         bool                                  bIsDeviceInternal) :
+    // clang-format off
+    TPipelineStateBase
     {
-        const SHADER_TYPE   Type;
-        ShaderGLImpl* const pShader;
-        GLPipelineShaderStageInfo(SHADER_TYPE   _Type,
-                                  ShaderGLImpl* _pShader) :
-            Type{_Type},
-            pShader{_pShader}
-        {}
-    };
+        pRefCounters,
+        pDeviceGL,
+        CreateInfo.PSODesc,
+        bIsDeviceInternal
+    },
+    m_ResourceLayout      {*this},
+    m_StaticResourceLayout{*this}
+// clang-format on
+{
     std::vector<GLPipelineShaderStageInfo> ShaderStages;
-    ExtractShaders<ShaderGLImpl>(ShaderStages);
+    ExtractShaders<ShaderGLImpl>(CreateInfo, ShaderStages);
+
+    // Memory must be released if an exception is thrown.
+    LinearAllocator MemPool{GetRawAllocator()};
+
+    MemPool.AddRequiredSize<GLProgramObj>(GetNumShaderStages());
+    MemPool.AddRequiredSize<GLProgramResources>(GetNumShaderStages());
+    MemPool.AddRequiredSize<SamplerPtr>(m_Desc.ResourceLayout.NumStaticSamplers);
+
+    ValidateAndReserveSpace(CreateInfo, MemPool);
+
+    MemPool.Reserve();
+
+    InitResourceLayouts(pDeviceGL, ShaderStages, MemPool);
+    InitComputePipeline(CreateInfo, MemPool);
+
+    void* Ptr = MemPool.Release();
+    VERIFY_EXPR(Ptr == m_GLPrograms);
+}
 
+PipelineStateGLImpl::~PipelineStateGLImpl()
+{
+    auto& RawAllocator = GetRawAllocator();
+    m_StaticResourceCache.Destroy(RawAllocator);
+    GetDevice()->OnDestroyPSO(this);
+
+    for (Uint32 i = 0; i < GetNumShaderStages(); ++i)
+    {
+        m_GLPrograms[i].~GLProgramObj();
+        m_ProgramResources[i].~GLProgramResources();
+    }
+    for (Uint32 i = 0; i < m_Desc.ResourceLayout.NumStaticSamplers; ++i)
+    {
+        m_StaticSamplers[i].~SamplerPtr();
+    }
+
+    void* pRawMem = m_GLPrograms;
+    RawAllocator.Free(pRawMem);
+}
+
+IMPLEMENT_QUERY_INTERFACE(PipelineStateGLImpl, IID_PipelineStateGL, TPipelineStateBase)
+
+
+void PipelineStateGLImpl::InitResourceLayouts(RenderDeviceGLImpl*                           pDeviceGL,
+                                              const std::vector<GLPipelineShaderStageInfo>& ShaderStages,
+                                              LinearAllocator&                              MemPool)
+{
     auto& DeviceCaps = pDeviceGL->GetDeviceCaps();
     VERIFY(DeviceCaps.DevType != RENDER_DEVICE_TYPE_UNDEFINED, "Device caps are not initialized");
 
@@ -97,13 +170,13 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCoun
             // Program pipelines are not shared between GL contexts, so we cannot create
             // it now
             m_ShaderResourceLayoutHash = 0;
-            m_ProgramResources.resize(ShaderStages.size());
-            m_GLPrograms.reserve(ShaderStages.size());
+            m_GLPrograms               = MemPool.Allocate<GLProgramObj>(ShaderStages.size());
+            m_ProgramResources         = MemPool.ConstructArray<GLProgramResources>(ShaderStages.size());
             for (size_t i = 0; i < ShaderStages.size(); ++i)
             {
                 auto*       pShaderGL  = ShaderStages[i].pShader;
                 const auto& ShaderDesc = pShaderGL->GetDesc();
-                m_GLPrograms.emplace_back(ShaderGLImpl::LinkProgram(&pShaderGL, 1, true));
+                new (m_GLPrograms + i) GLProgramObj{ShaderGLImpl::LinkProgram(&pShaderGL, 1, true)};
                 // Load uniforms and assign bindings
                 m_ProgramResources[i].LoadUniforms(ShaderDesc.ShaderType, m_GLPrograms[i], GLState,
                                                    m_TotalUniformBufferBindings,
@@ -126,8 +199,9 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCoun
                 ActiveStages |= Stage.Type;
             }
 
-            m_GLPrograms.emplace_back(ShaderGLImpl::LinkProgram(Shaders.data(), static_cast<Uint32>(ShaderStages.size()), false));
-            m_ProgramResources.resize(1);
+            m_GLPrograms       = MemPool.Construct<GLProgramObj>(ShaderGLImpl::LinkProgram(Shaders.data(), static_cast<Uint32>(ShaderStages.size()), false));
+            m_ProgramResources = MemPool.Construct<GLProgramResources>();
+
             m_ProgramResources[0].LoadUniforms(ActiveStages, m_GLPrograms[0], GLState,
                                                m_TotalUniformBufferBindings,
                                                m_TotalSamplerBindings,
@@ -138,10 +212,10 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCoun
         }
 
         // Initialize master resource layout that keeps all variable types and does not reference a resource cache
-        m_ResourceLayout.Initialize(m_ProgramResources.data(), static_cast<Uint32>(m_GLPrograms.size()), m_Desc.PipelineType, m_Desc.ResourceLayout, nullptr, 0, nullptr);
+        m_ResourceLayout.Initialize(m_ProgramResources, static_cast<Uint32>(ShaderStages.size()), m_Desc.PipelineType, m_Desc.ResourceLayout, nullptr, 0, nullptr);
     }
 
-    m_StaticSamplers.resize(m_Desc.ResourceLayout.NumStaticSamplers);
+    m_StaticSamplers = MemPool.ConstructArray<SamplerPtr>(m_Desc.ResourceLayout.NumStaticSamplers);
     for (Uint32 s = 0; s < m_Desc.ResourceLayout.NumStaticSamplers; ++s)
     {
         pDeviceGL->CreateSampler(m_Desc.ResourceLayout.StaticSamplers[s].Desc, &m_StaticSamplers[s]);
@@ -150,26 +224,16 @@ PipelineStateGLImpl::PipelineStateGLImpl(IReferenceCounters*            pRefCoun
     {
         // Clone only static variables into static resource layout, assign and initialize static resource cache
         const SHADER_RESOURCE_VARIABLE_TYPE StaticVars[] = {SHADER_RESOURCE_VARIABLE_TYPE_STATIC};
-        m_StaticResourceLayout.Initialize(m_ProgramResources.data(), static_cast<Uint32>(m_GLPrograms.size()), m_Desc.PipelineType, m_Desc.ResourceLayout, StaticVars, _countof(StaticVars), &m_StaticResourceCache);
+        m_StaticResourceLayout.Initialize(m_ProgramResources, static_cast<Uint32>(ShaderStages.size()), m_Desc.PipelineType, m_Desc.ResourceLayout, StaticVars, _countof(StaticVars), &m_StaticResourceCache);
         InitStaticSamplersInResourceCache(m_StaticResourceLayout, m_StaticResourceCache);
     }
 }
 
-
-PipelineStateGLImpl::~PipelineStateGLImpl()
-{
-    m_StaticResourceCache.Destroy(GetRawAllocator());
-    GetDevice()->OnDestroyPSO(this);
-}
-
-IMPLEMENT_QUERY_INTERFACE(PipelineStateGLImpl, IID_PipelineStateGL, TPipelineStateBase)
-
-
 void PipelineStateGLImpl::CreateShaderResourceBinding(IShaderResourceBinding** ppShaderResourceBinding, bool InitStaticResources)
 {
     auto* pRenderDeviceGL = GetDevice();
     auto& SRBAllocator    = pRenderDeviceGL->GetSRBAllocator();
-    auto  pResBinding     = NEW_RC_OBJ(SRBAllocator, "ShaderResourceBindingGLImpl instance", ShaderResourceBindingGLImpl)(this, m_ProgramResources.data(), static_cast<Uint32>(m_ProgramResources.size()));
+    auto  pResBinding     = NEW_RC_OBJ(SRBAllocator, "ShaderResourceBindingGLImpl instance", ShaderResourceBindingGLImpl)(this, m_ProgramResources, GetNumShaderStages());
     if (InitStaticResources)
         pResBinding->InitializeStaticResources(this);
     pResBinding->QueryInterface(IID_ShaderResourceBinding, reinterpret_cast<IObject**>(ppShaderResourceBinding));
@@ -186,10 +250,10 @@ bool PipelineStateGLImpl::IsCompatibleWith(const IPipelineState* pPSO) const
     if (m_ShaderResourceLayoutHash != pPSOGL->m_ShaderResourceLayoutHash)
         return false;
 
-    if (m_ProgramResources.size() != pPSOGL->m_ProgramResources.size())
+    if (GetNumShaderStages() != pPSOGL->GetNumShaderStages())
         return false;
 
-    for (size_t i = 0; i < m_ProgramResources.size(); ++i)
+    for (size_t i = 0; i < GetNumShaderStages(); ++i)
     {
         if (!m_ProgramResources[i].IsCompatibleWith(pPSOGL->m_ProgramResources[i]))
             return false;
@@ -214,7 +278,7 @@ void PipelineStateGLImpl::CommitProgram(GLContextState& State)
     }
     else
     {
-        VERIFY_EXPR(m_GLPrograms.size() == 1);
+        VERIFY_EXPR(m_GLPrograms != nullptr);
         State.SetProgram(m_GLPrograms[0]);
     }
 }
diff --git a/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp
index 466f1387..59b4bdfd 100644
--- a/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp
@@ -696,13 +696,20 @@ void RenderDeviceGLImpl::CreateSampler(const SamplerDesc& SamplerDesc, ISampler*
     CreateSampler(SamplerDesc, ppSampler, false);
 }
 
-
-void RenderDeviceGLImpl::CreatePipelineState(const PipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState)
+void RenderDeviceGLImpl::CreateGraphicsPipelineState(const GraphicsPipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState, bool bIsDeviceInternal)
 {
-    CreatePipelineState(PSOCreateInfo, ppPipelineState, false);
+    CreateDeviceObject(
+        "Pipeline state", PSOCreateInfo.PSODesc, ppPipelineState,
+        [&]() //
+        {
+            PipelineStateGLImpl* pPipelineStateOGL(NEW_RC_OBJ(m_PSOAllocator, "PipelineStateGLImpl instance", PipelineStateGLImpl)(this, PSOCreateInfo, bIsDeviceInternal));
+            pPipelineStateOGL->QueryInterface(IID_PipelineState, reinterpret_cast<IObject**>(ppPipelineState));
+            OnCreateDeviceObject(pPipelineStateOGL);
+        } //
+    );
 }
 
-void RenderDeviceGLImpl::CreatePipelineState(const PipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState, bool bIsDeviceInternal)
+void RenderDeviceGLImpl::CreateComputePipelineState(const ComputePipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState, bool bIsDeviceInternal)
 {
     CreateDeviceObject(
         "Pipeline state", PSOCreateInfo.PSODesc, ppPipelineState,
@@ -715,6 +722,16 @@ void RenderDeviceGLImpl::CreatePipelineState(const PipelineStateCreateInfo& PSOC
     );
 }
 
+void RenderDeviceGLImpl::CreateGraphicsPipelineState(const GraphicsPipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState)
+{
+    return CreateGraphicsPipelineState(PSOCreateInfo, ppPipelineState, false);
+}
+
+void RenderDeviceGLImpl::CreateComputePipelineState(const ComputePipelineStateCreateInfo& PSOCreateInfo, IPipelineState** ppPipelineState)
+{
+    return CreateComputePipelineState(PSOCreateInfo, ppPipelineState, false);
+}
+
 void RenderDeviceGLImpl::CreateFence(const FenceDesc& Desc, IFence** ppFence)
 {
     CreateDeviceObject(
diff --git a/Graphics/GraphicsEngineOpenGL/src/TexRegionRender.cpp b/Graphics/GraphicsEngineOpenGL/src/TexRegionRender.cpp
index bd47e4ac..1a9c99c0 100644
--- a/Graphics/GraphicsEngineOpenGL/src/TexRegionRender.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/TexRegionRender.cpp
@@ -105,16 +105,15 @@ TexRegionRender::TexRegionRender(class RenderDeviceGLImpl* pDeviceGL)
     CBDesc.CPUAccessFlags = CPU_ACCESS_WRITE;
     pDeviceGL->CreateBuffer(CBDesc, nullptr, &m_pConstantBuffer, IsInternalDeviceObject);
 
-    PipelineStateCreateInfo PSOCreateInfo;
-    PipelineStateDesc&      PSODesc = PSOCreateInfo.PSODesc;
+    GraphicsPipelineStateCreateInfo PSOCreateInfo;
 
-    auto& GraphicsPipeline                   = PSODesc.GraphicsPipeline;
+    auto& GraphicsPipeline                   = PSOCreateInfo.GraphicsPipeline;
     GraphicsPipeline.RasterizerDesc.CullMode = CULL_MODE_NONE;
     GraphicsPipeline.RasterizerDesc.FillMode = FILL_MODE_SOLID;
 
     GraphicsPipeline.DepthStencilDesc.DepthEnable      = False;
     GraphicsPipeline.DepthStencilDesc.DepthWriteEnable = False;
-    GraphicsPipeline.pVS                               = m_pVertexShader;
+    PSOCreateInfo.pVS                                  = m_pVertexShader;
     GraphicsPipeline.PrimitiveTopology                 = PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 
     static const char* CmpTypePrefix[3] = {"", "i", "u"};
@@ -150,17 +149,17 @@ TexRegionRender::TexRegionRender(class RenderDeviceGLImpl* pDeviceGL)
             ShaderAttrs.Source  = Source.c_str();
             auto& FragmetShader = m_pFragmentShaders[Dim * 3 + Fmt];
             pDeviceGL->CreateShader(ShaderAttrs, &FragmetShader, IsInternalDeviceObject);
-            GraphicsPipeline.pPS = FragmetShader;
+            PSOCreateInfo.pPS = FragmetShader;
 
-            PSODesc.ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC;
+            PSOCreateInfo.PSODesc.ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC;
             ShaderResourceVariableDesc Vars[] =
                 {
                     {SHADER_TYPE_PIXEL, "cbConstants", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE} //
                 };
-            PSODesc.ResourceLayout.NumVariables = _countof(Vars);
-            PSODesc.ResourceLayout.Variables    = Vars;
+            PSOCreateInfo.PSODesc.ResourceLayout.NumVariables = _countof(Vars);
+            PSOCreateInfo.PSODesc.ResourceLayout.Variables    = Vars;
 
-            pDeviceGL->CreatePipelineState(PSOCreateInfo, &m_pPSO[Dim * 3 + Fmt], IsInternalDeviceObject);
+            pDeviceGL->CreateGraphicsPipelineState(PSOCreateInfo, &m_pPSO[Dim * 3 + Fmt], IsInternalDeviceObject);
         }
     }
     m_pPSO[RESOURCE_DIM_TEX_2D * 3]->CreateShaderResourceBinding(&m_pSRB);
diff --git a/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp b/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp
index 8838b968..acb22e2a 100644
--- a/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp
+++ b/Graphics/GraphicsEngineOpenGL/src/VAOCache.cpp
@@ -93,7 +93,7 @@ const GLObjectWrappers::GLVertexArrayObj& VAOCache::GetVAO(IPipelineState*
     // Get layout
     auto*                pPSOGL         = ValidatedCast<PipelineStateGLImpl>(pPSO);
     auto*                pIndexBufferGL = ValidatedCast<BufferGLImpl>(pIndexBuffer);
-    const auto&          InputLayout    = pPSOGL->GetDesc().GraphicsPipeline.InputLayout;
+    const auto&          InputLayout    = pPSOGL->GetGraphicsPipelineDesc().InputLayout;
     const LayoutElement* LayoutElems    = InputLayout.LayoutElements;
     Uint32               NumElems       = InputLayout.NumElements;
     // Construct the key