@layoutit/polycss-core 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -11,6 +11,14 @@ declare const DEFAULT_PROJECTION: "cubic";
  *   variables, no JS work, no atlas re-rasterization.
  */
 type PolyTextureLightingMode = "baked" | "dynamic";
+/**
+ * Mesh post-processing intent.
+ * - "lossless": preserve the authored surface while applying exact
+ *   reductions such as interior culling and coplanar merge.
+ * - "lossy": allow bounded geometric approximation when it reduces the
+ *   rendered polygon/DOM count.
+ */
+type MeshResolution = "lossless" | "lossy";
 /**
  * 3D point/vector, stored as a `[x, y, z]` tuple. Tuple (rather than
  * `{x, y, z}`) for compact JSON: meshes serialize to thousands of vertices
@@ -280,6 +288,51 @@ declare function rotateVec3(v: Vec3, rxDeg: number, ryDeg: number, rzDeg: number
  */
 declare function inverseRotateVec3(v: Vec3, rot: Vec3): Vec3;
 
+/**
+ * Minimal quaternion helpers for composing rotations.
+ *
+ * Why we need quaternions: the public PolyMesh API exposes rotation as a
+ * Euler triple `[rx, ry, rz]` in degrees (drives CSS `rotateX rotateY
+ * rotateZ`, applied right-to-left). Euler triples don't compose by
+ * component addition — rotating Y after X must happen around the mesh's
+ * NEW local-Y axis, not world-Y. The transform-controls ring drag handler
+ * uses these helpers to compose around the mesh's local axis correctly:
+ *
+ *   q_start = quatFromEulerXYZ(currentRotationDeg)
+ *   q_delta = quatFromAxisAngle(localAxis, deltaRadians)
+ *   q_new   = quatMultiply(q_start, q_delta)        // RIGHT-multiply = local frame
+ *   next    = eulerXYZFromQuat(q_new)
+ *
+ * Convention: "XYZ" Euler means the composed rotation matrix is
+ * `Rx(rx) · Ry(ry) · Rz(rz)`, which matches CSS `rotateX rotateY rotateZ`
+ * (right-to-left application to a point ⇒ Z first, then Y, then X).
+ *
+ * Quaternion format: `[w, x, y, z]` (real-first, like three.js's internal
+ * `_x/_y/_z/_w` reordered). Stored as plain tuples — no constructor or
+ * runtime allocations per drag.
+ */
+
+/** Quaternion `[w, x, y, z]`, real component first. Unit-length is not
+ *  enforced by the type — callers normalize when needed. */
+type Quat = [number, number, number, number];
+/** Identity quaternion. */
+declare const QUAT_IDENTITY: Quat;
+/** Hamilton product `q1 * q2`. Apply to a vector as `q v q⁻¹`. Right-
+ *  multiplication composes the second rotation in the LOCAL frame of the
+ *  first — that's the property the gizmo relies on for local-axis drag. */
+declare function quatMultiply(q1: Quat, q2: Quat): Quat;
+/** Quaternion from axis-angle. `axis` must be unit length (caller's
+ *  responsibility — typically a CSS basis vector). `angleRad` in radians. */
+declare function quatFromAxisAngle(axis: Vec3, angleRad: number): Quat;
+/** Quaternion from Euler XYZ degrees — the order CSS `rotateX rotateY
+ *  rotateZ` applies. Matches the composed matrix `Rx(rx)·Ry(ry)·Rz(rz)`. */
+declare function quatFromEulerXYZ(eulerDeg: Vec3): Quat;
+/** Euler XYZ degrees from a quaternion — inverse of `quatFromEulerXYZ`.
+ *  Handles gimbal lock (|ry| → 90°) by collapsing rz onto rx. The output
+ *  matches the convention used by CSS `rotateX rotateY rotateZ` so it can
+ *  be written straight back into a PolyMesh rotation prop. */
+declare function eulerXYZFromQuat(q: Quat): Vec3;
+
 /**
  * Base tile size in CSS pixels. One polycss world unit = BASE_TILE CSS
  * pixels (pre-scale). Used to convert world-coordinate target values to
@@ -394,6 +447,82 @@ declare function computeShapeLighting(normal: Vec3, baseColor: string, direction
 
 declare function mergePolygons(input: Polygon[]): Polygon[];
 
+/**
+ * dedupeOverlappingPolygons — drop polygons whose 3D footprint coincides
+ * with another polygon's, within an epsilon tolerance.
+ *
+ * Why this exists: modelers (and importers) often emit redundant geometry
+ * for the same visible surface — a doubled face on a wall, an inner shell
+ * coincident with an outer shell, or two N-gons that fan-triangulate the
+ * same region. Each duplicate is a real `<i>` element at render time:
+ * it costs DOM, Lambert math, atlas budget, AND it produces stacked
+ * shadow leaves that visibly multiply on the receiver (overlapping dark
+ * patches on the ground).
+ *
+ * This is a separate concern from `cullInteriorPolygons` (which removes
+ * polygons fully *enclosed* by other geometry, conservative against
+ * false positives) and from `mergePolygons` (which joins same-color
+ * coplanar polygons that share an edge). A polygon's exact twin
+ * doesn't share an edge with itself and isn't enclosed by anything —
+ * it slips through both passes.
+ *
+ * Algorithm:
+ *   1. Compute each polygon's plane (normal + signed offset along
+ *      normal) and centroid.
+ *   2. Bucket polygons by quantized plane key (rounded normal direction
+ *      with sign-folding so anti-parallel faces share a bucket, and
+ *      rounded distance from origin along the unsigned normal axis).
+ *      Polygons in different buckets cannot overlap.
+ *   3. Within each bucket, do an O(K²) pairwise check on at most K
+ *      polygons. Two polygons overlap if their 2D projections onto
+ *      the shared plane share a significant area fraction.
+ *   4. When a pair overlaps, drop one: prefer keeping the one whose
+ *      normal points *away* from the mesh centroid (the "outward"
+ *      face). For ties (truly identical orientation), keep the one
+ *      with greater 2D area.
+ *
+ * Runs once at parse time in the same pipeline as mergePolygons. Zero
+ * cost at runtime — once it returns the polygon array is final and the
+ * dedup logic never executes again.
+ */
+
+/** Tunable thresholds. Default values are conservative — only catch
+ *  duplicates that are visually identical surfaces (exact twins,
+ *  back-to-back winding flips, nested polys on the same plane).
+ *  Looser values are appropriate for shadow-casting purposes, where
+ *  any polygons whose projections land in the same place can share a
+ *  shadow without affecting the rendered model. */
+interface DedupeOverlappingPolygonsOptions {
+    /** Maximum 1 - |dot(n_a, n_b)| for normals to count as "parallel".
+     *  Default 1e-3 (strict — must be near-identical orientation).
+     *  Looser values (~5e-2 ≈ 18° off) treat near-parallel normals as
+     *  duplicates, useful for shadow dedup where small orientation
+     *  differences project to nearly the same shadow shape. */
+    normalTolerance?: number;
+    /** Maximum signed-distance difference between two polygons' plane
+     *  offsets (along their shared normal) to count as coplanar.
+     *  Default 0.05 (world units). Looser values treat distinct
+     *  parallel shells (e.g. an inner cavity wall behind an outer
+     *  wall) as shadow-duplicates. */
+    distanceTolerance?: number;
+    /** Minimum overlap fraction (max of A-in-B and B-in-A vertex
+     *  containment ratios) for a pair to count as a duplicate.
+     *  Default 0.7. Lower (~0.4) is liberal; higher (~0.9) is strict. */
+    overlapFraction?: number;
+}
+/** Identify polygons that are duplicates within tolerance. Returns the
+ *  set of indices into the input array that should be dropped (the
+ *  losers of duplicate pairs). The "winner" of a pair is the polygon
+ *  whose normal faces away from the mesh centroid (outward), with
+ *  larger area as a tiebreaker.
+ *
+ *  Exposed for callers that want to act on the index set directly —
+ *  e.g. shadow casting can use a looser tolerance to skip shadow leaves
+ *  for redundant casters without removing them from the renderable
+ *  polygon set. */
+declare function findOverlappingPolygonDuplicates(input: Polygon[], options?: DedupeOverlappingPolygonsOptions): Set<number>;
+declare function dedupeOverlappingPolygons(input: Polygon[], options?: DedupeOverlappingPolygonsOptions): Polygon[];
+
 interface CoverPlanarPolygonsOptions {
     /** Smallest connected coplanar group worth attempting. Default 4. */
     minGroupPolygons?: number;
@@ -413,6 +542,30 @@ interface CoverPlanarPolygonsOptions {
  */
 declare function coverPlanarPolygons(input: Polygon[], options?: CoverPlanarPolygonsOptions): Polygon[];
 
+interface ApproximateMergeOptions {
+    maxAngleDeg?: number;
+    maxPlaneDisplacement?: number;
+    maxBoundaryDisplacement?: number;
+    isolatedPairs?: boolean;
+}
+interface OptimizeMeshPolygonsOptions {
+    /** Public quality/resolution intent. Defaults to "lossy". */
+    meshResolution?: MeshResolution;
+    /**
+     * Run the planar cover pass as an exact candidate for untextured coplanar
+     * regions. Defaults to true.
+     */
+    rectCover?: boolean | CoverPlanarPolygonsOptions;
+    /**
+     * Lossy approximate merge settings. Ignored for lossless resolution.
+     * When omitted, lossy evaluates isolated-pair and small plane-group
+     * strategies, then chooses the lowest render-cost result with a near-cost
+     * preference for candidates that reduce detected internal gaps.
+     */
+    approximateMerge?: boolean | ApproximateMergeOptions;
+}
+declare function optimizeMeshPolygons(polygons: Polygon[], options?: OptimizeMeshPolygonsOptions): Polygon[];
+
 /**
  * cullInteriorPolygons — remove polygons that are fully enclosed by other
  * polygons of the same mesh and therefore never visible from any external
@@ -440,6 +593,29 @@ interface CullInteriorOptions {
 }
 declare function cullInteriorPolygons(polygons: Polygon[], options?: CullInteriorOptions): Polygon[];
 
+declare const CAMERA_BACKFACE_CULL_EPS = 0.00001;
+declare const VOXEL_CAMERA_CULL_AXIS_EPS = 0.001;
+declare const VOXEL_CAMERA_CULL_NORMAL_LIMIT = 6;
+interface CameraCullRotation {
+    rotX: number;
+    rotY: number;
+    meshRotation?: Vec3;
+}
+interface CameraCullNormalGroup {
+    key: string;
+    normal: Vec3;
+}
+declare function polygonCssSurfaceNormal(polygon: Polygon): Vec3 | null;
+declare function cameraFacingDepth(normal: Vec3, rotation: CameraCullRotation): number;
+declare function normalFacesCamera(normal: Vec3, rotation: CameraCullRotation, depthThreshold?: number): boolean;
+declare function polygonFacesCamera(polygon: Polygon, rotation: CameraCullRotation, depthThreshold?: number): boolean;
+declare function cameraCullNormalKey(normal: Vec3): string;
+declare function cameraCullNormalGroups(normals: Iterable<Vec3 | null | undefined>): CameraCullNormalGroup[];
+declare function cameraCullNormalGroupsFromPolygons(polygons: readonly Polygon[]): CameraCullNormalGroup[];
+declare function isAxisAlignedSurfaceNormal(normal: Vec3, axisEpsilon?: number): boolean;
+declare function isVoxelCameraCullableNormalGroups(groups: readonly CameraCullNormalGroup[]): boolean;
+declare function cameraCullVisibleSignature(groups: readonly CameraCullNormalGroup[], rotation: CameraCullRotation, depthThreshold?: number): string;
+
 /**
  * Geometry for the three.js-style debug axes gizmo: three thin colored
  * cuboids stretching along world-X, world-Y and world-Z. Mirrors the
@@ -471,6 +647,30 @@ interface AxesHelperOptions {
  */
 declare function axesHelperPolygons(options?: AxesHelperOptions): Polygon[];
 
+/**
+ * Axis-aligned box/cuboid geometry as six quad polygons.
+ *
+ * Returned polygons are in standard polycss world space:
+ * +X = right, +Y = front/forward, +Z = top/up.
+ */
+
+type BoxFace = "right" | "left" | "front" | "back" | "top" | "bottom";
+type BoxFaceOptions = Pick<Polygon, "color" | "texture" | "material" | "uvs" | "data">;
+interface BoxPolygonsOptions extends BoxFaceOptions {
+    /** Size along the world X/Y/Z axes. Defaults to a 1×1×1 cube. */
+    size?: number | Vec3;
+    /** Center used with `size`. Defaults to the origin. */
+    center?: Vec3;
+    /** Explicit minimum world-space corner. When set with `max`, bounds win over size/center. */
+    min?: Vec3;
+    /** Explicit maximum world-space corner. When set with `min`, bounds win over size/center. */
+    max?: Vec3;
+    /** Per-face material/data overrides. Set a face to `false` to omit it. */
+    faces?: Partial<Record<BoxFace, BoxFaceOptions | false>>;
+}
+/** Build the polygons for one axis-aligned box/cuboid. */
+declare function boxPolygons(options?: BoxPolygonsOptions): Polygon[];
+
 /**
  * Geometry for a single 3D arrow: a thin axis-aligned cuboid shaft
  * stretching from the origin along one signed axis, capped with a
@@ -497,6 +697,11 @@ interface ArrowPolygonsOptions {
     headHalfThickness?: number;
     /** Fill color. */
     color?: string;
+    /** Emit the rectangular shaft polygons. Default `true`. Set `false` to
+     *  render just the pyramid head — used by transform-control gizmos to
+     *  declutter back-facing axes (only the head still identifies direction
+     *  while the shaft would visually overlap the front-facing arrow). */
+    shaft?: boolean;
 }
 /** Build the polygons for one signed-axis arrow. */
 declare function arrowPolygons(options: ArrowPolygonsOptions): Polygon[];
@@ -534,6 +739,66 @@ interface RingPolygonsOptions {
 /** Build the polygons for a flat ring (annulus). */
 declare function ringPolygons(options: RingPolygonsOptions): Polygon[];
 
+/**
+ * One square quad covering the bounding box of a ring (annulus) in the
+ * plane perpendicular to a chosen axis. Used by `<PolyTransformControls
+ * mode="rotate">` together with a CSS `mask: radial-gradient(...)` to
+ * render the visible donut, replacing the segmented quad-strip approach
+ * of `ringPolygons` with a single DOM element per ring.
+ *
+ * The caller is responsible for applying the mask CSS and using a donut-
+ * shaped hit-test (the quad's bounding rect alone would over-hit the
+ * inner hole). The recommended setup is to set the CSS custom property
+ * `--ring-inner-ratio` on the mesh element so the mask scales with the
+ * caller's chosen thickness ratio.
+ */
+
+interface RingQuadPolygonsOptions {
+    /** World axis the ring is perpendicular to: 0=X, 1=Y, 2=Z. The quad
+     *  lies in the plane spanned by the other two axes. */
+    axis: 0 | 1 | 2;
+    /** Outer radius of the ring. The quad spans ±outerRadius in both
+     *  in-plane axes. */
+    outerRadius: number;
+    /** Fill color. */
+    color?: string;
+}
+/** Build a single 4-vertex polygon (a square) bounding the ring's outer
+ *  circle. CSS `mask` is expected to clip this to the donut shape at
+ *  render time. */
+declare function ringQuadPolygons(options: RingQuadPolygonsOptions): Polygon[];
+
+/**
+ * A flat quad on one of the three axis-aligned planes, offset diagonally
+ * along the two in-plane axes. Used as a planar drag handle in
+ * `<PolyTransformControls>` — clicking and dragging this handle moves the
+ * attached mesh along two axes simultaneously (XY, XZ, or YZ), instead of
+ * the single-axis motion the arrow shafts provide.
+ *
+ * The polygon lives in standard polycss world space; wrap it in the
+ * framework's PolyMesh equivalent for rendering.
+ */
+
+interface PlanePolygonsOptions {
+    /** Axis perpendicular to the plane: 0 = YZ plane, 1 = XZ plane,
+     *  2 = XY plane. The quad lies on the OTHER two axes. */
+    axis: 0 | 1 | 2;
+    /** Half-extent of the quad along each in-plane axis. Default `0.4`. */
+    size?: number;
+    /** Center of the quad along the two in-plane axes. Pass a single number
+     *  to use the same offset on both (positive places the handle in the
+     *  +A/+B corner). Pass `[offsetA, offsetB]` to control each
+     *  independently — sign flips move the handle to a different octant.
+     *  `A = (axis+1)%3`, `B = (axis+2)%3`. Default `size * 2`. */
+    offset?: number | [number, number];
+    /** Position along the perpendicular axis. Default `0` (on the plane). */
+    along?: number;
+    /** Fill color. */
+    color?: string;
+}
+/** Build the polygons for one axis-aligned planar drag handle. */
+declare function planePolygons(options: PlanePolygonsOptions): Polygon[];
+
 /**
  * Geometry for a small solid-color octahedron — the marker shape used by
  * `PolyDirectionalLightHelper` to indicate where a directional light is
@@ -563,6 +828,22 @@ declare function octahedronPolygons(options: OctahedronPolygonsOptions): Polygon
  * is empty (e.g. `parseObj`, where it's a no-op).
  */
 
+interface PolyVoxelCell {
+    x: number;
+    y: number;
+    z: number;
+    color: string;
+}
+interface PolyVoxelSource {
+    kind: "magica-vox";
+    cells: PolyVoxelCell[];
+    rows: number;
+    cols: number;
+    depth: number;
+    scale: number;
+    gridShift: number;
+    sourceBytes: number;
+}
 interface ParseAnimationClip {
     /** Stable numeric index in the source file's animation array. */
     index: number;
@@ -585,6 +866,8 @@ interface ParseAnimationController {
 interface ParseResult {
     /** The mesh, as a flat polygon list. Already vertex-permuted to polycss space. */
     polygons: Polygon[];
+    /** Optional raw voxel source for `.vox` fast paths; polygon fallback remains authoritative. */
+    voxelSource?: PolyVoxelSource;
     /** Optional animation sampler for formats that carry timeline data. */
     animation?: ParseAnimationController;
     /**
@@ -616,6 +899,8 @@ interface ParseResult {
         animations?: ParseAnimationClip[];
         /** Source file size in bytes (for diagnostics). */
         sourceBytes?: number;
+        /** Voxel count for `.vox` sources. */
+        voxelCount?: number;
     };
 }
 
@@ -851,8 +1136,9 @@ declare function bakeSolidTextureSamples(result: ParseResult, options?: SolidTex
 
 interface VoxParseOptions {
     /**
-     * Largest mesh extent (in scene-space units). The mesh is uniformly
-     * scaled so its longest bbox dimension equals this. Default: 60.
+     * Largest mesh extent (in scene-space units). For `.vox`, the requested
+     * extent is snapped to the nearest integer CSS cell size to keep voxel
+     * fast-path coordinates integral. Default: 60.
      */
     targetSize?: number;
     /**
@@ -864,6 +1150,51 @@ interface VoxParseOptions {
 }
 declare function parseVox(buffer: ArrayBuffer, options?: VoxParseOptions): ParseResult;
 
+type PlaneAxis = "x" | "y" | "z";
+type PolyVoxelFace = "t" | "b" | "bl" | "br" | "fr" | "fl";
+interface PolyVoxelWallsMask {
+    t: boolean;
+    b: boolean;
+    bl: boolean;
+    br: boolean;
+    fl: boolean;
+    fr: boolean;
+}
+interface FaceKey {
+    axis: PlaneAxis;
+    plane: number;
+    face: PolyVoxelFace;
+}
+interface FaceBuffer {
+    width: number;
+    height: number;
+    minRow: number;
+    minCol: number;
+    ids: Uint32Array;
+    mask: Uint8Array;
+    filledCount: number;
+    palette: string[];
+}
+interface FaceData {
+    key: FaceKey;
+    buffer: FaceBuffer;
+}
+type Brush = {
+    r0: number;
+    c0: number;
+    r1: number;
+    c1: number;
+    baseColor: string;
+};
+type SlicePlan = {
+    key: FaceKey;
+    buffer: FaceBuffer;
+    brushes: Brush[];
+};
+declare const NEXT_LAYER_STEP: Record<PolyVoxelFace, number>;
+declare const buildSlicePlan: (faceData: FaceData, nextLayer: FaceBuffer | null) => SlicePlan;
+declare const buildFaceDataFromVoxelSource: (source: PolyVoxelSource) => FaceData[];
+
 /**
  * loadMesh — high-level fetch+parse dispatcher. Picks the parser by file
  * extension, fetches the URL, runs the parser, returns the unified
@@ -908,7 +1239,12 @@ interface LoadMeshOptions {
      * low-poly models that use texture atlases as color swatches.
      */
     solidTextureSamples?: boolean | SolidTextureSampleOptions;
+    /**
+     * Mesh optimization intent. Defaults to "lossy"; set "lossless" to keep
+     * exact planar candidates only.
+     */
+    meshResolution?: MeshResolution;
 }
 declare function loadMesh(url: string, options?: LoadMeshOptions): Promise<ParseResult>;
 
-export { type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BASE_TILE, type CameraHandle, type CameraState, type CameraStyleInput, type CoverPlanarPolygonsOptions, type CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, type GltfParseOptions, type LoadMeshOptions, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParsedColor, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyDirectionalLight, type PolyMaterial, type PolyTextureLightingMode, type Polygon, type PolygonFace, type RingPolygonsOptions, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type SolidTextureSampleOptions, type TexturePaintMetrics, type TexturePaintMetricsOptions, type TextureTriangle, type Vec2, type Vec3, type VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, buildSceneContext, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, formatColor, inverseRotateVec3, loadMesh, mergePolygons, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, polygonFaces, ringPolygons, rotateVec3, shadeColor };
+export { type ApproximateMergeOptions, type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BASE_TILE, type BoxFace, type BoxFaceOptions, type BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, type CameraCullNormalGroup, type CameraCullRotation, type CameraHandle, type CameraState, type CameraStyleInput, type CoverPlanarPolygonsOptions, type CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, type DedupeOverlappingPolygonsOptions, type GltfParseOptions, type LoadMeshOptions, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, type MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeMeshPolygonsOptions, NEXT_LAYER_STEP as POLY_VOXEL_NEXT_LAYER_STEP, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParsedColor, type PlanePolygonsOptions, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyDirectionalLight, type PolyMaterial, type PolyTextureLightingMode, type Brush as PolyVoxelBrush, type PolyVoxelCell, type PolyVoxelFace, type FaceBuffer as PolyVoxelFaceBuffer, type FaceData as PolyVoxelFaceData, type FaceKey as PolyVoxelFaceKey, type PlaneAxis as PolyVoxelPlaneAxis, type SlicePlan as PolyVoxelSlicePlan, type PolyVoxelSource, type PolyVoxelWallsMask, type Polygon, type PolygonFace, QUAT_IDENTITY, type Quat, type RingPolygonsOptions, type RingQuadPolygonsOptions, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type SolidTextureSampleOptions, type TexturePaintMetrics, type TexturePaintMetricsOptions, type TextureTriangle, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, type Vec2, type Vec3, type VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildFaceDataFromVoxelSource as buildPolyVoxelFaceData, buildSlicePlan as buildPolyVoxelSlicePlan, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, dedupeOverlappingPolygons, eulerXYZFromQuat, findOverlappingPolygonDuplicates, formatColor, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, ringPolygons, ringQuadPolygons, rotateVec3, shadeColor };