void PSSMLightShadowMap::_render( RenderPassManager* renderPass,
const SceneRenderState *diffuseState )
{
PROFILE_SCOPE(PSSMLightShadowMap_render);
const ShadowMapParams *params = mLight->getExtended<ShadowMapParams>();
const LightMapParams *lmParams = mLight->getExtended<LightMapParams>();
const bool bUseLightmappedGeometry = lmParams ? !lmParams->representedInLightmap || lmParams->includeLightmappedGeometryInShadow : true;
const U32 texSize = getBestTexSize( params->numSplits < 4 ? params->numSplits : 2 );
if ( mShadowMapTex.isNull() ||
mNumSplits != params->numSplits ||
mTexSize != texSize )
{
_setNumSplits( params->numSplits, texSize );
mShadowMapDepth = _getDepthTarget( mShadowMapTex->getWidth(), mShadowMapTex->getHeight() );
}
mLogWeight = params->logWeight;
Frustum fullFrustum( diffuseState->getCameraFrustum() );
fullFrustum.cropNearFar(fullFrustum.getNearDist(), params->shadowDistance);
GFXFrustumSaver frustSaver;
GFXTransformSaver saver;
// Set our render target
GFX->pushActiveRenderTarget();
mTarget->attachTexture( GFXTextureTarget::Color0, mShadowMapTex );
mTarget->attachTexture( GFXTextureTarget::DepthStencil, mShadowMapDepth );
GFX->setActiveRenderTarget( mTarget );
GFX->clear( GFXClearStencil | GFXClearZBuffer | GFXClearTarget, ColorI(255,255,255), 1.0f, 0 );
// Calculate our standard light matrices
MatrixF lightMatrix;
calcLightMatrices( lightMatrix, diffuseState->getCameraFrustum() );
lightMatrix.inverse();
MatrixF lightViewProj = GFX->getProjectionMatrix() * lightMatrix;
// TODO: This is just retrieving the near and far calculated
// in calcLightMatrices... we should make that clear.
F32 pnear, pfar;
GFX->getFrustum( NULL, NULL, NULL, NULL, &pnear, &pfar, NULL );
// Set our view up
GFX->setWorldMatrix(lightMatrix);
MatrixF toLightSpace = lightMatrix; // * invCurrentView;
_calcSplitPos(fullFrustum);
mWorldToLightProj = GFX->getProjectionMatrix() * toLightSpace;
// Apply the PSSM
const F32 savedSmallestVisible = TSShapeInstance::smSmallestVisiblePixelSize;
const F32 savedDetailAdjust = TSShapeInstance::smDetailAdjust;
TSShapeInstance::smDetailAdjust *= smDetailAdjustScale;
TSShapeInstance::smSmallestVisiblePixelSize = smSmallestVisiblePixelSize;
for (U32 i = 0; i < mNumSplits; i++)
{
GFXTransformSaver saver;
// Calculate a sub-frustum
Frustum subFrustum(fullFrustum);
subFrustum.cropNearFar(mSplitDist[i], mSplitDist[i+1]);
// Calculate our AABB in the light's clip space.
Box3F clipAABB = _calcClipSpaceAABB(subFrustum, lightViewProj, fullFrustum.getFarDist());
// Calculate our crop matrix
Point3F scale(2.0f / (clipAABB.maxExtents.x - clipAABB.minExtents.x),
2.0f / (clipAABB.maxExtents.y - clipAABB.minExtents.y),
1.0f);
// TODO: This seems to produce less "pops" of the
// shadow resolution as the camera spins around and
// it should produce pixels that are closer to being
// square.
//
// Still is it the right thing to do?
//
scale.y = scale.x = ( getMin( scale.x, scale.y ) );
//scale.x = mFloor(scale.x);
//scale.y = mFloor(scale.y);
Point3F offset( -0.5f * (clipAABB.maxExtents.x + clipAABB.minExtents.x) * scale.x,
-0.5f * (clipAABB.maxExtents.y + clipAABB.minExtents.y) * scale.y,
0.0f );
MatrixF cropMatrix(true);
cropMatrix.scale(scale);
cropMatrix.setPosition(offset);
_roundProjection(lightMatrix, cropMatrix, offset, i);
cropMatrix.setPosition(offset);
// Save scale/offset for shader computations
mScaleProj[i].set(scale);
mOffsetProj[i].set(offset);
// Adjust the far plane to the max z we got (maybe add a little to deal with split overlap)
bool isOrtho;
{
F32 left, right, bottom, top, nearDist, farDist;
GFX->getFrustum(&left, &right, &bottom, &top, &nearDist, &farDist,&isOrtho);
// BTRTODO: Fix me!
farDist = clipAABB.maxExtents.z;
if (!isOrtho)
GFX->setFrustum(left, right, bottom, top, nearDist, farDist);
else
{
// Calculate a new far plane, add a fudge factor to avoid bringing
// the far plane in too close.
F32 newFar = pfar * clipAABB.maxExtents.z + 1.0f;
mFarPlaneScalePSSM[i] = (pfar - pnear) / (newFar - pnear);
GFX->setOrtho(left, right, bottom, top, pnear, newFar, true);
}
}
// Crop matrix multiply needs to be post-projection.
MatrixF alightProj = GFX->getProjectionMatrix();
alightProj = cropMatrix * alightProj;
// Set our new projection
GFX->setProjectionMatrix(alightProj);
// Render into the quad of the shadow map we are using.
GFX->setViewport(mViewports[i]);
SceneManager* sceneManager = diffuseState->getSceneManager();
// The frustum is currently the full size and has not had
// cropping applied.
//
// We make that adjustment here.
const Frustum& uncroppedFrustum = GFX->getFrustum();
Frustum croppedFrustum;
scale *= 0.5f;
croppedFrustum.set(
isOrtho,
uncroppedFrustum.getNearLeft() / scale.x,
uncroppedFrustum.getNearRight() / scale.x,
uncroppedFrustum.getNearTop() / scale.y,
uncroppedFrustum.getNearBottom() / scale.y,
uncroppedFrustum.getNearDist(),
uncroppedFrustum.getFarDist(),
uncroppedFrustum.getTransform()
);
MatrixF camera = GFX->getWorldMatrix();
camera.inverse();
croppedFrustum.setTransform( camera );
// Setup the scene state and use the diffuse state
// camera position and screen metrics values so that
// lod is done the same as in the diffuse pass.
SceneRenderState shadowRenderState
(
sceneManager,
SPT_Shadow,
SceneCameraState( diffuseState->getViewport(), croppedFrustum,
GFX->getWorldMatrix(), GFX->getProjectionMatrix() ),
renderPass
);
shadowRenderState.getMaterialDelegate().bind( this, &LightShadowMap::getShadowMaterial );
shadowRenderState.renderNonLightmappedMeshes( true );
shadowRenderState.renderLightmappedMeshes( bUseLightmappedGeometry );
shadowRenderState.setDiffuseCameraTransform( diffuseState->getCameraTransform() );
shadowRenderState.setWorldToScreenScale( diffuseState->getWorldToScreenScale() );
U32 objectMask = SHADOW_TYPEMASK;
if ( i == mNumSplits-1 && params->lastSplitTerrainOnly )
objectMask = TerrainObjectType;
sceneManager->renderSceneNoLights( &shadowRenderState, objectMask );
_debugRender( &shadowRenderState );
}
// Restore the original TS lod settings.
TSShapeInstance::smSmallestVisiblePixelSize = savedSmallestVisible;
TSShapeInstance::smDetailAdjust = savedDetailAdjust;
// Release our render target
mTarget->resolve();
GFX->popActiveRenderTarget();
}
void PlaneReflector::updateReflection( const ReflectParams ¶ms )
{
PROFILE_SCOPE(PlaneReflector_updateReflection);
GFXDEBUGEVENT_SCOPE( PlaneReflector_updateReflection, ColorI::WHITE );
mIsRendering = true;
S32 texDim = mDesc->texSize;
texDim = getMax( texDim, 32 );
// Protect against the reflection texture being bigger
// than the current game back buffer.
texDim = getMin( texDim, params.viewportExtent.x );
texDim = getMin( texDim, params.viewportExtent.y );
bool texResize = ( texDim != mLastTexSize );
mLastTexSize = texDim;
const Point2I texSize( texDim, texDim );
if ( texResize ||
reflectTex.isNull() ||
reflectTex->getFormat() != REFLECTMGR->getReflectFormat() )
reflectTex = REFLECTMGR->allocRenderTarget( texSize );
GFXTexHandle depthBuff = LightShadowMap::_getDepthTarget( texSize.x, texSize.y );
// store current matrices
GFXTransformSaver saver;
Point2I viewport(params.viewportExtent);
if(GFX->getCurrentRenderStyle() == GFXDevice::RS_StereoSideBySide)
{
viewport.x *= 0.5f;
}
F32 aspectRatio = F32( viewport.x ) / F32( viewport.y );
Frustum frustum;
frustum.set(false, params.query->fov, aspectRatio, params.query->nearPlane, params.query->farPlane);
// Manipulate the frustum for tiled screenshots
const bool screenShotMode = gScreenShot && gScreenShot->isPending();
if ( screenShotMode )
gScreenShot->tileFrustum( frustum );
GFX->setFrustum( frustum );
// Store the last view info for scoring.
mLastDir = params.query->cameraMatrix.getForwardVector();
mLastPos = params.query->cameraMatrix.getPosition();
setGFXMatrices( params.query->cameraMatrix );
// Adjust the detail amount
F32 detailAdjustBackup = TSShapeInstance::smDetailAdjust;
TSShapeInstance::smDetailAdjust *= mDesc->detailAdjust;
if(reflectTarget.isNull())
reflectTarget = GFX->allocRenderToTextureTarget();
reflectTarget->attachTexture( GFXTextureTarget::Color0, reflectTex );
reflectTarget->attachTexture( GFXTextureTarget::DepthStencil, depthBuff );
GFX->pushActiveRenderTarget();
GFX->setActiveRenderTarget( reflectTarget );
U32 objTypeFlag = -1;
SceneCameraState reflectCameraState = SceneCameraState::fromGFX();
LIGHTMGR->registerGlobalLights( &reflectCameraState.getFrustum(), false );
// Since we can sometime be rendering a reflection for 1 or 2 frames before
// it gets updated do to the lag associated with getting the results from
// a HOQ we can sometimes see into parts of the reflection texture that
// have nothing but clear color ( eg. under the water ).
// To make this look less crappy use the ambient color of the sun.
//
// In the future we may want to fix this instead by having the scatterSky
// render a skirt or something in its lower half.
//
ColorF clearColor = gClientSceneGraph->getAmbientLightColor();
GFX->clear( GFXClearZBuffer | GFXClearStencil | GFXClearTarget, clearColor, 1.0f, 0 );
if(GFX->getCurrentRenderStyle() == GFXDevice::RS_StereoSideBySide)
{
// Store previous values
RectI originalVP = GFX->getViewport();
Point2F projOffset = GFX->getCurrentProjectionOffset();
Point3F eyeOffset = GFX->getStereoEyeOffset();
// Render left half of display
RectI leftVP = originalVP;
leftVP.extent.x *= 0.5;
GFX->setViewport(leftVP);
MatrixF leftWorldTrans(true);
leftWorldTrans.setPosition(Point3F(eyeOffset.x, eyeOffset.y, eyeOffset.z));
MatrixF leftWorld(params.query->cameraMatrix);
leftWorld.mulL(leftWorldTrans);
Frustum gfxFrustum = GFX->getFrustum();
gfxFrustum.setProjectionOffset(Point2F(projOffset.x, projOffset.y));
GFX->setFrustum(gfxFrustum);
setGFXMatrices( leftWorld );
SceneCameraState cameraStateLeft = SceneCameraState::fromGFX();
SceneRenderState renderStateLeft( gClientSceneGraph, SPT_Reflect, cameraStateLeft );
renderStateLeft.setSceneRenderStyle(SRS_SideBySide);
renderStateLeft.setSceneRenderField(0);
renderStateLeft.getMaterialDelegate().bind( REFLECTMGR, &ReflectionManager::getReflectionMaterial );
renderStateLeft.setDiffuseCameraTransform( params.query->cameraMatrix );
renderStateLeft.disableAdvancedLightingBins(true);
gClientSceneGraph->renderSceneNoLights( &renderStateLeft, objTypeFlag );
// Render right half of display
RectI rightVP = originalVP;
rightVP.extent.x *= 0.5;
rightVP.point.x += rightVP.extent.x;
GFX->setViewport(rightVP);
MatrixF rightWorldTrans(true);
rightWorldTrans.setPosition(Point3F(-eyeOffset.x, eyeOffset.y, eyeOffset.z));
MatrixF rightWorld(params.query->cameraMatrix);
rightWorld.mulL(rightWorldTrans);
gfxFrustum = GFX->getFrustum();
gfxFrustum.setProjectionOffset(Point2F(-projOffset.x, projOffset.y));
GFX->setFrustum(gfxFrustum);
setGFXMatrices( rightWorld );
SceneCameraState cameraStateRight = SceneCameraState::fromGFX();
SceneRenderState renderStateRight( gClientSceneGraph, SPT_Reflect, cameraStateRight );
renderStateRight.setSceneRenderStyle(SRS_SideBySide);
renderStateRight.setSceneRenderField(1);
renderStateRight.getMaterialDelegate().bind( REFLECTMGR, &ReflectionManager::getReflectionMaterial );
renderStateRight.setDiffuseCameraTransform( params.query->cameraMatrix );
renderStateRight.disableAdvancedLightingBins(true);
gClientSceneGraph->renderSceneNoLights( &renderStateRight, objTypeFlag );
// Restore previous values
gfxFrustum.clearProjectionOffset();
GFX->setFrustum(gfxFrustum);
GFX->setViewport(originalVP);
}
else
{
SceneRenderState reflectRenderState
(
gClientSceneGraph,
SPT_Reflect,
SceneCameraState::fromGFX()
);
reflectRenderState.getMaterialDelegate().bind( REFLECTMGR, &ReflectionManager::getReflectionMaterial );
reflectRenderState.setDiffuseCameraTransform( params.query->cameraMatrix );
reflectRenderState.disableAdvancedLightingBins(true);
gClientSceneGraph->renderSceneNoLights( &reflectRenderState, objTypeFlag );
}
LIGHTMGR->unregisterAllLights();
// Clean up.
reflectTarget->resolve();
GFX->popActiveRenderTarget();
// Restore detail adjust amount.
TSShapeInstance::smDetailAdjust = detailAdjustBackup;
mIsRendering = false;
}
void CubeReflector::updateFace( const ReflectParams ¶ms, U32 faceidx )
{
GFXDEBUGEVENT_SCOPE( CubeReflector_UpdateFace, ColorI::WHITE );
// store current matrices
GFXTransformSaver saver;
// set projection to 90 degrees vertical and horizontal
F32 left, right, top, bottom;
MathUtils::makeFrustum( &left, &right, &top, &bottom, M_HALFPI_F, 1.0f, mDesc->nearDist );
GFX->setFrustum( left, right, bottom, top, mDesc->nearDist, mDesc->farDist );
// We don't use a special clipping projection, but still need to initialize
// this for objects like SkyBox which will use it during a reflect pass.
gClientSceneGraph->setNonClipProjection( GFX->getProjectionMatrix() );
// Standard view that will be overridden below.
VectorF vLookatPt(0.0f, 0.0f, 0.0f), vUpVec(0.0f, 0.0f, 0.0f), vRight(0.0f, 0.0f, 0.0f);
switch( faceidx )
{
case 0 : // D3DCUBEMAP_FACE_POSITIVE_X:
vLookatPt = VectorF( 1.0f, 0.0f, 0.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
case 1 : // D3DCUBEMAP_FACE_NEGATIVE_X:
vLookatPt = VectorF( -1.0f, 0.0f, 0.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
case 2 : // D3DCUBEMAP_FACE_POSITIVE_Y:
vLookatPt = VectorF( 0.0f, 1.0f, 0.0f );
vUpVec = VectorF( 0.0f, 0.0f,-1.0f );
break;
case 3 : // D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookatPt = VectorF( 0.0f, -1.0f, 0.0f );
vUpVec = VectorF( 0.0f, 0.0f, 1.0f );
break;
case 4 : // D3DCUBEMAP_FACE_POSITIVE_Z:
vLookatPt = VectorF( 0.0f, 0.0f, 1.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
case 5: // D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookatPt = VectorF( 0.0f, 0.0f, -1.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
}
// create camera matrix
VectorF cross = mCross( vUpVec, vLookatPt );
cross.normalizeSafe();
MatrixF matView(true);
matView.setColumn( 0, cross );
matView.setColumn( 1, vLookatPt );
matView.setColumn( 2, vUpVec );
matView.setPosition( mObject->getPosition() );
matView.inverse();
GFX->setWorldMatrix(matView);
renderTarget->attachTexture( GFXTextureTarget::Color0, cubemap, faceidx );
GFX->setActiveRenderTarget( renderTarget );
GFX->clear( GFXClearStencil | GFXClearTarget | GFXClearZBuffer, gCanvasClearColor, 1.0f, 0 );
SceneRenderState reflectRenderState
(
gClientSceneGraph,
SPT_Reflect,
SceneCameraState::fromGFX()
);
reflectRenderState.getMaterialDelegate().bind( REFLECTMGR, &ReflectionManager::getReflectionMaterial );
reflectRenderState.setDiffuseCameraTransform( params.query->cameraMatrix );
reflectRenderState.disableAdvancedLightingBins(true);
// render scene
LIGHTMGR->registerGlobalLights( &reflectRenderState.getCullingFrustum(), false );
gClientSceneGraph->renderSceneNoLights( &reflectRenderState, mDesc->objectTypeMask );
LIGHTMGR->unregisterAllLights();
// Clean up.
renderTarget->resolve();
}
void ProjectedShadow::_renderToTexture( F32 camDist, const TSRenderState &rdata )
{
PROFILE_SCOPE( ProjectedShadow_RenderToTexture );
GFXDEBUGEVENT_SCOPE( ProjectedShadow_RenderToTexture, ColorI( 255, 0, 0 ) );
RenderPassManager *renderPass = _getRenderPass();
if ( !renderPass )
return;
GFXTransformSaver saver;
// NOTE: GFXTransformSaver does not save/restore the frustum
// so we must save it here before we modify it.
F32 l, r, b, t, n, f;
bool ortho;
GFX->getFrustum( &l, &r, &b, &t, &n, &f, &ortho );
// Set the orthographic projection
// matrix up, to be based on the radius
// generated based on our shape.
GFX->setOrtho( -mRadius, mRadius, -mRadius, mRadius, 0.001f, (mRadius * 2) * smDepthAdjust, true );
// Set the world to light space
// matrix set up in shouldRender().
GFX->setWorldMatrix( mWorldToLight );
// Get the shapebase datablock if we have one.
ShapeBaseData *data = NULL;
if ( mShapeBase )
data = static_cast<ShapeBaseData*>( mShapeBase->getDataBlock() );
// Init or update the shadow texture size.
if ( mShadowTexture.isNull() || ( data && data->shadowSize != mShadowTexture.getWidth() ) )
{
U32 texSize = getNextPow2( data ? data->shadowSize : 256 * LightShadowMap::smShadowTexScalar );
mShadowTexture.set( texSize, texSize, GFXFormatR8G8B8A8, &PostFxTargetProfile, "BLShadow" );
}
GFX->pushActiveRenderTarget();
if ( !mRenderTarget )
mRenderTarget = GFX->allocRenderToTextureTarget();
mRenderTarget->attachTexture( GFXTextureTarget::DepthStencil, _getDepthTarget( mShadowTexture->getWidth(), mShadowTexture->getHeight() ) );
mRenderTarget->attachTexture( GFXTextureTarget::Color0, mShadowTexture );
GFX->setActiveRenderTarget( mRenderTarget );
GFX->clear( GFXClearZBuffer | GFXClearStencil | GFXClearTarget, ColorI( 0, 0, 0, 0 ), 1.0f, 0 );
const SceneRenderState *diffuseState = rdata.getSceneState();
SceneManager *sceneManager = diffuseState->getSceneManager();
SceneRenderState baseState
(
sceneManager,
SPT_Shadow,
SceneCameraState::fromGFXWithViewport( diffuseState->getViewport() ),
renderPass
);
baseState.getMaterialDelegate().bind( &ProjectedShadow::_getShadowMaterial );
baseState.setDiffuseCameraTransform( diffuseState->getCameraTransform() );
baseState.setWorldToScreenScale( diffuseState->getWorldToScreenScale() );
baseState.getCullingState().disableZoneCulling( true );
mParentObject->prepRenderImage( &baseState );
renderPass->renderPass( &baseState );
// Delete the SceneRenderState we allocated.
mRenderTarget->resolve();
GFX->popActiveRenderTarget();
// If we're close enough then filter the shadow.
if ( camDist < BasicLightManager::getShadowFilterDistance() )
{
if ( !smShadowFilter )
{
PostEffect *filter = NULL;
if ( !Sim::findObject( "BL_ShadowFilterPostFx", filter ) )
Con::errorf( "ProjectedShadow::_renderToTexture() - 'BL_ShadowFilterPostFx' not found!" );
smShadowFilter = filter;
}
if ( smShadowFilter )
smShadowFilter->process( NULL, mShadowTexture );
}
// Restore frustum
if (!ortho)
GFX->setFrustum(l, r, b, t, n, f);
else
GFX->setOrtho(l, r, b, t, n, f);
// Set the last render time.
mLastRenderTime = Platform::getVirtualMilliseconds();
// HACK: Will remove in future release!
mDecalInstance->mCustomTex = &mShadowTexture;
}
void SingleLightShadowMap::_render( RenderPassManager* renderPass,
const SceneRenderState *diffuseState )
{
PROFILE_SCOPE(SingleLightShadowMap_render);
const LightMapParams *lmParams = mLight->getExtended<LightMapParams>();
const bool bUseLightmappedGeometry = lmParams ? !lmParams->representedInLightmap || lmParams->includeLightmappedGeometryInShadow : true;
const U32 texSize = getBestTexSize();
if ( mShadowMapTex.isNull() ||
mTexSize != texSize )
{
mTexSize = texSize;
mShadowMapTex.set( mTexSize, mTexSize,
ShadowMapFormat, &ShadowMapProfile,
"SingleLightShadowMap" );
}
GFXFrustumSaver frustSaver;
GFXTransformSaver saver;
MatrixF lightMatrix;
calcLightMatrices( lightMatrix, diffuseState->getCameraFrustum() );
lightMatrix.inverse();
GFX->setWorldMatrix(lightMatrix);
const MatrixF& lightProj = GFX->getProjectionMatrix();
mWorldToLightProj = lightProj * lightMatrix;
// Render the shadowmap!
GFX->pushActiveRenderTarget();
mTarget->attachTexture( GFXTextureTarget::Color0, mShadowMapTex );
mTarget->attachTexture( GFXTextureTarget::DepthStencil,
_getDepthTarget( mShadowMapTex->getWidth(), mShadowMapTex->getHeight() ) );
GFX->setActiveRenderTarget(mTarget);
GFX->clear(GFXClearStencil | GFXClearZBuffer | GFXClearTarget, ColorI(255,255,255), 1.0f, 0);
SceneManager* sceneManager = diffuseState->getSceneManager();
SceneRenderState shadowRenderState
(
sceneManager,
SPT_Shadow,
SceneCameraState::fromGFXWithViewport( diffuseState->getViewport() ),
renderPass
);
shadowRenderState.getMaterialDelegate().bind( this, &LightShadowMap::getShadowMaterial );
shadowRenderState.renderNonLightmappedMeshes( true );
shadowRenderState.renderLightmappedMeshes( bUseLightmappedGeometry );
shadowRenderState.setDiffuseCameraTransform( diffuseState->getCameraTransform() );
shadowRenderState.setWorldToScreenScale( diffuseState->getWorldToScreenScale() );
sceneManager->renderSceneNoLights( &shadowRenderState, SHADOW_TYPEMASK );
_debugRender( &shadowRenderState );
mTarget->resolve();
GFX->popActiveRenderTarget();
}
void DualParaboloidLightShadowMap::_render( RenderPassManager* renderPass,
const SceneRenderState *diffuseState )
{
PROFILE_SCOPE(DualParaboloidLightShadowMap_render);
const ShadowMapParams *p = mLight->getExtended<ShadowMapParams>();
const LightMapParams *lmParams = mLight->getExtended<LightMapParams>();
const bool bUseLightmappedGeometry = lmParams ? !lmParams->representedInLightmap || lmParams->includeLightmappedGeometryInShadow : true;
const U32 texSize = getBestTexSize( 2 );
if ( mShadowMapTex.isNull() ||
mTexSize != texSize )
{
mTexSize = texSize;
mShadowMapTex.set( mTexSize * 2, mTexSize,
ShadowMapFormat, &ShadowMapProfile,
"DualParaboloidLightShadowMap" );
mShadowMapDepth = _getDepthTarget( mShadowMapTex->getWidth(), mShadowMapTex->getHeight() );
}
GFXFrustumSaver frustSaver;
GFXTransformSaver saver;
// Set and Clear target
GFX->pushActiveRenderTarget();
mTarget->attachTexture(GFXTextureTarget::Color0, mShadowMapTex);
mTarget->attachTexture( GFXTextureTarget::DepthStencil, mShadowMapDepth );
GFX->setActiveRenderTarget(mTarget);
GFX->clear(GFXClearTarget | GFXClearStencil | GFXClearZBuffer, ColorI::WHITE, 1.0f, 0);
const bool bUseSinglePassDPM = (p->shadowType == ShadowType_DualParaboloidSinglePass);
// Set up matrix and visible distance
mWorldToLightProj = mLight->getTransform();
mWorldToLightProj.inverse();
const F32 &lightRadius = mLight->getRange().x;
const F32 paraboloidNearPlane = 0.01f;
const F32 renderPosOffset = 0.01f;
// Alter for creation of scene state if this is a single pass map
if(bUseSinglePassDPM)
{
VectorF camDir;
MatrixF temp = mLight->getTransform();
temp.getColumn(1, &camDir);
temp.setPosition(mLight->getPosition() - camDir * (lightRadius + renderPosOffset));
temp.inverse();
GFX->setWorldMatrix(temp);
GFX->setOrtho(-lightRadius, lightRadius, -lightRadius, lightRadius, paraboloidNearPlane, 2.0f * lightRadius, true);
}
else
{
VectorF camDir;
MatrixF temp = mLight->getTransform();
temp.getColumn(1, &camDir);
temp.setPosition(mLight->getPosition() - camDir * renderPosOffset);
temp.inverse();
GFX->setWorldMatrix(temp);
GFX->setOrtho(-lightRadius, lightRadius, -lightRadius, lightRadius, paraboloidNearPlane, lightRadius, true);
}
SceneManager* sceneManager = diffuseState->getSceneManager();
// Front map render
{
SceneRenderState frontMapRenderState
(
sceneManager,
SPT_Shadow,
SceneCameraState::fromGFXWithViewport( diffuseState->getViewport() ),
renderPass
);
frontMapRenderState.getMaterialDelegate().bind( this, &LightShadowMap::getShadowMaterial );
frontMapRenderState.renderNonLightmappedMeshes( true );
frontMapRenderState.renderLightmappedMeshes( bUseLightmappedGeometry );
frontMapRenderState.setDiffuseCameraTransform( diffuseState->getCameraTransform() );
frontMapRenderState.setWorldToScreenScale( diffuseState->getWorldToScreenScale() );
if(bUseSinglePassDPM)
{
GFX->setWorldMatrix(mWorldToLightProj);
frontMapRenderState.getRenderPass()->getMatrixSet().setSceneView(mWorldToLightProj);
GFX->setOrtho(-lightRadius, lightRadius, -lightRadius, lightRadius, paraboloidNearPlane, lightRadius, true);
}
GFXDEBUGEVENT_SCOPE( DualParaboloidLightShadowMap_Render_FrontFacingParaboloid, ColorI::RED );
mShadowMapScale.set(0.5f, 1.0f);
mShadowMapOffset.set(-0.5f, 0.0f);
sceneManager->renderSceneNoLights( &frontMapRenderState, SHADOW_TYPEMASK );
_debugRender( &frontMapRenderState );
}
// Back map render
if(!bUseSinglePassDPM)
{
GFXDEBUGEVENT_SCOPE( DualParaboloidLightShadowMap_Render_BackFacingParaboloid, ColorI::RED );
mShadowMapScale.set(0.5f, 1.0f);
mShadowMapOffset.set(0.5f, 0.0f);
// Invert direction on camera matrix
VectorF right, forward;
MatrixF temp = mLight->getTransform();
temp.getColumn( 1, &forward );
temp.getColumn( 0, &right );
forward *= -1.0f;
right *= -1.0f;
temp.setColumn( 1, forward );
temp.setColumn( 0, right );
temp.setPosition(mLight->getPosition() - forward * -renderPosOffset);
temp.inverse();
GFX->setWorldMatrix(temp);
// Create an inverted scene state for the back-map
SceneRenderState backMapRenderState
(
sceneManager,
SPT_Shadow,
SceneCameraState::fromGFXWithViewport( diffuseState->getViewport() ),
renderPass
);
backMapRenderState.getMaterialDelegate().bind( this, &LightShadowMap::getShadowMaterial );
backMapRenderState.renderNonLightmappedMeshes( true );
backMapRenderState.renderLightmappedMeshes( bUseLightmappedGeometry );
backMapRenderState.setDiffuseCameraTransform( diffuseState->getCameraTransform() );
backMapRenderState.setWorldToScreenScale( diffuseState->getWorldToScreenScale() );
backMapRenderState.getRenderPass()->getMatrixSet().setSceneView(temp);
// Draw scene
sceneManager->renderSceneNoLights( &backMapRenderState );
_debugRender( &backMapRenderState );
}
mTarget->resolve();
GFX->popActiveRenderTarget();
}
