DX12ClothSimulation.cpp

#include "stdafx.h"
#include "DX12ClothSimulation.h"

DX12ClothSimulation::DX12ClothSimulation( UINT width, UINT height, std::wstring name ) :
	DX12Framework( width, height, name ),
	m_frameIndex( 0 ),
	m_viewport(),
	m_scissorRect(),
	m_rtvDescriptorSize( 0 ),
	m_windowVisible( true ),
	m_resizeResources( true )
{
	ZeroMemory( m_fenceValues, sizeof( m_fenceValues ) );
}

void DX12ClothSimulation::OnInit()
{
	LoadPipeline();
	LoadAssets();
}

// Load the rendering pipeline dependencies.
void DX12ClothSimulation::LoadPipeline()
{
#ifdef _DEBUG
	// Enable the D3D12 debug layer.
{
	ComPtr<ID3D12Debug> debugController;
	if ( SUCCEEDED( D3D12GetDebugInterface( IID_PPV_ARGS( &debugController ) ) ) )
	{
		debugController->EnableDebugLayer();
	}
}
#endif

ComPtr<IDXGIFactory4> factory;
ThrowIfFailed( CreateDXGIFactory1( IID_PPV_ARGS( &factory ) ) );

if ( m_useWarpDevice )
{
	ComPtr<IDXGIAdapter> warpAdapter;
	ThrowIfFailed( factory->EnumWarpAdapter( IID_PPV_ARGS( &warpAdapter ) ) );

	ThrowIfFailed( D3D12CreateDevice(
		warpAdapter.Get(),
		D3D_FEATURE_LEVEL_11_0,
		IID_PPV_ARGS( &m_device )
		) );
}
else
{
	ComPtr<IDXGIAdapter1> hardwareAdapter;
	GetHardwareAdapter( factory.Get(), &hardwareAdapter );

	ThrowIfFailed( D3D12CreateDevice(
		hardwareAdapter.Get(),
		D3D_FEATURE_LEVEL_11_0,
		IID_PPV_ARGS( &m_device )
		) );
}

// Describe and create the command queue.
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;

ThrowIfFailed( m_device->CreateCommandQueue( &queueDesc, IID_PPV_ARGS( &m_commandQueue ) ) );

// Describe and create the swap chain.
DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.BufferDesc.Width = m_width;
swapChainDesc.BufferDesc.Height = m_height;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.OutputWindow = m_hwnd;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.Windowed = TRUE;

ComPtr<IDXGISwapChain> swapChain;
ThrowIfFailed( factory->CreateSwapChain(
	m_commandQueue.Get(),		// Swap chain needs the queue so that it can force a flush on it.
	&swapChainDesc,
	&swapChain
	) );

ThrowIfFailed( swapChain.As( &m_swapChain ) );

m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();

// Create descriptor heaps.
{
	// Describe and create a render target view (RTV) descriptor heap.
	D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
	rtvHeapDesc.NumDescriptors = FrameCount;
	rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
	rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
	ThrowIfFailed( m_device->CreateDescriptorHeap( &rtvHeapDesc, IID_PPV_ARGS( &m_rtvHeap ) ) );

	m_rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize( D3D12_DESCRIPTOR_HEAP_TYPE_RTV );
}

// Create a command allocator for each frame.
for ( UINT n = 0; n < FrameCount; n++ )
{
	ThrowIfFailed( m_device->CreateCommandAllocator( D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS( &m_commandAllocators[n] ) ) );
}
}

// Load the sample assets.
void DX12ClothSimulation::LoadAssets()
{
	// Create an empty root signature.
	{
		CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
		rootSignatureDesc.Init( 0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT );

		ComPtr<ID3DBlob> signature;
		ComPtr<ID3DBlob> error;
		ThrowIfFailed( D3D12SerializeRootSignature( &rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error ) );
		ThrowIfFailed( m_device->CreateRootSignature( 0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS( &m_rootSignature ) ) );
	}

	// Create the pipeline state, which includes compiling and loading shaders.
	{
		ComPtr<ID3DBlob> vertexShader;
		ComPtr<ID3DBlob> pixelShader;

#ifdef _DEBUG
		// Enable better shader debugging with the graphics debugging tools.
		UINT compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
#else
		UINT compileFlags = 0;
#endif

		ThrowIfFailed( D3DCompileFromFile( GetAssetFullPath( L"shaders.hlsl" ).c_str(), nullptr, nullptr, "VSMain", "vs_5_0", compileFlags, 0, &vertexShader, nullptr ) );
		ThrowIfFailed( D3DCompileFromFile( GetAssetFullPath( L"shaders.hlsl" ).c_str(), nullptr, nullptr, "PSMain", "ps_5_0", compileFlags, 0, &pixelShader, nullptr ) );

		// Define the vertex input layout.
		D3D12_INPUT_ELEMENT_DESC inputElementDescs[] =
		{
			{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
			{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
		};

		// Describe and create the graphics pipeline state object (PSO).
		D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
		psoDesc.InputLayout = { inputElementDescs, _countof( inputElementDescs ) };
		psoDesc.pRootSignature = m_rootSignature.Get();
		psoDesc.VS = { reinterpret_cast<UINT8*>( vertexShader->GetBufferPointer() ), vertexShader->GetBufferSize() };
		psoDesc.PS = { reinterpret_cast<UINT8*>( pixelShader->GetBufferPointer() ), pixelShader->GetBufferSize() };
		psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC( D3D12_DEFAULT );
		psoDesc.BlendState = CD3DX12_BLEND_DESC( D3D12_DEFAULT );
		psoDesc.DepthStencilState.DepthEnable = FALSE;
		psoDesc.DepthStencilState.StencilEnable = FALSE;
		psoDesc.SampleMask = UINT_MAX;
		psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
		psoDesc.NumRenderTargets = 1;
		psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
		psoDesc.SampleDesc.Count = 1;
		ThrowIfFailed( m_device->CreateGraphicsPipelineState( &psoDesc, IID_PPV_ARGS( &m_pipelineState ) ) );
	}

	// Create the command list.
	ThrowIfFailed( m_device->CreateCommandList( 0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocators[m_frameIndex].Get(), m_pipelineState.Get(), IID_PPV_ARGS( &m_commandList ) ) );

	LoadSizeDependentResources();

	// Close the command list and execute it to begin the vertex buffer copy into
	// the default heap.
	ThrowIfFailed( m_commandList->Close() );
	ID3D12CommandList* ppCommandLists[] = { m_commandList.Get() };
	m_commandQueue->ExecuteCommandLists( _countof( ppCommandLists ), ppCommandLists );

	// Create synchronization objects and wait until assets have been uploaded to the GPU.
	{
		ThrowIfFailed( m_device->CreateFence( m_fenceValues[m_frameIndex], D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS( &m_fence ) ) );
		m_fenceValues[m_frameIndex]++;

		// Create an event handle to use for frame synchronization.
		m_fenceEvent = CreateEvent( nullptr, FALSE, FALSE, nullptr );
		if ( m_fenceEvent == nullptr )
		{
			ThrowIfFailed( HRESULT_FROM_WIN32( GetLastError() ) );
		}

		// Wait for the command list to execute; we are reusing the same command 
		// list in our main loop but for now, we just want to wait for setup to 
		// complete before continuing.
		WaitForGpu();
	}
}

void DX12ClothSimulation::LoadSizeDependentResources()
{
	m_viewport.Width = static_cast<float>( m_width );
	m_viewport.Height = static_cast<float>( m_height );
	m_viewport.MaxDepth = 1.0f;

	m_scissorRect.right = static_cast<LONG>( m_width );
	m_scissorRect.bottom = static_cast<LONG>( m_height );

	// Create frame resources.
	{
		CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle( m_rtvHeap->GetCPUDescriptorHandleForHeapStart() );

		// Create a RTV for each frame.
		for ( UINT n = 0; n < FrameCount; n++ )
		{
			ThrowIfFailed( m_swapChain->GetBuffer( n, IID_PPV_ARGS( &m_renderTargets[n] ) ) );
			m_device->CreateRenderTargetView( m_renderTargets[n].Get(), nullptr, rtvHandle );
			rtvHandle.Offset( 1, m_rtvDescriptorSize );
		}
	}

	// Create/update the vertex buffer. When updating the vertex buffer it is important
	// to ensure that the GPU is finished using the resource before it is released.
	// The OnSizeChanged method waits for the GPU to be idle before this method is
	// called.
	{
		// Define the geometry for a triangle that stays the same size regardless
		// of the window size. This is not the recommended way to transform vertices.
		// The same effect could be achieved by using constant buffers and
		// transforming a static set of vertices in the vertex shader, but this
		// sample merely demonstrates modifying a resource that is tied to the render
		// target size.
		// Other apps might also resize intermediate render targets or depth stencils
		// at this time.
		float x = TriangleWidth / m_viewport.Width;
		float y = TriangleWidth / m_viewport.Height;

		Vertex triangleVertices[] =
		{
			{ { 0.0f, y, 0.0f },{ 1.0f, 0.0f, 0.0f, 1.0f } },
			{ { x, -y, 0.0f },{ 0.0f, 1.0f, 0.0f, 1.0f } },
			{ { -x, -y, 0.0f },{ 0.0f, 0.0f, 1.0f, 1.0f } }
		};

		const UINT vertexBufferSize = sizeof( triangleVertices );

		ThrowIfFailed( m_device->CreateCommittedResource(
			&CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_DEFAULT ),
			D3D12_HEAP_FLAG_NONE,
			&CD3DX12_RESOURCE_DESC::Buffer( vertexBufferSize ),
			D3D12_RESOURCE_STATE_COPY_DEST,
			nullptr,
			IID_PPV_ARGS( &m_vertexBuffer ) ) );

		ThrowIfFailed( m_device->CreateCommittedResource(
			&CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_UPLOAD ),
			D3D12_HEAP_FLAG_NONE,
			&CD3DX12_RESOURCE_DESC::Buffer( vertexBufferSize ),
			D3D12_RESOURCE_STATE_GENERIC_READ,
			nullptr,
			IID_PPV_ARGS( &m_vertexBufferUpload ) ) );

		// Copy data to the intermediate upload heap and then schedule a copy 
		// from the upload heap to the vertex buffer.
		UINT8* pVertexDataBegin;
		ThrowIfFailed( m_vertexBufferUpload->Map( 0, &CD3DX12_RANGE( 0, vertexBufferSize ), reinterpret_cast<void**>( &pVertexDataBegin ) ) );
		memcpy( pVertexDataBegin, triangleVertices, sizeof( triangleVertices ) );
		m_vertexBufferUpload->Unmap( 0, nullptr );

		m_commandList->CopyBufferRegion( m_vertexBuffer.Get(), 0, m_vertexBufferUpload.Get(), 0, vertexBufferSize );
		m_commandList->ResourceBarrier( 1, &CD3DX12_RESOURCE_BARRIER::Transition( m_vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER ) );

		// Initialize the vertex buffer views.
		m_vertexBufferView.BufferLocation = m_vertexBuffer->GetGPUVirtualAddress();
		m_vertexBufferView.StrideInBytes = sizeof( Vertex );
		m_vertexBufferView.SizeInBytes = vertexBufferSize;
	}

	m_resizeResources = false;
}

// Update frame-based values.
void DX12ClothSimulation::OnUpdate()
{
}

// Render the scene.
void DX12ClothSimulation::OnRender()
{
	if ( m_windowVisible )
	{
		// Record all the commands we need to render the scene into the command list.
		PopulateCommandList();

		// Execute the command list.
		ID3D12CommandList* ppCommandLists[] = { m_commandList.Get() };
		m_commandQueue->ExecuteCommandLists( _countof( ppCommandLists ), ppCommandLists );

		// Present the frame.
		ThrowIfFailed( m_swapChain->Present( 0, 0 ) );

		MoveToNextFrame();
	}
}

void DX12ClothSimulation::OnSizeChanged( UINT width, UINT height, bool minimized )
{
	// Determine if the swap buffers and other resources need to be resized or not.
	if ( ( width != m_width || height != m_height ) && !minimized )
	{
		// Flush all current GPU commands.
		WaitForGpu();

		// Release the resources holding references to the swap chain (requirement of
		// IDXGISwapChain::ResizeBuffers) and reset the frame fence values to the
		// current fence value.
		for ( UINT n = 0; n < FrameCount; n++ )
		{
			m_renderTargets[n].Reset();
			m_fenceValues[n] = m_fenceValues[m_frameIndex];
		}

		// Resize the swap chain to the desired dimensions.
		DXGI_SWAP_CHAIN_DESC desc = {};
		m_swapChain->GetDesc( &desc );
		ThrowIfFailed( m_swapChain->ResizeBuffers( FrameCount, width, height, desc.BufferDesc.Format, desc.Flags ) );

		// Reset the frame index to the current back buffer index.
		m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();

		// Update the width, height, and aspect ratio member variables.
		UpdateForSizeChange( width, height );

		m_resizeResources = true;
	}

	m_windowVisible = !minimized;
}

void DX12ClothSimulation::OnDestroy()
{
	// Wait for the GPU to be done with all resources.
	WaitForGpu();

	// Fullscreen state should always be false before exiting the app.
	ThrowIfFailed( m_swapChain->SetFullscreenState( FALSE, nullptr ) );

	CloseHandle( m_fenceEvent );
}

bool DX12ClothSimulation::OnEvent( MSG msg )
{
	switch ( msg.message )
	{
	case WM_KEYDOWN:
		// Instrument the Space Bar to toggle between fullscreen states.
		// The window message loop callback will receive a WM_SIZE message once the
		// window is in the fullscreen state. At that point, the IDXGISwapChain should
		// be resized to match the new window size.
		//
		// NOTE: ALT+Enter will perform a similar operation; the code below is not
		// required to enable that key combination.
		if ( msg.wParam == VK_SPACE )
		{
			BOOL fullscreenState;
			ThrowIfFailed( m_swapChain->GetFullscreenState( &fullscreenState, nullptr ) );
			if ( FAILED( m_swapChain->SetFullscreenState( !fullscreenState, nullptr ) ) )
			{
				// Transitions to fullscreen mode can fail when running apps over
				// terminal services or for some other unexpected reason.  Consider
				// notifying the user in some way when this happens.
				OutputDebugString( L"Fullscreen transition failed" );
				assert( false );
			}
		}
		break;
	}
	return false;
}

// Fill the command list with all the render commands and dependent state.
void DX12ClothSimulation::PopulateCommandList()
{
	// Command list allocators can only be reset when the associated 
	// command lists have finished execution on the GPU; apps should use 
	// fences to determine GPU execution progress.
	ThrowIfFailed( m_commandAllocators[m_frameIndex]->Reset() );

	// However, when ExecuteCommandList() is called on a particular command 
	// list, that command list can then be reset at any time and must be before 
	// re-recording.
	ThrowIfFailed( m_commandList->Reset( m_commandAllocators[m_frameIndex].Get(), m_pipelineState.Get() ) );

	if ( m_resizeResources )
	{
		// Reload resources that depend on the size of the swap chain.
		LoadSizeDependentResources();
	}

	// Set necessary state.
	m_commandList->SetGraphicsRootSignature( m_rootSignature.Get() );

	m_commandList->IASetPrimitiveTopology( D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
	m_commandList->RSSetViewports( 1, &m_viewport );
	m_commandList->RSSetScissorRects( 1, &m_scissorRect );

	// Indicate that the back buffer will be used as a render target.
	m_commandList->ResourceBarrier( 1, &CD3DX12_RESOURCE_BARRIER::Transition( m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET ) );

	CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle( m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), m_frameIndex, m_rtvDescriptorSize );
	m_commandList->OMSetRenderTargets( 1, &rtvHandle, FALSE, nullptr );

	// Record commands.
	const float clearColor[] = { 0.0f, 0.2f, 0.4f, 1.0f };
	m_commandList->ClearRenderTargetView( rtvHandle, clearColor, 0, nullptr );
	m_commandList->IASetPrimitiveTopology( D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
	m_commandList->IASetVertexBuffers( 0, 1, &m_vertexBufferView );
	m_commandList->DrawInstanced( 3, 1, 0, 0 );

	// Indicate that the back buffer will now be used to present.
	m_commandList->ResourceBarrier( 1, &CD3DX12_RESOURCE_BARRIER::Transition( m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT ) );

	ThrowIfFailed( m_commandList->Close() );
}

// Wait for pending GPU work to complete.
void DX12ClothSimulation::WaitForGpu()
{
	// Schedule a Signal command in the queue.
	ThrowIfFailed( m_commandQueue->Signal( m_fence.Get(), m_fenceValues[m_frameIndex] ) );

	// Wait until the fence has been processed.
	ThrowIfFailed( m_fence->SetEventOnCompletion( m_fenceValues[m_frameIndex], m_fenceEvent ) );
	WaitForSingleObjectEx( m_fenceEvent, INFINITE, FALSE );

	// Increment the fence value for the current frame.
	m_fenceValues[m_frameIndex]++;
}

// Prepare to render the next frame.
void DX12ClothSimulation::MoveToNextFrame()
{
	// Schedule a Signal command in the queue.
	const UINT64 currentFenceValue = m_fenceValues[m_frameIndex];
	ThrowIfFailed( m_commandQueue->Signal( m_fence.Get(), currentFenceValue ) );

	// Update the frame index.
	m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();

	// If the next frame is not ready to be rendered yet, wait until it is ready.
	if ( m_fence->GetCompletedValue() < m_fenceValues[m_frameIndex] )
	{
		ThrowIfFailed( m_fence->SetEventOnCompletion( m_fenceValues[m_frameIndex], m_fenceEvent ) );
		WaitForSingleObjectEx( m_fenceEvent, INFINITE, FALSE );
	}

	// Set the fence value for the next frame.
	m_fenceValues[m_frameIndex] = currentFenceValue + 1;
}