private unsafe void CreateDeviceDependentResourcesInternal()
{
ID3D12Device *d3dDevice = _deviceResources.D3DDevice;
{
D3D12_DESCRIPTOR_RANGE range =
CD3DX12_DESCRIPTOR_RANGE.Create(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);
CD3DX12_ROOT_PARAMETER.InitAsDescriptorTable(out D3D12_ROOT_PARAMETER parameter, 1, &range, D3D12_SHADER_VISIBILITY_VERTEX);
D3D12_ROOT_SIGNATURE_FLAGS rootSignatureFlags =
D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | // Only the input assembler stage needs access to the constant buffer.
D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS;
CD3DX12_ROOT_SIGNATURE_DESC.Init(out D3D12_ROOT_SIGNATURE_DESC descRootSignature, 1, ¶meter, 0, null, rootSignatureFlags);
var pSignature = new ComPtr <ID3DBlob>();
var pError = new ComPtr <ID3DBlob>();
ThrowIfFailed(D3D12SerializeRootSignature(&descRootSignature, D3D_ROOT_SIGNATURE_VERSION_1, pSignature.GetAddressOf(), pError.GetAddressOf()));
Guid iid = IID_ID3D12RootSignature;
ID3D12RootSignature *rootSignature;
ThrowIfFailed(d3dDevice->CreateRootSignature(0, pSignature.Ptr->GetBufferPointer(), pSignature.Ptr->GetBufferSize(), &iid, (void **)&rootSignature));
_rootSignature = rootSignature;
NameD3D12Object(_rootSignature.Ptr, nameof(_rootSignature));
}
}
public static void Init([NativeTypeName("D3D12_DESCRIPTOR_RANGE &")] out D3D12_DESCRIPTOR_RANGE range, D3D12_DESCRIPTOR_RANGE_TYPE rangeType, uint numDescriptors, uint baseShaderRegister, uint registerSpace = 0, uint offsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
{
range.RangeType = rangeType;
range.NumDescriptors = numDescriptors;
range.BaseShaderRegister = baseShaderRegister;
range.RegisterSpace = registerSpace;
range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
}
/// <summary>
/// Creates a new descriptor table root parameter
/// </summary>
/// <param name="ranges">The <see cref="DescriptorRange"/>s to bind</param>
/// <param name="visibility">Indicates which shaders have access to this parameter</param>
/// <returns>A new <see cref="RootParameter"/> representing a descriptor table</returns>
public static RootParameter CreateDescriptorTable(DescriptorRange[] ranges, ShaderVisibility visibility = ShaderVisibility.All)
{
// do NOT make this a not pinned array. RootSignature.TranslateRootParameters relies on it
var d3d12Ranges = GC.AllocateArray <D3D12_DESCRIPTOR_RANGE>(ranges.Length, pinned: true);
for (var i = 0; i < ranges.Length; i++)
{
var range = ranges[i];
d3d12Ranges[i] = new D3D12_DESCRIPTOR_RANGE(
(D3D12_DESCRIPTOR_RANGE_TYPE)range.Type,
range.DescriptorCount,
range.BaseShaderRegister,
range.RegisterSpace,
range.DescriptorOffset
);
}
return(new RootParameter(d3d12Ranges, visibility));
}
private Pointer <ID3D12RootSignature> CreateD3D12RootSignature()
{
ThrowIfDisposedOrDisposing(_state, nameof(D3D12GraphicsPipelineSignature));
ID3DBlob *rootSignatureBlob = null;
ID3DBlob *rootSignatureErrorBlob = null;
try
{
ID3D12RootSignature *d3d12RootSignature;
var rootSignatureDesc = new D3D12_ROOT_SIGNATURE_DESC {
Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT,
};
var resources = Resources;
var resourcesLength = resources.Length;
var rootParametersLength = 0;
var staticSamplersLength = 0;
var rootParametersIndex = 0;
var constantShaderRegister = 0;
var textureShaderRegister = 0;
var staticSamplersIndex = 0;
for (var inputIndex = 0; inputIndex < resourcesLength; inputIndex++)
{
rootParametersLength++;
if (resources[inputIndex].Kind == GraphicsPipelineResourceKind.Texture)
{
staticSamplersLength++;
}
}
var rootParameters = stackalloc D3D12_ROOT_PARAMETER[rootParametersLength];
var staticSamplers = stackalloc D3D12_STATIC_SAMPLER_DESC[staticSamplersLength];
var descriptorRanges = stackalloc D3D12_DESCRIPTOR_RANGE[staticSamplersLength];
for (var inputIndex = 0; inputIndex < resourcesLength; inputIndex++)
{
var input = resources[inputIndex];
switch (input.Kind)
{
case GraphicsPipelineResourceKind.ConstantBuffer:
{
var shaderVisibility = GetD3D12ShaderVisiblity(input.ShaderVisibility);
rootParameters[rootParametersIndex].InitAsConstantBufferView(unchecked ((uint)constantShaderRegister), registerSpace: 0, shaderVisibility);
constantShaderRegister++;
rootParametersIndex++;
break;
}
case GraphicsPipelineResourceKind.Texture:
{
descriptorRanges[staticSamplersIndex] = new D3D12_DESCRIPTOR_RANGE(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, numDescriptors: 1, baseShaderRegister: unchecked ((uint)textureShaderRegister));
var shaderVisibility = GetD3D12ShaderVisiblity(input.ShaderVisibility);
rootParameters[rootParametersIndex].InitAsDescriptorTable(1, &descriptorRanges[staticSamplersIndex], shaderVisibility);
staticSamplers[staticSamplersIndex] = new D3D12_STATIC_SAMPLER_DESC(
shaderRegister: unchecked ((uint)staticSamplersIndex),
shaderVisibility: shaderVisibility
);
textureShaderRegister++;
rootParametersIndex++;
staticSamplersIndex++;
break;
}
default:
{
break;
}
}
}
rootSignatureDesc.NumParameters = unchecked ((uint)rootParametersLength);
rootSignatureDesc.pParameters = rootParameters;
rootSignatureDesc.NumStaticSamplers = unchecked ((uint)staticSamplersLength);
rootSignatureDesc.pStaticSamplers = staticSamplers;
ThrowExternalExceptionIfFailed(D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &rootSignatureBlob, &rootSignatureErrorBlob), nameof(D3D12SerializeRootSignature));
var iid = IID_ID3D12RootSignature;
ThrowExternalExceptionIfFailed(Device.D3D12Device->CreateRootSignature(0, rootSignatureBlob->GetBufferPointer(), rootSignatureBlob->GetBufferSize(), &iid, (void **)&d3d12RootSignature), nameof(ID3D12Device.CreateRootSignature));
return(d3d12RootSignature);
}
finally
{
ReleaseIfNotNull(rootSignatureErrorBlob);
ReleaseIfNotNull(rootSignatureBlob);
}
private async void CreateDeviceDependentResources()
{
unsafe
{
ID3D12Device *d3dDevice = _deviceResources.D3DDevice;
{
D3D12_DESCRIPTOR_RANGE range =
CD3DX12_DESCRIPTOR_RANGE.Create(D3D12_DESCRIPTOR_RANGE_TYPE.D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);
CD3DX12_ROOT_PARAMETER.InitAsDescriptorTable(out D3D12_ROOT_PARAMETER parameter, 1, &range,
D3D12_SHADER_VISIBILITY.D3D12_SHADER_VISIBILITY_VERTEX);
D3D12_ROOT_SIGNATURE_FLAGS rootSignatureFlags =
D3D12_ROOT_SIGNATURE_FLAGS
.D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | // Only the input assembler stage needs access to the constant buffer.
D3D12_ROOT_SIGNATURE_FLAGS.D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAGS.D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAGS.D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAGS.D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS;
CD3DX12_ROOT_SIGNATURE_DESC.Init(out D3D12_ROOT_SIGNATURE_DESC descRootSignature, 1, ¶meter, 0,
null, rootSignatureFlags);
var pSignature = new ComPtrField <ID3DBlob>();
var pError = new ComPtrField <ID3DBlob>();
ThrowIfFailed(D3D12.D3D12SerializeRootSignature(&descRootSignature,
D3D_ROOT_SIGNATURE_VERSION.D3D_ROOT_SIGNATURE_VERSION_1, pSignature.DangerousGetAddressOf(),
pError.DangerousGetAddressOf()));
Guid iid = D3D12.IID_ID3D12RootSignature;
ID3D12RootSignature *rootSignature;
ThrowIfFailed(d3dDevice->CreateRootSignature(0, pSignature.Ptr->GetBufferPointer(),
pSignature.Ptr->GetBufferSize(), &iid, (void **)&rootSignature));
_rootSignature = rootSignature;
DX.NameD3D12Object(_rootSignature.Ptr, nameof(_rootSignature));
}
}
Task vertexShaderRead = ((Func <Task>)(async() =>
{
const string fileName = "Content/SampleVertexShader.cso";
var size = (UIntPtr) new FileInfo(fileName).Length;
byte[] shader = await File.ReadAllBytesAsync(fileName);
unsafe
{
CopyBytesToBlob(out _vertexShader.GetPinnableReference(), size, shader);
}
}))();
Task pixelShaderRead = ((Func <Task>)(async() =>
{
const string fileName = "Content/SamplePixelShader.cso";
var size = (UIntPtr) new FileInfo(fileName).Length;
byte[] shader = await File.ReadAllBytesAsync(fileName);
unsafe
{
CopyBytesToBlob(out _pixelShader.GetPinnableReference(), size, shader);
}
}))();
await CreatePipelineState(vertexShaderRead, pixelShaderRead).ContinueWith(CreateRendererAssets);
}
