TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-14 08:04:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #2009 from Areloch/Prepass_Deferred_Remainder

Browse source 
Catches the remaining prepass to deferred changes on the engine side.
This commit is contained in:
Areloch 2017-05-30 23:43:09 -05:00 • committed by GitHub
commit 75580a1126
10 changed files with 73 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

16
Engine/source/lighting/advanced/advancedLightManager.cpp
View file

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

16
Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.cpp
View file

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

12
Engine/source/lighting/basic/basicLightManager.cpp
View file

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

40
Engine/source/renderInstance/renderDeferredMgr.cpp
View file

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

12
Engine/source/renderInstance/renderDeferredMgr.h
View file

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

10
Engine/source/renderInstance/renderImposterMgr.cpp
View file

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

4
Engine/source/renderInstance/renderImposterMgr.h
View file

@ -74,9 +74,9 @@ protected:
GFXPrimitiveBufferHandle mIB; GFXPrimitiveBufferHandle mIB;
//GFXVertexBufferHandle<ImposterCorner> mCornerVB; //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 ); static bool _clearStats( GFXDevice::GFXDeviceEventType type );

10
Engine/source/renderInstance/renderParticleMgr.cpp
View file

@ -557,7 +557,7 @@ bool RenderParticleMgr::_initShader()
mParticleShaderConsts.mAlphaFactorSC = mParticleShader->getShaderConstHandle( "$alphaFactor" ); mParticleShaderConsts.mAlphaFactorSC = mParticleShader->getShaderConstHandle( "$alphaFactor" );
mParticleShaderConsts.mAlphaScaleSC = mParticleShader->getShaderConstHandle( "$alphaScale" ); mParticleShaderConsts.mAlphaScaleSC = mParticleShader->getShaderConstHandle( "$alphaScale" );
mParticleShaderConsts.mFSModelViewProjSC = mParticleShader->getShaderConstHandle( "$fsModelViewProj" ); mParticleShaderConsts.mFSModelViewProjSC = mParticleShader->getShaderConstHandle( "$fsModelViewProj" );
mParticleShaderConsts.mDeferredTargetParamsSC = mParticleShader->getShaderConstHandle( "$prePassTargetParams" ); mParticleShaderConsts.mDeferredTargetParamsSC = mParticleShader->getShaderConstHandle( "$deferredTargetParams" );
//samplers //samplers
mParticleShaderConsts.mSamplerDiffuse = mParticleShader->getShaderConstHandle("$diffuseMap"); mParticleShaderConsts.mSamplerDiffuse = mParticleShader->getShaderConstHandle("$diffuseMap");
@ -596,13 +596,13 @@ void RenderParticleMgr::_onLMActivate( const char*, bool activate )
return; return;
// Hunt for the pre-pass manager/target // Hunt for the pre-pass manager/target
RenderDeferredMgr *prePassBin = NULL; RenderDeferredMgr *deferredBin = NULL;
for( U32 i = 0; i < rpm->getManagerCount(); i++ ) for( U32 i = 0; i < rpm->getManagerCount(); i++ )
{ {
RenderBinManager *bin = rpm->getManager(i); RenderBinManager *bin = rpm->getManager(i);
if( bin->getRenderInstType() == RenderDeferredMgr::RIT_Deferred ) if( bin->getRenderInstType() == RenderDeferredMgr::RIT_Deferred )
{ {
prePassBin = (RenderDeferredMgr*)bin; deferredBin = (RenderDeferredMgr*)bin;
break; 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 // 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 // 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. // have a depth-texture, we can't render offscreen.
mOffscreenRenderEnabled = prePassBin && (prePassBin->getTargetChainLength() > 0); mOffscreenRenderEnabled = deferredBin && (deferredBin->getTargetChainLength() > 0);
if(mOffscreenRenderEnabled) if(mOffscreenRenderEnabled)
{ {
rpm->removeManager(this); rpm->removeManager(this);
setRenderOrder( prePassBin->getRenderOrder() + 0.011f ); setRenderOrder( deferredBin->getRenderOrder() + 0.011f );
rpm->addManager(this); rpm->addManager(this);
} }

22
Engine/source/terrain/terrCellMaterial.cpp
View file

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

4
Engine/source/terrain/terrCellMaterial.h
View file

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