void RSManager::DoLimbo()
{
if (!(mainRT && zSurf && doLimbo && limbo)) return;
IDirect3DSurface9 *oldRenderTarget;
d3ddev->GetRenderTarget(0, &oldRenderTarget);
if (oldRenderTarget == mainRT) {
// final renderbuffer has to be from texture, just making sure here
if (IDirect3DTexture9* tex = getSurfTexture(oldRenderTarget)) {
// check size just to make even more sure
D3DSURFACE_DESC desc;
oldRenderTarget->GetDesc(&desc);
if (desc.Width == Settings::get().getRenderWidth() && desc.Height == Settings::get().getRenderHeight()) {
IDirect3DTexture9 *zTex = getSurfTexture(zSurf);
storeRenderState();
d3ddev->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
d3ddev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
d3ddev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
/// Draw zbuffer
limbo->go(zTex, oldRenderTarget, limboZNear, limboZFar);
SDLOG(0, "ZNear: %g, ZFar: %g\n", limboZNear, limboZFar);
//d3ddev->StretchRect(zSurf, NULL, oldRenderTarget, NULL, D3DTEXF_NONE);
restoreRenderState();
zTex->Release();
}
tex->Release();
}
}
oldRenderTarget->Release();
}
HRESULT RSManager::redirectSetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) {
nrts++;
//if(RenderTargetIndex==0) lastReplacement = -1;
//SurfSurfMap::iterator it = renderTexSurfTargets.find(pRenderTarget);
//if(it != renderTexSurfTargets.end()) {
// SDLOG(1, "Redirected SetRenderTarget(%d, %p) to %p\n", RenderTargetIndex, pRenderTarget, it->second);
// if(capturing) dumpSurface("redirectRenderTarget", it->second);
// lastReplacement = renderTexSurfIndices[pRenderTarget];
// return d3ddev->SetRenderTarget(RenderTargetIndex, it->second);
//}
//if(capturing && hudStarted) {
// //SurfIntMap::iterator it = renderTexSurfIndices.find(pRenderTarget);
// //if(it != renderTexSurfIndices.end()) {
// dumpSurface("hudTarget", pRenderTarget);
// capturing = false;
// //}
//}
// determine where we are rendering to
//{
// SurfIntMap::iterator it = mainRenderSurfIndices.find(pRenderTarget);
// if(it != mainRenderSurfIndices.end()) {
// SDLOG(4, " - rendersurface #%d\n", it->second);
// } else {
// if(IDirect3DTexture9* tex = getSurfTexture(pRenderTarget)) {
// TexIntMap::iterator it = mainRenderTexIndices.find(tex);
// if(it != mainRenderTexIndices.end()) {
// SDLOG(4, " - rendertexture #%d\n", it->second);
// }
// tex->Release();
// } else {
// IDirect3DSurface9* backBuffer;
// d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &backBuffer);
// if(pRenderTarget == backBuffer) {
// SDLOG(4, " - backbuffer\n");
// }
// backBuffer->Release();
// }
// }
//}
if(capturing) {
IDirect3DSurface9 *oldRenderTarget, *depthStencilSurface;
d3ddev->GetRenderTarget(0, &oldRenderTarget);
d3ddev->GetDepthStencilSurface(&depthStencilSurface);
char buffer[64];
sprintf(buffer, "%03d_oldRenderTarget_%p_.tga", nrts, oldRenderTarget);
SDLOG(0, "Capturing surface %p as %s\n", oldRenderTarget, buffer);
D3DXSaveSurfaceToFile(buffer, D3DXIFF_TGA, oldRenderTarget, NULL, NULL);
if(depthStencilSurface) {
sprintf(buffer, "%03d_oldRenderTargetDepth_%p_.tga", nrts, oldRenderTarget);
SDLOG(0, "Capturing depth surface %p as %s\n", depthStencilSurface, buffer);
D3DXSaveSurfaceToFile(buffer, D3DXIFF_TGA, depthStencilSurface, NULL, NULL);
}
SAFERELEASE(oldRenderTarget);
SAFERELEASE(depthStencilSurface);
}
if(nrts == 1) { // we are switching to the RT that will be the main rendering target for this frame
// store it for later use
mainRT = pRenderTarget;
SDLOG(0, "Storing RT as main RT: %p\n", mainRT);
}
if(nrts == 11) { // we are switching to the RT used to store the Z value in the 24 RGB bits (among other things)
// lets store it for later use
zSurf = pRenderTarget;
SDLOG(0, "Storing RT as Z buffer RT: %p\n", zSurf);
}
if(mainRT && pRenderTarget == mainRT) {
SDLOG(0, "MainRT uses: %d + 1\n", mainRTuses);
++mainRTuses;
}
// we are switching away from the initial 3D-rendered image, do AA and SSAO
if(mainRTuses == 2 && mainRT && zSurf && ((ssao && doSsao) || (doAA && (smaa || fxaa)))) {
IDirect3DSurface9 *oldRenderTarget;
d3ddev->GetRenderTarget(0, &oldRenderTarget);
if(oldRenderTarget == mainRT) {
// final renderbuffer has to be from texture, just making sure here
if(IDirect3DTexture9* tex = getSurfTexture(oldRenderTarget)) {
// check size just to make even more sure
D3DSURFACE_DESC desc;
oldRenderTarget->GetDesc(&desc);
if(desc.Width == Settings::get().getRenderWidth() && desc.Height == Settings::get().getRenderHeight()) {
IDirect3DTexture9 *zTex = getSurfTexture(zSurf);
//if(takeScreenshot) D3DXSaveTextureToFile("0effect_pre.bmp", D3DXIFF_BMP, tex, NULL);
//if(takeScreenshot) D3DXSaveTextureToFile("0effect_z.bmp", D3DXIFF_BMP, zTex, NULL);
storeRenderState();
d3ddev->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
d3ddev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
d3ddev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
// perform AA processing
if(!lowFPSmode && doAA && (smaa || fxaa)) {
if(smaa) smaa->go(tex, tex, rgbaBuffer1Surf, SMAA::INPUT_COLOR);
else fxaa->go(tex, rgbaBuffer1Surf);
d3ddev->StretchRect(rgbaBuffer1Surf, NULL, oldRenderTarget, NULL, D3DTEXF_NONE);
}
// perform SSAO
if(ssao && doSsao) {
ssao->go(tex, zTex, rgbaBuffer1Surf);
d3ddev->StretchRect(rgbaBuffer1Surf, NULL, oldRenderTarget, NULL, D3DTEXF_NONE);
}
restoreRenderState();
zTex->Release();
//if(takeScreenshot) D3DXSaveSurfaceToFile("1effect_buff.bmp", D3DXIFF_BMP, rgbaBuffer1Surf, NULL, NULL);
//if(takeScreenshot) D3DXSaveSurfaceToFile("1effect_post.bmp", D3DXIFF_BMP, oldRenderTarget, NULL, NULL);
}
tex->Release();
}
}
oldRenderTarget->Release();
}
// DoF blur stuff
if(gauss && doDofGauss) {
IDirect3DSurface9 *oldRenderTarget;
d3ddev->GetRenderTarget(0, &oldRenderTarget);
D3DSURFACE_DESC desc;
oldRenderTarget->GetDesc(&desc);
unsigned dofIndex = isDof(desc.Width, desc.Height);
if(dofIndex) {
doft[dofIndex]++;
SDLOG(6,"DOF index: %u, doft: %u\n", dofIndex, doft[dofIndex]);
//if(takeScreenshot) {
// char buffer[256];
// sprintf(buffer, "dof%1u_doft%1u.bmp", dofIndex, doft[dofIndex]);
// D3DXSaveSurfaceToFile(buffer, D3DXIFF_BMP, oldRenderTarget, NULL, NULL);
//}
if(dofIndex == 1 && doft[1] == 4) {
IDirect3DTexture9 *oldRTtex = getSurfTexture(oldRenderTarget);
if(oldRTtex) {
storeRenderState();
for(size_t i=0; i<Settings::get().getDOFBlurAmount(); ++i) gauss->go(oldRTtex, oldRenderTarget);
restoreRenderState();
oldRTtex->Release();
}
}
}
oldRenderTarget->Release();
}
// Timing for hudless screenshots
if(mainRTuses == 11 && takeScreenshot) {
IDirect3DSurface9 *oldRenderTarget;
d3ddev->GetRenderTarget(0, &oldRenderTarget);
if(oldRenderTarget != mainRT) {
static int toggleSS = 0;
toggleSS = (toggleSS+1)%2;
if(!toggleSS) {
takeScreenshot = false;
SDLOG(0, "Capturing screenshot\n");
char timebuf[128], buffer[512];
time_t ltime;
time(<ime);
struct tm *timeinfo;
timeinfo = localtime(<ime);
strftime(timebuf, 128, "screenshot_%Y-%m-%d_%H-%M-%S.png", timeinfo);
sprintf(buffer, "%s\\%s", Settings::get().getScreenshotDir().c_str(), timebuf);
SDLOG(0, " - to %s\n", buffer);
D3DSURFACE_DESC desc;
oldRenderTarget->GetDesc(&desc);
IDirect3DSurface9 *convertedSurface;
d3ddev->CreateRenderTarget(desc.Width, desc.Height, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, 0, true, &convertedSurface, NULL);
D3DXLoadSurfaceFromSurface(convertedSurface, NULL, NULL, oldRenderTarget, NULL, NULL, D3DX_FILTER_POINT, 0);
D3DXSaveSurfaceToFile(buffer, D3DXIFF_PNG, convertedSurface, NULL, NULL);
convertedSurface->Release();
}
}
oldRenderTarget->Release();
}
if(rddp >= 4) { // we just finished rendering the frame (pre-HUD)
IDirect3DSurface9 *oldRenderTarget;
d3ddev->GetRenderTarget(0, &oldRenderTarget);
// final renderbuffer has to be from texture, just making sure here
if(IDirect3DTexture9* tex = getSurfTexture(oldRenderTarget)) {
// check size just to make even more sure
D3DSURFACE_DESC desc;
oldRenderTarget->GetDesc(&desc);
if(desc.Width == Settings::get().getRenderWidth() && desc.Height == Settings::get().getRenderHeight()) {
// HUD stuff
if(hud && doHud && rddp == 9) {
SDLOG(0, "Starting HUD rendering\n");
hddp = 0;
onHudRT = true;
d3ddev->SetRenderTarget(0, rgbaBuffer1Surf);
d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0,0,0,0), 0.0f, 0);
prevRenderTex = tex;
prevRenderTarget = pRenderTarget;
tex->Release();
oldRenderTarget->Release();
d3ddev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA);
d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_ADD);
d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
return S_OK;
}
}
tex->Release();
}
oldRenderTarget->Release();
}
if(onHudRT) {
finishHudRendering();
}
if(rddp < 4 || rddp > 8) rddp = 0;
else rddp++;
return d3ddev->SetRenderTarget(RenderTargetIndex, pRenderTarget);
}
