Add vector light support to forward materials.

Engine/source/lighting/advanced/advancedLightManager.cpp

@@ -391,6 +391,10 @@ void AdvancedLightManager::setLightInfo(  ProcessedMaterial *pmat,
                         lsc->mLightConfigDataSC,
                         lsc->mLightSpotDirSC,
                         lsc->mLightSpotParamsSC,
+                        lsc->mHasVectorLightSC,
+                        lsc->mVectorLightDirectionSC,
+                        lsc->mVectorLightColorSC,
+                        lsc->mVectorLightBrightnessSC,
                         shaderConsts );
 
    // Static

Engine/source/lighting/basic/basicLightManager.cpp

@@ -306,7 +306,11 @@ BasicLightManager::LightingShaderConstants::LightingShaderConstants()
       mLightAmbient( NULL ),
       mLightConfigDataSC( NULL ),
       mLightSpotDir( NULL ),
-      mLightSpotParamsSC( NULL )
+      mLightSpotParamsSC( NULL ),
+      mHasVectorLightSC(NULL),
+      mVectorLightDirectionSC(NULL),
+      mVectorLightColorSC(NULL),
+      mVectorLightBrightnessSC(NULL)
 {
 }
 
@@ -337,6 +341,11 @@ void BasicLightManager::LightingShaderConstants::init(GFXShader* shader)
    mLightSpotDir = shader->getShaderConstHandle( ShaderGenVars::lightSpotDir );
    mLightSpotParamsSC = shader->getShaderConstHandle( ShaderGenVars::lightSpotParams );
 
+   mHasVectorLightSC = shader->getShaderConstHandle(ShaderGenVars::hasVectorLight);
+   mVectorLightDirectionSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightDirection);
+   mVectorLightColorSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightColor);
+   mVectorLightBrightnessSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightBrightness);
+
    mInit = true;
 }
 
@@ -400,5 +409,9 @@ void BasicLightManager::setLightInfo(  ProcessedMaterial* pmat,
                         mLastConstants->mLightConfigDataSC,
                         mLastConstants->mLightSpotDir,
                         mLastConstants->mLightSpotParamsSC,
+                        mLastConstants->mHasVectorLightSC,
+                        mLastConstants->mVectorLightDirectionSC,
+                        mLastConstants->mVectorLightColorSC,
+                        mLastConstants->mVectorLightBrightnessSC,
                         shaderConsts );
 }

Engine/source/lighting/basic/basicLightManager.h

@@ -92,6 +92,11 @@ protected:
       GFXShaderConstHandle *mLightSpotDir;
       GFXShaderConstHandle *mLightSpotParamsSC;
 
+      GFXShaderConstHandle* mHasVectorLightSC;
+      GFXShaderConstHandle* mVectorLightDirectionSC;
+      GFXShaderConstHandle* mVectorLightColorSC;
+      GFXShaderConstHandle* mVectorLightBrightnessSC;
+
       LightingShaderConstants();
       ~LightingShaderConstants();
 

Engine/source/lighting/lightManager.cpp

@@ -309,6 +309,10 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
                                           GFXShaderConstHandle *lightConfigDataSC,
                                           GFXShaderConstHandle *lightSpotDirSC,
                                           GFXShaderConstHandle *lightSpotParamsSC,
+                                          GFXShaderConstHandle* hasVectorLightSC,
+                                          GFXShaderConstHandle* vectorLightDirectionSC,
+                                          GFXShaderConstHandle* vectorLightColorSC,
+                                          GFXShaderConstHandle* vectorLightBrightnessSC,
                                           GFXShaderConstBuffer *shaderConsts )
 {
    PROFILE_SCOPE( LightManager_Update4LightConsts );
@@ -417,6 +421,11 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
       shaderConsts->setSafe(lightConfigDataSC, lightConfigData);
       shaderConsts->setSafe(lightSpotParamsSC, lightSpotParams);
 
+      shaderConsts->setSafe(hasVectorLightSC, (int)hasVectorLight);
+      shaderConsts->setSafe(vectorLightDirectionSC, vectorLightDirection);
+      shaderConsts->setSafe(vectorLightColorSC, vectorLightColor);
+      shaderConsts->setSafe(vectorLightBrightnessSC, vectorLightBrightness);
+
       //================================================================
       //old setup
       /*static AlignedArray<Point4F> lightPositions( 3, sizeof( Point4F ) );

Engine/source/lighting/lightManager.h

@@ -178,6 +178,10 @@ protected:
                                     GFXShaderConstHandle *lightInvRadiusSqSC,
                                     GFXShaderConstHandle *lightSpotDirSC,
                                     GFXShaderConstHandle * lightSpotParamsSC,
+                                    GFXShaderConstHandle* hasVectorLightSC,
+                                    GFXShaderConstHandle* vectorLightDirectionSC,
+                                    GFXShaderConstHandle* vectorLightColorSC,
+                                    GFXShaderConstHandle* vectorLightBrightnessSC,
                                     GFXShaderConstBuffer *shaderConsts );
 
    /// A dummy default light used when no lights

Engine/source/lighting/shadowMap/lightShadowMap.cpp

@@ -462,6 +462,10 @@ LightingShaderConstants::LightingShaderConstants()
       mLightAmbientSC(NULL), 
       mLightConfigDataSC(NULL),
       mLightSpotDirSC(NULL),
+      mHasVectorLightSC(NULL),
+      mVectorLightDirectionSC(NULL),
+      mVectorLightColorSC(NULL),
+      mVectorLightBrightnessSC(NULL),
       mShadowMapSC(NULL), 
       mDynamicShadowMapSC(NULL), 
       mShadowMapSizeSC(NULL), 
@@ -525,6 +529,11 @@ void LightingShaderConstants::init(GFXShader* shader)
    mLightConfigDataSC = shader->getShaderConstHandle( ShaderGenVars::lightConfigData);
    mLightSpotDirSC = shader->getShaderConstHandle( ShaderGenVars::lightSpotDir );
 
+   mHasVectorLightSC = shader->getShaderConstHandle(ShaderGenVars::hasVectorLight);
+   mVectorLightDirectionSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightDirection);
+   mVectorLightColorSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightColor);
+   mVectorLightBrightnessSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightBrightness);
+
    mShadowMapSC = shader->getShaderConstHandle("$shadowMap");
    mDynamicShadowMapSC = shader->getShaderConstHandle("$dynamicShadowMap");
    mShadowMapSizeSC = shader->getShaderConstHandle("$shadowMapSize");

Engine/source/lighting/shadowMap/lightShadowMap.h

@@ -90,6 +90,11 @@ struct LightingShaderConstants
    GFXShaderConstHandle *mLightConfigDataSC;
    GFXShaderConstHandle *mLightSpotDirSC;
 
+   GFXShaderConstHandle* mHasVectorLightSC;
+   GFXShaderConstHandle* mVectorLightDirectionSC;
+   GFXShaderConstHandle* mVectorLightColorSC;
+   GFXShaderConstHandle* mVectorLightBrightnessSC;
+
    GFXShaderConstHandle* mShadowMapSC;
    GFXShaderConstHandle* mDynamicShadowMapSC;
    GFXShaderConstHandle* mShadowMapSizeSC;

Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp

@@ -2235,6 +2235,22 @@ void RTLightingFeatHLSL::processPix(   Vector<ShaderComponent*> &componentList,
    lightSpotParams->arraySize = 4;
    lightSpotParams->constSortPos = cspPotentialPrimitive;
 
+   Var* hasVectorLight = new Var("hasVectorLight", "int");
+   hasVectorLight->uniform = true;
+   hasVectorLight->constSortPos = cspPotentialPrimitive;
+
+   Var* vectorLightDirection = new Var("vectorLightDirection", "float4");
+   vectorLightDirection->uniform = true;
+   vectorLightDirection->constSortPos = cspPotentialPrimitive;
+
+   Var* vectorLightColor = new Var("vectorLightColor", "float4");
+   vectorLightColor->uniform = true;
+   vectorLightColor->constSortPos = cspPotentialPrimitive;
+
+   Var* vectorLightBrightness = new Var("vectorLightBrightness", "float");
+   vectorLightBrightness->uniform = true;
+   vectorLightBrightness->constSortPos = cspPotentialPrimitive;
+
    Var* surface = getSurface(componentList, meta, fd);
    if (!surface)
    {
@@ -2253,8 +2269,9 @@ void RTLightingFeatHLSL::processPix(   Vector<ShaderComponent*> &componentList,
    
    Var* lighting = new Var("lighting", "float4");
    meta->addStatement(new GenOp("   @ = compute4Lights( @, @, @, @,\r\n"
-      "      @, @, @);\r\n",
-      new DecOp(lighting), surface, lightMask, inLightPos, inLightConfigData, inLightColor, inLightSpotDir, lightSpotParams));
+      "      @, @, @, @, @, @, @);\r\n",
+      new DecOp(lighting), surface, lightMask, inLightPos, inLightConfigData, inLightColor, inLightSpotDir, lightSpotParams,
+         hasVectorLight, vectorLightDirection, vectorLightColor, vectorLightBrightness));
 
    meta->addStatement(new GenOp("   @.rgb += @.rgb;\r\n", curColor, lighting));
 

Engine/source/shaderGen/shaderGenVars.cpp

@@ -64,6 +64,12 @@ const String ShaderGenVars::lightAmbient("$ambient");
 const String ShaderGenVars::lightConfigData("$inLightConfigData");
 const String ShaderGenVars::lightSpotDir("$inLightSpotDir");
 const String ShaderGenVars::lightSpotParams("$lightSpotParams");
+
+const String ShaderGenVars::hasVectorLight("$hasVectorLight");
+const String ShaderGenVars::vectorLightDirection("$vectorLightDirection");
+const String ShaderGenVars::vectorLightColor("$vectorLightColor");
+const String ShaderGenVars::vectorLightBrightness("$vectorLightBrightness");
+
 const String ShaderGenVars::specularColor("$specularColor");
 const String ShaderGenVars::smoothness("$smoothness");
 const String ShaderGenVars::metalness("$metalness");

Engine/source/shaderGen/shaderGenVars.h

@@ -77,6 +77,11 @@ struct ShaderGenVars
    const static String lightConfigData;
    const static String lightSpotDir;
    const static String lightSpotParams;
+   const static String hasVectorLight;
+   const static String vectorLightDirection;
+   const static String vectorLightColor;
+   const static String vectorLightBrightness;
+
    const static String specularColor;
    const static String smoothness;
    const static String metalness;

Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl

@@ -240,7 +240,11 @@ float4 compute4Lights( Surface surface,
                      float4 inLightConfigData[4],
                      float4 inLightColor[4],
                      float4 inLightSpotDir[4],
-                     float4 lightSpotParams[4] )
+                     float4 lightSpotParams[4],
+                     int hasVectorLight,
+                     float4 vectorLightDirection,
+                     float4 vectorLightingColor,
+                     float  vectorLightBrightness )
 {
    float3 finalLighting = 0.0.xxx;
 
@@ -280,6 +284,17 @@ float4 compute4Lights( Surface surface,
       }
       finalLighting += lighting;
    }
+
+   //Vector light
+   [branch]
+   if(hasVectorLight)
+   {
+      SurfaceToLight surfaceToVecLight = createSurfaceToLight(surface, -vectorLightDirection.xyz);
+
+      float3 vecLighting = getDirectionalLight(surface, surfaceToVecLight, vectorLightingColor.rgb, vectorLightBrightness, 1);
+      finalLighting += vecLighting;
+   }
+
    finalLighting *= shadowMask.rgb;
 
    return float4(finalLighting,1);