more misc cleanup, including cutting down on sampling the pbrconfigmap by filling that out first, and drawing the smooth and metal vars from it, and filling out an ao var in case folks wanna use that later, as well as a bit more doubled up functionality prune-down. still tracing why forward lit seems to have lost the map config feature

Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.cpp

@@ -117,7 +117,7 @@ void PBRConfigMapGLSL::processVert( Vector<ShaderComponent*> &componentList,
 }
 
 // Material Info Flags -> Red ( Flags ) of Material Info Buffer.
-void DeferredMatInfoFlagsGLSL::processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd )
+void MatInfoFlagsGLSL::processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd )
 {
 	MultiLine *meta = new MultiLine;
 

Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.h

@@ -47,7 +47,7 @@ public:
                              const MaterialFeatureData &fd );
 };
 
-class DeferredMatInfoFlagsGLSL : public ShaderFeatureGLSL
+class MatInfoFlagsGLSL : public ShaderFeatureGLSL
 {
 public:
    virtual String getName() { return "Deferred Shading: Mat Info Flags"; }

Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.cpp

@@ -89,16 +89,20 @@ void PBRConfigMapHLSL::processPix( Vector<ShaderComponent*> &componentList, cons
    if (!metalness) metalness = new Var("metalness", "float");
    Var *smoothness = (Var*)LangElement::find("smoothness");
    if (!smoothness) smoothness = new Var("smoothness", "float");
+   Var* ao = (Var*)LangElement::find("ao");
+   if (!ao) ao = new Var("ao", "float");
 
-   meta->addStatement(new GenOp("   @ = @.r;\r\n", new DecOp(smoothness), texOp));
-   meta->addStatement(new GenOp("   @ = @.b;\r\n", new DecOp(metalness), texOp));
 
+   meta->addStatement(new GenOp("   @.bga = @.rgb;\r\n", pbrConfig, texOp));
+
+   meta->addStatement(new GenOp("   @ = @.b;\r\n", new DecOp(smoothness), pbrConfig));
    if (fd.features[MFT_InvertSmoothness])
+   {
+      meta->addStatement(new GenOp("   @.b = [email protected];\r\n", pbrConfig, pbrConfig));
       meta->addStatement(new GenOp("   @ = 1.0-@;\r\n", smoothness, smoothness));
-
-   if (!fd.features[MFT_isDeferred])
-   meta->addStatement(new GenOp("   @ = @.ggga;\r\n", pbrConfig, texOp));
-   meta->addStatement(new GenOp("   @.bga = float3(@,@.g,@);\r\n", pbrConfig, smoothness, pbrConfig, metalness));
+   }
+   meta->addStatement(new GenOp("   @ = @.g;\r\n", new DecOp(ao), pbrConfig));
+   meta->addStatement(new GenOp("   @ = @.a;\r\n", new DecOp(metalness), pbrConfig));
    output = meta;
 }
 
@@ -137,8 +141,13 @@ void PBRConfigMapHLSL::processVert( Vector<ShaderComponent*> &componentList,
    output = meta;
 }
 
+U32 MatInfoFlagsHLSL::getOutputTargets(const MaterialFeatureData& fd) const
+{
+   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget2 : ShaderFeature::DefaultTarget;
+}
+
 // Material Info Flags -> Red ( Flags ) of Material Info Buffer.
-void DeferredMatInfoFlagsHLSL::processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd )
+void MatInfoFlagsHLSL::processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd )
 {
    // search for material var
    Var* pbrConfig;

Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.h

@@ -48,15 +48,15 @@ public:
                              const MaterialFeatureData &fd );
 };
 
-class DeferredMatInfoFlagsHLSL : public ShaderFeatureHLSL
+class MatInfoFlagsHLSL : public ShaderFeatureHLSL
 {
 public:
    virtual String getName() { return "Deferred Shading: Mat Info Flags"; }
 
    virtual void processPix( Vector<ShaderComponent*> &componentList, 
       const MaterialFeatureData &fd );
-   
-   virtual U32 getOutputTargets( const MaterialFeatureData &fd ) const { return ShaderFeature::RenderTarget2; }
+
+   virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
 };
 
 class PBRConfigVarsHLSL : public ShaderFeatureHLSL

Engine/source/materials/materialFeatureTypes.cpp

@@ -44,9 +44,12 @@ ImplementFeatureType( MFT_DiffuseColor, MFG_Texture, 5.0f, true );
 ImplementFeatureType( MFT_DiffuseVertColor, MFG_Texture, 6.0f, true );
 ImplementFeatureType( MFT_AlphaTest, MFG_Texture, 7.0f, true );
 ImplementFeatureType(MFT_InvertSmoothness, U32(-1), -1, true);
-ImplementFeatureType( MFT_GlowMap, MFG_Texture, 9.0f, true );
-ImplementFeatureType( MFT_NormalMap, MFG_Texture, 10.0f, true );
-ImplementFeatureType( MFT_DetailNormalMap, MFG_Texture, 11.0f, true );
+ImplementFeatureType( MFT_PBRConfigMap, MFG_Texture, 8.0f, false );
+ImplementFeatureType( MFT_PBRConfigVars, MFG_Texture, 8.0f, false );
+ImplementFeatureType( MFT_MatInfoFlags, MFG_Texture, 9.0f, false );
+ImplementFeatureType( MFT_GlowMap, MFG_Texture, 10.0f, true );
+ImplementFeatureType( MFT_NormalMap, MFG_Texture, 11.0f, true );
+ImplementFeatureType( MFT_DetailNormalMap, MFG_Texture, 12.0f, true );
 ImplementFeatureType( MFT_Imposter, U32(-1), -1, true );
 
 ImplementFeatureType( MFT_AccuMap, MFG_PreLighting, 2.0f, true );
@@ -101,9 +104,6 @@ ImplementFeatureType( MFT_ImposterVert, MFG_PreTransform, 1.0, false );
 // Deferred Shading
 ImplementFeatureType( MFT_isDeferred, U32(-1), -1, true );
 ImplementFeatureType( MFT_SkyBox, MFG_Transform, 1.0f, false );
-ImplementFeatureType( MFT_PBRConfigMap, MFG_Texture, 8.2f, false );
-ImplementFeatureType( MFT_PBRConfigVars, MFG_Texture, 8.5f, false );
-ImplementFeatureType( MFT_DeferredMatInfoFlags, MFG_Texture, 8.7f, false );
 ImplementFeatureType( MFT_DeferredEmissive, MFG_Texture, 8.9f, false);
 
 ImplementFeatureType( MFT_HardwareSkinning, MFG_Transform,-2.0, false );

Engine/source/materials/materialFeatureTypes.h

@@ -191,6 +191,6 @@ DeclareFeatureType( MFT_HardwareSkinning );
 // Deferred Shading
 DeclareFeatureType( MFT_isDeferred );
 DeclareFeatureType( MFT_SkyBox );
-DeclareFeatureType( MFT_DeferredMatInfoFlags );
+DeclareFeatureType( MFT_MatInfoFlags );
 DeclareFeatureType( MFT_DeferredEmissive );
 #endif // _MATERIALFEATURETYPES_H_

Engine/source/materials/processedMaterial.cpp

@@ -492,7 +492,7 @@ void ProcessedMaterial::_setStageData()
                mMaterial->mMetalMapFilename[i], mMaterial->mGlowMapFilename[i],
                inputKey, profile));
             if (!mStages[i].getTex(MFT_PBRConfigMap))
-               mMaterial->logError("Failed to load specular map %s for stage %i", _getTexturePath(mMaterial->mPBRConfigMapFilename[i]).c_str(), i);
+               mMaterial->logError("Failed to load PBR Config map %s for stage %i", _getTexturePath(mMaterial->mPBRConfigMapFilename[i]).c_str(), i);
          }
       }
    }

Engine/source/materials/processedShaderMaterial.cpp

@@ -444,18 +444,14 @@ void ProcessedShaderMaterial::_determineFeatures(  U32 stageNum,
    if (mStages[stageNum].getTex(MFT_PBRConfigMap))
    {
       fd.features.addFeature(MFT_PBRConfigMap);
+      if (mStages[stageNum].getTex(MFT_PBRConfigMap)->mHasTransparency)
+         fd.features.addFeature(MFT_GlowMap);
    }
    else
       fd.features.addFeature(MFT_PBRConfigVars);
 
-   if( fd.features[ MFT_PBRConfigMap ] )
-   {
-      // Check for an alpha channel on the PBR Config map. If it has one (and it
-      // has values less than 255) than the artist has put the glow map into
-      // the alpha channel.
-      if( mStages[stageNum].getTex( MFT_PBRConfigMap )->mHasTransparency )
-         fd.features.addFeature( MFT_GlowMap );
-   }
+   // Deferred Shading : Material Info Flags
+   fd.features.addFeature(MFT_MatInfoFlags);
 
    if ( mMaterial->mAccuEnabled[stageNum] )
    {

Engine/source/renderInstance/renderDeferredMgr.cpp

@@ -638,12 +638,14 @@ void ProcessedDeferredMaterial::_determineFeatures( U32 stageNum,
    if( mStages[stageNum].getTex( MFT_PBRConfigMap ) )
    {
        newFeatures.addFeature( MFT_PBRConfigMap );
+       if( mStages[stageNum].getTex( MFT_PBRConfigMap )->mHasTransparency )
+          newFeatures.addFeature( MFT_GlowMap );
    }
    else
        newFeatures.addFeature( MFT_PBRConfigVars );
 
    // Deferred Shading : Material Info Flags
-   newFeatures.addFeature( MFT_DeferredMatInfoFlags );
+   newFeatures.addFeature( MFT_MatInfoFlags );
 
    for ( U32 i=0; i < fd.features.getCount(); i++ )
    {

Engine/source/shaderGen/GLSL/shaderGenGLSLInit.cpp

@@ -102,7 +102,7 @@ void _initShaderGenGLSL( ShaderGen *shaderGen )
    FEATUREMGR->registerFeature( MFT_isDeferred, new NamedFeatureGLSL( "Deferred Material" ) );
    FEATUREMGR->registerFeature( MFT_PBRConfigMap, new PBRConfigMapGLSL );
    FEATUREMGR->registerFeature( MFT_PBRConfigVars, new PBRConfigVarsGLSL );
-   FEATUREMGR->registerFeature( MFT_DeferredMatInfoFlags, new DeferredMatInfoFlagsGLSL );
+   FEATUREMGR->registerFeature( MFT_MatInfoFlags, new MatInfoFlagsGLSL );
    FEATUREMGR->registerFeature( MFT_SkyBox, new NamedFeatureGLSL( "skybox" ) );
    FEATUREMGR->registerFeature( MFT_HardwareSkinning, new HardwareSkinningFeatureGLSL );
 }

Engine/source/shaderGen/HLSL/shaderGenHLSLInit.cpp

@@ -104,7 +104,7 @@ void _initShaderGenHLSL( ShaderGen *shaderGen )
    FEATUREMGR->registerFeature( MFT_isDeferred, new NamedFeatureHLSL( "Deferred Material" ) );
    FEATUREMGR->registerFeature( MFT_PBRConfigMap, new PBRConfigMapHLSL);
    FEATUREMGR->registerFeature( MFT_PBRConfigVars, new PBRConfigVarsHLSL);
-   FEATUREMGR->registerFeature( MFT_DeferredMatInfoFlags, new DeferredMatInfoFlagsHLSL );
+   FEATUREMGR->registerFeature( MFT_MatInfoFlags, new MatInfoFlagsHLSL );
    FEATUREMGR->registerFeature( MFT_DeferredEmissive, new DeferredEmissiveHLSL);
    FEATUREMGR->registerFeature( MFT_SkyBox,  new NamedFeatureHLSL( "skybox" ) );
    FEATUREMGR->registerFeature( MFT_HardwareSkinning, new HardwareSkinningFeatureHLSL );