void VSimpleCopyPostprocess::Execute()
{
if (!IsActive() || !m_bIsInitialized)
return;
INSERT_PERF_MARKER_SCOPE("VSimpleCopyPostprocess");
RenderingOptimizationHelpers_cl::SetShaderPreference(112);
int iWidth, iHeight;
VisRenderContext_cl *pContext = VisRenderContext_cl::GetCurrentContext();
pContext->GetSize(iWidth, iHeight);
Vision::RenderLoopHelper.SetScissorRect(NULL);
Vision::RenderLoopHelper.ClearScreen();
// On DX9 a half pixel shift is required for the copy full screen pass.
#if defined(_VR_DX9)
const hkvVec2 texelShift(1.0f / (float)(iWidth*2), 1.0f / (float)(iHeight*2));
#else
const hkvVec2 texelShift(0.0f, 0.0f);
#endif
VSimpleRenderState_t iState(VIS_TRANSP_NONE,RENDERSTATEFLAG_FRONTFACE|RENDERSTATEFLAG_ALWAYSVISIBLE|RENDERSTATEFLAG_NOWIREFRAME|RENDERSTATEFLAG_NOMULTISAMPLING);
IVRender2DInterface *pRI = Vision::RenderLoopHelper.BeginOverlayRendering();
pRI->DrawTexturedQuad(hkvVec2(0.f,0.f), hkvVec2((float)iWidth, (float)iHeight), m_spSourceTextures[0], hkvVec2(0.0f) + texelShift, hkvVec2(1.0f) + texelShift, V_RGBA_WHITE, iState);
Vision::RenderLoopHelper.EndOverlayRendering();
}
int VMobileForwardRenderLoop::GetLightInfluenceArea(VisLightSource_cl *pLight)
{
VASSERT(pLight != NULL);
VisRenderContext_cl *pContext = VisRenderContext_cl::GetCurrentContext();
int iScreenWidth,iScreenHeight;
pContext->GetSize(iScreenWidth, iScreenHeight);
if (pLight->GetType() == VIS_LIGHT_DIRECTED)
{
// directional lights influence the whole screen
return (iScreenWidth*iScreenHeight);
}
hkvMat4 projMatrix = pContext->GetViewProperties()->getProjectionMatrix(hkvClipSpaceYRange::MinusOneToOne);
hkvMat4 viewMatrix = pContext->GetCamera()->GetWorldToCameraTransformation();
// get position/ radius of bounding sphere
hkvVec3 vPosition;
float fRadius = 0.0f;
if (pLight->GetType() == VIS_LIGHT_POINT)
{
vPosition = pLight->GetPosition();
fRadius = pLight->GetRadius();
}
else if (pLight->GetType() == VIS_LIGHT_SPOTLIGHT)
{
hkvAlignedBBox bBox;
pLight->GetBoundingBox(bBox);
vPosition = bBox.getBoundingSphere().m_vCenter;
fRadius = bBox.getBoundingSphere().m_fRadius;
}
else
VASSERT_MSG(false, "Unsupported light type");
// get corners of bounding rectangle in view space
hkvVec4 vPositionVS = viewMatrix*vPosition.getAsVec4(1.0f);
hkvVec4 vCorners[4];
vCorners[0] = vPositionVS+hkvVec4(-fRadius, -fRadius, 0.0f, 0.0f);
vCorners[1] = vPositionVS+hkvVec4(fRadius, -fRadius, 0.0f, 0.0f);
vCorners[2] = vPositionVS+hkvVec4(fRadius, fRadius, 0.0f, 0.0f);
vCorners[3] = vPositionVS+hkvVec4(-fRadius, fRadius, 0.0f, 0.0f);
// get corners of bounding rectangle in normalized device coordinates
for (int i=0;i<4;i++)
{
vCorners[i] = projMatrix*vCorners[i];
vCorners[i] /= vCorners[i].w;
}
// clip corners of bounding rectangle
hkvVec2 vMin(vCorners[0].x, vCorners[0].y);
vMin.clampTo(hkvVec2(-1.0f, -1.0f), hkvVec2(1.0f, 1.0f));
hkvVec2 vMax(vCorners[2].x, vCorners[2].y);
vMax.clampTo(hkvVec2(-1.0f, -1.0f), hkvVec2(1.0f, 1.0f));
// calculate influence area
int iWidth = (int)((vMax.x-vMin.x)*0.5f*iScreenWidth);
int iHeight = (int)((vMax.y-vMin.y)*0.5f*iScreenHeight);
return (iWidth*iHeight);
}
int VMobileForwardRenderLoop::GetLightPriority(VisLightSource_cl *pLight)
{
int iLightPriority = 0;
if (pLight->IsDynamic())
{
iLightPriority = GetLightInfluenceArea(pLight);
// lights with attached shadow map component have higher priority
if (GetCompatibleShadowMapComponent(pLight))
iLightPriority *= 2;
}
// static lights with attached shadow map component (subtractive shadows) have highest priority
else
{
VisRenderContext_cl *pContext = VisRenderContext_cl::GetCurrentContext();
int iScreenWidth,iScreenHeight;
pContext->GetSize(iScreenWidth, iScreenHeight);
iLightPriority = iScreenWidth*iScreenHeight*3;
}
return iLightPriority;
}
void VCoronaManager::RenderCorona (VCoronaCandidate& coronaCandidate, VTextureObject*& pTexture)
{
#ifdef SUPPORTS_CORONAS
VCoronaComponent *pCorona = coronaCandidate.m_pCorona;
VisRenderContext_cl* pContext = VisRenderContext_cl::GetCurrentContext();
VisLightSource_cl* pLight = (VisLightSource_cl*)pCorona->GetOwner();
hkvVec3 vLightPos(hkvNoInitialization);
pLight->GetVirtualPosition(vLightPos, pContext);
hkvVec3 vEyePos(hkvNoInitialization);
pContext->GetCamera()->GetPosition(vEyePos);
hkvVec3 vDir = pContext->GetCamera()->GetDirection();
// Corona texture
VTextureObject *pTex = pCorona->GetCoronaTexture();
if (pTex == NULL)
return;
if (pTexture != pTex)
{
pTexture = pTex;
Vision::RenderLoopHelper.BindMeshTexture(pTexture,0);
}
// Get light color
VColorRef color = pLight->GetColor();
hkvVec3 vDist = vLightPos - vEyePos;
float fEyeDist = vDir.dot(vDist);
//determine if camera is in light cone if the light is directional
float fDirectionalDampening = 1.0f;
if ( pLight->GetType() == VIS_LIGHT_SPOTLIGHT && pCorona->GetOnlyVisibleInSpotLight() )
{
fDirectionalDampening = 0.0f;
float fConeAngle = pLight->GetProjectionAngle();
float fConeLength = pLight->GetRadius();
hkvVec3 fConeDirection = pLight->GetDirection();
fConeDirection.normalize();
hkvVec3 vLightEyeDist = vEyePos - vLightPos;
//#2 check if the camera is inside the angle of the cone
float cosinusAngle = (vLightEyeDist/vLightEyeDist.getLength()).dot(fConeDirection);
float fDegree = hkvMath::acosDeg(cosinusAngle);
float normRadius = fDegree / (fConeAngle/2.0f);
if (normRadius < 1.0f)
{
//hardcoded falloff. For better performance, we avoid sampling the projection texture here.
const float fEpsilon = 64.0f/256.0f;
const float fQuadFactor = 1.0f/fEpsilon - 1.0f;
fDirectionalDampening = 1.0f / (1.0f + fQuadFactor*normRadius*normRadius);
// scale the function so that the value is exactly 0.0 at the edge and 1.0 in the center
fDirectionalDampening = (fDirectionalDampening - fEpsilon) / (1.0f - fEpsilon);
}
}
// Fog params
float fFogDampening = 1.0f;
if (pLight->GetType() != VIS_LIGHT_DIRECTED && Vision::World.IsLinearDepthFogEnabled())
{
const VFogParameters &fog = Vision::World.GetFogParameters();
float fFogStart = fog.fDepthStart;
float fFogEnd = fog.fDepthEnd;
float fFogFactor = (fFogEnd > fFogStart) ? ((fEyeDist - fFogStart) / (fFogEnd - fFogStart)) : 0.f;
fFogDampening = 1.0f - hkvMath::clamp(fFogFactor, 0.0f, 1.0f);
}
// Get corona rotation
float fRotation = 0.0f;
hkvVec4 vRotation(1.0f, 0.0f, 0.0f, 1.0f);
if (pCorona->CoronaFlags & VIS_CORONASCALE_ROTATING)
{
fRotation = hkvMath::mod (fEyeDist * 0.5f, 360.f);
vRotation.x = hkvMath::cosDeg (fRotation);
vRotation.y = -hkvMath::sinDeg (fRotation);
vRotation.z = -vRotation.y;
vRotation.w = vRotation.x;
}
// Texture dimensions
int iSizeX, iSizeY, depth;
pTex->GetTextureDimensions(iSizeX, iSizeY, depth);
hkvVec4 vScale(0.0f, 0.0f, 0.0f, 0.0f);
int iMainWidth, iMainHeight, iWidth, iHeight;
pContext->GetSize(iWidth, iHeight);
VisRenderContext_cl::GetMainRenderContext()->GetSize(iMainWidth, iMainHeight);
// Preserve texture aspect ratio
int iTexHeight = pTex->GetTextureHeight();
int iTexWidth = pTex->GetTextureWidth();
// Perspective scaling
// This scaling ensures roughly the same size on 720p as the old implementation.
vScale.z = iTexWidth * pCorona->CoronaScaling * 0.25f;
vScale.w = iTexHeight * pCorona->CoronaScaling * 0.25f;
// Screen-space scaling
// This scaling ensures roughly the same size on 720p as the old implementation.
const float fScaleFactor = pCorona->CoronaScaling * iMainHeight / 11.0f;
vScale.x = ((float)iTexWidth / 128.0f) * fScaleFactor * (float(iWidth) / float(iMainWidth));
vScale.y = ((float)iTexHeight / 128.0f) * fScaleFactor * (float(iHeight) / float(iMainHeight));
vScale.x *= 2.0f / iWidth;
vScale.y *= 2.0f / iHeight;
// Scale by visibility
if (pCorona->CoronaFlags & VIS_CORONASCALE_VISIBLEAREA)
{
vScale.x *= coronaCandidate.m_fCurrentVisibility;
vScale.y *= coronaCandidate.m_fCurrentVisibility;
vScale.z *= coronaCandidate.m_fCurrentVisibility;
vScale.w *= coronaCandidate.m_fCurrentVisibility;
}
VCompiledShaderPass* pShader = m_spCoronaTechnique->GetShader(0);
VShaderConstantBuffer *pVertexConstBuffer = pShader->GetConstantBuffer(VSS_VertexShader);
// xyz = worldspace position, w = 1.0 if VIS_CORONASCALE_DISTANCE is true, otherwise zero.
pVertexConstBuffer->SetSingleParameterF("coronaPosition", vLightPos.x, vLightPos.y, vLightPos.z, (pCorona->CoronaFlags & VIS_CORONASCALE_DISTANCE) ? 1.0f : 0.0f);
// xyz = light color, w = corona visibility.
pVertexConstBuffer->SetSingleParameterF("coronaColor", color.r/255.0f, color.g/255.0f, color.b/255.0f, coronaCandidate.m_fCurrentVisibility * fFogDampening * fDirectionalDampening);
// xyzw = 2x2 rotation matrix. float2x2 is not supported in shader model 2, so a float4 is used and multiplication is done manually in the shader.
pVertexConstBuffer->SetSingleParameterF("coronaRotation", vRotation.x, vRotation.y, vRotation.z, vRotation.w);
// xy = screen-space scaling. zw = view-space scaling.
pVertexConstBuffer->SetSingleParameterF("coronaScale", vScale.x, vScale.y, vScale.z, vScale.w);
Vision::RenderLoopHelper.RenderMeshes(pShader, VisMeshBuffer_cl::MB_PRIMTYPE_TRILIST, 0, 2, 6);
#endif
}
