//*************************************************************************************************************
void Render(float alpha, float elapsedtime)
{
D3DXMATRIX world, view, proj;
D3DXMATRIX skyworld, viewproj;
D3DXVECTOR3 eye(0, 0, -5);
D3DXVECTOR3 look(0, 0, 0);
D3DXVECTOR3 up(0, 1, 0);
D3DXVECTOR2 orient = cameraangle.smooth(alpha);
D3DXMatrixRotationYawPitchRoll(&view, orient.x, orient.y, 0);
D3DXVec3TransformCoord(&eye, &eye, &view);
D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 4, (float)screenwidth / (float)screenheight, 0.1f, 50);
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixMultiply(&viewproj, &view, &proj);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
device->SetTransform(D3DTS_VIEW, &view);
device->SetTransform(D3DTS_PROJECTION, &proj);
for( int i = 0; i < NUM_DWARFS; ++i )
dwarfs[i].Update(elapsedtime, &dwarfmatrices[i]);
effect->SetMatrix("matViewProj", &viewproj);
if( SUCCEEDED(device->BeginScene()) )
{
// render sky
device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
D3DXMatrixScaling(&skyworld, 20, 20, 20);
skyeffect->SetMatrix("matWorld", &skyworld);
D3DXMatrixIdentity(&skyworld);
skyeffect->SetMatrix("matWorldSky", &skyworld);
skyeffect->SetMatrix("matViewProj", &viewproj);
skyeffect->SetVector("eyePos", (D3DXVECTOR4*)&eye);
skyeffect->Begin(0, 0);
skyeffect->BeginPass(0);
{
device->SetTexture(0, skytex);
skymesh->DrawSubset(0);
}
skyeffect->EndPass();
skyeffect->End();
device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
// render ground
D3DXMatrixScaling(&world, 5, 0.1f, 5);
world._42 = -0.05f;
device->SetTransform(D3DTS_WORLD, &world);
device->SetTexture(0, texture2);
mesh->DrawSubset(0);
// dwarfs
for( int i = 0; i < NUM_DWARFS; ++i )
dwarfs[i].Draw();
// fire
D3DXMatrixTranslation(&world, 0, 0.25f, 0);
device->SetTransform(D3DTS_WORLD, &world);
system1.Draw(world, view);
// render text
device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
device->SetTexture(0, text);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, textvertices, 6 * sizeof(float));
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->EndScene();
}
device->Present(NULL, NULL, NULL, NULL);
}
//*************************************************************************************************************
void Render(float alpha, float elapsedtime)
{
static float time = 0;
D3DXMATRIX view, proj, vp;
D3DXMATRIX world;
D3DXMATRIX inv;
D3DXVECTOR4 amblight(0.2f, 0.2f, 0.2f, 1);
D3DXVECTOR4 intensity(0.8f, 0.8f, 0.8f, 1);
D3DXVECTOR4 zero(0, 0, 0, 1);
D3DXVECTOR3 lightpos(0, 0, -10);
D3DXVECTOR3 eye(0, 0, -5.2f);
D3DXVECTOR3 look(0, 0.5f, 0);
D3DXVECTOR3 up(0, 1, 0);
D3DXVECTOR3 p1, p2;
D3DXVECTOR2 orient = cameraangle.smooth(alpha);
D3DXVECTOR2 light = lightangle.smooth(alpha);
time += elapsedtime;
// setup light
D3DXMatrixRotationYawPitchRoll(&view, light.x, light.y, 0);
D3DXVec3TransformCoord(&lightpos, &lightpos, &view);
// TODO: no need to calculate every frame
for( int i = 0; i < NUM_OBJECTS; ++i )
{
FindSilhouette(objects[i], (D3DXVECTOR3&)lightpos);
ExtrudeSilhouette(objects[i], (D3DXVECTOR3&)lightpos);
}
// setup camera
D3DXMatrixRotationYawPitchRoll(&view, orient.x, orient.y, 0);
D3DXVec3TransformCoord(&eye, &eye, &view);
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 4, (float)screenwidth / (float)screenheight, 0.1f, 20);
// put far plane to infinity
proj._33 = 1;
proj._43 = -0.1f;
D3DXMatrixMultiply(&vp, &view, &proj);
D3DXMatrixScaling(&world, 5, 0.1f, 5);
// specular effect uniforms
specular->SetMatrix("matViewProj", &vp);
specular->SetVector("eyePos", (D3DXVECTOR4*)&eye);
specular->SetVector("lightPos", (D3DXVECTOR4*)&lightpos);
specular->SetVector("ambient", &zero); // it's a f**k-up
specular->SetVector("lightColor", &intensity); // lazy to tonemap
ambient->SetMatrix("matViewProj", &vp);
ambient->SetVector("ambient", &amblight);
if( SUCCEEDED(device->BeginScene()) )
{
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0xff6694ed, 1.0f, 0);
// STEP 1: z pass
ambient->SetTechnique("ambientlight");
ambient->SetMatrix("matViewProj", &vp);
DrawScene(ambient);
// STEP 2: draw shadow with depth fail method
device->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
device->SetRenderState(D3DRS_STENCILENABLE, TRUE);
device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
device->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
device->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_INCR);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
extrude->SetTechnique("extrude");
extrude->SetMatrix("matViewProj", &vp);
extrude->Begin(0, 0);
extrude->BeginPass(0);
{
for( int i = 0; i < NUM_OBJECTS; ++i )
DrawShadowVolume(objects[i]);
device->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
for( int i = 0; i < NUM_OBJECTS; ++i )
DrawShadowVolume(objects[i]);
}
extrude->EndPass();
extrude->End();
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_ALPHA);
// STEP 3: multipass lighting
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_GREATER);
device->SetRenderState(D3DRS_STENCILREF, 1);
DrawScene(specular);
device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
if( drawsilhouette )
{
amblight = D3DXVECTOR4(1, 1, 0, 0.5f);
// reuse whatever we can...
extrude->SetVector("ambient", &amblight);
extrude->Begin(0, 0);
extrude->BeginPass(0);
device->SetVertexDeclaration(shadowdecl);
for( int i = 0; i < NUM_OBJECTS; ++i )
{
const ShadowCaster& caster = objects[i];
D3DXVECTOR4* verts = (D3DXVECTOR4*)malloc(caster.silhouette.size() * 2 * sizeof(D3DXVECTOR4));
for( size_t j = 0; j < caster.silhouette.size(); ++j )
{
const Edge& e = caster.silhouette[j];
verts[j * 2 + 0] = D3DXVECTOR4(e.v1, 1);
verts[j * 2 + 1] = D3DXVECTOR4(e.v2, 1);
}
extrude->SetMatrix("matWorld", &caster.world);
extrude->CommitChanges();
device->DrawPrimitiveUP(D3DPT_LINELIST, caster.silhouette.size(), verts, sizeof(D3DXVECTOR4));
free(verts);
}
extrude->EndPass();
extrude->End();
extrude->SetVector("ambient", &zero);
}
if( drawvolume )
{
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
amblight = D3DXVECTOR4(1, 1, 0, 0.5f);
extrude->SetVector("ambient", &amblight);
extrude->Begin(0, 0);
extrude->BeginPass(0);
for( int i = 0; i < NUM_OBJECTS; ++i )
DrawShadowVolume(objects[i]);
extrude->EndPass();
extrude->End();
extrude->SetVector("ambient", &zero);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}
// render text
device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
device->SetTexture(0, text);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, textvertices, 6 * sizeof(float));
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->SetTexture(0, 0);
device->EndScene();
}
device->Present(NULL, NULL, NULL, NULL);
}
void Render(float alpha, float elapsedtime)
{
static float time = 0;
LPDIRECT3DSURFACE9 backbuffer = 0;
D3DXMATRIX view, proj, viewproj;
D3DXMATRIX world, inv;
D3DXVECTOR4 texelsize;
D3DXVECTOR4 lightpos(-600, 350, 1000, 1);
D3DXVECTOR4 refllight;
D3DXVECTOR3 eye(0, 0, -5.0f);
D3DXVECTOR3 look(0, 1.2f, 0);
D3DXVECTOR3 refleye, refllook;
D3DXVECTOR3 up(0, 1, 0);
D3DXVECTOR2 orient = cameraangle.smooth(alpha);
D3DXMatrixRotationYawPitchRoll(&view, orient.x, orient.y, 0);
D3DXVec3TransformCoord(&eye, &eye, &view);
eye.y += 1.2f;
D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 2, (float)screenwidth / (float)screenheight, 0.1f, 30);
time += elapsedtime;
if( SUCCEEDED(device->BeginScene()) )
{
device->GetRenderTarget(0, &backbuffer);
// STEP 1: render reflection texture
device->SetRenderTarget(0, reflectsurf);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
D3DXPLANE plane(0, 1, 0, 1);
refleye = eye - 2 * D3DXPlaneDotCoord(&plane, &eye) * (D3DXVECTOR3&)plane;
refllook = look - 2 * D3DXPlaneDotCoord(&plane, &look) * (D3DXVECTOR3&)plane;
refllight = lightpos - 2 * D3DXPlaneDot(&plane, &lightpos) * (D3DXVECTOR4&)plane;
refllight.w = 1;
D3DXMatrixLookAtLH(&view, &refleye, &refllook, &up);
D3DXMatrixMultiply(&viewproj, &view, &proj);
D3DXMatrixInverse(&inv, 0, &viewproj);
D3DXMatrixTranspose(&inv, &inv);
D3DXPlaneTransform(&plane, &plane, &inv);
device->SetClipPlane(0, &plane.a);
RenderScene(viewproj, refleye, refllight, true);
// STEP 2: render scene (later used for refraction)
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixMultiply(&viewproj, &view, &proj);
device->SetRenderTarget(0, refractsurf);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
RenderScene(viewproj, eye, lightpos, false);
// render water surface into alpha channel for masking
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA);
D3DXMatrixTranslation(&world, 0, -1, 0);
device->SetTransform(D3DTS_WORLD, &world);
device->SetTransform(D3DTS_VIEW, &view);
device->SetTransform(D3DTS_PROJECTION, &proj);
waterplane->DrawSubset(0, DXObject::Opaque);
device->SetRenderState(D3DRS_COLORWRITEENABLE, 0x0f);
// STEP 3: light shafts
quadvertices[6] = quadvertices[24] = quadvertices[30] = (float)screenwidth - 0.5f;
quadvertices[13] = quadvertices[19] = quadvertices[31] = (float)screenheight - 0.5f;
RenderLightShafts(view, proj, eye, lightpos);
// STEP 4: gamma correct
device->SetRenderTarget(0, sceneldrsurf);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetVertexDeclaration(quaddecl);
bloom->SetTechnique("gammacorrect");
bloom->Begin(0, 0);
bloom->BeginPass(0);
{
device->SetTexture(0, refraction);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, quadvertices, 6 * sizeof(float));
}
bloom->EndPass();
bloom->End();
device->SetRenderState(D3DRS_ZENABLE, TRUE);
// STEP 5: water surface
device->SetRenderState(D3DRS_SRGBWRITEENABLE, TRUE);
D3DXMatrixTranslation(&world, 0, -1, 0);
D3DXMatrixIdentity(&inv);
water->SetMatrix("matViewProj", &viewproj);
water->SetMatrix("matWorld", &world);
water->SetMatrix("matWorldInv", &inv);
water->SetVector("eyePos", (D3DXVECTOR4*)&eye);
water->SetVector("lightPos", &lightpos);
water->SetVector("lightColor", &lightcolor);
water->SetFloat("time", time);
water->Begin(0, 0);
water->BeginPass(0);
{
device->SetTexture(0, refraction);
device->SetTexture(1, reflection);
device->SetTexture(2, waves);
waterplane->DrawSubset(0, DXObject::Opaque);
}
water->EndPass();
water->End();
device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
// STEP 6: downsample & blur
quadvertices[6] = quadvertices[24] = quadvertices[30] = (float)screenwidth * 0.5f - 0.5f;
quadvertices[13] = quadvertices[19] = quadvertices[31] = (float)screenheight * 0.5f - 0.5f;
device->SetRenderTarget(0, bloomsurf1);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetVertexDeclaration(quaddecl);
texelsize.x = 1.0f / screenwidth;
texelsize.y = 1.0f / screenheight;
bloom->SetTechnique("downsample");
bloom->SetVector("texelSize", &texelsize);
bloom->Begin(0, 0);
bloom->BeginPass(0);
{
device->SetTexture(0, sceneldr);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, quadvertices, 6 * sizeof(float));
}
bloom->EndPass();
bloom->End();
device->SetRenderTarget(0, bloomsurf2);
texelsize.x = 2.0f / screenwidth;
texelsize.y = 2.0f / screenheight;
bloom->SetTechnique("blur");
bloom->SetVector("texelSize", &texelsize);
bloom->Begin(0, 0);
bloom->BeginPass(0);
{
device->SetTexture(0, bloomtex1);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, quadvertices, 6 * sizeof(float));
}
bloom->EndPass();
bloom->End();
// STEP 7: add light shafts
quadvertices[6] = quadvertices[24] = quadvertices[30] = (float)screenwidth - 0.5f;
quadvertices[13] = quadvertices[19] = quadvertices[31] = (float)screenheight - 0.5f;
device->SetRenderTarget(0, backbuffer);
godray->SetTechnique("final");
godray->Begin(0, 0);
godray->BeginPass(0);
{
device->SetTexture(0, sceneldr);
device->SetTexture(1, occluders);
device->SetTexture(2, bloomtex2);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, quadvertices, 6 * sizeof(float));
}
godray->EndPass();
godray->End();
backbuffer->Release();
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->EndScene();
}
device->Present(NULL, NULL, NULL, NULL);
}
//*************************************************************************************************************
void Render(float alpha, float elapsedtime)
{
D3DXMATRIX view, proj;
D3DXMATRIX inv, vp, tmp;
D3DXMATRIX lightview, lightproj, lightvp;
D3DXVECTOR2 orient = cameraangle.smooth(alpha);
D3DXVECTOR4 lightpos(0, 0, -5, 0);
D3DXVECTOR3 look(0, 0.5f, 0), up(0, 1, 0);
D3DXVECTOR3 eye(0, 0, -5.2f);
D3DXVECTOR4 clipplanes(0, 0, 0, 0);
D3DXVECTOR4 texelsize(1.0f / SHADOWMAP_SIZE, 1.0f / SHADOWMAP_SIZE, 0, 0);
// setup camera
D3DXMatrixRotationYawPitchRoll(&tmp, orient.x, orient.y, 0);
D3DXVec3TransformCoord(&eye, &eye, &tmp);
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 4, (float)screenwidth / (float)screenheight, 0.1f, 20);
D3DXMatrixMultiply(&vp, &view, &proj);
// setup light
orient = lightangle.smooth(alpha);
look = D3DXVECTOR3(0, 0, 0);
D3DXMatrixRotationYawPitchRoll(&tmp, orient.x, orient.y, 0);
D3DXVec4Transform(&lightpos, &lightpos, &tmp);
D3DXMatrixLookAtLH(&lightview, (D3DXVECTOR3*)&lightpos, &look, &up);
DXFitToBox(lightproj, clipplanes, lightview, scenebb);
D3DXMatrixMultiply(&lightvp, &lightview, &lightproj);
if( SUCCEEDED(device->BeginScene()) )
{
switch( shadowtech )
{
case 0:
RenderWithPCF(vp, eye, lightview, lightproj, lightpos, clipplanes, D3DXVECTOR4(0, 0, 0, 0));
break;
case 1:
RenderWithPCF(vp, eye, lightview, lightproj, lightpos, clipplanes, texelsize);
break;
case 2:
RenderWithIrregularPCF(vp, eye, lightview, lightproj, lightpos, clipplanes, texelsize);
break;
case 3:
RenderWithVariance(vp, eye, lightview, lightproj, lightpos, clipplanes);
break;
case 4:
RenderWithConvolution(vp, eye, lightview, lightproj, lightpos, clipplanes);
break;
case 5:
RenderWithExponential(vp, eye, lightview, lightproj, lightpos, clipplanes);
break;
case 6:
RenderWithExponentialVariance(vp, eye, lightview, lightproj, lightpos, clipplanes);
break;
case 7:
RenderWithPCSS(vp, eye, lightview, lightproj, lightpos, clipplanes, texelsize);
break;
default:
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
break;
}
// render text
device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
device->SetTexture(0, text);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, textvertices, 6 * sizeof(float));
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->EndScene();
}
device->Present(NULL, NULL, NULL, NULL);
}
//*************************************************************************************************************
void Render(float alpha, float elapsedtime)
{
LPDIRECT3DSURFACE9 oldtarget = NULL;
D3DXMATRIX vp, inv, tmp1, tmp2;
D3DXVECTOR3 axis(0, 1, 0);
D3DXVECTOR3 eye(0, 0, -5);
D3DXVECTOR3 look(0, 0, 0);
D3DXVECTOR3 up(0, 1, 0);
D3DXVECTOR2 cangle = cameraangle.smooth(alpha);
D3DXVECTOR2 oangle = objectangle.smooth(alpha);
float expo = exposure.smooth(alpha);
D3DXMatrixRotationYawPitchRoll(&world, cangle.x, cangle.y, 0);
D3DXVec3TransformCoord(&eye, &eye, &world);
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixMultiply(&vp, &view, &proj);
D3DXMatrixInverse(&inv, NULL, &view);
memcpy(&eye, inv.m[3], 3 * sizeof(float));
if( mesh == mesh1 )
{
// skullocc
D3DXMatrixScaling(&world, 0.4f, 0.4f, 0.4f);
world._42 = -1.5f;
}
else if( mesh == mesh2 )
{
// knot
D3DXMatrixScaling(&world, 0.8f, 0.8f, 0.8f);
}
else
{
// teapot
D3DXMatrixScaling(&world, 1.5f, 1.5f, 1.5f);
}
D3DXMatrixRotationYawPitchRoll(&tmp1, oangle.x, oangle.y, 0);
D3DXMatrixMultiply(&world, &world, &tmp1);
D3DXMatrixInverse(&inv, NULL, &world);
fresnel->SetVector("eyePos", (D3DXVECTOR4*)&eye);
fresnel->SetMatrix("matWorld", &world);
fresnel->SetMatrix("matWorldInv", &inv);
fresnel->SetMatrix("matViewProj", &vp);
D3DXMatrixScaling(&world, 20, 20, 20);
skyeffect->SetMatrix("matWorld", &world);
D3DXMatrixIdentity(&world);
skyeffect->SetMatrix("matWorldSky", &world);
skyeffect->SetMatrix("matViewProj", &vp);
memcpy(tmpvert, quadvertices, 36 * sizeof(float));
if( SUCCEEDED(device->BeginScene()) )
{
device->SetRenderState(D3DRS_SRGBWRITEENABLE, false);
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
// STEP 1: render sky
device->GetRenderTarget(0, &oldtarget);
if( firstframe )
{
device->SetRenderTarget(0, aftersurfaces[0]);
device->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
device->SetRenderTarget(0, aftersurfaces[1]);
device->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
device->SetRenderTarget(0, avglumsurfaces[4]);
device->Clear(0, NULL, D3DCLEAR_TARGET, 0x11111111, 1.0f, 0);
device->SetRenderTarget(0, avglumsurfaces[5]);
device->Clear(0, NULL, D3DCLEAR_TARGET, 0x11111111, 1.0f, 0);
firstframe = false;
}
device->SetRenderTarget(0, scenesurface);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetTexture(0, skytexture);
skyeffect->Begin(NULL, 0);
skyeffect->BeginPass(0);
{
skymesh->DrawSubset(0);
}
skyeffect->EndPass();
skyeffect->End();
device->SetRenderState(D3DRS_ZENABLE, TRUE);
// STEP 2: render object
device->SetTexture(0, texture);
device->SetTexture(1, fresneltexture);
device->SetTexture(2, skytexture);
device->SetTexture(3, roughspecular);
fresnel->Begin(NULL, 0);
fresnel->BeginPass(0);
{
mesh->DrawSubset(0);
}
fresnel->EndPass();
fresnel->End();
device->SetVertexDeclaration(vertexdecl);
// STEP 3: measure average luminance
MeasureLuminance();
// STEP 4: adapt luminance to eye
AdaptLuminance(elapsedtime);
// STEP 5: bright pass
BrightPass();
// STEP 6: downsample bright pass texture
DownSample();
// STEP 7: blur downsampled textures
Blur();
// STEP 8: ghost
LensFlare();
// STEP 9: star
Star();
// STEP 10: final combine
hdreffect->SetTechnique("final");
hdreffect->SetFloat("targetluminance", targetluminance);
device->SetRenderTarget(0, oldtarget);
device->SetTexture(0, scenetarget); // scene
device->SetTexture(1, blurtargets[0]); // blur
device->SetTexture(2, blurtargets[1]); // star
device->SetTexture(3, ghosttargets[0]); // ghost
device->SetTexture(4, afterimages[1 - afterimagetex]);
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
device->SetRenderState(D3DRS_SRGBWRITEENABLE, true);
oldtarget->Release();
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, quadvertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->End();
if( drawhelp )
{
// render text
device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
device->SetTexture(0, text);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, textvertices, 6 * sizeof(float));
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
}
// clean up
device->SetTexture(1, NULL);
device->SetTexture(2, NULL);
device->SetTexture(3, NULL);
device->SetTexture(4, NULL);
device->SetTexture(5, NULL);
device->EndScene();
}
device->Present(NULL, NULL, NULL, NULL);
}
