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();
}
void
MapNode::preprocess()
{
restoreRenderState();
//TODO: implement me , texture update
saveRenderState();
}
void MeshCommand::execute()
{
// set render state
applyRenderState();
// Set material
GL::bindTexture2D(_textureID);
GL::blendFunc(_blendType.src, _blendType.dst);
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
_glProgramState->setUniformVec4("u_color", _displayColor);
if (_matrixPaletteSize && _matrixPalette)
{
_glProgramState->setUniformCallback("u_matrixPalette", CC_CALLBACK_2(MeshCommand::MatrixPalleteCallBack, this));
}
_glProgramState->apply(_mv);
if (Director::getInstance()->getRunningScene()->getLights().size() > 0)
setLightUniforms();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);
// Draw
glDrawElements(_primitive, (GLsizei)_indexCount, _indexFormat, 0);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _indexCount);
//restore render state
restoreRenderState();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
HRESULT RSManager::redirectPresent(CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion) {
prePresent(false);
storeRenderState();
HRESULT hr = d3ddev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
restoreRenderState();
cpuFrameTimer.start();
perfMonitor->start();
return hr;
}
void RSManager::finishHudRendering() {
SDLOG(2, "FinishHudRendering\n");
if(takeScreenshot) dumpSurface("HUD_end", rgbaBuffer1Surf);
d3ddev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
d3ddev->SetRenderTarget(0, prevRenderTarget);
onHudRT = false;
// draw HUD to screen
storeRenderState();
hud->go(rgbaBuffer1Tex, prevRenderTarget);
restoreRenderState();
}
HRESULT RSManagerDX9::redirectPresent(CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion) {
prePresent(false);
storeRenderState();
genericPrePresent();
HRESULT hr = d3ddev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
genericPostPresent();
restoreRenderState();
return hr;
}
void MapNode::update()
{
restoreRenderState();
if (!m_initialized)
init();
if (m_dirtyFBO)
updateFBO();
saveRenderState();
}
HRESULT RSManager::redirectPresentEx(CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags) {
SDLOG(1, "- PresentEx flags: %s\n", D3DPresentExFlagsToString(dwFlags).c_str());
prePresent((dwFlags & D3DPRESENT_DONOTFLIP) != 0);
storeRenderState();
HRESULT hr = ((IDirect3DDevice9Ex*)d3ddev)->PresentEx(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
restoreRenderState();
cpuFrameTimer.start();
perfMonitor->start();
return hr;
}
void MeshCommand::postBatchDraw()
{
//restore render state
restoreRenderState();
if (_vao)
{
GL::bindVAO(0);
}
else
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}
void RSManager::prePresent(bool doNotFlip) {
if(dumpingFrame) {
dumpSurface("framedump_prePresent", backBuffers[0]);
SDLOG(0, "============================================\nFinished dumping frame.\n");
Settings::get().restoreLogLevel();
dumpingFrame = false;
}
// downsample offscreen backbuffer to screen
if(downsampling) {
storeRenderState();
d3ddev->BeginScene();
plugin->preDownsample(backBuffers[0]);
SDLOG(2, "Scaling fake backbuffer (%p)\n", backBuffers[0]);
IDirect3DSurface9* realBackBuffer;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &realBackBuffer);
SDLOG(2, "- to backbuffer %p\n", realBackBuffer);
scaler->go(backBufferTextures[0], realBackBuffer);
realBackBuffer->Release();
SDLOG(2, "- scaling complete!\n");
d3ddev->EndScene();
if(takeScreenshot == SCREENSHOT_STANDARD) {
takeScreenshot = SCREENSHOT_NONE;
captureRTScreen();
}
if(swapEffect == SWAP_FLIP && Settings::get().getEmulateFlipBehaviour() && !doNotFlip) {
d3ddev->StretchRect(backBuffers[0], NULL, extraBuffer->getSurf(), NULL, D3DTEXF_NONE);
for(unsigned bb=0; bb<numBackBuffers; ++bb) {
d3ddev->StretchRect(backBuffers[bb+1], NULL, backBuffers[bb], NULL, D3DTEXF_NONE);
}
d3ddev->StretchRect(extraBuffer->getSurf(), NULL, backBuffers[numBackBuffers-1], NULL, D3DTEXF_NONE);
SDLOG(2, "Advanced flip queue\n");
} else {
SDLOG(2, "Not \"flipping\" backbuffers\n");
}
restoreRenderState();
}
else {
storeRenderState();
d3ddev->BeginScene();
IDirect3DSurface9* bb = NULL;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &bb);
if(dumpingFrame) {
dumpSurface("framedump_preplugin", bb);
}
plugin->preDownsample(bb);
if(dumpingFrame) {
dumpSurface("framedump_postplugin", bb);
}
SAFERELEASE(bb);
d3ddev->EndScene();
restoreRenderState();
}
if(takeScreenshot == SCREENSHOT_FULL || takeScreenshot == SCREENSHOT_HUDLESS || (!downsampling && takeScreenshot == SCREENSHOT_STANDARD)) {
storeRenderState();
takeScreenshot = SCREENSHOT_NONE;
if(downsampling) d3ddev->SetRenderTarget(0, backBuffers[0]);
captureRTScreen("full resolution");
restoreRenderState();
}
// Frame time measurements
cpuFrameTimes.add(cpuFrameTimer.elapsed() / 1000.0);
perfMonitor->end();
frameTimeText->text = format("Frame times (avg/max):\n CPU: %6.2lf / %6.2lf ms\n GPU: %6.2f / %6.2lf ms\nVid mem. avail.: %4u MB",
cpuFrameTimes.get(), cpuFrameTimes.maximum(), perfMonitor->getCurrent(), perfMonitor->getMax(), d3ddev->GetAvailableTextureMem()/1024/1024);
// Draw console
if(console.needsDrawing()) {
storeRenderState();
d3ddev->BeginScene();
IDirect3DSurface9* realBackBuffer;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &realBackBuffer);
d3ddev->SetRenderTarget(0, realBackBuffer);
console.draw();
realBackBuffer->Release();
d3ddev->EndScene();
restoreRenderState();
}
// reset per-frame vars
renderTargetSwitches = 0;
plugin->prePresent();
//////////////////////////////////////////// IO
KeyActions::get().processIO();
//////////////////////////////////////////// IO
if(dumpingFrame) {
Settings::get().elevateLogLevel(50);
SDLOG(0, "============================================\nStarting frame dump.\n");
}
SDLOG(2, "Pre-present complete\n");
}
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);
}
void RSManagerDX9::prePresent(bool doNotFlip) {
// downsample offscreen backbuffer to screen
if(downsampling) {
storeRenderState();
d3ddev->BeginScene();
// restore neutral state
initStateBlock->Apply();
// apply plugin actions if specified
plugin->preDownsample(backBuffers[0]->getSurf());
// actual scaling
SDLOG(2, "Scaling fake backbuffer (%p)\n", backBuffers[0]);
IDirect3DSurface9* realBackBuffer;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &realBackBuffer);
SDLOG(2, "- to backbuffer %p\n", realBackBuffer);
scaler->go(backBuffers[0]->getTex(), realBackBuffer);
SDLOG(2, "- scaling complete!\n");
// apply plugin actions if specified
plugin->postDownsample(realBackBuffer);
realBackBuffer->Release();
// emulate flip queue behaviour exactly if required
if(swapEffect == SWAP_FLIP && Settings::get().getEmulateFlipBehaviour() && !doNotFlip) {
d3ddev->StretchRect(backBuffers[0]->getSurf(), NULL, extraBuffer->getSurf(), NULL, D3DTEXF_NONE);
for(unsigned bb = 0; bb < numBackBuffers; ++bb) {
d3ddev->StretchRect(backBuffers[bb + 1]->getSurf(), NULL, backBuffers[bb]->getSurf(), NULL, D3DTEXF_NONE);
}
d3ddev->StretchRect(extraBuffer->getSurf(), NULL, backBuffers[numBackBuffers - 1]->getSurf(), NULL, D3DTEXF_NONE);
SDLOG(2, "Advanced flip queue\n");
}
else {
SDLOG(2, "Not \"flipping\" backbuffers\n");
}
d3ddev->EndScene();
restoreRenderState();
}
else {
storeRenderState();
d3ddev->BeginScene();
IDirect3DSurface9* bb = NULL;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &bb);
if(dumpingFrame) {
dumpSurface("framedump_preplugin", bb);
}
plugin->preDownsample(bb);
if(dumpingFrame) {
dumpSurface("framedump_postplugin", bb);
}
SAFERELEASE(bb);
d3ddev->EndScene();
restoreRenderState();
}
// Stop dumping
if(dumpingFrame) {
if(downsampling) {
dumpSurface("framedump_prePresent", backBuffers[0]->getSurf());
}
SDLOG(0, "============================================\nFinished dumping frame.\n");
Settings::get().restoreLogLevel();
dumpingFrame = false;
console.add("Finished dumping frame.");
}
// Full-size screenshots
if(takingScreenshot(SCREENSHOT_FULL) || takingScreenshot(SCREENSHOT_HUDLESS)) {
storeRenderState();
if(downsampling) d3ddev->SetRenderTarget(0, backBuffers[0]->getSurf());
captureRTScreen("full resolution");
restoreRenderState();
tookScreenshot(SCREENSHOT_FULL);
tookScreenshot(SCREENSHOT_HUDLESS);
}
// Draw console
if(console.needsDrawing()) {
storeRenderState();
// restore neutral state
initStateBlock->Apply();
d3ddev->BeginScene();
IDirect3DSurface9* realBackBuffer;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &realBackBuffer);
if(realBackBuffer) d3ddev->SetRenderTarget(0, realBackBuffer);
console.draw();
if(realBackBuffer) realBackBuffer->Release();
d3ddev->EndScene();
restoreRenderState();
}
// Normal screenshots
if(takingScreenshot(SCREENSHOT_STANDARD)) {
storeRenderState();
IDirect3DSurface9* realBackBuffer = NULL;
d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &realBackBuffer);
if(realBackBuffer) d3ddev->SetRenderTarget(0, realBackBuffer);
captureRTScreen();
SAFERELEASE(realBackBuffer);
restoreRenderState();
if(realBackBuffer) realBackBuffer->Release();
tookScreenshot(SCREENSHOT_STANDARD);
}
// reset per-frame vars
renderTargetSwitches = 0;
plugin->prePresent();
//////////////////////////////////////////// IO
KeyActions::get().processIO();
//////////////////////////////////////////// IO
if(dumpingFrame) {
Settings::get().elevateLogLevel(50);
SDLOG(0, "============================================\nStarting frame dump.\n");
}
SDLOG(2, "Pre-present complete\n");
}
