Refactored overloaded IPipelineState::GetStaticShaderVariable and IShaderResourceBinding::GetVariable

12 files changed, 223 insertions, 223 deletions

diff --git a/DiligentCore b/DiligentCore
-Subproject ca7a18dbfac209b5b8d0d4ea01d17e06c7bcc68
+Subproject 00de719d9f6d1a099fe9d8c67ceae1ccdc013e5
diff --git a/DiligentFX b/DiligentFX
-Subproject 5cac241f218877e50a8d6a964cd83c58dfb5d84
+Subproject 072d2e091a691f5f4b98510eae1d7f9b4097d1f
diff --git a/DiligentSamples b/DiligentSamples
-Subproject eb9f62fa7602b737d581c461566c840d1d9e5b0
+Subproject a21905ac6a26200e97cba6d31ae53831e65a118
diff --git a/DiligentTools b/DiligentTools
-Subproject e7b12030bd0f8084432a7c38d6f48d57f0bc968
+Subproject d6d73dd8e7f98f6591f93b7ecda08b34cce518e
diff --git a/Projects/Asteroids/src/asteroids_DE.cpp b/Projects/Asteroids/src/asteroids_DE.cpp
index c87d488..cbbf3a6 100644
--- a/Projects/Asteroids/src/asteroids_DE.cpp
+++ b/Projects/Asteroids/src/asteroids_DE.cpp
@@ -319,7 +319,7 @@ Asteroids::Asteroids(const Settings &settings, AsteroidsSimulation* asteroids, G
             NumSRBs = NUM_UNIQUE_TEXTURES;
         }
         mDevice->CreatePipelineState(PSODesc, &mAsteroidsPSO);
-        mAsteroidsPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "DrawConstantBuffer")->Set(mDrawConstantBuffer);
+        mAsteroidsPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "DrawConstantBuffer")->Set(mDrawConstantBuffer);
 
         mAsteroidsSRBs.resize(NumSRBs);
         for(size_t srb = 0; srb < mAsteroidsSRBs.size(); ++srb)
@@ -405,8 +405,8 @@ Asteroids::Asteroids(const Settings &settings, AsteroidsSimulation* asteroids, G
         PSODesc.GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 
         mDevice->CreatePipelineState(PSODesc, &mSkyboxPSO);
-        mSkyboxPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "SkyboxConstantBuffer")->Set(mSkyboxConstantBuffer);
-        mSkyboxPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "Skybox")->Set(mSkyboxSRV);
+        mSkyboxPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "SkyboxConstantBuffer")->Set(mSkyboxConstantBuffer);
+        mSkyboxPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "Skybox")->Set(mSkyboxSRV);
         mSkyboxPSO->CreateShaderResourceBinding(&mSkyboxSRB, true);
     }
 
@@ -503,7 +503,7 @@ Asteroids::Asteroids(const Settings &settings, AsteroidsSimulation* asteroids, G
         PSODesc.ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_STATIC;
         PSODesc.GraphicsPipeline.pPS = font_ps;
         mDevice->CreatePipelineState(PSODesc, &mFontPSO);
-        mFontPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "Tex")->Set(mFontTextureSRV);
+        mFontPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "Tex")->Set(mFontTextureSRV);
         mFontPSO->CreateShaderResourceBinding(&mFontSRB, true);
     }
 
@@ -515,14 +515,14 @@ Asteroids::Asteroids(const Settings &settings, AsteroidsSimulation* asteroids, G
         for(size_t srb = 0; srb < NUM_ASTEROIDS; ++srb)
         {
             auto staticData = &mAsteroids->StaticData()[srb];
-            mAsteroidsSRBs[srb]->GetVariable(SHADER_TYPE_PIXEL, "Tex")->Set(mTextureSRVs[staticData->textureIndex]);
+            mAsteroidsSRBs[srb]->GetVariableByName(SHADER_TYPE_PIXEL, "Tex")->Set(mTextureSRVs[staticData->textureIndex]);
         }
     }
     else if( m_BindingMode == BindingMode::TextureMutable )
     {
         for(size_t srb = 0; srb < NUM_UNIQUE_TEXTURES; ++srb)
         {
-            mAsteroidsSRBs[srb]->GetVariable(SHADER_TYPE_PIXEL, "Tex")->Set(mTextureSRVs[srb]);
+            mAsteroidsSRBs[srb]->GetVariableByName(SHADER_TYPE_PIXEL, "Tex")->Set(mTextureSRVs[srb]);
         }
     }
     mDeviceCtxt->TransitionResourceStates(static_cast<Uint32>(Barriers.size()), Barriers.data());
@@ -755,7 +755,7 @@ void Asteroids::RenderSubset(Diligent::Uint32 SubsetNum,
         pCtx->SetIndexBuffer(mIndexBuffer, 0, RESOURCE_STATE_TRANSITION_MODE_VERIFY);
     }
 
-    auto pVar = m_BindingMode == BindingMode::Dynamic ? mAsteroidsSRBs[SubsetNum]->GetVariable(SHADER_TYPE_PIXEL, "Tex") : nullptr;
+    auto pVar = m_BindingMode == BindingMode::Dynamic ? mAsteroidsSRBs[SubsetNum]->GetVariableByName(SHADER_TYPE_PIXEL, "Tex") : nullptr;
     auto viewProjection = camera.ViewProjection();
     for (UINT drawIdx = startIdx; drawIdx < startIdx+numAsteroids; ++drawIdx)
     {
@@ -918,7 +918,7 @@ void Asteroids::Render(float frameTime, const OrbitCamera& camera, const Setting
                 } else { // Sprite
                     auto textureSRV = mSpriteTextures[control->TextureFile()];
                     mDeviceCtxt->SetPipelineState(mSpritePSO);
-                    mSpriteSRB->GetVariable(SHADER_TYPE_PIXEL, "Tex")->Set(textureSRV);
+                    mSpriteSRB->GetVariableByName(SHADER_TYPE_PIXEL, "Tex")->Set(textureSRV);
                     mDeviceCtxt->CommitShaderResources(mSpriteSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
                 }
                 DrawAttribs DrawAttrs(controlVertices[1+i], DRAW_FLAG_VERIFY_STATES);
diff --git a/Tests/TestApp/assets/TestComputeShaders.lua b/Tests/TestApp/assets/TestComputeShaders.lua
index e999752..aee1514 100644
--- a/Tests/TestApp/assets/TestComputeShaders.lua
+++ b/Tests/TestApp/assets/TestComputeShaders.lua
@@ -333,7 +333,7 @@ function Draw()
 end
 
 
-tex2DTestUAV = FillTextureSRB:GetVariable("SHADER_TYPE_COMPUTE", "g_tex2DTestUAV")
+tex2DTestUAV = FillTextureSRB:GetVariableByName("SHADER_TYPE_COMPUTE", "g_tex2DTestUAV")
 
 function Dispatch()
 
diff --git a/Tests/TestApp/src/TestSeparateTextureSampler.cpp b/Tests/TestApp/src/TestSeparateTextureSampler.cpp
index 0bbbce4..46e6411 100644
--- a/Tests/TestApp/src/TestSeparateTextureSampler.cpp
+++ b/Tests/TestApp/src/TestSeparateTextureSampler.cpp
@@ -124,25 +124,25 @@ TestSeparateTextureSampler::TestSeparateTextureSampler(IRenderDevice *pDevice, I
         RefCntAutoPtr<ISampler> pSampler;
         pDevice->CreateSampler( SamplerDesc{}, &pSampler );
         IDeviceObject* ppSamplers[2] = {pSampler, pSampler};
-        pPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_Sam3")->SetArray(ppSamplers, 0, 2);
+        pPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_Sam3")->SetArray(ppSamplers, 0, 2);
 
         RefCntAutoPtr<IShaderResourceBinding> pSRB;
         pPSO->CreateShaderResourceBinding(&pSRB, true);
 
-        pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Tex")->Set(pTexture->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE));
-        pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Sam")->Set(pSampler);
-        pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Sam4")->SetArray(ppSamplers, 0, 2);
-        pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Tex2")->Set(pTexture->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE));
-        VERIFY_EXPR(pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Sam2") == nullptr);
+        pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Tex")->Set(pTexture->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE));
+        pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Sam")->Set(pSampler);
+        pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Sam4")->SetArray(ppSamplers, 0, 2);
+        pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Tex2")->Set(pTexture->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE));
+        VERIFY_EXPR(pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Sam2") == nullptr);
 
         auto VarCount = pSRB->GetVariableCount(SHADER_TYPE_PIXEL);
         VERIFY_EXPR(VarCount == 4);
         for(Uint32 v=0; v < VarCount; ++v)
         {
-            auto* pVar = pSRB->GetVariable(SHADER_TYPE_PIXEL, v);
+            auto* pVar = pSRB->GetVariableByIndex(SHADER_TYPE_PIXEL, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
-            auto pVar2 = pSRB->GetVariable(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
+            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
 
diff --git a/Tests/TestApp/src/TestShaderResArrays.cpp b/Tests/TestApp/src/TestShaderResArrays.cpp
index 33e259f..28c5c70 100644
--- a/Tests/TestApp/src/TestShaderResArrays.cpp
+++ b/Tests/TestApp/src/TestShaderResArrays.cpp
@@ -168,19 +168,19 @@ TestShaderResArrays::TestShaderResArrays(IRenderDevice *pDevice, IDeviceContext
     //pVS->BindResources(m_pResourceMapping, 0);
     IDeviceObject *ppSRVs[] = {m_pTextures[3]->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE)};
     m_pPSO->BindStaticResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, pResMapping, BIND_SHADER_RESOURCES_KEEP_EXISTING);
-    m_pPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2DTest2")->SetArray( ppSRVs, 1, 1);
+    m_pPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2DTest2")->SetArray( ppSRVs, 1, 1);
 
     m_pSRB->InitializeStaticResources();
     m_pSRB->BindResources(SHADER_TYPE_PIXEL, pResMapping, BIND_SHADER_RESOURCES_KEEP_EXISTING | BIND_SHADER_RESOURCES_UPDATE_MUTABLE | BIND_SHADER_RESOURCES_UPDATE_DYNAMIC);
     ppSRVs[0] = m_pTextures[4]->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
-    m_pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2DTest")->SetArray(ppSRVs, 3, 1);
+    m_pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2DTest")->SetArray(ppSRVs, 3, 1);
 }
     
 void TestShaderResArrays::Draw()
 {
     m_pDeviceContext->SetPipelineState(m_pPSO);
     IDeviceObject *ppSRVs[] = {m_pTextures[7]->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE)};
-    m_pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D")->SetArray(ppSRVs, 1, 1);
+    m_pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D")->SetArray(ppSRVs, 1, 1);
 
     m_pDeviceContext->CommitShaderResources(m_pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
     
diff --git a/Tests/TestApp/src/TestShaderResourceLayout.cpp b/Tests/TestApp/src/TestShaderResourceLayout.cpp
index c6d2194..63b8ddc 100644
--- a/Tests/TestApp/src/TestShaderResourceLayout.cpp
+++ b/Tests/TestApp/src/TestShaderResourceLayout.cpp
@@ -272,59 +272,59 @@ TestShaderResourceLayout::TestShaderResourceLayout( IRenderDevice *pDevice, IDev
     VERIFY_EXPR(pTestPSO);
 
     {
-        //pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Static")->Set(pSRVs[0]);
-        //pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2DArr_Static")->SetArray(pSRVs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_sepTex2D_static")->Set(pSRVs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_sepTex2DArr_static")->SetArray(pSRVs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_SamArr_static")->SetArray(pSams, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "UniformBuff_Stat")->Set(pUBs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "UniformBuffArr_Stat")->SetArray(pUBs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "storageBuff_Static")->Set(pSBUAVs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "storageBuffArr_Static")->SetArray(pSBUAVs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2DStorageImg_Stat")->Set(pUAVs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_UniformTexelBuff")->Set(pUniformTexelBuffSRV);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_StorageTexelBuff")->Set(pStorageTexelBuffUAV);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Mut");
-        auto* pStaticSam = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_Sam_static");
+        //pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Static")->Set(pSRVs[0]);
+        //pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2DArr_Static")->SetArray(pSRVs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2D_static")->Set(pSRVs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2DArr_static")->SetArray(pSRVs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_SamArr_static")->SetArray(pSams, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Stat")->Set(pUBs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "UniformBuffArr_Stat")->SetArray(pUBs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "storageBuff_Static")->Set(pSBUAVs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "storageBuffArr_Static")->SetArray(pSBUAVs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2DStorageImg_Stat")->Set(pUAVs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_UniformTexelBuff")->Set(pUniformTexelBuffSRV);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_StorageTexelBuff")->Set(pStorageTexelBuffUAV);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Mut");
+        auto* pStaticSam = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_Sam_static");
         VERIFY_EXPR(pStaticSam == nullptr);
         
 
         auto NumVSVars = pTestPSO->GetStaticVariableCount(SHADER_TYPE_VERTEX);
         for(Uint32 v=0; v < NumVSVars; ++v)
         {
-            auto pVar = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, v);
+            auto pVar = pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_VERTEX, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
-            auto pVar2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
+            auto pVar2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
 
     {
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_Static")->Set(pSRVs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2DArr_Static")->SetArray(pSRVs, 0, 2);
-        //pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_sepTex2D_static")->Set(pSRVs[0]);
-        //pTestPSO->GetStaticShaderVariables(SHADER_TYPE_PIXEL, "g_sepTex2DArr_static")->SetArray(pSRVs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_SamArr_static")->SetArray(pSams, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "UniformBuff_Stat")->Set(pUBs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "UniformBuffArr_Stat")->SetArray(pUBs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "storageBuff_Static")->Set(pSBUAVs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "storageBuffArr_Static")->SetArray(pSBUAVs, 0, 2);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2DStorageImg_Stat")->Set(pUAVs[0]);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_UniformTexelBuff")->Set(pUniformTexelBuffSRV);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_StorageTexelBuff")->Set(pStorageTexelBuffUAV);
-        pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "storageBuff_Dyn");
-        auto* pStaticSam = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_Sam_static");
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Static")->Set(pSRVs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2DArr_Static")->SetArray(pSRVs, 0, 2);
+        //pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_sepTex2D_static")->Set(pSRVs[0]);
+        //pTestPSO->GetStaticVariableByNames(SHADER_TYPE_PIXEL, "g_sepTex2DArr_static")->SetArray(pSRVs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_SamArr_static")->SetArray(pSams, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Stat")->Set(pUBs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "UniformBuffArr_Stat")->SetArray(pUBs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "storageBuff_Static")->Set(pSBUAVs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "storageBuffArr_Static")->SetArray(pSBUAVs, 0, 2);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2DStorageImg_Stat")->Set(pUAVs[0]);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_UniformTexelBuff")->Set(pUniformTexelBuffSRV);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_StorageTexelBuff")->Set(pStorageTexelBuffUAV);
+        pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "storageBuff_Dyn");
+        auto* pStaticSam = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_Sam_static");
         VERIFY_EXPR(pStaticSam == nullptr);
 
 
         auto NumPSVars = pTestPSO->GetStaticVariableCount(SHADER_TYPE_PIXEL);
         for(Uint32 v=0; v < NumPSVars; ++v)
         {
-            auto pVar = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, v);
+            auto pVar = pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_PIXEL, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
-            auto pVar2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
+            auto pVar2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
@@ -334,69 +334,69 @@ TestShaderResourceLayout::TestShaderResourceLayout( IRenderDevice *pDevice, IDev
     RefCntAutoPtr<IShaderResourceBinding> pSRB;
     pTestPSO->CreateShaderResourceBinding(&pSRB, true);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuff_Stat");
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_sepTex2DArr_static");
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Stat");
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_sepTex2DArr_static");
     LOG_INFO_MESSAGE("The above 2 errors about missing shader resources are part of the test");
 
-    //pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Mut")->Set(pSRVs[0]);
-    //pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2DArr_Mut")->SetArray(pSRVs, 0, 3);
-    //pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Dyn")->Set(pSRVs[0]);
-    //pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2DArr_Dyn")->SetArray(pSRVs, 0, 4);
+    //pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Mut")->Set(pSRVs[0]);
+    //pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2DArr_Mut")->SetArray(pSRVs, 0, 3);
+    //pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Dyn")->Set(pSRVs[0]);
+    //pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2DArr_Dyn")->SetArray(pSRVs, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_sepTex2D_mut")->Set(pSRVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_sepTex2DArr_mut")->SetArray(pSRVs, 0, 3);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_sepTex2D_dyn")->Set(pSRVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_sepTex2DArr_dyn")->SetArray(pSRVs, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2D_mut")->Set(pSRVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2DArr_mut")->SetArray(pSRVs, 0, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2D_dyn")->Set(pSRVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2DArr_dyn")->SetArray(pSRVs, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_Sam_mut")->Set(pSams[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_SamArr_dyn")->SetArray(pSams, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_Sam_mut")->Set(pSams[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_SamArr_dyn")->SetArray(pSams, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuff_Mut")->Set(pUBs[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuffArr_Mut")->SetArray(pUBs, 0, 3);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuff_Dyn")->Set(pUBs[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuffArr_Dyn")->SetArray(pUBs, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Mut")->Set(pUBs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuffArr_Mut")->SetArray(pUBs, 0, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Dyn")->Set(pUBs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuffArr_Dyn")->SetArray(pUBs, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "storageBuff_Mut")->Set(pSBUAVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "storageBuffArr_Mut")->SetArray(pSBUAVs, 0, 3);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "storageBuff_Dyn")->Set(pSBUAVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "storageBuffArr_Dyn")->SetArray(pSBUAVs, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "storageBuff_Mut")->Set(pSBUAVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "storageBuffArr_Mut")->SetArray(pSBUAVs, 0, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "storageBuff_Dyn")->Set(pSBUAVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "storageBuffArr_Dyn")->SetArray(pSBUAVs, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2DStorageImgArr_Mut")->SetArray(pUAVs, 0, 2);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2DStorageImgArr_Dyn")->SetArray(pUAVs, 0, 2);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2DStorageImgArr_Mut")->SetArray(pUAVs, 0, 2);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2DStorageImgArr_Dyn")->SetArray(pUAVs, 0, 2);
 
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_UniformTexelBuff_mut")->Set(pUniformTexelBuffSRV);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_StorageTexelBuff_mut")->Set(pStorageTexelBuffUAV);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_UniformTexelBuff_mut")->Set(pUniformTexelBuffSRV);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_StorageTexelBuff_mut")->Set(pStorageTexelBuffUAV);
 
     
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Mut")->Set(pSRVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2DArr_Mut")->SetArray(pSRVs, 0, 3);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Dyn")->Set(pSRVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2DArr_Dyn")->SetArray(pSRVs, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Mut")->Set(pSRVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2DArr_Mut")->SetArray(pSRVs, 0, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Dyn")->Set(pSRVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2DArr_Dyn")->SetArray(pSRVs, 0, 4);
 
     //pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_sepTex2D_mut")->Set(pSRVs[0]);
     //pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_sepTex2DArr_mut")->SetArray(pSRVs, 0, 3);
     //pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_sepTex2D_dyn")->Set(pSRVs[0]);
     //pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_sepTex2DArr_dyn")->SetArray(pSRVs, 0, 4);
     
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Sam_mut")->Set(pSams[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_SamArr_dyn")->SetArray(pSams, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Sam_mut")->Set(pSams[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_SamArr_dyn")->SetArray(pSams, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuff_Mut")->Set(pUBs[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuffArr_Mut")->SetArray(pUBs, 0, 3);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuff_Dyn")->Set(pUBs[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuffArr_Dyn")->SetArray(pUBs, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Mut")->Set(pUBs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuffArr_Mut")->SetArray(pUBs, 0, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Dyn")->Set(pUBs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuffArr_Dyn")->SetArray(pUBs, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "storageBuff_Mut")->Set(pSBUAVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "storageBuffArr_Mut")->SetArray(pSBUAVs, 0, 3);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "storageBuff_Dyn")->Set(pSBUAVs[0]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "storageBuffArr_Dyn")->SetArray(pSBUAVs, 0, 4);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "storageBuff_Mut")->Set(pSBUAVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "storageBuffArr_Mut")->SetArray(pSBUAVs, 0, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "storageBuff_Dyn")->Set(pSBUAVs[0]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "storageBuffArr_Dyn")->SetArray(pSBUAVs, 0, 4);
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2DStorageImgArr_Mut")->SetArray(pUAVs, 0, 2);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2DStorageImgArr_Dyn")->SetArray(pUAVs, 0, 2);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2DStorageImgArr_Mut")->SetArray(pUAVs, 0, 2);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2DStorageImgArr_Dyn")->SetArray(pUAVs, 0, 2);
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_UniformTexelBuff_mut")->Set(pUniformTexelBuffSRV);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_StorageTexelBuff_mut")->Set(pStorageTexelBuffUAV);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_UniformTexelBuff_mut")->Set(pUniformTexelBuffSRV);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_StorageTexelBuff_mut")->Set(pStorageTexelBuffUAV);
 
     pSRB->BindResources(SHADER_TYPE_PIXEL | SHADER_TYPE_VERTEX, pResMapping, BIND_SHADER_RESOURCES_KEEP_EXISTING | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED | BIND_SHADER_RESOURCES_UPDATE_MUTABLE | BIND_SHADER_RESOURCES_UPDATE_DYNAMIC);
 
@@ -406,12 +406,12 @@ TestShaderResourceLayout::TestShaderResourceLayout( IRenderDevice *pDevice, IDev
     DrawAttribs DrawAttrs(3, DRAW_FLAG_VERIFY_STATES);
     pContext->Draw(DrawAttrs);
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "storageBuff_Dyn")->Set(pSBUAVs[1]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Dyn")->Set(pSRVs[1]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_sepTex2D_dyn")->Set(pSRVs[1]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_SamArr_dyn")->SetArray(pSams+1, 1, 3);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuff_Dyn")->Set(pUBs[1]);
-    pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2DStorageImgArr_Dyn")->SetArray(pUAVs+1, 1, 1);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "storageBuff_Dyn")->Set(pSBUAVs[1]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Dyn")->Set(pSRVs[1]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_sepTex2D_dyn")->Set(pSRVs[1]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_SamArr_dyn")->SetArray(pSams+1, 1, 3);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Dyn")->Set(pUBs[1]);
+    pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2DStorageImgArr_Dyn")->SetArray(pUAVs+1, 1, 1);
     pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
     pContext->Draw(DrawAttrs);
 
@@ -419,10 +419,10 @@ TestShaderResourceLayout::TestShaderResourceLayout( IRenderDevice *pDevice, IDev
         auto NumVSVars = pSRB->GetVariableCount(SHADER_TYPE_VERTEX);
         for(Uint32 v=0; v < NumVSVars; ++v)
         {
-            auto pVar = pSRB->GetVariable(SHADER_TYPE_VERTEX, v);
+            auto pVar = pSRB->GetVariableByIndex(SHADER_TYPE_VERTEX, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
-            auto pVar2 = pSRB->GetVariable(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
+            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
@@ -431,10 +431,10 @@ TestShaderResourceLayout::TestShaderResourceLayout( IRenderDevice *pDevice, IDev
         auto NumPSVars = pSRB->GetVariableCount(SHADER_TYPE_PIXEL);
         for(Uint32 v=0; v < NumPSVars; ++v)
         {
-            auto pVar = pSRB->GetVariable(SHADER_TYPE_PIXEL, v);
+            auto pVar = pSRB->GetVariableByIndex(SHADER_TYPE_PIXEL, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
-            auto pVar2 = pSRB->GetVariable(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
+            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
diff --git a/Tests/TestApp/src/TestShaderVarAccess.cpp b/Tests/TestApp/src/TestShaderVarAccess.cpp
index 8e2a440..4dd46b3 100644
--- a/Tests/TestApp/src/TestShaderVarAccess.cpp
+++ b/Tests/TestApp/src/TestShaderVarAccess.cpp
@@ -276,61 +276,61 @@ TestShaderVarAccess::TestShaderVarAccess( IRenderDevice *pDevice, IDeviceContext
     {
         VERIFY_EXPR(pTestPSO->GetStaticVariableCount(SHADER_TYPE_VERTEX) == 6);
         
-        auto tex2D_Static = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Static");
+        auto tex2D_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Static");
         VERIFY_EXPR(tex2D_Static->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(tex2D_Static == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, tex2D_Static->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_Static == pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, tex2D_Static->GetResourceDesc().Name));
         tex2D_Static->Set(pSRVs[0]);
 
-        auto tex2D_Static_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Static_sampler");
+        auto tex2D_Static_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Static_sampler");
         VERIFY_EXPR(tex2D_Static_sampler == nullptr);
 
-        auto tex2D_StaticArr = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_StaticArr");
+        auto tex2D_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_StaticArr");
         VERIFY_EXPR(tex2D_StaticArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(tex2D_StaticArr == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, tex2D_StaticArr->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_StaticArr == pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, tex2D_StaticArr->GetResourceDesc().Name));
         tex2D_StaticArr->SetArray(pSRVs, 0, 2);
 
-        auto tex2D_StaticArr_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_StaticArr_sampler");
+        auto tex2D_StaticArr_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_StaticArr_sampler");
         VERIFY_EXPR(tex2D_StaticArr_sampler == nullptr);
 
-        auto UniformBuff_Stat = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "UniformBuff_Stat");
+        auto UniformBuff_Stat = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Stat");
         VERIFY_EXPR(UniformBuff_Stat->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Stat == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, UniformBuff_Stat->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Stat == pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, UniformBuff_Stat->GetResourceDesc().Name));
         UniformBuff_Stat->Set(pUBs[0]);
 
-        auto UniformBuff_Stat2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "UniformBuff_Stat2");
+        auto UniformBuff_Stat2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Stat2");
         VERIFY_EXPR(UniformBuff_Stat2->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Stat2 == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, UniformBuff_Stat2->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Stat2 == pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, UniformBuff_Stat2->GetResourceDesc().Name));
         UniformBuff_Stat2->Set(pUBs[0]);
 
-        auto Buffer_Static = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_Buffer_Static");
+        auto Buffer_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_Buffer_Static");
         VERIFY_EXPR(Buffer_Static->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(Buffer_Static == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, Buffer_Static->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_Static == pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, Buffer_Static->GetResourceDesc().Name));
         Buffer_Static->Set(pFormattedBuffSRV);
 
-        auto Buffer_StaticArr = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_Buffer_StaticArr");
+        auto Buffer_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_Buffer_StaticArr");
         VERIFY_EXPR(Buffer_StaticArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(Buffer_StaticArr == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, Buffer_StaticArr->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_StaticArr == pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, Buffer_StaticArr->GetResourceDesc().Name));
         Buffer_StaticArr->SetArray(&pFormattedBuffSRV,0,1);
         Buffer_StaticArr->SetArray(&pFormattedBuffSRV,1,1);
         
 
-        auto tex2D_Mut = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Mut");
+        auto tex2D_Mut = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Mut");
         VERIFY_EXPR(tex2D_Mut == nullptr);
-        auto tex2D_Dyn = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Dyn");
+        auto tex2D_Dyn = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Dyn");
         VERIFY_EXPR(tex2D_Dyn == nullptr);
-        auto tex2D_Mut_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_Mut_sampler");
+        auto tex2D_Mut_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Mut_sampler");
         VERIFY_EXPR(tex2D_Mut_sampler == nullptr);
-        auto tex2D_Dyn_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "g_tex2D_DynArr_sampler");
+        auto tex2D_Dyn_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_DynArr_sampler");
         VERIFY_EXPR(tex2D_Dyn_sampler == nullptr);
 
 
         auto NumVSVars = pTestPSO->GetStaticVariableCount(SHADER_TYPE_VERTEX);
         for(Uint32 v=0; v < NumVSVars; ++v)
         {
-            auto pVar = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, v);
+            auto pVar = pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_VERTEX, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
-            auto pVar2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
+            auto pVar2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
@@ -339,76 +339,76 @@ TestShaderVarAccess::TestShaderVarAccess( IRenderDevice *pDevice, IDeviceContext
     {
         VERIFY_EXPR(pTestPSO->GetStaticVariableCount(SHADER_TYPE_PIXEL) == 9);
 
-        auto tex2D_Static = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_Static");
+        auto tex2D_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Static");
         VERIFY_EXPR(tex2D_Static->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(tex2D_Static == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, tex2D_Static->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_Static == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, tex2D_Static->GetResourceDesc().Name));
         tex2D_Static->Set(pSRVs[0]);
 
-        auto tex2D_Static_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_Static_sampler");
+        auto tex2D_Static_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Static_sampler");
         VERIFY_EXPR(tex2D_Static_sampler == nullptr);
 
-        auto tex2D_StaticArr = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_StaticArr");
+        auto tex2D_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_StaticArr");
         VERIFY_EXPR(tex2D_StaticArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(tex2D_StaticArr == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, tex2D_StaticArr->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_StaticArr == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, tex2D_StaticArr->GetResourceDesc().Name));
         tex2D_StaticArr->SetArray(pSRVs, 0, 2);
-        auto tex2D_StaticArr_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_StaticArr_sampler");
+        auto tex2D_StaticArr_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_StaticArr_sampler");
         VERIFY_EXPR(tex2D_StaticArr_sampler == nullptr);
         
-        auto UniformBuff_Stat = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "UniformBuff_Stat");
+        auto UniformBuff_Stat = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Stat");
         VERIFY_EXPR(UniformBuff_Stat->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Stat == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, UniformBuff_Stat->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Stat == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, UniformBuff_Stat->GetResourceDesc().Name));
         UniformBuff_Stat->Set(pUBs[0]);
 
-        auto UniformBuff_Stat2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "UniformBuff_Stat2");
+        auto UniformBuff_Stat2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Stat2");
         VERIFY_EXPR(UniformBuff_Stat2->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Stat2 == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, UniformBuff_Stat2->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Stat2 == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, UniformBuff_Stat2->GetResourceDesc().Name));
         UniformBuff_Stat2->Set(pUBs[0]);
 
-        auto Buffer_Static = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_Buffer_Static");
+        auto Buffer_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_Static");
         VERIFY_EXPR(Buffer_Static->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(Buffer_Static == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, Buffer_Static->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_Static == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, Buffer_Static->GetResourceDesc().Name));
         Buffer_Static->Set(pFormattedBuffSRV);
 
-        auto Buffer_StaticArr = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_Buffer_StaticArr");
+        auto Buffer_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_StaticArr");
         VERIFY_EXPR(Buffer_StaticArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(Buffer_StaticArr == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, Buffer_StaticArr->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_StaticArr == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, Buffer_StaticArr->GetResourceDesc().Name));
         Buffer_StaticArr->SetArray(&pFormattedBuffSRV,0,1);
         Buffer_StaticArr->SetArray(&pFormattedBuffSRV,1,1);
         
 
-        auto rwtex2D_Static = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_rwtex2D_Static");
+        auto rwtex2D_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_rwtex2D_Static");
         VERIFY_EXPR(rwtex2D_Static->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwtex2D_Static == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, rwtex2D_Static->GetResourceDesc().Name));
+        VERIFY_EXPR(rwtex2D_Static == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, rwtex2D_Static->GetResourceDesc().Name));
         rwtex2D_Static->Set(pTexUAVs[0]);
 
-        auto rwtex2D_Static2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_rwtex2D_Static2");
+        auto rwtex2D_Static2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_rwtex2D_Static2");
         VERIFY_EXPR(rwtex2D_Static2->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwtex2D_Static2 == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, rwtex2D_Static2->GetResourceDesc().Name));
+        VERIFY_EXPR(rwtex2D_Static2 == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, rwtex2D_Static2->GetResourceDesc().Name));
         rwtex2D_Static2->Set(pTexUAVs[1]);
 
-        auto rwBuff_Static = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_rwBuff_Static");
+        auto rwBuff_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_rwBuff_Static");
         VERIFY_EXPR(rwBuff_Static->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwBuff_Static == pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, rwBuff_Static->GetResourceDesc().Name));
+        VERIFY_EXPR(rwBuff_Static == pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, rwBuff_Static->GetResourceDesc().Name));
         rwBuff_Static->Set(spRawBuffUAV[0]);
 
 
-        auto tex2D_Mut = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_Mut");
+        auto tex2D_Mut = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Mut");
         VERIFY_EXPR(tex2D_Mut == nullptr);
-        auto tex2D_Dyn = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_Dyn");
+        auto tex2D_Dyn = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Dyn");
         VERIFY_EXPR(tex2D_Dyn == nullptr);
-        auto tex2D_Mut_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_Mut_sampler");
+        auto tex2D_Mut_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Mut_sampler");
         VERIFY_EXPR(tex2D_Mut_sampler == nullptr);
-        auto tex2D_Dyn_sampler = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2D_DynArr_sampler");
+        auto tex2D_Dyn_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_DynArr_sampler");
         VERIFY_EXPR(tex2D_Dyn_sampler == nullptr);
 
 
         auto NumPSVars = pTestPSO->GetStaticVariableCount(SHADER_TYPE_PIXEL);
         for(Uint32 v=0; v < NumPSVars; ++v)
         {
-            auto pVar = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, v);
+            auto pVar = pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_PIXEL, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
-            auto pVar2 = pTestPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
+            auto pVar2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
@@ -417,167 +417,167 @@ TestShaderVarAccess::TestShaderVarAccess( IRenderDevice *pDevice, IDeviceContext
     pTestPSO->CreateShaderResourceBinding(&pSRB, true);
 
     {
-        auto tex2D_Mut = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Mut");
+        auto tex2D_Mut = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Mut");
         VERIFY_EXPR(tex2D_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(tex2D_Mut == pSRB->GetVariable(SHADER_TYPE_VERTEX, tex2D_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_Mut == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, tex2D_Mut->GetResourceDesc().Name));
         tex2D_Mut->Set(pSRVs[0]);
 
-        auto tex2D_Mut_sampler = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Mut_sampler");
+        auto tex2D_Mut_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Mut_sampler");
         VERIFY_EXPR(tex2D_Mut_sampler == nullptr);
 
-        auto tex2D_MutArr = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_MutArr");
+        auto tex2D_MutArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_MutArr");
         VERIFY_EXPR(tex2D_MutArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(tex2D_MutArr == pSRB->GetVariable(SHADER_TYPE_VERTEX, tex2D_MutArr->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_MutArr == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, tex2D_MutArr->GetResourceDesc().Name));
         tex2D_MutArr->SetArray(pSRVs, 0, 2);
 
-        auto tex2D_MutArr_sampler = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_MutArr_sampler");
+        auto tex2D_MutArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_MutArr_sampler");
         VERIFY_EXPR(tex2D_MutArr_sampler == nullptr);
 
-        auto tex2D_Dyn = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Dyn");
+        auto tex2D_Dyn = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Dyn");
         VERIFY_EXPR(tex2D_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(tex2D_Dyn == pSRB->GetVariable(SHADER_TYPE_VERTEX, tex2D_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_Dyn == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, tex2D_Dyn->GetResourceDesc().Name));
         tex2D_Dyn->Set(pSRVs[0]);
 
-        auto tex2D_Dyn_sampler = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Dyn_sampler");
+        auto tex2D_Dyn_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Dyn_sampler");
         VERIFY_EXPR(tex2D_Dyn_sampler == nullptr);
 
-        auto tex2D_DynArr = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_DynArr");
+        auto tex2D_DynArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_DynArr");
         VERIFY_EXPR(tex2D_DynArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(tex2D_DynArr == pSRB->GetVariable(SHADER_TYPE_VERTEX, tex2D_DynArr->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_DynArr == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, tex2D_DynArr->GetResourceDesc().Name));
         tex2D_DynArr->SetArray(pSRVs, 0, 2);
 
-        auto tex2D_DynArr_sampler = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_DynArr_sampler");
+        auto tex2D_DynArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_DynArr_sampler");
         VERIFY_EXPR(tex2D_DynArr_sampler == nullptr);
 
-        auto UniformBuff_Mut = pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuff_Mut");
+        auto UniformBuff_Mut = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Mut");
         VERIFY_EXPR(UniformBuff_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Mut == pSRB->GetVariable(SHADER_TYPE_VERTEX, UniformBuff_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Mut == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, UniformBuff_Mut->GetResourceDesc().Name));
         UniformBuff_Mut->Set(pUBs[0]);
 
-        auto UniformBuff_Dyn = pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuff_Dyn");
+        auto UniformBuff_Dyn = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Dyn");
         VERIFY_EXPR(UniformBuff_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Dyn == pSRB->GetVariable(SHADER_TYPE_VERTEX, UniformBuff_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Dyn == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, UniformBuff_Dyn->GetResourceDesc().Name));
         UniformBuff_Dyn->Set(pUBs[0]);
 
-        auto Buffer_Mut = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_Buffer_Mut");
+        auto Buffer_Mut = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_Buffer_Mut");
         VERIFY_EXPR(Buffer_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(Buffer_Mut == pSRB->GetVariable(SHADER_TYPE_VERTEX, Buffer_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_Mut == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, Buffer_Mut->GetResourceDesc().Name));
         Buffer_Mut->Set(pFormattedBuffSRV);
 
-        auto Buffer_MutArr = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_Buffer_MutArr");
+        auto Buffer_MutArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_Buffer_MutArr");
         VERIFY_EXPR(Buffer_MutArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(Buffer_MutArr == pSRB->GetVariable(SHADER_TYPE_VERTEX, Buffer_MutArr->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_MutArr == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, Buffer_MutArr->GetResourceDesc().Name));
         Buffer_MutArr->SetArray(&pFormattedBuffSRV, 0, 1);
         Buffer_MutArr->SetArray(&pFormattedBuffSRV, 1, 1);
 
-        auto Buffer_Dyn = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_Buffer_Dyn");
+        auto Buffer_Dyn = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_Buffer_Dyn");
         VERIFY_EXPR(Buffer_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(Buffer_Dyn == pSRB->GetVariable(SHADER_TYPE_VERTEX, Buffer_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_Dyn == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, Buffer_Dyn->GetResourceDesc().Name));
         Buffer_Dyn->Set(pFormattedBuffSRV);
 
-        auto Buffer_DynArr = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_Buffer_DynArr");
+        auto Buffer_DynArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_Buffer_DynArr");
         VERIFY_EXPR(Buffer_DynArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(Buffer_DynArr == pSRB->GetVariable(SHADER_TYPE_VERTEX, Buffer_DynArr->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_DynArr == pSRB->GetVariableByName(SHADER_TYPE_VERTEX, Buffer_DynArr->GetResourceDesc().Name));
         Buffer_DynArr->SetArray(&pFormattedBuffSRV, 0, 1);
         Buffer_DynArr->SetArray(&pFormattedBuffSRV, 1, 1);
 
-        auto tex2D_Static = pSRB->GetVariable(SHADER_TYPE_VERTEX, "g_tex2D_Static");
+        auto tex2D_Static = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "g_tex2D_Static");
         VERIFY_EXPR(tex2D_Static == nullptr);
-        auto UniformBuff_Stat = pSRB->GetVariable(SHADER_TYPE_VERTEX, "UniformBuff_Stat");
+        auto UniformBuff_Stat = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "UniformBuff_Stat");
         VERIFY_EXPR(UniformBuff_Stat == nullptr);
     }
 
 
 
     {
-        auto tex2D_Mut = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Mut");
+        auto tex2D_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Mut");
         VERIFY_EXPR(tex2D_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(tex2D_Mut == pSRB->GetVariable(SHADER_TYPE_PIXEL, tex2D_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_Mut == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, tex2D_Mut->GetResourceDesc().Name));
         tex2D_Mut->Set(pRWTexSRVs[4]);
 
-        auto tex2D_Mut_sampler = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Mut_sampler");
+        auto tex2D_Mut_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Mut_sampler");
         VERIFY_EXPR(tex2D_Mut_sampler == nullptr);
 
-        auto tex2D_MutArr = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_MutArr");
+        auto tex2D_MutArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_MutArr");
         VERIFY_EXPR(tex2D_MutArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(tex2D_MutArr == pSRB->GetVariable(SHADER_TYPE_PIXEL, tex2D_MutArr->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_MutArr == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, tex2D_MutArr->GetResourceDesc().Name));
         tex2D_MutArr->SetArray(pRWTexSRVs+5, 0, 2);
 
-        auto tex2D_MutArr_sampler = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_MutArr_sampler");
+        auto tex2D_MutArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_MutArr_sampler");
         VERIFY_EXPR(tex2D_MutArr_sampler == nullptr);
 
-        auto tex2D_Dyn = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Dyn");
+        auto tex2D_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Dyn");
         VERIFY_EXPR(tex2D_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(tex2D_Dyn == pSRB->GetVariable(SHADER_TYPE_PIXEL, tex2D_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_Dyn == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, tex2D_Dyn->GetResourceDesc().Name));
         tex2D_Dyn->Set(pRWTexSRVs[7]);
 
-        auto tex2D_Dyn_sampler = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Dyn_sampler");
+        auto tex2D_Dyn_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Dyn_sampler");
         VERIFY_EXPR(tex2D_Dyn_sampler == nullptr);
 
-        auto tex2D_DynArr = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_DynArr");
+        auto tex2D_DynArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_DynArr");
         VERIFY_EXPR(tex2D_DynArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(tex2D_DynArr == pSRB->GetVariable(SHADER_TYPE_PIXEL, tex2D_DynArr->GetResourceDesc().Name));
+        VERIFY_EXPR(tex2D_DynArr == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, tex2D_DynArr->GetResourceDesc().Name));
         tex2D_DynArr->SetArray(pSRVs, 0, 2);
 
-        auto tex2D_DynArr_sampler = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_DynArr_sampler");
+        auto tex2D_DynArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_DynArr_sampler");
         VERIFY_EXPR(tex2D_DynArr_sampler == nullptr);
 
 
-        auto UniformBuff_Mut = pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuff_Mut");
+        auto UniformBuff_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Mut");
         VERIFY_EXPR(UniformBuff_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Mut == pSRB->GetVariable(SHADER_TYPE_PIXEL, UniformBuff_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Mut == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, UniformBuff_Mut->GetResourceDesc().Name));
         UniformBuff_Mut->Set(pUBs[0]);
 
-        auto UniformBuff_Dyn = pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuff_Dyn");
+        auto UniformBuff_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Dyn");
         VERIFY_EXPR(UniformBuff_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(UniformBuff_Dyn == pSRB->GetVariable(SHADER_TYPE_PIXEL, UniformBuff_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(UniformBuff_Dyn == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, UniformBuff_Dyn->GetResourceDesc().Name));
         UniformBuff_Dyn->Set(pUBs[0]);
 
-        auto Buffer_Mut = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Buffer_Mut");
+        auto Buffer_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_Mut");
         VERIFY_EXPR(Buffer_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(Buffer_Mut == pSRB->GetVariable(SHADER_TYPE_PIXEL, Buffer_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_Mut == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, Buffer_Mut->GetResourceDesc().Name));
         Buffer_Mut->Set(spRawBuffSRVs[1]);
 
-        auto Buffer_MutArr = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Buffer_MutArr");
+        auto Buffer_MutArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_MutArr");
         VERIFY_EXPR(Buffer_MutArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(Buffer_MutArr == pSRB->GetVariable(SHADER_TYPE_PIXEL, Buffer_MutArr->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_MutArr == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, Buffer_MutArr->GetResourceDesc().Name));
         Buffer_MutArr->SetArray(&pFormattedBuffSRV, 0, 1);
         Buffer_MutArr->SetArray(&pFormattedBuffSRV, 1, 1);
 
-        auto Buffer_Dyn = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Buffer_Dyn");
+        auto Buffer_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_Dyn");
         VERIFY_EXPR(Buffer_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(Buffer_Dyn == pSRB->GetVariable(SHADER_TYPE_PIXEL, Buffer_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_Dyn == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, Buffer_Dyn->GetResourceDesc().Name));
         Buffer_Dyn->Set(pFormattedBuffSRVs[3]);
 
-        auto Buffer_DynArr = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Buffer_DynArr");
+        auto Buffer_DynArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_DynArr");
         VERIFY_EXPR(Buffer_DynArr->GetResourceDesc().ArraySize == 2);
-        VERIFY_EXPR(Buffer_DynArr == pSRB->GetVariable(SHADER_TYPE_PIXEL, Buffer_DynArr->GetResourceDesc().Name));
+        VERIFY_EXPR(Buffer_DynArr == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, Buffer_DynArr->GetResourceDesc().Name));
         Buffer_DynArr->SetArray(&pFormattedBuffSRV, 0, 1);
         Buffer_DynArr->SetArray(&pFormattedBuffSRV, 1, 1);
 
-        auto rwtex2D_Mut = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_rwtex2D_Mut");
+        auto rwtex2D_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_rwtex2D_Mut");
         VERIFY_EXPR(rwtex2D_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwtex2D_Mut == pSRB->GetVariable(SHADER_TYPE_PIXEL, rwtex2D_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(rwtex2D_Mut == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, rwtex2D_Mut->GetResourceDesc().Name));
         rwtex2D_Mut->Set(pTexUAVs[2]);
 
-        auto rwtex2D_Dyn = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_rwtex2D_Dyn");
+        auto rwtex2D_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_rwtex2D_Dyn");
         VERIFY_EXPR(rwtex2D_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwtex2D_Dyn == pSRB->GetVariable(SHADER_TYPE_PIXEL, rwtex2D_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(rwtex2D_Dyn == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, rwtex2D_Dyn->GetResourceDesc().Name));
         rwtex2D_Dyn->Set(pTexUAVs[3]);
 
-        auto rwBuff_Mut = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_rwBuff_Mut");
+        auto rwBuff_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_rwBuff_Mut");
         VERIFY_EXPR(rwBuff_Mut->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwBuff_Mut == pSRB->GetVariable(SHADER_TYPE_PIXEL, rwBuff_Mut->GetResourceDesc().Name));
+        VERIFY_EXPR(rwBuff_Mut == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, rwBuff_Mut->GetResourceDesc().Name));
         rwBuff_Mut->Set(pFormattedBuffUAV[1]);
 
-        auto rwBuff_Dyn = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_rwBuff_Dyn");
+        auto rwBuff_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_rwBuff_Dyn");
         VERIFY_EXPR(rwBuff_Dyn->GetResourceDesc().ArraySize == 1);
-        VERIFY_EXPR(rwBuff_Dyn == pSRB->GetVariable(SHADER_TYPE_PIXEL, rwBuff_Dyn->GetResourceDesc().Name));
+        VERIFY_EXPR(rwBuff_Dyn == pSRB->GetVariableByName(SHADER_TYPE_PIXEL, rwBuff_Dyn->GetResourceDesc().Name));
         rwBuff_Dyn->Set(pFormattedBuffUAV[2]);
         
-        auto tex2D_Static = pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Static");
+        auto tex2D_Static = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Static");
         VERIFY_EXPR(tex2D_Static == nullptr);
-        auto UniformBuff_Stat = pSRB->GetVariable(SHADER_TYPE_PIXEL, "UniformBuff_Stat");
+        auto UniformBuff_Stat = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "UniformBuff_Stat");
         VERIFY_EXPR(UniformBuff_Stat == nullptr);
     }
 
@@ -587,10 +587,10 @@ TestShaderVarAccess::TestShaderVarAccess( IRenderDevice *pDevice, IDeviceContext
         auto NumVSVars = pSRB->GetVariableCount(SHADER_TYPE_VERTEX);
         for(Uint32 v=0; v < NumVSVars; ++v)
         {
-            auto pVar = pSRB->GetVariable(SHADER_TYPE_VERTEX, v);
+            auto pVar = pSRB->GetVariableByIndex(SHADER_TYPE_VERTEX, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
-            auto pVar2 = pSRB->GetVariable(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
+            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
@@ -599,10 +599,10 @@ TestShaderVarAccess::TestShaderVarAccess( IRenderDevice *pDevice, IDeviceContext
         auto NumPSVars = pSRB->GetVariableCount(SHADER_TYPE_PIXEL);
         for(Uint32 v=0; v < NumPSVars; ++v)
         {
-            auto pVar = pSRB->GetVariable(SHADER_TYPE_PIXEL, v);
+            auto pVar = pSRB->GetVariableByIndex(SHADER_TYPE_PIXEL, v);
             VERIFY_EXPR(pVar->GetIndex() == v);
             VERIFY_EXPR(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
-            auto pVar2 = pSRB->GetVariable(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
+            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, pVar->GetResourceDesc().Name);
             VERIFY_EXPR(pVar == pVar2);
         }
     }
@@ -614,15 +614,15 @@ TestShaderVarAccess::TestShaderVarAccess( IRenderDevice *pDevice, IDeviceContext
     DrawAttribs DrawAttrs(3, DRAW_FLAG_VERIFY_STATES);
     pContext->Draw(DrawAttrs);
 
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_rwtex2D_Dyn")->Set(pTexUAVs[7]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_tex2D_Dyn")->Set(pRWTexSRVs[3]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_rwBuff_Dyn")->Set(pFormattedBuffUAV[3]);
-    pSRB->GetVariable(SHADER_TYPE_PIXEL, "g_Buffer_Dyn")->Set(pFormattedBuffSRVs[2]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_rwtex2D_Dyn")->Set(pTexUAVs[7]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_tex2D_Dyn")->Set(pRWTexSRVs[3]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_rwBuff_Dyn")->Set(pFormattedBuffUAV[3]);
+    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, "g_Buffer_Dyn")->Set(pFormattedBuffSRVs[2]);
 
     LOG_INFO_MESSAGE("No worries about 3 errors below: attempting to access variables from inactive shader stage");
-    auto pNonExistingVar = pSRB->GetVariable(SHADER_TYPE_GEOMETRY, "g_NonExistingVar");
+    auto pNonExistingVar = pSRB->GetVariableByName(SHADER_TYPE_GEOMETRY, "g_NonExistingVar");
     VERIFY_EXPR(pNonExistingVar == nullptr);
-    pNonExistingVar = pSRB->GetVariable(SHADER_TYPE_GEOMETRY, 4);
+    pNonExistingVar = pSRB->GetVariableByIndex(SHADER_TYPE_GEOMETRY, 4);
     VERIFY_EXPR(pNonExistingVar == nullptr);
     VERIFY_EXPR(pSRB->GetVariableCount(SHADER_TYPE_GEOMETRY) == 0);
 
diff --git a/unityplugin/GhostCubePlugin/PluginSource/src/SamplePlugin.cpp b/unityplugin/GhostCubePlugin/PluginSource/src/SamplePlugin.cpp
index deae192..ea238c0 100644
--- a/unityplugin/GhostCubePlugin/PluginSource/src/SamplePlugin.cpp
+++ b/unityplugin/GhostCubePlugin/PluginSource/src/SamplePlugin.cpp
@@ -96,7 +96,7 @@ SamplePlugin::SamplePlugin(Diligent::IRenderDevice *pDevice, bool UseReverseZ, T
         PSODesc.GraphicsPipeline.InputLayout.LayoutElements = LayoutElems;
         PSODesc.GraphicsPipeline.InputLayout.NumElements    = _countof(LayoutElems);
         pDevice->CreatePipelineState(PSODesc, &m_PSO);
-        m_PSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "Constants")->Set(m_VSConstants);
+        m_PSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "Constants")->Set(m_VSConstants);
         m_PSO->CreateShaderResourceBinding(&m_SRB, true);
     }
 
diff --git a/unityplugin/GhostCubeScene/src/GhostCubeScene.cpp b/unityplugin/GhostCubeScene/src/GhostCubeScene.cpp
index cbed56c..abd3a26 100644
--- a/unityplugin/GhostCubeScene/src/GhostCubeScene.cpp
+++ b/unityplugin/GhostCubeScene/src/GhostCubeScene.cpp
@@ -131,8 +131,8 @@ void GhostCubeScene::OnGraphicsInitialized()
         PSODesc.GraphicsPipeline.pVS = pVS;
         PSODesc.GraphicsPipeline.pPS = pPS;
         pDevice->CreatePipelineState(PSODesc, &m_pMirrorPSO);
-        m_pMirrorPSO->GetStaticShaderVariable(SHADER_TYPE_VERTEX, "Constants")->Set(m_pMirrorVSConstants);
-        m_pMirrorPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2Reflection")->Set(m_pRenderTarget->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE));
+        m_pMirrorPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "Constants")->Set(m_pMirrorVSConstants);
+        m_pMirrorPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, "g_tex2Reflection")->Set(m_pRenderTarget->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE));
         m_pMirrorPSO->CreateShaderResourceBinding(&m_pMirrorSRB, true);
     }
 #if D3D12_SUPPORTED