void MSAAFilter::Render(const Timer& timer)
{
if(AppSettings::MSAAMode.Changed())
CreateRenderTargets();
ID3D11DeviceContextPtr context = deviceManager.ImmediateContext();
AppSettings::UpdateCBuffer(context);
RenderScene();
RenderBackgroundVelocity();
RenderAA();
{
// Kick off post-processing
PIXEvent pixEvent(L"Post Processing");
postProcessor.Render(context, resolveTarget.SRView, deviceManager.BackBuffer(), timer.DeltaSecondsF());
}
ID3D11RenderTargetView* renderTargets[1] = { deviceManager.BackBuffer() };
context->OMSetRenderTargets(1, renderTargets, NULL);
SetViewport(context, deviceManager.BackBufferWidth(), deviceManager.BackBufferHeight());
RenderHUD();
++frameCount;
}
void ShadowsApp::Render(const Timer& timer)
{
ID3D11DeviceContextPtr context = deviceManager.ImmediateContext();
AppSettings::UpdateCBuffer(context);
RenderMainPass();
if(colorTarget.MultiSamples > 1)
context->ResolveSubresource(resolveTarget.Texture, 0, colorTarget.Texture, 0, colorTarget.Format);
// Kick off post-processing
D3DPERF_BeginEvent(0xFFFFFFFF, L"Post Processing");
PostProcessor::Constants constants;
constants.BloomThreshold = AppSettings::BloomThreshold;
constants.BloomMagnitude = AppSettings::BloomMagnitude;
constants.BloomBlurSigma = AppSettings::BloomBlurSigma;
constants.Tau = AppSettings::AdaptationRate;
constants.KeyValue = AppSettings::KeyValue;
constants.TimeDelta = timer.DeltaSecondsF();
postProcessor.SetConstants(constants);
postProcessor.Render(context, resolveTarget.SRView, deviceManager.BackBuffer());
D3DPERF_EndEvent();
// postProcessor.DrawDepthBuffer(depthBuffer, deviceManager.BackBuffer());
ID3D11RenderTargetView* renderTargets[1] = { deviceManager.BackBuffer() };
context->OMSetRenderTargets(1, renderTargets, NULL);
D3D11_VIEWPORT vp;
vp.Width = static_cast<float>(deviceManager.BackBufferWidth());
vp.Height = static_cast<float>(deviceManager.BackBufferHeight());
vp.TopLeftX = 0;
vp.TopLeftY = 0;
vp.MinDepth = 0;
vp.MaxDepth = 1;
context->RSSetViewports(1, &vp);
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
/*spriteRenderer.Begin(context, SpriteRenderer::Linear);
ID3D11ShaderResourceView* srv = meshRenderer.ShadowMap().SRView;
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srv->GetDesc(&srvDesc);
srvDesc.Texture2DArray.ArraySize = 1;
ID3D11ShaderResourceViewPtr newSrv;
deviceManager.Device()->CreateShaderResourceView(meshRenderer.ShadowMap().Texture, &srvDesc, &newSrv);
spriteRenderer.Render(newSrv, Float4x4());
spriteRenderer.End();*/
RenderHUD();
}
void DirectX11RenderContext::SetRenderTarget()
{
Context->OMSetRenderTargets(1, &backBufferView.GetInterfacePtr(), nullptr);
D3D11_TEXTURE2D_DESC desc;
backBuffer->GetDesc(&desc);
// Setup the viewport
D3D11_VIEWPORT vp = { 0.0f, 0.0f, (FLOAT)desc.Width, (FLOAT)desc.Height, 0.0f, 1.0f };
Context->RSSetViewports(1, &vp);
}
namespace Slink
{
extern ID3D11DeviceContextPtr Context;
Shader::Shader()
: vertexShader(nullptr),
pixelShader(nullptr),
vsBlob(nullptr)
{
}
Shader::~Shader() {
}
static ID3DBlobPtr CompileShader(const char* shaderCode, size_t shaderLength, const char* shaderProfile) {
ID3DBlobPtr blob = nullptr;
ID3DBlobPtr errors = nullptr;
HRESULT hr = D3DCompile(shaderCode, shaderLength, nullptr, nullptr, nullptr, "Main", shaderProfile, 0, 0, &blob, &errors);
if (FAILED(hr)) {
if (errors) {
OutputDebugStringA((char*)errors->GetBufferPointer());
errors->Release();
}
return nullptr;
}
return blob;
}
bool Shader::createFromString(std::string vertex, std::string pixel, ID3D11DevicePtr device) {
vsBlob = CompileShader(vertex.c_str(), vertex.length(), "vs_5_0");
if (vsBlob == nullptr)
return false;
auto psBlob = CompileShader(pixel.c_str(), pixel.length(), "ps_5_0");
if (psBlob == nullptr) {
return false;
}
VERIFYDX(device->CreateVertexShader(vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), nullptr, &vertexShader));
VERIFYDX(device->CreatePixelShader(psBlob->GetBufferPointer(), psBlob->GetBufferSize(), nullptr, &pixelShader));
return true;
}
ID3DBlobPtr Shader::getBytecode() const {
return vsBlob;
}
void Shader::set() const {
Context->VSSetShader(vertexShader, nullptr, 0);
Context->PSSetShader(pixelShader, nullptr, 0);
}
}
void ShadowsApp::RenderMainPass()
{
PIXEvent event(L"Main Pass");
ID3D11DeviceContextPtr context = deviceManager.ImmediateContext();
ID3D11RenderTargetView* renderTargets[1] = { NULL };
ID3D11DepthStencilView* ds = depthBuffer.DSView;
context->OMSetRenderTargets(1, renderTargets, ds);
D3D11_VIEWPORT vp;
vp.Width = static_cast<float>(colorTarget.Width);
vp.Height = static_cast<float>(colorTarget.Height);
vp.TopLeftX = 0.0f;
vp.TopLeftY = 0.0f;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
context->RSSetViewports(1, &vp);
float clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
context->ClearRenderTargetView(colorTarget.RTView, clearColor);
context->ClearDepthStencilView(ds, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
Float4x4 meshWorld = Float4x4::ScaleMatrix(MeshScales[AppSettings::CurrentScene]);
Float4x4 characterWorld = Float4x4::ScaleMatrix(CharacterScale);
Float4x4 characterOrientation = Quaternion::ToFloat4x4(AppSettings::CharacterOrientation);
characterWorld = characterWorld * characterOrientation;
characterWorld.SetTranslation(CharacterPos);
{
ProfileBlock block(L"Depth Prepass");
if(AppSettings::GPUSceneSubmission)
meshRenderer.RenderDepthGPU(context, camera, meshWorld, characterWorld, false);
else
meshRenderer.RenderDepthCPU(context, camera, meshWorld, characterWorld, false);
}
if(AppSettings::AutoComputeDepthBounds)
meshRenderer.ReduceDepth(context, depthBuffer.SRView, camera);
if(AppSettings::GPUSceneSubmission)
meshRenderer.RenderShadowMapGPU(context, camera, meshWorld, characterWorld);
else
meshRenderer.RenderShadowMap(context, camera, meshWorld, characterWorld);
renderTargets[0] = colorTarget.RTView;
context->OMSetRenderTargets(1, renderTargets, ds);
context->RSSetViewports(1, &vp);
Float3 lightDir = AppSettings::LightDirection;
meshRenderer.Render(context, camera, meshWorld, characterWorld);
skybox.RenderSky(context, lightDir, true, camera.ViewMatrix(), camera.ProjectionMatrix());
}
void MSAAFilter::RenderScene()
{
PIXEvent event(L"Render Scene");
ID3D11DeviceContextPtr context = deviceManager.ImmediateContext();
SetViewport(context, colorTarget.Width, colorTarget.Height);
float clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
context->ClearRenderTargetView(colorTarget.RTView, clearColor);
context->ClearRenderTargetView(velocityTarget.RTView, clearColor);
context->ClearDepthStencilView(depthBuffer.DSView, D3D11_CLEAR_DEPTH, 1.0f, 0);
ID3D11RenderTargetView* renderTargets[2] = { nullptr, nullptr };
context->OMSetRenderTargets(1, renderTargets, depthBuffer.DSView);
meshRenderer.RenderDepth(context, camera, modelTransform, false);
meshRenderer.ReduceDepth(context, depthBuffer, camera);
meshRenderer.RenderShadowMap(context, camera, modelTransform);
renderTargets[0] = colorTarget.RTView;
renderTargets[1] = velocityTarget.RTView;
context->OMSetRenderTargets(2, renderTargets, depthBuffer.DSView);
meshRenderer.Render(context, camera, modelTransform, envMap, envMapSH, jitterOffset);
renderTargets[0] = colorTarget.RTView;
renderTargets[1] = nullptr;
context->OMSetRenderTargets(2, renderTargets, depthBuffer.DSView);
if(AppSettings::RenderBackground)
skybox.RenderEnvironmentMap(context, envMap, camera.ViewMatrix(), camera.ProjectionMatrix(), Float3(std::exp2(AppSettings::ExposureScale)));
renderTargets[0] = renderTargets[1] = nullptr;
context->OMSetRenderTargets(2, renderTargets, nullptr);
}
void D3D11RenderEngine::D3DDevice(ID3D11DevicePtr const & device, ID3D11DeviceContextPtr const & imm_ctx, D3D_FEATURE_LEVEL feature_level)
{
#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/)
is_d3d_11_1_ = false;
ID3D11Device1* d3d_device_1;
device->QueryInterface(IID_ID3D11Device1, reinterpret_cast<void**>(&d3d_device_1));
if (d3d_device_1)
{
ID3D11DeviceContext1* d3d_imm_ctx_1;
imm_ctx->QueryInterface(IID_ID3D11DeviceContext1, reinterpret_cast<void**>(&d3d_imm_ctx_1));
if (d3d_imm_ctx_1)
{
d3d_device_ = MakeCOMPtr(d3d_device_1);
d3d_imm_ctx_ = MakeCOMPtr(d3d_imm_ctx_1);
is_d3d_11_1_ = true;
}
else
{
d3d_device_1->Release();
}
}
if (!is_d3d_11_1_)
{
d3d_device_ = device;
d3d_imm_ctx_ = imm_ctx;
}
#else
d3d_device_ = device;
d3d_imm_ctx_ = imm_ctx;
#endif
d3d_feature_level_ = feature_level;
Verify(!!d3d_device_);
this->FillRenderDeviceCaps();
}
static void GetTextureData(ID3D11Device* device, ID3D11ShaderResourceView* textureSRV,
DXGI_FORMAT outFormat, TextureData<T>& texData)
{
static ComputeShaderPtr decodeTextureCS;
static ComputeShaderPtr decodeTextureArrayCS;
static const uint32 TGSize = 16;
if(decodeTextureCS.Valid() == false)
{
CompileOptions opts;
opts.Add("TGSize_", TGSize);
const std::wstring shaderPath = SampleFrameworkDir() + L"Shaders\\DecodeTextureCS.hlsl";
decodeTextureCS = CompileCSFromFile(device, shaderPath.c_str(), "DecodeTextureCS", "cs_5_0", opts);
decodeTextureArrayCS = CompileCSFromFile(device, shaderPath.c_str(), "DecodeTextureArrayCS", "cs_5_0", opts);
}
ID3D11Texture2DPtr texture;
textureSRV->GetResource(reinterpret_cast<ID3D11Resource**>(&texture));
D3D11_TEXTURE2D_DESC texDesc;
texture->GetDesc(&texDesc);
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
textureSRV->GetDesc(&srvDesc);
ID3D11ShaderResourceViewPtr sourceSRV = textureSRV;
uint32 arraySize = texDesc.ArraySize;
if(srvDesc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBE
|| srvDesc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
{
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
srvDesc.Texture2DArray.ArraySize = arraySize;
srvDesc.Texture2DArray.FirstArraySlice = 0;
srvDesc.Texture2DArray.MostDetailedMip = 0;
srvDesc.Texture2DArray.MipLevels = -1;
DXCall(device->CreateShaderResourceView(texture, &srvDesc, &sourceSRV));
}
D3D11_TEXTURE2D_DESC decodeTextureDesc;
decodeTextureDesc.Width = texDesc.Width;
decodeTextureDesc.Height = texDesc.Height;
decodeTextureDesc.ArraySize = arraySize;
decodeTextureDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
decodeTextureDesc.Format = outFormat;
decodeTextureDesc.MipLevels = 1;
decodeTextureDesc.MiscFlags = 0;
decodeTextureDesc.SampleDesc.Count = 1;
decodeTextureDesc.SampleDesc.Quality = 0;
decodeTextureDesc.Usage = D3D11_USAGE_DEFAULT;
decodeTextureDesc.CPUAccessFlags = 0;
ID3D11Texture2DPtr decodeTexture;
DXCall(device->CreateTexture2D(&decodeTextureDesc, nullptr, &decodeTexture));
ID3D11UnorderedAccessViewPtr decodeTextureUAV;
DXCall(device->CreateUnorderedAccessView(decodeTexture, nullptr, &decodeTextureUAV));
ID3D11DeviceContextPtr context;
device->GetImmediateContext(&context);
SetCSInputs(context, sourceSRV);
SetCSOutputs(context, decodeTextureUAV);
SetCSShader(context, arraySize > 1 ? decodeTextureArrayCS : decodeTextureCS);
context->Dispatch(DispatchSize(TGSize, texDesc.Width), DispatchSize(TGSize, texDesc.Height), arraySize);
ClearCSInputs(context);
ClearCSOutputs(context);
StagingTexture2D stagingTexture;
stagingTexture.Initialize(device, texDesc.Width, texDesc.Height, outFormat, 1, 1, 0, arraySize);
context->CopyResource(stagingTexture.Texture, decodeTexture);
texData.Init(texDesc.Width, texDesc.Height, arraySize);
for(uint32 slice = 0; slice < arraySize; ++slice)
{
uint32 pitch = 0;
const uint8* srcData = reinterpret_cast<const uint8*>(stagingTexture.Map(context, slice, pitch));
Assert_(pitch >= texDesc.Width * sizeof(T));
const uint32 sliceOffset = texDesc.Width * texDesc.Height * slice;
for(uint32 y = 0; y < texDesc.Height; ++y)
{
const T* rowData = reinterpret_cast<const T*>(srcData);
for(uint32 x = 0; x < texDesc.Width; ++x)
texData.Texels[y * texDesc.Width + x + sliceOffset] = rowData[x];
srcData += pitch;
}
}
}
void DirectX11RenderContext::ClearScreen()
{
float ClearColor[4] = { 1.0f, 0.5f, 0.5f, 1.0f };
Context->ClearRenderTargetView(backBufferView, ClearColor);
}
namespace Slink
{
ID3D11DeviceContextPtr Context = nullptr;
DirectX11RenderContext::DirectX11RenderContext()
: context(nullptr),
backBuffer(nullptr),
backBufferView(nullptr),
swapChain(nullptr),
device(nullptr),
simple(nullptr),
triangle(nullptr)
{
}
DirectX11RenderContext::~DirectX11RenderContext()
{
}
void DirectX11RenderContext::Init(HWND window, uint32_t WindowWidth, uint32_t WindowHeight)
{
const UINT NumFeatureLevels = 3;
D3D_FEATURE_LEVEL FeatureLevels[NumFeatureLevels] = { D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
DXGI_SWAP_CHAIN_DESC sd = {0};
sd.BufferCount = 1;
sd.BufferDesc.Width = WindowWidth;
sd.BufferDesc.Height = WindowHeight;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = window;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
//Create swap chain, device, and immediate context.
UINT Flags = 0;
#if _DEBUG
Flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
VERIFYDX(D3D11CreateDeviceAndSwapChain( nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, Flags, FeatureLevels, NumFeatureLevels,
D3D11_SDK_VERSION, &sd, &swapChain, &device, nullptr, &Context));
#if _DEBUG
device->QueryInterface(__uuidof(ID3D11Debug), reinterpret_cast<void**>(&debug));
//VERIFYDX(debug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL));
#endif
// Create a render target view
VERIFYDX(swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer));
VERIFYDX(device->CreateRenderTargetView(backBuffer, nullptr, &backBufferView));
//Test Code!
simple = new Shader();
simple->createFromString(std::string(VS), std::string(PS), device);
triangle = new Geometry();
float verts[9] = {-1.0f, -1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f};
triangle->setVertexShader(simple->getBytecode());
triangle->createFromData(device, verts, 3);
}
void DirectX11RenderContext::Terminate()
{
}
void DirectX11RenderContext::ClearScreen()
{
float ClearColor[4] = { 1.0f, 0.5f, 0.5f, 1.0f };
Context->ClearRenderTargetView(backBufferView, ClearColor);
}
void DirectX11RenderContext::SetRenderTarget()
{
Context->OMSetRenderTargets(1, &backBufferView.GetInterfacePtr(), nullptr);
D3D11_TEXTURE2D_DESC desc;
backBuffer->GetDesc(&desc);
// Setup the viewport
D3D11_VIEWPORT vp = { 0.0f, 0.0f, (FLOAT)desc.Width, (FLOAT)desc.Height, 0.0f, 1.0f };
Context->RSSetViewports(1, &vp);
}
void DirectX11RenderContext::Draw() {
simple->set();
triangle->draw();
}
void DirectX11RenderContext::Present() {
swapChain->Present(0, 0);
#if _DEBUG
//VERIFYDX(debug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL));
#endif
}
}
void Shader::set() const {
Context->VSSetShader(vertexShader, nullptr, 0);
Context->PSSetShader(pixelShader, nullptr, 0);
}
void MSAAFilter::RenderBackgroundVelocity()
{
PIXEvent pixEvent(L"Render Background Velocity");
ID3D11DeviceContextPtr context = deviceManager.ImmediateContext();
SetViewport(context, velocityTarget.Width, velocityTarget.Height);
// Don't use camera translation for background velocity
FirstPersonCamera tempCamera = camera;
tempCamera.SetPosition(Float3(0.0f, 0.0f, 0.0f));
backgroundVelocityConstants.Data.InvViewProjection = Float4x4::Transpose(Float4x4::Invert(tempCamera.ViewProjectionMatrix()));
backgroundVelocityConstants.Data.PrevViewProjection = Float4x4::Transpose(prevViewProjection);
backgroundVelocityConstants.Data.RTSize.x = float(velocityTarget.Width);
backgroundVelocityConstants.Data.RTSize.y = float(velocityTarget.Height);
backgroundVelocityConstants.Data.JitterOffset = jitterOffset;
backgroundVelocityConstants.ApplyChanges(context);
backgroundVelocityConstants.SetPS(context, 0);
prevViewProjection = tempCamera.ViewProjectionMatrix();
float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
context->OMSetBlendState(blendStates.BlendDisabled(), blendFactor, 0xFFFFFFFF);
context->OMSetDepthStencilState(depthStencilStates.DepthEnabled(), 0);
context->RSSetState(rasterizerStates.NoCull());
ID3D11RenderTargetView* rtvs[1] = { velocityTarget.RTView };
context->OMSetRenderTargets(1, rtvs, depthBuffer.DSView);
context->VSSetShader(backgroundVelocityVS, nullptr, 0);
context->PSSetShader(backgroundVelocityPS, nullptr, 0);
context->GSSetShader(nullptr, nullptr, 0);
context->HSSetShader(nullptr, nullptr, 0);
context->DSSetShader(nullptr, nullptr, 0);
ID3D11Buffer* vbs[1] = { nullptr };
UINT strides[1] = { 0 };
UINT offsets[1] = { 0 };
context->IASetVertexBuffers(0, 1, vbs, strides, offsets);
context->IASetInputLayout(nullptr);
context->IASetIndexBuffer(nullptr, DXGI_FORMAT_R16_UINT, 0);
context->Draw(3, 0);
rtvs[0] = nullptr;
context->OMSetRenderTargets(1, rtvs, nullptr);
}
