Skip to content

timschmidt/csgrs

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

443 Commits
.github
.github
 
 
docs
docs
 
 
hershey-fonts
hershey-fonts
 
 
src
src
 
 
.gitignore
.gitignore
 
 
Cargo.lock
Cargo.lock
 
 
Cargo.toml
Cargo.toml
 
 
LICENSE
LICENSE
 
 
asar.ttf
asar.ttf
 
 
readme.md
readme.md
 
 

Repository files navigation

csgrs

A fast, optionally multithreaded Constructive Solid Geometry (CSG) library in Rust, built around Boolean operations (union, difference, intersection, xor) on sets of polygons stored in BSP trees. csgrs constructs 2D and 3D geometry with an OpenSCAD-like syntax, and transforms, interrogates, and simulates without leaving Rust. csgrs aims to be light weight and full featured by integrating 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 to use 32bit or 64bit floats, dependencies are 100% rust and nearly all optional.

The BSP tree works with polygons made of lines. csgrs interpolates all curves when working in 3D so that they can be processed using the BSP tree. earcutr is used by geo for tessellation, and only works in 2D, so csgrs rotates 3D polygons into 2D for tessellation then back to 3D.

Example CSG output

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 CSG type with empty metadata:
type CSG = csgrs::csg::CSG<()>;

// Create two shapes:
let cube = CSG::cube(2.0, 2.0, 2.0, None);  // 2×2×2 cube at origin, no metadata
let sphere = CSG::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();

CSG Structure

  • CSG<S> is the main type. It stores:
    • 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 geo GeometryCollection<Real>
    • another optional metadata field (Option<S>) also defined by you

CSG<S> provides methods for working with 2D and 3D shapes. You can build a CSG<S> from polygons with CSG::from_polygons(...) or from geo Geometries with CSG::from_geo(...). Polygons must be closed, planar, have 3 or more vertices, and are 3D. Geometries can be open or closed, have holes, but must be planar in the XY. Operations work on both 2D and 3D shapes though they generally do not interact except where one is explicitly transformed into the other as in extrude or slice. Polygons and Geometries are triangulated with earcutr when being exported as an STL, or when a Geometry is converted into polygons using CSG::to_polygons(...).

2D Shapes

  • CSG::square(width: Real, length: Real, metadata: Option<S>)
  • CSG::circle(radius: Real, segments: usize, metadata: Option<S>)
  • CSG::polygon(&[[x1,y1],[x2,y2],...], metadata: Option<S>)
  • CSG::rounded_rectangle(width: Real, height: Real, corner_radius: Real, corner_segments: usize, metadata: Option<S>)
  • CSG::ellipse(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • CSG::regular_ngon(sides: usize, radius: Real, metadata: Option<S>)
  • CSG::right_triangle(width: Real, height: Real, metadata: Option<S>)
  • CSG::trapezoid(top_width: Real, bottom_width: Real, height: Real, top_offset: Real, metadata: Option<S>)
  • CSG::star(num_points: usize, outer_radius: Real, inner_radius: Real, metadata: Option<S>)
  • CSG::teardrop(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • CSG::egg_outline(width: Real, length: Real, segments: usize, metadata: Option<S>)
  • CSG::squircle(width: Real, height: Real, segments: usize, metadata: Option<S>)
  • CSG::keyhole(circle_radius: Real, handle_width: Real, handle_height: Real, segments: usize, metadata: Option<S>)
  • CSG::reuleaux_polygon(sides: usize, radius: Real, arc_segments_per_side: usize, metadata: Option<S>) final shape not yet achieved
  • CSG::ring(id: Real, thickness: Real, segments: usize, metadata: Option<S>)
  • CSG::pie_slice(radius: Real, start_angle_deg: Real, end_angle_deg: Real, segments: usize, metadata: Option<S>)
  • CSG::metaball_2d(balls: &[(nalgebra::Point2<Real>, Real)], resolution: (usize, usize), iso_value: Real, padding: Real, metadata: Option<S>) failing at the moment, pending rework
  • CSG::supershape(a: Real, b: Real, m: Real, n1: Real, n2: Real, n3: Real, segments: usize, metadata: Option<S>)
  • CSG::circle_with_keyway(radius: Real, segments: usize, key_width: Real, key_depth: Real, metadata: Option<S>)
  • CSG::circle_with_flat(radius: Real, segments: usize, flat_dist: Real, metadata: Option<S>)
  • CSG::circle_with_two_flats(radius: Real, segments: usize, flat_dist: Real, metadata: Option<S>)
  • CSG::from_image(img: &GrayImage, threshold: u8, closepaths: bool, metadata: Option<S>) - Builds a new CSG from the “on” pixels of a grayscale image
  • CSG::text(text: &str, font_data: &[u8], size: Real, metadata: Option<S>) - generate 2D text geometry in the XY plane from TTF fonts via meshtext
let square = CSG::square(1.0, 1.0, None); // 1×1 at origin
let rect = CSG::square(2.0, 4.0, None);
let circle = CSG::circle(1.0, 32, None); // radius=1, 32 segments
let circle2 = CSG::circle(2.0, 64, None);

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

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

Extrusions and Revolves

Extrusions build 3D polygons from 2D Geometries.

  • CSG::extrude(height: Real) - Simple extrude in Z+
  • CSG::extrude_vector(direction: Vector3) - Extrude along Vector3 direction
  • CSG::extrude_between(&polygon_bottom.polygons[0], &polygon_top.polygons[0], false) - Extrude Between Two BSP Polygons
  • CSG::rotate_extrude(angle_degs, segments) - Extrude while rotating around the Y axis
let square = CSG::square(2.0, 2.0, None);
let prism = square.extrude(5.0);

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

let polygon_bottom = CSG::circle(2.0, 64, None);
let polygon_top = polygon_bottom.translate(0.0, 0.0, 5.0);
let lofted = CSG::extrude_between(&polygon_bottom.polygons[0], &polygon_top.polygons[0], false);

3D Shapes

  • CSG::cube(width: Real, length: Real, height: Real, metadata: Option<S>)
  • CSG::sphere(radius: Real, segments: usize, stacks: usize, metadata: Option<S>)
  • CSG::cylinder(radius: Real, height: Real, segments: usize, metadata: Option<S>)
  • CSG::frustrum(radius1: Real, radius2: Real, height: Real, segments: usize, metadata: Option<S>) - Construct a frustum at origin with height and radius1 and radius2
  • CSG::frustrum_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
  • CSG::polyhedron(points: &[[Real; 3]], faces: &[Vec<usize>], metadata: Option<S>)
  • CSG::egg(width: Real, length: Real, revolve_segments: usize, outline_segments: usize, metadata: Option<S>)
  • CSG::teardrop(width: Real, height: Real, revolve_segments: usize, shape_segments: usize, metadata: Option<S>)
  • CSG::teardrop_cylinder(width: Real, length: Real, height: Real, shape_segments: usize, metadata: Option<S>)
  • CSG::ellipsoid(rx: Real, ry: Real, rz: Real, segments: usize, stacks: usize, metadata: Option<S>)
  • CSG::metaballs(balls: &[MetaBall], resolution: (usize, usize, usize), iso_value: Real, padding: Real, metadata: Option<S>)
  • CSG::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
  • CSG::gyroid(resolution: usize, period: Real, iso_value: Real, metadata: Option<S>) - Generate a Triply Periodic Minimal Surface (Gyroid) inside the volume of self
// Unit cube at origin, no metadata
let cube = CSG::cube(1.0, 1.0, 1.0, None);

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

// Cylinder from radius=1, height=2, 16 segments, and no metadata
let cyl = CSG::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 = CSG::polyhedron(points, &faces, None);

// Metaballs https://en.wikipedia.org/wiki/Metaballs
use csgrs::csg::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 = CSG::from_sdf(my_sdf, resolution, min_pt, max_pt, iso_value, None);

CSG Boolean Operations

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

They all return a new CSG<S>

Transformations

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

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 Operations

  • CSG::vertices() — collect all vertices from the CSG
  • CSG::inverse() — flips the inside/outside orientation.
  • CSG::convex_hull() — uses chull to generate a 3D convex hull.
  • CSG::minkowski_sum(&other) — naive Minkowski sum, then takes the hull.
  • CSG::ray_intersections(origin, direction) — returns all intersection points and distances.
  • CSG::flatten() — flattens a 3D shape into 2D (on the XY plane), unions the outlines.
  • CSG::slice(plane) — slices the CSG by a plane and returns the cross-section polygons.
  • CSG::offset(distance) — outward (or inward) offset in 2D using geo-offset.
  • CSG::subdivide_triangles(subdivisions) — subdivides each polygon’s triangles, increasing mesh density.
  • CSG::renormalize() — re-computes each polygon’s plane from its vertices, resetting all normals.
  • CSG::bounding_box() — computes the bounding box of the shape.
  • CSG::triangulate() — triangulates all polygons returning a CSG containing triangles.
  • CSG::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: CSG::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_csg = CSG::from_stl(&file_data)?;

DXF

  • Export: csg.to_dxf() -> Result<Vec<u8>, Box<dyn Error>>
  • Import: CSG::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 = CSG::from_hershey("Hello!", font_data, 20.0, None);

Create a Parry TriMesh

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

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

let trimesh_shape = csg_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::csg::CSG;

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 = csg_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) = csg_obj.mass_properties(density);
println!("Mass: {}", mass);
println!("Center of Mass: {:?}", com);
println!("Inertia local frame: {:?}", inertia_frame);

Manifold Check

csg.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 (csg_obj.is_manifold()){
    println!("CSG is manifold!");
} else {
    println!("Not manifold.");
}

Working with Metadata

CSG<S> is generic over S: Clone. Each polygon has 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 CSG = csgrs::CSG<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");
}

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

Roadmap / Todo

Todo maybe

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

Constructive solid geometry with polygons using BSP trees 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

50 stars

Watchers

2 watching

Forks

4 forks
Report repository

Releases

No releases published

Sponsor this project

  •  
Learn more about GitHub Sponsors

Packages

No packages published

Contributors 2

  •  
  •  

Languages