void renderFakeSpotLights(Storm3D_Scene &scene, bool renderShadows)
{
GFX_TRACE_SCOPE("renderFakeSpotLights");
// Renders fake shadows to screen?
Storm3D_Camera &camera = *static_cast<Storm3D_Camera *> (scene.GetCamera());
Storm3D_ShaderManager::GetSingleton()->setFakeShadowShaders();
device.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO);
device.SetRenderState(D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR);
device.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device.SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
device.SetRenderState(D3DRS_ZWRITEENABLE,FALSE);
device.SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
device.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
device.SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
device.SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
device.SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device.SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
device.SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device.SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
frozenbyte::storm::enableMipFiltering(device, 0, 4, false);
FakeSpotList::iterator it = fakeSpots.begin();
for(; it != fakeSpots.end(); ++it)
{
Storm3D_FakeSpotlight *spot = it->get();
if(!spot || !spot->enabled())
continue;
const float *cameraView = camera.GetView4x4Matrix();
spot->applyTextures(cameraView);
renderer.render(IStorm3D_TerrainRendererBase::FakeSpotProjection, scene, 0, spot);
}
frozenbyte::storm::enableMipFiltering(device, 0, 4, true);
device.SetPixelShader(0);
device.SetVertexShader(0);
device.SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device.SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
device.SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device.SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
device.SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
Storm3D_ShaderManager::GetSingleton()->setNormalShaders();
device.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
device.SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
device.SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device.SetRenderState(D3DRS_CLIPPLANEENABLE, FALSE);
}
void update(int ms)
{
GFX_TRACE_SCOPE("Storm3D_ProceduralManager::update");
if(useFallback)
return;
GfxDevice &device = storm.GetD3DDevice();
if(active.empty() || !target)
return;
ProceduralEffect &e = effects[active];
e.animate(ms);
CComPtr<IDirect3DSurface9> renderSurface;
CComPtr<IDirect3DSurface9> originalSurface;
target->GetSurfaceLevel(0, &renderSurface);
if(!renderSurface)
return;
device.SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
device.SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device.SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
device.GetRenderTarget(0, &originalSurface);
device.SetRenderTarget(0, renderSurface);
//device.Clear(0, 0, D3DCLEAR_TARGET, 0xFFFFFFFF, 1, 0);
D3DSURFACE_DESC desc;
renderSurface->GetDesc(&desc);
render(e, float(desc.Width), float(desc.Height), false);
if(distortionMode && offsetTarget)
{
CComPtr<IDirect3DSurface9> renderSurface;
offsetTarget->GetSurfaceLevel(0, &renderSurface);
device.SetRenderTarget(0, renderSurface);
if(e.distortion1 && e.distortion2 && e.effect.enableDistortion)
{
render(e, float(desc.Width / 2), float(desc.Height / 2), true);
hasDistortion = true;
}
else
hasDistortion = false;
}
device.SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
device.SetRenderTarget(0, originalSurface);
target->GenerateMipSubLevels();
}
void renderSpotBuffers(Storm3D_Scene &scene, bool renderShadows)
{
GFX_TRACE_SCOPE("renderSpotBuffers");
device.SetRenderState(D3DRS_COLORWRITEENABLE, 0);
Storm3D_ShaderManager::GetSingleton()->setNormalShaders();
Storm3D_Camera &camera = *static_cast<Storm3D_Camera *> (scene.GetCamera());
Storm3D_Spotlight::clearCache();
if(renderShadows)
{
SpotList::iterator it = spots.begin();
for(; it != spots.end(); ++it)
{
Storm3D_Spotlight *spot = it->get();
if(!spot || !spot->enabled() || !spot->featureEnabled(IStorm3D_Spotlight::Shadows))
continue;
// Test spot visibility with foo scissor rect -- not really an optimal way of doing this
if(!spot->setScissorRect(camera, VC2I(100, 100), scene))
continue;
device.SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
const float *cameraView = camera.GetView4x4Matrix();
if(!spot->setAsRenderTarget(cameraView))
continue;
/* debug
static unsigned int count = 0;
count++;
device.Clear(0, NULL, D3DCLEAR_ZBUFFER, 0, float(count % 21) / 20.0f, 0);
*/
//glClearDepth(float(count % 11) / 10.0f);
//glClear(GL_DEPTH_BUFFER_BIT);
renderer.render(IStorm3D_TerrainRendererBase::SpotBuffer, scene, spot);
}
}
device.SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device.SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
Storm3D_ShaderManager::GetSingleton()->setNormalShaders();
device.SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
device.SetPixelShader(0);
camera.Apply();
}
void renderFakeSpotBuffers(Storm3D_Scene &scene, bool renderShadows)
{
GFX_TRACE_SCOPE("renderFakeSpotBuffers");
// Renders fake shadows to texture?
Storm3D_ShaderManager::GetSingleton()->setFakeDepthShaders();
Storm3D_Camera &camera = *static_cast<Storm3D_Camera *> (scene.GetCamera());
device.SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device.SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
//device.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
Storm3D_FakeSpotlight::clearCache();
bool rendered = false;
FakeSpotList::iterator it = fakeSpots.begin();
for(; it != fakeSpots.end(); ++it)
{
Storm3D_FakeSpotlight *spot = it->get();
if(!spot || !spot->enabled())
continue;
const float *cameraView = camera.GetView4x4Matrix();
if(!spot->setAsRenderTarget(cameraView))
continue;
renderer.render(IStorm3D_TerrainRendererBase::FakeSpotBuffer, scene, 0, spot);
rendered = true;
}
//if(rendered)
// Storm3D_FakeSpotlight::filterBuffers(storm, device);
device.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device.SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
device.SetPixelShader(0);
Storm3D_ShaderManager::GetSingleton()->setNormalShaders();
camera.Apply();
}
void Storm3D_TerrainLightManager::renderCones(Storm3D_Scene &scene, bool renderShadows, bool renderGlows)
{
GFX_TRACE_SCOPE("Storm3D_TerrainLightManager::renderCones");
float timeFactor = float(scene.time_dif) * 0.001f;
data->renderCones(scene, renderShadows, timeFactor, renderGlows);
}
void Storm3D_TerrainLightManager::renderFakeLights(const VC2I &renderSize)
{
GFX_TRACE_SCOPE("Storm3D_TerrainLightManager::renderFakeLights");
data->renderFakeLights(renderSize);
}
void Storm3D_TerrainLightManager::renderProjectedLightsAlpha(Storm3D_Scene &scene, bool renderShadows)
{
GFX_TRACE_SCOPE("Storm3D_TerrainLightManager::renderProjectedLightsAlpha");
data->renderLights(Data::RealAlpha, scene, renderShadows);
}
void Storm3D_TerrainLightManager::renderProjectedFakeLights(Storm3D_Scene &scene, bool renderShadows)
{
GFX_TRACE_SCOPE("Storm3D_TerrainLightManager::renderProjectedFakeLights");
data->renderLights(Data::Fake, scene, renderShadows);
}
void Storm3D_TerrainLightManager::renderProjectedRenderTargets(Storm3D_Scene &scene, bool renderShadows, bool renderFakeBuffers)
{
GFX_TRACE_SCOPE("Storm3D_TerrainLightManager::renderProjectedRenderTargets");
data->renderBuffers(scene, renderShadows, renderFakeBuffers);
}
void renderSpotLights(Storm3D_Scene &scene, bool renderShadows, LightType type)
{
GFX_TRACE_SCOPE("renderSpotLights");
// this renders spotlight light & shadows
//setTracing(true);
Storm3D_ShaderManager::GetSingleton()->setProjectedShaders();
device.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
device.SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
device.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device.SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
device.SetRenderState(D3DRS_ALPHAREF, 0x1);
device.SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
for(int i = 0; i < 4; ++i)
{
if(i != 2)
{
device.SetSamplerState(i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device.SetSamplerState(i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
}
}
Storm3D_Camera &camera = *static_cast<Storm3D_Camera *> (scene.GetCamera());
SpotList::iterator it = spots.begin();
for(; it != spots.end(); ++it)
{
Storm3D_Spotlight *spot = it->get();
if(!spot || !spot->enabled())
continue;
// Test spot visibility with foo scissor rect -- not really an optimal way of doing this
if(!spot->setScissorRect(camera, VC2I(100, 100), scene))
continue;
device.SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
if(!false)
{
device.SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
device.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED);
device.SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
}
const float *cameraView = camera.GetView4x4Matrix();
const float *cameraViewProjection = camera.GetViewProjection4x4Matrix();
spot->applyTextures(cameraView, cameraViewProjection, storm, renderShadows);
if(type == RealSolid)
renderer.render(IStorm3D_TerrainRendererBase::SpotProjectionSolid, scene, spot);
else
{
renderer.render(IStorm3D_TerrainRendererBase::SpotProjectionDecal, scene, spot);
renderer.render(IStorm3D_TerrainRendererBase::SpotProjectionAlpha, scene, spot);
}
}
Storm3D_ShaderManager::GetSingleton()->setNormalShaders();
for(int i = 0; i < 4; ++i)
{
device.SetSamplerState(i, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device.SetSamplerState(i, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
}
//setTracing(false);
device.SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
device.SetTexture(1, 0);
device.SetTexture(2, 0);
device.SetTexture(3, 0);
device.SetTexture(4, 0);
device.SetPixelShader(0);
device.SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device.SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
device.SetRenderState(D3DRS_CLIPPLANEENABLE, FALSE);
}
void render(const ProceduralEffect &e, float width, float height, bool offsetTarget)
{
GFX_TRACE_SCOPE("Storm3D_ProceduralManager::render");
GfxDevice& device = storm.GetD3DDevice();
if(e.texture1)
e.texture1->Apply(1);
if(e.texture2)
e.texture2->Apply(3);
if(offsetTarget)
{
if(e.distortion1)
e.distortion1->Apply(0);
if(e.distortion2)
e.distortion2->Apply(2);
if(!e.distortion1 || !e.distortion2 || !e.effect.enableDistortion)
return;
}
else
{
if(e.offset1)
e.offset1->Apply(0);
if(e.offset2)
e.offset2->Apply(2);
}
assert(vshader && pshader);
vshader->apply();
float constants[8 * 4];
const TexCoord &c1 = (offsetTarget) ? e.displaceCoord1 : e.coord1;
const TexCoord &c2 = (offsetTarget) ? e.displaceCoord2 : e.coord2;
constants[0 + 0] = c1.offsetFactor.x;
constants[0 + 1] = c1.offsetFactor.y;
constants[4 + 0] = c1.offsetOffset.x;
constants[4 + 1] = c1.offsetOffset.y;
constants[8 + 0] = c1.baseFactor.x;
constants[8 + 1] = c1.baseFactor.y;
constants[12 + 0] = c1.baseOffset.x;
constants[12 + 1] = c1.baseOffset.y;
constants[16 + 0] = c2.offsetFactor.x;
constants[16 + 1] = c2.offsetFactor.y;
constants[20 + 0] = c2.offsetOffset.x;
constants[20 + 1] = c2.offsetOffset.y;
constants[24 + 0] = c2.baseFactor.x;
constants[24 + 1] = c2.baseFactor.y;
constants[28 + 0] = c2.baseOffset.x;
constants[28 + 1] = c2.baseOffset.y;
device.SetVertexShaderConstantF(0, constants, 8);
float scale1 = (offsetTarget) ? e.effect.distortion1.offset.scale.x : e.effect.source1.offset.scale.x;
float scale2 = (offsetTarget) ? e.effect.distortion2.offset.scale.x : e.effect.source2.offset.scale.x;
device.SetTextureStageState(1, D3DTSS_BUMPENVMAT00, F2DW(scale1));
device.SetTextureStageState(1, D3DTSS_BUMPENVMAT01, F2DW(0.f));
device.SetTextureStageState(1, D3DTSS_BUMPENVMAT10, F2DW(0.f));
device.SetTextureStageState(1, D3DTSS_BUMPENVMAT11, F2DW(scale1));
device.SetTextureStageState(3, D3DTSS_BUMPENVMAT00, F2DW(scale2));
device.SetTextureStageState(3, D3DTSS_BUMPENVMAT01, F2DW(0.f));
device.SetTextureStageState(3, D3DTSS_BUMPENVMAT10, F2DW(0.f));
device.SetTextureStageState(3, D3DTSS_BUMPENVMAT11, F2DW(scale2));
if(offsetTarget)
{
float scale = (scale1 + scale2) * .25f;
float c2[4] = { scale, scale, scale, scale };
device.SetPixelShaderConstantF(2, c2, 1);
poffsetShader->apply();
}
else
{
pshader->apply();
}
vbuffer->apply(device, 0);
ibuffer->render(device, 2, 4, 0);
device.SetPixelShader(0);
}
