Merge pull request #2009 from Areloch/Prepass_Deferred_Remainder

Catches the remaining prepass to deferred changes on the engine side.

Engine/source/lighting/advanced/advancedLightManager.cpp

@@ -116,23 +116,23 @@ void AdvancedLightManager::activate( SceneManager *sceneManager )
    mLightBinManager->assignName( "AL_LightBinMgr" );
 
    // First look for the deferred bin...
-   RenderDeferredMgr *prePassBin = _findDeferredRenderBin();
+   RenderDeferredMgr *deferredBin = _findDeferredRenderBin();
 
    // If we didn't find the deferred bin then add one.
-   if ( !prePassBin )
+   if ( !deferredBin )
    {
-      prePassBin = new RenderDeferredMgr( true, blendTargetFormat );
-      prePassBin->assignName( "AL_DeferredBin" );
-      prePassBin->registerObject();
-      getSceneManager()->getDefaultRenderPass()->addManager( prePassBin );
-      mDeferredRenderBin = prePassBin;
+      deferredBin = new RenderDeferredMgr( true, blendTargetFormat );
+      deferredBin->assignName( "AL_DeferredBin" );
+      deferredBin->registerObject();
+      getSceneManager()->getDefaultRenderPass()->addManager( deferredBin );
+      mDeferredRenderBin = deferredBin;
    }
 
    // Tell the material manager that deferred is enabled.
    MATMGR->setDeferredEnabled( true );
 
    // Insert our light bin manager.
-   mLightBinManager->setRenderOrder( prePassBin->getRenderOrder() + 0.01f );
+   mLightBinManager->setRenderOrder( deferredBin->getRenderOrder() + 0.01f );
    getSceneManager()->getDefaultRenderPass()->addManager( mLightBinManager );
 
    AdvancedLightingFeatures::registerFeatures(mDeferredRenderBin->getTargetFormat(), mLightBinManager->getTargetFormat());

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

@@ -748,16 +748,16 @@ void DeferredMinnaertHLSL::processPix( Vector<ShaderComponent*> &componentList,
    deferredBuffer->sampler = true;
    deferredBuffer->constNum = Var::getTexUnitNum();     // used as texture unit num here
 
-   Var* prePassTex = NULL;
+   Var* deferredTex = NULL;
    if (mIsDirect3D11)
    {
       deferredBuffer->setType("SamplerState");
-      prePassTex = new Var;
-      prePassTex->setName("prePassTex");
-      prePassTex->setType("Texture2D");
-      prePassTex->uniform = true;
-      prePassTex->texture = true;
-      prePassTex->constNum = deferredBuffer->constNum;
+      deferredTex = new Var;
+      deferredTex->setName("deferredTex");
+      deferredTex->setType("Texture2D");
+      deferredTex->uniform = true;
+      deferredTex->texture = true;
+      deferredTex->constNum = deferredBuffer->constNum;
    }
 
    // Texture coord
@@ -774,7 +774,7 @@ void DeferredMinnaertHLSL::processPix( Vector<ShaderComponent*> &componentList,
    Var *d_NL_Att = (Var*)LangElement::find( "d_NL_Att" );
 
    if (mIsDirect3D11)
-      meta->addStatement(new GenOp(avar("   float4 normalDepth = %s(@, ,@, @);\r\n", unconditionDeferredMethod.c_str()), deferredBuffer, prePassTex, uvScene));
+      meta->addStatement(new GenOp(avar("   float4 normalDepth = %s(@, ,@, @);\r\n", unconditionDeferredMethod.c_str()), deferredBuffer, deferredTex, uvScene));
    else
       meta->addStatement(new GenOp(avar("   float4 normalDepth = %s(@, @);\r\n", unconditionDeferredMethod.c_str()), deferredBuffer, uvScene));
 

Engine/source/lighting/basic/basicLightManager.cpp

@@ -185,12 +185,12 @@ void BasicLightManager::activate( SceneManager *sceneManager )
    FEATUREMGR->unregisterFeature( MFT_SubSurface );
 
    // First look for the deferred bin...
-   RenderDeferredMgr *prePassBin = _findDeferredRenderBin();
+   RenderDeferredMgr *deferredBin = _findDeferredRenderBin();
 
    /*
    // If you would like to use forward shading, and have a linear depth pre-pass
    // than un-comment this code block.
-   if ( !prePassBin )
+   if ( !deferredBin )
    {
       Vector<GFXFormat> formats;
       formats.push_back( GFXFormatR32F );
@@ -204,12 +204,12 @@ void BasicLightManager::activate( SceneManager *sceneManager )
       // Uncomment this for a no-color-write z-fill pass. 
       //linearDepthFormat = GFXFormat_COUNT;
 
-      prePassBin = new RenderDeferredMgr( linearDepthFormat != GFXFormat_COUNT, linearDepthFormat );
-      prePassBin->registerObject();
-      rpm->addManager( prePassBin );
+      deferredBin = new RenderDeferredMgr( linearDepthFormat != GFXFormat_COUNT, linearDepthFormat );
+      deferredBin->registerObject();
+      rpm->addManager( deferredBin );
    }
    */
-   mDeferredRenderBin = prePassBin;
+   mDeferredRenderBin = deferredBin;
 
    // If there is a deferred bin
    MATMGR->setDeferredEnabled( mDeferredRenderBin.isValid() );

Engine/source/renderInstance/renderDeferredMgr.cpp

@@ -589,8 +589,8 @@ const GFXStateBlockDesc & RenderDeferredMgr::getOpaqueStencilTestDesc()
 //------------------------------------------------------------------------------
 
 
-ProcessedDeferredMaterial::ProcessedDeferredMaterial( Material& mat, const RenderDeferredMgr *prePassMgr )
-: Parent(mat), mDeferredMgr(prePassMgr)
+ProcessedDeferredMaterial::ProcessedDeferredMaterial( Material& mat, const RenderDeferredMgr *deferredMgr )
+: Parent(mat), mDeferredMgr(deferredMgr)
 {
 
 }
@@ -817,43 +817,43 @@ U32 ProcessedDeferredMaterial::getNumStages()
 
 void ProcessedDeferredMaterial::addStateBlockDesc(const GFXStateBlockDesc& desc)
 {
-   GFXStateBlockDesc prePassStateBlock = desc;
+   GFXStateBlockDesc deferredStateBlock = desc;
 
    // Adjust color writes if this is a pure z-fill pass
    const bool pixelOutEnabled = mDeferredMgr->getTargetChainLength() > 0;
    if ( !pixelOutEnabled )
    {
-      prePassStateBlock.colorWriteDefined = true;
-      prePassStateBlock.colorWriteRed = pixelOutEnabled;
-      prePassStateBlock.colorWriteGreen = pixelOutEnabled;
-      prePassStateBlock.colorWriteBlue = pixelOutEnabled;
-      prePassStateBlock.colorWriteAlpha = pixelOutEnabled;
+      deferredStateBlock.colorWriteDefined = true;
+      deferredStateBlock.colorWriteRed = pixelOutEnabled;
+      deferredStateBlock.colorWriteGreen = pixelOutEnabled;
+      deferredStateBlock.colorWriteBlue = pixelOutEnabled;
+      deferredStateBlock.colorWriteAlpha = pixelOutEnabled;
    }
 
    // Never allow the alpha test state when rendering
    // the deferred as we use the alpha channel for the
    // depth information... MFT_AlphaTest will handle it.
-   prePassStateBlock.alphaDefined = true;
-   prePassStateBlock.alphaTestEnable = false;
+   deferredStateBlock.alphaDefined = true;
+   deferredStateBlock.alphaTestEnable = false;
 
    // If we're translucent then we're doing deferred blending
    // which never writes to the depth channels.
    const bool isTranslucent = getMaterial()->isTranslucent();
    if ( isTranslucent )
    {
-      prePassStateBlock.setBlend( true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha );
-      prePassStateBlock.setColorWrites(false, false, false, true);
+      deferredStateBlock.setBlend( true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha );
+      deferredStateBlock.setColorWrites(false, false, false, true);
    }
 
    // Enable z reads, but only enable zwrites if we're not translucent.
-   prePassStateBlock.setZReadWrite( true, isTranslucent ? false : true );
+   deferredStateBlock.setZReadWrite( true, isTranslucent ? false : true );
 
    // Pass to parent
-   Parent::addStateBlockDesc(prePassStateBlock);
+   Parent::addStateBlockDesc(deferredStateBlock);
 }
 
-DeferredMatInstance::DeferredMatInstance(MatInstance* root, const RenderDeferredMgr *prePassMgr)
-: Parent(*root->getMaterial()), mDeferredMgr(prePassMgr)
+DeferredMatInstance::DeferredMatInstance(MatInstance* root, const RenderDeferredMgr *deferredMgr)
+: Parent(*root->getMaterial()), mDeferredMgr(deferredMgr)
 {
    mFeatureList = root->getRequestedFeatures();
    mVertexFormat = root->getVertexFormat();
@@ -891,8 +891,8 @@ bool DeferredMatInstance::init( const FeatureSet &features,
 }
 
 DeferredMatInstanceHook::DeferredMatInstanceHook( MatInstance *baseMatInst,
-                                                const RenderDeferredMgr *prePassMgr )
-   : mHookedDeferredMatInst(NULL), mDeferredManager(prePassMgr)
+                                                const RenderDeferredMgr *deferredMgr )
+   : mHookedDeferredMatInst(NULL), mDeferredManager(deferredMgr)
 {
    // If the material is a custom material then
    // hope that using DefaultDeferredMaterial gives
@@ -901,7 +901,7 @@ DeferredMatInstanceHook::DeferredMatInstanceHook( MatInstance *baseMatInst,
    {
       MatInstance* dummyInst = static_cast<MatInstance*>( MATMGR->createMatInstance( "AL_DefaultDeferredMaterial", baseMatInst->getVertexFormat() ) );
 
-      mHookedDeferredMatInst = new DeferredMatInstance( dummyInst, prePassMgr );
+      mHookedDeferredMatInst = new DeferredMatInstance( dummyInst, deferredMgr );
       mHookedDeferredMatInst->init( dummyInst->getRequestedFeatures(), baseMatInst->getVertexFormat());
 
       delete dummyInst;
@@ -909,7 +909,7 @@ DeferredMatInstanceHook::DeferredMatInstanceHook( MatInstance *baseMatInst,
    }
 
    // Create the deferred material instance.
-   mHookedDeferredMatInst = new DeferredMatInstance(baseMatInst, prePassMgr);
+   mHookedDeferredMatInst = new DeferredMatInstance(baseMatInst, deferredMgr);
    mHookedDeferredMatInst->getFeaturesDelegate() = baseMatInst->getFeaturesDelegate();
 
    // Get the features, but remove the instancing feature if the

Engine/source/renderInstance/renderDeferredMgr.h

@@ -19,8 +19,8 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
-#ifndef _PREPASS_MGR_H_
-#define _PREPASS_MGR_H_
+#ifndef _DEFERRED_MGR_H_
+#define _DEFERRED_MGR_H_
 
 #include "renderInstance/renderTexTargetBinManager.h"
 #include "materials/matInstance.h"
@@ -122,7 +122,7 @@ class ProcessedDeferredMaterial : public ProcessedShaderMaterial
    typedef ProcessedShaderMaterial Parent;
    
 public:   
-   ProcessedDeferredMaterial(Material& mat, const RenderDeferredMgr *prePassMgr);
+   ProcessedDeferredMaterial(Material& mat, const RenderDeferredMgr *deferredMgr);
 
    virtual U32 getNumStages();
 
@@ -142,7 +142,7 @@ class DeferredMatInstance : public MatInstance
    typedef MatInstance Parent;
 
 public:   
-   DeferredMatInstance(MatInstance* root, const RenderDeferredMgr *prePassMgr);
+   DeferredMatInstance(MatInstance* root, const RenderDeferredMgr *deferredMgr);
    virtual ~DeferredMatInstance();
 
    bool init()
@@ -165,7 +165,7 @@ protected:
 class DeferredMatInstanceHook : public MatInstanceHook
 {
 public:
-   DeferredMatInstanceHook(MatInstance *baseMatInst, const RenderDeferredMgr *prePassMgr);
+   DeferredMatInstanceHook(MatInstance *baseMatInst, const RenderDeferredMgr *deferredMgr);
    virtual ~DeferredMatInstanceHook();
 
    virtual DeferredMatInstance *getDeferredMatInstance() { return mHookedDeferredMatInst; }
@@ -220,5 +220,5 @@ inline BaseMatInstance* RenderDeferredMgr::getDeferredMaterial( BaseMatInstance
    return hook->getDeferredMatInstance();
 }
 
-#endif // _PREPASS_MGR_H_
+#endif // _DEFERRED_MGR_H_
 

Engine/source/renderInstance/renderImposterMgr.cpp

@@ -119,7 +119,7 @@ bool RenderImposterMgr::_clearStats( GFXDevice::GFXDeviceEventType type )
    return true;
 }
 
-void RenderImposterMgr::_renderDeferred( const SceneRenderState *state, RenderDeferredMgr *prePassBin, bool startDeferred )
+void RenderImposterMgr::_renderDeferred( const SceneRenderState *state, RenderDeferredMgr *deferredBin, bool startDeferred )
 {
    PROFILE_SCOPE( RenderImposterMgr_RenderDeferred );
 
@@ -128,10 +128,10 @@ void RenderImposterMgr::_renderDeferred( const SceneRenderState *state, RenderDe
 
    GFXDEBUGEVENT_SCOPE( RenderImposterMgr_RenderDeferred, ColorI::RED );
 
-   _innerRender( state, prePassBin );
+   _innerRender( state, deferredBin );
 }
 
-void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDeferredMgr *prePassBin )
+void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDeferredMgr *deferredBin )
 {
    PROFILE_SCOPE( RenderImposterMgr_InnerRender );
 
@@ -219,7 +219,7 @@ void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDefer
    // list changes.
 
    SceneData sgData;
-   sgData.init( state, prePassBin ? SceneData::DeferredBin : SceneData::RegularBin );
+   sgData.init( state, deferredBin ? SceneData::DeferredBin : SceneData::RegularBin );
    sgData.lights[0] = LIGHTMGR->getDefaultLight();
 
    // TODO: I should rework this loop to generate the VB first then
@@ -232,7 +232,7 @@ void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDefer
    for ( U32 i=0; i < binSize; )
    {
       currMat = static_cast<ImposterBaseRenderInst*>( mElementList[i].inst )->mat;      
-      setupMat = prePassBin ? prePassBin->getDeferredMaterial( currMat ) : currMat;
+      setupMat = deferredBin ? deferredBin->getDeferredMaterial( currMat ) : currMat;
 
       // TODO: Fix MatInstance to take a const SceneRenderState!
       while ( setupMat->setupPass( (SceneRenderState*)state, sgData ) )

Engine/source/renderInstance/renderImposterMgr.h

@@ -74,9 +74,9 @@ protected:
    GFXPrimitiveBufferHandle mIB;
    //GFXVertexBufferHandle<ImposterCorner> mCornerVB;   
 
-   void _innerRender( const SceneRenderState *state, RenderDeferredMgr *prePassBin );
+   void _innerRender( const SceneRenderState *state, RenderDeferredMgr *deferredBin );
 
-   void _renderDeferred( const SceneRenderState *state, RenderDeferredMgr *prePassBin, bool startDeferred );
+   void _renderDeferred( const SceneRenderState *state, RenderDeferredMgr *deferredBin, bool startDeferred );
 
    static bool _clearStats( GFXDevice::GFXDeviceEventType type );
 

Engine/source/renderInstance/renderParticleMgr.cpp

@@ -557,7 +557,7 @@ bool RenderParticleMgr::_initShader()
       mParticleShaderConsts.mAlphaFactorSC = mParticleShader->getShaderConstHandle( "$alphaFactor" );
       mParticleShaderConsts.mAlphaScaleSC = mParticleShader->getShaderConstHandle( "$alphaScale" );
       mParticleShaderConsts.mFSModelViewProjSC = mParticleShader->getShaderConstHandle( "$fsModelViewProj" );
-      mParticleShaderConsts.mDeferredTargetParamsSC = mParticleShader->getShaderConstHandle( "$prePassTargetParams" );
+      mParticleShaderConsts.mDeferredTargetParamsSC = mParticleShader->getShaderConstHandle( "$deferredTargetParams" );
 
       //samplers
       mParticleShaderConsts.mSamplerDiffuse = mParticleShader->getShaderConstHandle("$diffuseMap");
@@ -596,13 +596,13 @@ void RenderParticleMgr::_onLMActivate( const char*, bool activate )
          return;
 
       // Hunt for the pre-pass manager/target
-      RenderDeferredMgr *prePassBin = NULL;
+      RenderDeferredMgr *deferredBin = NULL;
       for( U32 i = 0; i < rpm->getManagerCount(); i++ )
       {
          RenderBinManager *bin = rpm->getManager(i);
          if( bin->getRenderInstType() == RenderDeferredMgr::RIT_Deferred )
          {
-            prePassBin = (RenderDeferredMgr*)bin;
+            deferredBin = (RenderDeferredMgr*)bin;
             break;
          }
       }
@@ -610,11 +610,11 @@ void RenderParticleMgr::_onLMActivate( const char*, bool activate )
       // If we found the deferred bin, set this bin to render very shortly afterwards
       // and re-add this render-manager. If there is no pre-pass bin, or it doesn't
       // have a depth-texture, we can't render offscreen.
-      mOffscreenRenderEnabled = prePassBin && (prePassBin->getTargetChainLength() > 0);
+      mOffscreenRenderEnabled = deferredBin && (deferredBin->getTargetChainLength() > 0);
       if(mOffscreenRenderEnabled)
       {
          rpm->removeManager(this);
-         setRenderOrder( prePassBin->getRenderOrder() + 0.011f );
+         setRenderOrder( deferredBin->getRenderOrder() + 0.011f );
          rpm->addManager(this);
       }
 

Engine/source/terrain/terrCellMaterial.cpp

@@ -243,12 +243,12 @@ TerrainCellMaterial* TerrainCellMaterial::getReflectMat()
 
 void TerrainCellMaterial::init(  TerrainBlock *block,
                                  U64 activeMaterials, 
-                                 bool prePassMat,
+                                 bool deferredMat,
                                  bool reflectMat,
                                  bool baseOnly )
 {
    // This isn't allowed for now.
-   AssertFatal( !( prePassMat && reflectMat ), "TerrainCellMaterial::init - We shouldn't get deferred and reflection in the same material!" );
+   AssertFatal( !( deferredMat && reflectMat ), "TerrainCellMaterial::init - We shouldn't get deferred and reflection in the same material!" );
 
    mTerrain = block;
    mMaterials = activeMaterials;
@@ -280,7 +280,7 @@ void TerrainCellMaterial::init(  TerrainBlock *block,
       if ( !_createPass(   &materials, 
                            &mPasses.last(), 
                            mPasses.size() == 1, 
-                           prePassMat,
+                           deferredMat,
                            reflectMat,
                            baseOnly ) )
       {
@@ -310,7 +310,7 @@ void TerrainCellMaterial::init(  TerrainBlock *block,
 bool TerrainCellMaterial::_createPass( Vector<MaterialInfo*> *materials, 
                                        Pass *pass, 
                                        bool firstPass,
-                                       bool prePassMat,
+                                       bool deferredMat,
                                        bool reflectMat,
                                        bool baseOnly )
 {
@@ -343,7 +343,7 @@ bool TerrainCellMaterial::_createPass( Vector<MaterialInfo*> *materials,
 
    // Has advanced lightmap support been enabled for deferred.
    bool advancedLightmapSupport = false;
-   if ( prePassMat )
+   if ( deferredMat )
    {
       // This sucks... but it works.
       AdvancedLightBinManager *lightBin;
@@ -357,7 +357,7 @@ bool TerrainCellMaterial::_createPass( Vector<MaterialInfo*> *materials,
       FeatureSet features;
       features.addFeature( MFT_VertTransform );
 
-      if ( prePassMat )
+      if ( deferredMat )
       {
          features.addFeature( MFT_EyeSpaceDepthOut );
          features.addFeature( MFT_DeferredConditioner );
@@ -416,13 +416,13 @@ bool TerrainCellMaterial::_createPass( Vector<MaterialInfo*> *materials,
 		 // check for macro detail texture
          if (  !(mat->getMacroSize() <= 0 || mat->getMacroDistance() <= 0 || mat->getMacroMap().isEmpty() ) )
          {
-            if(prePassMat)
+            if(deferredMat)
                features.addFeature( MFT_DeferredTerrainMacroMap, featureIndex );
             else
 	         features.addFeature( MFT_TerrainMacroMap, featureIndex );
          }
 
-         if(prePassMat)
+         if(deferredMat)
              features.addFeature( MFT_DeferredTerrainDetailMap, featureIndex );
          else
          features.addFeature( MFT_TerrainDetailMap, featureIndex );
@@ -554,14 +554,14 @@ bool TerrainCellMaterial::_createPass( Vector<MaterialInfo*> *materials,
       // MFT_TerrainAdditive feature to lerp the
       // output normal with the previous pass.
       //
-      if ( prePassMat )
+      if ( deferredMat )
          desc.setColorWrites( true, true, true, false );
    }
 
    // We write to the zbuffer if this is a deferred
    // material or if the deferred is disabled.
    desc.setZReadWrite( true,  !MATMGR->getDeferredEnabled() || 
-                              prePassMat ||
+                              deferredMat ||
                               reflectMat );
 
    desc.samplersDefined = true;
@@ -671,7 +671,7 @@ bool TerrainCellMaterial::_createPass( Vector<MaterialInfo*> *materials,
 
    // If we're doing deferred it requires some 
    // special stencil settings for it to work.
-   if ( prePassMat )
+   if ( deferredMat )
       desc.addDesc( RenderDeferredMgr::getOpaqueStenciWriteDesc( false ) );
 
    desc.setCullMode( GFXCullCCW );

Engine/source/terrain/terrCellMaterial.h

@@ -165,7 +165,7 @@ protected:
    bool _createPass( Vector<MaterialInfo*> *materials, 
                      Pass *pass, 
                      bool firstPass,
-                     bool prePassMat,
+                     bool deferredMat,
                      bool reflectMat,
                      bool baseOnly );
 
@@ -178,7 +178,7 @@ public:
 
    void init(  TerrainBlock *block, 
                U64 activeMaterials,
-               bool prePassMat = false,
+               bool deferredMat = false,
                bool reflectMat = false,
                bool baseOnly = false );