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

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

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

@ -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

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
// 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_

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

@ -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 ) )

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

@ -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 );

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

@ -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);
}