from_network()

std::optional< SpatialHashConfig > MayaFlux::Buffers::SpatialHashConfig::from_network ( const std::shared_ptr< NetworkGeometryBuffer > &  buffer, float  cell_size  )

static

Build hash grid parameters from a NetworkGeometryBuffer's network and its primary operator.

Parameters

buffer

Buffer whose network supplies particle_count, vertex layout and bounds. Reads the layout from the network's own GraphicsOperator (e.g. PhysicsOperator::get_vertex_layout), not from the buffer's cached copy: that copy is written by NetworkGeometryProcessor during upload and unset before the first cycle, whereas the operator's own layout is valid the moment create_operator<PhysicsOperator>() (or equivalent) returns. Callable synchronously right after setup, with no need to wait for a processing cycle.

cell_size

Grid cell size. Ordinarily PhysicsOperator's own interaction radius when the network is physics-driven; there is no generic source for this, since not every ParticleNetwork operator has an equivalent concept, so the caller supplies it directly.

Returns

Populated config, or nullopt when the buffer's network is neither a ParticleNetwork nor a PointCloudNetwork, its primary operator is not a GraphicsOperator (or none is set), that operator's layout carries no word-aligned position attribute, or cell_size is not positive.

Definition at line 17 of file SpatialHashProcessor.cpp.

{
    if (cell_size <= 0.0F) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "SpatialHashConfig::from_network: cell_size {} is not positive", cell_size);
        return std::nullopt;
    }
 
    const auto network = buffer->get_network();
 
    Kinesis::SamplerBounds bounds;
    if (auto particle_net = std::dynamic_pointer_cast<Nodes::Network::ParticleNetwork>(network)) {
        bounds = particle_net->get_bounds();
    } else if (auto cloud_net = std::dynamic_pointer_cast<Nodes::Network::PointCloudNetwork>(network)) {
        bounds = cloud_net->get_bounds();
    } else {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "SpatialHashConfig::from_network: buffer's network is neither a ParticleNetwork "
            "nor a PointCloudNetwork");
        return std::nullopt;
    }
 
    auto* graphics_op = dynamic_cast<Nodes::Network::GraphicsOperator*>(network->get_operator());
    if (!graphics_op) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "SpatialHashConfig::from_network: network's primary operator is not a "
            "GraphicsOperator, or none is set. create_operator<PhysicsOperator>() (or "
            "equivalent) must run before this.");
        return std::nullopt;
    }
 
    const auto layout = graphics_op->get_vertex_layout();
 
    if (layout.stride_bytes == 0 || layout.stride_bytes % 4 != 0) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "SpatialHashConfig::from_network: stride {} is not a nonzero multiple of 4",
            layout.stride_bytes);
        return std::nullopt;
    }
 
    const auto position_offset = layout.find_word_offset(Kakshya::DataModality::VERTEX_POSITIONS_3D);
    if (!position_offset.has_value()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "SpatialHashConfig::from_network: vertex layout carries no word-aligned "
            "position attribute");
        return std::nullopt;
    }
 
    const glm::vec3 extent = bounds.max - bounds.min;
 
    const glm::uvec3 dims {
        std::max(1U, static_cast<uint32_t>(std::ceil(extent.x / cell_size))),
        std::max(1U, static_cast<uint32_t>(std::ceil(extent.y / cell_size))),
        std::max(1U, static_cast<uint32_t>(std::ceil(extent.z / cell_size))),
    };
 
    return SpatialHashConfig {
        .grid_min = bounds.min,
        .grid_dims = dims,
        .cell_size = cell_size,
        .particle_count = static_cast<uint32_t>(graphics_op->get_vertex_count()),
        .stride_words = layout.stride_bytes / 4,
        .position_word_offset = *position_offset,
    };
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, cell_size, grid_min, MayaFlux::Kinesis::SamplerBounds::max, MF_ERROR, MayaFlux::Kinesis::SamplerBounds::min, network, stride_words, and MayaFlux::Kakshya::VERTEX_POSITIONS_3D.

Referenced by MayaFlux::Buffers::NetworkGeometryBuffer::wire_field_operators().

Here is the caller graph for this function: