public Boolean ClearUAV(H1GpuBuffer target)
{
H1GpuBuffer targetDX12 = target as H1GpuBuffer;
H1DynamicDescriptorHeap dynamicDescriptorHeapDX12 = DynamicDescriptorHeap;
GpuDescriptorHandle gpuVisibleHandle = new GpuDescriptorHandle();
//if (dynamicDescriptorHeapDX12.UploadDirect(targetDX12.UAV, ref gpuVisibleHandle) == false)
//{
// return false;
//}
return(true);
}
void InitializePlatformDependent(ref Boolean bSuccess)
{
// platform-specific assignment
DynamicDescriptorHeap = new H1DynamicDescriptorHeap();
bSuccess = CommandListManager.CreateCommandList(CommandListType, this);
}
public Boolean CopyAndBindStaleTables(H1DescriptorHandle destHandleStart, GraphicsCommandList cmdList, Boolean bGraphicsRootDescriptorTable = true)
{
Int64 staleParamCount = 0;
Int64[] tableSize = new Int64[MaxNumDescriptorsTables];
Int64[] rootIndices = new Int64[MaxNumDescriptorsTables];
Int64 neededSpace = 0;
Int32 rootIndex;
// sum the maximum assigned offsets of stale descriptor tables to determine total needed space
BitArray staleParams = m_StaleRootParamsBitMap;
for (rootIndex = 0; rootIndex < staleParams.Count; ++rootIndex)
{
// forward bit scanning
if (staleParams[rootIndex] == true)
{
// cache stale parameter index to the root indices
rootIndices[staleParamCount] = rootIndex;
// XOR to staleParams
staleParams[rootIndex] = false;
BitArray AssignedHandlesForRootDescriptorTable = m_RootDescriptorTable[rootIndex].AssignedHandlesBitMap;
for (Int32 maxSetHandle = AssignedHandlesForRootDescriptorTable.Count - 1; maxSetHandle >= 0; --maxSetHandle)
{
// bit reverse traversing
if (AssignedHandlesForRootDescriptorTable[maxSetHandle] == true)
{
neededSpace += maxSetHandle + 1;
tableSize[staleParamCount] = maxSetHandle + 1;
break; // only take an account of maximum handle index
}
}
// increase stale param count
staleParamCount++;
}
}
if (staleParamCount > MaxNumDescriptorsTables)
{
return(false); // only equipped to handle so many descriptor tables
}
// clear stale root param bit map
for (int i = 0; i < m_StaleRootParamsBitMap.Count; ++i)
{
m_StaleRootParamsBitMap[i] = false;
}
const Int32 MaxDescriptorPerCopy = 16;
Int32 numDestDescriptorRanges = 0;
CpuDescriptorHandle[] destDescriptorRangeStart = new CpuDescriptorHandle[MaxDescriptorPerCopy];
Int32[] destDescriptorRangeSizes = new Int32[MaxDescriptorPerCopy];
Int32 numSrcDescriptorRanges = 0;
CpuDescriptorHandle[] srcDescriptorRangeStart = new CpuDescriptorHandle[MaxDescriptorPerCopy];
Int32[] srcDescriptorRangeSizes = new Int32[MaxDescriptorPerCopy];
Int32 descriptorSize = H1DynamicDescriptorHeap.GetDescriptorSize();
for (Int32 i = 0; i < staleParamCount; ++i)
{
// get the root index and set root descriptor table
rootIndex = Convert.ToInt32(rootIndices[i]);
if (bGraphicsRootDescriptorTable)
{
cmdList.SetGraphicsRootDescriptorTable(rootIndex, destHandleStart.GpuHandle);
}
else
{
cmdList.SetComputeRootDescriptorTable(rootIndex, destHandleStart.GpuHandle);
}
H1DescriptorTableCache rootDescriptorTable = m_RootDescriptorTable[rootIndex];
// cached local variables
Int32 srcHandles = rootDescriptorTable.TableStart;
BitArray setHandles = rootDescriptorTable.AssignedHandlesBitMap;
CpuDescriptorHandle currDest = destHandleStart.CpuHandle;
// move dest handle start ptr by table size scaled by descriptor size
destHandleStart = destHandleStart + (tableSize[i] * descriptorSize);
for (Int32 skipCount = 0; skipCount < setHandles.Count; ++skipCount)
{
// forward bit scanning
if (setHandles[skipCount] == true)
{
// skip over unset descriptor handles
srcHandles += skipCount;
currDest.Ptr += skipCount * descriptorSize;
Int32 descriptorCount;
for (descriptorCount = skipCount; descriptorCount < setHandles.Count; ++descriptorCount)
{
// find unset descriptor handles (skipping consecutive set descriptor handles)
if (setHandles[descriptorCount] == false)
{
// update descriptorCount as consecutive set descriptor handles
descriptorCount -= skipCount;
// update skipCount
skipCount += descriptorCount;
break;
}
}
// if we run out of temp room, copy that we've got so far
if (numDestDescriptorRanges + descriptorCount > MaxDescriptorPerCopy)
{
H1Global <H1ManagedRenderer> .Instance.Device.CopyDescriptors(
numDestDescriptorRanges, destDescriptorRangeStart, destDescriptorRangeSizes,
numSrcDescriptorRanges, srcDescriptorRangeStart, srcDescriptorRangeSizes,
DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
// reset the number of [src|dest] descriptor range numbers
numSrcDescriptorRanges = 0;
numDestDescriptorRanges = 0;
}
// set up destination range
destDescriptorRangeStart[numDestDescriptorRanges] = currDest;
destDescriptorRangeSizes[numDestDescriptorRanges] = descriptorCount;
++numDestDescriptorRanges;
// set up source ranges (one descriptor each because we don't assume they are contiguous)
for (Int32 j = 0; j < descriptorCount; ++j)
{
srcDescriptorRangeStart[numSrcDescriptorRanges] = m_HandleCaches[srcHandles + j];
srcDescriptorRangeSizes[numSrcDescriptorRanges] = 1;
++numSrcDescriptorRanges;
}
// move the destination pointer forward by the number of descriptors we will copy
srcHandles += descriptorCount;
currDest.Ptr += descriptorCount * descriptorCount;
}
}
}
H1Global <H1ManagedRenderer> .Instance.Device.CopyDescriptors(
numDestDescriptorRanges, destDescriptorRangeStart, destDescriptorRangeSizes,
numSrcDescriptorRanges, srcDescriptorRangeStart, srcDescriptorRangeSizes,
DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
return(true);
}