@layoutit/polycss-vue 0.0.1 → 0.2.1

package/dist/index.d.ts

@@ -1,20 +1,18 @@
 import * as vue from 'vue';
 import { PropType, Ref, InjectionKey, VNode, ComputedRef, MaybeRef } from 'vue';
-import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, LoadMeshOptions, PolyMaterial, Vec2, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
-export { ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, Vec2, Vec3, 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 } from '@layoutit/polycss-core';
+import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolySeamBleed, PolyRenderStrategiesOption, MeshResolution, LoadMeshOptions, ParseResult, PolyMaterial, Vec2, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
+export { ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, BoxFace, BoxFaceOptions, BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, ConePolygonsOptions, CoverPlanarPolygonsOptions, CullInteriorOptions, CylinderPolygonsOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DodecahedronPolygonsOptions, GltfParseOptions, IcosahedronPolygonsOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MeshResolution, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeAnimatedMeshPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PlanePolygonsOptions, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyRenderStrategiesOption, PolyRenderStrategy, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SeamFacetSplitCandidate, SeamFacetSplitCandidateReason, SeamFacetSplitOptions, SeamFacetSplitReport, SeamOverlapCandidate, SeamOverlapCandidateKind, SeamOverlapDiagnostics, SeamOverlapOptions, SolidTextureSampleOptions, TetrahedronPolygonsOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, TorusPolygonsOptions, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, conePolygons, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, cylinderPolygons, dodecahedronPolygons, formatColor, icosahedronPolygons, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeAnimatedMeshPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, tetrahedronPolygons, torusPolygons } from '@layoutit/polycss-core';
 
-interface PolyPerspectiveCameraProps {
+interface PolyOrthographicCameraProps {
     zoom?: number;
     target?: Vec3;
     rotX?: number;
     rotY?: number;
     /** Camera pull-back in CSS pixels (dolly). Default 0. */
     distance?: number;
-    /** CSS perspective distance in pixels. Defaults to 8000. */
-    perspective?: number;
     class?: string;
 }
-declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     zoom: {
         type: NumberConstructor;
     };
@@ -30,10 +28,6 @@ declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
-    perspective: {
-        type: NumberConstructor;
-        default: undefined;
-    };
     class: {
         type: StringConstructor;
     };
@@ -55,27 +49,23 @@ declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
-    perspective: {
-        type: NumberConstructor;
-        default: undefined;
-    };
     class: {
         type: StringConstructor;
     };
-}>> & Readonly<{}>, {
-    perspective: number;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface PolyOrthographicCameraProps {
+interface PolyPerspectiveCameraProps {
     zoom?: number;
     target?: Vec3;
     rotX?: number;
     rotY?: number;
     /** Camera pull-back in CSS pixels (dolly). Default 0. */
     distance?: number;
+    /** CSS perspective distance in pixels. Defaults to 8000. */
+    perspective?: number;
     class?: string;
 }
-declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     zoom: {
         type: NumberConstructor;
     };
@@ -91,6 +81,10 @@ declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -112,13 +106,19 @@ declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {
+    perspective: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 /**
- * Lightweight reactive store for polycss scene state.
+ * Lightweight reactive store for PolyCSS scene state.
  * Components subscribe to specific slices via selectors,
  * so only the components that care about a changed value re-render.
  */
@@ -154,6 +154,12 @@ interface UseCameraResult {
      * versions and can't preventDefault).
      */
     cameraElRef: Ref<HTMLDivElement | null>;
+    /**
+     * Bbox-center of all centerable meshes in world coords. Written by
+     * <PolyScene> when autoCenter is enabled. Read by applyTransformDirect
+     * to fold the offset into the scene transform without a DOM wrapper.
+     */
+    autoCenterOffset: Ref<Vec3>;
     /**
      * Apply the current camera state (from cameraRef.value.state) directly
      * to sceneEl.style.transform. Exposed so layered components like
@@ -172,6 +178,14 @@ interface PolyCameraContextValue {
      * <PolyControls> can attach pointer/wheel listeners.
      */
     cameraElRef: Ref<HTMLElement | null>;
+    /**
+     * Bbox-center of all centerable meshes in world coords, written by
+     * <PolyScene> when `autoCenter` is enabled. `applyTransformDirect`
+     * folds this into the innermost translate3d alongside `target` so the
+     * camera orbits the model's visible center without adding a DOM wrapper.
+     * Kept separate from `target` so user pan survives mesh add/remove.
+     */
+    autoCenterOffset: Ref<Vec3>;
     /**
      * Apply the current camera state (from cameraRef.value.state) directly
      * to sceneEl.style.transform. Layered components call this after
@@ -181,7 +195,26 @@ interface PolyCameraContextValue {
 }
 declare const PolyCameraContextKey: InjectionKey<PolyCameraContextValue>;
 
-type AtlasScale = number | "auto";
+/**
+ * PolySceneContext — propagates scene-level rendering options
+ * (textureLighting + lights) to descendants. PolyMesh / Poly children
+ * inherit these as fallbacks when their own equivalent props are
+ * undefined, so a helper rendered inside `<PolyScene texture-lighting="dynamic">`
+ * picks up the dynamic mode automatically (per-polygon normal vars + mask).
+ */
+
+interface PolyShadowOptions {
+    color?: string;
+    opacity?: number;
+    lift?: number;
+    /**
+     * Maximum CSS pixels the shadow may extend beyond the mesh's
+     * footprint. Caps the SVG backing store at low light elevations to
+     * prevent repaint flicker. Default: `2000`. Pass `Infinity` to
+     * disable the cap entirely.
+     */
+    maxExtend?: number;
+}
 
 interface PolySceneProps {
     polygons?: Polygon[];
@@ -192,8 +225,15 @@ interface PolySceneProps {
     directionalLight?: PolyDirectionalLight;
     ambientLight?: PolyAmbientLight;
     textureLighting?: PolyTextureLightingMode;
-    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
-    atlasScale?: AtlasScale;
+    /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
+     *  device-appropriate memory budget (~4 MB mobile / ~16 MB desktop) and
+     *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
+     *  raster scale and the 64px sprite. */
+    textureQuality?: TextureQuality;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
+    /** Opt out of specific render strategies. Disabled strategies fall through the chain (b→i→s, u→i→s, i→s). `<s>` cannot be disabled. */
+    strategies?: PolyRenderStrategiesOption;
     /**
      * When `true`, rotation pivots around the mesh's bbox center instead of
      * world (0,0,0). Polygon data is not mutated — a wrapper div translates
@@ -201,6 +241,14 @@ interface PolySceneProps {
      * Mirrors React's PolyScene autoCenter prop.
      */
     autoCenter?: boolean;
+    /**
+     * Shadow appearance for meshes with `castShadow: true`. Works in both
+     * lighting modes — dynamic mode projects via CSS vars so shadows
+     * follow a moving light, baked mode CPU-bakes the projection into
+     * each leaf's inline `matrix3d` and drops back-facing polys from the
+     * DOM entirely. Defaults: `{ color: "#000000", opacity: 0.25, lift: 0.05, maxExtend: 2000 }`.
+     */
+    shadow?: PolyShadowOptions;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -237,14 +285,26 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: string;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
+        default: undefined;
+    };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
+    strategies: {
+        type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
     };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
+    shadow: {
+        type: PropType<PolyShadowOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -297,14 +357,26 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: string;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
+        default: undefined;
+    };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
+    strategies: {
+        type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
     };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
+    shadow: {
+        type: PropType<PolyShadowOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -331,10 +403,13 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
-    atlasScale: AtlasScale;
     polygons: Polygon[];
     ambientLight: PolyAmbientLight;
+    textureQuality: TextureQuality;
+    seamBleed: PolySeamBleed;
+    strategies: PolyRenderStrategiesOption;
     autoCenter: boolean;
+    shadow: PolyShadowOptions;
     rotation: Vec3;
     debugShowLabels: boolean;
     debugShowBackfaces: boolean;
@@ -343,7 +418,7 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
 /**
  * Pointer event API for `<PolyMesh>` (Vue). Mirrors @react-three/fiber's
  * mesh event surface (handler names + payload shape) so devs migrating
- * from three.js use the same mental model. polycss is DOM-native so
+ * from three.js use the same mental model. PolyCSS is DOM-native so
  * we get native pointer events for free — no raycaster, no canvas
  * event synthesis.
  *
@@ -365,6 +440,21 @@ interface PolyMeshHandle {
     getRotation(): Vec3 | undefined;
     getScale(): number | Vec3 | undefined;
     getPolygons(): Polygon[];
+    /**
+     * Replace the mesh polygons imperatively. Animated solid-triangle meshes use
+     * a stable DOM update path that mutates mounted leaves directly; unsupported
+     * topology falls back to the normal framework render path.
+     */
+    setPolygons(polygons: Polygon[]): void;
+    /**
+     * Update a single polygon in place. `target` is either a polygon
+     * reference (as returned by `getPolygons()`) or its index. `partial`
+     * fields are merged onto the polygon; the mesh is then re-rendered.
+     * Skips the merge pass, so this is cheaper than replacing the
+     * `polygons` prop for targeted edits like color picker updates from
+     * an inspector UI. Silently no-ops if `target` isn't found.
+     */
+    updatePolygon(target: Polygon | number, partial: Partial<Polygon>): void;
     /**
      * Re-rasterize the baked texture atlas using the mesh's current rotation.
      *
@@ -436,8 +526,24 @@ interface PolyMeshProps extends InteractionProps {
     polygons?: Polygon[];
     autoCenter?: boolean;
     textureLighting?: PolyTextureLightingMode;
-    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
-    atlasScale?: AtlasScale;
+    /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
+     *  device-appropriate memory budget (~4 MB mobile / ~16 MB desktop) and
+     *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
+     *  raster scale and the 64px sprite. */
+    textureQuality?: TextureQuality;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
+    /**
+     * When `true` and the scene is in dynamic lighting mode, the renderer emits
+     * a flat shadow leaf sibling for each non-duplicate polygon. The shadow is
+     * projected onto the ground plane along the CSS-space light direction.
+     * Defaults to `false`.
+     */
+    castShadow?: boolean;
+    /** Mesh optimization intent. Defaults to "lossy"; set "lossless" to keep
+     *  authored surface fidelity. Top-level prop wins over any meshResolution
+     *  that might be set inside parseOptions. */
+    meshResolution?: MeshResolution;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -468,8 +574,20 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
+        default: undefined;
+    };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
+    castShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    meshResolution: {
+        type: PropType<MeshResolution>;
         default: undefined;
     };
     class: {
@@ -562,8 +680,20 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
+        default: undefined;
+    };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
+    castShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    meshResolution: {
+        type: PropType<MeshResolution>;
         default: undefined;
     };
     class: {
@@ -635,13 +765,16 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
-    atlasScale: AtlasScale;
     polygons: Polygon[];
+    textureQuality: TextureQuality;
+    seamBleed: PolySeamBleed;
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
     src: string;
     mtl: string;
+    castShadow: boolean;
+    meshResolution: MeshResolution;
     onContextMenu: PolyEventHandler<MouseEvent>;
     onDoubleClick: PolyEventHandler<MouseEvent>;
     onPointerDown: PolyEventHandler<PointerEvent>;
@@ -654,6 +787,70 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     onPointerCancel: PolyEventHandler<PointerEvent>;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+interface PolyGroundProps {
+    /** Side length of the ground quad in world units. Default `6`. */
+    size?: number;
+    /** World-space Z (floor height). Default `0`. */
+    z?: number;
+    /** World-space XY center. Default `[0, 0]`. */
+    center?: [number, number];
+    /** Fill color. Default `#7d848e` — medium gray, chosen so 25% black `<q>`
+     *  shadow leaves on top have visible contrast against it. */
+    color?: string;
+    class?: string;
+}
+declare const PolyGround: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    z: {
+        type: NumberConstructor;
+        default: number;
+    };
+    center: {
+        type: PropType<[number, number]>;
+        default: () => number[];
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    z: {
+        type: NumberConstructor;
+        default: number;
+    };
+    center: {
+        type: PropType<[number, number]>;
+        default: () => number[];
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    color: string;
+    size: number;
+    center: [number, number];
+    z: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
 interface UseSceneContextOptions {
     directionalLight?: PolyDirectionalLight;
 }
@@ -665,7 +862,7 @@ interface UseSceneContextResult {
     };
 }
 /**
- * Vue 3 composable that runs the polycss scene-context pipeline:
+ * Vue 3 composable that runs the PolyCSS scene-context pipeline:
  *   normalizePolygons → mergePolygons by default → bbox compute.
  *
  * Returns a Ref to the processed polygons + the scene-wide axis-aligned bbox.
@@ -676,6 +873,7 @@ declare function usePolySceneContext(polygons: Ref<Polygon[]>, options: Ref<UseS
 type UseMeshOptions = LoadMeshOptions;
 interface UseMeshResult {
     polygons: Ref<Polygon[]>;
+    voxelSource: Ref<ParseResult["voxelSource"]>;
     loading: Ref<boolean>;
     error: Ref<Error | null>;
     warnings: Ref<string[]>;
@@ -705,7 +903,7 @@ interface PolyContext {
     layerElevation?: number;
     directionalLight?: PolyDirectionalLight;
     textureLighting?: PolyTextureLightingMode;
-    atlasScale?: AtlasScale;
+    textureQuality?: TextureQuality;
     debugShowBackfaces?: boolean;
     [key: string]: unknown;
 }
@@ -724,8 +922,9 @@ interface PolyProps {
     rotation?: Vec3;
     context?: PolyContext;
     textureLighting?: PolyTextureLightingMode;
-    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
-    atlasScale?: AtlasScale;
+    /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
+     *  device-appropriate memory budget and desktop/mobile sprite sizing. */
+    textureQuality?: TextureQuality;
     baseColor?: string;
     pointerEvents?: "auto" | "none";
 }
@@ -768,8 +967,8 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
         default: undefined;
     };
     context: {
@@ -824,8 +1023,8 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
         default: undefined;
     };
     context: {
@@ -842,120 +1041,1046 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{}>, {
     data: Record<string, string | number | boolean>;
     pointerEvents: "none" | "auto";
-    uvs: Vec2[];
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
-    atlasScale: AtlasScale;
+    textureQuality: TextureQuality;
     rotation: Vec3;
     material: PolyMaterial;
+    uvs: Vec2[];
     context: PolyContext;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface PolyControlsAnimateOptions {
-    speed?: number;
-    axis?: "x" | "y";
-    pauseOnInteraction?: boolean;
-}
-interface PolyOrbitControlsCamera {
-    rotX: number;
-    rotY: number;
-    zoom: number;
-    target: Vec3;
-    distance: number;
-}
-interface PolyOrbitControlsProps {
-    drag?: boolean;
-    wheel?: boolean;
-    /** When true, wheel changes camera pull-back (distance) instead of zoom scale. */
-    dolly?: boolean;
-    invert?: boolean | number;
-    /** Minimum zoom multiplier (zoom mode). Default 0.1. */
-    minZoom?: number;
-    /** Maximum zoom multiplier (zoom mode). Default 10. */
-    maxZoom?: number;
-    /** Minimum camera pull-back in CSS pixels when dolly=true. Default 0. */
-    minDistance?: number;
-    /** Maximum camera pull-back in CSS pixels when dolly=true. Default 5000. */
-    maxDistance?: number;
-    animate?: false | PolyControlsAnimateOptions;
-}
-declare const PolyOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
-    drag: {
-        type: BooleanConstructor;
-        default: boolean;
+declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<number | Vec3>;
+        default: undefined;
     };
-    wheel: {
-        type: BooleanConstructor;
-        default: boolean;
+    center: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    dolly: {
-        type: BooleanConstructor;
-        default: boolean;
+    min: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    invert: {
-        type: PropType<boolean | number>;
-        default: boolean;
+    max: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    minZoom: {
-        type: NumberConstructor;
-        default: number;
+    color: {
+        type: StringConstructor;
+        default: undefined;
     };
-    maxZoom: {
-        type: NumberConstructor;
-        default: number;
+    texture: {
+        type: StringConstructor;
+        default: undefined;
     };
-    minDistance: {
-        type: NumberConstructor;
-        default: number;
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    maxDistance: {
-        type: NumberConstructor;
-        default: number;
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
     };
-    animate: {
-        type: PropType<false | PolyControlsAnimateOptions>;
-        default: boolean;
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    change: (_camera: PolyOrbitControlsCamera) => true;
-    "interaction-start": (_camera: PolyOrbitControlsCamera) => true;
-    "interaction-end": (_camera: PolyOrbitControlsCamera) => true;
-}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    drag: {
+    autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
-    wheel: {
-        type: BooleanConstructor;
-        default: boolean;
+    id: {
+        type: StringConstructor;
+        default: undefined;
     };
-    dolly: {
-        type: BooleanConstructor;
-        default: boolean;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<number | Vec3>;
+        default: undefined;
     };
-    invert: {
-        type: PropType<boolean | number>;
-        default: boolean;
+    center: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    minZoom: {
-        type: NumberConstructor;
-        default: number;
+    min: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    maxZoom: {
-        type: NumberConstructor;
-        default: number;
+    max: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    minDistance: {
-        type: NumberConstructor;
-        default: number;
+    color: {
+        type: StringConstructor;
+        default: undefined;
     };
-    maxDistance: {
-        type: NumberConstructor;
-        default: number;
+    texture: {
+        type: StringConstructor;
+        default: undefined;
     };
-    animate: {
-        type: PropType<false | PolyControlsAnimateOptions>;
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number | Vec3;
+    center: Vec3;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    texture: string;
+    id: string;
+    min: Vec3;
+    max: Vec3;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    along: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    along: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    along: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyRing: vue.DefineComponent<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    radius: {
+        type: NumberConstructor;
+        required: true;
+    };
+    halfThickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    segments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    radius: {
+        type: NumberConstructor;
+        required: true;
+    };
+    halfThickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    segments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    halfThickness: number;
+    segments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyOctahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    center: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    center: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyTetrahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyIcosahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyDodecahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolySphere: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    subdivisions: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    subdivisions: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    subdivisions: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyCylinder: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radiusTop: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radiusTop: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    height: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radiusTop: number;
+    radialSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyCone: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    height: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radialSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyTorus: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tube: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tubularSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tube: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tubularSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radialSegments: number;
+    tube: number;
+    tubularSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyControlsAnimateOptions {
+    speed?: number;
+    axis?: "x" | "y";
+    pauseOnInteraction?: boolean;
+}
+interface PolyOrbitControlsCamera {
+    rotX: number;
+    rotY: number;
+    zoom: number;
+    target: Vec3;
+    distance: number;
+}
+interface PolyOrbitControlsProps {
+    drag?: boolean;
+    wheel?: boolean;
+    /** When true, wheel changes camera pull-back (distance) instead of zoom scale. */
+    dolly?: boolean;
+    invert?: boolean | number;
+    /** Minimum zoom multiplier (zoom mode). Default 0.1. */
+    minZoom?: number;
+    /** Maximum zoom multiplier (zoom mode). Default 10. */
+    maxZoom?: number;
+    /** Minimum camera pull-back in CSS pixels when dolly=true. Default 0. */
+    minDistance?: number;
+    /** Maximum camera pull-back in CSS pixels when dolly=true. Default 5000. */
+    maxDistance?: number;
+    animate?: false | PolyControlsAnimateOptions;
+}
+declare const PolyOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_camera: PolyOrbitControlsCamera) => true;
+    "interaction-start": (_camera: PolyOrbitControlsCamera) => true;
+    "interaction-end": (_camera: PolyOrbitControlsCamera) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
         default: boolean;
     };
 }>> & Readonly<{
@@ -1215,8 +2340,8 @@ declare const PolyTransformControls: vue.DefineComponent<vue.ExtractPropTypes<{
 }>, {
     object: PolyTransformControlsObject;
     mode: "rotate" | "translate";
-    space: "local" | "world";
     size: number;
+    space: "local" | "world";
     enabled: boolean;
     showX: boolean;
     showY: boolean;
@@ -1225,6 +2350,211 @@ declare const PolyTransformControls: vue.DefineComponent<vue.ExtractPropTypes<{
     rotationSnap: number | null;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+interface PolyFirstPersonControlsOptions {
+    /** Master switch. When `false`, all sub-controls are inert. Default: `true`. */
+    enabled?: boolean;
+    /** Pointer-lock mouselook (rotX = pitch, rotY = yaw). Default: `true`. */
+    lookEnabled?: boolean;
+    /** WASD / arrow-key planar movement on world XY. Default: `true`. */
+    moveEnabled?: boolean;
+    /** Space-bar parametric jump arc on world Z. Default: `true`. */
+    jumpEnabled?: boolean;
+    /** Ctrl crouch (lowers eye height while held). Default: `true`. */
+    crouchEnabled?: boolean;
+    /** Mouselook sensitivity in degrees per pixel. Default: `0.15`. */
+    lookSensitivity?: number;
+    /** Invert vertical mouselook. Default: `false`. */
+    invertY?: boolean;
+    /** Movement speed in world units per second. Default: `5`. */
+    moveSpeed?: number;
+    /** Initial vertical velocity for a jump, world units per second. Default: `7`. */
+    jumpVelocity?: number;
+    /** Gravity acceleration in world units per second squared. Default: `18`. */
+    gravity?: number;
+    /** Standing eye height above the ground plane. Default: `1.7`. */
+    eyeHeight?: number;
+    /** Eye height while crouching. Default: `1`. */
+    crouchHeight?: number;
+    /** World Z of the ground plane the player walks on. Default: `0`. */
+    groundZ?: number;
+    /** Min pitch (rotX) angle in degrees. Default: `5`. */
+    minPitch?: number;
+    /** Max pitch (rotX) angle in degrees. Default: `175`. */
+    maxPitch?: number;
+}
+interface PolyFirstPersonControlsHandle {
+    update(partial: PolyFirstPersonControlsOptions): void;
+    resume(): void;
+    pause(): void;
+    destroy(): void;
+    /** Request pointer-lock now. Call from a user gesture (click). */
+    lock(): void;
+    /** Release pointer-lock. */
+    unlock(): void;
+    /** Whether pointer-lock is currently held. */
+    isLocked(): boolean;
+    /**
+     * The camera's WORLD position (the eye). Snapshot — mutate via WASD /
+     * jump / crouch, or by calling `setOrigin`.
+     */
+    getOrigin(): [number, number, number];
+    /**
+     * Move the camera origin to a specific world position. Re-derives the
+     * scene's target so the perspective viewer follows.
+     */
+    setOrigin(origin: [number, number, number]): void;
+    addEventListener(type: "change" | "start" | "end", listener: () => void): void;
+    removeEventListener(type: "change" | "start" | "end", listener: () => void): void;
+    hasEventListener(type: "change" | "start" | "end", listener: () => void): boolean;
+}
+declare const PolyFirstPersonControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lookEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    jumpEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    crouchEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lookSensitivity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    invertY: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveSpeed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    jumpVelocity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gravity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    eyeHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    crouchHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    groundZ: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minPitch: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxPitch: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_origin: [number, number, number]) => true;
+    "interaction-start": (_origin: [number, number, number]) => true;
+    "interaction-end": (_origin: [number, number, number]) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lookEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    jumpEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    crouchEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lookSensitivity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    invertY: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveSpeed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    jumpVelocity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gravity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    eyeHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    crouchHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    groundZ: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minPitch: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxPitch: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onChange?: ((_origin: [number, number, number]) => any) | undefined;
+    "onInteraction-start"?: ((_origin: [number, number, number]) => any) | undefined;
+    "onInteraction-end"?: ((_origin: [number, number, number]) => any) | undefined;
+}>, {
+    enabled: boolean;
+    lookEnabled: boolean;
+    moveEnabled: boolean;
+    jumpEnabled: boolean;
+    crouchEnabled: boolean;
+    lookSensitivity: number;
+    invertY: boolean;
+    moveSpeed: number;
+    jumpVelocity: number;
+    gravity: number;
+    eyeHeight: number;
+    crouchHeight: number;
+    groundZ: number;
+    minPitch: number;
+    maxPitch: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
 interface PolySelectProps {
     multiple?: boolean;
     clearOnMiss?: boolean;
@@ -1419,6 +2749,29 @@ declare const PolyDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTyp
 
 declare function injectPolyBaseStyles(doc?: Document): void;
 
+interface PolyRenderSurfaceLeafCounts {
+    quad: number;
+    clippedSolid: number;
+    atlas: number;
+    stableTriangle: number;
+}
+interface PolyRenderStats {
+    polygonCount: number;
+    mountedPolygonLeafCount: number;
+    shadowLeafCount: number;
+    surfaceLeafCounts: PolyRenderSurfaceLeafCounts;
+    bucketCount: number;
+}
+interface PolyRenderStatsOptions {
+    polygonCount?: number;
+    /**
+     * Optional subtree selector for diagnostics that only want model leaves and
+     * not helpers/floors/gizmos sharing the same scene root.
+     */
+    scopeSelector?: string;
+}
+declare function collectPolyRenderStats(root: ParentNode | null | undefined, optionsOrPolygonCount?: number | PolyRenderStatsOptions): PolyRenderStats;
+
 interface UsePolyAnimationResultVue {
     /** Attach to a mesh handle when not passing `root` directly. */
     ref: Ref<PolyAnimationTarget | null>;
@@ -1436,4 +2789,4 @@ interface UsePolyAnimationResultVue {
 }
 declare function usePolyAnimation(clips: MaybeRef<PolyAnimationClip[] | undefined>, controller: MaybeRef<ParseAnimationController | undefined>, root?: MaybeRef<PolyAnimationTarget | null | undefined>): UsePolyAnimationResultVue;
 
-export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyPerspectiveCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyPerspectiveCameraProps as PolyCameraProps, type PolyContext, type PolyControlsAnimateOptions, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, type PolyEventHandler, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, type PolyPointerEvent, type PolyProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResultVue, type UseSceneContextOptions, type UseSceneContextResult, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };
+export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, PolyOrthographicCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, PolyCone, type PolyContext, type PolyControlsAnimateOptions, PolyCylinder, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, PolyDodecahedron, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, PolyIcosahedron, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOctahedron, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, PolyPlane, type PolyPointerEvent, type PolyProps, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolySphere, PolyTetrahedron, PolyTorus, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResultVue, type UseSceneContextOptions, type UseSceneContextResult, collectPolyRenderStats, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };