Enum ShapePlan 

pub(super) enum ShapePlan {
    Identity,
    Shared {
        shapes: Vec<usize>,
        rows: Vec<PlannedRow>,
    },
}

Which shapes get their vertices written, and how each mesh row reaches one.

Identity carries NO data on purpose: its plan is a function of the mesh index alone, so materializing it would allocate ~80 bytes per mesh — on every streamed batch of a writer that shares nothing — to store i and nine repeated constants.

Variants

Identity

The -parquet-v8 layout: every mesh writes its own geometry. What the streaming route uses unless the client opted in to cross-batch sharing.

Shared

The -parquet-v9 layout.

Fields

shapes: Vec<usize>

Mesh indices whose vertex/index data is emitted, in emission order.

rows: Vec<PlannedRow>

One entry per input mesh, parallel to the mesh slice.

Implementations

impl ShapePlan

pub(super) fn shared_shapes( meshes: &[MeshData], baked_basis: Option<&Matrix4<f64>>, ) -> Self

Plan a whole model (the buffered route) in the SAME two-stage order /optimized uses (issue #5130): the rotation-aware collator (collate_rotation_aware_placements) runs first, and every occurrence it did not place falls through to a content hash of its (origin-relative) vertex and index buffers (mesh_geometry_key), so bit-identical occurrences the collator has no group for still collapse onto one shape.

Stage 1 reuses the collator verbatim — the same grouping, the same per-vertex residual check, the same all-or-nothing per group — so the flat route can never share a shape the /optimized route would have refused to share. Stage 2 mirrors serialize_to_parquet_optimized’s None branch: the hash’s first occurrence (by mesh index, not by slot) becomes the shared shape every later bit-identical occurrence points at.

Returns ShapePlan::Identity only when NEITHER stage shared anything — a hash-only match must still return Shared, not just a collator match — so a model with no repeats at all emits the v5 layout through the same path it always did rather than through a Shared plan that happens to be one-to-one.

pub(super) fn shared_shapes_after( meshes: &[MeshData], baked_basis: Option<&Matrix4<f64>>, prior: &PriorShapes, ) -> (Self, Vec<NewShape>)

Plan one stream batch against the shapes earlier batches emitted (#5407). Everything Self::shared_shapes shares inside the batch is still shared; on top of that, a shape whose content hash matches one in prior is not written again — the row carries the earlier block’s whole-stream range instead.

Stage 1 reaches across batches the same way: every retained template whose representation occurs in this batch is put in FRONT of it for the collator, which takes a group’s first member as its template, so this batch’s occurrences are verified against the very geometry an earlier batch emitted and placed on its block.

Also returns every shape this batch DOES emit, in emission order, with its content hash, so the caller can record where each one lands without hashing its geometry a second time.

baked_basis is the stream’s frame, which the pipeline publishes before its first batch; None costs a site-rotated model its rotated sharing (#4118), never correctness.

pub(super) fn shape_meshes<'a>( &self, meshes: &'a [MeshData], ) -> Vec<&'a MeshData>

The meshes whose geometry is emitted, in emission order.

pub(super) fn row( &self, meshes: &[MeshData], i: usize, ) -> (ShapeRef, [f64; 3], [f32; 9])

Mesh row i’s shape and the placement mapping that shape’s geometry onto this occurrence. Computed, not stored, under Identity.

pub(super) fn row_count(&self) -> Option<usize>

The mesh count this plan was built for; None fits any slice.