protected override void Draw(GameTimer gt)
{
CommandAllocator cmdListAlloc = CurrFrameResource.CmdListAlloc;
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
cmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(cmdListAlloc, _opaquePso);
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(CurrentBackBufferView, Color.LightSteelBlue);
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
CommandList.SetGraphicsRootSignature(_rootSignature);
Resource passCB = CurrFrameResource.PassCB.Resource;
CommandList.SetGraphicsRootConstantBufferView(2, passCB.GPUVirtualAddress);
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Opaque]);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.RenderTarget, ResourceStates.Present);
// Done recording commands.
CommandList.Close();
// Add the command list to the queue for execution.
CommandQueue.ExecuteCommandList(CommandList);
// Present the buffer to the screen. Presenting will automatically swap the back and front buffers.
SwapChain.Present(0, PresentFlags.None);
// Advance the fence value to mark commands up to this fence point.
CurrFrameResource.Fence = ++CurrentFence;
// Add an instruction to the command queue to set a new fence point.
// Because we are on the GPU timeline, the new fence point won't be
// set until the GPU finishes processing all the commands prior to this Signal().
CommandQueue.Signal(Fence, CurrentFence);
}
protected override void Draw(GameTimer gt)
{
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
DirectCmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(DirectCmdListAlloc, null);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Set the viewport and scissor rect. This needs to be reset whenever the command list is reset.
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle); // TODO: API suggestion: SetScissorRectangle overload similar to SetViewport
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(CurrentBackBufferView, Color.LightSteelBlue);
// TODO: API suggestion: simplify flags naming to ClearFlags.Depth|Stencil
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.RenderTarget, ResourceStates.Present);
// Done recording commands.
CommandList.Close();
// Add the command list to the queue for execution.
CommandQueue.ExecuteCommandList(CommandList);
// Present the buffer to the screen. Presenting will automatically swap the back and front buffers.
// Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/bb174576(v=vs.85).aspx
SwapChain.Present(0, PresentFlags.None);
// Wait until frame commands are complete. This waiting is inefficient and is
// done for simplicity. Later we will show how to organize our rendering code
// so we do not have to wait per frame.
FlushCommandQueue();
}
public override void BeginDraw()
{
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
DirectCmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(DirectCmdListAlloc, null);
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(CurrentBackBufferView, Color.DarkBlue);
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
// TODO: API suggestion: rename descriptorHeapsOut to descriptorHeaps;
// TODO: Add an overload for a setting a single SetDescriptorHeap?
// TODO: Make requiring explicit length optional.
// CommandList.SetDescriptorHeaps(_descriptorHeaps.Length, _descriptorHeaps);
// CommandList.SetGraphicsRootSignature(_rootSignature);
// CommandList.SetVertexBuffer(0, _boxGeo.VertexBufferView);
// CommandList.SetIndexBuffer(_boxGeo.IndexBufferView);
// CommandList.PrimitiveTopology = PrimitiveTopology.TriangleList;
//CommandList.SetGraphicsRootDescriptorTable(0, _cbvHeap.GPUDescriptorHandleForHeapStart);
//CommandList.DrawIndexedInstanced(_boxGeo.IndexCount, 1, 0, 0, 0);
}
private void DrawSceneToCubeMap()
{
CommandList.SetViewport(_dynamicCubeMap.Viewport);
CommandList.SetScissorRectangles(_dynamicCubeMap.ScissorRectangle);
// Change to RENDER_TARGET.
CommandList.ResourceBarrierTransition(_dynamicCubeMap.Resource, ResourceStates.GenericRead, ResourceStates.RenderTarget);
int passCBByteSize = D3DUtil.CalcConstantBufferByteSize <PassConstants>();
// For each cube map face.
for (int i = 0; i < 6; i++)
{
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(_dynamicCubeMap.Rtvs[i], Color.LightSteelBlue);
CommandList.ClearDepthStencilView(_cubeDSV, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(_dynamicCubeMap.Rtvs[i], _cubeDSV);
// Bind the pass constant buffer for this cube map face so we use
// the right view/proj matrix for this cube face.
Resource passCB = CurrFrameResource.PassCB.Resource;
long passCBAddress = passCB.GPUVirtualAddress + (1 + i) * passCBByteSize;
CommandList.SetGraphicsRootConstantBufferView(1, passCBAddress);
CommandList.PipelineState = _psos["opaque"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Opaque]);
CommandList.PipelineState = _psos["sky"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Sky]);
}
// Change back to GENERIC_READ so we can read the texture in a shader.
CommandList.ResourceBarrierTransition(_dynamicCubeMap.Resource, ResourceStates.RenderTarget, ResourceStates.GenericRead);
}
protected override void Draw(GameTimer gt)
{
CommandAllocator cmdListAlloc = CurrFrameResource.CmdListAlloc;
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
cmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(cmdListAlloc, _psos["opaque"]);
CommandList.SetDescriptorHeaps(_descriptorHeaps.Length, _descriptorHeaps);
UpdateWavesGPU(gt);
CommandList.PipelineState = _psos["opaque"];
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle);
// Change offscreen texture to be used as a a render target output.
CommandList.ResourceBarrierTransition(_offscreenRT.Resource, ResourceStates.GenericRead, ResourceStates.RenderTarget);
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(_offscreenRT.Rtv, new Color(_mainPassCB.FogColor));
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(_offscreenRT.Rtv, DepthStencilView);
CommandList.SetGraphicsRootSignature(_rootSignature);
Resource passCB = CurrFrameResource.PassCB.Resource;
CommandList.SetGraphicsRootConstantBufferView(2, passCB.GPUVirtualAddress);
CommandList.SetGraphicsRootDescriptorTable(4, _waves.DisplacementMap);
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Opaque]);
CommandList.PipelineState = _psos["alphaTested"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.AlphaTested]);
CommandList.PipelineState = _psos["transparent"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Transparent]);
CommandList.PipelineState = _psos["wavesRender"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.GpuWaves]);
// Change offscreen texture to be used as an input.
CommandList.ResourceBarrierTransition(_offscreenRT.Resource, ResourceStates.RenderTarget, ResourceStates.GenericRead);
_sobelFilter.Execute(CommandList, _postProcessRootSignature, _psos["sobel"], _offscreenRT.Srv);
//
// Switching back to back buffer rendering.
//
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
CommandList.SetGraphicsRootSignature(_postProcessRootSignature);
CommandList.PipelineState = _psos["composite"];
CommandList.SetGraphicsRootDescriptorTable(0, _offscreenRT.Srv);
CommandList.SetGraphicsRootDescriptorTable(1, _sobelFilter.OutputSrv);
DrawFullscreenQuad(CommandList);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.RenderTarget, ResourceStates.Present);
// Done recording commands.
CommandList.Close();
// Add the command list to the queue for execution.
CommandQueue.ExecuteCommandList(CommandList);
// Present the buffer to the screen. Presenting will automatically swap the back and front buffers.
SwapChain.Present(0, PresentFlags.None);
// Advance the fence value to mark commands up to this fence point.
CurrFrameResource.Fence = ++CurrentFence;
// Add an instruction to the command queue to set a new fence point.
// Because we are on the GPU timeline, the new fence point won't be
// set until the GPU finishes processing all the commands prior to this Signal().
CommandQueue.Signal(Fence, CurrentFence);
}
protected override void Draw(GameTimer gt)
{
CommandAllocator cmdListAlloc = CurrFrameResource.CmdListAlloc;
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
cmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(cmdListAlloc, _psos["opaque"]);
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(CurrentBackBufferView, Color.LightSteelBlue);
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
CommandList.SetDescriptorHeaps(_descriptorHeaps.Length, _descriptorHeaps);
CommandList.SetGraphicsRootSignature(_rootSignature);
Resource passCB = CurrFrameResource.PassCB.Resource;
CommandList.SetGraphicsRootConstantBufferView(1, passCB.GPUVirtualAddress);
// Bind all the materials used in this scene. For structured buffers, we can bypass the heap and
// set as a root descriptor.
Resource matBuffer = CurrFrameResource.MaterialBuffer.Resource;
CommandList.SetGraphicsRootShaderResourceView(2, matBuffer.GPUVirtualAddress);
// Bind the sky cube map. For our demos, we just use one "world" cube map representing the environment
// from far away, so all objects will use the same cube map and we only need to set it once per-frame.
// If we wanted to use "local" cube maps, we would have to change them per-object, or dynamically
// index into an array of cube maps.
GpuDescriptorHandle skyTexDescriptor = _srvDescriptorHeap.GPUDescriptorHandleForHeapStart;
skyTexDescriptor += _skyTexHeapIndex * CbvSrvUavDescriptorSize;
CommandList.SetGraphicsRootDescriptorTable(3, skyTexDescriptor);
// Bind all the textures used in this scene. Observe
// that we only have to specify the first descriptor in the table.
// The root signature knows how many descriptors are expected in the table.
CommandList.SetGraphicsRootDescriptorTable(4, _srvDescriptorHeap.GPUDescriptorHandleForHeapStart);
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Opaque]);
CommandList.PipelineState = _psos["sky"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Sky]);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.RenderTarget, ResourceStates.Present);
// Done recording commands.
CommandList.Close();
// Add the command list to the queue for execution.
CommandQueue.ExecuteCommandList(CommandList);
// Present the buffer to the screen. Presenting will automatically swap the back and front buffers.
SwapChain.Present(0, PresentFlags.None);
// Advance the fence value to mark commands up to this fence point.
CurrFrameResource.Fence = ++CurrentFence;
// Add an instruction to the command queue to set a new fence point.
// Because we are on the GPU timeline, the new fence point won't be
// set until the GPU finishes processing all the commands prior to this Signal().
CommandQueue.Signal(Fence, CurrentFence);
}
protected override void Draw(GameTimer gt)
{
CommandAllocator cmdListAlloc = CurrFrameResource.CmdListAlloc;
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
cmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(cmdListAlloc, _psos["opaque"]);
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(CurrentBackBufferView, new Color(_mainPassCB.FogColor));
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
CommandList.SetDescriptorHeaps(_descriptorHeaps.Length, _descriptorHeaps);
CommandList.SetGraphicsRootSignature(_rootSignature);
// Bind per-pass constant buffer. We only need to do this once per-pass.
Resource passCB = CurrFrameResource.PassCB.Resource;
CommandList.SetGraphicsRootConstantBufferView(2, passCB.GPUVirtualAddress);
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Opaque]);
CommandList.PipelineState = _psos["alphaTested"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.AlphaTested]);
CommandList.PipelineState = _psos["transparent"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Transparent]);
_blurFilter.Execute(CommandList, _postProcessRootSignature, _psos["horzBlur"], _psos["vertBlur"], CurrentBackBuffer, 4);
// Prepare to copy blurred output to the back buffer.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.CopySource, ResourceStates.CopyDestination);
CommandList.CopyResource(CurrentBackBuffer, _blurFilter.Output);
// Transition to PRESENT state.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.CopyDestination, ResourceStates.Present);
// Done recording commands.
CommandList.Close();
// Add the command list to the queue for execution.
CommandQueue.ExecuteCommandList(CommandList);
// Present the buffer to the screen. Presenting will automatically swap the back and front buffers.
SwapChain.Present(0, PresentFlags.None);
// Advance the fence value to mark commands up to this fence point.
CurrFrameResource.Fence = ++CurrentFence;
// Add an instruction to the command queue to set a new fence point.
// Because we are on the GPU timeline, the new fence point won't be
// set until the GPU finishes processing all the commands prior to this Signal().
CommandQueue.Signal(Fence, CurrentFence);
}
protected override void Draw(GameTimer gt)
{
CommandAllocator cmdListAlloc = CurrFrameResource.CmdListAlloc;
// Reuse the memory associated with command recording.
// We can only reset when the associated command lists have finished execution on the GPU.
cmdListAlloc.Reset();
// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
// Reusing the command list reuses memory.
CommandList.Reset(cmdListAlloc, _psos["opaque"]);
CommandList.SetViewport(Viewport);
CommandList.SetScissorRectangles(ScissorRectangle);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.Present, ResourceStates.RenderTarget);
// Clear the back buffer and depth buffer.
CommandList.ClearRenderTargetView(CurrentBackBufferView, new Color(_mainPassCB.FogColor));
CommandList.ClearDepthStencilView(DepthStencilView, ClearFlags.FlagsDepth | ClearFlags.FlagsStencil, 1.0f, 0);
// Specify the buffers we are going to render to.
CommandList.SetRenderTargets(CurrentBackBufferView, DepthStencilView);
CommandList.SetDescriptorHeaps(_descriptorHeaps.Length, _descriptorHeaps);
CommandList.SetGraphicsRootSignature(_rootSignature);
var passCBByteSize = D3DUtil.CalcConstantBufferByteSize <PassConstants>();
// Draw opaque items--floors, walls, skull.
Resource passCB = CurrFrameResource.PassCB.Resource;
CommandList.SetGraphicsRootConstantBufferView(2, passCB.GPUVirtualAddress);
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Opaque]);
// Mark the visible mirror pixels in the stencil buffer with the value 1
CommandList.StencilReference = 1;
CommandList.PipelineState = _psos["markStencilMirrors"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Mirrors]);
// Draw the reflection into the mirror only (only for pixels where the stencil buffer is 1).
// Note that we must supply a different per-pass constant buffer--one with the lights reflected.
CommandList.SetGraphicsRootConstantBufferView(2, passCB.GPUVirtualAddress + passCBByteSize);
CommandList.PipelineState = _psos["drawStencilReflections"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Reflected]);
// Restore main pass constants and stencil ref.
CommandList.SetGraphicsRootConstantBufferView(2, passCB.GPUVirtualAddress);
CommandList.StencilReference = 0;
// Draw mirror with transparency so reflection blends through.
CommandList.PipelineState = _psos["transparent"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Transparent]);
// Draw shadows
CommandList.PipelineState = _psos["shadow"];
DrawRenderItems(CommandList, _ritemLayers[RenderLayer.Shadow]);
// Indicate a state transition on the resource usage.
CommandList.ResourceBarrierTransition(CurrentBackBuffer, ResourceStates.RenderTarget, ResourceStates.Present);
// Done recording commands.
CommandList.Close();
// Add the command list to the queue for execution.
CommandQueue.ExecuteCommandList(CommandList);
// Present the buffer to the screen. Presenting will automatically swap the back and front buffers.
SwapChain.Present(0, PresentFlags.None);
// Advance the fence value to mark commands up to this fence point.
CurrFrameResource.Fence = ++CurrentFence;
// Add an instruction to the command queue to set a new fence point.
// Because we are on the GPU timeline, the new fence point won't be
// set until the GPU finishes processing all the commands prior to this Signal().
CommandQueue.Signal(Fence, CurrentFence);
}