@layoutit/polycss-vue 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as vue from 'vue';
-import { PropType, Ref, InjectionKey, VNode, ComputedRef, MaybeRef } from 'vue';
-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';
+import { PropType, Ref, InjectionKey, VNode, CSSProperties, ComputedRef, MaybeRef } from 'vue';
+import * as _layoutit_polycss_core from '@layoutit/polycss-core';
+import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolySeamBleed, PolyRenderStrategiesOption, LoadMeshOptions, ParseResult, MeshResolution, PolyMaterial, Vec2, BoxPolygonsOptions, ConePolygonsOptions, CylinderPolygonsOptions, DodecahedronPolygonsOptions, IcosahedronPolygonsOptions, OctahedronPolygonsOptions, PlanePolygonsOptions, RingPolygonsOptions, SpherePolygonsOptions, TetrahedronPolygonsOptions, TorusPolygonsOptions, 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, OptimizeMeshParseResultOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParseStlColor, ParseStlSolid, ParseStlTopology, ParsedColor, PlanePolygonsOptions, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyMeshTransformInput, PolyRenderStrategiesOption, PolyRenderStrategy, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SeamFacetSplitCandidate, SeamFacetSplitCandidateReason, SeamFacetSplitOptions, SeamFacetSplitReport, SeamOverlapCandidate, SeamOverlapCandidateKind, SeamOverlapDiagnostics, SeamOverlapOptions, SimplifyTriangleMeshPolygonsOptions, SolidTextureSampleOptions, StlParseOptions, TetrahedronPolygonsOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, TorusPolygonsOptions, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildPolyMeshTransform, 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, optimizeMeshParseResult, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseStl, parseVox, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, simplifyTriangleMeshPolygons, tetrahedronPolygons, torusPolygons, worldDirectionToCss as worldDirectionToPolyCss, worldPositionToCss as worldPositionToPolyCss } from '@layoutit/polycss-core';
 
 interface PolyOrthographicCameraProps {
     zoom?: number;
@@ -61,7 +62,7 @@ interface PolyPerspectiveCameraProps {
     rotY?: number;
     /** Camera pull-back in CSS pixels (dolly). Default 0. */
     distance?: number;
-    /** CSS perspective distance in pixels. Defaults to 8000. */
+    /** CSS perspective distance in pixels. Defaults to 32000. */
     perspective?: number;
     class?: string;
 }
@@ -218,6 +219,7 @@ interface PolyShadowOptions {
 
 interface PolySceneProps {
     polygons?: Polygon[];
+    centerPolygons?: Polygon[];
     perspective?: number;
     rotX?: number;
     rotY?: number;
@@ -243,10 +245,9 @@ interface PolySceneProps {
     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 }`.
+     * lighting modes. Shadows emit as SVG paths and reproject when light,
+     * ground, or mesh geometry changes. Defaults:
+     * `{ color: "#000000", opacity: 0.25, lift: 0.05, maxExtend: 2000 }`.
      */
     shadow?: PolyShadowOptions;
     class?: string;
@@ -261,6 +262,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    centerPolygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
     perspective: {
         type: NumberConstructor;
     };
@@ -333,6 +338,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    centerPolygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
     perspective: {
         type: NumberConstructor;
     };
@@ -400,13 +409,14 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>> & Readonly<{}>, {
     directionalLight: PolyDirectionalLight;
-    textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
+    seamBleed: PolySeamBleed;
+    textureLighting: PolyTextureLightingMode;
     polygons: Polygon[];
+    centerPolygons: Polygon[];
     ambientLight: PolyAmbientLight;
     textureQuality: TextureQuality;
-    seamBleed: PolySeamBleed;
     strategies: PolyRenderStrategiesOption;
     autoCenter: boolean;
     shadow: PolyShadowOptions;
@@ -415,6 +425,18 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     debugShowBackfaces: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+type UseMeshOptions = LoadMeshOptions;
+interface UseMeshResult {
+    polygons: Ref<Polygon[]>;
+    voxelSource: Ref<ParseResult["voxelSource"]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    warnings: Ref<string[]>;
+    /** Manually trigger cleanup (also called on unmount automatically). */
+    dispose: () => void;
+}
+declare function usePolyMesh(src: Ref<string>, options?: UseMeshOptions): UseMeshResult;
+
 /**
  * Pointer event API for `<PolyMesh>` (Vue). Mirrors @react-three/fiber's
  * mesh event surface (handler names + payload shape) so devs migrating
@@ -534,16 +556,38 @@ interface PolyMeshProps extends InteractionProps {
     /** 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.
+     * Hold the previous frame until the next atlas is decoded, then swap
+     * atomically. Best for discrete geometry edits where a partial texture
+     * frame would be visible.
+     */
+    atomicAtlas?: boolean;
+    /** Fires when the displayed atlas frame swaps to a ready one in atomic mode. */
+    onFrameReady?: () => void;
+    /**
+     * When `true`, emits a per-mesh SVG shadow path in both lighting modes.
+     * Each casting polygon projects onto the scene ground plane along the
+     * directional light; overlapping outlines are merged into one silhouette.
      * Defaults to `false`.
      */
     castShadow?: boolean;
+    /**
+     * When `true`, this mesh acts as a shadow receiver. The scene's caster
+     * meshes (those with `castShadow=true`) project per-coplanar-face SVG
+     * shadows onto each visible surface, matching Three.js's `mesh.receiveShadow`
+     * semantics. Disables the ground-shadow fallback when at least one
+     * receiver exists. Defaults to `false`.
+     */
+    receiveShadow?: boolean;
+    /** Apply mesh optimization (coplanar merge + interior cull) before
+     *  rendering. Defaults to `true` — matches vanilla `scene.add`. Set
+     *  `false` for helper meshes whose geometry shouldn't be merged. */
+    merge?: 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;
+    /** Parser options forwarded to parseObj/parseGltf/parseVox. */
+    parseOptions?: UseMeshOptions;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -566,6 +610,13 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    /** Optional `parseResult.voxelSource` companion for `.vox` meshes. When
+     *  set alongside `polygons`, the direct voxel renderer fast path
+     *  activates — mirrors vanilla's `scene.add(parseResult)` behaviour. */
+    voxelSource: {
+        type: PropType<_layoutit_polycss_core.ParseResult["voxelSource"]>;
+        default: undefined;
+    };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
@@ -582,14 +633,34 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolySeamBleed>;
         default: undefined;
     };
+    atomicAtlas: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    onFrameReady: {
+        type: PropType<() => void>;
+        default: undefined;
+    };
     castShadow: {
         type: PropType<boolean>;
         default: boolean;
     };
+    receiveShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    merge: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     meshResolution: {
         type: PropType<MeshResolution>;
         default: undefined;
     };
+    parseOptions: {
+        type: PropType<UseMeshOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -672,6 +743,13 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    /** Optional `parseResult.voxelSource` companion for `.vox` meshes. When
+     *  set alongside `polygons`, the direct voxel renderer fast path
+     *  activates — mirrors vanilla's `scene.add(parseResult)` behaviour. */
+    voxelSource: {
+        type: PropType<_layoutit_polycss_core.ParseResult["voxelSource"]>;
+        default: undefined;
+    };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
@@ -688,14 +766,34 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolySeamBleed>;
         default: undefined;
     };
+    atomicAtlas: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    onFrameReady: {
+        type: PropType<() => void>;
+        default: undefined;
+    };
     castShadow: {
         type: PropType<boolean>;
         default: boolean;
     };
+    receiveShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    merge: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     meshResolution: {
         type: PropType<MeshResolution>;
         default: undefined;
     };
+    parseOptions: {
+        type: PropType<UseMeshOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -762,19 +860,25 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{}>, {
     onClick: PolyEventHandler<MouseEvent>;
     onWheel: PolyEventHandler<WheelEvent>;
-    textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
+    seamBleed: PolySeamBleed;
+    textureLighting: PolyTextureLightingMode;
     polygons: Polygon[];
     textureQuality: TextureQuality;
-    seamBleed: PolySeamBleed;
     autoCenter: boolean;
     rotation: Vec3;
+    voxelSource: _layoutit_polycss_core.PolyVoxelSource | undefined;
     id: string;
     src: string;
     mtl: string;
+    atomicAtlas: boolean;
+    onFrameReady: () => void;
     castShadow: boolean;
+    receiveShadow: boolean;
+    merge: boolean;
     meshResolution: MeshResolution;
+    parseOptions: _layoutit_polycss_core.LoadMeshOptions;
     onContextMenu: PolyEventHandler<MouseEvent>;
     onDoubleClick: PolyEventHandler<MouseEvent>;
     onPointerDown: PolyEventHandler<PointerEvent>;
@@ -787,6 +891,142 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     onPointerCancel: PolyEventHandler<PointerEvent>;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+interface PolyIframeProps {
+    src: string;
+    width: number;
+    height: number;
+    position?: Vec3;
+    rotation?: Vec3;
+    scale?: number | Vec3;
+    allow?: string;
+    sandbox?: string;
+    loading?: "lazy" | "eager";
+    referrerpolicy?: string;
+    title?: string;
+    class?: string;
+    style?: CSSProperties;
+}
+declare const PolyIframe: vue.DefineComponent<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    allow: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sandbox: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<"lazy" | "eager">;
+        default: undefined;
+    };
+    referrerpolicy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    allow: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sandbox: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<"lazy" | "eager">;
+        default: undefined;
+    };
+    referrerpolicy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    style: CSSProperties;
+    title: string;
+    position: Vec3;
+    scale: number | Vec3;
+    rotation: Vec3;
+    allow: string;
+    sandbox: string;
+    loading: "eager" | "lazy";
+    referrerpolicy: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
 interface PolyGroundProps {
     /** Side length of the ground quad in world units. Default `6`. */
     size?: number;
@@ -794,8 +1034,8 @@ interface PolyGroundProps {
     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. */
+    /** Fill color. Default `#7d848e` — medium gray, chosen so the default
+     *  25% black SVG shadow has visible contrast against it. */
     color?: string;
     class?: string;
 }
@@ -845,9 +1085,9 @@ declare const PolyGround: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>> & Readonly<{}>, {
     class: string;
-    color: string;
     size: number;
     center: [number, number];
+    color: string;
     z: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
@@ -870,18 +1110,6 @@ interface UseSceneContextResult {
  */
 declare function usePolySceneContext(polygons: Ref<Polygon[]>, options: Ref<UseSceneContextOptions>): Ref<UseSceneContextResult>;
 
-type UseMeshOptions = LoadMeshOptions;
-interface UseMeshResult {
-    polygons: Ref<Polygon[]>;
-    voxelSource: Ref<ParseResult["voxelSource"]>;
-    loading: Ref<boolean>;
-    error: Ref<Error | null>;
-    warnings: Ref<string[]>;
-    /** Manually trigger cleanup (also called on unmount automatically). */
-    dispose: () => void;
-}
-declare function usePolyMesh(src: Ref<string>, options?: UseMeshOptions): UseMeshResult;
-
 /**
  * usePolyMaterial — Vue composable that returns a stable computed material
  * handle. Accepts either a plain options object or a reactive getter so that
@@ -1040,17 +1268,20 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>> & Readonly<{}>, {
     data: Record<string, string | number | boolean>;
-    pointerEvents: "none" | "auto";
-    textureLighting: PolyTextureLightingMode;
     position: Vec3;
+    pointerEvents: "auto" | "none";
     scale: number | Vec3;
-    textureQuality: TextureQuality;
-    rotation: Vec3;
     material: PolyMaterial;
     uvs: Vec2[];
+    textureLighting: PolyTextureLightingMode;
+    textureQuality: TextureQuality;
+    rotation: Vec3;
     context: PolyContext;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+type ShapeMeshProps = Omit<PolyMeshProps, "polygons" | "src" | "mtl">;
+interface PolyBoxProps extends ShapeMeshProps, BoxPolygonsOptions {
+}
 declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
     size: {
         type: PropType<number | Vec3>;
@@ -1076,6 +1307,22 @@ declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
+    material: {
+        type: PropType<PolyMaterial>;
+        default: undefined;
+    };
+    uvs: {
+        type: PropType<Vec2[]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<BoxPolygonsOptions["data"]>;
+        default: undefined;
+    };
+    faces: {
+        type: PropType<BoxPolygonsOptions["faces"]>;
+        default: undefined;
+    };
     position: {
         type: PropType<Vec3>;
         default: undefined;
@@ -1123,6 +1370,22 @@ declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
+    material: {
+        type: PropType<PolyMaterial>;
+        default: undefined;
+    };
+    uvs: {
+        type: PropType<Vec2[]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<BoxPolygonsOptions["data"]>;
+        default: undefined;
+    };
+    faces: {
+        type: PropType<BoxPolygonsOptions["faces"]>;
+        default: undefined;
+    };
     position: {
         type: PropType<Vec3>;
         default: undefined;
@@ -1144,18 +1407,24 @@ declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
+    data: Record<string, string | number | boolean> | undefined;
     size: number | Vec3;
     center: Vec3;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
+    texture: string;
+    material: PolyMaterial;
+    uvs: Vec2[];
     autoCenter: boolean;
     rotation: Vec3;
-    texture: string;
     id: string;
+    faces: Partial<Record<_layoutit_polycss_core.BoxFace, false | _layoutit_polycss_core.BoxFaceOptions>> | undefined;
     min: Vec3;
     max: Vec3;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyPlaneProps extends ShapeMeshProps, PlanePolygonsOptions {
+}
 declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
     axis: {
         type: PropType<0 | 1 | 2>;
@@ -1165,6 +1434,10 @@ declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
         type: NumberConstructor;
         default: undefined;
     };
+    offset: {
+        type: PropType<number | [number, number]>;
+        default: undefined;
+    };
     along: {
         type: NumberConstructor;
         default: undefined;
@@ -1204,6 +1477,10 @@ declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
         type: NumberConstructor;
         default: undefined;
     };
+    offset: {
+        type: PropType<number | [number, number]>;
+        default: undefined;
+    };
     along: {
         type: NumberConstructor;
         default: undefined;
@@ -1233,15 +1510,18 @@ declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     size: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
+    offset: number | [number, number];
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
     along: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyRingProps extends ShapeMeshProps, RingPolygonsOptions {
+}
 declare const PolyRing: vue.DefineComponent<vue.ExtractPropTypes<{
     axis: {
         type: PropType<0 | 1 | 2>;
@@ -1336,6 +1616,8 @@ declare const PolyRing: vue.DefineComponent<vue.ExtractPropTypes<{
     halfThickness: number;
     segments: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyOctahedronProps extends ShapeMeshProps, OctahedronPolygonsOptions {
+}
 declare const PolyOctahedron: vue.DefineComponent<vue.ExtractPropTypes<{
     center: {
         type: PropType<Vec3>;
@@ -1412,6 +1694,8 @@ declare const PolyOctahedron: vue.DefineComponent<vue.ExtractPropTypes<{
     rotation: Vec3;
     id: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyTetrahedronProps extends ShapeMeshProps, TetrahedronPolygonsOptions {
+}
 declare const PolyTetrahedron: vue.DefineComponent<vue.ExtractPropTypes<{
     size: {
         type: NumberConstructor;
@@ -1473,14 +1757,16 @@ declare const PolyTetrahedron: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     size: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyIcosahedronProps extends ShapeMeshProps, IcosahedronPolygonsOptions {
+}
 declare const PolyIcosahedron: vue.DefineComponent<vue.ExtractPropTypes<{
     size: {
         type: NumberConstructor;
@@ -1542,14 +1828,16 @@ declare const PolyIcosahedron: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     size: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyDodecahedronProps extends ShapeMeshProps, DodecahedronPolygonsOptions {
+}
 declare const PolyDodecahedron: vue.DefineComponent<vue.ExtractPropTypes<{
     size: {
         type: NumberConstructor;
@@ -1611,14 +1899,16 @@ declare const PolyDodecahedron: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     size: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolySphereProps extends ShapeMeshProps, SpherePolygonsOptions {
+}
 declare const PolySphere: vue.DefineComponent<vue.ExtractPropTypes<{
     radius: {
         type: NumberConstructor;
@@ -1697,6 +1987,8 @@ declare const PolySphere: vue.DefineComponent<vue.ExtractPropTypes<{
     radius: number;
     subdivisions: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyCylinderProps extends ShapeMeshProps, CylinderPolygonsOptions {
+}
 declare const PolyCylinder: vue.DefineComponent<vue.ExtractPropTypes<{
     radius: {
         type: NumberConstructor;
@@ -1782,8 +2074,8 @@ declare const PolyCylinder: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     height: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
     autoCenter: boolean;
@@ -1793,6 +2085,8 @@ declare const PolyCylinder: vue.DefineComponent<vue.ExtractPropTypes<{
     radiusTop: number;
     radialSegments: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyConeProps extends ShapeMeshProps, ConePolygonsOptions {
+}
 declare const PolyCone: vue.DefineComponent<vue.ExtractPropTypes<{
     radius: {
         type: NumberConstructor;
@@ -1870,8 +2164,8 @@ declare const PolyCone: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     height: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
     autoCenter: boolean;
@@ -1880,6 +2174,8 @@ declare const PolyCone: vue.DefineComponent<vue.ExtractPropTypes<{
     radius: number;
     radialSegments: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyTorusProps extends ShapeMeshProps, TorusPolygonsOptions {
+}
 declare const PolyTorus: vue.DefineComponent<vue.ExtractPropTypes<{
     radius: {
         type: NumberConstructor;
@@ -2743,8 +3039,8 @@ declare const PolyDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTyp
 }>> & Readonly<{}>, {
     target: Vec3;
     distance: number;
-    color: string;
     size: number;
+    color: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare function injectPolyBaseStyles(doc?: Document): void;
@@ -2789,4 +3085,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, 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 };
+export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, type PolyBoxProps, PolyOrthographicCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, PolyCone, type PolyConeProps, type PolyContext, type PolyControlsAnimateOptions, PolyCylinder, type PolyCylinderProps, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, PolyDodecahedron, type PolyDodecahedronProps, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, PolyIcosahedron, type PolyIcosahedronProps, PolyIframe, type PolyIframeProps, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOctahedron, type PolyOctahedronProps, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, PolyPlane, type PolyPlaneProps, type PolyPointerEvent, type PolyProps, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, type PolyRingProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolySphere, type PolySphereProps, PolyTetrahedron, type PolyTetrahedronProps, PolyTorus, type PolyTorusProps, 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 };