@layoutit/polycss-vue 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 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';
+export { ApproximateMergeOptions, ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, BoxFace, BoxFaceOptions, BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MeshResolution, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, 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, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, formatColor, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, ringPolygons, rotateVec3, shadeColor } from '@layoutit/polycss-core';
 
 interface PolyPerspectiveCameraProps {
     zoom?: number;
@@ -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,28 @@ 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;
+}
+
+type TextureQuality = number | "auto";
+type PolyRenderStrategy = "b" | "i" | "u";
+interface PolyRenderStrategiesOption {
+    /** Strategies to skip; polygons that would normally use them fall through
+     *  the chain (b → i → s, u → i → s, i → s). `<s>` is the universal
+     *  fallback and cannot be disabled — textured polys have no other path. */
+    disable?: readonly PolyRenderStrategy[];
+}
 
 interface PolySceneProps {
     polygons?: Polygon[];
@@ -192,8 +227,13 @@ 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;
+    /** 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,12 @@ interface PolySceneProps {
      * Mirrors React's PolyScene autoCenter prop.
      */
     autoCenter?: boolean;
+    /**
+     * Shadow appearance for meshes with `castShadow: true`. Only applies in
+     * dynamic lighting mode — baked mode does not emit shadow leaves.
+     * Defaults: `{ color: "#000000", opacity: 0.25, lift: 0.05 }`.
+     */
+    shadow?: PolyShadowOptions;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -237,14 +283,22 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: string;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
+        default: undefined;
+    };
+    strategies: {
+        type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
     };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
+    shadow: {
+        type: PropType<PolyShadowOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -297,14 +351,22 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: string;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
+        default: undefined;
+    };
+    strategies: {
+        type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
     };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
+    shadow: {
+        type: PropType<PolyShadowOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -331,10 +393,12 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
-    atlasScale: AtlasScale;
     polygons: Polygon[];
     ambientLight: PolyAmbientLight;
+    textureQuality: TextureQuality;
+    strategies: PolyRenderStrategiesOption;
     autoCenter: boolean;
+    shadow: PolyShadowOptions;
     rotation: Vec3;
     debugShowLabels: boolean;
     debugShowBackfaces: boolean;
@@ -365,6 +429,15 @@ interface PolyMeshHandle {
     getRotation(): Vec3 | undefined;
     getScale(): number | Vec3 | undefined;
     getPolygons(): Polygon[];
+    /**
+     * 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 +509,18 @@ 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;
+    /**
+     * 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;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -468,10 +551,14 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
         default: undefined;
     };
+    castShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     class: {
         type: StringConstructor;
     };
@@ -562,10 +649,14 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
         default: undefined;
     };
+    castShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
     class: {
         type: StringConstructor;
     };
@@ -635,13 +726,14 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
-    atlasScale: AtlasScale;
     polygons: Polygon[];
+    textureQuality: TextureQuality;
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
     src: string;
     mtl: string;
+    castShadow: boolean;
     onContextMenu: PolyEventHandler<MouseEvent>;
     onDoubleClick: PolyEventHandler<MouseEvent>;
     onPointerDown: PolyEventHandler<PointerEvent>;
@@ -654,6 +746,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;
 }
@@ -705,7 +861,7 @@ interface PolyContext {
     layerElevation?: number;
     directionalLight?: PolyDirectionalLight;
     textureLighting?: PolyTextureLightingMode;
-    atlasScale?: AtlasScale;
+    textureQuality?: TextureQuality;
     debugShowBackfaces?: boolean;
     [key: string]: unknown;
 }
@@ -724,8 +880,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 +925,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 +981,8 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<PolyTextureLightingMode>;
         default: undefined;
     };
-    atlasScale: {
-        type: PropType<AtlasScale>;
+    textureQuality: {
+        type: PropType<TextureQuality>;
         default: undefined;
     };
     context: {
@@ -846,7 +1003,7 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
-    atlasScale: AtlasScale;
+    textureQuality: TextureQuality;
     rotation: Vec3;
     material: PolyMaterial;
     context: PolyContext;
@@ -1215,8 +1372,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 +1382,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;
@@ -1436,4 +1798,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, PolyPerspectiveCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyPerspectiveCameraProps as PolyCameraProps, type PolyContext, type PolyControlsAnimateOptions, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, 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, type PolyRenderStrategiesOption, type PolyRenderStrategy, 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 };