Struct Refiner 

pub struct Refiner { /* private fields */ }

Subdivision refiner with validated topology and cached analysis.

Create a Refiner once for a given topology + scheme, then call refine_topology for the cached two-phase API or refine_uniform for the one-shot RefinementResult-returning API.

Example

use core::num::NonZeroU8;
let refiner = Refiner::new(topology, Scheme::CatmullClark, SchemeOptions::default())?;
let req = UniformRefine { levels: NonZeroU8::new(2).unwrap(), ..Default::default() };
let result = refiner.refine_uniform(&req)?;
let positions = result.interpolate(&my_positions);

Implementations

impl Refiner

pub fn new( topology: Mesh, scheme: Scheme, options: SchemeOptions, ) -> Result<Self, KernelError>

Create a new refiner, validating the input topology.

pub fn topology(&self) -> &Mesh

Access the input topology.

pub fn scheme(&self) -> Scheme

Access the scheme.

pub fn options(&self) -> &SchemeOptions

Access the scheme options.

pub fn refine_topology( &self, req: &UniformRefine, ) -> Result<Refinement, KernelError>

Build and cache per-level topology for all refinement levels.

This is the expensive phase (edge discovery, adjacency construction). Call Refinement::vertex_stencils and Refinement::face_varying_stencils to compute stencils from the cached topology without redundant edge rebuilds.

pub fn refine_uniform( &self, req: &UniformRefine, ) -> Result<RefinementResult, KernelError>

Perform uniform refinement, producing refined topology + vertex stencils.

The returned StencilTables map input vertex data to refined vertex data. Apply them with StencilTable::interpolate to any buffer, or use RefinementResult::interpolate to chain through all levels in one call.

pub fn face_varying_stencils( &self, req: &UniformRefine, channel: &FaceVaryingChannel, mode: FaceVaryingInterpolation, ) -> Result<Vec<StencilTable>, KernelError>

Compute per-level face-varying stencil tables for a channel.

Returns one StencilTable per refinement level. Use the same chaining pattern as RefinementResult::interpolate:

let fvar_tables = refiner.face_varying_stencils(&req, &channel, mode)?;
let mut uvs = my_uvs.to_vec();
for table in &fvar_tables {
    uvs = table.interpolate(&uvs);
}