Files
neoLegacy/Minecraft.Client/Windows64/PostProcesser.cpp
T

791 lines
27 KiB
C++

#include "stdafx.h"
#include "../Common/PostProcesser.h"
#include <d3dcompiler.h>
#pragma comment(lib, "d3dcompiler.lib")
extern ID3D11Device* g_pd3dDevice;
extern ID3D11DeviceContext* g_pImmediateContext;
extern IDXGISwapChain* g_pSwapChain;
extern ID3D11RenderTargetView* g_pRenderTargetView;
const char* PostProcesser::g_gammaVSCode =
"void main(uint id : SV_VertexID, out float4 pos : SV_Position, out float2 uv : TEXCOORD0)\n"
"{\n"
" uv = float2((id << 1) & 2, id & 2);\n"
" pos = float4(uv * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0);\n"
"}\n";
const char* PostProcesser::g_gammaPSCode =
"cbuffer PostProcessCB : register(b0) { float gamma; float inverseWidth; float inverseHeight; float threshold; float2 uvOffset; float2 uvScale; float2 direction; float fxaaStrength; float padding; };\n"
"Texture2D sceneTex : register(t0); SamplerState sceneSampler : register(s0);\n"
"float4 main(float4 pos : SV_Position, float2 uv : TEXCOORD0) : SV_Target {\n"
" float4 color = sceneTex.Sample(sceneSampler, uvOffset + uv * uvScale);\n"
" color.rgb = pow(max(color.rgb, 0.0), 1.0 / max(gamma, 0.001));\n"
" return color;\n"
"}\n";
const char* PostProcesser::g_fxaaPSCode =
"cbuffer PostProcessCB : register(b0) { float gamma; float inverseWidth; float inverseHeight; float threshold; float2 uvOffset; float2 uvScale; float2 direction; float fxaaStrength; float padding; };\n"
"Texture2D sceneTex : register(t0); SamplerState sceneSampler : register(s0);\n"
"float Luma(float3 color) { return dot(color, float3(0.299, 0.587, 0.114)); }\n"
"float2 ClampUV(float2 uv) { float2 halfPixel = float2(inverseWidth, inverseHeight) * 0.5; return clamp(uv, uvOffset + halfPixel, uvOffset + uvScale - halfPixel); }\n"
"float4 main(float4 pos : SV_Position, float2 uv : TEXCOORD0) : SV_Target {\n"
" float2 pixel = float2(inverseWidth, inverseHeight);\n"
" float2 uvCenter = uvOffset + uv * uvScale;\n"
" float lumaNW = Luma(sceneTex.Sample(sceneSampler, ClampUV(uvCenter + pixel * float2(-1.0, -1.0))).rgb);\n"
" float lumaNE = Luma(sceneTex.Sample(sceneSampler, ClampUV(uvCenter + pixel * float2(1.0, -1.0))).rgb);\n"
" float lumaSW = Luma(sceneTex.Sample(sceneSampler, ClampUV(uvCenter + pixel * float2(-1.0, 1.0))).rgb);\n"
" float lumaSE = Luma(sceneTex.Sample(sceneSampler, ClampUV(uvCenter + pixel * float2(1.0, 1.0))).rgb);\n"
" float4 center = sceneTex.Sample(sceneSampler, uvCenter);\n"
" float lumaM = Luma(center.rgb);\n"
" float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));\n"
" float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));\n"
" if (lumaMax - lumaMin < max(0.0312, lumaMax * threshold)) return center;\n"
" float2 edge = float2(-((lumaNW + lumaNE) - (lumaSW + lumaSE)), (lumaNW + lumaSW) - (lumaNE + lumaSE));\n"
" float reduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * 0.03125, 0.0078125);\n"
" float reciprocal = 1.0 / (min(abs(edge.x), abs(edge.y)) + reduce);\n"
" edge = clamp(edge * reciprocal, -8.0, 8.0) * pixel;\n"
" float3 rgbA = 0.5 * (sceneTex.Sample(sceneSampler, ClampUV(uvCenter + edge * (1.0 / 3.0 - 0.5))).rgb + sceneTex.Sample(sceneSampler, ClampUV(uvCenter + edge * (2.0 / 3.0 - 0.5))).rgb);\n"
" float3 rgbB = rgbA * 0.5 + 0.25 * (sceneTex.Sample(sceneSampler, ClampUV(uvCenter + edge * -0.5)).rgb + sceneTex.Sample(sceneSampler, ClampUV(uvCenter + edge * 0.5)).rgb);\n"
" float lumaB = Luma(rgbB);\n"
" float3 filtered = (lumaB < lumaMin || lumaB > lumaMax) ? rgbA : rgbB;\n"
" return float4(lerp(center.rgb, filtered, saturate(fxaaStrength)), center.a);\n"
"}\n";
bool CompilePixelShader(ID3D11Device* device, const char* source, const char* name, UINT compileFlags, ID3D11PixelShader** shader) {
ID3DBlob* shaderBlob = nullptr;
ID3DBlob* errorBlob = nullptr;
const HRESULT compileResult = D3DCompile(source, strlen(source), name, nullptr, nullptr, "main", "ps_4_0", compileFlags, 0, &shaderBlob, &errorBlob);
if (FAILED(compileResult)) {
if (errorBlob) {
app.DebugPrintf(static_cast<const char*>(errorBlob->GetBufferPointer()));
errorBlob->Release();
}
return false;
}
const HRESULT createResult = device->CreatePixelShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr, shader);
shaderBlob->Release();
if (errorBlob) errorBlob->Release();
if (FAILED(createResult)) app.DebugPrintf("PostProcesser: failed to create a pixel shader.\n");
return SUCCEEDED(createResult);
}
PostProcesser::PostProcesser()
{
RegisterPass(PostProcessType::FXAA, PostProcessStage::BeforeNativeHud);
}
PostProcesser::~PostProcesser()
{
Cleanup();
}
bool PostProcesser::IsRunningUnderWine()
{
const HMODULE ntdll = GetModuleHandleA("ntdll.dll");
if (ntdll)
{
if (GetProcAddress(ntdll, "wine_get_version"))
return true;
}
return false;
}
void PostProcesser::SetGamma(float gamma)
{
m_gamma = gamma;
}
void PostProcesser::SetFXAAStrength(float strength)
{
m_fxaaStrength = max(0.0f, min(strength, 1.0f));
}
void PostProcesser::Init()
{
if (!g_pd3dDevice || !g_pSwapChain)
return;
if (m_initialized)
return;
m_wineMode = IsRunningUnderWine();
HRESULT hr;
ID3D11Texture2D* pBackBuffer = nullptr;
hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<LPVOID*>(&pBackBuffer));
if (FAILED(hr))
return;
D3D11_TEXTURE2D_DESC bbDesc;
pBackBuffer->GetDesc(&bbDesc);
pBackBuffer->Release();
m_gammaTexWidth = bbDesc.Width;
m_gammaTexHeight = bbDesc.Height;
DXGI_FORMAT texFormat = bbDesc.Format;
if (m_wineMode)
{
texFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
}
D3D11_TEXTURE2D_DESC texDesc;
ZeroMemory(&texDesc, sizeof(texDesc));
texDesc.Width = bbDesc.Width;
texDesc.Height = bbDesc.Height;
texDesc.MipLevels = 1;
texDesc.ArraySize = 1;
texDesc.Format = texFormat;
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
hr = g_pd3dDevice->CreateTexture2D(&texDesc, nullptr, &m_pGammaOffscreenTex);
if (FAILED(hr))
return;
hr = g_pd3dDevice->CreateShaderResourceView(m_pGammaOffscreenTex, nullptr, &m_pGammaOffscreenSRV);
if (FAILED(hr))
return;
hr = g_pd3dDevice->CreateRenderTargetView(m_pGammaOffscreenTex, nullptr, &m_pGammaOffscreenRTV);
if (FAILED(hr))
return;
ID3DBlob* vsBlob = nullptr;
ID3DBlob* errBlob = nullptr;
UINT compileFlags = D3DCOMPILE_ENABLE_STRICTNESS;
if (m_wineMode)
{
compileFlags |= D3DCOMPILE_AVOID_FLOW_CONTROL;
}
hr = D3DCompile(g_gammaVSCode, strlen(g_gammaVSCode), "GammaVS", nullptr, nullptr, "main", "vs_4_0", compileFlags, 0, &vsBlob, &errBlob);
if (FAILED(hr))
{
if (errBlob)
errBlob->Release();
return;
}
hr = g_pd3dDevice->CreateVertexShader(vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), nullptr, &m_pGammaVS);
vsBlob->Release();
if (errBlob)
errBlob->Release();
if (FAILED(hr))
return;
errBlob = nullptr;
ID3DBlob* psBlob = nullptr;
hr = D3DCompile(g_gammaPSCode, strlen(g_gammaPSCode), "GammaPS", nullptr, nullptr, "main", "ps_4_0", compileFlags, 0, &psBlob, &errBlob);
if (FAILED(hr))
{
if (errBlob)
errBlob->Release();
return;
}
hr = g_pd3dDevice->CreatePixelShader(psBlob->GetBufferPointer(), psBlob->GetBufferSize(), nullptr, &m_pGammaPS);
psBlob->Release();
if (errBlob)
errBlob->Release();
if (FAILED(hr))
return;
if (!CompilePixelShader(g_pd3dDevice, g_fxaaPSCode, "FXAAPS", compileFlags, &m_pFXAAPS))
{
Cleanup();
return;
}
D3D11_BUFFER_DESC cbDesc;
ZeroMemory(&cbDesc, sizeof(cbDesc));
cbDesc.ByteWidth = sizeof(PostProcessCBData);
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
PostProcessCBData initData = {1.0f, 1.0f / static_cast<float>(m_gammaTexWidth),
1.0f / static_cast<float>(m_gammaTexHeight),
0.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.0f, 0.0f, 0.0f, 0.0f};
D3D11_SUBRESOURCE_DATA srData;
srData.pSysMem = &initData;
srData.SysMemPitch = 0;
srData.SysMemSlicePitch = 0;
hr = g_pd3dDevice->CreateBuffer(&cbDesc, &srData, &m_pGammaCB);
if (FAILED(hr))
{
Cleanup();
return;
}
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory(&sampDesc, sizeof(sampDesc));
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
hr = g_pd3dDevice->CreateSamplerState(&sampDesc, &m_pGammaSampler);
if (FAILED(hr))
{
Cleanup();
return;
}
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
hr = g_pd3dDevice->CreateSamplerState(&sampDesc, &m_pPostProcessSampler);
if (FAILED(hr))
{
Cleanup();
return;
}
D3D11_RASTERIZER_DESC rasDesc;
ZeroMemory(&rasDesc, sizeof(rasDesc));
rasDesc.FillMode = D3D11_FILL_SOLID;
rasDesc.CullMode = D3D11_CULL_NONE;
rasDesc.DepthClipEnable = FALSE;
rasDesc.ScissorEnable = FALSE;
hr = g_pd3dDevice->CreateRasterizerState(&rasDesc, &m_pGammaRastState);
if (FAILED(hr))
{
Cleanup();
return;
}
D3D11_DEPTH_STENCIL_DESC dsDesc;
ZeroMemory(&dsDesc, sizeof(dsDesc));
dsDesc.DepthEnable = FALSE;
dsDesc.StencilEnable = FALSE;
hr = g_pd3dDevice->CreateDepthStencilState(&dsDesc, &m_pGammaDepthState);
if (FAILED(hr))
{
Cleanup();
return;
}
D3D11_BLEND_DESC blendDesc;
ZeroMemory(&blendDesc, sizeof(blendDesc));
blendDesc.RenderTarget[0].BlendEnable = FALSE;
blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
hr = g_pd3dDevice->CreateBlendState(&blendDesc, &m_pGammaBlendState);
if (FAILED(hr))
{
Cleanup();
return;
}
m_initialized = true;
}
void PostProcesser::Apply() const
{
if (!m_initialized)
return;
if (m_gamma > 0.99f && m_gamma < 1.01f)
return;
ID3D11DeviceContext *ctx = g_pImmediateContext;
ID3D11Texture2D *pBackBuffer = nullptr;
HRESULT hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<LPVOID *>(&pBackBuffer));
if (FAILED(hr))
return;
D3D11_BOX srcBox = { 0, 0, 0, m_gammaTexWidth, m_gammaTexHeight, 1 };
ctx->CopySubresourceRegion(m_pGammaOffscreenTex, 0, 0, 0, 0, pBackBuffer, 0, &srcBox);
pBackBuffer->Release();
D3D11_MAPPED_SUBRESOURCE mapped;
const D3D11_MAP mapType = m_wineMode ? D3D11_MAP_WRITE_NO_OVERWRITE : D3D11_MAP_WRITE_DISCARD;
hr = ctx->Map(m_pGammaCB, 0, mapType, 0, &mapped);
if (SUCCEEDED(hr))
{
PostProcessCBData *cb = static_cast<PostProcessCBData *>(mapped.pData);
cb->gamma = m_gamma;
cb->inverseWidth = 1.0f / static_cast<float>(m_gammaTexWidth);
cb->inverseHeight = 1.0f / static_cast<float>(m_gammaTexHeight);
cb->uvOffsetX = 0.0f;
cb->uvOffsetY = 0.0f;
cb->uvScaleX = 1.0f;
cb->uvScaleY = 1.0f;
ctx->Unmap(m_pGammaCB, 0);
}
ID3D11RenderTargetView* oldRTV = nullptr;
ID3D11DepthStencilView* oldDSV = nullptr;
ctx->OMGetRenderTargets(1, &oldRTV, &oldDSV);
UINT numViewports = 1;
D3D11_VIEWPORT oldViewport = {};
ctx->RSGetViewports(&numViewports, &oldViewport);
ID3D11RenderTargetView* bbRTV = g_pRenderTargetView;
ctx->OMSetRenderTargets(1, &bbRTV, nullptr);
D3D11_VIEWPORT vp;
if (m_useCustomViewport)
{
vp = m_customViewport;
}
else
{
vp.Width = static_cast<FLOAT>(m_gammaTexWidth);
vp.Height = static_cast<FLOAT>(m_gammaTexHeight);
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
}
ctx->RSSetViewports(1, &vp);
ctx->IASetInputLayout(nullptr);
ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ctx->VSSetShader(m_pGammaVS, nullptr, 0);
ctx->PSSetShader(m_pGammaPS, nullptr, 0);
ctx->PSSetShaderResources(0, 1, &m_pGammaOffscreenSRV);
ctx->PSSetSamplers(0, 1, &m_pGammaSampler);
ctx->PSSetConstantBuffers(0, 1, &m_pGammaCB);
ctx->RSSetState(m_pGammaRastState);
ctx->OMSetDepthStencilState(m_pGammaDepthState, 0);
constexpr float blendFactor[4] = {0, 0, 0, 0};
ctx->OMSetBlendState(m_pGammaBlendState, blendFactor, 0xFFFFFFFF);
ctx->Draw(3, 0);
ID3D11ShaderResourceView* nullSrv = nullptr;
ctx->PSSetShaderResources(0, 1, &nullSrv);
ctx->OMSetRenderTargets(1, &oldRTV, oldDSV);
ctx->RSSetViewports(1, &oldViewport);
if (oldRTV)
oldRTV->Release();
if (oldDSV)
oldDSV->Release();
}
void PostProcesser::SetViewport(const D3D11_VIEWPORT& viewport)
{
m_customViewport = viewport;
m_useCustomViewport = true;
}
void PostProcesser::ResetViewport()
{
m_useCustomViewport = false;
}
void PostProcesser::CopyBackbuffer()
{
if (!m_initialized)
return;
ID3D11DeviceContext* ctx = g_pImmediateContext;
ID3D11Texture2D* pBackBuffer = nullptr;
HRESULT hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<LPVOID*>(&pBackBuffer));
if (FAILED(hr))
{
OutputDebugStringA("PostProcesser: failed to acquire the backbuffer for copying.\n");
return;
}
D3D11_BOX srcBox = { 0, 0, 0, m_gammaTexWidth, m_gammaTexHeight, 1 };
ctx->CopySubresourceRegion(m_pGammaOffscreenTex, 0, 0, 0, 0, pBackBuffer, 0, &srcBox);
pBackBuffer->Release();
}
void PostProcesser::ApplyFromCopied() const
{
if (!m_initialized)
return;
if (m_gamma > 0.99f && m_gamma < 1.01f)
return;
ID3D11DeviceContext* ctx = g_pImmediateContext;
D3D11_VIEWPORT vp;
if (m_useCustomViewport)
{
vp = m_customViewport;
}
else
{
vp.Width = static_cast<FLOAT>(m_gammaTexWidth);
vp.Height = static_cast<FLOAT>(m_gammaTexHeight);
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
}
D3D11_MAPPED_SUBRESOURCE mapped;
const D3D11_MAP mapType = m_wineMode ? D3D11_MAP_WRITE_NO_OVERWRITE : D3D11_MAP_WRITE_DISCARD;
const HRESULT hr = ctx->Map(m_pGammaCB, 0, mapType, 0, &mapped);
if (SUCCEEDED(hr))
{
const auto cb = static_cast<PostProcessCBData*>(mapped.pData);
cb->gamma = m_gamma;
const float texW = static_cast<float>(m_gammaTexWidth);
const float texH = static_cast<float>(m_gammaTexHeight);
cb->inverseWidth = 1.0f / texW;
cb->inverseHeight = 1.0f / texH;
cb->uvOffsetX = vp.TopLeftX / texW;
cb->uvOffsetY = vp.TopLeftY / texH;
cb->uvScaleX = vp.Width / texW;
cb->uvScaleY = vp.Height / texH;
cb->directionX = 0.0f;
cb->directionY = 0.0f;
cb->fxaaStrength = 0.0f;
cb->padding = 0.0f;
ctx->Unmap(m_pGammaCB, 0);
}
ID3D11RenderTargetView* oldRTV = nullptr;
ID3D11DepthStencilView* oldDSV = nullptr;
ctx->OMGetRenderTargets(1, &oldRTV, &oldDSV);
UINT numViewports = 1;
D3D11_VIEWPORT oldViewport = {};
ctx->RSGetViewports(&numViewports, &oldViewport);
ID3D11RenderTargetView* bbRTV = g_pRenderTargetView;
ctx->OMSetRenderTargets(1, &bbRTV, nullptr);
ctx->RSSetViewports(1, &vp);
ctx->IASetInputLayout(nullptr);
ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ctx->VSSetShader(m_pGammaVS, nullptr, 0);
ctx->PSSetShader(m_pGammaPS, nullptr, 0);
ctx->PSSetShaderResources(0, 1, &m_pGammaOffscreenSRV);
ctx->PSSetSamplers(0, 1, &m_pGammaSampler);
ctx->PSSetConstantBuffers(0, 1, &m_pGammaCB);
ctx->RSSetState(m_pGammaRastState);
ctx->OMSetDepthStencilState(m_pGammaDepthState, 0);
constexpr float blendFactor[4] = {0, 0, 0, 0};
ctx->OMSetBlendState(m_pGammaBlendState, blendFactor, 0xFFFFFFFF);
ctx->Draw(3, 0);
ID3D11ShaderResourceView* nullSrv = nullptr;
ctx->PSSetShaderResources(0, 1, &nullSrv);
ctx->OMSetRenderTargets(1, &oldRTV, oldDSV);
ctx->RSSetViewports(1, &oldViewport);
if (oldRTV)
oldRTV->Release();
if (oldDSV)
oldDSV->Release();
}
void PostProcesser::RegisterPass(PostProcessType type, PostProcessStage stage, bool enabled)
{
for (RegisteredPass& pass : m_registeredPasses)
{
if (pass.type == type)
{
pass.stage = stage;
pass.enabled = enabled;
return;
}
}
m_registeredPasses.push_back({type, stage, enabled});
}
void PostProcesser::SetPassEnabled(PostProcessType type, bool enabled)
{
for (RegisteredPass& pass : m_registeredPasses)
{
if (pass.type == type)
{
pass.enabled = enabled;
return;
}
}
}
void PostProcesser::RunStage(PostProcessStage stage)
{
if (!m_initialized || !g_pImmediateContext)
return;
D3D11_VIEWPORT viewport = {};
UINT viewportCount = 1;
g_pImmediateContext->RSGetViewports(&viewportCount, &viewport);
if (viewportCount == 0 || viewport.Width <= 0.0f || viewport.Height <= 0.0f)
return;
for (const RegisteredPass& pass : m_registeredPasses)
{
if (!pass.enabled || pass.stage != stage)
continue;
switch (pass.type)
{
case PostProcessType::FXAA:
ApplyFXAA(viewport);
break;
case PostProcessType::Gamma:
ApplyGamma(viewport);
break;
}
}
}
bool PostProcesser::DrawFullscreen(ID3D11PixelShader* pixelShader,
ID3D11ShaderResourceView* source,
ID3D11RenderTargetView* target,
const D3D11_VIEWPORT& outputViewport,
const D3D11_VIEWPORT& sourceViewport,
float sourceWidth,
float sourceHeight,
float directionX,
float directionY,
float gamma,
float threshold,
float fxaaStrength) const
{
if (!pixelShader || !source || !target || !g_pImmediateContext)
return false;
D3D11_MAPPED_SUBRESOURCE mapped = {};
const D3D11_MAP mapType = m_wineMode ? D3D11_MAP_WRITE_NO_OVERWRITE : D3D11_MAP_WRITE_DISCARD;
if (FAILED(g_pImmediateContext->Map(m_pGammaCB, 0, mapType, 0, &mapped)))
{
OutputDebugStringA("PostProcesser: failed to map post-process constants.\n");
return false;
}
PostProcessCBData* cb = static_cast<PostProcessCBData*>(mapped.pData);
const float textureWidth = sourceWidth;
const float textureHeight = sourceHeight;
cb->gamma = gamma;
cb->inverseWidth = 1.0f / textureWidth;
cb->inverseHeight = 1.0f / textureHeight;
cb->threshold = threshold;
cb->uvOffsetX = sourceViewport.TopLeftX / textureWidth;
cb->uvOffsetY = sourceViewport.TopLeftY / textureHeight;
cb->uvScaleX = sourceViewport.Width / textureWidth;
cb->uvScaleY = sourceViewport.Height / textureHeight;
cb->directionX = directionX;
cb->directionY = directionY;
cb->fxaaStrength = fxaaStrength;
cb->padding = 0.0f;
g_pImmediateContext->Unmap(m_pGammaCB, 0);
ID3D11RenderTargetView* oldRTV = nullptr;
ID3D11DepthStencilView* oldDSV = nullptr;
g_pImmediateContext->OMGetRenderTargets(1, &oldRTV, &oldDSV);
D3D11_VIEWPORT oldViewports[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE] = {};
UINT oldViewportCount = D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
g_pImmediateContext->RSGetViewports(&oldViewportCount, oldViewports);
ID3D11InputLayout* oldInputLayout = nullptr;
g_pImmediateContext->IAGetInputLayout(&oldInputLayout);
D3D11_PRIMITIVE_TOPOLOGY oldTopology;
g_pImmediateContext->IAGetPrimitiveTopology(&oldTopology);
constexpr UINT maxClassInstances = 256;
ID3D11ClassInstance* oldVSInstances[maxClassInstances] = {};
ID3D11ClassInstance* oldPSInstances[maxClassInstances] = {};
UINT oldVSInstanceCount = maxClassInstances;
UINT oldPSInstanceCount = maxClassInstances;
ID3D11VertexShader* oldVS = nullptr;
ID3D11PixelShader* oldPS = nullptr;
g_pImmediateContext->VSGetShader(&oldVS, oldVSInstances, &oldVSInstanceCount);
g_pImmediateContext->PSGetShader(&oldPS, oldPSInstances, &oldPSInstanceCount);
ID3D11ShaderResourceView* oldResource = nullptr;
ID3D11SamplerState* oldSampler = nullptr;
ID3D11Buffer* oldConstantBuffer = nullptr;
g_pImmediateContext->PSGetShaderResources(0, 1, &oldResource);
g_pImmediateContext->PSGetSamplers(0, 1, &oldSampler);
g_pImmediateContext->PSGetConstantBuffers(0, 1, &oldConstantBuffer);
ID3D11RasterizerState* oldRasterizer = nullptr;
ID3D11DepthStencilState* oldDepthState = nullptr;
UINT oldStencilReference = 0;
ID3D11BlendState* oldBlendState = nullptr;
FLOAT oldBlendFactor[4] = {};
UINT oldSampleMask = 0;
g_pImmediateContext->RSGetState(&oldRasterizer);
g_pImmediateContext->OMGetDepthStencilState(&oldDepthState, &oldStencilReference);
g_pImmediateContext->OMGetBlendState(&oldBlendState, oldBlendFactor, &oldSampleMask);
ID3D11ShaderResourceView* nullResource = nullptr;
g_pImmediateContext->PSSetShaderResources(0, 1, &nullResource);
g_pImmediateContext->OMSetRenderTargets(1, &target, nullptr);
g_pImmediateContext->RSSetViewports(1, &outputViewport);
g_pImmediateContext->IASetInputLayout(nullptr);
g_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
g_pImmediateContext->VSSetShader(m_pGammaVS, nullptr, 0);
g_pImmediateContext->PSSetShader(pixelShader, nullptr, 0);
g_pImmediateContext->PSSetShaderResources(0, 1, &source);
g_pImmediateContext->PSSetSamplers(0, 1, &m_pPostProcessSampler);
g_pImmediateContext->PSSetConstantBuffers(0, 1, &m_pGammaCB);
g_pImmediateContext->RSSetState(m_pGammaRastState);
g_pImmediateContext->OMSetDepthStencilState(m_pGammaDepthState, 0);
constexpr float blendFactor[4] = {0, 0, 0, 0};
g_pImmediateContext->OMSetBlendState(m_pGammaBlendState, blendFactor, 0xFFFFFFFF);
g_pImmediateContext->Draw(3, 0);
g_pImmediateContext->PSSetShaderResources(0, 1, &nullResource);
g_pImmediateContext->OMSetRenderTargets(1, &oldRTV, oldDSV);
g_pImmediateContext->RSSetViewports(oldViewportCount, oldViewports);
g_pImmediateContext->IASetInputLayout(oldInputLayout);
g_pImmediateContext->IASetPrimitiveTopology(oldTopology);
g_pImmediateContext->VSSetShader(oldVS, oldVSInstances, oldVSInstanceCount);
g_pImmediateContext->PSSetShader(oldPS, oldPSInstances, oldPSInstanceCount);
g_pImmediateContext->PSSetShaderResources(0, 1, &oldResource);
g_pImmediateContext->PSSetSamplers(0, 1, &oldSampler);
g_pImmediateContext->PSSetConstantBuffers(0, 1, &oldConstantBuffer);
g_pImmediateContext->RSSetState(oldRasterizer);
g_pImmediateContext->OMSetDepthStencilState(oldDepthState, oldStencilReference);
g_pImmediateContext->OMSetBlendState(oldBlendState, oldBlendFactor, oldSampleMask);
if (oldRTV)
oldRTV->Release();
if (oldDSV)
oldDSV->Release();
if (oldInputLayout)
oldInputLayout->Release();
if (oldVS)
oldVS->Release();
if (oldPS)
oldPS->Release();
for (UINT i = 0; i < oldVSInstanceCount; ++i)
{
if (oldVSInstances[i])
oldVSInstances[i]->Release();
}
for (UINT i = 0; i < oldPSInstanceCount; ++i)
{
if (oldPSInstances[i])
oldPSInstances[i]->Release();
}
if (oldResource)
oldResource->Release();
if (oldSampler)
oldSampler->Release();
if (oldConstantBuffer)
oldConstantBuffer->Release();
if (oldRasterizer)
oldRasterizer->Release();
if (oldDepthState)
oldDepthState->Release();
if (oldBlendState)
oldBlendState->Release();
return true;
}
void PostProcesser::ApplyFXAA(const D3D11_VIEWPORT& viewport)
{
CopyBackbuffer();
DrawFullscreen(m_pFXAAPS, m_pGammaOffscreenSRV, g_pRenderTargetView,
viewport, viewport, static_cast<float>(m_gammaTexWidth),
static_cast<float>(m_gammaTexHeight),
0.0f, 0.0f, 1.0f, 0.125f, m_fxaaStrength);
}
void PostProcesser::ApplyGamma(const D3D11_VIEWPORT& viewport)
{
if (m_gamma > 0.99f && m_gamma < 1.01f)
return;
CopyBackbuffer();
DrawFullscreen(m_pGammaPS, m_pGammaOffscreenSRV, g_pRenderTargetView,
viewport, viewport, static_cast<float>(m_gammaTexWidth),
static_cast<float>(m_gammaTexHeight),
0.0f, 0.0f, m_gamma, 0.0f, 0.0f);
}
void PostProcesser::Cleanup()
{
if (m_pFXAAPS)
{
m_pFXAAPS->Release();
m_pFXAAPS = nullptr;
}
if (m_pGammaBlendState)
{
m_pGammaBlendState->Release();
m_pGammaBlendState = nullptr;
}
if (m_pGammaDepthState)
{
m_pGammaDepthState->Release();
m_pGammaDepthState = nullptr;
}
if (m_pGammaRastState)
{
m_pGammaRastState->Release();
m_pGammaRastState = nullptr;
}
if (m_pGammaSampler)
{
m_pGammaSampler->Release();
m_pGammaSampler = nullptr;
}
if (m_pPostProcessSampler)
{
m_pPostProcessSampler->Release();
m_pPostProcessSampler = nullptr;
}
if (m_pGammaCB)
{
m_pGammaCB->Release();
m_pGammaCB = nullptr;
}
if (m_pGammaPS)
{
m_pGammaPS->Release();
m_pGammaPS = nullptr;
}
if (m_pGammaVS)
{
m_pGammaVS->Release();
m_pGammaVS = nullptr;
}
if (m_pGammaOffscreenRTV)
{
m_pGammaOffscreenRTV->Release();
m_pGammaOffscreenRTV = nullptr;
}
if (m_pGammaOffscreenSRV)
{
m_pGammaOffscreenSRV->Release();
m_pGammaOffscreenSRV = nullptr;
}
if (m_pGammaOffscreenTex)
{
m_pGammaOffscreenTex->Release();
m_pGammaOffscreenTex = nullptr;
}
m_initialized = false;
m_useCustomViewport = false;
m_gammaTexWidth = 0;
m_gammaTexHeight = 0;
}