mill()

uint32_t MayaFlux::Portal::Graphics::PrimitiveMill::mill	(	const std::shared_ptr< Buffers::VKBuffer > &	source,
		std::span< const DrawRun >	runs,
		const MillView &	view
	)

Mill runs out of source into the owned buffer.

Parameters

source	Vertex buffer the spans index into. Must carry a vertex layout whose stride is a multiple of four bytes and which has a word aligned position attribute.
runs	Spans to mill, in output order.
view	Viewpoint, consumed only by Ribbon::WorldFacing.

Returns

Vertices written, or 0 when there was nothing to mill or the source could not be used.

Does not wait on its own dispatch. It resolves the previous call's submission first, then submits this one and returns. output() is immediately valid to record a draw against; it is not valid to read from the host until a later mill() or release() has resolved the fence.

Dispatched on the graphics queue, not a compute one, which is what makes the recorded barriers mean anything: submission order spans vkQueueSubmit calls to one queue, so the trailing barrier orders this write before the draw submitted afterwards and the leading one orders the previous frame's vertex fetch before this write. Neither reaches across queues, and the destination is SharingMode::eExclusive, so a dedicated compute queue would need a semaphore and a queue family ownership transfer instead.

Waiting on the previous dispatch is not optional: the run and prefix tables are host visible and rewritten here, so the prior dispatch must have finished reading them.

The destination grows to fit and never shrinks.

Definition at line 630 of file PrimitiveMill.cpp.

{
    resolve_pending();
 
    m_milled_count = 0;
 
    if (!source || runs.empty()) {
        return 0;
    }
 
    const auto layout = source->get_vertex_layout();
    if (!layout.has_value()) {
        return 0;
    }
 
    MillOffsets off;
    if (!offsets_from(*layout, off)) {
        MF_RT_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "PrimitiveMill: layout is not millable, stride {} needs word alignment "
            "and an addressable position attribute",
            layout->stride_bytes);
        return 0;
    }
 
    const uint32_t source_vertices = layout->vertex_count;
    for (const auto& run : runs) {
        if (run.vertex_count == 0) {
            continue;
        }
        if (run.vertex_offset > source_vertices
            || run.vertex_count > source_vertices - run.vertex_offset) {
            MF_RT_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
                "PrimitiveMill: run [{}, {}) exceeds the source's {} vertices",
                run.vertex_offset, run.vertex_offset + run.vertex_count, source_vertices);
            return 0;
        }
    }
 
    build_prefix(runs, m_prefix);
    const uint32_t total = m_prefix.back();
    if (total == 0) {
        return 0;
    }
 
    if (!ensure_kernel() || !ensure_buffers(source, *layout, total, runs.size())) {
        return 0;
    }
 
    m_output_slot = (m_output_slot + 1) % m_outputs.size();
 
    auto* run_ptr = static_cast<uint32_t*>(m_run_buf->get_mapped_ptr());
    auto* prefix_ptr = static_cast<uint32_t*>(m_prefix_buf->get_mapped_ptr());
    if (!run_ptr || !prefix_ptr) {
        MF_RT_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "PrimitiveMill: run or prefix buffer is not host mapped");
        return 0;
    }
 
    for (size_t r = 0; r < runs.size(); ++r) {
        run_ptr[r * RUN_WORDS + 0] = static_cast<uint32_t>(runs[r].topology);
        run_ptr[r * RUN_WORDS + 1] = runs[r].vertex_offset;
        run_ptr[r * RUN_WORDS + 2] = runs[r].vertex_count;
    }
    std::memcpy(prefix_ptr, m_prefix.data(), m_prefix.size() * sizeof(uint32_t));
 
    write_descriptors(source);
 
    const auto pc = make_pc(m_spec, view, off, total, runs.size());
 
    auto& foundry = get_shader_foundry();
    auto& press = get_compute_press();
 
    const auto destination = m_outputs[m_output_slot]->get_buffer();
 
    auto cmd_id = foundry.begin_commands(ShaderFoundry::CommandBufferType::GRAPHICS);
 
    foundry.buffer_barrier(
        cmd_id,
        destination,
        vk::AccessFlagBits::eVertexAttributeRead,
        vk::AccessFlagBits::eShaderWrite,
        vk::PipelineStageFlagBits::eVertexInput,
        vk::PipelineStageFlagBits::eComputeShader);
 
    press.bind_all(cmd_id, m_pipeline, m_sets, &pc, sizeof(MillPC));
    press.dispatch(cmd_id, (total + WORKGROUP - 1) / WORKGROUP, 1, 1);
 
    foundry.buffer_barrier(
        cmd_id,
        destination,
        vk::AccessFlagBits::eShaderWrite,
        vk::AccessFlagBits::eVertexAttributeRead,
        vk::PipelineStageFlagBits::eComputeShader,
        vk::PipelineStageFlagBits::eVertexInput);
 
    m_pending_fence = foundry.submit_async(cmd_id);
    if (m_pending_fence == INVALID_FENCE) {
        MF_RT_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "PrimitiveMill: dispatch submission failed");
        return 0;
    }
 
    m_milled_count = total;
 
    MF_RT_TRACE(Journal::Component::Portal, Journal::Context::Rendering,
        "PrimitiveMill: milled {} runs into {} vertices", runs.size(), total);
 
    return total;
}

References ensure_buffers(), ensure_kernel(), MayaFlux::Portal::Graphics::get_compute_press(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Portal::Graphics::ShaderFoundry::GRAPHICS, MayaFlux::Portal::Graphics::INVALID_FENCE, m_milled_count, m_output_slot, m_outputs, m_pending_fence, m_pipeline, m_prefix, m_prefix_buf, m_run_buf, m_sets, m_spec, MF_RT_ERROR, MF_RT_TRACE, MayaFlux::Journal::Portal, MayaFlux::Journal::Rendering, resolve_pending(), run(), total, and write_descriptors().

Referenced by MayaFlux::Buffers::RenderProcessor::mill_runs().

Here is the call graph for this function:

Here is the caller graph for this function: