download_compute_mesh()

std::optional< Kakshya::MeshData > MayaFlux::IO::download_compute_mesh

(

const std::shared_ptr< Buffers::ComputeMeshBuffer > &

buffer

)

Download a ComputeMeshBuffer's current live geometry to CPU.

ComputeMeshBuffer's own doc states its live rendering path never reads back vertex data; this is the deliberate, one-shot exception for export. Reads the true live vertex count off the atomic counter buffer's mapped pointer (host-visible, no transfer), then downloads exactly that many vertices from the buffer itself, not its worst-case allocated capacity. The result is non-indexed triangles, so a trivial sequential index array (0..N-1) is synthesized to satisfy Kakshya::MeshData's index requirement.

Parameters

buffer

Source buffer. setup_processors() must have run.

Returns

The current geometry, or nullopt if the buffer is null, has no mesh processor yet, or the live vertex count is zero.

Definition at line 290 of file ModelExport.cpp.

{
    if (!buffer) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, "download_compute_mesh: null buffer");
        return std::nullopt;
    }
 
    auto processor = buffer->get_mesh_processor();
    if (!processor) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "download_compute_mesh: no mesh processor; setup_processors() has not been called");
        return std::nullopt;
    }
 
    auto counter_buf = processor->counter_buf();
    const auto* counter_ptr = counter_buf
        ? static_cast<const uint32_t*>(counter_buf->get_mapped_ptr())
        : nullptr;
    if (!counter_ptr) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "download_compute_mesh: counter buffer is not host-visible or not allocated yet");
        return std::nullopt;
    }
 
    const uint32_t vertex_count = *counter_ptr;
    if (vertex_count == 0) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "download_compute_mesh: live vertex count is zero");
        return std::nullopt;
    }
 
    std::vector<Kakshya::MeshVertex> verts(vertex_count);
    std::shared_ptr<Buffers::VKBuffer> staging;
    Buffers::download_from_gpu_async(
        buffer, verts.data(), verts.size() * sizeof(Kakshya::MeshVertex), staging);
 
    std::vector<uint32_t> indices(vertex_count);
    std::ranges::iota(indices, 0U);
 
    auto mesh_data = Kakshya::MeshData::empty();
    Kakshya::MeshInsertion ins(mesh_data.vertex_variant, mesh_data.index_variant);
    ins.insert_flat(
        std::span<const uint8_t>(
            reinterpret_cast<const uint8_t*>(verts.data()),
            verts.size() * sizeof(Kakshya::MeshVertex)),
        std::span<const uint32_t>(indices),
        Kakshya::VertexLayout::for_meshes(sizeof(Kakshya::MeshVertex)));
    auto access = ins.build();
    if (!access) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "download_compute_mesh: MeshInsertion::build() failed");
        return std::nullopt;
    }
    mesh_data.layout = access->layout;
 
    return mesh_data;
}

References buffer, MayaFlux::Kakshya::MeshInsertion::build(), MayaFlux::Buffers::download_from_gpu_async(), MayaFlux::Kakshya::MeshData::empty(), MayaFlux::Journal::FileIO, MayaFlux::Kakshya::VertexLayout::for_meshes(), MayaFlux::Kakshya::MeshInsertion::insert_flat(), MayaFlux::Journal::IO, MF_ERROR, and U.

Referenced by save_mesh().

Here is the call graph for this function:

Here is the caller graph for this function: