Updated renderscript to work with the new API

9 files changed, 424 insertions, 384 deletions

diff --git a/RenderScript/include/PSODescParser.h b/RenderScript/include/PSODescParser.h
index 40b729b..0b5fa0e 100644
--- a/RenderScript/include/PSODescParser.h
+++ b/RenderScript/include/PSODescParser.h
@@ -34,7 +34,7 @@ namespace Diligent
     class PSODescParser final : public EngineObjectParserCommon<IPipelineState>
     {
     public:
-        PSODescParser( IRenderDevice *pRenderDevice, lua_State *L );
+        PSODescParser( IRenderDevice *pRenderDevice, lua_State *L, const String& ResMappingMetatableName );
         static const Char* PSODescLibName;
 
     protected:
@@ -46,6 +46,10 @@ namespace Diligent
         struct PSODescWrapper : PipelineStateDesc
         {
             String NameBuffer;
+            std::vector<ShaderResourceVariableDesc> m_VarDescBuffer;
+            std::vector<String> m_VarNamesBuffer;
+            std::vector<StaticSamplerDesc> m_StaticSamplersBuffer;
+            std::vector<String> m_StaticSamplerTexNamesBuffer;
             std::vector<LayoutElement> LayoutElementsBuffer;
         };
         friend class MemberBinder<GraphicsPipelineDesc>;
@@ -55,5 +59,12 @@ namespace Diligent
 
         int IsCompatibleWith(lua_State *L);
         ClassMethodCaller<PSODescParser> m_IsCompatibleWithBinding;
+
+        const String m_ResMappingMetatableName;
+
+        ClassMethodCaller<PSODescParser> m_BindStaticResourcesBinding;
+        int BindStaticResources( lua_State *L );
+        
+        BindShaderResourcesFlagEnumMapping m_BindShaderResFlagEnumMapping;
     };
 }
diff --git a/RenderScript/include/ScriptParser.h b/RenderScript/include/ScriptParser.h
index 41056b4..094cef0 100644
--- a/RenderScript/include/ScriptParser.h
+++ b/RenderScript/include/ScriptParser.h
@@ -38,10 +38,10 @@ namespace Diligent
     public:
         typedef RefCountedObject<IObject> TBase;
 
-        ScriptParser( IReferenceCounters *pRefCounters, IRenderDevice *pRenderDevice );
+        ScriptParser( IReferenceCounters* pRefCounters, IRenderDevice* pRenderDevice );
         ~ScriptParser();
         
-        virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface );
+        virtual void QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface );
 
         void Parse(const Char *pScript);
         
@@ -75,7 +75,7 @@ namespace Diligent
         void GetTextureViewByName( const Char *TextureViewName, ITextureView** ppTextureView );
         void GetBufferViewByName( const Char *BufferViewName, IBufferView** ppTextureView );
         void GetPipelineStateByName( const Char *PSOName, IPipelineState** ppPSO );
-        void GetShaderVariableByName( const Char *ShaderVarName, IShaderVariable** ppShaderVar );
+        void GetShaderVariableByName( const Char *ShaderVarName, IShaderResourceVariable** ppShaderVar );
         void GetShaderResourceBindingByName( const Char *SRBName, IShaderResourceBinding** ppSRB );
 
         template<typename ValType>
@@ -113,8 +113,8 @@ namespace Diligent
             void PushFuncStub( lua_State *L, const RefCntAutoPtr<IPipelineState> &pPSO );
             void PushFuncStub( lua_State *L, const Viewport &Viewport );
             void PushFuncStub( lua_State *L, const Rect &Rect );
-            void PushFuncStub( lua_State *L, const IShaderVariable* pShaderVar );
-            void PushFuncStub( lua_State *L, const RefCntAutoPtr<IShaderVariable> &pShaderVar );
+            void PushFuncStub( lua_State *L, const IShaderResourceVariable* pShaderVar );
+            void PushFuncStub( lua_State *L, const RefCntAutoPtr<IShaderResourceVariable> &pShaderVar );
             void PushFuncStub( lua_State *L, const IShaderResourceBinding* pShaderVar );
             void PushFuncStub( lua_State *L, const RefCntAutoPtr<IShaderResourceBinding> &pShaderVar );
 
diff --git a/RenderScript/include/ShaderParser.h b/RenderScript/include/ShaderParser.h
index f3fae7e..e833364 100644
--- a/RenderScript/include/ShaderParser.h
+++ b/RenderScript/include/ShaderParser.h
@@ -34,13 +34,13 @@ namespace Diligent
     class ShaderParser final : public EngineObjectParserCommon<IShader>
     {
     public:
-        ShaderParser( IRenderDevice *pRenderDevice, lua_State *L, const String& ResMappingMetatableName);
+        ShaderParser( IRenderDevice *pRenderDevice, lua_State *L);
         static const Char* ShaderLibName;
 
-        // ShaderCreationAttribs structure does not provide storage for the Name field,
+        // ShaderCreateInfo structure does not provide storage for the Name field,
         // nor does it provide storage for FilePath.
-        // We need to use ShaderCreationAttribsWrapper to be able to store the data.
-        struct ShaderCreationAttribsWrapper : ShaderCreationAttribs
+        // We need to use ShaderCreateInfoWrapper to be able to store the data.
+        struct ShaderCreateInfoWrapper : ShaderCreateInfo
         {
             String NameBuffer;
             String SourceBuffer;
@@ -49,10 +49,6 @@ namespace Diligent
             String SearchDirectoriesBuffer;
             String CombinedSamplerSuffixBuffer;
             const char *SearchDirectories = nullptr;
-            std::vector<ShaderVariableDesc> m_VarDescBuffer;
-            std::vector<String> m_VarNamesBuffer;
-            std::vector<StaticSamplerDesc> m_StaticSamplersBuffer;
-            std::vector<String> m_StaticSamplerTexNamesBuffer;
         };
 
     protected:
@@ -60,14 +56,6 @@ namespace Diligent
         virtual void ReadField( lua_State *L, void *pData, const Char *Field )override final;
 
     private:
-
-        ClassMethodCaller< ShaderParser > m_BindResourcesBinding;
-        int BindResources( lua_State *L );
-
-        const String m_ResMappingMetatableName;
-
         EnumMapping<SHADER_SOURCE_LANGUAGE>   m_ShaderSourceLangEnumMapping;
-
-        BindShaderResourcesFlagEnumMapping m_BindShaderResFlagEnumMapping;
     };
 }
diff --git a/RenderScript/include/ShaderVariableParser.h b/RenderScript/include/ShaderVariableParser.h
index e75d99e..6b97e89 100644
--- a/RenderScript/include/ShaderVariableParser.h
+++ b/RenderScript/include/ShaderVariableParser.h
@@ -35,13 +35,13 @@ namespace Diligent
     {
     public:
         ShaderVariableParser( IRenderDevice *pRenderDevice, lua_State *L, 
-                               const String &ShaderLibMetatableName,
+                               const String &PSOLibMetatableName,
                                const String &BufferLibMetatableName,
                                const String &BufferViewLibMetatableName,
                                const String &TexViewMetatableName );
         static const Char* ShaderVariableLibName;
 
-        void GetObjectByName( lua_State *L, const Char *ShaderName, IShaderVariable** ppObject );
+        void GetObjectByName( lua_State *L, const Char *ShaderName, IShaderResourceVariable** ppObject );
 
     protected:
         virtual void CreateObj( lua_State *L )override final;
@@ -51,15 +51,17 @@ namespace Diligent
         virtual void PushExistingObject( lua_State *L, const void *pObject )override final;
 
     private:
-        const String m_ShaderLibMetatableName;
+        const String m_PSOLibMetatableName;
         const String m_BufferLibMetatableName;
         const String m_BufferViewLibMetatableName;
         const String m_TexViewMetatableName;
 
+        ShaderTypeEnumMapping m_ShaderTypeEnumMapping;
+
         int Set( lua_State *L );
         ClassMethodCaller < ShaderVariableParser > m_SetBinding;
 
-        ClassMethodCaller<ShaderVariableParser> m_GetShaderVariableBinding;
-        int GetShaderVariable( lua_State *L );
+        ClassMethodCaller<ShaderVariableParser> m_GetStaticShaderVariableBinding;
+        int GetStaticShaderVariable( lua_State *L );
     };
 }
diff --git a/RenderScript/src/PSODescParser.cpp b/RenderScript/src/PSODescParser.cpp
index b1da543..4d2b143 100644
--- a/RenderScript/src/PSODescParser.cpp
+++ b/RenderScript/src/PSODescParser.cpp
@@ -27,9 +27,248 @@
 #include "RasterizerStateDescParser.h"
 #include "DepthStencilStateDescParser.h"
 #include "InputLayoutDescParser.h"
+#include "SamplerParser.h"
 
 namespace Diligent
 {
+    class ShaderVariableTypeEnumMapping : public EnumMapping < Diligent::SHADER_RESOURCE_VARIABLE_TYPE >
+    {
+    public:
+        ShaderVariableTypeEnumMapping()
+        {
+            DEFINE_ENUM_ELEMENT_MAPPING( (*this), SHADER_RESOURCE_VARIABLE_TYPE_STATIC );
+            DEFINE_ENUM_ELEMENT_MAPPING( (*this), SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE );
+            DEFINE_ENUM_ELEMENT_MAPPING( (*this), SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC );
+        }
+    };
+
+    class ShaderResourceVariableDescArrayParser;
+    template<>
+    class MemberBinder<ShaderResourceVariableDescArrayParser> : public MemberBinderBase
+    {
+    public:
+        MemberBinder( size_t VariableDescOffset, 
+                      size_t NumVariablesOffset,
+                      size_t VarDescBufferOffset,
+                      size_t VarNamesBufferOffset ) :
+            MemberBinderBase( VariableDescOffset ),
+            m_NumVariablesOffset(NumVariablesOffset),
+            m_VarDescBufferOffset(VarDescBufferOffset),
+            m_VarNamesBufferOffset(VarNamesBufferOffset)
+        {
+            DEFINE_ENUM_BINDER( m_Bindings, ShaderResourceVariableDesc, Type, m_ShaderVarTypeEnumMapping );
+            DEFINE_FLAGS_BINDER( m_Bindings, ShaderResourceVariableDesc, ShaderStages, SHADER_TYPE, m_ShaderTypeEnumMapping );
+        }
+
+        virtual void GetValue( lua_State *L, const void* pBasePointer )override
+        {
+            // Use raw pointer to push the value to Lua because the buffer
+            // most likely does not exist
+            const auto &VarDesc = GetMemberByOffest<ShaderResourceVariableDesc*>( pBasePointer, m_MemberOffset);
+            const auto &NumVars = GetMemberByOffest<Uint32>( pBasePointer, m_NumVariablesOffset);
+
+            PushLuaArray( L, VarDesc, VarDesc + NumVars, [&]( const ShaderResourceVariableDesc &VarDesc )
+            {
+                // Push variable type. The function will leave the new table on top
+                // of the stack
+                PushLuaTable( L, &VarDesc, m_Bindings ); // Stack: +1
+                
+                // Push name into the same table
+                lua_pushstring( L, "Name" ); // Stack: +2
+                lua_pushstring( L, VarDesc.Name); // Stack: +3
+                lua_settable( L, -3 ); // Stack: +1
+            }
+            );
+        }
+
+        virtual void SetValue( lua_State *L, int Index, void* pBasePointer )override
+        {
+            auto &ShaderVarDescBuffer = GetMemberByOffest<std::vector<ShaderResourceVariableDesc>>( pBasePointer, m_VarDescBufferOffset);
+            auto &ShaderNamesBuffer = GetMemberByOffest<std::vector<String>>( pBasePointer, m_VarNamesBufferOffset);
+
+            ParseLuaArray( L, Index, pBasePointer, 
+                           [&]( void* _pBasePointer, int StackIndex, int NewArrayIndex )
+                           {
+                               VERIFY_EXPR( pBasePointer == _pBasePointer );
+                           
+                               auto CurrIndex = ShaderVarDescBuffer.size();
+                               if( static_cast<int>(CurrIndex) != NewArrayIndex - 1 )
+                                   SCRIPT_PARSING_ERROR( L, "Explicit array indices are not allowed in shader name description.  Provided index ", NewArrayIndex - 1, " conflicts with actual index ", CurrIndex, "." );
+                               ShaderVarDescBuffer.resize( CurrIndex + 1 );
+                               ShaderNamesBuffer.resize( CurrIndex + 1 );
+                               ParseLuaTable( L, StackIndex, &(ShaderVarDescBuffer)[CurrIndex], 
+                                              [&](int TblStackInd, void* __pBasePointer, const char *Key) 
+                                              {
+                                                  auto Binding = m_Bindings.find( Key );
+                                                  if( Binding != m_Bindings.end() )
+                                                  {
+                                                      Binding->second->SetValue( L, TblStackInd, __pBasePointer );
+                                                  }
+                                                  else if (strcmp(Key, "Name") == 0)
+                                                  {
+                                                      auto Name = ReadValueFromLua<const Char*>(L, TblStackInd);
+                                                      ShaderNamesBuffer[CurrIndex] = Name;
+                                                  }
+                                                  else
+                                                  {
+                                                      SCRIPT_PARSING_ERROR( L, "Unknown Member \"", Key, '\"' );
+                                                  }
+                                              }
+                                );
+
+                            if( ShaderNamesBuffer[CurrIndex].length() == 0 )
+                                SCRIPT_PARSING_ERROR(L, "Missing shader variable name")
+                        }
+            );
+
+            for(size_t v=0; v < ShaderVarDescBuffer.size(); ++v)
+            {
+                ShaderVarDescBuffer[v].Name = ShaderNamesBuffer[v].c_str();
+            }
+
+            auto &VarDesc = GetMemberByOffest<ShaderResourceVariableDesc*>( pBasePointer, m_MemberOffset);
+            auto &NumVars = GetMemberByOffest<Uint32>( pBasePointer, m_NumVariablesOffset);
+            NumVars = static_cast<Uint32>(ShaderVarDescBuffer.size());
+            VarDesc = NumVars ? ShaderVarDescBuffer.data() : nullptr;
+        }    
+    private:
+        BindingsMapType m_Bindings;
+        ShaderVariableTypeEnumMapping m_ShaderVarTypeEnumMapping;
+        ShaderTypeEnumMapping m_ShaderTypeEnumMapping;
+        size_t m_NumVariablesOffset;
+        size_t m_VarDescBufferOffset;
+        size_t m_VarNamesBufferOffset;
+    };
+
+
+    class StaticSamplerDescArrayParser;
+    template<>
+    class MemberBinder<StaticSamplerDescArrayParser> : public MemberBinderBase
+    {
+    public:
+        MemberBinder( size_t StaticSamplerDescOffset, 
+                      size_t NumStaticSamplersOffset,
+                      size_t StaticSamplersBufferOffset,
+                      size_t StaticSamplerTexNamesBufferOffset ) :
+            MemberBinderBase( StaticSamplerDescOffset ),
+            m_NumStaticSamplersOffset(NumStaticSamplersOffset),
+            m_StaticSamplersBufferOffset(StaticSamplersBufferOffset),
+            m_StaticSamplerTexNamesBufferOffset(StaticSamplerTexNamesBufferOffset)
+        {
+            DEFINE_FLAGS_BINDER( m_Bindings, StaticSamplerDesc, ShaderStages, SHADER_TYPE, m_ShaderTypeEnumMapping );
+            InitSamplerParserBindings<SamplerDesc>(m_Bindings, m_FilterTypeEnumMapping, m_TexAddrModeEnumMapping, m_CmpFuncEnumMapping);
+        }
+
+        virtual void GetValue( lua_State *L, const void* pBasePointer )override
+        {
+            // Use raw pointer to push the value to Lua because the buffer
+            // most likely does not exist
+            const auto &StaticSamplers = GetMemberByOffest<StaticSamplerDesc*>( pBasePointer, m_MemberOffset);
+            const auto &NumStaticSamplers = GetMemberByOffest<Uint32>( pBasePointer, m_NumStaticSamplersOffset);
+
+            PushLuaArray( L, StaticSamplers, StaticSamplers + NumStaticSamplers, [&]( const StaticSamplerDesc &SamDesc )
+            {
+                // Push new table to hold variables of StaticSamplerDesc struct
+                lua_newtable(L); // Stack: +1
+
+                // Push "Desc" field
+                lua_pushstring( L, "Desc" ); // Stack: +2
+                // Push members of StaticSamplerDesc::Desc. The function will leave new table on top
+                // of the stack
+                PushLuaTable( L, &SamDesc.Desc, m_Bindings ); // Stack: +3
+                // Push the table from the top into the parent table
+                lua_settable( L, -3 ); // Stack: +1
+
+                // Push "SamplerOrTextureName" field
+                lua_pushstring( L, "SamplerOrTextureName" ); // Stack: +2
+                lua_pushstring( L, SamDesc.SamplerOrTextureName); // Stack: +3
+                lua_settable( L, -3 ); // Stack: +1
+            }
+            );
+        }
+
+        virtual void SetValue( lua_State *L, int Index, void* pBasePointer )override
+        {
+            auto &StaticSamplersBuffer = GetMemberByOffest<std::vector<StaticSamplerDesc>>( pBasePointer, m_StaticSamplersBufferOffset);
+            auto &StaticSamplerTexNamesBuffer = GetMemberByOffest<std::vector<String>>( pBasePointer, m_StaticSamplerTexNamesBufferOffset);
+
+            ParseLuaArray( L, Index, pBasePointer, 
+                           [&]( void* _pBasePointer, int StackIndex, int NewArrayIndex )
+                           {
+                               VERIFY_EXPR( pBasePointer == _pBasePointer );
+                           
+                               auto CurrIndex = StaticSamplersBuffer.size();
+                               if(static_cast<int>(CurrIndex) != NewArrayIndex - 1 )
+                                   SCRIPT_PARSING_ERROR( L, "Explicit array indices are not allowed in static sampler description.  Provided index ", NewArrayIndex - 1, " conflicts with actual index ", CurrIndex, "." );
+                               StaticSamplersBuffer.resize( CurrIndex + 1 );
+                               StaticSamplerTexNamesBuffer.resize( CurrIndex + 1 );
+                               ParseLuaTable( L, StackIndex, &(StaticSamplersBuffer)[CurrIndex], 
+                                              [&](int TblStackInd, void* __pBasePointer, const char *Key) 
+                                              {
+                                                  if (strcmp(Key, "Desc") == 0)
+                                                  {
+                                                       ParseLuaTable( L, StackIndex, &(StaticSamplersBuffer)[CurrIndex].Desc, 
+                                                                      [&](int TblStackInd, void* __pBasePointer, const char *Key) 
+                                                                      {    
+                                                                           if (strcmp(Key, "Name") == 0)
+                                                                           {
+                                                                               UNSUPPORTED("Parsing of the static sampler name is not implemented");
+                                                                           }
+                                                                           else
+                                                                           {
+                                                                               auto Binding = m_Bindings.find( Key );
+                                                                               if (Binding != m_Bindings.end())
+                                                                               {
+                                                                                   Binding->second->SetValue( L, TblStackInd, __pBasePointer );
+                                                                               }
+                                                                               else
+                                                                               {
+                                                                                   SCRIPT_PARSING_ERROR( L, "Unknown Member \"", Key, '\"' );
+                                                                               }
+                                                                           }
+                                                                       }
+                                                                     );
+                                                  }
+                                                  else if (strcmp(Key, "SamplerOrTextureName") == 0)
+                                                  {
+                                                      auto Name = ReadValueFromLua<const Char*>(L, TblStackInd);
+                                                      StaticSamplerTexNamesBuffer[CurrIndex] = Name;
+                                                  }
+                                                  else
+                                                  {
+                                                      SCRIPT_PARSING_ERROR( L, "Unknown Member \"", Key, '\"' );
+                                                  }
+                                              }
+                                );
+
+                            if( StaticSamplerTexNamesBuffer[CurrIndex].length() == 0 )
+                                SCRIPT_PARSING_ERROR(L, "Missing static sampler texture name")
+                        }
+            );
+
+            for(size_t v=0; v < StaticSamplersBuffer.size(); ++v)
+            {
+                StaticSamplersBuffer[v].SamplerOrTextureName = StaticSamplerTexNamesBuffer[v].c_str();
+            }
+
+            auto &StaticSamplers = GetMemberByOffest<StaticSamplerDesc*>( pBasePointer, m_MemberOffset);
+            auto &NumStaticSamplers = GetMemberByOffest<Uint32>( pBasePointer, m_NumStaticSamplersOffset);
+            NumStaticSamplers = static_cast<Uint32>(StaticSamplersBuffer.size());
+            StaticSamplers = NumStaticSamplers ? StaticSamplersBuffer.data() : nullptr;
+        }    
+    private:
+        BindingsMapType m_Bindings;
+        EnumMapping<FILTER_TYPE>           m_FilterTypeEnumMapping;
+        EnumMapping<TEXTURE_ADDRESS_MODE>  m_TexAddrModeEnumMapping;
+        ComparisonFuncEnumMapping          m_CmpFuncEnumMapping;
+        ShaderTypeEnumMapping              m_ShaderTypeEnumMapping;
+
+        size_t m_NumStaticSamplersOffset;
+        size_t m_StaticSamplersBufferOffset;
+        size_t m_StaticSamplerTexNamesBufferOffset;
+    };
+
+
     class RTVFormatsParser;
     
     template<>
@@ -115,6 +354,52 @@ namespace Diligent
         BindingsMapType m_Bindings;
     };
 
+
+    template<>
+    class MemberBinder<PipelineResourceLayoutDesc> : public MemberBinderBase
+    {
+    public:
+        MemberBinder( size_t MemberOffset, size_t VarDescBufferOffset, size_t VarNamesBufferOffset, size_t StaticSamplersBufferOffset, size_t StaticSamplerTexNamesBufferOffset ) :
+            MemberBinderBase( MemberOffset )
+        {
+            DEFINE_ENUM_BINDER( m_Bindings, PipelineResourceLayoutDesc, DefaultVariableType, m_ShaderVarTypeEnumMapping );
+
+            auto *pShaderDescBinder = 
+                new MemberBinder<ShaderResourceVariableDescArrayParser>( 
+                    offsetof(PipelineResourceLayoutDesc, Variables), 
+                    offsetof(PipelineResourceLayoutDesc, NumVariables), 
+                    VarDescBufferOffset, 
+                    VarNamesBufferOffset
+                );
+            m_Bindings.insert( std::make_pair( "VariableDesc", std::unique_ptr<MemberBinderBase>(pShaderDescBinder) ) );
+
+            auto *pStaticSamplerDescBinder = 
+                new MemberBinder<StaticSamplerDescArrayParser>( 
+                    offsetof(PipelineResourceLayoutDesc, StaticSamplers), 
+                    offsetof(PipelineResourceLayoutDesc, NumStaticSamplers), 
+                    StaticSamplersBufferOffset, 
+                    StaticSamplerTexNamesBufferOffset
+                );
+            m_Bindings.insert( std::make_pair( "StaticSamplers", std::unique_ptr<MemberBinderBase>(pStaticSamplerDescBinder) ) );
+        }
+
+        virtual void GetValue( lua_State *L, const void* pBasePointer )
+        {
+            const auto *pShaderDesc = &GetMemberByOffest<ShaderDesc>( pBasePointer, m_MemberOffset );
+            PushLuaTable( L, pShaderDesc, m_Bindings );
+        }
+
+        virtual void SetValue( lua_State *L, int Index, void* pBasePointer )
+        {
+            auto *pShaderDesc = &GetMemberByOffest<ShaderDesc>(pBasePointer, m_MemberOffset);
+            ParseLuaTable( L, Index, pShaderDesc, m_Bindings );
+        }
+
+    private:
+        BindingsMapType m_Bindings;
+        ShaderVariableTypeEnumMapping m_ShaderVarTypeEnumMapping;
+    };
+
     template<>
     class MemberBinder<GraphicsPipelineDesc> : public MemberBinderBase
     {
@@ -242,10 +527,12 @@ namespace Diligent
 
 
     const Char* PSODescParser::PSODescLibName = "PipelineState";
-    PSODescParser::PSODescParser( IRenderDevice *pRenderDevice, lua_State *L ) :
+    PSODescParser::PSODescParser( IRenderDevice *pRenderDevice, lua_State *L, const String& ResMappingMetatableName  ) :
         EngineObjectParserCommon<IPipelineState>( pRenderDevice, L, PSODescLibName ),
         m_SetPSOBinding( this, L, "Context", "SetPipelineState", &PSODescParser::SetPSO ),
-        m_IsCompatibleWithBinding(this, L, m_MetatableRegistryName.c_str(), "IsCompatibleWith", &PSODescParser::IsCompatibleWith)
+        m_IsCompatibleWithBinding(this, L, m_MetatableRegistryName.c_str(), "IsCompatibleWith", &PSODescParser::IsCompatibleWith),
+        m_ResMappingMetatableName(ResMappingMetatableName),
+        m_BindStaticResourcesBinding( this, L, m_MetatableRegistryName.c_str(), "BindStaticResources", &PSODescParser::BindStaticResources )
     {
         DEFINE_BUFFERED_STRING_BINDER( m_Bindings, PSODescWrapper, Name, NameBuffer )
 
@@ -254,6 +541,16 @@ namespace Diligent
         Validator<SRBAllocationGranularityType> SRBValidator("SRBAllocationGranularity", 1, 65536);
         DEFINE_BINDER_EX( m_Bindings, PSODescWrapper, SRBAllocationGranularity, SRBAllocationGranularityType, SRBValidator);
 
+        auto *pShaderDescBinder = 
+            new MemberBinder<PipelineResourceLayoutDesc>( 
+                offsetof(PSODescWrapper, ResourceLayout), 
+                offsetof(PSODescWrapper, m_VarDescBuffer) - offsetof(PSODescWrapper, ResourceLayout), 
+                offsetof(PSODescWrapper, m_VarNamesBuffer) - offsetof(PSODescWrapper, ResourceLayout),
+                offsetof(PSODescWrapper, m_StaticSamplersBuffer) - offsetof(PSODescWrapper, ResourceLayout),
+                offsetof(PSODescWrapper, m_StaticSamplerTexNamesBuffer) - offsetof(PSODescWrapper, ResourceLayout)
+            );
+        m_Bindings.insert( std::make_pair( "ResourceLayout", std::unique_ptr<MemberBinderBase>(pShaderDescBinder) ) );
+
         DEFINE_BINDER_EX( m_Bindings, PSODescWrapper, GraphicsPipeline, GraphicsPipelineDesc, 0 );
         DEFINE_BINDER_EX( m_Bindings, PSODescWrapper, ComputePipeline, ComputePipelineDesc, 0 );
     };
@@ -303,4 +600,55 @@ namespace Diligent
         // Returning one value to Lua
         return 1;
     }
+
+    int PSODescParser::BindStaticResources( lua_State *L )
+    {
+        // In order to communicate properly with Lua, a C function must use the following protocol, 
+        // which defines the way parameters and results are passed : a C function receives its arguments 
+        // from Lua in its PRIVATE stack in direct order( the first argument is pushed first ).So, when the 
+        // function starts, lua_gettop( L ) returns the number of arguments received by the function.The first 
+        // argument( if any ) is at index 1 and its last argument is at index lua_gettop( L ).
+        // To return values to Lua, a C function just pushes them onto the stack, in direct order 
+        // ( the first result is pushed first ), and returns the number of results. 
+        // Any other value in the stack below the results will be properly discarded by Lua. 
+        // Like a Lua function, a C function called by Lua can also return many results.
+
+        try
+        {
+            auto NumArgs = lua_gettop( L );
+            if( NumArgs < 2 )
+            {
+                SCRIPT_PARSING_ERROR( L, "At least 1 argument (resource mapping) is expected" );
+            }
+
+            auto *pPSO = *GetUserData<IPipelineState**>( L, 1, m_MetatableRegistryName.c_str() );
+            VERIFY( pPSO, "PSO pointer is null" );
+            if( !pPSO )return 0;
+
+            auto *pResourceMapping = *GetUserData<IResourceMapping**>( L, 2, m_ResMappingMetatableName.c_str() );
+            if( !pResourceMapping )
+            {
+                SCRIPT_PARSING_ERROR( L, "Incorrect 1st argument type: resource mapping is expected" );
+            }
+
+            Uint32 Flags = 0;
+            // The last argument may be flags
+            const int FlagsArgInd = 3;
+            if( NumArgs >= FlagsArgInd &&
+                (lua_type( L, FlagsArgInd ) == LUA_TSTRING || lua_type( L, FlagsArgInd ) == LUA_TTABLE ) )
+            {
+                FlagsLoader<BIND_SHADER_RESOURCES_FLAGS> FlagsLoader(0, "BindShaderResourceFlags", m_BindShaderResFlagEnumMapping);
+                FlagsLoader.SetValue( L, FlagsArgInd, &Flags );
+            }
+
+
+            pPSO->BindStaticResources( pResourceMapping, Flags );
+        }
+        catch( const std::runtime_error& )
+        {
+
+        }
+
+        return 0;
+    }
 }
diff --git a/RenderScript/src/ScriptParser.cpp b/RenderScript/src/ScriptParser.cpp
index 10cd351..49d5deb 100644
--- a/RenderScript/src/ScriptParser.cpp
+++ b/RenderScript/src/ScriptParser.cpp
@@ -40,9 +40,6 @@
 #include "ShaderVariableParser.h"
 #include "ShaderResourceBindingParser.h"
 
-using namespace Diligent;
-using namespace Diligent;
-
 namespace Diligent
 {
     const Char* ScriptParser::DeviceContextRegistryKey = "DeviceContext";
@@ -66,7 +63,7 @@ namespace Diligent
     IMPLEMENT_PUSH_FUNC_STUBS( ITextureView, m_pTextureViewParser )
     IMPLEMENT_PUSH_FUNC_STUBS( IBufferView, m_pBufferViewParser )
     IMPLEMENT_PUSH_FUNC_STUBS( IPipelineState, m_pPSOParser )
-    IMPLEMENT_PUSH_FUNC_STUBS( IShaderVariable, m_pShaderVariableParser )
+    IMPLEMENT_PUSH_FUNC_STUBS( IShaderResourceVariable, m_pShaderVariableParser )
     IMPLEMENT_PUSH_FUNC_STUBS( IShaderResourceBinding, m_pShaderResBindingParser )
 
 
@@ -108,11 +105,11 @@ namespace Diligent
         m_pTextureViewParser.reset( new TextureViewParser( m_pTextureParser.get(), m_pSamplerParser.get(), pRenderDevice, m_LuaState ) );
         m_pBufferViewParser.reset( new BufferViewParser( m_pBufferParser.get(), pRenderDevice, m_LuaState ) );
         m_pResourceMappingParser.reset( new ResourceMappingParser( pRenderDevice, m_LuaState, m_pTextureViewParser.get(), m_pBufferParser.get(), m_pBufferViewParser.get() ) );
-        m_pShaderParser.reset( new ShaderParser( pRenderDevice, m_LuaState, m_pResourceMappingParser->GetMetatableName() ) );
-        m_pPSOParser.reset( new PSODescParser( pRenderDevice, m_LuaState ) );
+        m_pShaderParser.reset( new ShaderParser( pRenderDevice, m_LuaState ) );
+        m_pPSOParser.reset( new PSODescParser( pRenderDevice, m_LuaState, m_pResourceMappingParser->GetMetatableName() ) );
         m_pViewportParser.reset( new ViewportParser( pRenderDevice, m_LuaState ) );
         m_pScissorRectParser.reset( new ScissorRectParser( pRenderDevice, m_LuaState ) );
-        m_pShaderVariableParser.reset( new ShaderVariableParser( pRenderDevice, m_LuaState, m_pShaderParser->GetMetatableName(), m_pBufferParser->GetMetatableName(), m_pBufferViewParser->GetMetatableName(), m_pTextureViewParser->GetMetatableName() ) );
+        m_pShaderVariableParser.reset( new ShaderVariableParser( pRenderDevice, m_LuaState, m_pPSOParser->GetMetatableName(), m_pBufferParser->GetMetatableName(), m_pBufferViewParser->GetMetatableName(), m_pTextureViewParser->GetMetatableName() ) );
         m_pShaderResBindingParser.reset( new ShaderResourceBindingParser( pRenderDevice, m_LuaState, m_pPSOParser->GetMetatableName(), m_pResourceMappingParser->GetMetatableName(), m_pShaderVariableParser->GetMetatableName() ) );
         m_pDeviceCtxFuncBindings.reset( new DeviceContextFuncBindings( pRenderDevice, m_LuaState, m_pTextureViewParser.get(), m_pShaderResBindingParser.get(), m_pPSOParser.get() ) );
     }
@@ -239,7 +236,7 @@ namespace Diligent
         m_pPSOParser->GetObjectByName( m_LuaState, PSOName, ppPSO );
     }
 
-    void ScriptParser::GetShaderVariableByName( const Char *ShaderVarName, IShaderVariable** ppShaderVar )
+    void ScriptParser::GetShaderVariableByName( const Char *ShaderVarName, IShaderResourceVariable** ppShaderVar )
     {
         m_pShaderVariableParser->GetObjectByName( m_LuaState, ShaderVarName, ppShaderVar );
     }
@@ -249,7 +246,7 @@ namespace Diligent
         m_pShaderResBindingParser->GetObjectByName( m_LuaState, SRBName, ppSRB );
     }
 
-    void ScriptParser::QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface )
+    void ScriptParser::QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface )
     {
         UNSUPPORTED( "Not implemented" );
     }
diff --git a/RenderScript/src/ShaderParser.cpp b/RenderScript/src/ShaderParser.cpp
index 761e1af..3ca4981 100644
--- a/RenderScript/src/ShaderParser.cpp
+++ b/RenderScript/src/ShaderParser.cpp
@@ -24,286 +24,29 @@
 #include "pch.h"
 #include "ShaderParser.h"
 #include "BasicShaderSourceStreamFactory.h"
-#include "SamplerParser.h"
 
 namespace Diligent
 {
     const Char* ShaderParser::ShaderLibName = "Shader";
 
-
-    class ShaderVariableTypeEnumMapping : public EnumMapping < Diligent::SHADER_VARIABLE_TYPE >
-    {
-    public:
-        ShaderVariableTypeEnumMapping()
-        {
-            DEFINE_ENUM_ELEMENT_MAPPING( (*this), SHADER_VARIABLE_TYPE_STATIC );
-            DEFINE_ENUM_ELEMENT_MAPPING( (*this), SHADER_VARIABLE_TYPE_MUTABLE );
-            DEFINE_ENUM_ELEMENT_MAPPING( (*this), SHADER_VARIABLE_TYPE_DYNAMIC );
-        }
-    };
-
-    class ShaderVariableDescArrayParser;
-    template<>
-    class MemberBinder<ShaderVariableDescArrayParser> : public MemberBinderBase
-    {
-    public:
-        MemberBinder( size_t VariableDescOffset, 
-                      size_t NumVariablesOffset,
-                      size_t VarDescBufferOffset,
-                      size_t VarNamesBufferOffset ) :
-            MemberBinderBase( VariableDescOffset ),
-            m_NumVariablesOffset(NumVariablesOffset),
-            m_VarDescBufferOffset(VarDescBufferOffset),
-            m_VarNamesBufferOffset(VarNamesBufferOffset)
-        {
-            DEFINE_ENUM_BINDER( m_Bindings, ShaderVariableDesc, Type, m_ShaderVarTypeEnumMapping );
-        }
-
-        virtual void GetValue( lua_State *L, const void* pBasePointer )override
-        {
-            // Use raw pointer to push the value to Lua because the buffer
-            // most likely does not exist
-            const auto &VarDesc = GetMemberByOffest<ShaderVariableDesc*>( pBasePointer, m_MemberOffset);
-            const auto &NumVars = GetMemberByOffest<Uint32>( pBasePointer, m_NumVariablesOffset);
-
-            PushLuaArray( L, VarDesc, VarDesc + NumVars, [&]( const ShaderVariableDesc &VarDesc )
-            {
-                // Push variable type. The function will leave the new table on top
-                // of the stack
-                PushLuaTable( L, &VarDesc, m_Bindings ); // Stack: +1
-                
-                // Push name into the same table
-                lua_pushstring( L, "Name" ); // Stack: +2
-                lua_pushstring( L, VarDesc.Name); // Stack: +3
-                lua_settable( L, -3 ); // Stack: +1
-            }
-            );
-        }
-
-        virtual void SetValue( lua_State *L, int Index, void* pBasePointer )override
-        {
-            auto &ShaderVarDescBuffer = GetMemberByOffest<std::vector<ShaderVariableDesc>>( pBasePointer, m_VarDescBufferOffset);
-            auto &ShaderNamesBuffer = GetMemberByOffest<std::vector<String>>( pBasePointer, m_VarNamesBufferOffset);
-
-            ParseLuaArray( L, Index, pBasePointer, 
-                           [&]( void* _pBasePointer, int StackIndex, int NewArrayIndex )
-                           {
-                               VERIFY_EXPR( pBasePointer == _pBasePointer );
-                           
-                               auto CurrIndex = ShaderVarDescBuffer.size();
-                               if( static_cast<int>(CurrIndex) != NewArrayIndex - 1 )
-                                   SCRIPT_PARSING_ERROR( L, "Explicit array indices are not allowed in shader name description.  Provided index ", NewArrayIndex - 1, " conflicts with actual index ", CurrIndex, "." );
-                               ShaderVarDescBuffer.resize( CurrIndex + 1 );
-                               ShaderNamesBuffer.resize( CurrIndex + 1 );
-                               ParseLuaTable( L, StackIndex, &(ShaderVarDescBuffer)[CurrIndex], 
-                                              [&](int TblStackInd, void* __pBasePointer, const char *Key) 
-                                              {
-                                                  auto Binding = m_Bindings.find( Key );
-                                                  if( Binding != m_Bindings.end() )
-                                                  {
-                                                      Binding->second->SetValue( L, TblStackInd, __pBasePointer );
-                                                  }
-                                                  else if (strcmp(Key, "Name") == 0)
-                                                  {
-                                                      auto Name = ReadValueFromLua<const Char*>(L, TblStackInd);
-                                                      ShaderNamesBuffer[CurrIndex] = Name;
-                                                  }
-                                                  else
-                                                  {
-                                                      SCRIPT_PARSING_ERROR( L, "Unknown Member \"", Key, '\"' );
-                                                  }
-                                              }
-                                );
-
-                            if( ShaderNamesBuffer[CurrIndex].length() == 0 )
-                                SCRIPT_PARSING_ERROR(L, "Missing shader variable name")
-                        }
-            );
-
-            for(size_t v=0; v < ShaderVarDescBuffer.size(); ++v)
-            {
-                ShaderVarDescBuffer[v].Name = ShaderNamesBuffer[v].c_str();
-            }
-
-            auto &VarDesc = GetMemberByOffest<ShaderVariableDesc*>( pBasePointer, m_MemberOffset);
-            auto &NumVars = GetMemberByOffest<Uint32>( pBasePointer, m_NumVariablesOffset);
-            NumVars = static_cast<Uint32>(ShaderVarDescBuffer.size());
-            VarDesc = NumVars ? ShaderVarDescBuffer.data() : nullptr;
-        }    
-    private:
-        BindingsMapType m_Bindings;
-        ShaderVariableTypeEnumMapping m_ShaderVarTypeEnumMapping;
-        ShaderTypeEnumMapping m_ShaderTypeEnumMapping;
-        size_t m_NumVariablesOffset;
-        size_t m_VarDescBufferOffset;
-        size_t m_VarNamesBufferOffset;
-    };
-
-
-    class StaticSamplerDescArrayParser;
-    template<>
-    class MemberBinder<StaticSamplerDescArrayParser> : public MemberBinderBase
-    {
-    public:
-        MemberBinder( size_t StaticSamplerDescOffset, 
-                      size_t NumStaticSamplersOffset,
-                      size_t StaticSamplersBufferOffset,
-                      size_t StaticSamplerTexNamesBufferOffset ) :
-            MemberBinderBase( StaticSamplerDescOffset ),
-            m_NumStaticSamplersOffset(NumStaticSamplersOffset),
-            m_StaticSamplersBufferOffset(StaticSamplersBufferOffset),
-            m_StaticSamplerTexNamesBufferOffset(StaticSamplerTexNamesBufferOffset)
-        {
-            InitSamplerParserBindings<SamplerDesc>(m_Bindings, m_FilterTypeEnumMapping, m_TexAddrModeEnumMapping, m_CmpFuncEnumMapping);
-        }
-
-        virtual void GetValue( lua_State *L, const void* pBasePointer )override
-        {
-            // Use raw pointer to push the value to Lua because the buffer
-            // most likely does not exist
-            const auto &StaticSamplers = GetMemberByOffest<StaticSamplerDesc*>( pBasePointer, m_MemberOffset);
-            const auto &NumStaticSamplers = GetMemberByOffest<Uint32>( pBasePointer, m_NumStaticSamplersOffset);
-
-            PushLuaArray( L, StaticSamplers, StaticSamplers + NumStaticSamplers, [&]( const StaticSamplerDesc &SamDesc )
-            {
-                // Push new table to hold variables of StaticSamplerDesc struct
-                lua_newtable(L); // Stack: +1
-
-                // Push "Desc" field
-                lua_pushstring( L, "Desc" ); // Stack: +2
-                // Push members of StaticSamplerDesc::Desc. The function will leave new table on top
-                // of the stack
-                PushLuaTable( L, &SamDesc.Desc, m_Bindings ); // Stack: +3
-                // Push the table from the top into the parent table
-                lua_settable( L, -3 ); // Stack: +1
-
-                // Push "SamplerOrTextureName" field
-                lua_pushstring( L, "SamplerOrTextureName" ); // Stack: +2
-                lua_pushstring( L, SamDesc.SamplerOrTextureName); // Stack: +3
-                lua_settable( L, -3 ); // Stack: +1
-            }
-            );
-        }
-
-        virtual void SetValue( lua_State *L, int Index, void* pBasePointer )override
-        {
-            auto &StaticSamplersBuffer = GetMemberByOffest<std::vector<StaticSamplerDesc>>( pBasePointer, m_StaticSamplersBufferOffset);
-            auto &StaticSamplerTexNamesBuffer = GetMemberByOffest<std::vector<String>>( pBasePointer, m_StaticSamplerTexNamesBufferOffset);
-
-            ParseLuaArray( L, Index, pBasePointer, 
-                           [&]( void* _pBasePointer, int StackIndex, int NewArrayIndex )
-                           {
-                               VERIFY_EXPR( pBasePointer == _pBasePointer );
-                           
-                               auto CurrIndex = StaticSamplersBuffer.size();
-                               if(static_cast<int>(CurrIndex) != NewArrayIndex - 1 )
-                                   SCRIPT_PARSING_ERROR( L, "Explicit array indices are not allowed in static sampler description.  Provided index ", NewArrayIndex - 1, " conflicts with actual index ", CurrIndex, "." );
-                               StaticSamplersBuffer.resize( CurrIndex + 1 );
-                               StaticSamplerTexNamesBuffer.resize( CurrIndex + 1 );
-                               ParseLuaTable( L, StackIndex, &(StaticSamplersBuffer)[CurrIndex], 
-                                              [&](int TblStackInd, void* __pBasePointer, const char *Key) 
-                                              {
-                                                  if (strcmp(Key, "Desc") == 0)
-                                                  {
-                                                       ParseLuaTable( L, StackIndex, &(StaticSamplersBuffer)[CurrIndex].Desc, 
-                                                                      [&](int TblStackInd, void* __pBasePointer, const char *Key) 
-                                                                      {    
-                                                                           if (strcmp(Key, "Name") == 0)
-                                                                           {
-                                                                               UNSUPPORTED("Parsing of the static sampler name is not implemented");
-                                                                           }
-                                                                           else
-                                                                           {
-                                                                               auto Binding = m_Bindings.find( Key );
-                                                                               if (Binding != m_Bindings.end())
-                                                                               {
-                                                                                   Binding->second->SetValue( L, TblStackInd, __pBasePointer );
-                                                                               }
-                                                                               else
-                                                                               {
-                                                                                   SCRIPT_PARSING_ERROR( L, "Unknown Member \"", Key, '\"' );
-                                                                               }
-                                                                           }
-                                                                       }
-                                                                     );
-                                                  }
-                                                  else if (strcmp(Key, "SamplerOrTextureName") == 0)
-                                                  {
-                                                      auto Name = ReadValueFromLua<const Char*>(L, TblStackInd);
-                                                      StaticSamplerTexNamesBuffer[CurrIndex] = Name;
-                                                  }
-                                                  else
-                                                  {
-                                                      SCRIPT_PARSING_ERROR( L, "Unknown Member \"", Key, '\"' );
-                                                  }
-                                              }
-                                );
-
-                            if( StaticSamplerTexNamesBuffer[CurrIndex].length() == 0 )
-                                SCRIPT_PARSING_ERROR(L, "Missing static sampler texture name")
-                        }
-            );
-
-            for(size_t v=0; v < StaticSamplersBuffer.size(); ++v)
-            {
-                StaticSamplersBuffer[v].SamplerOrTextureName = StaticSamplerTexNamesBuffer[v].c_str();
-            }
-
-            auto &StaticSamplers = GetMemberByOffest<StaticSamplerDesc*>( pBasePointer, m_MemberOffset);
-            auto &NumStaticSamplers = GetMemberByOffest<Uint32>( pBasePointer, m_NumStaticSamplersOffset);
-            NumStaticSamplers = static_cast<Uint32>(StaticSamplersBuffer.size());
-            StaticSamplers = NumStaticSamplers ? StaticSamplersBuffer.data() : nullptr;
-        }    
-    private:
-        BindingsMapType m_Bindings;
-        EnumMapping<FILTER_TYPE>           m_FilterTypeEnumMapping;
-        EnumMapping<TEXTURE_ADDRESS_MODE>  m_TexAddrModeEnumMapping;
-        ComparisonFuncEnumMapping          m_CmpFuncEnumMapping;
-
-        size_t m_NumStaticSamplersOffset;
-        size_t m_StaticSamplersBufferOffset;
-        size_t m_StaticSamplerTexNamesBufferOffset;
-    };
-
-
     class ShaderDescLoader;
 
     template<>
     class MemberBinder<ShaderDescLoader> : public MemberBinderBase
     {
     public:
-        MemberBinder( size_t MemberOffset, size_t VarDescBufferOffset, size_t VarNamesBufferOffset, size_t StaticSamplersBufferOffset, size_t StaticSamplerTexNamesBufferOffset ) :
+        MemberBinder( size_t MemberOffset ) :
             MemberBinderBase( MemberOffset )
         {
             auto *pNameBinder = new BufferedStringBinder( offsetof( ShaderDesc, Name ), 
                 // This is a small hack: we need to compute an offset from the beginning of ShaderDesc structure to
-                // the NameBuffer member of ShaderCreationAttribsWrapper:
-                offsetof( ShaderParser::ShaderCreationAttribsWrapper, NameBuffer ) - offsetof( ShaderParser::ShaderCreationAttribsWrapper, Desc.Name ) );
+                // the NameBuffer member of ShaderCreateInfoWrapper:
+                offsetof( ShaderParser::ShaderCreateInfoWrapper, NameBuffer ) - offsetof( ShaderParser::ShaderCreateInfoWrapper, Desc.Name ) );
             // No need to make a copy of Name since it is constant and HashMapStringKey will simply
             // keep pointer to it
             m_Bindings.insert( std::make_pair( "Name", std::unique_ptr<MemberBinderBase>(pNameBinder) ) );
 
             DEFINE_ENUM_BINDER( m_Bindings, ShaderDesc, ShaderType, m_ShaderTypeEnumMapping );
-
-            DEFINE_ENUM_BINDER( m_Bindings, ShaderDesc, DefaultVariableType, m_ShaderVarTypeEnumMapping );
-
-            auto *pShaderDescBinder = 
-                new MemberBinder<ShaderVariableDescArrayParser>( 
-                    offsetof(ShaderDesc, VariableDesc), 
-                    offsetof(ShaderDesc, NumVariables), 
-                    VarDescBufferOffset, 
-                    VarNamesBufferOffset
-                );
-            m_Bindings.insert( std::make_pair( "VariableDesc", std::unique_ptr<MemberBinderBase>(pShaderDescBinder) ) );
-
-            auto *pStaticSamplerDescBinder = 
-                new MemberBinder<StaticSamplerDescArrayParser>( 
-                    offsetof(ShaderDesc, StaticSamplers), 
-                    offsetof(ShaderDesc, NumStaticSamplers), 
-                    StaticSamplersBufferOffset, 
-                    StaticSamplerTexNamesBufferOffset
-                );
-            m_Bindings.insert( std::make_pair( "StaticSamplers", std::unique_ptr<MemberBinderBase>(pStaticSamplerDescBinder) ) );
         }
 
         virtual void GetValue( lua_State *L, const void* pBasePointer )
@@ -321,34 +64,27 @@ namespace Diligent
     private:
         BindingsMapType m_Bindings;
         ShaderTypeEnumMapping m_ShaderTypeEnumMapping;
-        ShaderVariableTypeEnumMapping m_ShaderVarTypeEnumMapping;
     };
 
-    ShaderParser::ShaderParser( IRenderDevice *pRenderDevice, lua_State *L, const String& ResMappingMetatableName ) :
-        EngineObjectParserCommon<IShader>( pRenderDevice, L, ShaderLibName ),
-        m_BindResourcesBinding( this, L, m_MetatableRegistryName.c_str(), "BindResources", &ShaderParser::BindResources ),
-        m_ResMappingMetatableName(ResMappingMetatableName)
+    ShaderParser::ShaderParser( IRenderDevice *pRenderDevice, lua_State *L) :
+        EngineObjectParserCommon<IShader>( pRenderDevice, L, ShaderLibName )
     {
-        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreationAttribsWrapper, FilePath, FilePathBuffer )
-        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreationAttribsWrapper, Source, SourceBuffer )
-        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreationAttribsWrapper, EntryPoint, EntryPointBuffer )
-        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreationAttribsWrapper, SearchDirectories, SearchDirectoriesBuffer )
-        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreationAttribsWrapper, CombinedSamplerSuffix, CombinedSamplerSuffixBuffer )
+        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreateInfoWrapper, FilePath, FilePathBuffer )
+        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreateInfoWrapper, Source, SourceBuffer )
+        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreateInfoWrapper, EntryPoint, EntryPointBuffer )
+        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreateInfoWrapper, SearchDirectories, SearchDirectoriesBuffer )
+        DEFINE_BUFFERED_STRING_BINDER( m_Bindings, ShaderCreateInfoWrapper, CombinedSamplerSuffix, CombinedSamplerSuffixBuffer )
 
-        DEFINE_BINDER(m_Bindings, ShaderCreationAttribsWrapper, UseCombinedTextureSamplers);
+        DEFINE_BINDER(m_Bindings, ShaderCreateInfoWrapper, UseCombinedTextureSamplers);
 
         DEFINE_ENUM_ELEMENT_MAPPING( m_ShaderSourceLangEnumMapping, SHADER_SOURCE_LANGUAGE_DEFAULT );
         DEFINE_ENUM_ELEMENT_MAPPING( m_ShaderSourceLangEnumMapping, SHADER_SOURCE_LANGUAGE_HLSL );
         DEFINE_ENUM_ELEMENT_MAPPING( m_ShaderSourceLangEnumMapping, SHADER_SOURCE_LANGUAGE_GLSL );
-        DEFINE_ENUM_BINDER( m_Bindings, ShaderCreationAttribsWrapper, SourceLanguage, m_ShaderSourceLangEnumMapping );
+        DEFINE_ENUM_BINDER( m_Bindings, ShaderCreateInfoWrapper, SourceLanguage, m_ShaderSourceLangEnumMapping );
 
         auto *pShaderDescBinder = 
             new MemberBinder<ShaderDescLoader>( 
-                offsetof(ShaderCreationAttribsWrapper, Desc), 
-                offsetof(ShaderCreationAttribsWrapper, m_VarDescBuffer) - offsetof(ShaderCreationAttribsWrapper, Desc), 
-                offsetof(ShaderCreationAttribsWrapper, m_VarNamesBuffer) - offsetof(ShaderCreationAttribsWrapper, Desc),
-                offsetof(ShaderCreationAttribsWrapper, m_StaticSamplersBuffer) - offsetof(ShaderCreationAttribsWrapper, Desc),
-                offsetof(ShaderCreationAttribsWrapper, m_StaticSamplerTexNamesBuffer) - offsetof(ShaderCreationAttribsWrapper, Desc)
+                offsetof(ShaderCreateInfoWrapper, Desc)
             );
         m_Bindings.insert( std::make_pair( "Desc", std::unique_ptr<MemberBinderBase>(pShaderDescBinder) ) );
     };
@@ -357,7 +93,7 @@ namespace Diligent
     {
         INIT_LUA_STACK_TRACKING( L );
 
-        ShaderCreationAttribsWrapper ShaderCreationAttrs;
+        ShaderCreateInfoWrapper ShaderCreationAttrs;
         ParseLuaTable( L, -1, &ShaderCreationAttrs, m_Bindings );
 
         BasicShaderSourceStreamFactory BasicSSSFactory(ShaderCreationAttrs.SearchDirectories);
@@ -376,61 +112,9 @@ namespace Diligent
 
     void ShaderParser::ReadField( lua_State *L, void *pData, const Char *Field )
     {
-        ShaderCreationAttribsWrapper ShaderCreationAttrs;
+        ShaderCreateInfoWrapper ShaderCreationAttrs;
         auto *ppShader = reinterpret_cast<IShader**>(pData);
         ShaderCreationAttrs.Desc = (*ppShader)->GetDesc();
         PushField( L, &ShaderCreationAttrs, Field, m_Bindings );
     }
-    
-    int ShaderParser::BindResources( lua_State *L )
-    {
-        // In order to communicate properly with Lua, a C function must use the following protocol, 
-        // which defines the way parameters and results are passed : a C function receives its arguments 
-        // from Lua in its PRIVATE stack in direct order( the first argument is pushed first ).So, when the 
-        // function starts, lua_gettop( L ) returns the number of arguments received by the function.The first 
-        // argument( if any ) is at index 1 and its last argument is at index lua_gettop( L ).
-        // To return values to Lua, a C function just pushes them onto the stack, in direct order 
-        // ( the first result is pushed first ), and returns the number of results. 
-        // Any other value in the stack below the results will be properly discarded by Lua. 
-        // Like a Lua function, a C function called by Lua can also return many results.
-
-        try
-        {
-            auto NumArgs = lua_gettop( L );
-            if( NumArgs < 2 )
-            {
-                SCRIPT_PARSING_ERROR( L, "At least 1 argument (resource mapping) is expected" );
-            }
-
-            auto *pShader = *GetUserData<IShader**>( L, 1, m_MetatableRegistryName.c_str() );
-            VERIFY( pShader, "Shader pointer is null" );
-            if( !pShader )return 0;
-
-            auto *pResourceMapping = *GetUserData<IResourceMapping**>( L, 2, m_ResMappingMetatableName.c_str() );
-            if( !pResourceMapping )
-            {
-                SCRIPT_PARSING_ERROR( L, "Incorrect 1st argument type: resource mapping is expected" );
-            }
-
-            Uint32 Flags = 0;
-            // The last argument may be flags
-            const int FlagsArgInd = 3;
-            if( NumArgs >= FlagsArgInd &&
-                (lua_type( L, FlagsArgInd ) == LUA_TSTRING || lua_type( L, FlagsArgInd ) == LUA_TTABLE ) )
-            {
-                FlagsLoader<BIND_SHADER_RESOURCES_FLAGS> FlagsLoader(0, "BindShaderResourceFlags", m_BindShaderResFlagEnumMapping);
-                FlagsLoader.SetValue( L, FlagsArgInd, &Flags );
-            }
-
-
-            pShader->BindResources( pResourceMapping, Flags );
-        }
-        catch( const std::runtime_error& )
-        {
-
-        }
-
-        return 0;
-    }
-
 }
diff --git a/RenderScript/src/ShaderResourceBindingParser.cpp b/RenderScript/src/ShaderResourceBindingParser.cpp
index dc77a1c..32c8176 100644
--- a/RenderScript/src/ShaderResourceBindingParser.cpp
+++ b/RenderScript/src/ShaderResourceBindingParser.cpp
@@ -176,7 +176,7 @@ namespace Diligent
 
         auto pVar = pShaderResBinding->GetVariable(ShaderType, VarName.c_str());
 
-        auto pNewShaderVarLuaObj = reinterpret_cast<IShaderVariable**>(lua_newuserdata( L, sizeof( IShaderVariable* ) ));
+        auto pNewShaderVarLuaObj = reinterpret_cast<IShaderResourceVariable**>(lua_newuserdata( L, sizeof( IShaderResourceVariable* ) ));
         *pNewShaderVarLuaObj = pVar;
         pVar->AddRef();
 
diff --git a/RenderScript/src/ShaderVariableParser.cpp b/RenderScript/src/ShaderVariableParser.cpp
index d56cd1f..0bfac71 100644
--- a/RenderScript/src/ShaderVariableParser.cpp
+++ b/RenderScript/src/ShaderVariableParser.cpp
@@ -29,33 +29,43 @@ namespace Diligent
     const Char* ShaderVariableParser::ShaderVariableLibName = "ShaderVariable";
 
     ShaderVariableParser::ShaderVariableParser( IRenderDevice *pRenderDevice, lua_State *L, 
-                                                  const String &ShaderLibMetatableName,
+                                                  const String &PSOLibMetatableName,
                                                   const String &BufferLibMetatableName,
                                                   const String &BufferViewLibMetatableName,
                                                   const String &TexViewMetatableName ) :
         EngineObjectParserBase( pRenderDevice, L, ShaderVariableLibName ),
-        m_ShaderLibMetatableName(ShaderLibMetatableName),
+        m_PSOLibMetatableName(PSOLibMetatableName),
         m_BufferLibMetatableName(BufferLibMetatableName),
         m_BufferViewLibMetatableName(BufferViewLibMetatableName),
         m_TexViewMetatableName(TexViewMetatableName),
         m_SetBinding( this, L, m_MetatableRegistryName.c_str(), "Set", &ShaderVariableParser::Set ),
-        m_GetShaderVariableBinding( this, L, m_ShaderLibMetatableName.c_str(), "GetShaderVariable", &ShaderVariableParser::GetShaderVariable )
+        m_GetStaticShaderVariableBinding( this, L, m_PSOLibMetatableName.c_str(), "GetStaticShaderVariable", &ShaderVariableParser::GetStaticShaderVariable )
     {
     };
 
     void ShaderVariableParser::CreateObj( lua_State *L )
     {
+        auto NumArgs = lua_gettop( L );
+        if( NumArgs < 3 )
+        {
+            SCRIPT_PARSING_ERROR( L, "2 arguments (shader type and variable name) are expected" );
+        }
+
         INIT_LUA_STACK_TRACKING(L);
 
         // Shader should be the first argument
-        auto *pShader = *GetUserData<IShader**>( L, 1, m_ShaderLibMetatableName.c_str() );
+        auto *pPSO = *GetUserData<IPipelineState**>( L, 1, m_PSOLibMetatableName.c_str() );
         
+        SHADER_TYPE ShaderType = SHADER_TYPE_UNKNOWN;
+        EnumMemberBinder<SHADER_TYPE> ShaderTypeParser(0, "ShaderType", m_ShaderTypeEnumMapping);
+        ShaderTypeParser.SetValue(L, 2, &ShaderType);
+
         // Variable name should be the second argument
-        auto VarName = ReadValueFromLua<String>( L, 2 );
+        auto VarName = ReadValueFromLua<String>( L, 3 );
 
-        auto pVar = pShader->GetShaderVariable( VarName.c_str() );
+        auto pVar = pPSO->GetStaticShaderVariable(ShaderType, VarName.c_str() );
 
-        auto pNewShaderVarLuaObj = reinterpret_cast<IShaderVariable**>(lua_newuserdata( L, sizeof( IShaderVariable* ) ));
+        auto pNewShaderVarLuaObj = reinterpret_cast<IShaderResourceVariable**>(lua_newuserdata( L, sizeof( IShaderResourceVariable* ) ));
         *pNewShaderVarLuaObj = pVar;
         pVar->AddRef();
 
@@ -66,7 +76,7 @@ namespace Diligent
     {
         if( pData != nullptr )
         {
-            auto ppShaderVar = reinterpret_cast<IShaderVariable**>(pData);
+            auto ppShaderVar = reinterpret_cast<IShaderResourceVariable**>(pData);
             if( *ppShaderVar != nullptr )
                 (*ppShaderVar)->Release();
         }
@@ -84,15 +94,15 @@ namespace Diligent
 
     void ShaderVariableParser::PushExistingObject( lua_State *L, const void *pObject )
     {
-        auto pShaderVariable = reinterpret_cast<IShaderVariable**>(lua_newuserdata( L, sizeof( IShaderVariable* ) ));
-        *pShaderVariable = reinterpret_cast<IShaderVariable*>( const_cast<void*>(pObject) );
+        auto pShaderVariable = reinterpret_cast<IShaderResourceVariable**>(lua_newuserdata( L, sizeof( IShaderResourceVariable* ) ));
+        *pShaderVariable = reinterpret_cast<IShaderResourceVariable*>( const_cast<void*>(pObject) );
         (*pShaderVariable)->AddRef();
     }
 
     int ShaderVariableParser::Set( lua_State *L )
     {
         // Shader variable is the first argument
-        auto *pShaderVar = *GetUserData<IShaderVariable**>( L, 1, m_MetatableRegistryName.c_str() );
+        auto *pShaderVar = *GetUserData<IShaderResourceVariable**>( L, 1, m_MetatableRegistryName.c_str() );
 
         IDeviceObject *pObject = nullptr;
         auto ArgType = lua_type( L, 2 );
@@ -126,14 +136,14 @@ namespace Diligent
         return 0;
     }
 
-    int ShaderVariableParser::GetShaderVariable( lua_State *L )
+    int ShaderVariableParser::GetStaticShaderVariable( lua_State *L )
     {
         return LuaCreate(L);
     }
 
-    void ShaderVariableParser::GetObjectByName( lua_State *L, const Char *ShaderName, IShaderVariable** ppObject )
+    void ShaderVariableParser::GetObjectByName( lua_State *L, const Char *ShaderName, IShaderResourceVariable** ppObject )
     {
-        auto pObject = *GetGlobalObject<IShaderVariable**>( L, ShaderName, m_MetatableRegistryName.c_str() );
+        auto pObject = *GetGlobalObject<IShaderResourceVariable**>( L, ShaderName, m_MetatableRegistryName.c_str() );
         *ppObject = pObject;
         pObject->AddRef();
     }