manifold-csg

https://github.com/zmerlynn/manifold-csg
Admin
Safe Rust bindings to the manifold3d geometry kernel for constructive solid geometry (CSG)....
Tokens:24,372
Snippets:243
Trust Score:7.8
Update:3 months ago
Show doc for...
Tokens:
Raw
### Build Example for WebAssembly

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Example command to build a specific example (e.g., 'basics') for the wasm32-unknown-emscripten target, producing a .wasm file and a JavaScript shim.

```sh
cargo build --example basics --target wasm32-unknown-emscripten -p manifold-csg --no-default-features
```

--------------------------------

### Build and run a smoke example for wasm32-unknown-unknown

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Compile and execute a smoke test example for the wasm32-unknown-unknown target. This involves building the example with specific features and then running the generated WASM binary using Node.js.

```sh
cargo build --example wasm32_uu_smoke --target wasm32-unknown-unknown \
-p manifold-csg --no-default-features --features unstable-wasm-uu
node crates/manifold-csg/wasm32-uu-runner/run.mjs \
    target/wasm32-unknown-unknown/debug/examples/wasm32_uu_smoke.wasm
```

--------------------------------

### CMake Project Setup

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-sys/wasm32-uu/CMakeLists.txt

Initializes CMake version and project name. It also includes checks for required environment variables for the WebAssembly C++ shim.

```cmake
cmake_minimum_required(VERSION 3.20)
project(manifold-csg-wasm-uu LANGUAGES CXX C)

if(NOT WASM_CXX_SHIM_DIR)
    message(FATAL_ERROR "Set -DWASM_CXX_SHIM_DIR=<path> to the cloned wasm-cxx-shim source tree.")
endif()
if(NOT WASM32_UU_INC_DIR)
    message(FATAL_ERROR "Set -DWASM32_UU_INC_DIR=<path> to crates/manifold-csg-sys/wasm32-uu/include.")
endif()
if(NOT LIBCXX_HEADERS)
    message(FATAL_ERROR "Set -DLIBCXX_HEADERS=<path> to the LLVM libc++ v1 headers directory.")
endif()

include(${WASM_CXX_SHIM_DIR}/cmake/WasmCxxShimManifold.cmake)
```

--------------------------------

### Install Specific Emscripten SDK Version

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Installs a specific version of the Emscripten SDK from its repository and activates it for the current shell session. This is useful for matching CI environments.

```bash
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk && ./emsdk install <version> && ./emsdk activate <version>
source ./emsdk_env.sh    # per-shell
```

--------------------------------

### Basic CSG Operations in Rust

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold3d/README.md

Demonstrates creating a cube and a cylinder, then performing a boolean difference operation. This is a quick start example for using the manifold3d crate.

```rust
use manifold3d::{Manifold, CrossSection, JoinType};

let cube = Manifold::cube(20.0, 20.0, 20.0, true);
let hole = Manifold::cylinder(30.0, 5.0, 5.0, 32, false);
let result = &cube - &hole;
```

--------------------------------

### Install Emscripten via Homebrew

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Installs the Emscripten SDK using Homebrew and adds the Wasm target for Rust. This is a convenient method for local development.

```bash
brew install emscripten            # 5.0.7 currently (matches CI pin)
rustup target add wasm32-unknown-emscripten
cargo build --target wasm32-unknown-emscripten -p manifold-csg-sys --no-default-features
```

--------------------------------

### Nix Build Configuration for Manifold CSG

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/offline-build.md

Example Nix expression for building a Rust package that depends on Manifold CSG. It shows how to specify the Manifold library directory and include Manifold in build inputs.

```nix
# manifold from the upstream flake, pinned to our exact MANIFOLD_VERSION:
#   inputs.manifold.url = "github:elalish/manifold/v3.5.1";
# or nixpkgs' pkgs.manifold (also 3.5.1).
buildRustPackage {
  # ...
  MANIFOLD_CSG_LIB_DIR = "${manifold}/lib";   # dylib by default
  buildInputs = [ manifold ];                 # rpath / NEEDED pulls clipper2 + tbb
}
```

--------------------------------

### Run Manifold CSG Playground Tests

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-playground/README.md

Runs the Node-side test suite for the manifold-csg-playground. This script rebuilds the WASM, installs Node dependencies, and executes tests.

```sh
bash crates/manifold-csg-playground/test.sh
```

--------------------------------

### Forwarding Link Arguments in Dependent Crates

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

In the `build.rs` of a dependent crate, read the `DEP_<NAME>_LINK_ARGS` environment variable and re-emit each token as `cargo:rustc-link-arg`. This ensures flags reach the final binary, test, or example.

```rust
fn main() {
    if let Ok(link_args) = std::env::var("DEP_MANIFOLD_LINK_ARGS") {
        for arg in link_args.split_whitespace() {
            println!("cargo:rustc-link-arg={}", arg);
        }
    }
}
```

--------------------------------

### MeshGL64::merge_from_vert

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Merges another MeshGL64 instance into the current one, starting from a specific vertex.

```APIDOC
## MeshGL64::merge_from_vert

### Description
Merges another MeshGL64 instance into the current one, starting from a specific vertex, using the `manifold_meshgl64_merge_from_vert` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **other** (MeshGL64): The other MeshGL64 instance to merge.
- **vert_idx** (usize): The index of the vertex in the current mesh to merge from.

### Request Example
```rust
mesh_gl64_1.merge_from_vert(mesh_gl64_2, start_vertex_index);
```

### Response
#### Success Response
None (modifies the instance in place).

#### Response Example
```rust
// MeshGL64 instances merged from vertex
```
```

--------------------------------

### MeshGL64::new_with_options

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a new MeshGL64 instance with specified options.

```APIDOC
## MeshGL64::new_with_options

### Description
Creates a new MeshGL64 instance using the `manifold_meshgl64_w_options` C API function, allowing for custom options.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **options** (OptionsType): An object or structure containing options for mesh creation.

### Request Example
```rust
let mesh_gl64 = MeshGL64::new_with_options(some_options);
```

### Response
#### Success Response
- **MeshGL64**: A new MeshGL64 instance with specified options.

#### Response Example
```rust
// MeshGL64 instance created with options
```
```

--------------------------------

### MeshGL::new_with_options

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a new MeshGL instance with specified options.

```APIDOC
## MeshGL::new_with_options

### Description
Creates a new MeshGL instance using the `manifold_meshgl_w_options` C API function, allowing for custom options.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **options** (OptionsType): An object or structure containing options for mesh creation.

### Request Example
```rust
let mesh_gl = MeshGL::new_with_options(some_options);
```

### Response
#### Success Response
- **MeshGL**: A new MeshGL instance with specified options.

#### Response Example
```rust
// MeshGL instance created with options
```
```

--------------------------------

### MeshGL::merge_from_vert

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Merges another MeshGL instance into the current one, starting from a specific vertex.

```APIDOC
## MeshGL::merge_from_vert

### Description
Merges another MeshGL instance into the current one, starting from a specific vertex, using the `manifold_meshgl_merge_from_vert` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **other** (MeshGL): The other MeshGL instance to merge.
- **vert_idx** (usize): The index of the vertex in the current mesh to merge from.

### Request Example
```rust
mesh_gl1.merge_from_vert(mesh_gl2, start_vertex_index);
```

### Response
#### Success Response
None (modifies the instance in place).

#### Response Example
```rust
// MeshGL instances merged from vertex
```
```

--------------------------------

### MeshGL::new

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a new MeshGL instance from a C API function.

```APIDOC
## MeshGL::new

### Description
Creates a new MeshGL instance using the `manifold_meshgl` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let mesh_gl = MeshGL::new();
```

### Response
#### Success Response
- **MeshGL**: A new MeshGL instance.

#### Response Example
```rust
// MeshGL instance created
```
```

--------------------------------

### MeshGL64::new

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a new MeshGL64 instance from a C API function.

```APIDOC
## MeshGL64::new

### Description
Creates a new MeshGL64 instance using the `manifold_meshgl64` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let mesh_gl64 = MeshGL64::new();
```

### Response
#### Success Response
- **MeshGL64**: A new MeshGL64 instance.

#### Response Example
```rust
// MeshGL64 instance created
```
```

--------------------------------

### After: Using closure for warp callback

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold3d-macros/README.md

Demonstrates the current approach using a closure directly for the warp callback, replacing the macro.

```rust
let warped = manifold.warp(|x, y, z| [x + 1.0, y, z]);
```

--------------------------------

### Run Integration Tests

Source: https://github.com/zmerlynn/manifold-csg/blob/main/CLAUDE.md

Execute all integration tests for the project, including those that require the 'nalgebra' feature.

```bash
cargo test --features nalgebra
```

--------------------------------

### Build with Specific LLVM Path

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-playground/README.md

Builds the WASM module when LLVM 20+ is not on the system PATH. Point to the LLVM bin directory using the WASM_CXX_SHIM_LLVM_BIN_DIR environment variable.

```sh
WASM_CXX_SHIM_LLVM_BIN_DIR=/usr/lib/llvm-20/bin bash build.sh
```

--------------------------------

### 2D to 3D Operations: Offset and Extrude Rectangle

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Shows how to create a 2D cross-section of a rectangle, offset it with rounded joins, and then extrude it into a 3D solid. Requires importing `Manifold`, `CrossSection`, and `JoinType`.

```rust
// 2D -> 3D: offset a rectangle and extrude it
let section = CrossSection::square(10.0, 10.0, true);
let expanded = section.offset(2.0, JoinType::Round, 2.0, 16);
let solid = expanded.extrude(20.0);
```

--------------------------------

### Run WebAssembly Integration Tests

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Command to execute the integration test suite for the wasm32-unknown-emscripten target. This assumes the workspace .cargo/config.toml is set up to use the correct runner.

```sh
cargo test --target wasm32-unknown-emscripten -p manifold-csg --no-default-features --tests
```

--------------------------------

### MeshGL64::from_obj

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a MeshGL64 instance by reading from an OBJ file.

```APIDOC
## MeshGL64::from_obj

### Description
Creates a new MeshGL64 instance by parsing data from an OBJ file, using the `manifold_meshgl64_read_obj` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **obj_data** (&str): A string slice containing the OBJ file content.

### Request Example
```rust
let mesh_gl64 = MeshGL64::from_obj(obj_file_content);
```

### Response
#### Success Response
- **MeshGL64**: A new MeshGL64 instance loaded from the OBJ data.

#### Response Example
```rust
// MeshGL64 instance created from OBJ data
```
```

--------------------------------

### Rust Wrapper for Manifold from MeshGL64 with Context

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for creating a Manifold from MeshGL64 data with an execution context in Rust. Supports higher precision mesh data.

```rust
Manifold::from_meshgl64_with_context
```

--------------------------------

### Rust Wrapper for Manifold from SDF with Context

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for creating a Manifold from an SDF with an execution context in Rust. Supports cancellation and progress reporting.

```rust
Manifold::from_sdf_with_context
```

--------------------------------

### Serve Manifold CSG Playground

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-playground/README.md

Serves the manifold-csg-playground application locally. Open http://localhost:8000 in a browser after serving.

```sh
# 2. Serve
bash crates/manifold-csg-playground/serve.sh
```

--------------------------------

### Rust Wrapper for Manifold from SDF Sequence with Context

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for creating a Manifold from a sequence of SDFs with an execution context in Rust. Useful for complex SDF constructions.

```rust
Manifold::from_sdf_seq_with_context
```

--------------------------------

### Rust Wrapper for Execution Context Creation

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for creating an execution context in Rust. Used for operations that require cancellation or progress tracking.

```rust
ExecutionContext::new
```

--------------------------------

### Adding Compile Options for wasm32-uu

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-sys/wasm32-uu/CMakeLists.txt

Configures the include paths for the WebAssembly build, ensuring correct header resolution for libc++, mutex stub, and libm/libc. The `SHELL:` prefix is used to prevent CMake's compile flag deduplication from collapsing repeated `-isystem` flags.

```cmake
add_compile_options(
    "SHELL:-isystem ${WASM32_UU_INC_DIR}"
    "SHELL:-isystem ${LIBCXX_HEADERS}"
    "SHELL:-isystem ${WASM_CXX_SHIM_DIR}/libm/include"
    "SHELL:-isystem ${WASM_CXX_SHIM_DIR}/libc/include"
    # Defense-in-depth: drop standard system include directories but
    # keep the compiler resource dir so builtin headers like <stdint.h>
    # still resolve. Even if the explicit -isystem chain misbehaves,
    # host C/C++ system paths stay excluded.
    -nostdlibinc
)
```

--------------------------------

### Build and Test Manifold CSG

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Standard commands to build the project crates and run the test suite with nalgebra features enabled.

```sh
cargo build           # builds both crates
```

```sh
cargo test --features nalgebra   # runs the test suite
```

--------------------------------

### Rust Wrapper for Manifold from MeshGL with Context

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for creating a Manifold from MeshGL data with an execution context in Rust. Handles mesh data processing with cancellation support.

```rust
Manifold::from_meshgl_with_context
```

--------------------------------

### Build Manifold CSG for WebAssembly

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Commands to build the manifold-csg project for the wasm32-unknown-emscripten target, disabling default features. Requires Emscripten and the wasm32-unknown-emscripten Rust target.

```sh
brew install emscripten   # or install the raw emsdk and source emsdk_env.sh
```

```sh
rustup target add wasm32-unknown-emscripten
```

```sh
cargo build --target wasm32-unknown-emscripten -p manifold-csg --no-default-features
```

--------------------------------

### Build Manifold CSG Playground

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-playground/README.md

Builds the WASM module for the manifold-csg-playground. Requires rustup target add wasm32-unknown-unknown and LLVM 20+.

```sh
# 1. Build (requires rustup target add wasm32-unknown-unknown + LLVM 20+)
bash crates/manifold-csg-playground/build.sh
```

--------------------------------

### 3D Boolean Operations: Drill Hole in Cube

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Demonstrates how to perform a boolean difference operation to drill a cylindrical hole through a cube using Manifold. Ensure the `manifold_csg` crate is imported.

```rust
use manifold_csg::{Manifold, CrossSection, JoinType};

// 3D: drill a cylindrical hole through a cube
let cube = Manifold::cube(20.0, 20.0, 20.0, true);
let hole = Manifold::cylinder(30.0, 5.0, 5.0, 32, false);
let result = &cube - &hole;
assert!(result.volume() < cube.volume());
```

--------------------------------

### Rust Wrapper for Manifold Smooth F64 with Context

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for smoothing a Manifold (f64 precision) with an execution context in Rust. Applies smoothing operations with cancellation support.

```rust
Manifold::smooth_f64_with_context
```

--------------------------------

### Build manifold-csg for wasm32-unknown-unknown

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Compile the manifold-csg crate for the wasm32-unknown-unknown target using Cargo. Ensure that default features are disabled and the 'unstable-wasm-uu' feature is enabled.

```sh
cargo build --target wasm32-unknown-unknown -p manifold-csg \
    --no-default-features --features unstable-wasm-uu
```

--------------------------------

### Before: Using manifold_warp macro

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold3d-macros/README.md

Illustrates the previous usage of the #[manifold_warp] macro with a struct implementing the WarpVertex trait.

```rust
#[manifold_warp]
struct MyWarp;
impl WarpVertex for MyWarp {
    fn warp_vertex(&self, p: Point3) -> Point3 { ... }
}
let warped = manifold.warp(Pin::new(&MyWarp));
```

--------------------------------

### Run Diagnostic Script for Wasm Build

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-unknown-unknown.md

Execute the standalone diagnostic script to gather detailed information about the build environment. This is crucial for troubleshooting build failures on the wasm32-unknown-unknown target. Attach the output to bug reports.

```bash
bash crates/manifold-csg-sys/wasm32-uu/diagnose.sh > bugreport.txt 2>&1
```

--------------------------------

### CrossSection Transforms and Queries

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Provides an overview of the C API functions and their corresponding safe Rust wrappers for CrossSection operations. These include transformations like translate, rotate, scale, mirror, offset, and warp, as well as queries for area, vertex count, contour count, emptiness, bounds, polygon conversion, and general transformation.

```APIDOC
## CrossSection API

This section details the C API functions and their safe Rust wrapper equivalents for `CrossSection` objects.

### Transforms

- **`manifold_cross_section_translate`**: Corresponds to `CrossSection::translate`.
- **`manifold_cross_section_rotate`**: Corresponds to `CrossSection::rotate`.
- **`manifold_cross_section_scale`**: Corresponds to `CrossSection::scale`.
- **`manifold_cross_section_mirror`**: Corresponds to `CrossSection::mirror`.
- **`manifold_cross_section_offset`**: Corresponds to `CrossSection::offset`.
- **`manifold_cross_section_warp_context`**: Corresponds to `CrossSection::warp`.
- **`manifold_cross_section_transform`**: Corresponds to `CrossSection::transform`.

### Queries

- **`manifold_cross_section_area`**: Corresponds to `CrossSection::area`.
- **`manifold_cross_section_num_vert`**: Corresponds to `CrossSection::num_vert`.
- **`manifold_cross_section_num_contour`**: Corresponds to `CrossSection::num_contour`.
- **`manifold_cross_section_is_empty`**: Corresponds to `CrossSection::is_empty`.
- **`manifold_cross_section_bounds`**: Corresponds to `CrossSection::bounds`.
- **`manifold_cross_section_to_polygons`**: Corresponds to `CrossSection::to_polygons`.

### Other

- **`manifold_cross_section_simplify`**: Corresponds to `CrossSection::simplify`.
- **`manifold_cross_section_size`**: Not needed (alloc size).
```

--------------------------------

### Ensuring Default Build of Libraries

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-sys/wasm32-uu/CMakeLists.txt

Creates a custom target `_force_manifold_build` that depends on the manifold and Clipper2 libraries. This ensures that `cmake --build` compiles these libraries by default, as FetchContent subprojects are not always marked as ALL targets.

```cmake
add_custom_target(_force_manifold_build ALL
    DEPENDS manifoldc manifold Clipper2)
```

--------------------------------

### Setting Emscripten Runner for Node.js

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Configure Cargo to use Node.js as the runner for Wasm32 Emscripten targets. This simplifies testing by leveraging Cargo's existing target infrastructure.

```bash
CARGO_TARGET_WASM32_UNKNOWN_EMSCRIPTEN_RUNNER=node
```

--------------------------------

### Rust Wrapper for Execution Context Progress

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for updating the progress of an execution context in Rust. Used to report the completion status of operations.

```rust
ExecutionContext::progress
```

--------------------------------

### Execution Context Functions (Internal)

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Internal C API functions for managing execution context, including cancellation and progress tracking.

```c
manifold_execution_context
```

```c
manifold_execution_context_cancel
```

```c
manifold_execution_context_cancelled
```

```c
manifold_execution_context_progress
```

```c
manifold_execution_context_level_set
```

```c
manifold_execution_context_level_set_seq
```

```c
manifold_execution_context_of_meshgl
```

```c
manifold_execution_context_of_meshgl64
```

```c
manifold_execution_context_smooth
```

```c
manifold_execution_context_smooth64
```

```c
manifold_execution_context_size
```

--------------------------------

### Emitting Link Arguments for Emscripten

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

In the `build.rs` of a sys crate, emit `cargo:link_args` when targeting Emscripten. Cargo translates this into the `DEP_<NAME>_LINK_ARGS` environment variable for dependents.

```rust
fn main() {
    if cfg!(target_env = "emscripten") {
        println!("cargo:link_args=-sSTACK_SIZE=33554432 -sINITIAL_MEMORY=64MB");
    }
}
```

--------------------------------

### MeshGL64::to_obj

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Serializes a MeshGL64 instance to OBJ file format.

```APIDOC
## MeshGL64::to_obj

### Description
Serializes the MeshGL64 instance into a string representing the OBJ file format, using the `manifold_meshgl64_write_obj` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let obj_string = mesh_gl64.to_obj();
```

### Response
#### Success Response
- **String**: A string containing the OBJ formatted data.

#### Response Example
```rust
// Example: "v 1.0 2.0 3.0\nf 1 2 3\n..."
```
```

--------------------------------

### Integrating manifold and Clipper2 with wasm-cxx-shim

Source: https://github.com/zmerlynn/manifold-csg/blob/main/crates/manifold-csg-sys/wasm32-uu/CMakeLists.txt

Uses the `wasm_cxx_shim_add_manifold` helper function to integrate the manifold and Clipper2 libraries. It supports specifying a particular Git tag for manifold if provided via `MANIFOLD_GIT_TAG`.

```cmake
if(MANIFOLD_GIT_TAG)
    wasm_cxx_shim_add_manifold(MANIFOLD_GIT_TAG ${MANIFOLD_GIT_TAG})
else()
    wasm_cxx_shim_add_manifold()
endif()
```

--------------------------------

### Forward Emscripten Linker Flags in build.rs

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Forwards Emscripten-specific linker arguments to rustc for binaries, tests, and cdylibs when targeting Emscripten. This ensures correct memory management and exception handling.

```rust
if is_emscripten {
    for flag in [
        "-sALLOW_MEMORY_GROWTH=1",
        "-sMAXIMUM_MEMORY=4294967296",
        "-fexceptions",
        "-sDISABLE_EXCEPTION_CATCHING=0",
    ] {
        println!("cargo:rustc-link-arg-bins={flag}");
        println!("cargo:rustc-link-arg-tests={flag}");
        println!("cargo:rustc-link-arg-cdylib={flag}");
    }
}
```

--------------------------------

### MeshGL64::new_with_tangents

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a new MeshGL64 instance with tangent information.

```APIDOC
## MeshGL64::new_with_tangents

### Description
Creates a new MeshGL64 instance using the `manifold_meshgl64_w_tangents` C API function, which includes tangent information.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let mesh_gl64 = MeshGL64::new_with_tangents();
```

### Response
#### Success Response
- **MeshGL64**: A new MeshGL64 instance with tangent information.

#### Response Example
```rust
// MeshGL64 instance created with tangents
```
```

--------------------------------

### MeshGL::new_with_tangents

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Creates a new MeshGL instance with tangent information.

```APIDOC
## MeshGL::new_with_tangents

### Description
Creates a new MeshGL instance using the `manifold_meshgl_w_tangents` C API function, which includes tangent information.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let mesh_gl = MeshGL::new_with_tangents();
```

### Response
#### Success Response
- **MeshGL**: A new MeshGL instance with tangent information.

#### Response Example
```rust
// MeshGL instance created with tangents
```
```

--------------------------------

### Vector Container Functions (Internal)

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Internal C API functions for managing vector containers, used in batch operations and decomposition.

```c
manifold_manifold_vec
```

```c
manifold_manifold_empty_vec
```

```c
manifold_manifold_vec_get
```

```c
manifold_manifold_vec_length
```

```c
manifold_manifold_vec_push_back
```

```c
manifold_manifold_vec_reserve
```

```c
manifold_manifold_vec_set
```

```c
manifold_manifold_vec_size
```

```c
manifold_cross_section_vec
```

```c
manifold_cross_section_empty_vec
```

```c
manifold_cross_section_vec_get
```

```c
manifold_cross_section_vec_length
```

```c
manifold_cross_section_vec_push_back
```

```c
manifold_cross_section_vec_reserve
```

```c
manifold_cross_section_vec_set
```

```c
manifold_cross_section_vec_size
```

--------------------------------

### MeshGL64::merge

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Merges two MeshGL64 instances.

```APIDOC
## MeshGL64::merge

### Description
Merges another MeshGL64 instance into the current one, using the `manifold_meshgl64_merge` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **other** (MeshGL64): The other MeshGL64 instance to merge.

### Request Example
```rust
mesh_gl64_1.merge(mesh_gl64_2);
```

### Response
#### Success Response
None (modifies the instance in place).

#### Response Example
```rust
// MeshGL64 instances merged
```
```

--------------------------------

### Decomposition and Slicing

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Functions for decomposing a manifold and slicing it.

```APIDOC
## `manifold_decompose`

### Description
Decomposes a manifold into its constituent parts.

### Method
C API function

### Endpoint
`manifold_decompose`

### Safe Wrapper
[`Manifold::decompose`](crates/manifold-csg/src/manifold.rs)
```

```APIDOC
## `manifold_slice`

### Description
Slices a manifold at a specified Z-plane or creates a cross-section.

### Method
C API function

### Endpoint
`manifold_slice`

### Safe Wrappers
[`Manifold::slice_at_z`](crates/manifold-csg/src/manifold.rs)
[`slice_to_cross_section`](crates/manifold-csg/src/manifold.rs)
```

--------------------------------

### Rust Wrapper for Checking Execution Context Cancellation

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for checking if an execution context has been cancelled in Rust. Used to periodically check for cancellation requests.

```rust
ExecutionContext::is_cancelled
```

--------------------------------

### MeshGL::merge

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Merges two MeshGL instances.

```APIDOC
## MeshGL::merge

### Description
Merges another MeshGL instance into the current one, using the `manifold_meshgl_merge` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **other** (MeshGL): The other MeshGL instance to merge.

### Request Example
```rust
mesh_gl1.merge(mesh_gl2);
```

### Response
#### Success Response
None (modifies the instance in place).

#### Response Example
```rust
// MeshGL instances merged
```
```

--------------------------------

### Rust Wrapper for Execution Context Cancellation

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Safe wrapper for cancelling an execution context in Rust. Allows external interruption of long-running operations.

```rust
ExecutionContext::cancel
```

--------------------------------

### MeshGL64::run_flags

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the flags associated with each run in a MeshGL64 instance.

```APIDOC
## MeshGL64::run_flags

### Description
Returns a slice containing the flags for each run in the MeshGL64 object, corresponding to the `manifold_meshgl64_run_flags` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let run_flags = mesh_gl64.run_flags();
```

### Response
#### Success Response
- **&[u32]**: A slice of u32 values representing the flags for each run.

#### Response Example
```rust
// Example: [flag1, flag2, ...]
```
```

--------------------------------

### MeshGL64::run_transform

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the transformation matrix for a given run in a MeshGL64 instance.

```APIDOC
## MeshGL64::run_transform

### Description
Returns the transformation matrix applied to a specific run in the MeshGL64 object, corresponding to the `manifold_meshgl64_run_transform` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **run_idx** (usize): The index of the run.

### Request Example
```rust
let transform = mesh_gl64.run_transform(run_index);
```

### Response
#### Success Response
- **[[f64; 4]; 4]**: A 4x4 transformation matrix.

#### Response Example
```rust
// Example: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]
```
```

--------------------------------

### Configuring Emscripten Stack and Memory

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Adjust Emscripten's default stack size and initial memory using compiler flags. The stack size is increased to 32 MiB and initial memory to 64 MiB to prevent overflows during deep recursion and satisfy memory requirements.

```bash
-sSTACK_SIZE=33554432 -sINITIAL_MEMORY=64MB
```

--------------------------------

### Minkowski Sum and Difference

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Functions for performing Minkowski sum and difference operations.

```APIDOC
## `manifold_minkowski_sum`

### Description
Computes the Minkowski sum of two manifolds.

### Method
C API function

### Endpoint
`manifold_minkowski_sum`

### Safe Wrapper
[`Manifold::minkowski_sum`](crates/manifold-csg/src/manifold.rs)
```

```APIDOC
## `manifold_minkowski_difference`

### Description
Computes the Minkowski difference of two manifolds.

### Method
C API function

### Endpoint
`manifold_minkowski_difference`

### Safe Wrapper
[`Manifold::minkowski_difference`](crates/manifold-csg/src/manifold.rs)
```

--------------------------------

### MeshGL::run_flags

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the flags associated with each run in a MeshGL instance.

```APIDOC
## MeshGL::run_flags

### Description
Returns a slice containing the flags for each run in the MeshGL object, corresponding to the `manifold_meshgl_run_flags` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let run_flags = mesh_gl.run_flags();
```

### Response
#### Success Response
- **&[u32]**: A slice of u32 values representing the flags for each run.

#### Response Example
```rust
// Example: [flag1, flag2, ...]
```
```

--------------------------------

### MeshGL64::run_index

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the run index for a given triangle in a MeshGL64 instance.

```APIDOC
## MeshGL64::run_index

### Description
Returns the index of the run to which a given triangle belongs in the MeshGL64 object, corresponding to the `manifold_meshgl64_run_index` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **tri_idx** (usize): The index of the triangle.

### Request Example
```rust
let run_idx = mesh_gl64.run_index(triangle_index);
```

### Response
#### Success Response
- **usize**: The index of the run.

#### Response Example
```rust
// Example: 5
```
```

--------------------------------

### Passing C++ Exception Flags

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Pass the `-fwasm-exceptions` flag to the C++ compiler and forward it via `cargo:rustc-link-arg` to enable WebAssembly-native exceptions. This flag is available in current Emscripten SDK versions.

```rust
println!("cargo:rustc-link-arg=-fwasm-exceptions");
```

--------------------------------

### MeshGL64::vert_properties

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves properties for all vertices in a MeshGL64 instance.

```APIDOC
## MeshGL64::vert_properties

### Description
Returns a slice containing the properties for all vertices in the MeshGL64 object, corresponding to the `manifold_meshgl64_vert_properties` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let vertex_properties = mesh_gl64.vert_properties();
```

### Response
#### Success Response
- **&[f64]**: A slice of f64 values representing vertex properties.

#### Response Example
```rust
// Example: [x1, y1, z1, x2, y2, z2, ...]
```
```

--------------------------------

### MeshGL::run_transform

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the transformation matrix for a given run in a MeshGL instance.

```APIDOC
## MeshGL::run_transform

### Description
Returns the transformation matrix applied to a specific run in the MeshGL object, corresponding to the `manifold_meshgl_run_transform` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **run_idx** (usize): The index of the run.

### Request Example
```rust
let transform = mesh_gl.run_transform(run_index);
```

### Response
#### Success Response
- **[[f32; 4]; 4]**: A 4x4 transformation matrix.

#### Response Example
```rust
// Example: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]
```
```

--------------------------------

### Polygon Helper Functions (Internal)

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Internal C API functions for manipulating polygons. These are used by various higher-level operations within the library.

```c
manifold_polygons
```

```c
manifold_polygons_length
```

```c
manifold_polygons_simple_length
```

```c
manifold_polygons_get_point
```

```c
manifold_polygons_get_simple
```

```c
manifold_polygons_size
```

```c
manifold_simple_polygon
```

```c
manifold_simple_polygon_get_point
```

```c
manifold_simple_polygon_length
```

```c
manifold_simple_polygon_size
```

--------------------------------

### MeshGL::vert_properties

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves properties for all vertices in a MeshGL instance.

```APIDOC
## MeshGL::vert_properties

### Description
Returns a slice containing the properties for all vertices in the MeshGL object, corresponding to the `manifold_meshgl_vert_properties` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let vertex_properties = mesh_gl.vert_properties();
```

### Response
#### Success Response
- **&[f32]**: A slice of f32 values representing vertex properties.

#### Response Example
```rust
// Example: [x1, y1, z1, x2, y2, z2, ...]
```
```

--------------------------------

### MeshGL::run_index

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the run index for a given triangle in a MeshGL instance.

```APIDOC
## MeshGL::run_index

### Description
Returns the index of the run to which a given triangle belongs in the MeshGL object, corresponding to the `manifold_meshgl_run_index` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
- **tri_idx** (usize): The index of the triangle.

### Request Example
```rust
let run_idx = mesh_gl.run_index(triangle_index);
```

### Response
#### Success Response
- **usize**: The index of the run.

#### Response Example
```rust
// Example: 5
```
```

--------------------------------

### Detect Emscripten Target in build.rs

Source: https://github.com/zmerlynn/manifold-csg/blob/main/docs/plans/wasm-emscripten.md

Detects if the current build target is for Emscripten (wasm32-unknown-emscripten). This is crucial for applying Emscripten-specific build configurations.

```rust
let target = env::var("TARGET").unwrap_or_default();
let is_emscripten = target == "wasm32-unknown-emscripten";
```

--------------------------------

### Add manifold-csg to Cargo.toml for wasm32-unknown-unknown

Source: https://github.com/zmerlynn/manifold-csg/blob/main/README.md

Specify the manifold-csg dependency in your Cargo.toml file, ensuring to disable default features and enable the 'unstable-wasm-uu' feature for the wasm32-unknown-unknown target.

```toml
manifold-csg = { version = "...", default-features = false, features = ["unstable-wasm-uu"] }
```

--------------------------------

### MeshGL64::num_run

Source: https://github.com/zmerlynn/manifold-csg/blob/main/API_COVERAGE.md

Retrieves the number of runs in a MeshGL64 instance.

```APIDOC
## MeshGL64::num_run

### Description
Returns the number of runs in the MeshGL64 object, corresponding to the `manifold_meshgl64_num_run` C API function.

### Method
Rust function call

### Endpoint
N/A

### Parameters
None explicitly documented for this wrapper.

### Request Example
```rust
let num_runs = mesh_gl64.num_run();
```

### Response
#### Success Response
- **usize**: The number of runs.

#### Response Example
```rust
// Example: 10
```
```
Tokens:
Raw