TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-12 19:31:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Goes and replaces the references/names that use Prepass to be Deferred, since we're actually using deferred.

Browse source
This commit is contained in:
Areloch 2017-04-11 00:23:14 -05:00
parent b052a1f970
commit af8fbf0e3a
122 changed files with 641 additions and 641 deletions
Download patch file Download diff file Expand all files Collapse all files

218
Engine/source/renderInstance/renderPrePassMgr.cpp → Engine/source/renderInstance/renderDeferredMgr.cpp
View file

@ -21,7 +21,7 @@
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "renderInstance/renderPrePassMgr.h"
#include "renderInstance/renderDeferredMgr.h"
#include "gfx/gfxTransformSaver.h"
#include "materials/sceneData.h"
@ -51,40 +51,40 @@
#include "materials/shaderData.h"
#include "gfx/sim/cubemapData.h"
const MatInstanceHookType PrePassMatInstanceHook::Type( "PrePass" );
const String RenderPrePassMgr::BufferName("prepass");
const RenderInstType RenderPrePassMgr::RIT_PrePass("PrePass");
const String RenderPrePassMgr::ColorBufferName("color");
const String RenderPrePassMgr::MatInfoBufferName("matinfo");
const MatInstanceHookType DeferredMatInstanceHook::Type( "Deferred" );
const String RenderDeferredMgr::BufferName("deferred");
const RenderInstType RenderDeferredMgr::RIT_Deferred("Deferred");
const String RenderDeferredMgr::ColorBufferName("color");
const String RenderDeferredMgr::MatInfoBufferName("matinfo");
IMPLEMENT_CONOBJECT(RenderPrePassMgr);
IMPLEMENT_CONOBJECT(RenderDeferredMgr);
ConsoleDocClass( RenderPrePassMgr,
"@brief The render bin which performs a z+normals prepass used in Advanced Lighting.\n\n"
ConsoleDocClass( RenderDeferredMgr,
"@brief The render bin which performs a z+normals deferred used in Advanced Lighting.\n\n"
"This render bin is used in Advanced Lighting to gather all opaque mesh render instances "
"and render them to the g-buffer for use in lighting the scene and doing effects.\n\n"
"PostEffect and other shaders can access the output of this bin by using the #prepass "
"PostEffect and other shaders can access the output of this bin by using the #deferred "
"texture target name. See the edge anti-aliasing post effect for an example.\n\n"
"@see game/core/scripts/client/postFx/edgeAA.cs\n"
"@ingroup RenderBin\n" );
RenderPrePassMgr::RenderSignal& RenderPrePassMgr::getRenderSignal()
RenderDeferredMgr::RenderSignal& RenderDeferredMgr::getRenderSignal()
{
static RenderSignal theSignal;
return theSignal;
}
RenderPrePassMgr::RenderPrePassMgr( bool gatherDepth,
RenderDeferredMgr::RenderDeferredMgr( bool gatherDepth,
GFXFormat format )
: Parent( RIT_PrePass,
: Parent( RIT_Deferred,
0.01f,
0.01f,
format,
Point2I( Parent::DefaultTargetSize, Parent::DefaultTargetSize),
gatherDepth ? Parent::DefaultTargetChainLength : 0 ),
mPrePassMatInstance( NULL )
mDeferredMatInstance( NULL )
{
notifyType( RenderPassManager::RIT_Decal );
notifyType( RenderPassManager::RIT_DecalRoad );
@ -107,30 +107,30 @@ RenderPrePassMgr::RenderPrePassMgr( bool gatherDepth,
_registerFeatures();
}
RenderPrePassMgr::~RenderPrePassMgr()
RenderDeferredMgr::~RenderDeferredMgr()
{
GFXShader::removeGlobalMacro( "TORQUE_LINEAR_DEPTH" );
mColorTarget.release();
mMatInfoTarget.release();
_unregisterFeatures();
SAFE_DELETE( mPrePassMatInstance );
SAFE_DELETE( mDeferredMatInstance );
}
void RenderPrePassMgr::_registerFeatures()
void RenderDeferredMgr::_registerFeatures()
{
ConditionerFeature *cond = new LinearEyeDepthConditioner( getTargetFormat() );
FEATUREMGR->registerFeature( MFT_PrePassConditioner, cond );
FEATUREMGR->registerFeature( MFT_DeferredConditioner, cond );
mNamedTarget.setConditioner( cond );
}
void RenderPrePassMgr::_unregisterFeatures()
void RenderDeferredMgr::_unregisterFeatures()
{
mNamedTarget.setConditioner( NULL );
FEATUREMGR->unregisterFeature(MFT_PrePassConditioner);
FEATUREMGR->unregisterFeature(MFT_DeferredConditioner);
}
bool RenderPrePassMgr::setTargetSize(const Point2I &newTargetSize)
bool RenderDeferredMgr::setTargetSize(const Point2I &newTargetSize)
{
bool ret = Parent::setTargetSize( newTargetSize );
mNamedTarget.setViewport( GFX->getViewport() );
@ -139,14 +139,14 @@ bool RenderPrePassMgr::setTargetSize(const Point2I &newTargetSize)
return ret;
}
bool RenderPrePassMgr::_updateTargets()
bool RenderDeferredMgr::_updateTargets()
{
PROFILE_SCOPE(RenderPrePassMgr_updateTargets);
PROFILE_SCOPE(RenderDeferredMgr_updateTargets);
bool ret = Parent::_updateTargets();
// check for an output conditioner, and update it's format
ConditionerFeature *outputConditioner = dynamic_cast<ConditionerFeature *>(FEATUREMGR->getByType(MFT_PrePassConditioner));
ConditionerFeature *outputConditioner = dynamic_cast<ConditionerFeature *>(FEATUREMGR->getByType(MFT_DeferredConditioner));
if( outputConditioner && outputConditioner->setBufferFormat(mTargetFormat) )
{
// reload materials, the conditioner needs to alter the generated shaders
@ -193,7 +193,7 @@ bool RenderPrePassMgr::_updateTargets()
// lightmapped geometry in the scene.
AdvancedLightBinManager *lightBin;
if ( Sim::findObject( "AL_LightBinMgr", lightBin ) &&
lightBin->MRTLightmapsDuringPrePass() &&
lightBin->MRTLightmapsDuringDeferred() &&
lightBin->isProperlyAdded() )
{
// Update the size of the light bin target here. This will call _updateTargets
@ -218,28 +218,28 @@ bool RenderPrePassMgr::_updateTargets()
return ret;
}
void RenderPrePassMgr::_createPrePassMaterial()
void RenderDeferredMgr::_createDeferredMaterial()
{
SAFE_DELETE(mPrePassMatInstance);
SAFE_DELETE(mDeferredMatInstance);
const GFXVertexFormat *vertexFormat = getGFXVertexFormat<GFXVertexPNTTB>();
MatInstance* prepassMat = static_cast<MatInstance*>(MATMGR->createMatInstance("AL_DefaultPrePassMaterial", vertexFormat));
AssertFatal( prepassMat, "TODO: Handle this better." );
mPrePassMatInstance = new PrePassMatInstance(prepassMat, this);
mPrePassMatInstance->init( MATMGR->getDefaultFeatures(), vertexFormat);
delete prepassMat;
MatInstance* deferredMat = static_cast<MatInstance*>(MATMGR->createMatInstance("AL_DefaultDeferredMaterial", vertexFormat));
AssertFatal( deferredMat, "TODO: Handle this better." );
mDeferredMatInstance = new DeferredMatInstance(deferredMat, this);
mDeferredMatInstance->init( MATMGR->getDefaultFeatures(), vertexFormat);
delete deferredMat;
}
void RenderPrePassMgr::setPrePassMaterial( PrePassMatInstance *mat )
void RenderDeferredMgr::setDeferredMaterial( DeferredMatInstance *mat )
{
SAFE_DELETE(mPrePassMatInstance);
mPrePassMatInstance = mat;
SAFE_DELETE(mDeferredMatInstance);
mDeferredMatInstance = mat;
}
void RenderPrePassMgr::addElement( RenderInst *inst )
void RenderDeferredMgr::addElement( RenderInst *inst )
{
PROFILE_SCOPE( RenderPrePassMgr_addElement )
PROFILE_SCOPE( RenderDeferredMgr_addElement )
// Skip out if this bin is disabled.
if ( gClientSceneGraph->getCurrentRenderState() &&
@ -269,8 +269,8 @@ void RenderPrePassMgr::addElement( RenderInst *inst )
static_cast<CustomMaterial*>(matInst->getMaterial())->mRefract)
return;
// Make sure we got a prepass material.
matInst = getPrePassMaterial(matInst);
// Make sure we got a deferred material.
matInst = getDeferredMaterial(matInst);
if (!matInst || !matInst->isValid())
return;
}
@ -302,36 +302,36 @@ void RenderPrePassMgr::addElement( RenderInst *inst )
elem.key2 = originalKey;
}
void RenderPrePassMgr::sort()
void RenderDeferredMgr::sort()
{
PROFILE_SCOPE( RenderPrePassMgr_sort );
PROFILE_SCOPE( RenderDeferredMgr_sort );
Parent::sort();
dQsort( mTerrainElementList.address(), mTerrainElementList.size(), sizeof(MainSortElem), cmpKeyFunc);
dQsort( mObjectElementList.address(), mObjectElementList.size(), sizeof(MainSortElem), cmpKeyFunc);
}
void RenderPrePassMgr::clear()
void RenderDeferredMgr::clear()
{
Parent::clear();
mTerrainElementList.clear();
mObjectElementList.clear();
}
void RenderPrePassMgr::render( SceneRenderState *state )
void RenderDeferredMgr::render( SceneRenderState *state )
{
PROFILE_SCOPE(RenderPrePassMgr_render);
PROFILE_SCOPE(RenderDeferredMgr_render);
// Take a look at the SceneRenderState and see if we should skip drawing the pre-pass
if ( state->disableAdvancedLightingBins() )
return;
// NOTE: We don't early out here when the element list is
// zero because we need the prepass to be cleared.
// zero because we need the deferred to be cleared.
// Automagically save & restore our viewport and transforms.
GFXTransformSaver saver;
GFXDEBUGEVENT_SCOPE( RenderPrePassMgr_Render, ColorI::RED );
GFXDEBUGEVENT_SCOPE( RenderDeferredMgr_Render, ColorI::RED );
// Tell the superclass we're about to render
const bool isRenderingToTarget = _onPreRender(state);
@ -344,13 +344,13 @@ void RenderPrePassMgr::render( SceneRenderState *state )
matrixSet.restoreSceneViewProjection();
const MatrixF worldViewXfm = GFX->getWorldMatrix();
// Setup the default prepass material for object instances.
if ( !mPrePassMatInstance )
_createPrePassMaterial();
if ( mPrePassMatInstance )
// Setup the default deferred material for object instances.
if ( !mDeferredMatInstance )
_createDeferredMaterial();
if ( mDeferredMatInstance )
{
matrixSet.setWorld(MatrixF::Identity);
mPrePassMatInstance->setTransforms(matrixSet, state);
mDeferredMatInstance->setTransforms(matrixSet, state);
}
// Signal start of pre-pass
@ -361,16 +361,16 @@ void RenderPrePassMgr::render( SceneRenderState *state )
// on the smaller meshes and objects.
// The terrain doesn't need any scene graph data
// in the the prepass... so just clear it.
// in the the deferred... so just clear it.
SceneData sgData;
sgData.init( state, SceneData::PrePassBin );
sgData.init( state, SceneData::DeferredBin );
Vector< MainSortElem >::const_iterator itr = mTerrainElementList.begin();
for ( ; itr != mTerrainElementList.end(); itr++ )
{
TerrainRenderInst *ri = static_cast<TerrainRenderInst*>( itr->inst );
TerrainCellMaterial *mat = ri->cellMat->getPrePassMat();
TerrainCellMaterial *mat = ri->cellMat->getDeferredMat();
GFX->setPrimitiveBuffer( ri->primBuff );
GFX->setVertexBuffer( ri->vertBuff );
@ -396,8 +396,8 @@ void RenderPrePassMgr::render( SceneRenderState *state )
{
MeshRenderInst *ri = static_cast<MeshRenderInst*>( itr->inst );
// Get the prepass material.
BaseMatInstance *mat = getPrePassMaterial( ri->matInst );
// Get the deferred material.
BaseMatInstance *mat = getDeferredMaterial( ri->matInst );
// Set up SG data proper like and flag it
// as a pre-pass render
@ -414,9 +414,9 @@ void RenderPrePassMgr::render( SceneRenderState *state )
// Check to see if we need to break this batch.
//
// NOTE: We're comparing the non-prepass materials
// NOTE: We're comparing the non-deferred materials
// here so we don't incur the cost of looking up the
// prepass hook on each inst.
// deferred hook on each inst.
//
if ( newPassNeeded( ri, passRI ) )
break;
@ -523,7 +523,7 @@ void RenderPrePassMgr::render( SceneRenderState *state )
{
ObjectRenderInst *ri = static_cast<ObjectRenderInst*>( itr->inst );
if ( ri->renderDelegate )
ri->renderDelegate( ri, state, mPrePassMatInstance );
ri->renderDelegate( ri, state, mDeferredMatInstance );
}
// Signal end of pre-pass
@ -533,7 +533,7 @@ void RenderPrePassMgr::render( SceneRenderState *state )
_onPostRender();
}
const GFXStateBlockDesc & RenderPrePassMgr::getOpaqueStenciWriteDesc( bool lightmappedGeometry /*= true*/ )
const GFXStateBlockDesc & RenderDeferredMgr::getOpaqueStenciWriteDesc( bool lightmappedGeometry /*= true*/ )
{
static bool sbInit = false;
static GFXStateBlockDesc sOpaqueStaticLitStencilWriteDesc;
@ -548,7 +548,7 @@ const GFXStateBlockDesc & RenderPrePassMgr::getOpaqueStenciWriteDesc( bool light
sOpaqueStaticLitStencilWriteDesc.stencilEnable = true;
sOpaqueStaticLitStencilWriteDesc.stencilWriteMask = 0x03;
sOpaqueStaticLitStencilWriteDesc.stencilMask = 0x03;
sOpaqueStaticLitStencilWriteDesc.stencilRef = RenderPrePassMgr::OpaqueStaticLitMask;
sOpaqueStaticLitStencilWriteDesc.stencilRef = RenderDeferredMgr::OpaqueStaticLitMask;
sOpaqueStaticLitStencilWriteDesc.stencilPassOp = GFXStencilOpReplace;
sOpaqueStaticLitStencilWriteDesc.stencilFailOp = GFXStencilOpKeep;
sOpaqueStaticLitStencilWriteDesc.stencilZFailOp = GFXStencilOpKeep;
@ -556,13 +556,13 @@ const GFXStateBlockDesc & RenderPrePassMgr::getOpaqueStenciWriteDesc( bool light
// Same only dynamic
sOpaqueDynamicLitStencilWriteDesc = sOpaqueStaticLitStencilWriteDesc;
sOpaqueDynamicLitStencilWriteDesc.stencilRef = RenderPrePassMgr::OpaqueDynamicLitMask;
sOpaqueDynamicLitStencilWriteDesc.stencilRef = RenderDeferredMgr::OpaqueDynamicLitMask;
}
return (lightmappedGeometry ? sOpaqueStaticLitStencilWriteDesc : sOpaqueDynamicLitStencilWriteDesc);
}
const GFXStateBlockDesc & RenderPrePassMgr::getOpaqueStencilTestDesc()
const GFXStateBlockDesc & RenderDeferredMgr::getOpaqueStencilTestDesc()
{
static bool sbInit = false;
static GFXStateBlockDesc sOpaqueStencilTestDesc;
@ -589,13 +589,13 @@ const GFXStateBlockDesc & RenderPrePassMgr::getOpaqueStencilTestDesc()
//------------------------------------------------------------------------------
ProcessedPrePassMaterial::ProcessedPrePassMaterial( Material& mat, const RenderPrePassMgr *prePassMgr )
: Parent(mat), mPrePassMgr(prePassMgr)
ProcessedDeferredMaterial::ProcessedDeferredMaterial( Material& mat, const RenderDeferredMgr *prePassMgr )
: Parent(mat), mDeferredMgr(prePassMgr)
{
}
void ProcessedPrePassMaterial::_determineFeatures( U32 stageNum,
void ProcessedDeferredMaterial::_determineFeatures( U32 stageNum,
MaterialFeatureData &fd,
const FeatureSet &features )
{
@ -605,7 +605,7 @@ void ProcessedPrePassMaterial::_determineFeatures( U32 stageNum,
bool bEnableMRTLightmap = false;
AdvancedLightBinManager *lightBin;
if ( Sim::findObject( "AL_LightBinMgr", lightBin ) )
bEnableMRTLightmap = lightBin->MRTLightmapsDuringPrePass();
bEnableMRTLightmap = lightBin->MRTLightmapsDuringDeferred();
// If this material has a lightmap or tonemap (texture or baked vertex color),
// it must be static. Otherwise it is dynamic.
@ -617,17 +617,17 @@ void ProcessedPrePassMaterial::_determineFeatures( U32 stageNum,
fd.features.hasFeature( MFT_IsTranslucentZWrite) ) ) );
// Integrate proper opaque stencil write state
mUserDefined.addDesc( mPrePassMgr->getOpaqueStenciWriteDesc( mIsLightmappedGeometry ) );
mUserDefined.addDesc( mDeferredMgr->getOpaqueStenciWriteDesc( mIsLightmappedGeometry ) );
FeatureSet newFeatures;
// These are always on for prepass.
// These are always on for deferred.
newFeatures.addFeature( MFT_EyeSpaceDepthOut );
newFeatures.addFeature( MFT_PrePassConditioner );
newFeatures.addFeature( MFT_DeferredConditioner );
#ifndef TORQUE_DEDICATED
//tag all materials running through prepass as deferred
//tag all materials running through deferred as deferred
newFeatures.addFeature(MFT_isDeferred);
// Deferred Shading : Diffuse
@ -677,7 +677,7 @@ void ProcessedPrePassMaterial::_determineFeatures( U32 stageNum,
type == MFT_DetailNormalMap ||
type == MFT_AlphaTest ||
type == MFT_Parallax ||
type == MFT_InterlacedPrePass ||
type == MFT_InterlacedDeferred ||
type == MFT_Visibility ||
type == MFT_UseInstancing ||
type == MFT_DiffuseVertColor ||
@ -764,7 +764,7 @@ void ProcessedPrePassMaterial::_determineFeatures( U32 stageNum,
fd.features = newFeatures;
}
U32 ProcessedPrePassMaterial::getNumStages()
U32 ProcessedDeferredMaterial::getNumStages()
{
// Loops through all stages to determine how many
// stages we actually use.
@ -816,12 +816,12 @@ U32 ProcessedPrePassMaterial::getNumStages()
return numStages;
}
void ProcessedPrePassMaterial::addStateBlockDesc(const GFXStateBlockDesc& desc)
void ProcessedDeferredMaterial::addStateBlockDesc(const GFXStateBlockDesc& desc)
{
GFXStateBlockDesc prePassStateBlock = desc;
// Adjust color writes if this is a pure z-fill pass
const bool pixelOutEnabled = mPrePassMgr->getTargetChainLength() > 0;
const bool pixelOutEnabled = mDeferredMgr->getTargetChainLength() > 0;
if ( !pixelOutEnabled )
{
prePassStateBlock.colorWriteDefined = true;
@ -832,12 +832,12 @@ void ProcessedPrePassMaterial::addStateBlockDesc(const GFXStateBlockDesc& desc)
}
// Never allow the alpha test state when rendering
// the prepass 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.
prePassStateBlock.alphaDefined = true;
prePassStateBlock.alphaTestEnable = false;
// If we're translucent then we're doing prepass blending
// If we're translucent then we're doing deferred blending
// which never writes to the depth channels.
const bool isTranslucent = getMaterial()->isTranslucent();
if ( isTranslucent )
@ -853,24 +853,24 @@ void ProcessedPrePassMaterial::addStateBlockDesc(const GFXStateBlockDesc& desc)
Parent::addStateBlockDesc(prePassStateBlock);
}
PrePassMatInstance::PrePassMatInstance(MatInstance* root, const RenderPrePassMgr *prePassMgr)
: Parent(*root->getMaterial()), mPrePassMgr(prePassMgr)
DeferredMatInstance::DeferredMatInstance(MatInstance* root, const RenderDeferredMgr *prePassMgr)
: Parent(*root->getMaterial()), mDeferredMgr(prePassMgr)
{
mFeatureList = root->getRequestedFeatures();
mVertexFormat = root->getVertexFormat();
mUserObject = root->getUserObject();
}
PrePassMatInstance::~PrePassMatInstance()
DeferredMatInstance::~DeferredMatInstance()
{
}
ProcessedMaterial* PrePassMatInstance::getShaderMaterial()
ProcessedMaterial* DeferredMatInstance::getShaderMaterial()
{
return new ProcessedPrePassMaterial(*mMaterial, mPrePassMgr);
return new ProcessedDeferredMaterial(*mMaterial, mDeferredMgr);
}
bool PrePassMatInstance::init( const FeatureSet &features,
bool DeferredMatInstance::init( const FeatureSet &features,
const GFXVertexFormat *vertexFormat )
{
bool vaild = Parent::init(features, vertexFormat);
@ -891,27 +891,27 @@ bool PrePassMatInstance::init( const FeatureSet &features,
return vaild;
}
PrePassMatInstanceHook::PrePassMatInstanceHook( MatInstance *baseMatInst,
const RenderPrePassMgr *prePassMgr )
: mHookedPrePassMatInst(NULL), mPrePassManager(prePassMgr)
DeferredMatInstanceHook::DeferredMatInstanceHook( MatInstance *baseMatInst,
const RenderDeferredMgr *prePassMgr )
: mHookedDeferredMatInst(NULL), mDeferredManager(prePassMgr)
{
// If the material is a custom material then
// hope that using DefaultPrePassMaterial gives
// them a good prepass.
// hope that using DefaultDeferredMaterial gives
// them a good deferred.
if ( baseMatInst->isCustomMaterial() )
{
MatInstance* dummyInst = static_cast<MatInstance*>( MATMGR->createMatInstance( "AL_DefaultPrePassMaterial", baseMatInst->getVertexFormat() ) );
MatInstance* dummyInst = static_cast<MatInstance*>( MATMGR->createMatInstance( "AL_DefaultDeferredMaterial", baseMatInst->getVertexFormat() ) );
mHookedPrePassMatInst = new PrePassMatInstance( dummyInst, prePassMgr );
mHookedPrePassMatInst->init( dummyInst->getRequestedFeatures(), baseMatInst->getVertexFormat());
mHookedDeferredMatInst = new DeferredMatInstance( dummyInst, prePassMgr );
mHookedDeferredMatInst->init( dummyInst->getRequestedFeatures(), baseMatInst->getVertexFormat());
delete dummyInst;
return;
}
// Create the prepass material instance.
mHookedPrePassMatInst = new PrePassMatInstance(baseMatInst, prePassMgr);
mHookedPrePassMatInst->getFeaturesDelegate() = baseMatInst->getFeaturesDelegate();
// Create the deferred material instance.
mHookedDeferredMatInst = new DeferredMatInstance(baseMatInst, prePassMgr);
mHookedDeferredMatInst->getFeaturesDelegate() = baseMatInst->getFeaturesDelegate();
// Get the features, but remove the instancing feature if the
// original material didn't end up using it.
@ -920,12 +920,12 @@ PrePassMatInstanceHook::PrePassMatInstanceHook( MatInstance *baseMatInst,
features.removeFeature( MFT_UseInstancing );
// Initialize the material.
mHookedPrePassMatInst->init(features, baseMatInst->getVertexFormat());
mHookedDeferredMatInst->init(features, baseMatInst->getVertexFormat());
}
PrePassMatInstanceHook::~PrePassMatInstanceHook()
DeferredMatInstanceHook::~DeferredMatInstanceHook()
{
SAFE_DELETE(mHookedPrePassMatInst);
SAFE_DELETE(mHookedDeferredMatInst);
}
//------------------------------------------------------------------------------
@ -1027,10 +1027,10 @@ Var* LinearEyeDepthConditioner::printMethodHeader( MethodType methodType, const
methodVar->setType("inline float4");
DecOp *methodDecl = new DecOp(methodVar);
Var *prepassSampler = new Var;
prepassSampler->setName("prepassSamplerVar");
prepassSampler->setType("sampler2D");
DecOp *prepassSamplerDecl = new DecOp(prepassSampler);
Var *deferredSampler = new Var;
deferredSampler->setName("deferredSamplerVar");
deferredSampler->setType("sampler2D");
DecOp *deferredSamplerDecl = new DecOp(deferredSampler);
Var *screenUV = new Var;
screenUV->setName("screenUVVar");
@ -1048,7 +1048,7 @@ Var* LinearEyeDepthConditioner::printMethodHeader( MethodType methodType, const
bufferSample->setType("float4");
DecOp *bufferSampleDecl = new DecOp(bufferSample);
meta->addStatement( new GenOp( "@(@, @)\r\n", methodDecl, prepassSamplerDecl, screenUVDecl ) );
meta->addStatement( new GenOp( "@(@, @)\r\n", methodDecl, deferredSamplerDecl, screenUVDecl ) );
meta->addStatement( new GenOp( "{\r\n" ) );
@ -1058,14 +1058,14 @@ Var* LinearEyeDepthConditioner::printMethodHeader( MethodType methodType, const
// possible so that the shader compiler can optimize.
meta->addStatement( new GenOp( " #if TORQUE_SM >= 30\r\n" ) );
if (GFX->getAdapterType() == OpenGL)
meta->addStatement( new GenOp( " @ = textureLod(@, @, 0); \r\n", bufferSampleDecl, prepassSampler, screenUV) );
meta->addStatement( new GenOp( " @ = textureLod(@, @, 0); \r\n", bufferSampleDecl, deferredSampler, screenUV) );
else
meta->addStatement( new GenOp( " @ = tex2Dlod(@, float4(@,0,0));\r\n", bufferSampleDecl, prepassSampler, screenUV ) );
meta->addStatement( new GenOp( " @ = tex2Dlod(@, float4(@,0,0));\r\n", bufferSampleDecl, deferredSampler, screenUV ) );
meta->addStatement( new GenOp( " #else\r\n" ) );
if (GFX->getAdapterType() == OpenGL)
meta->addStatement( new GenOp( " @ = texture(@, @);\r\n", bufferSampleDecl, prepassSampler, screenUV) );
meta->addStatement( new GenOp( " @ = texture(@, @);\r\n", bufferSampleDecl, deferredSampler, screenUV) );
else
meta->addStatement( new GenOp( " @ = tex2D(@, @);\r\n", bufferSampleDecl, prepassSampler, screenUV ) );
meta->addStatement( new GenOp( " @ = tex2D(@, @);\r\n", bufferSampleDecl, deferredSampler, screenUV ) );
meta->addStatement( new GenOp( " #endif\r\n\r\n" ) );
// We don't use this way of passing var's around, so this should cause a crash
@ -1076,7 +1076,7 @@ Var* LinearEyeDepthConditioner::printMethodHeader( MethodType methodType, const
return retVal;
}
void RenderPrePassMgr::_initShaders()
void RenderDeferredMgr::_initShaders()
{
if ( mClearGBufferShader ) return;
@ -1084,7 +1084,7 @@ void RenderPrePassMgr::_initShaders()
ShaderData *shaderData;
mClearGBufferShader = Sim::findObject( "ClearGBufferShader", shaderData ) ? shaderData->getShader() : NULL;
if ( !mClearGBufferShader )
Con::errorf( "RenderPrePassMgr::_initShaders - could not find ClearGBufferShader" );
Con::errorf( "RenderDeferredMgr::_initShaders - could not find ClearGBufferShader" );
// Create StateBlocks
GFXStateBlockDesc desc;
@ -1108,7 +1108,7 @@ void RenderPrePassMgr::_initShaders()
mSpecularPowerSC = mClearGBufferShader->getShaderConstHandle( "$specularPower" );
}
void RenderPrePassMgr::clearBuffers()
void RenderDeferredMgr::clearBuffers()
{
// Clear z-buffer.
GFX->clear( GFXClearTarget | GFXClearZBuffer | GFXClearStencil, ColorI::ZERO, 1.0f, 0);

60
Engine/source/renderInstance/renderPrePassMgr.h → Engine/source/renderInstance/renderDeferredMgr.h
View file

@ -29,12 +29,12 @@
#include "core/util/autoPtr.h"
// Forward declare
class PrePassMatInstance;
class DeferredMatInstance;
// This render manager renders opaque objects to the z-buffer as a z-fill pass.
// It can optionally accumulate data from this opaque render pass into a render
// target for later use.
class RenderPrePassMgr : public RenderTexTargetBinManager
class RenderDeferredMgr : public RenderTexTargetBinManager
{
typedef RenderTexTargetBinManager Parent;
@ -47,15 +47,15 @@ public:
static const String ColorBufferName;
static const String MatInfoBufferName;
// Generic PrePass Render Instance Type
static const RenderInstType RIT_PrePass;
// Generic Deferred Render Instance Type
static const RenderInstType RIT_Deferred;
RenderPrePassMgr( bool gatherDepth = true,
RenderDeferredMgr( bool gatherDepth = true,
GFXFormat format = GFXFormatR16G16B16A16 );
virtual ~RenderPrePassMgr();
virtual ~RenderDeferredMgr();
virtual void setPrePassMaterial( PrePassMatInstance *mat );
virtual void setDeferredMaterial( DeferredMatInstance *mat );
// RenderBinManager interface
virtual void render(SceneRenderState * state);
@ -64,10 +64,10 @@ public:
virtual void addElement( RenderInst *inst );
// ConsoleObject
DECLARE_CONOBJECT(RenderPrePassMgr);
DECLARE_CONOBJECT(RenderDeferredMgr);
typedef Signal<void(const SceneRenderState*, RenderPrePassMgr*, bool)> RenderSignal;
typedef Signal<void(const SceneRenderState*, RenderDeferredMgr*, bool)> RenderSignal;
static RenderSignal& getRenderSignal();
@ -79,7 +79,7 @@ public:
virtual bool setTargetSize(const Point2I &newTargetSize);
inline BaseMatInstance* getPrePassMaterial( BaseMatInstance *mat );
inline BaseMatInstance* getDeferredMaterial( BaseMatInstance *mat );
protected:
@ -89,12 +89,12 @@ protected:
/// The object render instance elements.
Vector< MainSortElem > mObjectElementList;
PrePassMatInstance *mPrePassMatInstance;
DeferredMatInstance *mDeferredMatInstance;
virtual void _registerFeatures();
virtual void _unregisterFeatures();
virtual bool _updateTargets();
virtual void _createPrePassMaterial();
virtual void _createDeferredMaterial();
bool _lightManagerActivate(bool active);
@ -117,12 +117,12 @@ public:
//------------------------------------------------------------------------------
class ProcessedPrePassMaterial : public ProcessedShaderMaterial
class ProcessedDeferredMaterial : public ProcessedShaderMaterial
{
typedef ProcessedShaderMaterial Parent;
public:
ProcessedPrePassMaterial(Material& mat, const RenderPrePassMgr *prePassMgr);
ProcessedDeferredMaterial(Material& mat, const RenderDeferredMgr *prePassMgr);
virtual U32 getNumStages();
@ -131,19 +131,19 @@ public:
protected:
virtual void _determineFeatures( U32 stageNum, MaterialFeatureData &fd, const FeatureSet &features );
const RenderPrePassMgr *mPrePassMgr;
const RenderDeferredMgr *mDeferredMgr;
bool mIsLightmappedGeometry;
};
//------------------------------------------------------------------------------
class PrePassMatInstance : public MatInstance
class DeferredMatInstance : public MatInstance
{
typedef MatInstance Parent;
public:
PrePassMatInstance(MatInstance* root, const RenderPrePassMgr *prePassMgr);
virtual ~PrePassMatInstance();
DeferredMatInstance(MatInstance* root, const RenderDeferredMgr *prePassMgr);
virtual ~DeferredMatInstance();
bool init()
{
@ -157,27 +157,27 @@ public:
protected:
virtual ProcessedMaterial* getShaderMaterial();
const RenderPrePassMgr *mPrePassMgr;
const RenderDeferredMgr *mDeferredMgr;
};
//------------------------------------------------------------------------------
class PrePassMatInstanceHook : public MatInstanceHook
class DeferredMatInstanceHook : public MatInstanceHook
{
public:
PrePassMatInstanceHook(MatInstance *baseMatInst, const RenderPrePassMgr *prePassMgr);
virtual ~PrePassMatInstanceHook();
DeferredMatInstanceHook(MatInstance *baseMatInst, const RenderDeferredMgr *prePassMgr);
virtual ~DeferredMatInstanceHook();
virtual PrePassMatInstance *getPrePassMatInstance() { return mHookedPrePassMatInst; }
virtual DeferredMatInstance *getDeferredMatInstance() { return mHookedDeferredMatInst; }
virtual const MatInstanceHookType& getType() const { return Type; }
/// The type for prepass material hooks.
/// The type for deferred material hooks.
static const MatInstanceHookType Type;
protected:
PrePassMatInstance *mHookedPrePassMatInst;
const RenderPrePassMgr *mPrePassManager;
DeferredMatInstance *mHookedDeferredMatInst;
const RenderDeferredMgr *mDeferredManager;
};
//------------------------------------------------------------------------------
@ -208,16 +208,16 @@ protected:
};
inline BaseMatInstance* RenderPrePassMgr::getPrePassMaterial( BaseMatInstance *mat )
inline BaseMatInstance* RenderDeferredMgr::getDeferredMaterial( BaseMatInstance *mat )
{
PrePassMatInstanceHook *hook = static_cast<PrePassMatInstanceHook*>( mat->getHook( PrePassMatInstanceHook::Type ) );
DeferredMatInstanceHook *hook = static_cast<DeferredMatInstanceHook*>( mat->getHook( DeferredMatInstanceHook::Type ) );
if ( !hook )
{
hook = new PrePassMatInstanceHook( static_cast<MatInstance*>( mat ), this );
hook = new DeferredMatInstanceHook( static_cast<MatInstance*>( mat ), this );
mat->addHook( hook );
}
return hook->getPrePassMatInstance();
return hook->getDeferredMatInstance();
}
#endif // _PREPASS_MGR_H_

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

@ -30,7 +30,7 @@
#include "lighting/lightInfo.h"
#include "scene/sceneRenderState.h"
#include "gfx/gfxDebugEvent.h"
#include "renderInstance/renderPrePassMgr.h"
#include "renderInstance/renderDeferredMgr.h"
#include "gfx/gfxTransformSaver.h"
#include "console/consoleTypes.h"
#include "gfx/util/screenspace.h"
@ -70,7 +70,7 @@ RenderImposterMgr::RenderImposterMgr( F32 renderOrder, F32 processAddOrder )
: RenderBinManager( RIT_Imposter, renderOrder, processAddOrder )
{
notifyType( RIT_ImposterBatch );
RenderPrePassMgr::getRenderSignal().notify( this, &RenderImposterMgr::_renderPrePass );
RenderDeferredMgr::getRenderSignal().notify( this, &RenderImposterMgr::_renderDeferred );
}
void RenderImposterMgr::initPersistFields()
@ -88,7 +88,7 @@ void RenderImposterMgr::initPersistFields()
RenderImposterMgr::~RenderImposterMgr()
{
RenderPrePassMgr::getRenderSignal().remove( this, &RenderImposterMgr::_renderPrePass );
RenderDeferredMgr::getRenderSignal().remove( this, &RenderImposterMgr::_renderDeferred );
mIB = NULL;
}
@ -119,19 +119,19 @@ bool RenderImposterMgr::_clearStats( GFXDevice::GFXDeviceEventType type )
return true;
}
void RenderImposterMgr::_renderPrePass( const SceneRenderState *state, RenderPrePassMgr *prePassBin, bool startPrePass )
void RenderImposterMgr::_renderDeferred( const SceneRenderState *state, RenderDeferredMgr *prePassBin, bool startDeferred )
{
PROFILE_SCOPE( RenderImposterMgr_RenderPrePass );
PROFILE_SCOPE( RenderImposterMgr_RenderDeferred );
if ( !mElementList.size() || !startPrePass )
if ( !mElementList.size() || !startDeferred )
return;
GFXDEBUGEVENT_SCOPE( RenderImposterMgr_RenderPrePass, ColorI::RED );
GFXDEBUGEVENT_SCOPE( RenderImposterMgr_RenderDeferred, ColorI::RED );
_innerRender( state, prePassBin );
}
void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderPrePassMgr *prePassBin )
void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDeferredMgr *prePassBin )
{
PROFILE_SCOPE( RenderImposterMgr_InnerRender );
@ -219,7 +219,7 @@ void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderPrePa
// list changes.
SceneData sgData;
sgData.init( state, prePassBin ? SceneData::PrePassBin : SceneData::RegularBin );
sgData.init( state, prePassBin ? 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, RenderPrePa
for ( U32 i=0; i < binSize; )
{
currMat = static_cast<ImposterBaseRenderInst*>( mElementList[i].inst )->mat;
setupMat = prePassBin ? prePassBin->getPrePassMaterial( currMat ) : currMat;
setupMat = prePassBin ? prePassBin->getDeferredMaterial( currMat ) : currMat;
// TODO: Fix MatInstance to take a const SceneRenderState!
while ( setupMat->setupPass( (SceneRenderState*)state, sgData ) )

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

@ -38,7 +38,7 @@
class TSLastDetail;
class GFXTextureObject;
class RenderPrePassMgr;
class RenderDeferredMgr;
struct ImposterRenderInst;
@ -74,9 +74,9 @@ protected:
GFXPrimitiveBufferHandle mIB;
//GFXVertexBufferHandle<ImposterCorner> mCornerVB;
void _innerRender( const SceneRenderState *state, RenderPrePassMgr *prePassBin );
void _innerRender( const SceneRenderState *state, RenderDeferredMgr *prePassBin );
void _renderPrePass( const SceneRenderState *state, RenderPrePassMgr *prePassBin, bool startPrePass );
void _renderDeferred( const SceneRenderState *state, RenderDeferredMgr *prePassBin, bool startDeferred );
static bool _clearStats( GFXDevice::GFXDeviceEventType type );

2
Engine/source/renderInstance/renderMeshMgr.cpp
View file

@ -147,7 +147,7 @@ void RenderMeshMgr::render(SceneRenderState * state)
// Check if bin is disabled in advanced lighting.
// Allow forward rendering pass on custom materials.
if ( ( MATMGR->getPrePassEnabled() && mBasicOnly && !mat->isCustomMaterial() ) )
if ( ( MATMGR->getDeferredEnabled() && mBasicOnly && !mat->isCustomMaterial() ) )
{
j++;
continue;

2
Engine/source/renderInstance/renderObjectMgr.cpp
View file

@ -69,7 +69,7 @@ void RenderObjectMgr::render( SceneRenderState *state )
return;
// Check if bin is disabled in advanced lighting.
if ( MATMGR->getPrePassEnabled() && mBasicOnly )
if ( MATMGR->getDeferredEnabled() && mBasicOnly )
return;
for( U32 i=0; i<mElementList.size(); i++ )

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

@ -22,7 +22,7 @@
#include "platform/platform.h"
#include "renderInstance/renderParticleMgr.h"
#include "renderInstance/renderPrePassMgr.h"
#include "renderInstance/renderDeferredMgr.h"
#include "scene/sceneManager.h"
#include "scene/sceneObject.h"
#include "scene/sceneRenderState.h"
@ -512,17 +512,17 @@ void RenderParticleMgr::renderParticle(ParticleRenderInst* ri, SceneRenderState*
GFX->setTexture( mParticleShaderConsts.mSamplerDiffuse->getSamplerRegister(), ri->diffuseTex );
// Set up the prepass texture.
if ( mParticleShaderConsts.mPrePassTargetParamsSC->isValid() )
// Set up the deferred texture.
if ( mParticleShaderConsts.mDeferredTargetParamsSC->isValid() )
{
GFXTextureObject *texObject = mPrepassTarget ? mPrepassTarget->getTexture(0) : NULL;
GFX->setTexture( mParticleShaderConsts.mSamplerPrePassTex->getSamplerRegister(), texObject );
GFXTextureObject *texObject = mDeferredTarget ? mDeferredTarget->getTexture(0) : NULL;
GFX->setTexture( mParticleShaderConsts.mSamplerDeferredTex->getSamplerRegister(), texObject );
Point4F rtParams( 0.0f, 0.0f, 1.0f, 1.0f );
if ( texObject )
ScreenSpace::RenderTargetParameters(texObject->getSize(), mPrepassTarget->getViewport(), rtParams);
ScreenSpace::RenderTargetParameters(texObject->getSize(), mDeferredTarget->getViewport(), rtParams);
mParticleShaderConsts.mShaderConsts->set( mParticleShaderConsts.mPrePassTargetParamsSC, rtParams );
mParticleShaderConsts.mShaderConsts->set( mParticleShaderConsts.mDeferredTargetParamsSC, rtParams );
}
GFX->setPrimitiveBuffer( *ri->primBuff );
@ -538,8 +538,8 @@ bool RenderParticleMgr::_initShader()
// Need depth from pre-pass, so get the macros
Vector<GFXShaderMacro> macros;
if ( mPrepassTarget )
mPrepassTarget->getShaderMacros( &macros );
if ( mDeferredTarget )
mDeferredTarget->getShaderMacros( &macros );
// Create particle shader
if ( !Sim::findObject( "ParticlesShaderData", shaderData ) || !shaderData )
@ -557,11 +557,11 @@ bool RenderParticleMgr::_initShader()
mParticleShaderConsts.mAlphaFactorSC = mParticleShader->getShaderConstHandle( "$alphaFactor" );
mParticleShaderConsts.mAlphaScaleSC = mParticleShader->getShaderConstHandle( "$alphaScale" );
mParticleShaderConsts.mFSModelViewProjSC = mParticleShader->getShaderConstHandle( "$fsModelViewProj" );
mParticleShaderConsts.mPrePassTargetParamsSC = mParticleShader->getShaderConstHandle( "$prePassTargetParams" );
mParticleShaderConsts.mDeferredTargetParamsSC = mParticleShader->getShaderConstHandle( "$prePassTargetParams" );
//samplers
mParticleShaderConsts.mSamplerDiffuse = mParticleShader->getShaderConstHandle("$diffuseMap");
mParticleShaderConsts.mSamplerPrePassTex = mParticleShader->getShaderConstHandle("$prepassTex");
mParticleShaderConsts.mSamplerDeferredTex = mParticleShader->getShaderConstHandle("$deferredTex");
mParticleShaderConsts.mSamplerParaboloidLightMap = mParticleShader->getShaderConstHandle("$paraboloidLightMap");
}
@ -596,18 +596,18 @@ void RenderParticleMgr::_onLMActivate( const char*, bool activate )
return;
// Hunt for the pre-pass manager/target
RenderPrePassMgr *prePassBin = NULL;
RenderDeferredMgr *prePassBin = NULL;
for( U32 i = 0; i < rpm->getManagerCount(); i++ )
{
RenderBinManager *bin = rpm->getManager(i);
if( bin->getRenderInstType() == RenderPrePassMgr::RIT_PrePass )
if( bin->getRenderInstType() == RenderDeferredMgr::RIT_Deferred )
{
prePassBin = (RenderPrePassMgr*)bin;
prePassBin = (RenderDeferredMgr*)bin;
break;
}
}
// If we found the prepass 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
// have a depth-texture, we can't render offscreen.
mOffscreenRenderEnabled = prePassBin && (prePassBin->getTargetChainLength() > 0);
@ -619,7 +619,7 @@ void RenderParticleMgr::_onLMActivate( const char*, bool activate )
}
// Find the targets we use
mPrepassTarget = NamedTexTarget::find( "prepass" );
mDeferredTarget = NamedTexTarget::find( "deferred" );
mEdgeTarget = NamedTexTarget::find( "edge" );
// Setup the shader
@ -668,7 +668,7 @@ GFXStateBlockRef RenderParticleMgr::_getOffscreenStateBlock(ParticleRenderInst *
d.samplers[0].alphaArg1 = GFXTATexture;
d.samplers[0].alphaArg2 = GFXTADiffuse;
// Prepass sampler
// Deferred sampler
d.samplers[1] = GFXSamplerStateDesc::getClampPoint();
mOffscreenBlocks[blendStyle] = GFX->createStateBlock(d);
@ -701,7 +701,7 @@ GFXStateBlockRef RenderParticleMgr::_getHighResStateBlock(ParticleRenderInst *ri
d.samplers[0].alphaArg1 = GFXTATexture;
d.samplers[0].alphaArg2 = GFXTADiffuse;
// Prepass sampler
// Deferred sampler
d.samplers[1] = GFXSamplerStateDesc::getClampPoint();
mHighResBlocks[blendStyle] = GFX->createStateBlock(d);
@ -773,7 +773,7 @@ GFXStateBlockRef RenderParticleMgr::_getMixedResStateBlock(ParticleRenderInst *r
d.samplers[0].alphaArg1 = GFXTATexture;
d.samplers[0].alphaArg2 = GFXTADiffuse;
// Prepass sampler
// Deferred sampler
d.samplers[1] = GFXSamplerStateDesc::getClampPoint();
mMixedResBlocks[blendStyle] = GFX->createStateBlock(d);

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

@ -42,7 +42,7 @@ class RenderParticleMgr : public RenderTexTargetBinManager
friend class RenderTranslucentMgr;
public:
// Generic PrePass Render Instance Type
// Generic Deferred Render Instance Type
static const RenderInstType RIT_Particles;
RenderParticleMgr();
@ -82,9 +82,9 @@ public:
protected:
bool mOffscreenRenderEnabled;
/// The prepass render target used for the
/// The deferred render target used for the
/// soft particle shader effect.
NamedTexTargetRef mPrepassTarget;
NamedTexTargetRef mDeferredTarget;
/// The shader used for particle rendering.
GFXShaderRef mParticleShader;
@ -109,11 +109,11 @@ protected:
GFXShaderConstHandle *mFSModelViewProjSC;
GFXShaderConstHandle *mOneOverFarSC;
GFXShaderConstHandle *mOneOverSoftnessSC;
GFXShaderConstHandle *mPrePassTargetParamsSC;
GFXShaderConstHandle *mDeferredTargetParamsSC;
GFXShaderConstHandle *mAlphaFactorSC;
GFXShaderConstHandle *mAlphaScaleSC;
GFXShaderConstHandle *mSamplerDiffuse;
GFXShaderConstHandle *mSamplerPrePassTex;
GFXShaderConstHandle *mSamplerDeferredTex;
GFXShaderConstHandle *mSamplerParaboloidLightMap;
} mParticleShaderConsts;

2
Engine/source/renderInstance/renderTerrainMgr.cpp
View file

@ -119,7 +119,7 @@ void RenderTerrainMgr::render( SceneRenderState *state )
return;
// Check if bin is disabled in advanced lighting.
if ( MATMGR->getPrePassEnabled() && mBasicOnly )
if ( MATMGR->getDeferredEnabled() && mBasicOnly )
return;
PROFILE_SCOPE( RenderTerrainMgr_Render );

2
Engine/source/renderInstance/renderTexTargetBinManager.cpp
View file

@ -37,7 +37,7 @@ ConsoleDocClass( RenderTexTargetBinManager,
"@brief An abstract base class for render bin managers that render to a named textue target.\n\n"
"This bin itself doesn't do any rendering work. It offers functionality to manage "
"a texture render target which derived render bin classes can render into.\n\n"
"@see RenderPrePassMgr\n"
"@see RenderDeferredMgr\n"
"@ingroup RenderBin\n" );