/**
 * Rasterize an {@link AbstractShape3D} into a cell-centered Uint8 grid mask.
 *
 * For each integer cell `(i, j, k)` in `[0, rx) × [0, ry) × [0, rz)`, the cell's
 * center is recovered as the world-space point `grid_to_world * (i, j, k)`. If
 * that point lies inside the shape — or close enough to its surface (see below)
 * — the corresponding cell in `grid` is written as `1`.
 *
 * The grid is **not** cleared first. Cells outside the shape (and outside its
 * proximity band) are left exactly as they were, which lets the caller compose
 * multiple shapes into the same buffer by calling this function repeatedly. The
 * caller is responsible for `grid.fill(0)` if a fresh mask is desired.
 *
 * **Proximity test.** A cell whose centre is outside the shape is still marked
 * solid if `signed_distance_at_point(centre) < half_cell_diagonal`. This catches
 * features that pass through a cell without containing its centre — e.g. a thin
 * sheet bisecting a cubic cell at 45°. The threshold is the largest possible
 * distance from a cell's centre to any point inside the cell, so any shape that
 * intersects the cell at all is captured. Cheap fast path: `contains_point` is
 * tested first (no sqrt for most shapes); the more expensive signed-distance
 * call only runs for cells whose centre is outside.
 *
 * **Volume guard.** If the shape's total volume is less than half the volume of
 * a single cell, the function returns immediately without writing anything. A
 * shape that small can't be meaningfully represented as a unit-cell solid — the
 * obstacle would end up perceptibly larger than the shape itself. Callers with
 * sub-cell shapes should either refine the grid or use a different
 * representation (e.g. a point-velocity effector).
 *
 * **Coord space.** `shape.contains_point` / `signed_distance_at_point` are
 * called with **world** coordinates. For shapes that have their own local frame
 * (e.g. `UnitSphereShape3D` centred at the origin), wrap them in a
 * {@link TransformedShape3D} so they sit at the right world position before
 * passing in. The voxelizer is otherwise agnostic to how the shape interprets
 * its inputs.
 *
 * **Grid orientation.** `world_to_grid` and `grid_to_world` are full 4×4
 * column-major affines, so the grid can be translated, scaled, or rotated in
 * world space; the algorithm makes no axis-aligned assumption. Cell size per
 * axis is recovered from the column lengths of `grid_to_world`, which is exact
 * for orthogonal grids and an overestimate of cell volume for skewed ones — the
 * latter only widens the volume-guard threshold, which is conservative.
 *
 * Designed to feed e.g. a fluid simulator's solid mask, but lives outside any
 * specific package: anything that needs "rasterize a shape into a cell-centered
 * boolean grid" can use it.
 *
 * @param {AbstractShape3D} shape  shape to voxelize; `contains_point` and
 *     `signed_distance_at_point` are invoked with world-space points.
 * @param {Float32Array|number[]} world_to_grid  column-major 4×4 affine;
 *     world point → grid (cell-index) coords.
 * @param {Float32Array|number[]} grid_to_world  column-major 4×4 affine;
 *     grid (cell-index) coords → world cell center.
 * @param {Uint8Array} grid  output mask, length must be ≥ `rx * ry * rz`.
 *     Cells that don't pass the test are left untouched.
 * @param {number} rx  positive integer.
 * @param {number} ry  positive integer.
 * @param {number} rz  positive integer.
 */
export function shape3d_voxelize_to_grid(shape: AbstractShape3D, world_to_grid: Float32Array | number[], grid_to_world: Float32Array | number[], grid: Uint8Array, rx: number, ry: number, rz: number): void;
//# sourceMappingURL=shape3d_voxelize_to_grid.d.ts.map