Struct FlameModel 

pub struct FlameModel {
    pub v_template: Array2<f32>,
    pub faces: Vec<[u32; 3]>,
    pub shapedirs: Array3<f32>,
    pub expressiondirs: Array3<f32>,
    pub posedirs: Array3<f32>,
    pub j_regressor: Array2<f32>,
    pub parents: Vec<i32>,
    pub lbs_weights: Array2<f32>,
    pub n_joints: usize,
}

The loaded FLAME parametric head model.

Immutable after construction — call forward with different FlameParams to produce posed meshes.

Fields

v_template: Array2<f32>

Template (rest-pose) vertex positions [N, 3].

faces: Vec<[u32; 3]>

Triangle face indices.

shapedirs: Array3<f32>

Shape blend-shape directions [N, 3, n_shape].

expressiondirs: Array3<f32>

Expression blend-shape directions [N, 3, n_expr].

posedirs: Array3<f32>

Pose corrective blend-shape directions [N, 3, (n_joints-1)*9].

j_regressor: Array2<f32>

Joint regressor matrix [n_joints, N].

parents: Vec<i32>

Parent joint index for each joint (root = -1).

lbs_weights: Array2<f32>

LBS skinning weights [N, n_joints].

n_joints: usize

Number of joints (5 for FLAME).

Implementations

impl FlameModel

pub fn load(dir: impl AsRef<Path>) -> Result<Self, FlameError>

Load a FLAME model from a directory of .npy files produced by scripts/convert_flame.py.

Errors

Returns an error if:

• The directory does not exist
• Required .npy files are missing
• Array shapes do not match expected dimensions

pub fn num_vertices(&self) -> usize

Number of template vertices (5023 for standard FLAME).

pub fn forward(&self, params: &FlameParams) -> Mesh

Compute the posed mesh from FLAME parameters.

pub fn forward_batch(&self, params_batch: &[FlameParams]) -> Vec<Mesh>

Process multiple parameter sets sequentially.

Shares the model weights across all meshes in the batch.

Arguments

• params_batch - Slice of FLAME parameters for each mesh

Returns

Vector of posed meshes, one per parameter set.

pub fn forward_batch_optimized( &self, params_batch: &[FlameParams], ) -> BatchedFlameOutput

Process multiple parameter sets with pre-allocated output buffers.

This method is more memory-efficient than forward_batch when processing many batches repeatedly, as it returns a BatchedFlameOutput with pre-allocated buffers that can be reused.

Arguments

• params_batch - Slice of FLAME parameters for each mesh

Returns

BatchedFlameOutput containing all vertices and normals with shared faces.

pub fn forward_batch_with_pool( &self, params_batch: &[FlameParams], buffer_pool: &mut BatchBufferPool, ) -> BatchedFlameOutput

Process multiple parameter sets with buffer pool for intermediate values.

This method reuses intermediate buffers across the batch to minimize memory allocations during the forward pass.

Arguments

• params_batch - Slice of FLAME parameters for each mesh
• buffer_pool - Pre-allocated buffer pool for intermediate values

Returns

BatchedFlameOutput containing all vertices and normals.

Example

let model = FlameModel::load("path/to/flame")?;
let mut pool = BatchBufferPool::new(16, model.num_vertices(), 5);

// Reuse pool across multiple batch calls
for _ in 0..100 {
    let params_batch: Vec<FlameParams> = vec![/* ... */];
    let output = model.forward_batch_with_pool(&params_batch, &mut pool);
}

pub fn create_buffer_pool(&self, batch_size: usize) -> BatchBufferPool

Create a buffer pool sized for this model.

Arguments

• batch_size - Maximum batch size to support

pub fn forward_into( &self, params: &FlameParams, vertices_out: &mut [Point3<f32>], normals_out: &mut [Vector3<f32>], )

Compute the posed mesh, writing directly to provided output buffers.

This method avoids allocation by writing vertices and normals directly to the provided slices.

Arguments

• params - FLAME parameters
• vertices_out - Output buffer for vertices (must have correct size)
• normals_out - Output buffer for normals (must have correct size)