read_bounds()

MAYAFLUX_API std::optional< Kinesis::AABB3D > MayaFlux::Nexus::read_bounds	(	const std::shared_ptr< Buffers::VKBuffer > &	buf,
		const std::optional< uint32_t > &	collection = std::nullopt
	)

Bounds of a buffer's geometry in its own stored coordinates.

A VolumeGridBuffer reports its lattice bounds. A NetworkGeometryBuffer reports its vertices, or those of one collection. The primary operator only knows the authored positions and the CPU updates it dispatched, so once the chain holds a GpuFieldOperator the bytes are downloaded from the device instead, as the spatial export does; before the device buffer exists the operator's bytes are used. A GeometryBuffer on a node other than a MeshWriterNode, a point or path node for example, reports the node's own vertices, downloaded from the device when a VertexFieldProcessor is on the buffer. An InstanceNetworkBuffer reports the union of its slots' bounds through the slot transforms as the CPU holds them; the eight corners are placed, so a rotated slot is bounded loosely, and a transform a GPU kernel drives is not seen. Other mesh buffers are read as read_anchor reads them. Blocks for a ComputeMeshBuffer and for a buffer a field processor drives: call it from a FRAME_ACCURATE metro or the main thread, never the graphics thread.

Parameters

buf	Buffer to read.
collection	Collection of a NetworkGeometryBuffer to bound, if not all of it. Ignored for other buffers.

Returns

The bounds, or nullopt when no geometry can be read from the buffer.

Definition at line 256 of file Survey.cpp.

{
    if (const auto volume = std::dynamic_pointer_cast<Buffers::VolumeGridBuffer>(buf)) {
        return volume->get_bounds();
    }
 
    if (const auto network_buffer = std::dynamic_pointer_cast<Buffers::NetworkGeometryBuffer>(buf)) {
        const auto cloud = network_cloud(network_buffer);
        if (!cloud || cloud->positions.empty()) {
            return std::nullopt;
        }
        if (!collection) {
            return Kinesis::aabb(cloud->positions);
        }
 
        std::vector<glm::vec3> chosen;
        const size_t count = std::min(cloud->positions.size(), cloud->clusters.size());
        for (size_t i = 0; i < count; ++i) {
            if (cloud->clusters.at(i) == *collection) {
                chosen.push_back(cloud->positions.at(i));
            }
        }
        return chosen.empty() ? std::nullopt : std::optional<Kinesis::AABB3D> { Kinesis::aabb(chosen) };
    }
 
    if (const auto geometry = std::dynamic_pointer_cast<Buffers::GeometryBuffer>(buf)) {
        if (const auto cloud = node_cloud(geometry); cloud && !cloud->positions.empty()) {
            return Kinesis::aabb(cloud->positions);
        }
    }
 
    if (const auto instances = std::dynamic_pointer_cast<Buffers::InstanceNetworkBuffer>(buf)) {
        return instance_bounds(instances);
    }
 
    const auto mesh = snapshot_mesh(buf);
    const auto* vertices = mesh ? std::get_if<std::vector<uint8_t>>(&mesh->vertex_variant) : nullptr;
    if (!vertices) {
        return std::nullopt;
    }
 
    const auto positions = decode_positions(*vertices, mesh->layout);
    return positions && !positions->empty() ? std::optional<Kinesis::AABB3D> { Kinesis::aabb(*positions) } : std::nullopt;
}

References count, positions, and read_bounds().

Referenced by MayaFlux::Nexus::Hull::Hull(), MayaFlux::Nexus::Mantle::Mantle(), read_bounds(), MayaFlux::Nexus::Hull::refit(), and MayaFlux::Nexus::Mantle::refit().

Here is the call graph for this function:

Here is the caller graph for this function: