Added shader parameter register count information in the D3D shader file format.

Added tracking of last assigned shader parameter per hardware register to D3D9Graphics. This allows reusing shader registers for different parameters in different shaders.
Removed the ElapsedTime shader parameter, as wrapping it is problematic depending on the calculations it would be used for.
Removed support for bool & int shader parameters from Graphics, as bool constants are not supported in OpenGL 2.0, and int parameters are not (at least currently) needed, and can lead to worse performance.

Docs/Reference.dox

@@ -1280,6 +1280,7 @@ uint       Number of constant parameters
     For each constant parameter:
     cstring    Parameter name
     byte       Hardware register index
+    byte       Number of hardware registers
 
 uint       Number of texture units (0 for vertex shaders)
 

Engine/Graphics/Direct3D9/D3D9Graphics.cpp

@@ -929,42 +929,20 @@ void Graphics::SetShaders(ShaderVariation* vs, ShaderVariation* ps)
     }
 }
 
-void Graphics::SetShaderParameter(StringHash param, const bool* data, unsigned count)
-{
-    HashMap<StringHash, ShaderParameter>::ConstIterator i = shaderParameters_.Find(param);
-    if (i == shaderParameters_.End())
-        return;
-    
-    if (i->second_.type_ == VS)
-       impl_->device_->SetVertexShaderConstantB(i->second_.register_, (const BOOL*)data, count);
-    else
-       impl_->device_->SetPixelShaderConstantB(i->second_.register_, (const BOOL*)data, count);
-}
-
 void Graphics::SetShaderParameter(StringHash param, const float* data, unsigned count)
 {
     HashMap<StringHash, ShaderParameter>::ConstIterator i = shaderParameters_.Find(param);
     if (i == shaderParameters_.End())
         return;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, count / 4);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, data, count / 4);
     else
         impl_->device_->SetPixelShaderConstantF(i->second_.register_, data, count / 4);
 }
 
-void Graphics::SetShaderParameter(StringHash param, const int* data, unsigned count)
-{
-    HashMap<StringHash, ShaderParameter>::ConstIterator i = shaderParameters_.Find(param);
-    if (i == shaderParameters_.End())
-        return;
-    
-    if (i->second_.type_ == VS)
-        impl_->device_->SetVertexShaderConstantI(i->second_.register_, data, count / 4);
-    else
-        impl_->device_->SetPixelShaderConstantI(i->second_.register_, data, count / 4);
-}
-
 void Graphics::SetShaderParameter(StringHash param, float value)
 {
     HashMap<StringHash, ShaderParameter>::ConstIterator i = shaderParameters_.Find(param);
@@ -978,6 +956,8 @@ void Graphics::SetShaderParameter(StringHash param, float value)
     data[2] = 0.0f;
     data[3] = 0.0f;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 1);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, &data[0], 1);
     else
@@ -990,6 +970,8 @@ void Graphics::SetShaderParameter(StringHash param, const Color& color)
     if (i == shaderParameters_.End())
         return;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 1);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, color.GetData(), 1);
     else
@@ -1017,6 +999,8 @@ void Graphics::SetShaderParameter(StringHash param, const Matrix3& matrix)
     data[10] = matrix.m22_;
     data[11] = 0.0f;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 3);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, &data[0], 3);
     else
@@ -1036,6 +1020,8 @@ void Graphics::SetShaderParameter(StringHash param, const Vector3& vector)
     data[2] = vector.z_;
     data[3] = 0.0f;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 1);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, &data[0], 1);
     else
@@ -1048,6 +1034,8 @@ void Graphics::SetShaderParameter(StringHash param, const Matrix4& matrix)
     if (i == shaderParameters_.End())
         return;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 4);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, matrix.GetData(), 4);
     else
@@ -1060,6 +1048,8 @@ void Graphics::SetShaderParameter(StringHash param, const Vector4& vector)
     if (i == shaderParameters_.End())
         return;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 1);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, vector.GetData(), 1);
     else
@@ -1072,18 +1062,21 @@ void Graphics::SetShaderParameter(StringHash param, const Matrix3x4& matrix)
     if (i == shaderParameters_.End())
         return;
     
+    AssignShaderRegisters(i->second_.type_, param, i->second_.register_, 3);
+    
     if (i->second_.type_ == VS)
         impl_->device_->SetVertexShaderConstantF(i->second_.register_, matrix.GetData(), 3);
     else
         impl_->device_->SetPixelShaderConstantF(i->second_.register_, matrix.GetData(), 3);
 }
 
-void Graphics::DefineShaderParameter(StringHash param, ShaderType type, unsigned hwReg)
+void Graphics::DefineShaderParameter(StringHash param, ShaderType type, unsigned reg, unsigned regCount)
 {
     unsigned oldSize = shaderParameters_.Size();
     
     shaderParameters_[param].type_ = type;
-    shaderParameters_[param].register_ = hwReg;
+    shaderParameters_[param].register_ = reg;
+    shaderParameters_[param].regCount_ = regCount;
     
     // Rehash if necessary to ensure minimum load factor and fast queries
     unsigned newSize = shaderParameters_.Size();
@@ -1099,19 +1092,49 @@ bool Graphics::NeedParameterUpdate(StringHash param, const void* source)
     
     if (i->second_.type_ == VS)
     {
-        if (i->second_.lastSource_ != source && vertexShader_ && vertexShader_->HasParameter(param))
+        if (!vertexShader_ || !vertexShader_->HasParameter(param))
+            return false;
+        
+        if (i->second_.lastSource_ != source)
         {
             i->second_.lastSource_ = source;
             return true;
         }
+        else
+        {
+            // If last source is same, check if the register assignment has changed
+            unsigned lastReg = i->second_.register_ + i->second_.regCount_;
+            for (unsigned j = i->second_.register_; j < lastReg; ++j)
+            {
+                if (vsRegisterAssignments_[j] != param)
+                    return true;
+            }
+            
+            return false;
+        }
     }
     else
     {
-        if (i->second_.lastSource_ != source && pixelShader_ && pixelShader_->HasParameter(param))
+        if (!pixelShader_ || !pixelShader_->HasParameter(param))
+            return false;
+        
+        if (i->second_.lastSource_ != source)
         {
             i->second_.lastSource_ = source;
             return true;
         }
+        else
+        {
+            // If last source is same, check if the register assignment has changed
+            unsigned lastReg = i->second_.register_ + i->second_.regCount_;
+            for (unsigned j = i->second_.register_; j < lastReg; ++j)
+            {
+                if (psRegisterAssignments_[j] != param)
+                    return true;
+            }
+            
+            return false;
+        }
     }
     
     return false;
@@ -1126,6 +1149,10 @@ void Graphics::ClearParameterSources()
 {
     for (HashMap<StringHash, ShaderParameter>::Iterator i = shaderParameters_.Begin(); i != shaderParameters_.End(); ++i)
         i->second_.lastSource_ = (const void*)M_MAX_UNSIGNED;
+    for (unsigned i = 0; i < MAX_VS_REGISTERS; ++i)
+        vsRegisterAssignments_[i] = StringHash();
+    for (unsigned i = 0; i < MAX_PS_REGISTERS; ++i)
+        psRegisterAssignments_[i] = StringHash();
 }
 
 void Graphics::ClearTransformSources()
@@ -2288,6 +2315,22 @@ void Graphics::SetTextureUnitMappings()
     textureUnits_["IndirectionCubeMap"] = TU_INDIRECTION;
 }
 
+void Graphics::AssignShaderRegisters(ShaderType type, StringHash param, unsigned reg, unsigned regCount)
+{
+    unsigned lastReg = reg + regCount;
+    
+    if (type == VS)
+    {
+        for (unsigned i = reg; i < lastReg; ++i)
+            vsRegisterAssignments_[i] = param;
+    }
+    else
+    {
+        for (unsigned i = reg; i < lastReg; ++i)
+            psRegisterAssignments_[i] = param;
+    }
+}
+
 void Graphics::HandleWindowMessage(StringHash eventType, VariantMap& eventData)
 {
     using namespace WindowMessage;

Engine/Graphics/Direct3D9/D3D9Graphics.h

@@ -56,6 +56,8 @@ struct ShaderParameter
     ShaderType type_;
     /// Hardware register.
     unsigned register_;
+    /// Number of registers.
+    unsigned regCount_;
     /// Last source.
     const void* lastSource_;
 };
@@ -108,12 +110,8 @@ public:
     void SetIndexBuffer(IndexBuffer* buffer);
     /// %Set shaders.
     void SetShaders(ShaderVariation* vs, ShaderVariation* ps);
-    /// %Set shader bool constants.
-    void SetShaderParameter(StringHash param, const bool* data, unsigned count);
     /// %Set shader float constants.
     void SetShaderParameter(StringHash param, const float* data, unsigned count);
-    /// %Set shader int constants.
-    void SetShaderParameter(StringHash param, const int* data, unsigned count);
     /// %Set shader float constant.
     void SetShaderParameter(StringHash param, float value);
     /// %Set shader color constant.
@@ -129,7 +127,7 @@ public:
     /// %Set shader 3x4 matrix constant.
     void SetShaderParameter(StringHash param, const Matrix3x4& matrix);
     /// Define a shader parameter. Called by Shader.
-    void DefineShaderParameter(StringHash param, ShaderType type, unsigned hwReg);
+    void DefineShaderParameter(StringHash param, ShaderType type, unsigned reg, unsigned regCount);
     /// Check whether a shader parameter in the currently set shaders needs update.
     bool NeedParameterUpdate(StringHash param, const void* source);
     /// Check whether the current pixel shader uses a texture unit.
@@ -365,9 +363,11 @@ private:
     void ResetCachedState();
     /// Initialize texture unit mappings.
     void SetTextureUnitMappings();
+    /// Assign a shader parameter to hardware registers and clear remembered source if another parameter was overwritten.
+    void AssignShaderRegisters(ShaderType type, StringHash param, unsigned reg, unsigned count);
     /// Handle operating system window message.
     void HandleWindowMessage(StringHash eventType, VariantMap& eventData);
-    
+
     /// Implementation.
     GraphicsImpl* impl_;
     /// Window title.
@@ -456,6 +456,10 @@ private:
     ShaderVariation* pixelShader_;
     /// Shader parameters.
     HashMap<StringHash, ShaderParameter> shaderParameters_;
+    /// Currently assigned vertex shader parameter per hardware register.
+    StringHash vsRegisterAssignments_[MAX_VS_REGISTERS];
+    /// Currently assigned pixel shader parameter per hardware register.
+    StringHash psRegisterAssignments_[MAX_PS_REGISTERS];
     /// Textures in use.
     Texture* textures_[MAX_TEXTURE_UNITS];
     /// Texture unit mappings.

Engine/Graphics/Direct3D9/D3D9Shader.cpp

@@ -34,6 +34,26 @@
 
 OBJECTTYPESTATIC(Shader);
 
+/// Temporary shader parameter description for loading.
+struct ShaderParameterDesc
+{
+    /// Parameter name.
+    String name_;
+    /// Hardware register index.
+    unsigned register_;
+    /// Number of registers.
+    unsigned regCount_;
+};
+
+/// Temporary texture unit description for loading.
+struct TextureUnitDesc
+{
+    /// Texture unit name.
+    String name_;
+    /// Hardware sampler index.
+    unsigned sampler_;
+};
+
 Shader::Shader(Context* context) :
     Resource(context),
     shaderType_(VS),
@@ -72,32 +92,33 @@ bool Shader::Load(Deserializer& source)
     shaderType_ = (ShaderType)source.ReadShort();
     isSM3_ = (source.ReadShort() == 3);
     
-    Vector<Pair<String, unsigned char> > parameters;
-    Vector<Pair<String, unsigned char> > textureUnits;
+    Vector<ShaderParameterDesc> parameters;
+    Vector<TextureUnitDesc> textureUnits;
     
     // Read the parameters and texture units used by this shader; use information is specified in terms of them
     unsigned numParameters = source.ReadUInt();
     for (unsigned i = 0; i < numParameters; ++i)
     {
-        Pair<String, unsigned char> newParameter;
-        newParameter.first_ = source.ReadString();
-        newParameter.second_ = source.ReadUByte();
+        ShaderParameterDesc newParameter;
+        newParameter.name_ = source.ReadString();
+        newParameter.register_ = source.ReadUByte();
+        newParameter.regCount_ = source.ReadUByte();
         parameters.Push(newParameter);
         
-        graphics->DefineShaderParameter(StringHash(newParameter.first_), shaderType_, newParameter.second_);
+        graphics->DefineShaderParameter(StringHash(newParameter.name_), shaderType_, newParameter.register_, newParameter.regCount_);
     }
     
     unsigned numTextureUnits = source.ReadUInt();
     for (unsigned i = 0; i < numTextureUnits; ++i)
     {
-        Pair<String, unsigned char> newTextureUnit;
-        newTextureUnit.first_ = source.ReadString();
-        newTextureUnit.second_ = source.ReadUByte();
+        TextureUnitDesc newTextureUnit;
+        newTextureUnit.name_ = source.ReadString();
+        newTextureUnit.sampler_ = source.ReadUByte();
         textureUnits.Push(newTextureUnit);
         
-        TextureUnit tuIndex = graphics->GetTextureUnit(newTextureUnit.first_);
+        TextureUnit tuIndex = graphics->GetTextureUnit(newTextureUnit.name_);
         if (tuIndex == MAX_TEXTURE_UNITS)
-            LOGWARNING("Unknown texture unit " + newTextureUnit.first_);
+            LOGWARNING("Unknown texture unit " + newTextureUnit.name_);
     }
     
     // Read the variations
@@ -116,7 +137,7 @@ bool Shader::Load(Deserializer& source)
         for (unsigned j = 0; j < numParameters; ++j)
         {
             if (source.ReadBool())
-                variation->SetUseParameter(StringHash(parameters[j].first_), true);
+                variation->SetUseParameter(StringHash(parameters[j].name_), true);
         }
         
         variation->OptimizeParameters();
@@ -125,7 +146,7 @@ bool Shader::Load(Deserializer& source)
         {
             if (source.ReadBool())
             {
-                TextureUnit tuIndex = graphics->GetTextureUnit(textureUnits[j].first_);
+                TextureUnit tuIndex = graphics->GetTextureUnit(textureUnits[j].name_);
                 if (tuIndex != MAX_TEXTURE_UNITS)
                     variation->SetUseTextureUnit(tuIndex, true);
             }

Engine/Graphics/GraphicsDefs.cpp

@@ -29,7 +29,6 @@
 StringHash VSP_CAMERAPOS("CameraPos");
 StringHash VSP_CAMERAROT("CameraRot");
 StringHash VSP_DEPTHMODE("DepthMode");
-StringHash VSP_ELAPSEDTIME("ElapsedTime");
 StringHash VSP_LIGHTATTEN("LightAtten");
 StringHash VSP_LIGHTDIR("LightDir");
 StringHash VSP_LIGHTPOS("LightPos");
@@ -44,7 +43,6 @@ StringHash VSP_VIEWRIGHTVECTOR("ViewRightVector");
 StringHash VSP_VIEWUPVECTOR("ViewUpVector");
 StringHash VSP_SKINMATRICES("SkinMatrices");
 StringHash PSP_AMBIENTCOLOR("AmbientColor");
-StringHash PSP_ELAPSEDTIME("ElapsedTimePS");
 StringHash PSP_FOGCOLOR("FogColor");
 StringHash PSP_FOGPARAMS("FogParams");
 StringHash PSP_LIGHTCOLOR("LightColor");

Engine/Graphics/GraphicsDefs.h

@@ -196,7 +196,6 @@ enum ShaderType
 extern StringHash VSP_CAMERAPOS;
 extern StringHash VSP_CAMERAROT;
 extern StringHash VSP_DEPTHMODE;
-extern StringHash VSP_ELAPSEDTIME;
 extern StringHash VSP_LIGHTATTEN;
 extern StringHash VSP_LIGHTDIR;
 extern StringHash VSP_LIGHTPOS;
@@ -211,7 +210,6 @@ extern StringHash VSP_VIEWRIGHTVECTOR;
 extern StringHash VSP_VIEWUPVECTOR;
 extern StringHash VSP_SKINMATRICES;
 extern StringHash PSP_AMBIENTCOLOR;
-extern StringHash PSP_ELAPSEDTIME;
 extern StringHash PSP_FOGCOLOR;
 extern StringHash PSP_FOGPARAMS;
 extern StringHash PSP_LIGHTCOLOR;
@@ -278,5 +276,6 @@ static const float ANIMATION_LOD_BASESCALE = 2.5f;
 static const int MAX_RENDERTARGETS = 4;
 static const int MAX_VERTEX_STREAMS = 4;
 static const int MAX_SKIN_MATRICES = 64;
-static const int MAX_CONSTANT_REGISTERS = 256;
 static const int MAX_IMMEDIATE_ELEMENTS = 4;
+static const int MAX_VS_REGISTERS = 256;
+static const int MAX_PS_REGISTERS = 32;

Engine/Graphics/OpenGL/OGLGraphics.cpp

@@ -804,11 +804,6 @@ void Graphics::SetShaders(ShaderVariation* vs, ShaderVariation* ps)
     }
 }
 
-void Graphics::SetShaderParameter(StringHash param, const bool* data, unsigned count)
-{
-    // Not supported
-}
-
 void Graphics::SetShaderParameter(StringHash param, const float* data, unsigned count)
 {
     if (shaderProgram_)
@@ -846,35 +841,6 @@ void Graphics::SetShaderParameter(StringHash param, const float* data, unsigned
     }
 }
 
-void Graphics::SetShaderParameter(StringHash param, const int* data, unsigned count)
-{
-    if (shaderProgram_)
-    {
-        const ShaderParameter* info = shaderProgram_->GetParameter(param);
-        if (info)
-        {
-            switch (info->type_)
-            {
-            case GL_INT:
-                glUniform1iv(info->location_, count, data);
-                break;
-                
-            case GL_INT_VEC2:
-                glUniform2iv(info->location_, count / 2, data);
-                break;
-                
-            case GL_INT_VEC3:
-                glUniform3iv(info->location_, count / 3, data);
-                break;
-                
-            case GL_INT_VEC4:
-                glUniform4iv(info->location_, count / 4, data);
-                break;
-            }
-        }
-    }
-}
-
 void Graphics::SetShaderParameter(StringHash param, float value)
 {
     if (shaderProgram_)

Engine/Graphics/OpenGL/OGLGraphics.h

@@ -98,12 +98,8 @@ public:
     void SetIndexBuffer(IndexBuffer* buffer);
     /// Set shaders.
     void SetShaders(ShaderVariation* vs, ShaderVariation* ps);
-    /// Set shader bool constants.
-    void SetShaderParameter(StringHash param, const bool* data, unsigned count);
     /// Set shader float constants.
     void SetShaderParameter(StringHash param, const float* data, unsigned count);
-    /// Set shader int constants.
-    void SetShaderParameter(StringHash param, const int* data, unsigned count);
     /// Set shader float constant.
     void SetShaderParameter(StringHash param, float value);
     /// Set shader color constant.

Engine/Graphics/View.cpp

@@ -1511,7 +1511,6 @@ void View::CalculateShaderParameters()
         fogStart = fogEnd * (1.0f - M_LARGE_EPSILON);
     float fogRange = Max(fogEnd - fogStart, M_EPSILON);
     Vector4 fogParams(fogStart / farClip, fogEnd / farClip, 1.0f / (fogRange / farClip), 0.0f);
-    Vector4 elapsedTime((time->GetTotalMSec() & 0x3fffff) / 1000.0f, 0.0f, 0.0f, 0.0f);
     
     Vector4 depthMode = Vector4::ZERO;
     if (camera_->IsOrthographic())
@@ -1529,9 +1528,7 @@ void View::CalculateShaderParameters()
     
     shaderParameters_.Clear();
     shaderParameters_[VSP_DEPTHMODE] = depthMode;
-    shaderParameters_[VSP_ELAPSEDTIME] = elapsedTime;
     shaderParameters_[PSP_AMBIENTCOLOR] = zone_->GetAmbientColor().ToVector4();
-    shaderParameters_[PSP_ELAPSEDTIME] = elapsedTime;
     shaderParameters_[PSP_FOGCOLOR] = zone_->GetFogColor().ToVector4(),
     shaderParameters_[PSP_FOGPARAMS] = fogParams;
 }

SourceAssets/GLSLShaders/Uniforms.frag

@@ -1,5 +1,4 @@
 uniform vec3 cAmbientColor;
-uniform vec2 cElapsedTimePS;
 uniform vec4 cFogParams;
 uniform vec3 cFogColor;
 uniform vec4 cLightColor;

SourceAssets/GLSLShaders/Uniforms.vert

@@ -1,7 +1,6 @@
 uniform vec3 cCameraPos;
 uniform mat3 cCameraRot;
 uniform vec4 cDepthMode;
-uniform vec2 cElapsedTime;
 uniform float cLightAtten;
 uniform vec3 cLightDir;
 uniform vec3 cLightPos;

SourceAssets/HLSLShaders/Uniforms.hlsl

@@ -2,33 +2,31 @@
 uniform float3 cCameraPos : register(C0);
 uniform float3x3 cCameraRot : register(C1);
 uniform float4 cDepthMode : register(C4);
-uniform float2 cElapsedTime : register(C5);
-uniform float cLightAtten : register(C6);
-uniform float3 cLightDir : register(C7);
-uniform float3 cLightPos : register(C8);
-uniform float3x3 cLightVecRot: register(C9);
-uniform float4x3 cModel : register(C12);
-uniform float4x4 cSpotProj : register(C15);
-uniform float4x4 cViewProj : register(C19);
-uniform float4 cUOffset : register(C23);
-uniform float4 cVOffset : register(C24);
-uniform float3 cViewRightVector : register(C25);
-uniform float3 cViewUpVector : register(C26);
-uniform float4x4 cShadowProj[4] : register(C27);
-uniform float4x3 cSkinMatrices[64] : register(C43);
+uniform float cLightAtten : register(C5);
+uniform float3 cLightDir : register(C6);
+uniform float3 cLightPos : register(C7);
+uniform float3x3 cLightVecRot: register(C8);
+uniform float4x3 cModel : register(C11);
+uniform float4x4 cSpotProj : register(C14);
+uniform float4x4 cViewProj : register(C18);
+uniform float4 cUOffset : register(C22);
+uniform float4 cVOffset : register(C23);
+uniform float3 cViewRightVector : register(C24);
+uniform float3 cViewUpVector : register(C25);
+uniform float4x4 cShadowProj[4] : register(C26);
+uniform float4x3 cSkinMatrices[64] : register(C42);
 
 // Pixel shader parameters
 uniform float3 cAmbientColor : register(C0);
-uniform float2 cElapsedTimePS : register(C1);
-uniform float4 cFogParams : register(C2);
-uniform float3 cFogColor : register(C3);
-uniform float4 cLightColor : register(C4);
-uniform float4 cMatDiffColor : register(C5);
-uniform float3 cMatEmissiveColor : register(C6);
-uniform float2 cMatSpecProperties : register(C7);
-uniform float2 cSampleOffsets : register(C8);
-uniform float4 cShadowCubeAdjust : register(C9);
-uniform float2 cShadowCubeProj : register(C10);
-uniform float2 cShadowFade : register(C11);
-uniform float4 cShadowIntensity : register(C12);
-uniform float4 cShadowSplits : register(C13);
+uniform float4 cFogParams : register(C1);
+uniform float3 cFogColor : register(C2);
+uniform float4 cLightColor : register(C3);
+uniform float4 cMatDiffColor : register(C4);
+uniform float3 cMatEmissiveColor : register(C5);
+uniform float2 cMatSpecProperties : register(C6);
+uniform float2 cSampleOffsets : register(C7);
+uniform float4 cShadowCubeAdjust : register(C8);
+uniform float2 cShadowCubeProj : register(C9);
+uniform float2 cShadowFade : register(C10);
+uniform float4 cShadowIntensity : register(C11);
+uniform float4 cShadowSplits : register(C12);

Tools/ShaderCompiler/ShaderCompiler.cpp

@@ -53,9 +53,10 @@ struct Parameter
     {
     }
     
-    Parameter(const String& name, unsigned index) :
+    Parameter(const String& name, unsigned index, unsigned regCount) :
         name_(name),
-        index_(index)
+        index_(index),
+        regCount_(regCount)
     {
     }
     
@@ -63,24 +64,29 @@ struct Parameter
     {
         if (index_ != rhs.index_)
             return index_ < rhs.index_;
-        else
+        else if (name_ != rhs.name_)
             return name_ < rhs.name_;
+        else
+            return regCount_ < rhs.regCount_;
     }
     
     bool operator > (const Parameter& rhs) const
     {
         if (index_ != rhs.index_)
             return index_ > rhs.index_;
-        else
+        else if (name_ != rhs.name_)
             return name_ > rhs.name_;
+        else
+            return regCount_ > rhs.regCount_;
     }
     
-    bool operator == (const Parameter& rhs) const { return index_ == rhs.index_ && name_ == rhs.name_; }
+    bool operator == (const Parameter& rhs) const { return index_ == rhs.index_ && name_ == rhs.name_ && regCount_ == rhs.regCount_; }
     
-    bool operator != (const Parameter& rhs) const { return index_ != rhs.index_ || name_ != rhs.name_; }
+    bool operator != (const Parameter& rhs) const { return index_ != rhs.index_ || name_ != rhs.name_ || regCount_ != rhs.regCount_; }
     
     String name_;
     unsigned index_;
+    unsigned regCount_;
 };
 
 struct Variation
@@ -571,6 +577,7 @@ void CompileVariations(const Shader& baseShader, XMLElement& shaders)
     {
         outFile.WriteString(constants[i].name_);
         outFile.WriteUByte(constants[i].index_);
+        outFile.WriteUByte(constants[i].regCount_);
     }
     
     outFile.WriteUInt(textureUnits.Size());
@@ -683,6 +690,7 @@ void Compile(CompiledVariation* variation)
             
             String name(constantDesc.Name);
             unsigned index = constantDesc.RegisterIndex;
+            unsigned regCount = constantDesc.RegisterCount;
             
             // Check if the parameter is a constant or a texture sampler
             bool isSampler = (name[0] == 's');
@@ -695,14 +703,14 @@ void Compile(CompiledVariation* variation)
                 // Skip if it's a G-buffer sampler
                 if (name.Find("Buffer") == String::NPOS)
                 {
-                    Parameter newTextureUnit(name, index);
+                    Parameter newTextureUnit(name, index, 1);
                     variation->textureUnits_.Insert(newTextureUnit);
                     textureUnits_.Insert(newTextureUnit);
                 }
             }
             else
             {
-                Parameter newParam(name, index);
+                Parameter newParam(name, index, regCount);
                 variation->constants_.Insert(newParam);
                 constants_.Insert(newParam);
             }