public HeapDescription(ulong size, HeapProperties properties, ulong alignment = 0, HeapFlags flags = HeapFlags.None)
{
SizeInBytes = size;
Properties = properties;
Alignment = alignment;
Flags = flags;
}
public HeapDescription(ulong size, HeapType type, ulong alignment = 0, HeapFlags flags = HeapFlags.None)
{
SizeInBytes = size;
Properties = new HeapProperties(type);
Alignment = alignment;
Flags = flags;
}
/// <summary>
/// The Create
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name">The <see cref="string"/></param>
/// <param name="numElements">The <see cref="uint"/></param>
/// <param name="elementSize">The <see cref="uint"/></param>
/// <param name="initialData">The <see cref="T[]"/></param>
internal void Create(string name, int numElements, int elementSize, byte[] initialData = null)
{
base.Destroy();
_ElementCount = numElements;
_ElementSize = elementSize;
_BufferSize = numElements * elementSize;
var resourceDesc = DescribeBuffer;
_UsageState = ResourceStates.Common;
var heapProp = new HeapProperties
{
Type = HeapType.Default,
CPUPageProperty = CpuPageProperty.Unknown,
CreationNodeMask = 1,
VisibleNodeMask = 1
};
_Resource = Globals.Device.CreateCommittedResource(heapProp, HeapFlags.None, resourceDesc, _UsageState, null);
_Resource.Name = name;
Debug.Assert(_Resource != null);
_GPUVirtualAddress = _Resource.GPUVirtualAddress;
if (initialData != null)
{
CommandContext.InitializeBuffer(this, initialData, _BufferSize);
}
}
public HeapDescription(ulong size, CpuPageProperty cpuPageProperty, MemoryPool memoryPoolPreference, ulong alignment = 0, HeapFlags flags = HeapFlags.None)
{
SizeInBytes = size;
Properties = new HeapProperties(cpuPageProperty, memoryPoolPreference);
Alignment = alignment;
Flags = flags;
}
public Result CreateCommittedResource1 <T>(
HeapProperties heapProperties,
HeapFlags heapFlags,
ResourceDescription description,
ResourceStates initialResourceState,
ID3D12ProtectedResourceSession protectedSession,
ClearValue optimizedClearValue,
out T?resource) where T : ID3D12Resource1
{
Result result = CreateCommittedResource1(ref heapProperties, heapFlags,
ref description,
initialResourceState,
optimizedClearValue,
protectedSession,
typeof(T).GUID, out IntPtr nativePtr);
if (result.Failure)
{
resource = default;
return(result);
}
resource = MarshallingHelpers.FromPointer <T>(nativePtr);
return(result);
}
Resource CreateCommonBuffer(uint resourceSize)
{
// @TODO - I will change change this more flexible memory management with 'Heap' class in SharpDX
HeapProperties heapProperties = new HeapProperties(
HeapType.Upload // specifies a heap for uploading, it has CPU access optimized for uploading to the GPU - best for CPU-write-once, GPU-read-once
);
// create new resource
return(m_RendererRef.Device.CreateCommittedResource(heapProperties, HeapFlags.None, ResourceDescription.Buffer(resourceSize), ResourceStates.GenericRead));
}
public T CreateCommittedResource1 <T>(
HeapProperties heapProperties,
HeapFlags heapFlags,
ResourceDescription description,
ResourceStates initialResourceState,
ID3D12ProtectedResourceSession protectedSession,
ClearValue?optimizedClearValue = null) where T : ID3D12Resource1
{
CreateCommittedResource1(ref heapProperties, heapFlags,
ref description,
initialResourceState,
optimizedClearValue,
protectedSession,
typeof(T).GUID, out IntPtr nativePtr).CheckError();
return(MarshallingHelpers.FromPointer <T>(nativePtr));
}
public int CreateTexture2D(H1PixelFormat elementType, int width, int height, Vector4 clearValue, H1SubresourceData[] subResources)
{
// @TODO - I will change change this more flexible memory management with 'Heap' class in SharpDX
HeapProperties heapProperties = new HeapProperties(
HeapType.Upload // specifies a heap for uploading, it has CPU access optimized for uploading to the GPU - best for CPU-write-once, GPU-read-once
);
// HeapType (from msdn)
// 1. Upload Heaps - a heap for loading data from the CPU to the GPU, typically containing vertex, index or constant buffers or textures and other resources
// 2. Readback Heaps - a heap for loading data back from the GPU to the CPU. Typically data that would be collected by the GPU and downloaded to the CPU would be image data from
// a captured screen shot and statistical and performance data such as counters and timings
// 3. Default Heaps - a heap which supports all GPU operations. This resource heap is focused on containing data that is persistently required by the GPU, such as index and vertex data that maybe required for many frames
// Resources (from msdn)
// 1. Commited resources
// - commited resources are the most common idea of D3D resources over the generations.
// - creating such a resource allocates virtual address range, an implicit heap large enough to fit the whole resource and commits the virtual address range to the physical memory encapsulated by the heap
// - the implicit heap properties must be passed to match functional parity with previous D3D versions.
// 2. Reserved resources
// - Reserved resources are equivalent to D3D11 tiled resources.
// - On their creation, only a virtual address range is allocated and not mapped to any heap.
// - the application will map such resources to heaps latere
// - the capabilities of such resources are currently unchanged over D3D11, as they can be mapped to a heap at a 64KB tile granularity with 'UpdateTileMappings'
// 3. Placed resources
// - new for D3D12, applications may create heaps seperate from resources.
// - afterward, the application may locate multiple resources within a single heap.
// - this can be done without creating tiled or reserved resources, enabling the capabilities for all resource types able to be created directly by applications.
// - multiple resources may overlap, and the application must use the 'TiledResourceBarrier' to re-use physical memory correctly.
// create new resource
H1Texture2D.Description desc = new H1Texture2D.Description();
desc.Width = Convert.ToUInt32(width);
desc.Height = Convert.ToUInt32(height);
desc.Format = elementType;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.MipLevels = 0;
desc.ArraySize = 1;
Direct3D12.H1DX12Texture2D texture2D = Direct3D12.H1DX12Texture2D.Create(Device, clearValue, desc, subResources);
Int32 index = m_Texture2Ds.Count;
m_Texture2Ds.Add(texture2D);
return(index);
}
/// <summary>
/// The CreateNewPage
/// </summary>
/// <param name="pageSize">The <see cref="UInt64"/></param>
/// <returns>The <see cref="LinearAllocationPage"/></returns>
public LinearAllocationPage CreateNewPage(long pageSize = 0)
{
var heapProp = new HeapProperties
{
CPUPageProperty = CpuPageProperty.Unknown,
MemoryPoolPreference = MemoryPool.Unknown,
CreationNodeMask = 1,
VisibleNodeMask = 1
};
var resourceDesc = new ResourceDescription
{
Dimension = ResourceDimension.Buffer,
Alignment = 0,
Height = 1,
DepthOrArraySize = 1,
MipLevels = 1,
Format = SharpDX.DXGI.Format.Unknown,
SampleDescription = new SharpDX.DXGI.SampleDescription {
Count = 1, Quality = 0
},
Layout = TextureLayout.RowMajor
};
ResourceStates defaultUsage;
if (_AllocationType == ELinearAllocatorType.GpuExclusive)
{
heapProp.Type = HeapType.Default;
resourceDesc.Width = pageSize == 0 ? (long)ELinearAllocatorPageSize.GpuAllocatorPageSize : pageSize;
resourceDesc.Flags = ResourceFlags.AllowUnorderedAccess;
defaultUsage = ResourceStates.UnorderedAccess;
}
else
{
heapProp.Type = HeapType.Upload;
resourceDesc.Width = pageSize == 0 ? (long)ELinearAllocatorPageSize.CpuAllocatorPageSize : pageSize;
resourceDesc.Flags = ResourceFlags.None;
defaultUsage = ResourceStates.GenericRead;
}
var buffer = Globals.Device.CreateCommittedResource(heapProp, HeapFlags.None, resourceDesc, defaultUsage, null);
buffer.Name = "LinearAllocator Page";
return(new LinearAllocationPage(buffer, defaultUsage));
}
protected virtual ID3D12Resource *CreateDepthStencil()
{
ID3D12Resource *depthStencil;
var heapProperties = new HeapProperties(HeapType.HeapTypeDefault);
var resourceDesc = new ResourceDesc
(
ResourceDimension.ResourceDimensionTexture2D,
0ul,
(ulong)Size.X,
(uint)Size.Y,
1,
1,
DepthBufferFormat,
new SampleDesc()
{
Count = 1, Quality = 0
},
TextureLayout.TextureLayoutUnknown,
ResourceFlags.ResourceFlagAllowDepthStencil
);
var clearValue = new ClearValue(DepthBufferFormat, depthStencil: new DepthStencilValue(1.0f, 0));
var iid = ID3D12Resource.Guid;
SilkMarshal.ThrowHResult
(
D3DDevice->CreateCommittedResource
(
&heapProperties, HeapFlags.HeapFlagNone, &resourceDesc, ResourceStates.ResourceStateDepthWrite,
&clearValue, &iid, (void **)&depthStencil
)
);
var dsvDesc = new DepthStencilViewDesc
{
Format = DepthBufferFormat,
ViewDimension = DsvDimension.DsvDimensionTexture2D
};
D3DDevice->CreateDepthStencilView(depthStencil, &dsvDesc, DSVHeap->GetCPUDescriptorHandleForHeapStart());
return(depthStencil);
}
public ID3D12Resource1 CreateCommittedResource1(
HeapProperties heapProperties,
HeapFlags heapFlags,
ResourceDescription description,
ResourceStates initialResourceState,
ID3D12ProtectedResourceSession protectedSession,
ClearValue?optimizedClearValue = null)
{
return(CreateCommittedResource1(
ref heapProperties,
heapFlags,
ref description,
initialResourceState,
optimizedClearValue,
protectedSession,
typeof(ID3D12Resource1).GUID));
}
private AccelerationStructureBuffers CreateBottomLevelAS(ID3D12Device5 device, ID3D12GraphicsCommandList4 commandList,
ID3D12Resource[] vertexBuffers, int[] vertexCounts, int geometryCount)
{
RaytracingGeometryDescription[] descs = new RaytracingGeometryDescription[geometryCount];
for (int i = 0; i < descs.Length; i++)
{
descs[i] = new RaytracingGeometryDescription();
descs[i].Type = RaytracingGeometryType.Triangles;
descs[i].Triangles = new RaytracingGeometryTrianglesDescription();
descs[i].Triangles.VertexBuffer = new GpuVirtualAddressAndStride();
descs[i].Triangles.VertexBuffer.StartAddress = vertexBuffers[i].GPUVirtualAddress;
descs[i].Triangles.VertexBuffer.StrideInBytes = 3 * 4;
descs[i].Triangles.VertexFormat = Format.R32G32B32_Float;
descs[i].Triangles.VertexCount = vertexCounts[i];
descs[i].Flags = RaytracingGeometryFlags.Opaque;
}
BuildRaytracingAccelerationStructureInputs inputs = new BuildRaytracingAccelerationStructureInputs();
inputs.Layout = ElementsLayout.Array;
inputs.Flags = RaytracingAccelerationStructureBuildFlags.None;
inputs.DescriptorsCount = geometryCount;
inputs.GeometryDescriptions = descs;
inputs.Type = RaytracingAccelerationStructureType.BottomLevel;
RaytracingAccelerationStructurePrebuildInfo info = device.GetRaytracingAccelerationStructurePrebuildInfo(inputs);
HeapProperties properties = new HeapProperties(HeapType.Default, CpuPageProperty.Unknown, MemoryPool.Unknown, 0, 0);
AccelerationStructureBuffers buffers = new AccelerationStructureBuffers();
buffers.Scratch = CreateBuffer(device, info.ScratchDataSizeInBytes, ResourceFlags.AllowUnorderedAccess, ResourceStates.UnorderedAccess, properties);
buffers.Result = CreateBuffer(device, info.ResultDataMaxSizeInBytes, ResourceFlags.AllowUnorderedAccess, ResourceStates.RaytracingAccelerationStructure, properties);
BuildRaytracingAccelerationStructureDescription asDesc = new BuildRaytracingAccelerationStructureDescription();
asDesc.Inputs = inputs;
asDesc.DestinationAccelerationStructureData = buffers.Result.GPUVirtualAddress;
asDesc.ScratchAccelerationStructureData = buffers.Scratch.GPUVirtualAddress;
commandList.BuildRaytracingAccelerationStructure(asDesc);
commandList.ResourceBarrier(ResourceBarrier.BarrierUnorderedAccessView(buffers.Result));
return(buffers);
}
Int32 CreateResourcePlatformDependent(H1HeapType heapType, H1GpuResourceDesc resourceDesc, H1ResourceStates defaultUsage)
{
HeapProperties heapProps = new HeapProperties();
heapProps.CPUPageProperty = CpuPageProperty.Unknown;
heapProps.MemoryPoolPreference = MemoryPool.Unknown;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
// convert to H1HeapType to HeapType for dx12
switch (heapType)
{
case H1HeapType.Default:
heapProps.Type = HeapType.Default;
break;
case H1HeapType.Readback:
heapProps.Type = HeapType.Readback;
break;
case H1HeapType.Upload:
heapProps.Type = HeapType.Upload;
break;
}
// convert H1ResourceDesc to ResourceDesc for dx12
ResourceDescription resourceDescDX12 = ConvertToResourceDescDx12(resourceDesc);
ResourceStates defaultStates = (ResourceStates)ResourceStateMapper[Convert.ToInt32(defaultUsage)];
Device deviceDX11 = H1Global <H1ManagedRenderer> .Instance.Device;
m_GpuResource = deviceDX11.CreateCommittedResource(heapProps, HeapFlags.None, resourceDescDX12, defaultStates);
Int32 elementSize = Convert.ToInt32(H1RHIDefinitionHelper.ElementTypeToSize(resourceDesc.Format));
if (elementSize == 0)
{
throw new InvalidOperationException("there is no appropriate format is implemented in ElementTypeToSize()!");
}
Int32 totalSizeInBytes = elementSize * Convert.ToInt32(resourceDesc.Width * resourceDesc.Height * resourceDesc.DepthOrArraySize);
return(totalSizeInBytes);
}
public GpuRingBuffer(uint maxSize, Device device)
: base(maxSize)
{
var heapProperties = new HeapProperties(HeapType.Upload);
var resourceDescription = ResourceDescription.Buffer(maxSize);
var defaultUsage = ResourceStates.GenericRead;
_buffer = device.CreateCommittedResource(
heapProperties,
HeapFlags.None,
resourceDescription,
defaultUsage);
_buffer.Name = "Upload Ring Buffer";
_gpuVirtualAddress = _buffer.GPUVirtualAddress;
_cpuVirtualAddress = _buffer.Map(0);
}
private void CreateShaderResources()
{
HeapProperties heapProperties = new HeapProperties(HeapType.Default, CpuPageProperty.Unknown, MemoryPool.Unknown, 0, 0);
// Create the output resource. The dimensions and format should match the swap-chain
ResourceDescription resDesc = new ResourceDescription();
resDesc.Alignment = 0;
resDesc.DepthOrArraySize = 1;
resDesc.Dimension = ResourceDimension.Texture2D;
resDesc.Flags = ResourceFlags.AllowUnorderedAccess;
resDesc.Format = Format.R8G8B8A8_UNorm;
resDesc.Width = Window.Width;
resDesc.Height = Window.Height;
resDesc.Layout = TextureLayout.Unknown;
resDesc.MipLevels = 1;
resDesc.SampleDescription = new SampleDescription();
resDesc.SampleDescription.Count = 1;
outputResource = device.CreateCommittedResource(heapProperties, HeapFlags.None, resDesc, ResourceStates.CopySource, null);
// Create an SRV/UAV descriptor heap. Need 2 entries - 1 SRV for the scene and 1 UAV for the output
srvUavHeap = CreateDescriptorHeap(device, 2, DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView, true);
// Create the UAV. Based on the root signature we created it should be the first entry
UnorderedAccessViewDescription uavDesc = new UnorderedAccessViewDescription();
uavDesc.ViewDimension = UnorderedAccessViewDimension.Texture2D;
device.CreateUnorderedAccessView(outputResource, null, uavDesc, srvUavHeap.GetCPUDescriptorHandleForHeapStart());
// Create the TLAS SRV right after the UAV. Note that we are using a different SRV desc here
ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription();
srvDesc.ViewDimension = ShaderResourceViewDimension.RaytracingAccelerationStructure;
srvDesc.Shader4ComponentMapping = 5768; // D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING
srvDesc.RaytracingAccelerationStructure = new RaytracingAccelerationStructureShaderResourceView();
srvDesc.RaytracingAccelerationStructure.Location = topLevelAS.GPUVirtualAddress;
CpuDescriptorHandle srvHandle = srvUavHeap.GetCPUDescriptorHandleForHeapStart();
srvHandle.Ptr += device.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
device.CreateShaderResourceView(null, srvDesc, srvHandle);
}
private void CreateConstantBuffer()
{
triangleConstantBuffers = new ID3D12Resource[3];
TriangleColors[] bufferData = new TriangleColors[]
{
new TriangleColors()
{
A = new Vector4(0.0f, 0.2f, 1.0f, 1.0f),
B = new Vector4(0.0f, 0.2f, 1.0f, 1.0f),
C = new Vector4(0.0f, 0.2f, 1.0f, 1.0f),
},
new TriangleColors()
{
A = new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
B = new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
C = new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
},
new TriangleColors()
{
A = new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
B = new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
C = new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
},
};
HeapProperties upload_properties = new HeapProperties(HeapType.Upload, CpuPageProperty.Unknown, MemoryPool.Unknown, 0, 0);
for (int i = 0; i < triangleConstantBuffers.Length; i++)
{
triangleConstantBuffers[i] = CreateBuffer(device, Unsafe.SizeOf <TriangleColors>(),
ResourceFlags.None, ResourceStates.GenericRead, upload_properties);
IntPtr data = triangleConstantBuffers[i].Map(0);
Helpers.CopyMemory <TriangleColors>(data, new ReadOnlySpan <TriangleColors>(bufferData).Slice(i, 1));
triangleConstantBuffers[i].Unmap(0);
}
}
public T CreateCommittedResource2 <T>(
HeapProperties heapProperties,
HeapFlags heapFlags,
ResourceDescription1 description,
ResourceStates initialResourceState,
ClearValue?optimizedClearValue,
ID3D12ProtectedResourceSession protectedSession) where T : ID3D12Resource
{
var result = CreateCommittedResource2(
ref heapProperties,
heapFlags,
ref description,
initialResourceState,
optimizedClearValue,
protectedSession,
typeof(T).GUID, out var nativePtr);
if (result.Success)
{
return(FromPointer <T>(nativePtr));
}
return(default);
public static Resource CreateBuffer(Device device, long size, HeapType heapType = HeapType.Default, ResourceFlags resourceFlags = ResourceFlags.None, ResourceStates resourceStates = ResourceStates.Common)
{
var heapProperties = new HeapProperties(heapType);
return(device.CreateCommittedResource(heapProperties, HeapFlags.None, ResourceDescription.Buffer(size, resourceFlags), resourceStates));
}
private unsafe void CreateShaderTable()
{
/** The shader-table layout is as follows:
* Entry 0 - Ray-gen program
* Entry 1 - Miss program
* Entry 2 - Miss program for Shadow
* Entry 3,4 - Hit program for triangle 0 (pimary, shadow)
* Entry 5,6 - Hit program for the plane (pimary, shadow)
* Entry 7,8 - Hit program for triangle 1 (pimary, shadow)
* Entry 9,10 - Hit program for triangle 2 (pimary, shadow)
* All entries in the shader-table must have the same size, so we will choose it base on the largest required entry.
* The triangle hit program requires the largest entry - sizeof(program identifier) + 8 bytes for the constant-buffer root descriptor.
* The entry size must be aligned up to D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT
*/
shaderTableEntrySize = D3D12ShaderIdentifierSizeInBytes;
shaderTableEntrySize += 16; // TLAS + Constant Buffer
shaderTableEntrySize = align_to(D3D12RaytracingShaderRecordByteAlignment, shaderTableEntrySize);
uint shaderTableSize = shaderTableEntrySize * 11;
HeapProperties upload_properties = new HeapProperties(HeapType.Upload, CpuPageProperty.Unknown, MemoryPool.Unknown, 0, 0);
shaderTable = CreateBuffer(device, shaderTableSize, ResourceFlags.None, ResourceStates.GenericRead, upload_properties);
IntPtr data = shaderTable.Map(0);
ID3D12StateObjectProperties props = pipelineState.QueryInterface <ID3D12StateObjectProperties>();
IntPtr rayGenPtr = props.GetShaderIdentifier("rayGen");
IntPtr missPtr = props.GetShaderIdentifier("miss");
IntPtr hitGroupPtr = props.GetShaderIdentifier("HitGroup");
IntPtr planeHitGroupPtr = props.GetShaderIdentifier("HitGroupPlane");
IntPtr shadowHitGroupPtr = props.GetShaderIdentifier("ShadowHitGroup");
IntPtr shadowMissPtr = props.GetShaderIdentifier("shadowMiss");
// Entry 0 - ray-gen program ID and descriptor data
Helpers.CopyMemory(data, rayGenPtr, (int)D3D12ShaderIdentifierSizeInBytes);
ulong heapStart = (ulong)srvUavHeap.GetGPUDescriptorHandleForHeapStart().Ptr;
Unsafe.Write <ulong>((data + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), heapStart);
// Entry 1 - miss program
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, missPtr, (int)D3D12ShaderIdentifierSizeInBytes);
// Entry 2 - shadow miss program
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, shadowMissPtr, (int)D3D12ShaderIdentifierSizeInBytes);
int increment = device.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
// Entry 3,4 - Triangle 0 hit program. ProgramID and constant-buffer data
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, hitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
ulong constantBufferAddress = (ulong)triangleConstantBuffers[1].GPUVirtualAddress;
Unsafe.Write <ulong>((data + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), constantBufferAddress);
Unsafe.Write <ulong>((data + sizeof(ulong) + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), heapStart + (ulong)increment);
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, shadowHitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
// Entry 5,6 - Triangle 1 hit program. ProgramID and constant-buffer data
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, hitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
constantBufferAddress = (ulong)triangleConstantBuffers[0].GPUVirtualAddress;
Unsafe.Write <ulong>((data + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), constantBufferAddress);
Unsafe.Write <ulong>((data + sizeof(ulong) + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), heapStart + (ulong)increment);
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, shadowHitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
// Entry 7,8 - Plane hit program. ProgramID only
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, planeHitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
Unsafe.Write <ulong>((data + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(),
heapStart + (ulong)device.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView));
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, shadowHitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
// Entry 9,10 - Triangle 2 hit program. ProgramID and constant-buffer data
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, hitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
constantBufferAddress = (ulong)triangleConstantBuffers[2].GPUVirtualAddress;
Unsafe.Write <ulong>((data + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), constantBufferAddress);
Unsafe.Write <ulong>((data + sizeof(ulong) + (int)D3D12ShaderIdentifierSizeInBytes).ToPointer(), heapStart + (ulong)increment);
data += (int)shaderTableEntrySize;
Helpers.CopyMemory(data, shadowHitGroupPtr, (int)D3D12ShaderIdentifierSizeInBytes);
shaderTable.Unmap(0);
}
public ID3D12Resource CreateBuffer(ID3D12Device5 pDevice, uint size, ResourceFlags flags, ResourceStates initState, HeapProperties heapProps)
{
ResourceDescription bufDesc = new ResourceDescription();
bufDesc.Alignment = 0;
bufDesc.DepthOrArraySize = 1;
bufDesc.Dimension = ResourceDimension.Buffer;
bufDesc.Flags = flags;
bufDesc.Format = Format.Unknown;
bufDesc.Height = 1;
bufDesc.Layout = TextureLayout.RowMajor;
bufDesc.MipLevels = 1;
bufDesc.SampleDescription = new SampleDescription(1, 0);
bufDesc.Width = size;
ID3D12Resource pBuffer = pDevice.CreateCommittedResource(heapProps, HeapFlags.None, bufDesc, initState, null);
return(pBuffer);
}
public static void Main()
{
using ID3D12Device device = D3D12CreateDevice <ID3D12Device>(null, FeatureLevel.Level_12_1);
using IDStorageFactory factory = DStorageGetFactory <IDStorageFactory>();
string fileToLoad = "Test.txt";
Result result = factory.OpenFile(fileToLoad, out IDStorageFile? file);
if (result.Failure)
{
Console.WriteLine($"The file '{fileToLoad}' could not be opened. HRESULT={result}");
//ShowHelpText();
return;
}
ByHandleFileInformation info = file !.FileInformation;
uint fileSize = info.FileSizeLow;
// Create a DirectStorage queue which will be used to load data into a buffer on the GPU.
QueueDesc queueDesc = new QueueDesc
{
Capacity = MaxQueueCapacity,
Priority = Priority.Normal,
SourceType = RequestSourceType.File,
Device = device
};
using IDStorageQueue queue = factory.CreateQueue(queueDesc);
// Create the ID3D12Resource buffer which will be populated with the file's contents
HeapProperties bufferHeapProps = new HeapProperties(HeapType.Default);
ResourceDescription bufferDesc = ResourceDescription.Buffer(fileSize);
using ID3D12Resource bufferResource = device.CreateCommittedResource(
bufferHeapProps,
HeapFlags.None,
bufferDesc,
ResourceStates.Common
);
// Enqueue a request to read the file contents into a destination D3D12 buffer resource.
// Note: The example request below is performing a single read of the entire file contents.
Request request = new Request();
request.Options.SourceType = RequestSourceType.File;
request.Options.DestinationType = RequestDestinationType.Buffer;
request.Source.File.Source = file;
request.Source.File.Offset = 0;
request.Source.File.Size = fileSize;
request.UncompressedSize = fileSize;
request.Destination.Buffer.Resource = bufferResource;
request.Destination.Buffer.Offset = 0;
request.Destination.Buffer.Size = request.Source.File.Size;
queue.EnqueueRequest(request);
// Configure a fence to be signaled when the request is completed
using ID3D12Fence fence = device.CreateFence();
using AutoResetEvent fenceEvent = new AutoResetEvent(false);
ulong fenceValue = 1;
fence.SetEventOnCompletion(fenceValue, fenceEvent).CheckError();
queue.EnqueueSignal(fence, fenceValue);
// Tell DirectStorage to start executing all queued items.
queue.Submit();
// Wait for the submitted work to complete
Console.WriteLine("Waiting for the DirectStorage request to complete...");
fenceEvent.WaitOne();
// Check the status array for errors.
// If an error was detected the first failure record
// can be retrieved to get more details.
ErrorRecord errorRecord = queue.RetrieveErrorRecord();
if (errorRecord.FirstFailure.HResult.Failure)
{
//
// errorRecord.FailureCount - The number of failed requests in the queue since the last
// RetrieveErrorRecord call.
// errorRecord.FirstFailure - Detailed record about the first failed command in the enqueue order.
//
Console.WriteLine($"The DirectStorage request failed! HRESULT={errorRecord.FirstFailure.HResult}");
}
else
{
Console.WriteLine("The DirectStorage request completed successfully!");
}
}
public void InitializeFrom(BufferDescription description)
{
Description = description;
ResourceStates resourceStates = ResourceStates.Common;
if (description.HeapType == HeapType.Upload)
{
resourceStates |= ResourceStates.GenericRead;
}
else if (description.HeapType == HeapType.Readback)
{
resourceStates |= ResourceStates.CopyDestination;
}
if ((description.Flags & BufferFlags.ConstantBuffer) != 0)
{
constantBufferView = CreateConstantBufferView();
}
ResourceDescription ResourceDesc = new ResourceDescription()
{
Width = (ulong)SizeInBytes,
Height = 1,
DepthOrArraySize = 1,
Dimension = ResourceDimension.Buffer,
Alignment = 65536,
Layout = TextureLayout.RowMajor,
Flags = ResourceFlags.None,
MipLevels = 1,
Format = Format.Unknown,
SampleDescription = new SampleDescription()
{
Count = 1,
Quality = 0
}
};
HeapProperties heapProp = new HeapProperties()
{
Type = (Vortice.Direct3D12.HeapType)description.HeapType,
CreationNodeMask = 1,
VisibleNodeMask = 1,
CPUPageProperty = CpuPageProperty.Unknown,
MemoryPoolPreference = MemoryPool.Unknown,
};
NativeResource = GraphicsDevice.NativeDevice.CreateCommittedResource <ID3D12Resource>(heapProp, HeapFlags.None, ResourceDesc, resourceStates);
GPUVirtualAddress = (long)NativeResource.GPUVirtualAddress;
//return InitializeFrom(resource, description);
}
public static H1DX12Texture2D Create(Device device, Vector4 clearValue, H1Texture2D.Description desc, H1SubresourceData[] initialData)
{
// converting description to DX12 description
ResourceDescription desc12 = new ResourceDescription
{
Format = H1RHIDefinitionHelper.ConvertToFormat(desc.Format),
Width = Convert.ToInt32(desc.Width),
Height = Convert.ToInt32(desc.Height),
DepthOrArraySize = Convert.ToInt16(desc.ArraySize),
MipLevels = Convert.ToInt16(desc.MipLevels),
Flags = ResourceFlags.None,
Layout = TextureLayout.Unknown,
Dimension = ResourceDimension.Texture2D,
};
desc12.SampleDescription.Count = Convert.ToInt32(desc.SampleDesc.Count);
desc12.SampleDescription.Quality = Convert.ToInt32(desc.SampleDesc.Quality);
HeapProperties heapProperties = new HeapProperties(HeapType.Default);
ResourceStates resourceUsage = ResourceStates.CopyDestination;
ClearValue value = H1GlobalDX12Definitions.GetDXGIFormatClearValue(desc12.Format, (desc.BindFlags & Convert.ToUInt32(H1BindFlag.DepthStencil)) != 0);
Boolean allowClearValue = desc12.Dimension == ResourceDimension.Buffer;
if (desc.Usage == H1Usage.Immutable)
{
heapProperties = new HeapProperties(HeapType.Default);
resourceUsage = ResourceStates.CopyDestination;
}
else if (desc.Usage == H1Usage.Staging)
{
heapProperties = new HeapProperties(HeapType.Readback);
resourceUsage = ResourceStates.CopyDestination;
}
else if (desc.Usage == H1Usage.Dynamic)
{
heapProperties = new HeapProperties(HeapType.Upload);
resourceUsage = ResourceStates.GenericRead;
}
if (desc.CPUAccessFlags != 0)
{
if (desc.CPUAccessFlags == Convert.ToUInt32(H1CPUAccessFlag.Write))
{
heapProperties = new HeapProperties(HeapType.Upload);
resourceUsage = ResourceStates.GenericRead;
}
else if (desc.CPUAccessFlags == Convert.ToUInt32(H1CPUAccessFlag.Read))
{
heapProperties = new HeapProperties(HeapType.Readback);
resourceUsage = ResourceStates.CopyDestination;
}
else
{
return(null);
}
}
if (clearValue != null)
{
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.DepthStencil)) != 0)
{
value.DepthStencil.Depth = clearValue.X;
value.DepthStencil.Stencil = Convert.ToByte(clearValue.Y);
}
else
{
value.Color = clearValue;
}
}
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.UnorderedAccess)) != 0)
{
desc12.Flags |= ResourceFlags.AllowUnorderedAccess;
resourceUsage = ResourceStates.UnorderedAccess;
}
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.DepthStencil)) != 0)
{
desc12.Flags |= ResourceFlags.AllowDepthStencil;
allowClearValue = true;
resourceUsage = ResourceStates.DepthWrite;
}
if ((desc.BindFlags & Convert.ToUInt32(H1BindFlag.RenderTarget)) != 0)
{
desc12.Flags |= ResourceFlags.AllowRenderTarget;
allowClearValue = true;
resourceUsage = ResourceStates.RenderTarget;
}
Resource resource = device.CreateCommittedResource(
heapProperties,
HeapFlags.None,
desc12,
resourceUsage,
allowClearValue ? value : default(ClearValue?));
H1DX12Texture2D newTexture = new H1DX12Texture2D();
newTexture.m_Resource = new H1DX12Resource(resource, resourceUsage, resource.Description, initialData, Convert.ToUInt32(desc12.DepthOrArraySize * desc12.MipLevels));
return(newTexture);
}
private ID3D12Resource CreateBuffer(ID3D12Device5 device, long size, ResourceFlags flags, ResourceStates initState, HeapProperties heapProperties)
{
ResourceDescription desc = new ResourceDescription();
desc.Alignment = 0;
desc.DepthOrArraySize = 1;
desc.Dimension = ResourceDimension.Buffer;
desc.Flags = flags;
desc.Format = Format.Unknown;
desc.Width = size;
desc.Height = 1;
desc.Layout = TextureLayout.RowMajor;
desc.MipLevels = 1;
desc.SampleDescription = new SampleDescription();
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
return(device.CreateCommittedResource(heapProperties, HeapFlags.None, desc, initState, null));
}
private void CreateTopLevelAS(ID3D12Device5 device, ID3D12GraphicsCommandList4 commandList,
ID3D12Resource[] bottomLevelAS, ref long tlasSize, bool isUpdate, float rotate)
{
int instanceCount = 3;
BuildRaytracingAccelerationStructureInputs inputs = new BuildRaytracingAccelerationStructureInputs();
inputs.Layout = ElementsLayout.Array;
inputs.Flags = RaytracingAccelerationStructureBuildFlags.AllowUpdate;
inputs.DescriptorsCount = instanceCount;
inputs.Type = RaytracingAccelerationStructureType.TopLevel;
var info = device.GetRaytracingAccelerationStructurePrebuildInfo(inputs);
if (isUpdate == false)
{
HeapProperties properties = new HeapProperties(HeapType.Default, CpuPageProperty.Unknown, MemoryPool.Unknown, 0, 0);
HeapProperties upload_properties = new HeapProperties(HeapType.Upload, CpuPageProperty.Unknown, MemoryPool.Unknown, 0, 0);
long descSize = (long)Unsafe.SizeOf <MyRaytracingInstanceDescription>();
buffers = new AccelerationStructureBuffers();
buffers.Scratch = CreateBuffer(device, info.ScratchDataSizeInBytes, ResourceFlags.AllowUnorderedAccess, ResourceStates.UnorderedAccess, properties);
buffers.Result = CreateBuffer(device, info.ResultDataMaxSizeInBytes, ResourceFlags.AllowUnorderedAccess, ResourceStates.RaytracingAccelerationStructure, properties);
buffers.InstanceDesc = CreateBuffer(device, descSize * instanceCount, ResourceFlags.None, ResourceStates.GenericRead, upload_properties);
tlasSize = info.ResultDataMaxSizeInBytes;
}
else
{
InsertUAVResourceBarrier(buffers.Result);
}
int instanceContr = 0;
MyRaytracingInstanceDescription[] instanceDescs = new MyRaytracingInstanceDescription[instanceCount];
for (int i = 0; i < instanceCount; i++)
{
instanceDescs[i] = new MyRaytracingInstanceDescription();
float xPos = (i - 1) * 1.5f;
float yPos = 0.0f;
float zPos = 0.0f;
instanceDescs[i].Transform = Matrix4x4.Identity;
if (i != 1)
{
instanceDescs[i].Transform *= Matrix4x4.CreateRotationY(rotate);
if (i == 2)
{
zPos = -0.5f;
}
}
instanceDescs[i].Transform *= Matrix4x4.CreateTranslation(xPos, yPos, zPos);
instanceDescs[i].Transform = Matrix4x4.Transpose(instanceDescs[i].Transform);
instanceDescs[i].InstanceID = i;
instanceDescs[i].InstanceContributionToHitGroupIndex = instanceContr;
instanceDescs[i].Flags = (byte)RaytracingInstanceFlags.None;
instanceDescs[i].InstanceMask = 0xFF;
if (i == 1)
{
instanceDescs[i].AccelerationStructure = bottomLevelAS[0].GPUVirtualAddress;
instanceContr += 4;
}
else
{
instanceDescs[i].AccelerationStructure = bottomLevelAS[1].GPUVirtualAddress;
instanceContr += 2;
}
}
IntPtr data = buffers.InstanceDesc.Map(0, null);
Helpers.CopyMemory <MyRaytracingInstanceDescription>(data, new ReadOnlySpan <MyRaytracingInstanceDescription>(
instanceDescs));
buffers.InstanceDesc.Unmap(0, null);
BuildRaytracingAccelerationStructureDescription asDesc = new BuildRaytracingAccelerationStructureDescription();
asDesc.Inputs = inputs;
asDesc.Inputs.InstanceDescriptions = buffers.InstanceDesc.GPUVirtualAddress;
asDesc.DestinationAccelerationStructureData = buffers.Result.GPUVirtualAddress;
asDesc.ScratchAccelerationStructureData = buffers.Scratch.GPUVirtualAddress;
if (isUpdate)
{
asDesc.Inputs.Flags |= RaytracingAccelerationStructureBuildFlags.PerformUpdate;
asDesc.SourceAccelerationStructureData = buffers.Result.GPUVirtualAddress;
}
commandList.BuildRaytracingAccelerationStructure(asDesc);
InsertUAVResourceBarrier(buffers.Result);
}
protected virtual ID3D12Resource *CreateVertexBuffer(out VertexBufferView vertexBufferView)
{
// Define the geometry for a triangle.
const int TriangleVerticesCount = 3;
var triangleVertices = stackalloc Vertex[TriangleVerticesCount]
{
new Vertex
{
Position = new Vector3(0.0f, 0.5f, 0.0f),
Color = new Vector4(1.0f, 0.0f, 0.0f, 1.0f)
},
new Vertex
{
Position = new Vector3(0.5f, -0.5f, 0.0f),
Color = new Vector4(0.0f, 1.0f, 0.0f, 1.0f)
},
new Vertex
{
Position = new Vector3(-0.5f, -0.5f, 0.0f),
Color = new Vector4(0.0f, 0.0f, 1.0f, 1.0f)
},
};
var vertexBufferSize = (uint)sizeof(Vertex) * TriangleVerticesCount;
// Note: using upload heaps to transfer static data like vert buffers is not
// recommended. Every time the GPU needs it, the upload heap will be marshalled
// over. Please read up on Default Heap usage. An upload heap is used here for
// code simplicity and because there are very few verts to actually transfer.
ID3D12Resource *vertexBuffer;
var heapProperties = new HeapProperties(HeapType.HeapTypeUpload);
var bufferDesc = new ResourceDesc
(
ResourceDimension.ResourceDimensionBuffer, 0, vertexBufferSize, 1, 1, 1, Format.FormatUnknown,
new SampleDesc(1, 0),
TextureLayout.TextureLayoutRowMajor, ResourceFlags.ResourceFlagNone
);
var iid = ID3D12Resource.Guid;
SilkMarshal.ThrowHResult
(
D3DDevice->CreateCommittedResource
(
&heapProperties,
HeapFlags.HeapFlagNone,
&bufferDesc,
ResourceStates.ResourceStateGenericRead,
pOptimizedClearValue: null,
&iid,
(void **)&vertexBuffer
)
);
// Copy the triangle data to the vertex buffer.
var readRange = new Range();
byte *pVertexDataBegin;
SilkMarshal.ThrowHResult(vertexBuffer->Map(Subresource: 0, &readRange, (void **)&pVertexDataBegin));
Unsafe.CopyBlock(pVertexDataBegin, triangleVertices, vertexBufferSize);
vertexBuffer->Unmap(0, null);
// Initialize the vertex buffer view.
vertexBufferView.BufferLocation = vertexBuffer->GetGPUVirtualAddress();
vertexBufferView.StrideInBytes = (uint)sizeof(Vertex);
vertexBufferView.SizeInBytes = vertexBufferSize;
return(vertexBuffer);
}
