227 lines
9.1 KiB
C++
227 lines
9.1 KiB
C++
/*
|
|
* Copyright (c) 2016-2021, NVIDIA CORPORATION. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* SPDX-FileCopyrightText: Copyright (c) 2016-2021 NVIDIA CORPORATION
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
|
|
#include "base_dx12.hpp"
|
|
#include "error_dx12.hpp"
|
|
#include <dxgi1_5.h>
|
|
|
|
#include <algorithm>
|
|
|
|
namespace nvdx12 {
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
D3D12_RESOURCE_BARRIER transitionBarrier(_In_ ID3D12Resource* pResource,
|
|
D3D12_RESOURCE_STATES stateBefore,
|
|
D3D12_RESOURCE_STATES stateAfter,
|
|
UINT subresource /*= D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES*/,
|
|
D3D12_RESOURCE_BARRIER_FLAGS flags /*= D3D12_RESOURCE_BARRIER_FLAG_NONE*/)
|
|
{
|
|
D3D12_RESOURCE_BARRIER result;
|
|
ZeroMemory(&result, sizeof(result));
|
|
result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
|
result.Flags = flags;
|
|
result.Transition.pResource = pResource;
|
|
result.Transition.StateBefore = stateBefore;
|
|
result.Transition.StateAfter = stateAfter;
|
|
result.Transition.Subresource = subresource;
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
ID3D12Device* DeviceUtils::createDevice(IDXGIFactory5* factory)
|
|
{
|
|
HRESULT hr = 0;
|
|
IDXGIAdapter1* hardwareAdapter = nullptr;
|
|
|
|
// Look for an actual GPU. This sample does not support WARP (software)
|
|
// devices.
|
|
for(UINT adapterIndex = 0; DXGI_ERROR_NOT_FOUND != factory->EnumAdapters1(adapterIndex, &hardwareAdapter); ++adapterIndex)
|
|
{
|
|
DXGI_ADAPTER_DESC1 desc;
|
|
hardwareAdapter->GetDesc1(&desc);
|
|
|
|
if(desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)
|
|
{
|
|
// Don't select the Basic Render Driver adapter.
|
|
continue;
|
|
}
|
|
|
|
// Check to see if the adapter supports Direct3D 12, but don't create the
|
|
// actual device yet.
|
|
if(SUCCEEDED(D3D12CreateDevice(hardwareAdapter, D3D_FEATURE_LEVEL_12_0, _uuidof(ID3D12Device), nullptr)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(hardwareAdapter == nullptr)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
DXGI_ADAPTER_DESC1 adapterDesc;
|
|
hardwareAdapter->GetDesc1(&adapterDesc);
|
|
printf("Running on DXGI Adapter %S\n", adapterDesc.Description);
|
|
|
|
// Create the DX12 device on the selected GPU
|
|
hr = D3D12CreateDevice(hardwareAdapter, D3D_FEATURE_LEVEL_12_0, IID_PPV_ARGS(&m_device));
|
|
if(FAILED(hr))
|
|
{
|
|
return nullptr;
|
|
}
|
|
hardwareAdapter->Release();
|
|
return m_device;
|
|
}
|
|
|
|
D3D12_GRAPHICS_PIPELINE_STATE_DESC DeviceUtils::createDefaultPipelineDesc(D3D12_INPUT_ELEMENT_DESC* inputDescs,
|
|
UINT inputCount,
|
|
ID3D12RootSignature* rootSignature,
|
|
void* vertexShaderPointer,
|
|
size_t vertexShaderSize,
|
|
void* pixelShaderPointer,
|
|
size_t pixelShaderSize)
|
|
{
|
|
|
|
// Describe and create the graphics pipeline state object (PSO).
|
|
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
|
|
psoDesc.InputLayout = {inputDescs, inputCount};
|
|
psoDesc.pRootSignature = rootSignature;
|
|
|
|
psoDesc.VS = {vertexShaderPointer, vertexShaderSize};
|
|
psoDesc.PS = {pixelShaderPointer, pixelShaderSize};
|
|
|
|
psoDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
|
|
psoDesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
|
|
psoDesc.RasterizerState.FrontCounterClockwise = TRUE;
|
|
psoDesc.RasterizerState.DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
|
|
psoDesc.RasterizerState.DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
|
|
psoDesc.RasterizerState.SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
|
|
psoDesc.RasterizerState.DepthClipEnable = TRUE;
|
|
psoDesc.RasterizerState.MultisampleEnable = FALSE;
|
|
psoDesc.RasterizerState.AntialiasedLineEnable = FALSE;
|
|
psoDesc.RasterizerState.ForcedSampleCount = 0;
|
|
psoDesc.RasterizerState.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
|
|
|
|
psoDesc.BlendState.AlphaToCoverageEnable = FALSE;
|
|
psoDesc.BlendState.IndependentBlendEnable = FALSE;
|
|
|
|
const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc = {
|
|
FALSE,
|
|
FALSE,
|
|
D3D12_BLEND_ONE,
|
|
D3D12_BLEND_ZERO,
|
|
D3D12_BLEND_OP_ADD,
|
|
D3D12_BLEND_ONE,
|
|
D3D12_BLEND_ZERO,
|
|
D3D12_BLEND_OP_ADD,
|
|
D3D12_LOGIC_OP_NOOP,
|
|
D3D12_COLOR_WRITE_ENABLE_ALL,
|
|
};
|
|
for(UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
|
|
psoDesc.BlendState.RenderTarget[i] = defaultRenderTargetBlendDesc;
|
|
|
|
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;
|
|
|
|
return psoDesc;
|
|
}
|
|
|
|
void DeviceUtils::addDepthStencilTestToPipeline(D3D12_GRAPHICS_PIPELINE_STATE_DESC& psoDesc,
|
|
bool enableDepth /*= true*/,
|
|
bool enableStencil /*= false*/,
|
|
DXGI_FORMAT format /*= DXGI_FORMAT_D32_FLOAT*/)
|
|
{
|
|
D3D12_DEPTH_STENCIL_DESC depthStencilState;
|
|
depthStencilState.DepthEnable = enableDepth ? TRUE : FALSE;
|
|
depthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
|
|
depthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS;
|
|
depthStencilState.StencilEnable = enableStencil ? TRUE : FALSE;
|
|
depthStencilState.StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
|
|
depthStencilState.StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
|
|
const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = {D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP,
|
|
D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS};
|
|
depthStencilState.FrontFace = defaultStencilOp;
|
|
depthStencilState.BackFace = defaultStencilOp;
|
|
|
|
psoDesc.DepthStencilState = depthStencilState;
|
|
psoDesc.DSVFormat = format;
|
|
}
|
|
|
|
ID3D12Resource* DeviceUtils::createBuffer(uint64_t size, D3D12_RESOURCE_FLAGS flags, D3D12_RESOURCE_STATES initState, const D3D12_HEAP_PROPERTIES& heapProps)
|
|
{
|
|
D3D12_RESOURCE_DESC bufDesc = {};
|
|
bufDesc.Alignment = 0;
|
|
bufDesc.DepthOrArraySize = 1;
|
|
bufDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
|
|
bufDesc.Flags = flags;
|
|
bufDesc.Format = DXGI_FORMAT_UNKNOWN;
|
|
bufDesc.Height = 1;
|
|
bufDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
|
|
bufDesc.MipLevels = 1;
|
|
bufDesc.SampleDesc.Count = 1;
|
|
bufDesc.SampleDesc.Quality = 0;
|
|
bufDesc.Width = size;
|
|
|
|
ID3D12Resource* pBuffer;
|
|
HRESULT hr = 0;
|
|
hr = m_device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &bufDesc, initState, nullptr, IID_PPV_ARGS(&pBuffer));
|
|
if(FAILED(hr))
|
|
{
|
|
return nullptr;
|
|
}
|
|
return pBuffer;
|
|
}
|
|
|
|
ID3D12RootSignature* DeviceUtils::createRootSignature(D3D12_ROOT_SIGNATURE_DESC rootSignatureDesc)
|
|
{
|
|
HRESULT hr = 0;
|
|
|
|
ID3DBlob* serializedRootSignature;
|
|
ID3DBlob* error;
|
|
ID3D12RootSignature* rootSignature;
|
|
hr = D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &serializedRootSignature, &error);
|
|
if(FAILED(hr))
|
|
{
|
|
fprintf(stderr, "Could not serialize root signature: %s\n", (LPCSTR)(error->GetBufferPointer()));
|
|
error->Release();
|
|
return nullptr;
|
|
}
|
|
hr = m_device->CreateRootSignature(0, serializedRootSignature->GetBufferPointer(),
|
|
serializedRootSignature->GetBufferSize(), IID_PPV_ARGS(&rootSignature));
|
|
|
|
serializedRootSignature->Release();
|
|
if(FAILED(hr))
|
|
{
|
|
fprintf(stderr, "Could not create root signature\n");
|
|
return nullptr;
|
|
}
|
|
|
|
return rootSignature;
|
|
}
|
|
|
|
} // namespace nvdx12
|