mirror of
https://git.neolegacy.dev/neoStudiosLCE/neoLegacy.git
synced 2026-11-18 19:50:00 +01:00
Co-authored-by: DrPerkyLegit <116128211+DrPerkyLegit@users.noreply.github.com> Co-authored-by: github-actions <github-actions@github.com> Co-authored-by: Anaël <60509176+Bakoubak@users.noreply.github.com> Reviewed-on: https://git.neolegacy.dev/neoStudiosLCE/neoLegacy/pulls/4205
791 lines
27 KiB
C++
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;
|
|
}
|