Enum FillMode 

pub enum FillMode {
    SurfaceOnly,
    FloodFill {
        detect_cavities: bool,
        detect_self_intersections: bool,
    },
}

Controls how voxelization determines which voxels are filled vs empty.

The fill mode is a critical parameter that determines the structure of the resulting voxel set. Choose the appropriate mode based on whether you need just the surface boundary or a solid volume.

Variants

SurfaceOnly

Only voxels that intersect the input surface boundary (triangle mesh in 3D, polyline in 2D) are marked as filled. This creates a hollow shell representation.

Use this when:

• You only need the surface boundary
• Memory is limited (fewer voxels to store)
• You’re approximating a thin shell or surface

Example:

use parry3d::transformation::voxelization::{FillMode, VoxelSet};
use parry3d::shape::Ball;
///
let ball = Ball::new(1.0);
let (vertices, indices) = ball.to_trimesh(20, 20);

let surface_voxels = VoxelSet::voxelize(
    &vertices,
    &indices,
    10,
    FillMode::SurfaceOnly,  // Only the shell
    false,
);

// All voxels are on the surface
assert!(surface_voxels.voxels().iter().all(|v| v.is_on_surface));

FloodFill

Marks surface voxels AND all interior voxels as filled, creating a solid volume. Uses a flood-fill algorithm starting from outside the shape to determine inside vs outside.

Fields:

• detect_cavities: If true, properly detects and preserves internal cavities/holes. If false, all enclosed spaces are filled (faster but may fill unintended regions).

• detect_self_intersections (2D only): If true, attempts to handle self-intersecting polylines correctly. More expensive but more robust.

Use this when:

• You need volume information (mass properties, volume computation)
• You want a solid representation for collision detection
• You need to distinguish between interior and surface voxels

Example:

use parry3d::transformation::voxelization::{FillMode, VoxelSet};
use parry3d::shape::Ball;
///
let ball = Ball::new(1.0);
let (vertices, indices) = ball.to_trimesh(20, 20);

let solid_voxels = VoxelSet::voxelize(
    &vertices,
    &indices,
    15,
    FillMode::FloodFill {
        detect_cavities: false,  // No cavities in a sphere
    },
    false,
);

// Mix of surface and interior voxels
let surface_count = solid_voxels.voxels().iter().filter(|v| v.is_on_surface).count();
let interior_count = solid_voxels.voxels().iter().filter(|v| !v.is_on_surface).count();
assert!(surface_count > 0 && interior_count > 0);

Performance Notes

• SurfaceOnly is faster and uses less memory than FloodFill
• detect_cavities = true adds computational overhead but gives more accurate results
• For simple convex shapes, detect_cavities = false is usually sufficient

Variants

SurfaceOnly

Only consider full the voxels intersecting the surface of the shape being voxelized.

FloodFill

Use a flood-fill technique to consider fill the voxels intersecting the surface of the shape being voxelized, as well as all the voxels bounded of them.

Fields

detect_cavities: bool

Detects holes inside of a solid contour.

detect_self_intersections: bool

Attempts to properly handle self-intersections.

Trait Implementations

impl Clone for FillMode

fn clone(&self) -> FillMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FillMode

impl Debug for FillMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FillMode

fn default() -> Self

Returns the “default value” for a type.

impl Eq for FillMode

impl PartialEq for FillMode

fn eq(&self, other: &FillMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for FillMode