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); }