mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-25 09:33:50 +00:00
Merge pull request #2009 from Areloch/Prepass_Deferred_Remainder
Catches the remaining prepass to deferred changes on the engine side.
This commit is contained in:
Areloch
GitHub
commit
75580a1126
10 changed files with 73 additions and 73 deletions
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
||||
|
|
|
|||
|
|
@ -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() );
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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_
|
||||
|
||||
|
|
|
|||
|
|
@ -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 ) )
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue