@layoutit/polycss-core 0.2.5 → 0.2.7

package/dist/index.d.ts

@@ -11,6 +11,29 @@ declare const DEFAULT_PROJECTION: "cubic";
  *   variables, no JS work, no atlas re-rasterization.
  */
 type PolyTextureLightingMode = "baked" | "dynamic";
+type PolyTextureLeafSizing = "canonical" | "local" | "raster";
+type PolyTextureBackend = "auto" | "atlas" | "image";
+type PolyTextureImageRendering = "auto" | "pixelated";
+type PolyTextureImageLighting = "scene" | "source";
+type PolyTextureProjection = "affine" | "projective";
+interface PolyTextureImageSource {
+    url: string;
+    width: number;
+    height: number;
+    sourceRect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    imageRendering?: PolyTextureImageRendering;
+}
+interface PolyTexturePresentation {
+    imageRendering?: PolyTextureImageRendering;
+    backend?: PolyTextureBackend;
+    lighting?: PolyTextureImageLighting;
+    projection?: PolyTextureProjection;
+}
 /**
  * Mesh post-processing intent.
  * - "lossless": preserve the authored surface while applying exact
@@ -59,6 +82,29 @@ interface PolyDirectionalLight {
     /** Scalar multiplier on the directional contribution. Default 1. */
     intensity?: number;
 }
+/**
+ * Point light — radiates from a world-space position. Contributes per-face
+ * Lambert like a directional light, but the light direction is computed
+ * per polygon (face centroid → light position) rather than being global.
+ *
+ * DIRECTION-ONLY by design: there is no distance falloff (no `decay`/
+ * `distance`). A point light differs from a directional light only in that
+ * its direction varies per face. To emulate in three.js for parity, use
+ * `new THREE.PointLight(color, intensity, 0, 0)` (distance 0, decay 0 →
+ * no attenuation). Shading is flat per face (the centroid direction), so it
+ * approximates three.js's per-fragment gradient — exact for small faces /
+ * distant lights, never a CSS gradient.
+ */
+interface PolyPointLight {
+    /** World-space position the light radiates from. */
+    position: Vec3;
+    /** Light tint, hex string. White by default. */
+    color?: string;
+    /** Scalar multiplier on the contribution. Default 1. */
+    intensity?: number;
+    /** When true, this light casts shadows (radial projection). Default false. */
+    castShadow?: boolean;
+}
 /**
  * Ambient light — uniform fill that adds to every polygon regardless of
  * orientation. Mirrors three.js's `AmbientLight`. Decoupled from the
@@ -92,6 +138,8 @@ interface PolyMaterial {
      *  pass a stable string; if omitted, the material's identity is its object
      *  reference. */
     key?: string;
+    imageSource?: PolyTextureImageSource;
+    presentation?: PolyTexturePresentation;
 }
 /**
  * The single polygon type for polycss. N coplanar vertices in 3D space,
@@ -134,6 +182,8 @@ interface Polygon {
      * polygon canvas rasterization). Falls back to the atlas path otherwise.
      */
     material?: PolyMaterial;
+    textureImageSource?: PolyTextureImageSource;
+    texturePresentation?: PolyTexturePresentation;
     /**
      * Per-vertex UV coords (0..1, OBJ convention with v=0 at bottom).
      * Length MUST equal vertices.length when set; mismatched UVs are
@@ -432,8 +482,32 @@ interface CameraHandle {
         height: string;
     };
 }
+interface PolyCameraSceneTransformOptions {
+    autoCenterOffset?: Vec3;
+    layoutScale?: number;
+    tileSize?: number;
+}
+type PolyCameraProjection = "orthographic" | "perspective";
+interface PolyCameraSnapshot {
+    projection: PolyCameraProjection;
+    perspectiveStyle: string;
+    appliedPerspectiveStyle: string;
+    state: CameraState;
+}
+interface PolyCameraSnapshotOptions {
+    projection?: PolyCameraProjection;
+    perspectiveStyle?: string;
+}
+type PolyCameraSnapshotSource = CameraHandle & {
+    readonly type?: PolyCameraProjection;
+    readonly perspectiveStyle?: string;
+};
 declare function normalizeInvertMultiplier(value: number | boolean | undefined): number | undefined;
 declare const DEFAULT_CAMERA_STATE: CameraState;
+declare function polyCameraTargetToCss(target?: Vec3, autoCenterOffset?: Vec3, tileSize?: number): Vec3;
+declare function buildPolyCameraSceneTransform(state?: Partial<CameraState>, options?: PolyCameraSceneTransformOptions): string;
+declare function resolvePolyCameraAppliedPerspectiveStyle(perspectiveStyle?: string): string;
+declare function capturePolyCameraSnapshot(camera: PolyCameraSnapshotSource, options?: PolyCameraSnapshotOptions): PolyCameraSnapshot;
 declare function createIsometricCamera(initial?: Partial<CameraState>): CameraHandle;
 
 /**
@@ -1404,6 +1478,29 @@ declare const BAKED_SHADOW_MIN_UP = 0.01;
  * already in unit-less form (matrix3d entries must be dimensionless).
  */
 declare function buildBakedShadowProjectionMatrix(lightDir: Vec3, groundCssZ: number): number[];
+/**
+ * Radial variant of `projectCssVertexToGround` for a point light at a fixed
+ * CSS-frame position. The shadow ray travels FROM the light THROUGH the
+ * vertex and onto the ground plane `z = groundCssZ`, so each vertex projects
+ * along its own direction (a true perspective projection) rather than the
+ * single parallel direction a directional light uses.
+ *
+ * Returns `null` when no valid forward intersection exists — the vertex sits
+ * on the light's side of the ground plane, or the ray runs parallel to it.
+ * The caller drops that vertex (and any polygon that loses ≥1 vertex falls
+ * back to a degenerate projection it can skip).
+ *
+ * `lightPos` and `cssVertex` are both in the dimensionless CSS frame (after
+ * the world→CSS axis swap + tile scale), matching `projectCssVertexToGround`.
+ */
+declare function projectCssVertexToGroundFromPoint(cssVertex: Vec3, lightPos: Vec3, groundCssZ: number): [number, number] | null;
+/**
+ * Point-light variant of `isBakedShadowCaster`. A polygon casts shadow when
+ * its outward normal points away from the light — i.e. the ray from the
+ * light to the polygon centroid runs into the back of the face. `centroid`
+ * and `lightPos` are CSS-frame; `normal` is the CSS-frame outward normal.
+ */
+declare function isPointShadowCaster(centroid: Vec3, normal: Vec3, lightPos: Vec3): boolean;
 /**
  * Decides whether a polygon should cast a shadow given its outward
  * normal and the light's travel direction.
@@ -1449,6 +1546,73 @@ declare function ensureCcw2D(vertices: ReadonlyArray<readonly [number, number]>)
  */
 declare function projectCssVertexToGround(cssVertex: Vec3, lightDir: Vec3, groundCssZ: number): [number, number];
 
+/**
+ * Build the parametric silhouette loop for a caster lit by a directional light.
+ *
+ * @param worldVerts  Every caster vertex in the same world-CSS frame the
+ *                    receiver projector works in (e.g. `CasterPolyItem.wv`).
+ * @param lightDir    Directional light vector (to-source) in that frame.
+ * @param definition  Max loop points. The convex hull is decimated down to this
+ *                    by repeatedly dropping the lowest-area vertex (shape-
+ *                    preserving). `<= 2` is treated as 3.
+ * @returns A closed 3D loop (the silhouette vertices), or `null` if degenerate.
+ */
+declare function computeParametricShadowSilhouette(worldVerts: ReadonlyArray<Vec3>, lightDir: Vec3, definition: number): Vec3[] | null;
+
+/**
+ * Build concave coverage-contour silhouette loops for a caster lit by a
+ * directional light.
+ *
+ * @param polysWorldVerts  Each caster polygon's vertices in the world-CSS frame
+ *                         (e.g. `CasterPolyItem.wv`).
+ * @param lightDir         Directional light vector (to-source) in that frame.
+ * @param definition       Detail knob → coverage mask resolution.
+ * @param layers           Depth bands along the light. 1 (default) = one flat
+ *                         outline (cross-mesh casting). >1 = depth-stratified
+ *                         outlines for correct self-shadow.
+ * @returns Closed 3D loops, or `null`.
+ */
+declare function computeCoverageShadowSilhouette(polysWorldVerts: ReadonlyArray<ReadonlyArray<Vec3>>, lightDir: Vec3, definition: number, layers?: number, mode?: "contour" | "pixel"): Vec3[][] | null;
+
+/** True when every caster vertex lies in a single plane (a ground quad, a
+ *  billboard, etc.). Such casters have no coverage volume for the parametric
+ *  proxy — their tilted proxy would project garbage onto a coplanar receiver —
+ *  so the caller routes them through the exact path instead. */
+declare function isFlatCaster(polysWv: ReadonlyArray<ReadonlyArray<Vec3>>): boolean;
+/** Rubric: a CONVEX caster self-shadows nothing. The depth-band proxy still
+ *  leaks a little false self-shadow on convex meshes, so detect convexity and
+ *  skip self-shadow for them. Capped at `maxPolys` (O(faces × verts), and large
+ *  meshes are essentially never convex — they early-exit on the first concave
+ *  face anyway). */
+declare function isConvexCaster(polysWv: ReadonlyArray<ReadonlyArray<Vec3>>, maxPolys?: number): boolean;
+interface ParametricOverrideInput {
+    /** Caster polygons, each a vertex list in the world-CSS frame. */
+    polysWorldVerts: ReadonlyArray<ReadonlyArray<Vec3>>;
+    /** Directional light (to-source) in the world-CSS frame. */
+    lightDir: Vec3;
+    /** Effective definition (caller folds in per-mesh override + drag cap). */
+    definition: number;
+    /** True when the caster is also the receiver (self-shadow). */
+    isSelf: boolean;
+    /** `"pixel"` greedy-meshes the coverage into voxel rects; default contour. */
+    style?: "vector" | "pixel";
+    /** Shadow-casting point lights (CSS position + index in `allPointLights`). */
+    pointLights?: ReadonlyArray<{
+        position: Vec3;
+        index: number;
+    }>;
+}
+interface ParametricOverrideResult {
+    /** Directional override loops, or undefined to use the exact path. */
+    overrideSilhouette?: Vec3[][];
+    /** Per-point-light radial override loops (indexed by point light index). */
+    overridePointSilhouettes?: Array<Vec3[][] | undefined>;
+}
+/** Build the parametric override(s) for one caster — directional plus one
+ *  radial silhouette per shadow-casting point light. Returns empty overrides
+ *  (use the exact path) for flat casters and convex self-shadow. */
+declare function buildParametricCasterOverride(input: ParametricOverrideInput): ParametricOverrideResult;
+
 type Pt = readonly [number, number];
 /**
  * Clips `subject` against the convex polygon `clip`. Both polygons are
@@ -1497,6 +1661,12 @@ declare function worldDirectionToCss(d: Vec3): Vec3;
 declare function worldDirectionalLightToCss<T extends {
     direction?: Vec3;
 } | undefined>(light: T): T;
+declare const worldDistanceToPolyCss: typeof worldDistanceToCss;
+declare const polyCssDistanceToWorld: typeof cssDistanceToWorld;
+declare const worldPositionToPolyCss: typeof worldPositionToCss;
+declare const polyCssPositionToWorld: typeof cssPositionToWorld;
+declare const worldDirectionToPolyCss: typeof worldDirectionToCss;
+declare const worldDirectionalLightToPolyCss: typeof worldDirectionalLightToCss;
 /** Normalize a mesh `scale` value into a Vec3 (undefined → [1,1,1], number →
  *  uniform, Vec3 → as-is with `?? 1` per axis). */
 declare function meshScaleVec3(scale: number | Vec3 | undefined | null): Vec3;
@@ -1633,18 +1803,6 @@ declare function buildEdgeOwners(polygons: readonly Polygon[]): Map<string, Edge
  *  TRAVELS in direction L, polygons are CCW-from-outside). Matches the
  *  light-backface cull's sign convention. */
 declare function classifyFacing(planeNormals: Array<Vec3 | null>, lightDir: Vec3): boolean[];
-/**
- * Walk silhouette edges into closed loops. An edge is silhouette iff
- * its two adjacent polygons disagree on `facing`. Boundary edges
- * (polyB === null) are silhouette iff their owner is front-facing —
- * the boundary is where the lit side ends.
- *
- * Returns one closed loop per connected silhouette cycle, each as a
- * Vec3[] sequence (last vertex equals first vertex implicitly; not
- * duplicated). For non-manifold or open meshes some edges may not form
- * a clean cycle; those edges are dropped and the remaining cycles are
- * returned best-effort.
- */
 declare function extractSilhouetteLoops(edgeOwners: ReadonlyMap<string, EdgeOwners>, facing: boolean[]): Vec3[][];
 
 /**
@@ -1717,6 +1875,15 @@ interface ReceiverCasterInput<T = unknown> {
      *  array is sized correctly even when atlas-plan / dedup filters drop
      *  some polygons from `items`. */
     casterPolygonCount?: number;
+    /** Parametric-shadow override: a precomputed world-frame silhouette loop set
+     *  (see `computeParametricShadowSilhouette`). When present it is projected
+     *  directly — skipping per-poly and silhouette extraction — so a cheap,
+     *  low-resolution outline casts onto every receiver via the normal pipeline. */
+    overrideSilhouette?: Vec3[][];
+    /** Per-point-light parametric override (indexed by the point light's index in
+     *  `allPointLights`). A point pass uses this RADIAL silhouette instead of the
+     *  directional `overrideSilhouette`; an undefined entry → exact point path. */
+    overridePointSilhouettes?: Array<Vec3[][] | undefined>;
 }
 /**
  * Build a polygon-adjacency map: polygonIndex → set of polygonIndex that
@@ -1758,6 +1925,15 @@ interface ReceiverShadowFaceSpec<T = unknown> {
      *  if applicable). */
     opacity: number;
     paths: Array<ReceiverShadowPath<T>>;
+    /** Full-lit face color C (all lights), for the multi-light merge: callers
+     *  multiply C by each pass's `fill/C` factor so overlaps composite to the
+     *  both-blocked color. Empty string for textured receivers (per-pixel base,
+     *  multiply can't be uniform — those fall back to cumulative-alpha). */
+    fullLitFill: string;
+    /** Every clipped caster polygon for this pass in absolute face-(u,v) space
+     *  (NOT offset by the tight bbox). The multi-light merge re-bases these to a
+     *  shared per-face bbox so all lights' shadows live in one SVG. */
+    facePolysUv: Array<Array<[number, number]>>;
 }
 /**
  * Build silhouette `edgeOwners` for a caster mesh in world-CSS frame.
@@ -1802,8 +1978,29 @@ interface ComputeReceiverShadowFacesInput<T = unknown> {
     receiverHasTexture: boolean;
     /** Per-caster items + caller id, in caller-defined order. */
     casters: ReceiverCasterInput<T>[];
-    /** Directional light vector in CSS frame. */
+    /** Light direction in CSS frame, pointing TOWARD the light (to-source).
+     *  For a point light this is a representative direction (used only for the
+     *  textured-receiver opacity ratio); per-vertex directions come from
+     *  `lightPos`. */
     lightDir: Vec3;
+    /** When set, the light is a point light at this CSS-frame position. The
+     *  shadow projection becomes radial (per-vertex direction from the light)
+     *  and the silhouette fast path is disabled (facing is per-polygon). */
+    lightPos?: Vec3;
+    /** Every point light in the scene (CSS-frame absolute positions), used to
+     *  compute the SHADED shadow color — a shadow shows the receiver lit by all
+     *  lights EXCEPT the blocked one, so a spot shadowed from one colored light
+     *  still shows the others' color (Three.js parity). Includes non-shadow-
+     *  casting lights, since they still illuminate the shadowed region. */
+    allPointLights?: ReadonlyArray<{
+        position: Vec3;
+        color?: string;
+        intensity?: number;
+    }>;
+    /** For a point-light pass, the index into `allPointLights` of the light
+     *  being shadowed (excluded from the remaining-light fill). Undefined for
+     *  the directional pass (which instead excludes the directional light). */
+    thisPointIndex?: number;
     /** Camera cull rotation (rotX/rotY + receiver mesh rotation) so back-
      *  facing receiver faces can be skipped. */
     cameraRot: CameraCullRotation;
@@ -1824,6 +2021,73 @@ interface ComputeReceiverShadowFacesInput<T = unknown> {
  * back-facing faces. Caller mounts SVGs per spec.
  */
 declare function computeReceiverShadowFaces<T = unknown>(input: ComputeReceiverShadowFacesInput<T>): ReceiverShadowFaceSpec<T>[];
+/** One path inside a merged face SVG. */
+interface MergedShadowLayer {
+    /** Path data (`M…L…Z`, already offset to the SVG's tight bbox). */
+    d: string;
+    /** Fill color (remaining-light color for a single layer, multiply factor for
+     *  a merged solid layer, dark shadow color for textured). */
+    fill: string;
+    /** Apply `mix-blend-mode: multiply` (merged solid layers only). */
+    multiply: boolean;
+    /** Per-path opacity (1 for merged solid layers, which carry strength on the
+     *  SVG; the pass's own opacity otherwise). */
+    opacity: number;
+}
+/** One receiver FACE's merged shadow, ready to mount as a single SVG. */
+interface MergedShadowFace {
+    faceIndex: number;
+    memberPolyIndices: number[];
+    matrixCss: string;
+    width: number;
+    height: number;
+    /** SVG-level opacity (shadow strength for merged solid faces, else 1). */
+    svgOpacity: number;
+    /** Full-lit base path (merged solid faces only); null otherwise. */
+    baseFill: string | null;
+    baseD: string | null;
+    layers: MergedShadowLayer[];
+}
+/** Inputs for `computeMergedReceiverShadows` — the full light set for one
+ *  receiver, plus its prepared face planes and casters. */
+interface MergedReceiverShadowInput<T = unknown> {
+    receiverPlanes: ReceiverFacePlane[];
+    receiverPolygons: readonly Polygon[];
+    receiverHasTexture: boolean;
+    casters: ReceiverCasterInput<T>[];
+    /** Directional light vector in CSS frame (to-source). */
+    lightDir: Vec3;
+    /** Run the directional pass (caller gates on a real, nonzero-intensity
+     *  directional light). */
+    runDirectional: boolean;
+    /** One pass per shadow-casting point light: CSS position + index into
+     *  `allPointLights`. Empty in dynamic mode (point lights are baked-only). */
+    pointPasses: ReadonlyArray<{
+        lightPos: Vec3;
+        index: number;
+    }>;
+    /** All point lights (CSS positions) for the shaded shadow color; empty in
+     *  dynamic mode. */
+    allPointLights?: ReadonlyArray<{
+        position: Vec3;
+        color?: string;
+        intensity?: number;
+    }>;
+    cameraRot: CameraCullRotation;
+    ambientLight?: PolyAmbientLight;
+    directionalLight?: PolyDirectionalLight;
+    shadow?: {
+        color?: string;
+        opacity?: number;
+        maxExtend?: number;
+    };
+}
+/**
+ * Run every light pass for one receiver and merge each face's passes into a
+ * single SVG descriptor. Shared by all three renderers so multi-light shadow
+ * overlap is identical everywhere.
+ */
+declare function computeMergedReceiverShadows<T = unknown>(input: MergedReceiverShadowInput<T>): MergedShadowFace[];
 
 /**
  * PolyAnimationMixer — three.js-shaped animation API for polycss.
@@ -2272,6 +2536,9 @@ interface TextureAtlasPlan {
     canonicalMatrix: string;
     atlasMatrix: string;
     atlasCanonicalSize?: number;
+    atlasLeafSizing?: PolyTextureLeafSizing;
+    atlasLeafWidth?: number;
+    atlasLeafHeight?: number;
     projectiveMatrix: string | null;
     canvasW: number;
     canvasH: number;
@@ -2296,6 +2563,33 @@ interface TextureAtlasPlan {
     textureTint: RGBFactors;
     shadedColor: string;
 }
+interface PolyTextureLeafSourceRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface PolyTextureLeafGeometry {
+    source: PolyTextureImageSource;
+    url: string;
+    sourceRect: PolyTextureLeafSourceRect;
+    leafWidth: number;
+    leafHeight: number;
+    matrix: string;
+    backgroundPosition: [number, number];
+    backgroundSize: [number, number];
+    imageRendering: PolyTextureImageRendering;
+    lighting: PolyTextureImageLighting;
+    projection: PolyTextureProjection;
+}
+interface PolyTextureLeafResolverOptions {
+    imageRendering?: PolyTextureImageRendering;
+    backend?: PolyTextureBackend;
+    lighting?: PolyTextureImageLighting;
+    projection?: PolyTextureProjection;
+    allowProjective?: boolean;
+    projectiveQuadGuards?: ProjectiveQuadGuardSettings;
+}
 interface BorderShapeBounds {
     minX: number;
     minY: number;
@@ -2483,6 +2777,10 @@ interface SolidTrianglePlanOptions {
     tileSize?: number;
     layerElevation?: number;
     directionalLight?: PolyDirectionalLight;
+    /** Point lights in MESH-LOCAL frame (renderer pre-transforms each scene
+     *  point light by inverse-rotate(worldPos - meshPos) so positions match
+     *  the local cssPoints frame). Direction-only, per-face Lambert. */
+    pointLights?: PolyPointLight[];
     ambientLight?: PolyAmbientLight;
     textureLighting?: PolyTextureLightingMode;
     solidPaintDefaults?: SolidPaintDefaults;
@@ -2515,6 +2813,10 @@ interface ComputeTextureAtlasPlanOptions {
     tileSize?: number;
     layerElevation?: number;
     directionalLight?: PolyDirectionalLight;
+    /** Point lights in MESH-LOCAL frame (renderer pre-transforms each scene
+     *  point light by inverse-rotate(worldPos - meshPos) so positions match
+     *  the local cssPoints frame). Direction-only, per-face Lambert. */
+    pointLights?: PolyPointLight[];
     ambientLight?: PolyAmbientLight;
     /** Shared-edge set returned by {@link buildTextureEdgeRepairSets}. */
     textureEdgeRepairEdges?: Set<number>;
@@ -2538,7 +2840,7 @@ declare function formatAffineMatrix3dTransformScalars(x0: number, x1: number, x2
 declare function formatScaledMatrixFromPlan(entry: TextureAtlasPlan, scaleX: number, scaleY: number, offsetX?: number, offsetY?: number): string;
 declare function formatBorderShapeMatrix(entry: TextureAtlasPlan, bounds: BorderShapeBounds): string;
 declare function formatSolidQuadMatrix(entry: TextureAtlasPlan): string;
-declare function formatAtlasMatrix(entry: TextureAtlasPlan, atlasCanonicalSize: number): string;
+declare function formatAtlasMatrix(entry: TextureAtlasPlan, atlasLeafWidth: number, atlasLeafHeight?: number): string;
 declare function formatPercent(value: number, decimals?: number): string;
 /** Format a raw comma-separated matrix3d value string with rounded decimals. */
 declare function formatMatrix3d(matrix: string, decimals?: number): string;
@@ -2587,9 +2889,20 @@ declare function rgbToHex({ r, g, b }: RGB): string;
  * (see applyTextureTint in the renderer). `directScale` is already
  * `intensity × max(n·L, 0)` (computed by the caller).
  */
-declare function textureTintFactors(directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number): RGBFactors;
+/**
+ * One point light's per-face contribution to a polygon: its color and the
+ * scalar `intensity × max(0, n·L̂)` already computed by the caller against the
+ * face normal + centroid (point lights are direction-only — no distance
+ * falloff). Multiple lights of different colours can't fold into one scalar,
+ * so the shading functions accumulate these per channel in linear space.
+ */
+interface PointLightContrib {
+    color: string;
+    scale: number;
+}
+declare function textureTintFactors(directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number, pointContribs?: readonly PointLightContrib[]): RGBFactors;
 declare function tintToCss({ r, g, b }: RGBFactors): string;
-declare function shadePolygon(baseColor: string, directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number): string;
+declare function shadePolygon(baseColor: string, directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number, pointContribs?: readonly PointLightContrib[]): string;
 declare function quantizeCssColor(input: string, steps: number): string;
 declare function rgbEqual(a: RGB | undefined, b: RGB | undefined): boolean;
 declare function stepRgbToward(current: RGB, target: RGB, maxStep: number): RGB;
@@ -2614,6 +2927,10 @@ interface FilterAtlasPlansEnv {
     solidTriangleSupported: boolean;
     projectiveQuadSupported: boolean;
     borderShapeSupported: boolean;
+    textureBackend?: PolyTextureBackend;
+    textureImageRendering?: PolyTextureImageRendering;
+    textureImageLighting?: PolyTextureImageLighting;
+    textureProjection?: PolyTextureProjection;
     /** When true, non-triangle non-rect non-projective polys whose plan has
      *  cornerShapeGeometryForPlan != null are excluded from the atlas (they
      *  render as <u> via corner-*-shape: bevel CSS — matches vanilla's
@@ -2723,6 +3040,13 @@ declare function computeTextureAtlasPlanPublic(polygon: Polygon, index: number,
  *  this from {@link buildBasisHints}; React/Vue mirror that path. */
 basisHintOverride?: BasisHint): TextureAtlasPlan | null;
 
+declare function resolvePolyTextureLeafGeometry(plan: TextureAtlasPlan, options?: PolyTextureLeafResolverOptions): PolyTextureLeafGeometry | null;
+
+declare function resolvePolyTextureImageSource(polygon: Polygon): PolyTextureImageSource | undefined;
+declare function resolvePolyTextureUrl(polygon: Polygon): string | undefined;
+declare function resolvePolyTexturePresentation(polygon: Polygon, defaults?: PolyTexturePresentation): PolyTexturePresentation;
+declare function resolvePolyTextureImageRendering(polygon: Polygon, defaultImageRendering: PolyTextureImageRendering | undefined): PolyTextureImageRendering;
+
 declare function normalizeAtlasScale(scale: number | string | undefined): number;
 declare function atlasArea(pages: PackedPage[]): number;
 declare function autoAtlasScaleCap(pages: PackedPage[], maxDecodedBytes: number): number;
@@ -2735,6 +3059,12 @@ declare function autoAtlasMaxDecodedBytes(isMobile: boolean): number;
 /** Returns the atlas canonical size for the given texture quality and device class. */
 declare function atlasCanonicalSizeForTextureQuality(textureQualityInput: TextureQuality | undefined, isMobile: boolean): number;
 declare function applyPackedAtlasCanonicalSize(packed: PackedAtlas, atlasCanonicalSize: number): PackedAtlas;
+declare function resolveAtlasLeafBox(entry: TextureAtlasPlan, atlasScale: number, textureLeafSizing: PolyTextureLeafSizing | undefined, atlasCanonicalSize?: number): {
+    width: number;
+    height: number;
+    sizing: PolyTextureLeafSizing;
+};
+declare function applyPackedAtlasLeafSizing(packed: PackedAtlas, atlasCanonicalSize: number, atlasScale: number, textureLeafSizing?: PolyTextureLeafSizing | undefined): PackedAtlas;
 declare function atlasCanonicalSizeForEntry(entry: TextureAtlasPlan): number;
 declare function atlasPadding(atlasScale: number): number;
 declare function packTextureAtlasPlans(plans: Array<TextureAtlasPlan | null>, atlasScale?: number): PackedAtlas;
@@ -2742,10 +3072,10 @@ declare function packTextureAtlasPlans(plans: Array<TextureAtlasPlan | null>, at
  * Pack atlas plans and resolve atlas scale, accepting a pre-resolved isMobile
  * boolean instead of a Document reference.
  */
-declare function packTextureAtlasPlansWithScaleCore(plans: Array<TextureAtlasPlan | null>, textureQualityInput: TextureQuality | undefined, isMobile: boolean): {
+declare function packTextureAtlasPlansWithScaleCore(plans: Array<TextureAtlasPlan | null>, textureQualityInput: TextureQuality | undefined, isMobile: boolean, textureLeafSizing?: PolyTextureLeafSizing | undefined): {
     packed: PackedAtlas;
     atlasScale: number;
     atlasCanonicalSize: number;
 };
 
-export { ASYNC_RENDER_BUDGET_MS, ATLAS_CANONICAL_SIZE_AUTO_DESKTOP, ATLAS_CANONICAL_SIZE_EXPLICIT, ATLAS_MAX_SIZE, ATLAS_PADDING, AUTO_ATLAS_LOW_AREA, AUTO_ATLAS_MAX_BITMAP_SIDE, AUTO_ATLAS_MAX_DECODED_BYTES_DESKTOP, AUTO_ATLAS_MAX_DECODED_BYTES_MOBILE, AUTO_ATLAS_MEDIUM_AREA, AUTO_ATLAS_SCALE_GUARD, type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BAKED_SHADOW_MIN_UP, BAKED_SHADOW_Z_SQUASH, BASE_TILE, BASIS_EPS, BORDER_SHAPE_BLEED, BORDER_SHAPE_CANONICAL_SIZE, BORDER_SHAPE_CENTER_PERCENT, BORDER_SHAPE_POINT_EPS, type BasisHint, type BasisOptions, type BorderShapeBounds, type BorderShapeGeometry, type BoxFace, type BoxFaceOptions, type BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, COLOR_PARSE_CACHE_MAX, CORNER_SHAPE_DUPLICATE_EPS, CORNER_SHAPE_POINT_EPS, type CameraCullNormalGroup, type CameraCullRotation, type CameraHandle, type CameraState, type CameraStyleInput, type CasterPolyItem, type ComputeReceiverShadowFacesInput, type ComputeTextureAtlasPlanOptions, type ConePolygonsOptions, type CornerShapeCorner, type CornerShapeGeometry, type CornerShapeRadius, type CornerShapeSide, type CoverPlanarPolygonsOptions, type CullInteriorOptions, type CylinderPolygonsOptions, DECIMAL_SCALES, DEFAULT_AMBIENT_COLOR, DEFAULT_AMBIENT_INTENSITY, DEFAULT_ATLAS_CSS_DECIMALS, DEFAULT_BORDER_SHAPE_DECIMALS, DEFAULT_CAMERA_STATE, DEFAULT_LIGHT_COLOR, DEFAULT_LIGHT_DIR, DEFAULT_LIGHT_INTENSITY, DEFAULT_MATRIX_DECIMALS, DEFAULT_PROJECTION, DEFAULT_SEAM_BLEED, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DEFAULT_TILE, type DedupeOverlappingPolygonsOptions, type DodecahedronPolygonsOptions, type EdgeOwners, type FilterAtlasPlansEnv, type GetSolidPaintDefaultsEnv, type GltfParseOptions, type IcosahedronPolygonsOptions, type InternalSolidTrianglePlanOptions, type LoadMeshOptions, type LocalBasis, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MAX_ATLAS_SCALE, MIN_ATLAS_SCALE, type MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeAnimatedMeshPolygonsOptions, type OptimizeMeshParseResultOptions, type OptimizeMeshPolygonsOptions, PROJECTIVE_QUAD_BLEED, PROJECTIVE_QUAD_DENOM_EPS, PROJECTIVE_QUAD_MAX_WEIGHT_RATIO, type PackedAtlas, type PackedPage, type PackedTextureAtlasEntry, type PackingPage, type PackingShelf, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParseStlColor, type ParseStlSolid, type ParseStlTopology, type ParsedColor, type PlanePolygonsOptions, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyDirectionalLight, type PolyMaterial, type PolyMeshTransformInput, type PolyRenderStrategiesOption, type PolyRenderStrategy, type PolySceneTransformInput, type PolySeamBleed, type PolySeamBleedEdgeValue, type PolySeamBleedEdges, type PolyTextureAlphaMode, type PolyTextureLightingMode, type PolyTextureWrap, type PolyTextureWrapMode, type PolyVoxelCell, type PolyVoxelSource, type Polygon, type PolygonBasisInfo, type PolygonFace, type ProjectiveQuadCoefficients, type ProjectiveQuadGuardGlobal, type ProjectiveQuadGuardOverrides, type ProjectiveQuadGuardSettings, QUAT_IDENTITY, type Quat, RECEIVER_NORMAL_TOL, RECEIVER_OFFSET_TOL, RECEIVER_OUTLINE_EXPAND, RECT_EPS, type RGB, type RGBFactors, type ReceiverCasterInput, type ReceiverFacePlane, type ReceiverPlaneGroup, type ReceiverShadowFaceSpec, type ReceiverShadowPath, type RectBrush, type RingPolygonsOptions, type RingQuadPolygonsOptions, SEAM_LIGHT_EPS, SOLID_QUAD_CANONICAL_SIZE, SOLID_TRIANGLE_BLEED, SOLID_TRIANGLE_CANONICAL_SIZE, SOLID_TRIANGLE_LARGE_BORDER_CANONICAL_SIZE, SURFACE_DISTANCE_EPS, SURFACE_NORMAL_EPS, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type ScreenToWorldOptions, type SeamBleedInsets, type SeamFacetSplitCandidate, type SeamFacetSplitCandidateReason, type SeamFacetSplitOptions, type SeamFacetSplitReport, type SeamOverlapCandidate, type SeamOverlapCandidateKind, type SeamOverlapDiagnostics, type SeamOverlapOptions, type SimplifyTriangleMeshPolygonsOptions, type SolidPaintDefaults, type SolidTextureSampleOptions, type SolidTriangleBasis, type SolidTriangleColorPlan, type SolidTriangleComputeOptions, type SolidTriangleFrame, type SolidTrianglePlan, type SolidTrianglePlanOptions, type SolidTrianglePrimitive, type SpherePolygonsOptions, type StablePlanBasis, type StableTriangleColorState, type StlParseOptions, TEXTURE_EDGE_REPAIR_ALPHA_MIN, TEXTURE_EDGE_REPAIR_RADIUS, TEXTURE_EDGE_REPAIR_SOURCE_ALPHA_MIN, TEXTURE_TRIANGLE_BLEED, type TetrahedronPolygonsOptions, type TextureAtlasPage, type TextureAtlasPlan, type TexturePaintMetrics, type TexturePaintMetricsOptions, type TextureQuality, type TextureTriangle, type TextureTrianglePlan, type TorusPolygonsOptions, type UvAffine, type UvSampleRect, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, type Vec2, type Vec3, type VoxParseOptions, applyPackedAtlasCanonicalSize, arrowPolygons, atlasArea, atlasBitmapMaxSide, atlasCanonicalSizeForEntry, atlasCanonicalSizeForTextureQuality, atlasDecodedBytes, atlasPadding, autoAtlasBudgetFactor, autoAtlasMaxDecodedBytes, autoAtlasScale, autoAtlasScaleCap, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, basisAxisKey, borderShapeBoundsFromPoints, borderShapeGeometryForPlan, boxPolygons, buildBakedShadowProjectionMatrix, buildBasisHints, buildEdgeOwners, buildPolyMeshTransform, buildPolySceneTransform, buildSceneContext, buildSeamBleedPolygonEdges, buildSeamBleedPolygonSet, buildSharedEdgeMap, buildTextureEdgeRepairSets, cachedParsePureColor, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, chooseIslandXAxis, chooseLocalBasis, clampChannel, classifyFacing, clipPolygonToConvex2D, colorErrorScore, compatibleBleedSurface, compatibleSurface, computeLightVisibility, computePlanSeamBleedEdgeAmounts, computeProjectiveQuadCoefficients, computeProjectiveQuadMatrix, computeReceiverShadowFaces, computeSceneBbox, computeSeamBleedInsets, computeShapeLighting, computeSolidTriangleColorPlan, computeSolidTriangleColorPlanFromNormal, computeSolidTrianglePlan, computeSolidTrianglePlanFromCssPoints, computeSurfaceNormal, computeTextureAtlasPlan, computeTextureAtlasPlanPublic, computeTexturePaintMetrics, computeUvAffine, computeUvSampleRect, conePolygons, convexHull2D, cornerShapeDiagonal, cornerShapeGeometryForPlan, cornerShapePointSides, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, crossVec, cssBorderShapeForGeometry, cssBorderShapeForPlan, cssDistanceToWorld, cssPoints, cssPositionToWorld, cullInteriorPolygons, cylinderPolygons, dedupeOverlappingPolygons, dodecahedronPolygons, dominantCountKey, dotVec, ensureCcw2D, eulerXYZFromQuat, evaluateIslandAxis, expandClipPoints, expandConvexHullOutward, extractSilhouetteLoops, filterAtlasPlans, findOverlappingPolygonDuplicates, formatAffineMatrix3dColumns, formatAffineMatrix3dScalars, formatAffineMatrix3dTransformScalars, formatAtlasMatrix, formatBorderShapeElementStyle, formatBorderShapeEntryMatrix, formatBorderShapeMatrix, formatColor, formatCornerShapeElementStyle, formatCssLength, formatCssLengthPx, formatMatrix3d, formatMatrix3dValues, formatPercent, formatScaledMatrixFromPlan, formatSolidQuadEntryMatrix, formatSolidQuadMatrix, fullRectBounds, getPolygonBasisInfo, getSolidPaintDefaultsForPlansCore, groupReceiverFaceGroups, icosahedronPolygons, incrementCount, intersect2DLines, intersect2DLinesRaw, inverseRotateVec3, isAxisAlignedSurfaceNormal, isBakedShadowCaster, isBasisOptimizable, isConvexPolygonPoints, isFullRectBasis, isFullRectSolid, isProjectiveQuadPlan, isSolidTrianglePlan, isVoxelCameraCullableNormalGroups, loadMesh, makeLocalBasis, mergePolygons, meshScaleVec3, normalFacesCamera, normalizeAtlasScale, normalizeInvertMultiplier, normalizePolygons, normalizedSeamBleed, octahedronPolygons, offsetConvexPolygonPoints, offsetConvexPolygonPointsByEdgeAmounts, offsetStableTrianglePoints, offsetTrianglePoints, optimizeAnimatedMeshPolygons, optimizeMeshParseResult, optimizeMeshPolygons, packTextureAtlasPlans, packTextureAtlasPlansWithScaleCore, parseAlpha, parseColor, parseGltf, parseHex, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseStl, parseVox, planePolygons, cssDistanceToWorld as polyCssDistanceToWorld, cssPositionToWorld as polyCssPositionToWorld, polygonContainsPoint, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, polygonSignedArea2D, prepareCasterEdgeOwners, prepareCasterPolyItems, prepareReceiverFacePlanes, projectCssVertexToGround, projectTextureTriangle, quantizeCssColor, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, repairMeshSeams, resolveBleedRatio, resolveProjectiveQuadGuards, resolveSeamBleed, rgbEqual, rgbKey, rgbToCss, rgbToHex, ringPolygons, ringQuadPolygons, rotateVec3, rotateVec3InWrapperCssFrame, roundDecimal, safariCssProjectiveUnsupported, safePlanSeamBleedAmount, screenToWorldOnSphere, screenToWorldRay, seamBleedAmountArray, seamFacetSplitPolygons, seamFacetSplitReport, seamLightBrightness, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, shadePolygon, sharedCornerShapeSide, signedArea2D, simplifyCornerShapePoints, simplifyTriangleMeshPolygons, spherePolygons, stableBasisFromPlan, stableTriangleMatrixDecimals, stepRgbToward, tetrahedronPolygons, textureTintFactors, tintToCss, torusPolygons, worldCssForMesh, worldDirectionToCss, worldDirectionToCss as worldDirectionToPolyCss, worldDirectionalLightToCss, worldDirectionalLightToCss as worldDirectionalLightToPolyCss, worldDistanceToCss, worldDistanceToCss as worldDistanceToPolyCss, worldPositionToCss, worldPositionToCss as worldPositionToPolyCss };
+export { ASYNC_RENDER_BUDGET_MS, ATLAS_CANONICAL_SIZE_AUTO_DESKTOP, ATLAS_CANONICAL_SIZE_EXPLICIT, ATLAS_MAX_SIZE, ATLAS_PADDING, AUTO_ATLAS_LOW_AREA, AUTO_ATLAS_MAX_BITMAP_SIDE, AUTO_ATLAS_MAX_DECODED_BYTES_DESKTOP, AUTO_ATLAS_MAX_DECODED_BYTES_MOBILE, AUTO_ATLAS_MEDIUM_AREA, AUTO_ATLAS_SCALE_GUARD, type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BAKED_SHADOW_MIN_UP, BAKED_SHADOW_Z_SQUASH, BASE_TILE, BASIS_EPS, BORDER_SHAPE_BLEED, BORDER_SHAPE_CANONICAL_SIZE, BORDER_SHAPE_CENTER_PERCENT, BORDER_SHAPE_POINT_EPS, type BasisHint, type BasisOptions, type BorderShapeBounds, type BorderShapeGeometry, type BoxFace, type BoxFaceOptions, type BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, COLOR_PARSE_CACHE_MAX, CORNER_SHAPE_DUPLICATE_EPS, CORNER_SHAPE_POINT_EPS, type CameraCullNormalGroup, type CameraCullRotation, type CameraHandle, type CameraState, type CameraStyleInput, type CasterPolyItem, type ComputeReceiverShadowFacesInput, type ComputeTextureAtlasPlanOptions, type ConePolygonsOptions, type CornerShapeCorner, type CornerShapeGeometry, type CornerShapeRadius, type CornerShapeSide, type CoverPlanarPolygonsOptions, type CullInteriorOptions, type CylinderPolygonsOptions, DECIMAL_SCALES, DEFAULT_AMBIENT_COLOR, DEFAULT_AMBIENT_INTENSITY, DEFAULT_ATLAS_CSS_DECIMALS, DEFAULT_BORDER_SHAPE_DECIMALS, DEFAULT_CAMERA_STATE, DEFAULT_LIGHT_COLOR, DEFAULT_LIGHT_DIR, DEFAULT_LIGHT_INTENSITY, DEFAULT_MATRIX_DECIMALS, DEFAULT_PROJECTION, DEFAULT_SEAM_BLEED, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DEFAULT_TILE, type DedupeOverlappingPolygonsOptions, type DodecahedronPolygonsOptions, type EdgeOwners, type FilterAtlasPlansEnv, type GetSolidPaintDefaultsEnv, type GltfParseOptions, type IcosahedronPolygonsOptions, type InternalSolidTrianglePlanOptions, type LoadMeshOptions, type LocalBasis, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MAX_ATLAS_SCALE, MIN_ATLAS_SCALE, type MergedReceiverShadowInput, type MergedShadowFace, type MergedShadowLayer, type MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeAnimatedMeshPolygonsOptions, type OptimizeMeshParseResultOptions, type OptimizeMeshPolygonsOptions, PROJECTIVE_QUAD_BLEED, PROJECTIVE_QUAD_DENOM_EPS, PROJECTIVE_QUAD_MAX_WEIGHT_RATIO, type PackedAtlas, type PackedPage, type PackedTextureAtlasEntry, type PackingPage, type PackingShelf, type ParametricOverrideInput, type ParametricOverrideResult, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParseStlColor, type ParseStlSolid, type ParseStlTopology, type ParsedColor, type PlanePolygonsOptions, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyCameraProjection, type PolyCameraSceneTransformOptions, type PolyCameraSnapshot, type PolyCameraSnapshotOptions, type PolyCameraSnapshotSource, type PolyDirectionalLight, type PolyMaterial, type PolyMeshTransformInput, type PolyPointLight, type PolyRenderStrategiesOption, type PolyRenderStrategy, type PolySceneTransformInput, type PolySeamBleed, type PolySeamBleedEdgeValue, type PolySeamBleedEdges, type PolyTextureAlphaMode, type PolyTextureBackend, type PolyTextureImageLighting, type PolyTextureImageRendering, type PolyTextureImageSource, type PolyTextureLeafGeometry, type PolyTextureLeafResolverOptions, type PolyTextureLeafSizing, type PolyTextureLeafSourceRect, type PolyTextureLightingMode, type PolyTexturePresentation, type PolyTextureProjection, type PolyTextureWrap, type PolyTextureWrapMode, type PolyVoxelCell, type PolyVoxelSource, type Polygon, type PolygonBasisInfo, type PolygonFace, type ProjectiveQuadCoefficients, type ProjectiveQuadGuardGlobal, type ProjectiveQuadGuardOverrides, type ProjectiveQuadGuardSettings, QUAT_IDENTITY, type Quat, RECEIVER_NORMAL_TOL, RECEIVER_OFFSET_TOL, RECEIVER_OUTLINE_EXPAND, RECT_EPS, type RGB, type RGBFactors, type ReceiverCasterInput, type ReceiverFacePlane, type ReceiverPlaneGroup, type ReceiverShadowFaceSpec, type ReceiverShadowPath, type RectBrush, type RingPolygonsOptions, type RingQuadPolygonsOptions, SEAM_LIGHT_EPS, SOLID_QUAD_CANONICAL_SIZE, SOLID_TRIANGLE_BLEED, SOLID_TRIANGLE_CANONICAL_SIZE, SOLID_TRIANGLE_LARGE_BORDER_CANONICAL_SIZE, SURFACE_DISTANCE_EPS, SURFACE_NORMAL_EPS, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type ScreenToWorldOptions, type SeamBleedInsets, type SeamFacetSplitCandidate, type SeamFacetSplitCandidateReason, type SeamFacetSplitOptions, type SeamFacetSplitReport, type SeamOverlapCandidate, type SeamOverlapCandidateKind, type SeamOverlapDiagnostics, type SeamOverlapOptions, type SimplifyTriangleMeshPolygonsOptions, type SolidPaintDefaults, type SolidTextureSampleOptions, type SolidTriangleBasis, type SolidTriangleColorPlan, type SolidTriangleComputeOptions, type SolidTriangleFrame, type SolidTrianglePlan, type SolidTrianglePlanOptions, type SolidTrianglePrimitive, type SpherePolygonsOptions, type StablePlanBasis, type StableTriangleColorState, type StlParseOptions, TEXTURE_EDGE_REPAIR_ALPHA_MIN, TEXTURE_EDGE_REPAIR_RADIUS, TEXTURE_EDGE_REPAIR_SOURCE_ALPHA_MIN, TEXTURE_TRIANGLE_BLEED, type TetrahedronPolygonsOptions, type TextureAtlasPage, type TextureAtlasPlan, type TexturePaintMetrics, type TexturePaintMetricsOptions, type TextureQuality, type TextureTriangle, type TextureTrianglePlan, type TorusPolygonsOptions, type UvAffine, type UvSampleRect, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, type Vec2, type Vec3, type VoxParseOptions, applyPackedAtlasCanonicalSize, applyPackedAtlasLeafSizing, arrowPolygons, atlasArea, atlasBitmapMaxSide, atlasCanonicalSizeForEntry, atlasCanonicalSizeForTextureQuality, atlasDecodedBytes, atlasPadding, autoAtlasBudgetFactor, autoAtlasMaxDecodedBytes, autoAtlasScale, autoAtlasScaleCap, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, basisAxisKey, borderShapeBoundsFromPoints, borderShapeGeometryForPlan, boxPolygons, buildBakedShadowProjectionMatrix, buildBasisHints, buildEdgeOwners, buildParametricCasterOverride, buildPolyCameraSceneTransform, buildPolyMeshTransform, buildPolySceneTransform, buildSceneContext, buildSeamBleedPolygonEdges, buildSeamBleedPolygonSet, buildSharedEdgeMap, buildTextureEdgeRepairSets, cachedParsePureColor, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, capturePolyCameraSnapshot, chooseIslandXAxis, chooseLocalBasis, clampChannel, classifyFacing, clipPolygonToConvex2D, colorErrorScore, compatibleBleedSurface, compatibleSurface, computeCoverageShadowSilhouette, computeLightVisibility, computeMergedReceiverShadows, computeParametricShadowSilhouette, computePlanSeamBleedEdgeAmounts, computeProjectiveQuadCoefficients, computeProjectiveQuadMatrix, computeReceiverShadowFaces, computeSceneBbox, computeSeamBleedInsets, computeShapeLighting, computeSolidTriangleColorPlan, computeSolidTriangleColorPlanFromNormal, computeSolidTrianglePlan, computeSolidTrianglePlanFromCssPoints, computeSurfaceNormal, computeTextureAtlasPlan, computeTextureAtlasPlanPublic, computeTexturePaintMetrics, computeUvAffine, computeUvSampleRect, conePolygons, convexHull2D, cornerShapeDiagonal, cornerShapeGeometryForPlan, cornerShapePointSides, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, crossVec, cssBorderShapeForGeometry, cssBorderShapeForPlan, cssDistanceToWorld, cssPoints, cssPositionToWorld, cullInteriorPolygons, cylinderPolygons, dedupeOverlappingPolygons, dodecahedronPolygons, dominantCountKey, dotVec, ensureCcw2D, eulerXYZFromQuat, evaluateIslandAxis, expandClipPoints, expandConvexHullOutward, extractSilhouetteLoops, filterAtlasPlans, findOverlappingPolygonDuplicates, formatAffineMatrix3dColumns, formatAffineMatrix3dScalars, formatAffineMatrix3dTransformScalars, formatAtlasMatrix, formatBorderShapeElementStyle, formatBorderShapeEntryMatrix, formatBorderShapeMatrix, formatColor, formatCornerShapeElementStyle, formatCssLength, formatCssLengthPx, formatMatrix3d, formatMatrix3dValues, formatPercent, formatScaledMatrixFromPlan, formatSolidQuadEntryMatrix, formatSolidQuadMatrix, fullRectBounds, getPolygonBasisInfo, getSolidPaintDefaultsForPlansCore, groupReceiverFaceGroups, icosahedronPolygons, incrementCount, intersect2DLines, intersect2DLinesRaw, inverseRotateVec3, isAxisAlignedSurfaceNormal, isBakedShadowCaster, isBasisOptimizable, isConvexCaster, isConvexPolygonPoints, isFlatCaster, isFullRectBasis, isFullRectSolid, isPointShadowCaster, isProjectiveQuadPlan, isSolidTrianglePlan, isVoxelCameraCullableNormalGroups, loadMesh, makeLocalBasis, mergePolygons, meshScaleVec3, normalFacesCamera, normalizeAtlasScale, normalizeInvertMultiplier, normalizePolygons, normalizedSeamBleed, octahedronPolygons, offsetConvexPolygonPoints, offsetConvexPolygonPointsByEdgeAmounts, offsetStableTrianglePoints, offsetTrianglePoints, optimizeAnimatedMeshPolygons, optimizeMeshParseResult, optimizeMeshPolygons, packTextureAtlasPlans, packTextureAtlasPlansWithScaleCore, parseAlpha, parseColor, parseGltf, parseHex, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseStl, parseVox, planePolygons, polyCameraTargetToCss, polyCssDistanceToWorld, polyCssPositionToWorld, polygonContainsPoint, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, polygonSignedArea2D, prepareCasterEdgeOwners, prepareCasterPolyItems, prepareReceiverFacePlanes, projectCssVertexToGround, projectCssVertexToGroundFromPoint, projectTextureTriangle, quantizeCssColor, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, repairMeshSeams, resolveAtlasLeafBox, resolveBleedRatio, resolvePolyCameraAppliedPerspectiveStyle, resolvePolyTextureImageRendering, resolvePolyTextureImageSource, resolvePolyTextureLeafGeometry, resolvePolyTexturePresentation, resolvePolyTextureUrl, resolveProjectiveQuadGuards, resolveSeamBleed, rgbEqual, rgbKey, rgbToCss, rgbToHex, ringPolygons, ringQuadPolygons, rotateVec3, rotateVec3InWrapperCssFrame, roundDecimal, safariCssProjectiveUnsupported, safePlanSeamBleedAmount, screenToWorldOnSphere, screenToWorldRay, seamBleedAmountArray, seamFacetSplitPolygons, seamFacetSplitReport, seamLightBrightness, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, shadePolygon, sharedCornerShapeSide, signedArea2D, simplifyCornerShapePoints, simplifyTriangleMeshPolygons, spherePolygons, stableBasisFromPlan, stableTriangleMatrixDecimals, stepRgbToward, tetrahedronPolygons, textureTintFactors, tintToCss, torusPolygons, worldCssForMesh, worldDirectionToCss, worldDirectionToPolyCss, worldDirectionalLightToCss, worldDirectionalLightToPolyCss, worldDistanceToCss, worldDistanceToPolyCss, worldPositionToCss, worldPositionToPolyCss };