@layoutit/polycss-vue 0.2.5 → 0.2.7

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as vue from 'vue';
 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, PolySceneTransformInput, 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, buildPolySceneTransform, 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, cssDistanceToWorld as polyCssDistanceToWorld, cssPositionToWorld as polyCssPositionToWorld, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, simplifyTriangleMeshPolygons, tetrahedronPolygons, torusPolygons, worldDirectionToCss as worldDirectionToPolyCss, worldDirectionalLightToCss as worldDirectionalLightToPolyCss, worldDistanceToCss as worldDistanceToPolyCss, worldPositionToCss as worldPositionToPolyCss } from '@layoutit/polycss-core';
+import { Vec3, CameraState, CameraHandle, PolyCameraProjection, Polygon, PolyDirectionalLight, PolyPointLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolyTextureLeafSizing, PolyTextureImageRendering, PolyTextureBackend, PolyTextureProjection, PolySeamBleed, PolyRenderStrategiesOption, LoadMeshOptions, ParseResult, MeshResolution, PolyMaterial, PolyTextureImageSource, PolyTexturePresentation, 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, PolyCameraProjection, PolyCameraSnapshot, PolyCameraSnapshotOptions, PolyCameraSnapshotSource, PolyDirectionalLight, PolyMaterial, PolyMeshTransformInput, PolyRenderStrategiesOption, PolyRenderStrategy, PolySceneTransformInput, PolyTextureBackend, PolyTextureImageLighting, PolyTextureImageRendering, PolyTextureImageSource, PolyTextureLeafSizing, PolyTextureLightingMode, PolyTexturePresentation, PolyTextureProjection, 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, buildPolyCameraSceneTransform, buildPolyMeshTransform, buildPolySceneTransform, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, capturePolyCameraSnapshot, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, conePolygons, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cssDistanceToWorld, cssPositionToWorld, 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, polyCameraTargetToCss, polyCssDistanceToWorld, polyCssPositionToWorld, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, resolvePolyCameraAppliedPerspectiveStyle, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, simplifyTriangleMeshPolygons, tetrahedronPolygons, torusPolygons, worldDirectionToCss, worldDirectionToPolyCss, worldDirectionalLightToCss, worldDirectionalLightToPolyCss, worldDistanceToCss, worldDistanceToPolyCss, worldPositionToCss, worldPositionToPolyCss } from '@layoutit/polycss-core';
 
 interface PolyOrthographicCameraProps {
     zoom?: number;
@@ -143,6 +143,8 @@ interface UseCameraOptions {
     rotX?: number;
     rotY?: number;
     distance?: number;
+    projection?: PolyCameraProjection;
+    perspectiveStyle?: string;
 }
 interface UseCameraResult {
     store: SceneStore;
@@ -215,6 +217,30 @@ interface PolyShadowOptions {
      * disable the cap entirely.
      */
     maxExtend?: number;
+    /**
+     * Cast a low-resolution parametric silhouette per caster instead of full
+     * geometry — lighter DOM + cheaper projection. Directional + point lights.
+     * Default: `false`.
+     */
+    parametric?: boolean;
+    /**
+     * Parametric-shadow detail (max silhouette points / pixel-grid resolution).
+     * Only used when `parametric` is true. Default: `16`. Override per mesh via
+     * `<poly-mesh shadow-definition>`.
+     */
+    definition?: number;
+    /**
+     * Parametric render style: `"vector"` (smooth contour, default) or `"pixel"`
+     * (greedy-meshed voxel blocks; `definition` becomes the grid resolution).
+     */
+    style?: "vector" | "pixel";
+    /**
+     * Re-emit a caster's shadow while it animates (deforms) so the shadow follows
+     * the pose instead of freezing. Default `false`: a same-topology deform keeps
+     * the last shadow pose (re-emitting every frame is expensive). Best with
+     * `parametric`. Topology changes (different polygon count) always re-emit.
+     */
+    followAnimation?: boolean;
 }
 
 interface PolySceneProps {
@@ -225,6 +251,7 @@ interface PolySceneProps {
     rotY?: number;
     zoom?: number;
     directionalLight?: PolyDirectionalLight;
+    pointLights?: PolyPointLight[];
     ambientLight?: PolyAmbientLight;
     textureLighting?: PolyTextureLightingMode;
     /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
@@ -232,6 +259,14 @@ interface PolySceneProps {
      *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
      *  raster scale and the 64px sprite. */
     textureQuality?: TextureQuality;
+    /** Atlas leaf CSS primitive sizing. Defaults to canonical browser-fast sizing. */
+    textureLeafSizing?: PolyTextureLeafSizing;
+    /** Default image filtering for atlas and direct image texture leaves. */
+    textureImageRendering?: PolyTextureImageRendering;
+    /** Default texture backend request. Defaults to "auto". */
+    textureBackend?: PolyTextureBackend;
+    /** Default texture projection request. Defaults to "affine". */
+    textureProjection?: PolyTextureProjection;
     /** 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. */
@@ -282,6 +317,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyDirectionalLight>;
         default: undefined;
     };
+    pointLights: {
+        type: PropType<PolyPointLight[]>;
+        default: undefined;
+    };
     ambientLight: {
         type: PropType<PolyAmbientLight>;
         default: undefined;
@@ -294,6 +333,22 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    textureLeafSizing: {
+        type: PropType<PolyTextureLeafSizing>;
+        default: undefined;
+    };
+    textureImageRendering: {
+        type: PropType<PolyTextureImageRendering>;
+        default: undefined;
+    };
+    textureBackend: {
+        type: PropType<PolyTextureBackend>;
+        default: undefined;
+    };
+    textureProjection: {
+        type: PropType<PolyTextureProjection>;
+        default: undefined;
+    };
     seamBleed: {
         type: PropType<PolySeamBleed>;
         default: undefined;
@@ -358,6 +413,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyDirectionalLight>;
         default: undefined;
     };
+    pointLights: {
+        type: PropType<PolyPointLight[]>;
+        default: undefined;
+    };
     ambientLight: {
         type: PropType<PolyAmbientLight>;
         default: undefined;
@@ -370,6 +429,22 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    textureLeafSizing: {
+        type: PropType<PolyTextureLeafSizing>;
+        default: undefined;
+    };
+    textureImageRendering: {
+        type: PropType<PolyTextureImageRendering>;
+        default: undefined;
+    };
+    textureBackend: {
+        type: PropType<PolyTextureBackend>;
+        default: undefined;
+    };
+    textureProjection: {
+        type: PropType<PolyTextureProjection>;
+        default: undefined;
+    };
     seamBleed: {
         type: PropType<PolySeamBleed>;
         default: undefined;
@@ -413,10 +488,15 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     scale: number | Vec3;
     seamBleed: PolySeamBleed;
     textureLighting: PolyTextureLightingMode;
+    textureImageRendering: PolyTextureImageRendering;
     polygons: Polygon[];
     centerPolygons: Polygon[];
+    pointLights: PolyPointLight[];
     ambientLight: PolyAmbientLight;
     textureQuality: TextureQuality;
+    textureLeafSizing: PolyTextureLeafSizing;
+    textureBackend: PolyTextureBackend;
+    textureProjection: PolyTextureProjection;
     strategies: PolyRenderStrategiesOption;
     autoCenter: boolean;
     shadow: PolyShadowOptions;
@@ -496,6 +576,8 @@ interface PolyMeshHandle {
      * is always correct and never needs rebaking.
      */
     rebakeAtlas(): void;
+    /** Resolves when this mesh's current texture generation has usable backgrounds. */
+    whenTexturesReady(): Promise<void>;
 }
 interface PolyPointerEvent<E extends Event = PointerEvent> {
     object: PolyMeshHandle;
@@ -553,6 +635,14 @@ interface PolyMeshProps extends InteractionProps {
      *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
      *  raster scale and the 64px sprite. */
     textureQuality?: TextureQuality;
+    /** Atlas leaf CSS primitive sizing. Defaults to scene context, then canonical. */
+    textureLeafSizing?: PolyTextureLeafSizing;
+    /** Default image filtering for atlas and direct image texture leaves. */
+    textureImageRendering?: PolyTextureImageRendering;
+    /** Default texture backend request. Defaults to scene context, then "auto". */
+    textureBackend?: PolyTextureBackend;
+    /** Default texture projection request. Defaults to scene context, then "affine". */
+    textureProjection?: PolyTextureProjection;
     /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
     seamBleed?: PolySeamBleed;
     /**
@@ -629,6 +719,22 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    textureLeafSizing: {
+        type: PropType<PolyTextureLeafSizing>;
+        default: undefined;
+    };
+    textureImageRendering: {
+        type: PropType<PolyTextureImageRendering>;
+        default: undefined;
+    };
+    textureBackend: {
+        type: PropType<PolyTextureBackend>;
+        default: undefined;
+    };
+    textureProjection: {
+        type: PropType<PolyTextureProjection>;
+        default: undefined;
+    };
     seamBleed: {
         type: PropType<PolySeamBleed>;
         default: undefined;
@@ -649,6 +755,12 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<boolean>;
         default: boolean;
     };
+    /** Per-mesh parametric-shadow detail override (scene `shadow.definition`
+     *  when undefined). Only used when the scene's `shadow.parametric` is true. */
+    shadowDefinition: {
+        type: PropType<number>;
+        default: undefined;
+    };
     merge: {
         type: PropType<boolean>;
         default: boolean;
@@ -762,6 +874,22 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    textureLeafSizing: {
+        type: PropType<PolyTextureLeafSizing>;
+        default: undefined;
+    };
+    textureImageRendering: {
+        type: PropType<PolyTextureImageRendering>;
+        default: undefined;
+    };
+    textureBackend: {
+        type: PropType<PolyTextureBackend>;
+        default: undefined;
+    };
+    textureProjection: {
+        type: PropType<PolyTextureProjection>;
+        default: undefined;
+    };
     seamBleed: {
         type: PropType<PolySeamBleed>;
         default: undefined;
@@ -782,6 +910,12 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<boolean>;
         default: boolean;
     };
+    /** Per-mesh parametric-shadow detail override (scene `shadow.definition`
+     *  when undefined). Only used when the scene's `shadow.parametric` is true. */
+    shadowDefinition: {
+        type: PropType<number>;
+        default: undefined;
+    };
     merge: {
         type: PropType<boolean>;
         default: boolean;
@@ -864,8 +998,12 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     scale: number | Vec3;
     seamBleed: PolySeamBleed;
     textureLighting: PolyTextureLightingMode;
+    textureImageRendering: PolyTextureImageRendering;
     polygons: Polygon[];
     textureQuality: TextureQuality;
+    textureLeafSizing: PolyTextureLeafSizing;
+    textureBackend: PolyTextureBackend;
+    textureProjection: PolyTextureProjection;
     autoCenter: boolean;
     rotation: Vec3;
     voxelSource: _layoutit_polycss_core.PolyVoxelSource | undefined;
@@ -879,6 +1017,7 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     merge: boolean;
     meshResolution: MeshResolution;
     parseOptions: _layoutit_polycss_core.LoadMeshOptions;
+    shadowDefinition: number;
     onContextMenu: PolyEventHandler<MouseEvent>;
     onDoubleClick: PolyEventHandler<MouseEvent>;
     onPointerDown: PolyEventHandler<PointerEvent>;
@@ -1132,6 +1271,10 @@ interface PolyContext {
     directionalLight?: PolyDirectionalLight;
     textureLighting?: PolyTextureLightingMode;
     textureQuality?: TextureQuality;
+    textureLeafSizing?: PolyTextureLeafSizing;
+    textureImageRendering?: PolyTextureImageRendering;
+    textureBackend?: PolyTextureBackend;
+    textureProjection?: PolyTextureProjection;
     debugShowBackfaces?: boolean;
     [key: string]: unknown;
 }
@@ -1139,8 +1282,11 @@ interface PolyProps {
     vertices: Vec3[];
     color?: string;
     texture?: string;
+    textureImageSource?: PolyTextureImageSource;
+    texturePresentation?: PolyTexturePresentation;
     uvs?: Vec2[];
     data?: Record<string, string | number | boolean>;
+    doubleSided?: boolean;
     /** Shared material. When set AND the polygon's UVs form an axis-aligned
      *  rectangle, renders via `background-image` directly — no per-polygon
      *  canvas rasterization. Falls back to the atlas path otherwise. */
@@ -1153,6 +1299,14 @@ interface PolyProps {
     /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
      *  device-appropriate memory budget and desktop/mobile sprite sizing. */
     textureQuality?: TextureQuality;
+    /** Atlas leaf CSS primitive sizing. Defaults to scene context, then canonical. */
+    textureLeafSizing?: PolyTextureLeafSizing;
+    /** Default image filtering for atlas and direct image texture leaves. */
+    textureImageRendering?: PolyTextureImageRendering;
+    /** Default texture backend request. Defaults to scene context, then "auto". */
+    textureBackend?: PolyTextureBackend;
+    /** Default texture projection request. Defaults to scene context, then "affine". */
+    textureProjection?: PolyTextureProjection;
     baseColor?: string;
     pointerEvents?: "auto" | "none";
 }
@@ -1167,6 +1321,14 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
     texture: {
         type: StringConstructor;
     };
+    textureImageSource: {
+        type: PropType<PolyTextureImageSource>;
+        default: undefined;
+    };
+    texturePresentation: {
+        type: PropType<PolyTexturePresentation>;
+        default: undefined;
+    };
     uvs: {
         type: PropType<Vec2[]>;
         default: undefined;
@@ -1175,6 +1337,10 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Record<string, string | number | boolean>>;
         default: undefined;
     };
+    doubleSided: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
     material: {
         type: PropType<PolyMaterial>;
         default: undefined;
@@ -1199,6 +1365,22 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    textureLeafSizing: {
+        type: PropType<PolyTextureLeafSizing>;
+        default: undefined;
+    };
+    textureImageRendering: {
+        type: PropType<PolyTextureImageRendering>;
+        default: undefined;
+    };
+    textureBackend: {
+        type: PropType<PolyTextureBackend>;
+        default: undefined;
+    };
+    textureProjection: {
+        type: PropType<PolyTextureProjection>;
+        default: undefined;
+    };
     context: {
         type: PropType<PolyContext>;
         default: undefined;
@@ -1223,6 +1405,14 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
     texture: {
         type: StringConstructor;
     };
+    textureImageSource: {
+        type: PropType<PolyTextureImageSource>;
+        default: undefined;
+    };
+    texturePresentation: {
+        type: PropType<PolyTexturePresentation>;
+        default: undefined;
+    };
     uvs: {
         type: PropType<Vec2[]>;
         default: undefined;
@@ -1231,6 +1421,10 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Record<string, string | number | boolean>>;
         default: undefined;
     };
+    doubleSided: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
     material: {
         type: PropType<PolyMaterial>;
         default: undefined;
@@ -1255,6 +1449,22 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    textureLeafSizing: {
+        type: PropType<PolyTextureLeafSizing>;
+        default: undefined;
+    };
+    textureImageRendering: {
+        type: PropType<PolyTextureImageRendering>;
+        default: undefined;
+    };
+    textureBackend: {
+        type: PropType<PolyTextureBackend>;
+        default: undefined;
+    };
+    textureProjection: {
+        type: PropType<PolyTextureProjection>;
+        default: undefined;
+    };
     context: {
         type: PropType<PolyContext>;
         default: undefined;
@@ -1269,12 +1479,19 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{}>, {
     data: Record<string, string | number | boolean>;
     position: Vec3;
-    pointerEvents: "auto" | "none";
+    pointerEvents: "none" | "auto";
     scale: number | Vec3;
     material: PolyMaterial;
+    textureImageSource: PolyTextureImageSource;
+    texturePresentation: PolyTexturePresentation;
     uvs: Vec2[];
+    doubleSided: boolean;
     textureLighting: PolyTextureLightingMode;
+    textureImageRendering: PolyTextureImageRendering;
     textureQuality: TextureQuality;
+    textureLeafSizing: PolyTextureLeafSizing;
+    textureBackend: PolyTextureBackend;
+    textureProjection: PolyTextureProjection;
     rotation: Vec3;
     context: PolyContext;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
@@ -3051,11 +3268,84 @@ interface PolyRenderSurfaceLeafCounts {
     atlas: number;
     stableTriangle: number;
 }
+type PolyRenderLeafStrategy = keyof PolyRenderSurfaceLeafCounts;
+interface PolyTextureReadiness {
+    ready: boolean;
+    textureLeafCount: number;
+    readyTextureLeafCount: number;
+    pendingTextureLeafCount: number;
+    atlasTextureLeafCount: number;
+    imageTextureLeafCount: number;
+}
+interface PolyTextureRenderStats {
+    ready: boolean;
+    leafCount: number;
+    atlasCount: number;
+    imageCount: number;
+    pendingCount: number;
+    sizingCounts: {
+        canonical: number;
+        local: number;
+        raster: number;
+        image: number;
+        unknown: number;
+    };
+    imageRenderingCounts: {
+        auto: number;
+        pixelated: number;
+        unknown: number;
+    };
+    projectionCounts: {
+        affine: number;
+        projective: number;
+        fallback: number;
+        unknown: number;
+    };
+    minLeafWidth: number;
+    maxLeafWidth: number;
+    minLeafHeight: number;
+    maxLeafHeight: number;
+    doubleSidedCount: number;
+}
+interface PolySnapshotRenderStats {
+    runtimeAtlasUrlCount: number;
+    snapshotAtlasCount: number;
+    snapshotBackgroundCount: number;
+    selfContained: boolean;
+}
+interface PolyCameraSnapshotStats {
+    rootFound: boolean;
+    projection: "orthographic" | "perspective" | "unknown";
+    perspectiveStyle: string;
+    appliedPerspectiveStyle: string;
+    zoom?: number;
+    distance?: number;
+    rotX?: number;
+    rotY?: number;
+    target?: [number, number, number];
+}
+interface PolyLeafInfo {
+    element: HTMLElement;
+    strategy: PolyRenderLeafStrategy;
+    polygonIndex?: number;
+    textureBackend?: string;
+    textureReady?: boolean;
+    textureLeafSizing?: string;
+    textureImageRendering?: string;
+    textureProjection?: string;
+    textureLeafWidth?: number;
+    textureLeafHeight?: number;
+    doubleSided?: boolean;
+}
 interface PolyRenderStats {
     polygonCount: number;
     mountedPolygonLeafCount: number;
     shadowLeafCount: number;
     surfaceLeafCounts: PolyRenderSurfaceLeafCounts;
+    textureReadiness: PolyTextureReadiness;
+    textureStats: PolyTextureRenderStats;
+    snapshotStats: PolySnapshotRenderStats;
+    cameraStats: PolyCameraSnapshotStats;
     bucketCount: number;
 }
 interface PolyRenderStatsOptions {
@@ -3066,6 +3356,8 @@ interface PolyRenderStatsOptions {
      */
     scopeSelector?: string;
 }
+declare function queryPolyLeaves(root: ParentNode | null | undefined, optionsOrPolygonCount?: number | PolyRenderStatsOptions): PolyLeafInfo[];
+declare function collectPolyTextureReadiness(root: ParentNode | null | undefined, optionsOrPolygonCount?: number | PolyRenderStatsOptions): PolyTextureReadiness;
 declare function collectPolyRenderStats(root: ParentNode | null | undefined, optionsOrPolygonCount?: number | PolyRenderStatsOptions): PolyRenderStats;
 
 interface UsePolyAnimationResultVue {
@@ -3085,4 +3377,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, 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 };
+export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, type PolyBoxProps, PolyOrthographicCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, type PolyCameraSnapshotStats, 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, type PolyLeafInfo, 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 PolyRenderLeafStrategy, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, type PolyRingProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, type PolySnapshotRenderStats, PolySphere, type PolySphereProps, PolyTetrahedron, type PolyTetrahedronProps, type PolyTextureReadiness, type PolyTextureRenderStats, 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, collectPolyTextureReadiness, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, queryPolyLeaves, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };