read_mesh()

void MayaFlux::Buffers::DataReadProcessor::read_mesh

(

)

Read the attached mesh.

A MeshBuffer, a GeometryBuffer driven by a MeshWriterNode, and a MeshNetworkBuffer yield a copy of their CPU-authoritative geometry with no transfer; a network is merged into one mesh with a submesh per slot, in local space with no transforms applied. A ComputeMeshBuffer or a VolumeGridBuffer with a surface yields its live vertices as non-indexed triangles, sized by its live counter rather than its capacity.

Definition at line 150 of file DataReadProcessor.cpp.

{
    arm([](DataReadProcessor& self, const std::shared_ptr<VKBuffer>& vk, PendingRead& pending) {
        const auto keep_cpu_mesh = [&pending](std::optional<Kakshya::MeshData> mesh) {
            if (!mesh) {
                MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "DataReadProcessor read_mesh found no geometry to read");
                return false;
            }
            pending.mesh = std::move(mesh);
            return true;
        };
 
        if (const auto mesh_buffer = std::dynamic_pointer_cast<MeshBuffer>(vk)) {
            return keep_cpu_mesh(mesh_buffer->get_mesh_data());
        }
 
        if (const auto network_buffer = std::dynamic_pointer_cast<MeshNetworkBuffer>(vk)) {
            const auto network = network_buffer->get_network();
            return keep_cpu_mesh(network ? network->get_mesh_data() : std::nullopt);
        }
 
        if (const auto geometry_buffer = std::dynamic_pointer_cast<GeometryBuffer>(vk)) {
            const auto node = std::dynamic_pointer_cast<Nodes::GpuSync::MeshWriterNode>(
                geometry_buffer->get_geometry_node());
            return keep_cpu_mesh(node ? node->get_mesh_data() : std::nullopt);
        }
 
        std::optional<uint32_t> live_count;
        if (const auto compute_mesh = std::dynamic_pointer_cast<ComputeMeshBuffer>(vk)) {
            live_count = compute_mesh->get_live_vertex_count();
        } else if (const auto volume = std::dynamic_pointer_cast<VolumeGridBuffer>(vk)) {
            live_count = volume->get_live_vertex_count();
        }
 
        if (!live_count || *live_count == 0) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "DataReadProcessor read_mesh requires a mesh, geometry or mesh network buffer, "
                "or a compute mesh or volume surface with live vertices");
            return false;
        }
        pending.triangle_soup = true;
        pending.handle = gpu_buffer_handle(vk);
        return submit_read(pending, self.m_staging, vk->get_size_bytes(),
            static_cast<size_t>(*live_count) * sizeof(Kakshya::MeshVertex),
            vk->is_host_visible(), is_transfer_source(vk));
    });
}

References arm(), MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, MayaFlux::Buffers::gpu_buffer_handle(), MayaFlux::Buffers::DataReadProcessor::PendingRead::handle, MayaFlux::Buffers::is_transfer_source(), m_staging, MayaFlux::Buffers::DataReadProcessor::PendingRead::mesh, MF_RT_ERROR, network, submit_read(), and MayaFlux::Buffers::DataReadProcessor::PendingRead::triangle_soup.

Referenced by MayaFlux::Kriya::detail::arm_graphics_read().

Here is the call graph for this function:

Here is the caller graph for this function: