Skip to content

timschmidt/csgrs

BranchesTags

Repository files navigation

csgrs

A fast, optionally multithreaded Constructive Solid Geometry (CSG) library in Rust, built around Boolean operations (union, difference, intersection, xor) on several different internal geometry representations. csgrs provides data structures and methods for constructing 2D and 3D geometry with an OpenSCAD-like syntax. Our aim is for csgrs to be light weight and full featured through integration with the Dimforge ecosystem (e.g., nalgebra, Parry, and Rapier) and geo for robust processing of Simple Features. csgrs has a number of functions useful for generating CNC toolpaths. The library can be built for 32bit or 64bit floats, and for WASM. Dependencies are 100% rust and nearly all optional.

Earcut and constrained delaunay algorithms used for triangulation only work in 2D, so csgrs rotates 3D polygons into 2D for triangulation then back to 3D.

Example CSG output

Community

Getting started

Install the Rust language tools from rustup.rs.

cargo new my_cad_project
cd my_cad_project
cargo add csgrs

Example main.rs

// Alias the library’s generic Mesh type with empty metadata:
type Mesh = csgrs::mesh::Mesh<()>;

// Create two shapes:
let cube = Mesh::cube(2.0, None);  // 2×2×2 cube at origin, no metadata
let sphere = Mesh::sphere(1.0, 16, 8, None); // sphere of radius=1 at origin, no metadata

// Difference one from the other:
let difference_result = cube.difference(&sphere);

// Write the result as an ASCII STL:
let stl = difference_result.to_stl_ascii("cube_minus_sphere");
std::fs::write("cube_sphere_difference.stl", stl).unwrap();

Building for WASM

cargo build --features="wasm" --target=wasm32-unknown-unknown --release

Sketch Structure

  • Sketch<S> is the type which stores and manipulates 2D polygonal geometry. It contains:
    • a geo GeometryCollection<Real>
    • a bounding box wrapped in a OnceLock (bounding_box: OnceLock)
    • an optional metadata field (Option<S>) also defined by you

Sketch<S> provides methods for working with 2D shapes made of points and lines. You can build a Sketch<S> geo Geometries with Sketch::from_geo(...). Geometries can be open or closed, have holes, but must be planar in the XY. Sketch's are triangulated when exported as an STL, or when a Geometry is converted into a Mesh<S>.

2D Shapes in Sketch

  • top down view of a square Sketch::square(width: Real, metadata: Option<S>)
  • top down view of a square Sketch::rectangle(width: Real, length: Real, metadata: Option<S>)
  • top down view of a circle Sketch::circle(radius: Real, segments: usize, metadata: Option<S>)
  • top down view of a triangle Sketch::polygon(&[[x1,y1],[x2,y2],...], metadata: Option<S>)
  • top down view of a rectangle with rounded corners Sketch::rounded_rectangle(width: Real, height: Real, corner_radius: Real, corner_segments: usize, metadata: Option<S>)
  • top down view of an ellipse Sketch::ellipse(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • top down view of a 6 sided n-gon Sketch::regular_ngon(sides: usize, radius: Real, metadata: Option<S>)
  • top down view of a right triangle Sketch::right_triangle(width: Real, height: Real, metadata: Option<S>)
  • top down view of trapezoid Sketch::trapezoid(top_width: Real, bottom_width: Real, height: Real, top_offset: Real, metadata: Option<S>)
  • top down view of star Sketch::star(num_points: usize, outer_radius: Real, inner_radius: Real, metadata: Option<S>)
  • top down view of a teardrop Sketch::teardrop(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • top down view of an egg shape Sketch::egg(width: Real, length: Real, segments: usize, metadata: Option<S>)
  • top down view of a squircle Sketch::squircle(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • top down view of a keyhole Sketch::keyhole(circle_radius: Real, handle_width: Real, handle_height: Real, segments: usize, metadata: Option<S>)
  • Sketch::reuleaux(sides: usize, radius: Real, arc_segments_per_side: usize, metadata: Option<S>)
  • top down view of a ring Sketch::ring(id: Real, thickness: Real, segments: usize, metadata: Option<S>)
  • top down view of a slice of a circle Sketch::pie_slice(radius: Real, start_angle_deg: Real, end_angle_deg: Real, segments: usize, metadata: Option<S>)
  • Sketch::supershape(a: Real, b: Real, m: Real, n1: Real, n2: Real, n3: Real, segments: usize, metadata: Option<S>)
  • top down view of a circle with a notch taken out of it Sketch::circle_with_keyway(radius: Real, segments: usize, key_width: Real, key_depth: Real, metadata: Option<S>)
  • top down view of a circle with a flat edge Sketch::circle_with_flat(radius: Real, segments: usize, flat_dist: Real, metadata: Option<S>)
  • top down view of a circle with two flat edges Sketch::circle_with_two_flats(radius: Real, segments: usize, flat_dist: Real, metadata: Option<S>)
  • top down view of a pixleated circle Sketch::from_image(img: &GrayImage, threshold: u8, closepaths: bool, metadata: Option<S>) - Builds a new CSG from the “on” pixels of a grayscale image
  • top down view of the text 'HELLO' Sketch::text(text: &str, font_data: &[u8], size: Real, metadata: Option<S>) - generate 2D text geometry in the XY plane from TTF fonts
  • Sketch::metaballs(balls: &[(nalgebra::Point2<Real>, Real)], resolution: (usize, usize), iso_value: Real, padding: Real, metadata: Option<S>)
  • a side view of an airfoil Sketch::airfoil(code: &str, chord: Real, samples: usize, metadata: Option<S>) - NACA 4 digit airfoil
  • an angled view of a bezier cirve Sketch::bezier(control: &[[Real; 2]], segments: usize, metadata: Option<S>)
  • top down view of a neer semi-circle shape Sketch::bspline(control: &[[Real; 2]], p: usize, segments_per_span: usize, metadata: Option<S>)
  • top down view of a cartune heart Sketch::heart(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • Sketch::crescent(outer_r: Real, inner_r: Real, offset: Real, segments: usize, metadata: Option<S>) -
  • Sketch::involute_gear(module_: Real, teeth: usize, pressure_angle_deg: Real, clearance: Real, backlash: Real, segments_per_flank: usize, metadata: Option<S>) - under construction
  • Sketch::cycloidal_gear(module_: Real, teeth: usize, pin_teeth: usize, clearance: Real, segments_per_flank: usize, metadata: Option<S>) - under construction
  • Sketch::involute_rack(module_: Real, num_teeth: usize, pressure_angle_deg: Real, clearance: Real, backlash: Real, metadata: Option<S>) - under construction
  • Sketch::cycloidal_rack(module_: Real, num_teeth: usize, generating_radius: Real, clearance: Real, segments_per_flank: usize, metadata: Option<S>) - under construction
// Alias the library’s generic Sketch type with empty metadata:
type Sketch = csgrs::sketch::Sketch<()>;

let square = Sketch::square(1.0, None); // 1×1 at origin
let rect = Sketch::rectangle(2.0, 4.0, None);
let circle = Sketch::circle(1.0, 32, None); // radius=1, 32 segments
let circle2 = Sketch::circle(2.0, 64, None);

let font_data = include_bytes!("../fonts/MyFont.ttf");
let sketch_text = Sketch::text("Hello!", font_data, 20.0, None);

// Then extrude the text to make it 3D:
let text_3d = sketch_text.extrude(1.0);

Extrusions and Revolves

Extrusions build 3D polygons from 2D Geometries.

  • an angled view of an extruded star Sketch::extrude(height: Real) - Simple extrude in Z+
  • an angled view of a star extruded at an angle Sketch::extrude_vector(direction: Vector3) - Extrude along Vector3 direction
  • an arch with round ends Sketch::revolve(angle_degs, segments) - Extrude while rotating around the Y axis
  • Sketch::loft(&bottom_polygon, &top_polygon, false) - Helper function which extrudes between two Mesh Polygons, optionally with caps
let square = Sketch::square(2.0, None);
let prism = square.extrude(5.0);

let revolve_shape = square.revolve(360.0, 16);

let bottom = Sketch::circle(2.0, 64, None);
let top = bottom.translate(0.0, 0.0, 5.0);
let lofted = Sketch::loft(&bottom.polygons[0], &top.polygons[0], false);

Misc Sketch operations

  • Sketch::offset(distance) - outward (or inward) offset in 2D using geo-offset.
  • Sketch::offset_rounded(distance) - outward (or inward) offset in 2D using geo-offset.
  • Sketch::straight_skeleton(&self, orientation: bool) - returns a Sketch containing the inside (orientation: true) or outside (orientation: false) straight skeleton
  • Sketch::bounding_box() - computes the bounding box of the shape.
  • Sketch::invalidate_bounding_box() - invalidates the bounding box of the shape, causing it to be recomputed on next access

Mesh Structure

  • Mesh<S> is the type which stores and manipulates 3D polygonal geometry. It contains:
    • a Vec<Polygon<S>> polygons, describing 3D shapes, each Polygon<S> holds:
      • a Vec<Vertex> (positions + normals),
      • a Plane describing the polygon’s orientation in 3D.
      • an optional metadata field (Option<S>) defined by you
    • a bounding box wrapped in a OnceLock (bounding_box: OnceLock)
    • another optional metadata field (Option<S>) also defined by you

Mesh<S> provides methods for working with 3D shapes. You can build a Mesh<S> from polygons with Mesh::from_polygons(...). Polygons must be closed, planar, have 3 or more vertices. Polygons are triangulated when being exported as an STL.

3D Shapes in Mesh

  • an angled view of a cube Mesh::cube(width: Real, metadata: Option<S>)
  • an angled view of a cube Mesh::cuboid(width: Real, length: Real, height: Real, metadata: Option<S>)
  • an angled view of a sphere Mesh::sphere(radius: Real, segments: usize, stacks: usize, metadata: Option<S>)
  • an angled view of a cylinder Mesh::cylinder(radius: Real, height: Real, segments: usize, metadata: Option<S>)
  • Mesh::frustum(radius1: Real, radius2: Real, height: Real, segments: usize, metadata: Option<S>) - Construct a frustum at origin with height and radius1 and radius2. If either radius is within EPSILON of 0.0, a cone terminating at a point is constructed.
  • Mesh::frustum_ptp(start: Point3, end: Point3, radius1: Real, radius2: Real, segments: usize, metadata: Option<S>) - Construct a frustum from start to end with radius1 and radius2. If either radius is within EPSILON of 0.0, a cone terminating at a point is constructed.
  • Mesh::polyhedron(points: &[[Real; 3]], faces: &[Vec<usize>], metadata: Option<S>)
  • Mesh::octahedron(radius: Real, metadata: Option<S>) -
  • Mesh::icosahedron(radius: Real, metadata: Option<S>) -
  • Mesh::torus(major_r: Real, minor_r: Real, segments_major: usize, segments_minor: usize, metadata: Option<S>) -
  • Mesh::egg(width: Real, length: Real, revolve_segments: usize, outline_segments: usize, metadata: Option<S>)
  • Mesh::teardrop(width: Real, height: Real, revolve_segments: usize, shape_segments: usize, metadata: Option<S>)
  • Mesh::teardrop_cylinder(width: Real, length: Real, height: Real, shape_segments: usize, metadata: Option<S>)
  • Mesh::ellipsoid(rx: Real, ry: Real, rz: Real, segments: usize, stacks: usize, metadata: Option<S>)
  • Mesh::metaballs(balls: &[MetaBall], resolution: (usize, usize, usize), iso_value: Real, padding: Real, metadata: Option<S>)
  • Mesh::sdf<F>(sdf: F, resolution: (usize, usize, usize), min_pt: Point3, max_pt: Point3, iso_value: Real, metadata: Option<S>) - Return a CSG created by meshing a signed distance field within a bounding box
  • Mesh::arrow(start: Point3, direction: Vector3, segments: usize, orientation: bool, metadata: Option<S>) - Create an arrow at start, pointing along direction
  • Mesh::gyroid(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>) - Generate a Triply Periodic Minimal Surface (Gyroid) inside the volume of self
  • Mesh::schwarz_p(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>) - Generate a Triply Periodic Minimal Surface (Schwarz P) inside the volume of self
  • Mesh::schwarz_d(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>) - Generate a Triply Periodic Minimal Surface (Schwarz D) inside the volume of self
  • Mesh::helical_involute_gear(module_: Real, teeth: usize, pressure_angle_deg: Real, clearance: Real, backlash: Real, segments_per_flank: usize, thickness: Real, helix_angle_deg: Real, slices: usize, metadata: Option<S>) - under construction
// Unit cube at origin, no metadata
let cube = Mesh::cube(1.0, None);

// Sphere of radius=2 at origin with 32 segments and 16 stacks
let sphere = Mesh::sphere(2.0, 32, 16, None);

// Cylinder from radius=1, height=2, 16 segments, and no metadata
let cyl = Mesh::cylinder(1.0, 2.0, 16, None);

// Create a custom polyhedron from points and face indices:
let points = &[
    [0.0, 0.0, 0.0],
    [1.0, 0.0, 0.0],
    [1.0, 1.0, 0.0],
    [0.0, 1.0, 0.0],
    [0.5, 0.5, 1.0],
];
let faces = vec![
    vec![0, 1, 2, 3], // base rectangle
    vec![0, 1, 4],    // triangular side
    vec![1, 2, 4],
    vec![2, 3, 4],
    vec![3, 0, 4],
];
let pyramid = Mesh::polyhedron(points, &faces, None);

// Metaballs https://en.wikipedia.org/wiki/Metaballs
use csgrs::mesh::metaballs::MetaBall;
let balls = vec![
    MetaBall::new(Point3::origin(), 1.0),
    MetaBall::new(Point3::new(1.5, 0.0, 0.0), 1.0),
];

let resolution = (60, 60, 60);
let iso_value = 1.0;
let padding = 1.0;

let metaball_csg = CSG::from_metaballs(
    &balls,
    resolution,
    iso_value,
    padding,
    None,
);

// Example Signed Distance Field for a sphere of radius 1.5 centered at (0,0,0)
let my_sdf = |p: &Point3<Real>| p.coords.norm() - 1.5;

let resolution = (60, 60, 60);
let min_pt = Point3::new(-2.0, -2.0, -2.0);
let max_pt = Point3::new( 2.0,  2.0,  2.0);
let iso_value = 0.0; // Typically zero for SDF-based surfaces

let csg_shape = Mesh::from_sdf(my_sdf, resolution, min_pt, max_pt, iso_value, None);

CSG Boolean Operations

use csgrs::traits::CSG;

let union_result = cube.union(&sphere);
let difference_result = cube.difference(&sphere);
let intersection_result = cylinder.intersection(&sphere);

Booleans on any type implementing the CSG trait such as Mesh<S> or Sketch<S> return their own type. Types implementing the CSG trait also provide the following transformation functions:

Transformations

  • ::translate(x: Real, y: Real, z: Real) - Returns the CSG translated by x, y, and z
  • ::translate_vector(vector: Vector3) - Returns the CSG translated by vector
  • ::rotate(x_deg, y_deg, z_deg) - Returns the CSG rotated in x, y, and z
  • ::scale(scale_x, scale_y, scale_z) - Returns the CSG scaled in x, y, and z
  • ::mirror(plane: Plane) - Returns the CSG mirrored across plane
  • ::center() - Returns the CSG centered at the origin
  • ::float() - Returns the CSG translated so that its bottommost point(s) sit exactly at z=0
  • ::transform(&Matrix4) - Returns the CSG after applying arbitrary affine transforms
  • ::distribute_arc(count: usize, radius: Real, start_angle_deg: Real, end_angle_deg: Real)
  • ::distribute_linear(count: usize, dir: nalgebra::Vector3, spacing: Real)
  • ::distribute_grid(rows: usize, cols: usize, dx: Real, dy: Real)
  • ::inverse() - flips the inside/outside orientation.
use nalgebra::Vector3;
use csgrs::mesh::plane::Plane;
use csgrs::traits::CSG;

let moved = cube.translate(3.0, 0.0, 0.0);
let moved2 = cube.translate_vector(Vector3::new(3.0, 0.0, 0.0));
let rotated = sphere.rotate(0.0, 45.0, 90.0);
let scaled = cylinder.scale(2.0, 1.0, 1.0);
let plane_x = Plane { normal: Vector3::x(), w: 0.0 }; // x=0 plane
let plane_y = Plane { normal: Vector3::y(), w: 0.0 }; // y=0 plane
let plane_z = Plane { normal: Vector3::z(), w: 0.0 }; // z=0 plane
let mirrored = cube.mirror(plane_x);

Miscellaneous Mesh Operations

  • Mesh::vertices() - collect all vertices from the Mesh
  • Mesh::convex_hull() - uses chull to generate a 3D convex hull.
  • Mesh::minkowski_sum(&other) - naive Minkowski sum, then takes the hull.
  • Mesh::ray_intersections(origin, direction) — returns all intersection points and distances.
  • Mesh::flatten() - flattens a 3D shape into 2D (on the XY plane), unions the outlines.
  • Mesh::slice(plane) - slices the CSG by a plane and returns the cross-section polygons.
  • Mesh::subdivide_triangles(subdivisions) - subdivides each polygon’s triangles, increasing mesh density.
  • Mesh::renormalize() - re-computes each polygon’s plane from its vertices, resetting all normals.
  • Mesh::bounding_box() - computes the bounding box of the shape.
  • Mesh::invalidate_bounding_box() - invalidates the bounding box of the shape, causing it to be recomputed on next access
  • Mesh::triangulate() - triangulates all polygons returning a CSG containing triangles.
  • Mesh::from_polygons(polygons: &[Polygon<S>]) - create a new CSG from Polygons.

STL

  • Export ASCII STL: csg.to_stl_ascii("solid_name") -> String
  • Export Binary STL: csg.to_stl_binary("solid_name") -> io::Result<Vec<u8>>
  • Import STL: Mesh::from_stl(&stl_data) -> io::Result<CSG<S>>
// Save to ASCII STL
let stl_text = csg_union.to_stl_ascii("union_solid");
std::fs::write("union_ascii.stl", stl_text).unwrap();

// Save to binary STL
let stl_bytes = csg_union.to_stl_binary("union_solid").unwrap();
std::fs::write("union_bin.stl", stl_bytes).unwrap();

// Load from an STL file on disk
let file_data = std::fs::read("some_file.stl")?;
let imported_mesh = Mesh::from_stl(&file_data)?;

DXF

  • Export: csg.to_dxf() -> Result<Vec<u8>, Box<dyn Error>>
  • Import: Mesh::from_dxf(&dxf_data) -> Result<CSG<S>, Box<dyn Error>>
// Export DXF
let dxf_bytes = csg_obj.to_dxf()?;
std::fs::write("output.dxf", dxf_bytes)?;

// Import DXF
let dxf_data = std::fs::read("some_file.dxf")?;
let csg_dxf = CSG::from_dxf(&dxf_data)?;

Hershey Text

Hershey fonts are single stroke fonts which produce open ended polylines in the XY plane via hershey:

let font_data = include_bytes("../fonts/myfont.jhf");
let csg_text = Sketch::from_hershey("Hello!", font_data, 20.0, None);

Create a Bevy Mesh

csg.to_bevy_mesh() returns a Bevy Mesh.

use bevy::{prelude::*, render::render_asset::RenderAssetUsages, render::mesh::{Indices, PrimitiveTopology}};

let bevy_mesh = mesh_obj.to_bevy_mesh();

Create a Parry TriMesh

csg.to_trimesh() returns a SharedShape containing a TriMesh<Real>.

use csgrs::float_types::rapier3d::prelude::*;  // re-exported for f32/f64 support

let trimesh_shape = mesh_obj.to_trimesh(); // SharedShape with a TriMesh

Create a Rapier Rigid Body

csg.to_rigid_body(rb_set, co_set, translation, rotation, density) helps build and insert both a rigid body and a collider:

use nalgebra::Vector3;
use csgrs::float_types::rapier3d::prelude::*;  // re-exported for f32/f64 support
use csgrs::float_types::FRAC_PI_2;
use csgrs::traits::CSG;
use csgrs::mesh::Mesh;

let mut rb_set = RigidBodySet::new();
let mut co_set = ColliderSet::new();

let axis_angle = Vector3::z() * FRAC_PI_2; // 90° around Z
let rb_handle = mesh_obj.to_rigid_body(
    &mut rb_set,
    &mut co_set,
    Vector3::new(0.0, 0.0, 0.0), // translation
    axis_angle,                  // axis-angle
    1.0,                         // density
);

Mass Properties

let density = 1.0;
let (mass, com, inertia_frame) = mesh_obj.mass_properties(density);
println!("Mass: {}", mass);
println!("Center of Mass: {:?}", com);
println!("Inertia local frame: {:?}", inertia_frame);

Manifold Check

mesh.is_manifold() triangulates the CSG, builds a HashMap of all edges (pairs of vertices), and checks that each is used exactly twice. Returns true if manifold, false if not.

if (mesh_obj.is_manifold()){
    println!("Mesh is manifold!");
} else {
    println!("Not manifold.");
}

Working with Metadata

Mesh<S> and Sketch<S> are generic over S: Clone. Each polygon in a Mesh<S> and each Mesh<S> and Sketch<S> have an optional metadata: Option<S>.
Use cases include storing color, ID, or layer info.

use csgrs::polygon::Polygon;
use csgrs::vertex::Vertex;
use nalgebra::{Point3, Vector3};

#[derive(Clone)]
struct MyMetadata {
    color: (u8, u8, u8),
    label: String,
}

type Mesh = csgrs::mesh::Mesh<MyMetadata>;

// For a single polygon:
let mut poly = Polygon::new(
    vec![
        Vertex::new(Point3::origin(), Vector3::z()),
        Vertex::new(Point3::new(1.0, 0.0, 0.0), Vector3::z()),
        Vertex::new(Point3::new(0.0, 1.0, 0.0), Vector3::z()),
    ],
    Some(MyMetadata {
        color: (255, 0, 0),
        label: "Triangle".into(),
    }),
);

// Retrieve metadata
if let Some(data) = poly.metadata() {
    println!("This polygon is labeled {}", data.label);
}

// Mutate metadata
if let Some(data_mut) = poly.metadata_mut() {
    data_mut.label.push_str("_extended");
}

Examples

Build tests

A cargo xtask is included in the repository for testing building with various combinations of feature flags. To use it, you must install cargo xtask:

cargo install xtask

To run the tests:

cargo xtask test-all

Roadmap

  • Attachments Unless you make models containing just one object attachments features can revolutionize your modeling. They will let you position components of a model relative to other components so you don't have to keep track of the positions and orientations of parts of the model. You can instead place something on the TOP of something else, perhaps aligned to the RIGHT.
  • Rounding and filleting Provide modules like cuboid() to make a cube with any of the edges rounded, offset_sweep() to round the ends of a linear extrusion, and prism_connector() which works with the attachments feature to create filleted prisms between a variety of objects, or even rounded holes through a single object. Also edge_profile() to apply a variety of different mask profiles to chosen edges of a cubic shape, or directly subtract 3d mask shapes from an edge of objects that are not cubes.
  • Complex object support The path_sweep() function/module takes a 2d polygon moves it through space along a path and sweeps out a 3d shape as it moves. Link together a series of arbitrary polygons with skin() or vnf_vertex_array(). Build parts of an object in multiple different representations and combine.
  • Texturing Apply textures to many kinds of objects. Create knurling or any repeating pattern. Applying a texture can actually replace the base object with something different based on repeating copies of the texture element. A texture can also be an image; using texturing you can emboss an arbitrary image onto your model.
  • Parts library The parts library will include many useful specific functional parts including gears, generic threading, and specific threading to match plastic bottles, pipe fittings, and standard screws. Also clips, hinges, and dovetail joints, aluminum extrusion, bearings, nuts, bolts, washers, etc.
  • Shorthands Shorthands to make your code a little shorter, and more importantly, make it significantly easier to read. Compare up(x) to translate([0,0,x]). Shorthands will include operations for creating copies of objects and for applying transformations to objects. Drawing like turtle graphics will be possible.
  • Non-linear solver Composed of a tree which can contain operations and variables representing systems of equations describing constraints, and functionality to perterb variables, sample the solution space described by the tree expression, determine the local slope, and hill climb toward a solution.

Performance

Patterns we work to follow throughout the library to improve performance and memory usage:

  • functions should accept borrowed slices, this permits easy use of iterators
  • iterators should be used wherever parallelism may help (and rayon's par_iter)
  • allocations should be kept to a minimum. Memory should be read-only if possible, clone if necessary, and offer the choice of transmut in place or create new copy via appropriate functions

Todo

Todo shapes

  • geodesic domes / goldberg polyhedra
  • uniform polyhedra
  • molecular models
  • kepler-poinsot polyhedra
  • dodecahedron
  • Archimedean / Catalan solids
  • Johnson solids, near-miss johnson solids
  • deltahedrons
  • regular polytopes
  • regular skew polyhedra
  • toroidal polyhedra
  • shapes from https://iquilezles.org/articles/

Todo easy

  • finish naca airfoil implementations
  • stack transformation
  • additional renders

Todo maybe

References

Shape Interrogation for Computer Aided Design and Manufacturing

Shewchuk, J.R., 1997. Adaptive precision floating-point arithmetic and fast robust geometric predicates. Discrete & Computational Geometry, 18(3), pp.305-363.

Shewchuk, J.R., 1996, May. Robust adaptive floating-point geometric predicates. In Proceedings of the twelfth annual symposium on Computational geometry (pp. 141-150).

License

MIT License

Copyright (c) 2025 Timothy Schmidt

Permission is hereby granted, free of charge, to any person obtaining a copy of this 
software and associated documentation files (the "Software"), to deal in the Software 
without restriction, including without limitation the rights to use, copy, modify, merge, 
publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons 
to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

This library initially based on a translation of CSG.js © 2011 Evan Wallace, under the MIT license.

If you find issues, please file an issue or submit a pull request. Feedback and contributions are welcome!

Have fun building geometry in Rust!

About

Multi-modal constructive solid geometry kernel in Rust

Topics

svg gamedev simulation geometry physics geo geospatial stl csg cnc tessellation polygons parametric 3d-printing slicing offsetting metaballs polylines signed-distance-fields code-cad

Resources

Readme

License

MIT license
Activity

Stars

132 stars

Watchers

3 watching

Forks

16 forks
Report repository

Releases 7

v0.18.1 Latest
Jun 19, 2025
+ 6 releases

Sponsor this project

  •  
Learn more about GitHub Sponsors

Packages

No packages published

Contributors 9

Languages