工作图 API – 计算光栅化器学习示例

struct Workload
{
    uint offsetIndex;  // local cluster location in the global shared index buffer
    uint offsetVertex; // local cluster location in the global shared vertex buffer
                     // (indices are cluster local)
    uint startIndex;   // start of the triangle-range in the index buffer
    uint stopIndex;    // end of the triangle range in the index buffer, inclusive

    float4 vCenter;
    float4 vRadius;

    matrix mWorldCurrent;
    matrix mWorldPrevious;
};

[Shader("node")]
[NodeLaunch("Broadcasting")]
[NodeMaxDispatchGrid(65535, 1, 1)]
[NodeIsProgramEntry]
[NumThreads(TRANSF_NUM_THREADS, 1, 1)]
void TriangleFetchAndTransform(
    uint WorkgroupIndex : SV_GroupID,
    uint SIMDLaneIndex : SV_GroupIndex,

[Shader("node")]
[NodeLaunch("broadcasting")]
#if (EXPANSION == 1) // fixed expansion
[NodeDispatchGrid(1, 1, 1)] // has the size of one wave, consumes no
dispatch parameters
[NumThreads(SPLITR_NUM_THREADS, 1, 1)]
void SplitFixed(
#elif (EXPANSION == 2) // dynamic expansion
[NodeMaxDispatchGrid(240, 135, 1)] // can be very large, consumes
dispatch parameters
[NumThreads(SPLITR_NUM_THREADS, 1, 1)]
void SplitDynamic(
#else
[NodeMaxDispatchGrid(240, 135, 1)]
[NumThreads(SPLITR_NUM_THREADS, 1, 1)]
void Split(
#endif
    uint  WorkSIMDIndex : SV_DispatchThreadID, // use only one dimension to allow optimizations of the dispatch

[Shader("node")]
[NodeLaunch("thread")]
[NodeID("Rasterize", TRIANGLE_BIN)] // indicate position in a node-array, passed in as a preprocessor symbol while compiling the node
void Rasterize(

struct DrawRecord
{
    // index into the global scene buffer containing all Workload descriptors
    uint  workloadOffset;

    uint3 DispatchGrid : SV_DispatchGrid;
};

void TriangleFetchAndTransform(
    // Input record that contains the dispatch grid size.
    // Set up by the application.
    DispatchNodeInputRecord<DrawRecord> launchRecord,

struct SplitDynamicRecord
{
    uint3 DispatchGrid : SV_DispatchGrid;

    // Triangle equation, bbox and interpolateable values
    struct TriangleStateStorage tri;

    uint2 DispatchDims; // 2D grid range processed by this 1D dispatch
    uint2 DispatchFrag; // 2D size of the subdividing bounding boxes
};

struct SplitFixedRecord
{
    // Triangle equation, bbox and interpolateable values
    struct TriangleStateStorage tri;

    uint2 DispatchDims; // 2D grid range processed by this 1D dispatch
    uint2 DispatchFrag; // 2D size of the subdividing bounding boxes
};

void TriangleFetchAndTransform(
    [MaxRecords(TRANSF_NUM_THREADS)] // N threads that each output 1 bbox-split
    [NodeID("SplitFixed")]
    NodeOutput<SplitFixedRecord> splitFixedOutput,

    [MaxRecords(TRANSF_NUM_THREADS)] // N threads that each output 1 bbox-split
    [NodeID("SplitDynamic")]
    NodeOutput<SplitDynamicRecord> splitDynamicOutput,

void SplitFixed/Dynamic(
    // Input record that may contain the dispatch grid size.
    // Set up by TriangleFetchAndTransform.
    #if (EXPANSION == 1) // fixed expansion
    DispatchNodeInputRecord<SplitFixedRecord> splitRecord,
    #else // dynamic expansion
    DispatchNodeInputRecord<SplitDynamicRecord> splitRecord,
    #endif

struct RasterizeRecord
{
    // Triangle equation, bbox and interpolateable values
    struct TriangleStateStorage tri;
};

void TriangleFetchAndTransform(
    [MaxRecords(TRANSF_NUM_THREADS)] // N threads that each output 1 triangle
    [NodeID("Rasterize")]
    [NodeArraySize(TRIANGLE_BINS)]  // TRIANGLE_BINS defined by application
                                    // during compilation
    NodeOutputArray<RasterizeRecord> triangleOutput

void SplitFixed/Dynamic(
    [MaxRecords(SPLITR_NUM_THREADS)] // N threads that each output 1 triangle
    [NodeID("Rasterize")]
    [NodeArraySize(TRIANGLE_BINS)]  // TRIANGLE_BINS defined by application
                                  // during compilation
    NodeOutputArray<RasterizeRecord> triangleOutput

void Rasterize(
    ThreadNodeInputRecord<RasterizeRecord> triangleRecord

uint workloadOffset = launchRecord.Get().workloadOffset;

const uint triangleBin                             = ts.triangleBBBin; // calculated bin, if not too large
const bool allocateRasterRecordForThisThread       = ts.triangleValid; // true if not too large
const bool allocateSplitDynamicRecordForThisThread = !allocateRasterRecordForThisThread & (DispatchGrid.x != 1); // too large, and many work groups necessary for subdivision
const bool allocateSplitFixedRecordForThisThread   = !allocateRasterRecordForThisThread & (DispatchGrid.x == 1); // too large, but only one work group necessary for subdivision

// call allocators outside of branch scopes, the boolean indicates if we want a real record or not
ThreadNodeOutputRecords<RasterizeRecord> rasterRecord =
    triangleOutput[triangleBin]
      .GetThreadNodeOutputRecords(allocateRasterRecordForThisThread);
ThreadNodeOutputRecords<SplitDynamicRecord> splitterDynamicRecord =
    splitDynamicOutput
      .GetThreadNodeOutputRecords(allocateSplitDynamicRecordForThisThread);
ThreadNodeOutputRecords<SplitFixedRecord> splitterFixedRecord =
    splitFixedOutput
      .GetThreadNodeOutputRecords(allocateSplitFixedRecordForThisThread);

// fill the acquired output records, here we branch according to the conditions
if (allocateRasterRecordForThisThread)
{
    rasterRecord.Get().tri = StoreTriangleState(ts);
}
else if (allocateSplitFixedRecordForThisThread)
{
    splitterFixedRecord.Get().DispatchDims = DispatchDims;
    splitterFixedRecord.Get().DispatchFrag = DispatchFrag;
    splitterFixedRecord.Get().tri = StoreTriangleState(ts);
}
else if (allocateSplitDynamicRecordForThisThread)
{
    splitterDynamicRecord.Get().DispatchGrid = DispatchGrid;
    splitterDynamicRecord.Get().DispatchDims = DispatchDims;
    splitterDynamicRecord.Get().DispatchFrag = DispatchFrag;
    splitterDynamicRecord.Get().tri = StoreTriangleState(ts);
}

// call completion outside of branch scopes, this allows the scheduler to start processing them
rasterRecord.OutputComplete();
splitterDynamicRecord.OutputComplete();
splitterFixedRecord.OutputComplete();

D3D12_NODE_ID entryPointId = {
    .Name = L"TriangleFetchAndTransform", // name of entry-point/root node
    .ArrayIndex = 0,
};

D3D12_WORK_GRAPH_DESC workGraphDesc = {
    .ProgramName = L"WorkGraphRasterization",
    .Flags = D3D12_WORK_GRAPH_FLAG_INCLUDE_ALL_AVAILABLE_NODES,
    .NumEntrypoints = 1,
    .pEntrypoints = &entryPointId,
    .NumExplicitlyDefinedNodes = 0,
    .pExplicitlyDefinedNodes = nullptr
};

CompileShaderFromFile(sourceWG, &defines,
    "TriangleFetchAndTransform", "-T lib_6_8" OPT, &shaderComputeFrontend);

CompileShaderFromFile(sourceWG, &defines,
    "SplitDynamic", "-T lib_6_8" OPT, &shaderComputeSplitter[0]);
CompileShaderFromFile(sourceWG, &defines,
    "SplitFixed", "-T lib_6_8" OPT, &shaderComputeSplitter[1]);

for (int triangleBin = 0; triangleBin < triangleBins; ++triangleBin)
    CompileShaderFromFile(sourceWG, &defines,
        "Rasterize", "-T lib_6_8" OPT, &shaderComputeRasterize[triangleBin);

std::vector<D3D12_STATE_SUBOBJECT> subObjects = {
    {.Type = D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE,
   .pDesc = &globalRootSignature},
    {.Type = D3D12_STATE_SUBOBJECT_TYPE_WORK_GRAPH,
   .pDesc = &workGraphDesc},
};

D3D12_DXIL_LIBRARY_DESC shaderComputeFrontendDXIL = {
    .DXILLibrary = shaderComputeFrontend,
    .NumExports = 0,
    .pExports = nullptr
};

subObjects.emplace_back(D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY, &shaderComputeFrontendDXIL); // move into persistent allocation

D3D12_DXIL_LIBRARY_DESC shaderComputeSplitter0DXIL = {
    .DXILLibrary = shaderComputeSplitter[0],
    .NumExports = 0,
    .pExports = nullptr
};

subObjects.emplace_back(D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY, &shaderComputeSplitter0DXIL); // move into persistent allocation

D3D12_DXIL_LIBRARY_DESC shaderComputeSplitter1DXIL = {
    .DXILLibrary = shaderComputeSplitter[1],
    .NumExports = 0,
    .pExports = nullptr
};

subObjects.emplace_back(D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY, &shaderComputeSplitter1DXIL); // move into persistent allocation

[NodeID("Rasterize")]
NodeOutputArray<RasterizeRecord> triangleOutput

for (int triangleBin = 0; triangleBin < triangleBins; ++triangleBin)
{
    auto entryPoint = L"Rasterize";

    // Change "Rasterize" into "Rasterize_k"
    refNames.emplace_back(std::format(L"{}_{}", entryPoint, triangleBin)); // move into persistent allocation

    // Tell the linker to change the export name when linking
    D3D12_EXPORT_DESC shaderComputeRasterizeExport = {
        .Name = refNames.back().c_str(),
        .ExportToRename = entryPoint,
        .Flags = D3D12_EXPORT_FLAG_NONE
    };

    expNames.emplace_back(shaderComputeRasterizeExport); // move into persistent allocation

    D3D12_DXIL_LIBRARY_DESC shaderComputeRasterizeDXIL = {
        .DXILLibrary = shaderComputeRasterize[triangleBin],
        .NumExports = 1,
        .pExports = &expNames.back()
    };

    libNames.emplace_back(shaderComputeRasterizeDXIL); // move into persistent allocation

    subObjects.emplace_back(D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY, &libNames.back());
}

const D3D12_STATE_OBJECT_DESC stateObjectDesc = {
    .Type = D3D12_STATE_OBJECT_TYPE_EXECUTABLE,
    .NumSubobjects = static_cast<UINT>(subObjects.size()),
    .pSubobjects = subObjects.data()
};

ThrowIfFailed(m_pDevice->CreateStateObject(&stateObjectDesc, IID_PPV_ARGS(&m_pipelineWorkGraph)));

ComPtr<ID3D12WorkGraphProperties> workGraphProperties;
ThrowIfFailed(m_pipelineWorkGraph->QueryInterface(IID_PPV_ARGS(&workGraphProperties)));

D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS workGraphMemoryRequirements;
workGraphProperties->GetWorkGraphMemoryRequirements(0, &workGraphMemoryRequirements);

const auto workGraphBackingMemoryResourceDesc = CD3DX12_RESOURCE_DESC::Buffer(workGraphMemoryRequirements.MaxSizeInBytes);

const auto defaultHeapProps = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);

ThrowIfFailed(m_pDevice->CreateCommittedResource(
    &defaultHeapProps,
    D3D12_HEAP_FLAG_NONE,
    &workGraphBackingMemoryResourceDesc,
    D3D12_RESOURCE_STATE_COMMON,
    nullptr,
    IID_PPV_ARGS(&m_memoryWorkGraph
)));

const D3D12_GPU_VIRTUAL_ADDRESS_RANGE backingMemoryAddrRange = {
    .StartAddress = m_memoryWorkGraph->GetGPUVirtualAddress(),
    .SizeInBytes = workGraphMemoryRequirements.MaxSizeInBytes,
};

ComPtr<ID3D12WorkGraphProperties> workGraphProperties;
ThrowIfFailed(m_pipelineWorkGraph->QueryInterface(IID_PPV_ARGS(&workGraphProperties)));

ComPtr<ID3D12StateObjectProperties1> workGraphProperties1;
ThrowIfFailed(m_pipelineWorkGraph->QueryInterface(IID_PPV_ARGS(&workGraphProperties1)));

D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS workGraphMemoryRequirements;
workGraphProperties->GetWorkGraphMemoryRequirements(0, &workGraphMemoryRequirements);

// Define the address and size of the backing memory
const D3D12_GPU_VIRTUAL_ADDRESS_RANGE backingMemoryAddrRange = {
    .StartAddress = m_memoryWorkGraph->GetGPUVirtualAddress(),
    .SizeInBytes = workGraphMemoryRequirements.MaxSizeInBytes,
};

// Backing memory only needs to be initialized once
const D3D12_SET_WORK_GRAPH_FLAGS setWorkGraphFlags =
m_memoryInitialized ? D3D12_SET_WORK_GRAPH_FLAG_NONE
                    : D3D12_SET_WORK_GRAPH_FLAG_INITIALIZE;
m_memoryInitialized = true;

const D3D12_SET_WORK_GRAPH_DESC workGraphProgramDesc = {
    .ProgramIdentifier = workGraphProperties1->GetProgramIdentifier(L"WorkGraphRasterization"),
    .Flags = setWorkGraphFlags,
    .BackingMemory = backingMemoryAddrRange
};

const D3D12_SET_PROGRAM_DESC programDesc = {
    .Type = D3D12_PROGRAM_TYPE_WORK_GRAPH,
    .WorkGraph = workGraphProgramDesc
};

// Set the program and backing memory
pCommandList->SetProgram(&programDesc);

// Submit all of our DrawRecords in one batch-submission
const D3D12_NODE_CPU_INPUT nodeCPUInput {
    .EntrypointIndex = 0,
    .NumRecords = UINT(m_Arguments.size()),
    .pRecords = (void*)m_Arguments.data(),
    .RecordStrideInBytes = sizeof(DrawRecord),
};

const D3D12_DISPATCH_GRAPH_DESC dispatchGraphDesc = {
    .Mode = D3D12_DISPATCH_MODE_NODE_CPU_INPUT,
    .NodeCPUInput = nodeCPUInput,
};

pCommandList->DispatchGraph(&dispatchGraphDesc);