write_operator_sample()

bool MayaFlux::IO::write_operator_sample	(	SpatialCache &	cache,
		const std::string &	stream_name,
		const Nodes::Network::GraphicsOperator *	op
	)

Pack one GraphicsOperator's current vertex state into a SpatialCache stream, as a Points or Curves sample depending on what the operator declares.

Reads op->get_vertex_data() as Kakshya::Vertex records: PointVertex, LineVertex, and MeshVertex all share its exact 60-byte layout, so this works unchanged for any GraphicsOperator, not only PhysicsOperator. Every field comes along, not only position: color, scalar (size/thickness/ weight depending on the concrete type), uv, normal, and tangent each become their own SpatialAttribute, so a vertex reaches the archive whole rather than reduced to a coordinate. Always attaches a "cluster" attribute from op->build_cluster_ids() (0 for every vertex on an operator that never overrides it), plus one SpatialAttribute per op->extract_vertex_attributes() entry (extra state beyond the vertex record itself, e.g. PhysicsOperator's mass).

op->declared_topology() decides the sample's shape:

• nullopt or POINT_LIST: the point path. ids are the vertex's own index within this operator, for cross-sample identity tracking, and native velocities come from op->extract_vertex_velocities() when non-empty.
• LINE_STRIP (PathOperator): one curve per contiguous build_cluster_ids() run, matching one path per continuous interpolated strip.
• LINE_LIST (TopologyOperator): fixed 2-vertex curves, one per expanded edge, since a graph's edges are independent segments, not one connected strip through the whole graph. Curve samples carry no ids/velocities (Alembic's Curves schema has neither) and fail outright if declared_topology() reports LINE_LIST for an odd vertex count, which no known producer of that topology should do.

Parameters

cache	Target cache, already open().
stream_name	Stream to write.
op	Source operator. Must be non-null, report at least one vertex, and use the Kakshya::Vertex record layout (every GraphicsOperator does today).

Returns

False if op is null, reports zero vertices, its vertex layout is not a Kakshya::Vertex record, its vertex buffer is smaller than layout.stride_bytes * get_vertex_count(), any extract_vertex_attributes()/extract_vertex_velocities() entry disagrees with get_vertex_count() in size, or a LINE_LIST topology's vertex count is odd.

Definition at line 156 of file SpatialExport.cpp.

{
    if (!op) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write_operator_sample: null operator");
        return false;
    }
 
    const size_t vertex_count = op->get_vertex_count();
    if (vertex_count == 0) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write_operator_sample: operator reports zero vertices");
        return false;
    }
 
    const Kakshya::VertexLayout layout = op->get_vertex_layout();
    const std::span<const uint8_t> raw = op->get_vertex_data();
    if (layout.stride_bytes == 0 || raw.size() < static_cast<size_t>(layout.stride_bytes) * vertex_count) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write_operator_sample: vertex buffer smaller than layout implies");
        return false;
    }
 
    std::vector<glm::vec3> positions;
    std::vector<SpatialAttribute> attributes;
    if (!extract_vertex_columns(layout, raw, vertex_count, positions, attributes)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write_operator_sample: vertex layout is not a Kakshya::Vertex record");
        return false;
    }
 
    std::vector<uint32_t> cluster_ids = op->build_cluster_ids();
    if (cluster_ids.size() != vertex_count) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write_operator_sample: build_cluster_ids() count mismatch");
        return false;
    }
 
    const auto topology = op->declared_topology().value_or(Portal::Graphics::PrimitiveTopology::POINT_LIST);
    std::optional<std::vector<int32_t>> vertex_counts_per_curve;
    if (topology == Portal::Graphics::PrimitiveTopology::LINE_LIST
        || topology == Portal::Graphics::PrimitiveTopology::LINE_STRIP) {
        vertex_counts_per_curve = curve_vertex_counts(topology, cluster_ids, vertex_count);
        if (!vertex_counts_per_curve) {
            MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                "write_operator_sample: {} vertices cannot form LINE_LIST pairs", vertex_count);
            return false;
        }
    }
 
    attributes.push_back(SpatialAttribute {
        .name = "cluster",
        .scope = SpatialScope::Varying,
        .values = Kakshya::DataVariant { std::move(cluster_ids) } });
 
    for (auto& [name, values] : op->extract_vertex_attributes()) {
        const size_t count = std::visit([](const auto& v) { return v.size(); }, values);
        if (count != vertex_count) {
            MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                "write_operator_sample: extract_vertex_attributes() '{}' count mismatch", name);
            return false;
        }
        attributes.push_back(SpatialAttribute {
            .name = name,
            .scope = SpatialScope::Varying,
            .values = std::move(values) });
    }
 
    if (vertex_counts_per_curve) {
        return cache.write(stream_name,
            SpatialSample {
                .topology = topology,
                .positions = positions,
                .vertex_counts_per_curve = *vertex_counts_per_curve,
                .attributes = attributes });
    }
 
    std::vector<uint64_t> ids(vertex_count);
    std::ranges::iota(ids, uint64_t { 0 });
 
    std::vector<glm::vec3> velocities = op->extract_vertex_velocities();
    if (!velocities.empty() && velocities.size() != vertex_count) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write_operator_sample: extract_vertex_velocities() count mismatch");
        return false;
    }
 
    return cache.write(stream_name,
        SpatialSample {
            .topology = Portal::Graphics::PrimitiveTopology::POINT_LIST,
            .positions = positions,
            .ids = ids,
            .velocities = velocities,
            .attributes = attributes });
}

References MayaFlux::Nodes::Network::GraphicsOperator::build_cluster_ids(), count, MayaFlux::Nodes::Network::GraphicsOperator::declared_topology(), MayaFlux::Nodes::Network::GraphicsOperator::extract_vertex_attributes(), MayaFlux::Nodes::Network::GraphicsOperator::extract_vertex_velocities(), MayaFlux::Journal::FileIO, MayaFlux::Nodes::Network::GraphicsOperator::get_vertex_count(), MayaFlux::Nodes::Network::GraphicsOperator::get_vertex_data(), MayaFlux::Nodes::Network::GraphicsOperator::get_vertex_layout(), MayaFlux::Journal::IO, MayaFlux::Portal::Graphics::LINE_LIST, MayaFlux::Portal::Graphics::LINE_STRIP, MF_ERROR, name, MayaFlux::IO::SpatialAttribute::name, MayaFlux::Portal::Graphics::POINT_LIST, MayaFlux::Kakshya::VertexLayout::stride_bytes, MayaFlux::IO::SpatialSample::topology, values, Varying, and MayaFlux::IO::SpatialCache::write().

Referenced by write_network_geometry_buffer_sample().

Here is the call graph for this function:

Here is the caller graph for this function: