Struct ShellBuilder 

pub struct ShellBuilder<'a> { /* private fields */ }

Fluent builder for shell generation.

ShellBuilder provides a chainable API for configuring shell generation parameters before executing the operation. This is the recommended way to generate shells when you need custom configuration.

Example

use mesh_repair::Mesh;
use mesh_shell::ShellBuilder;

let mesh = Mesh::load("scan.stl").unwrap();

// Simple usage with defaults
let result = ShellBuilder::new(&mesh)
    .offset(2.0)
    .build()
    .unwrap();

// Advanced usage with custom settings
let result = ShellBuilder::new(&mesh)
    .offset(3.0)
    .wall_thickness(2.0)
    .voxel_size(0.5)
    .use_gpu(true)
    .high_quality()
    .build()
    .unwrap();

Implementations

impl<'a> ShellBuilder<'a>

pub fn new(mesh: &'a Mesh) -> Self

Create a new ShellBuilder for the given mesh.

Arguments

• mesh - The input mesh to generate a shell around

Example

use mesh_repair::Mesh;
use mesh_shell::ShellBuilder;

let mesh = Mesh::load("scan.stl").unwrap();
let builder = ShellBuilder::new(&mesh);

pub fn offset(self, offset: f64) -> Self

Set the offset distance in mm.

This is the distance to offset the surface outward (positive) or inward (negative). For custom-fit products like shoe insoles, this is typically 1-5mm.

Arguments

• offset - Offset distance in millimeters

Example

use mesh_repair::Mesh;
use mesh_shell::ShellBuilder;

let mesh = Mesh::load("scan.stl").unwrap();
let result = ShellBuilder::new(&mesh)
    .offset(2.5)  // 2.5mm outward
    .build()
    .unwrap();

pub fn voxel_size(self, size: f64) -> Self

Set the voxel size for SDF computation in mm.

Smaller voxels give more detail but use more memory and time. The default (0.75mm) is a good balance for most use cases.

Arguments

• size - Voxel size in millimeters

Recommendations

• High quality: 0.3-0.5mm
• Standard: 0.5-1.0mm
• Fast/large meshes: 1.0-2.0mm

pub fn padding(self, padding: f64) -> Self

Set padding beyond mesh bounds in mm.

This ensures the SDF grid extends far enough beyond the mesh to capture the full offset surface.

pub fn max_voxels(self, max: usize) -> Self

Set maximum number of voxels (memory limit).

If the required grid would exceed this, an error is returned. Default is 50 million voxels (~200MB for SDF values).

pub fn adaptive(self, enable: bool) -> Self

Enable adaptive multi-resolution SDF.

Uses coarse voxels far from the surface and fine voxels near it. This significantly reduces memory usage for large meshes while maintaining detail quality near the surface.

pub fn use_gpu(self, enable: bool) -> Self

Enable GPU acceleration for SDF computation.

When enabled and a GPU is available, SDF computation uses GPU compute shaders for significant speedup (3-68x faster for small-medium meshes).

Falls back to CPU if GPU is unavailable.

pub fn wall_thickness(self, thickness: f64) -> Self

Set uniform wall thickness in mm.

This is the thickness of the shell walls. For 3D printing, typical values are 1.5-4mm depending on the application.

Arguments

• thickness - Wall thickness in millimeters

pub fn thickness_map(self, map: ThicknessMap) -> Self

Set variable wall thickness using a thickness map.

This allows different wall thicknesses in different regions (e.g., thick heel cup, thin arch in a shoe insole).

Arguments

• map - ThicknessMap with per-vertex or per-region thickness values

pub fn min_thickness(self, thickness: f64) -> Self

Set minimum acceptable wall thickness in mm.

Used during validation to flag walls that are too thin for reliable 3D printing.

pub fn validate(self, enable: bool) -> Self

Enable or disable post-generation validation.

When enabled, the generated shell is validated for manifoldness, wall thickness, and other quality metrics.

pub fn fast_walls(self) -> Self

Use normal-based wall generation (fast but less accurate).

Each vertex is offset along its normal. Fast, but wall thickness may vary at corners (thinner at convex, thicker at concave).

pub fn sdf_walls(self) -> Self

Use SDF-based wall generation (slower but consistent thickness).

Computes a signed distance field and extracts an isosurface. This ensures consistent wall thickness regardless of curvature.

pub fn high_quality(self) -> Self

Apply high-quality preset settings.

Uses SDF-based wall generation with fine voxel resolution for consistent wall thickness and smooth surfaces.

pub fn fast(self) -> Self

Apply fast preset settings.

Uses normal-based wall generation with coarser resolution. Good for quick previews or when speed is more important than quality.

pub fn large_mesh(self) -> Self

Apply settings optimized for large meshes.

Uses adaptive resolution and larger voxels to handle meshes with hundreds of thousands of triangles.

pub fn with_progress(self, callback: ProgressCallback) -> Self

Set a progress callback.

The callback receives:

• progress: 0.0-1.0 completion percentage
• stage: Description of current stage

Return false from the callback to cancel the operation.

Example

use mesh_repair::Mesh;
use mesh_repair::progress::ProgressCallback;
use mesh_shell::ShellBuilder;

let mesh = Mesh::load("scan.stl").unwrap();

let callback: ProgressCallback = Box::new(|progress| {
    println!("{}%: {}", progress.percent(), progress.message);
    true // continue
});

let result = ShellBuilder::new(&mesh)
    .offset(2.0)
    .with_progress(callback)
    .build();

pub fn build(self) -> ShellResult<ShellBuildResult>

Build the shell with the configured parameters.

This executes the full shell generation pipeline:

1. Apply SDF offset to create inner surface
2. Generate outer surface with walls
3. Create rim connecting inner and outer
4. Validate result (if enabled)

Returns

A ShellBuildResult containing the generated mesh and statistics.

Errors

Returns an error if:

• The mesh is empty or invalid
• The voxel grid would exceed memory limits
• Shell generation fails for any reason

pub fn build_offset_only(self) -> ShellResult<SdfOffsetResult>

Build only the offset surface (no walls).

This is useful when you want the inner surface without generating a full shell with walls.

Returns

The offset result containing the inner surface mesh.