avila-optimizer

Mesh optimization for BIM/CAD models - 100% Rust, zero dependencies beyond the Avila ecosystem.

Features

• Mesh Merging - Combine multiple meshes sharing the same material into a single draw call
• Vertex Deduplication - Remove duplicate vertices to reduce memory usage
• LOD Generation - Generate multiple Levels of Detail for distance-based rendering
• Spatial Indexing - Octree-based spatial partitioning for view frustum culling
• Pipeline Integration - Seamlessly integrates with avila-mesh and avila-vec3d

Installation

[dependencies]
avila-optimizer = "0.1.0"

Quick Start

use avila_optimizer::*;
use avila_mesh::*;

// Create a scene with multiple meshes
let mut scene = Scene::new();
scene.add_mesh(primitives::cube(1.0));
scene.add_mesh(primitives::cube(1.0));
scene.add_mesh(primitives::sphere(0.5, 16));

// Optimize everything
let optimizer = Optimizer::new();
let optimized = optimizer.optimize_scene(&scene)?;

// Result:
// - Meshes merged by material
// - Multiple LOD levels generated
// - Spatial index for culling

Mesh Merging

Combines meshes sharing the same material into a single mesh, reducing draw calls:

use avila_optimizer::MeshMerger;

let mut scene = Scene::new();
// Add 100 meshes with same material
for i in 0..100 {
    let mut cube = primitives::cube(1.0);
    cube.material_id = Some("concrete".to_string());
    scene.add_mesh(cube);
}

let merger = MeshMerger::new();
let merged_scene = merger.merge_scene(&scene)?;

// Result: 100 meshes → 1 mesh (single draw call!)
assert_eq!(merged_scene.meshes.len(), 1);

Vertex Deduplication

The merger automatically removes duplicate vertices within a tolerance:

let mut merger = MeshMerger::new();
merger.vertex_tolerance = 0.001; // 1mm tolerance

let merged = merger.merge_meshes(&[&mesh1, &mesh2, &mesh3])?;
// Vertices within 1mm are merged

LOD Generation

Generate multiple Levels of Detail for performance optimization:

use avila_optimizer::LodGenerator;

let high_poly_mesh = primitives::sphere(1.0, 128); // 16k triangles

let lod_gen = LodGenerator::new();
let lods = lod_gen.generate_lods(&high_poly_mesh)?;

// lods[0] = 100% detail (original)
// lods[1] = 50% detail
// lods[2] = 25% detail
// lods[3] = 12.5% detail

Custom ratios:

let mut lod_gen = LodGenerator::new();
lod_gen.ratios = vec![0.75, 0.5, 0.25, 0.1]; // 4 LOD levels

let lods = lod_gen.generate_lods(&mesh)?;

Spatial Indexing

Octree-based spatial partitioning for efficient culling:

use avila_optimizer::Octree;
use avila_vec3d::*;

// Create octree covering scene bounds
let bounds = Aabb::new(
    Vec3::new(-100.0, -100.0, -100.0),
    Vec3::new(100.0, 100.0, 100.0)
);
let mut octree = Octree::new(bounds);

// Insert meshes
for (i, mesh) in scene.meshes.iter().enumerate() {
    octree.insert(i, &mesh.bounds);
}

// Query visible meshes
let camera_frustum = Aabb::new(
    Vec3::new(-10.0, -10.0, 0.0),
    Vec3::new(10.0, 10.0, 50.0)
);
let visible_indices = octree.query(&camera_frustum);

// Render only visible meshes
for &idx in &visible_indices {
    render(&scene.meshes[idx]);
}

Complete Optimization Pipeline

The Optimizer combines all optimizations:

use avila_optimizer::Optimizer;

let optimizer = Optimizer::new();
let optimized = optimizer.optimize_scene(&scene)?;

// Access optimized data:
// 1. Base scene (merged meshes)
let base_scene = &optimized.base_scene;

// 2. LOD levels per mesh
for (mesh_idx, lods) in optimized.lods.iter().enumerate() {
    println!("Mesh {} has {} LOD levels", mesh_idx, lods.len());
}

// 3. Spatial index for culling
let visible = optimized.spatial_index.query(&camera_bounds);

// 4. Select LOD based on distance
let distance = 50.0;
if let Some(lod_mesh) = optimized.select_lod(0, distance) {
    render(lod_mesh);
}

LOD Selection

Automatic LOD selection based on camera distance:

// Render loop
for (i, _) in optimized.base_scene.meshes.iter().enumerate() {
    let mesh_center = optimized.base_scene.meshes[i].bounds.center();
    let distance = (camera_position - mesh_center).length();
    
    // Select appropriate LOD
    if let Some(lod) = optimized.select_lod(i, distance) {
        render(lod);
    }
}

Distance thresholds (default):

• < 10m → LOD 0 (full detail)
• 10-50m → LOD 1 (50%)
• 50-100m → LOD 2 (25%)
• > 100m → LOD 3 (12.5%)

Architecture

Built from the ground up using only Avila primitives:

avila-optimizer
├── avila-mesh ←───── Mesh structures, PBR materials
│   └── avila-vec3d ← Vec3, Mat4, AABB, Ray
└── thiserror ←────── Error handling

Zero dependencies on external geometry libraries - everything from scratch.

Performance

Typical optimizations on a BIM model with 10,000 meshes:

Integration with BIM Pipeline

use avila_optimizer::Optimizer;
use avila_tesselation::Tesselator;
use avila_gltf::GltfExporter;

// 1. Tesselate IFC geometry
let tesselator = Tesselator::new();
let mut scene = Scene::new();
for ifc_solid in ifc_solids {
    let mesh = tesselator.tesselate(&ifc_solid)?;
    scene.add_mesh(mesh);
}

// 2. Optimize
let optimizer = Optimizer::new();
let optimized = optimizer.optimize_scene(&scene)?;

// 3. Export base + LODs
let exporter = GltfExporter::new();
exporter.export_glb(&optimized.base_scene, "model.glb")?;
exporter.export_glb(&Scene { meshes: vec![optimized.lods[0][1].clone()], ..Default::default() }, "model_lod1.glb")?;

License

MIT OR Apache-2.0