@glyphcss/vue 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,22 +1,23 @@
-import { RenderMode, Vec3, GlyphcssAnimationTarget, GlyphcssAnimationMixer, GlyphcssAnimationClip, GlyphcssAnimationAction, ParseAnimationController } from '@glyphcss/core';
-export { ApproximateMergeOptions, ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, GlyphcssAmbientLight, GlyphcssAnimationAction, GlyphcssAnimationClip, GlyphcssAnimationMixer, GlyphcssAnimationTarget, GlyphcssDirectionalLight, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TextureTriangle, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, coverPlanarPolygons, createGlyphcssAnimationMixer, createIsometricCamera, 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 '@glyphcss/core';
+import { RenderMode, Polygon, GlyphGeometryName, Vec3, GlyphAnimationTarget, GlyphAnimationMixer, GlyphAnimationClip, GlyphAnimationAction, ParseAnimationController } from '@glyphcss/core';
+export { ApproximateMergeOptions, ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, GlyphAmbientLight, GlyphAnimationAction, GlyphAnimationClip, GlyphAnimationMixer, GlyphAnimationTarget, GlyphDirectionalLight, GlyphGeometryName, GlyphGeometryOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TextureTriangle, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, antiprismPolygons, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, bipyramidPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, conePolygons, coverPlanarPolygons, createGlyphAnimationMixer, createIsometricCamera, cubePolygons, cuboctahedronPolygons, cullInteriorPolygons, cylinderPolygons, deltoidalHexecontahedronPolygons, deltoidalIcositetrahedronPolygons, disdyakisDodecahedronPolygons, disdyakisTriacontahedronPolygons, dodecahedronPolygons, formatColor, greatDodecahedronPolygons, greatIcosahedronPolygons, greatStellatedDodecahedronPolygons, icosahedronPolygons, icosidodecahedronPolygons, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, pentagonalHexecontahedronPolygons, pentagonalIcositetrahedronPolygons, pentakisDodecahedronPolygons, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, prismPolygons, pyramidPolygons, resolveGeometry, rhombicDodecahedronPolygons, rhombicTriacontahedronPolygons, rhombicosidodecahedronPolygons, rhombicuboctahedronPolygons, ringPolygons, ringQuadPolygons, rotateVec3, shadeColor, smallStellatedDodecahedronPolygons, snubCubePolygons, snubDodecahedronPolygons, spherePolygons, tetrahedronPolygons, tetrakisHexahedronPolygons, torusPolygons, trapezohedronPolygons, triakisIcosahedronPolygons, triakisOctahedronPolygons, triakisTetrahedronPolygons, truncatedCubePolygons, truncatedCuboctahedronPolygons, truncatedDodecahedronPolygons, truncatedIcosahedronPolygons, truncatedIcosidodecahedronPolygons, truncatedOctahedronPolygons, truncatedTetrahedronPolygons } from '@glyphcss/core';
 import * as vue from 'vue';
-import { PropType, InjectionKey, ShallowRef, Ref, ComputedRef, MaybeRef } from 'vue';
-import { GlyphcssDirectionalLight, GlyphcssAmbientLight, GlyphcssTriangle, GlyphcssSceneHandle, GlyphcssCamera } from 'glyphcss';
-export { injectGlyphcssBaseStyles } from 'glyphcss';
+import { PropType, InjectionKey, ShallowRef, CSSProperties, Ref, ComputedRef, MaybeRef } from 'vue';
+import { GlyphDirectionalLight, GlyphAmbientLight, GlyphPointerEvent, GlyphMouseEvent, GlyphWheelEvent, GlyphSceneHandle, GlyphCamera } from 'glyphcss';
+export { GlyphEventHandler, GlyphMeshHandle, GlyphMouseEvent, GlyphPointerEvent, GlyphWheelEvent, findGlyphMeshHandle, findMeshUnderPoint, injectGlyphBaseStyles, pointInMeshElement } from 'glyphcss';
 
-interface GlyphcssSceneProps {
+interface GlyphSceneProps {
     mode?: RenderMode;
     glyphPalette?: string;
     useColors?: boolean;
     cols?: number;
     rows?: number;
     cellAspect?: number;
-    directionalLight?: GlyphcssDirectionalLight;
-    ambientLight?: GlyphcssAmbientLight;
+    directionalLight?: GlyphDirectionalLight;
+    ambientLight?: GlyphAmbientLight;
+    autoSize?: boolean;
     class?: string;
 }
-declare const GlyphcssScene: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphScene: vue.DefineComponent<vue.ExtractPropTypes<{
     mode: {
         type: PropType<RenderMode>;
         default: undefined;
@@ -42,11 +43,15 @@ declare const GlyphcssScene: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
     directionalLight: {
-        type: PropType<GlyphcssDirectionalLight>;
+        type: PropType<GlyphDirectionalLight>;
         default: undefined;
     };
     ambientLight: {
-        type: PropType<GlyphcssAmbientLight>;
+        type: PropType<GlyphAmbientLight>;
+        default: undefined;
+    };
+    autoSize: {
+        type: BooleanConstructor;
         default: undefined;
     };
     class: {
@@ -81,11 +86,15 @@ declare const GlyphcssScene: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
     directionalLight: {
-        type: PropType<GlyphcssDirectionalLight>;
+        type: PropType<GlyphDirectionalLight>;
         default: undefined;
     };
     ambientLight: {
-        type: PropType<GlyphcssAmbientLight>;
+        type: PropType<GlyphAmbientLight>;
+        default: undefined;
+    };
+    autoSize: {
+        type: BooleanConstructor;
         default: undefined;
     };
     class: {
@@ -99,27 +108,58 @@ declare const GlyphcssScene: vue.DefineComponent<vue.ExtractPropTypes<{
     cols: number;
     rows: number;
     cellAspect: number;
-    directionalLight: GlyphcssDirectionalLight;
-    ambientLight: GlyphcssAmbientLight;
+    directionalLight: GlyphDirectionalLight;
+    ambientLight: GlyphAmbientLight;
+    autoSize: boolean;
     class: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssMeshProps {
+interface GlyphMeshProps {
     id?: string;
-    triangles?: GlyphcssTriangle[];
+    polygons?: Polygon[];
+    /**
+     * Built-in geometry name. Resolved via `resolveGeometry` when neither
+     * `polygons` nor `src` is provided.
+     *
+     * Precedence: explicit `polygons` > `geometry`.
+     */
+    geometry?: GlyphGeometryName;
+    /** Uniform size passed to `resolveGeometry` when `geometry` is set. Defaults to 1. */
+    size?: number;
+    /** Fill color passed to `resolveGeometry` when `geometry` is set. */
+    color?: string;
     position?: Vec3;
     scale?: number | Vec3;
     rotation?: Vec3;
     class?: string;
+    onPointerDown?: (event: GlyphPointerEvent) => void;
+    onPointerUp?: (event: GlyphPointerEvent) => void;
+    onPointerMove?: (event: GlyphPointerEvent) => void;
+    onPointerEnter?: (event: GlyphPointerEvent) => void;
+    onPointerLeave?: (event: GlyphPointerEvent) => void;
+    onClick?: (event: GlyphMouseEvent) => void;
+    onWheel?: (event: GlyphWheelEvent) => void;
 }
-declare const GlyphcssMesh: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     id: {
         type: StringConstructor;
         default: undefined;
     };
-    triangles: {
-        type: PropType<GlyphcssTriangle[]>;
-        default: () => never[];
+    polygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
+    geometry: {
+        type: PropType<GlyphGeometryName>;
+        default: undefined;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
     };
     position: {
         type: PropType<Vec3>;
@@ -137,6 +177,34 @@ declare const GlyphcssMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
+    onPointerDown: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerUp: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerMove: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerEnter: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerLeave: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onClick: {
+        type: PropType<(e: GlyphMouseEvent) => void>;
+        default: undefined;
+    };
+    onWheel: {
+        type: PropType<(e: GlyphWheelEvent) => void>;
+        default: undefined;
+    };
 }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
@@ -144,9 +212,21 @@ declare const GlyphcssMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
-    triangles: {
-        type: PropType<GlyphcssTriangle[]>;
-        default: () => never[];
+    polygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
+    geometry: {
+        type: PropType<GlyphGeometryName>;
+        default: undefined;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
     };
     position: {
         type: PropType<Vec3>;
@@ -164,21 +244,133 @@ declare const GlyphcssMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
+    onPointerDown: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerUp: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerMove: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerEnter: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onPointerLeave: {
+        type: PropType<(e: GlyphPointerEvent) => void>;
+        default: undefined;
+    };
+    onClick: {
+        type: PropType<(e: GlyphMouseEvent) => void>;
+        default: undefined;
+    };
+    onWheel: {
+        type: PropType<(e: GlyphWheelEvent) => void>;
+        default: undefined;
+    };
 }>> & Readonly<{}>, {
     class: string;
+    onClick: (e: GlyphMouseEvent) => void;
+    onWheel: (e: GlyphWheelEvent) => void;
     id: string;
-    triangles: GlyphcssTriangle[];
+    polygons: Polygon[];
+    geometry: GlyphGeometryName;
+    size: number;
+    color: string;
     position: Vec3;
     scale: number | Vec3;
     rotation: Vec3;
+    onPointerDown: (e: GlyphPointerEvent) => void;
+    onPointerUp: (e: GlyphPointerEvent) => void;
+    onPointerMove: (e: GlyphPointerEvent) => void;
+    onPointerEnter: (e: GlyphPointerEvent) => void;
+    onPointerLeave: (e: GlyphPointerEvent) => void;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssHotspotProps {
+interface GlyphGroundProps {
+    /** Half-extent of the ground plane in world units. Default 5. */
+    size?: number;
+    /** Fill color. Default "#444444". */
+    color?: string;
+    /** World-space position. Default [0, -0.5, 0]. */
+    position?: Vec3;
+    /** World-space rotation in radians (Euler XYZ). */
+    rotation?: Vec3;
+    /** String id forwarded to the underlying mesh handle. */
+    id?: string;
+    class?: string;
+}
+declare const GlyphGround: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: () => Vec3;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    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;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: () => Vec3;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    id: string;
+    size: number;
+    color: string;
+    position: Vec3;
+    rotation: Vec3;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphHotspotProps {
     id: string;
     at: Vec3;
     size?: [number, number];
 }
-declare const GlyphcssHotspot: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphHotspot: vue.DefineComponent<vue.ExtractPropTypes<{
     id: {
         type: StringConstructor;
         required: true;
@@ -191,7 +383,9 @@ declare const GlyphcssHotspot: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<[number, number]>;
         default: undefined;
     };
-}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "click"[], "click", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "click"[], "click", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     id: {
         type: StringConstructor;
         required: true;
@@ -210,22 +404,22 @@ declare const GlyphcssHotspot: vue.DefineComponent<vue.ExtractPropTypes<{
     size: [number, number];
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssSceneContextValue {
-    sceneRef: ShallowRef<GlyphcssSceneHandle | null>;
+interface GlyphSceneContextValue {
+    sceneRef: ShallowRef<GlyphSceneHandle | null>;
 }
-declare const GlyphcssSceneContextKey: InjectionKey<GlyphcssSceneContextValue>;
+declare const GlyphSceneContextKey: InjectionKey<GlyphSceneContextValue>;
 
-declare function useGlyphcssSceneContext(): GlyphcssSceneContextValue;
+declare function useGlyphSceneContext(): GlyphSceneContextValue;
 
-interface GlyphcssPerspectiveCameraProps {
+interface GlyphOrthographicCameraProps {
     rotX?: number;
     rotY?: number;
-    distance?: number;
-    scale?: number;
-    stretch?: number;
+    zoom?: number;
     center?: [number, number];
+    class?: string;
+    style?: CSSProperties | string;
 }
-declare const GlyphcssPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     rotX: {
         type: NumberConstructor;
         default: undefined;
@@ -234,25 +428,25 @@ declare const GlyphcssPerspectiveCamera: vue.DefineComponent<vue.ExtractPropType
         type: NumberConstructor;
         default: undefined;
     };
-    distance: {
+    zoom: {
         type: NumberConstructor;
         default: undefined;
     };
-    scale: {
-        type: NumberConstructor;
+    center: {
+        type: PropType<[number, number]>;
         default: undefined;
     };
-    stretch: {
-        type: NumberConstructor;
+    class: {
+        type: StringConstructor;
         default: undefined;
     };
-    center: {
-        type: PropType<[number, number]>;
+    style: {
+        type: PropType<CSSProperties | string>;
         default: undefined;
     };
 }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
-}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     rotX: {
         type: NumberConstructor;
         default: undefined;
@@ -261,38 +455,42 @@ declare const GlyphcssPerspectiveCamera: vue.DefineComponent<vue.ExtractPropType
         type: NumberConstructor;
         default: undefined;
     };
-    distance: {
+    zoom: {
         type: NumberConstructor;
         default: undefined;
     };
-    scale: {
-        type: NumberConstructor;
+    center: {
+        type: PropType<[number, number]>;
         default: undefined;
     };
-    stretch: {
-        type: NumberConstructor;
+    class: {
+        type: StringConstructor;
         default: undefined;
     };
-    center: {
-        type: PropType<[number, number]>;
+    style: {
+        type: PropType<CSSProperties | string>;
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    scale: number;
+    class: string;
+    style: string | CSSProperties;
     rotX: number;
     rotY: number;
-    distance: number;
-    stretch: number;
+    zoom: number;
     center: [number, number];
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssOrthographicCameraProps {
+interface GlyphPerspectiveCameraProps {
     rotX?: number;
     rotY?: number;
+    distance?: number;
     zoom?: number;
+    stretch?: number;
     center?: [number, number];
+    class?: string;
+    style?: CSSProperties | string;
 }
-declare const GlyphcssOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     rotX: {
         type: NumberConstructor;
         default: undefined;
@@ -301,17 +499,33 @@ declare const GlyphcssOrthographicCamera: vue.DefineComponent<vue.ExtractPropTyp
         type: NumberConstructor;
         default: undefined;
     };
+    distance: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     zoom: {
         type: NumberConstructor;
         default: undefined;
     };
+    stretch: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     center: {
         type: PropType<[number, number]>;
         default: undefined;
     };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties | string>;
+        default: undefined;
+    };
 }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
-}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     rotX: {
         type: NumberConstructor;
         default: undefined;
@@ -320,30 +534,55 @@ declare const GlyphcssOrthographicCamera: vue.DefineComponent<vue.ExtractPropTyp
         type: NumberConstructor;
         default: undefined;
     };
+    distance: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     zoom: {
         type: NumberConstructor;
         default: undefined;
     };
+    stretch: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     center: {
         type: PropType<[number, number]>;
         default: undefined;
     };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties | string>;
+        default: undefined;
+    };
 }>> & Readonly<{}>, {
+    class: string;
+    style: string | CSSProperties;
     rotX: number;
     rotY: number;
-    center: [number, number];
     zoom: number;
+    center: [number, number];
+    distance: number;
+    stretch: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssCameraContextValue {
-    cameraRef: ShallowRef<GlyphcssCamera | null>;
+interface GlyphCameraContextValue {
+    cameraRef: ShallowRef<GlyphCamera | null>;
     rerender: () => void;
+    /**
+     * Set by the child GlyphScene so the camera can trigger rerenders when
+     * props change after the scene is mounted.
+     */
+    sceneRerenderRef: ShallowRef<(() => void) | null>;
 }
-declare const GlyphcssCameraContextKey: InjectionKey<GlyphcssCameraContextValue>;
+declare const GlyphCameraContextKey: InjectionKey<GlyphCameraContextValue>;
 
-declare function useGlyphcssCamera(): GlyphcssCameraContextValue;
+declare function useGlyphCamera(): GlyphCameraContextValue;
 
-interface GlyphcssOrbitControlsProps {
+interface GlyphOrbitControlsProps {
     drag?: boolean;
     wheel?: boolean;
     invert?: boolean | number;
@@ -353,7 +592,7 @@ interface GlyphcssOrbitControlsProps {
         pauseOnInteraction?: boolean;
     };
 }
-declare const GlyphcssOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
     drag: {
         type: BooleanConstructor;
         default: boolean;
@@ -406,7 +645,7 @@ declare const GlyphcssOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssMapControlsProps {
+interface GlyphMapControlsProps {
     drag?: boolean;
     wheel?: boolean;
     invert?: boolean | number;
@@ -416,7 +655,7 @@ interface GlyphcssMapControlsProps {
         pauseOnInteraction?: boolean;
     };
 }
-declare const GlyphcssMapControls: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphMapControls: vue.DefineComponent<vue.ExtractPropTypes<{
     drag: {
         type: BooleanConstructor;
         default: boolean;
@@ -469,14 +708,14 @@ declare const GlyphcssMapControls: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssFirstPersonControlsProps {
+interface GlyphFirstPersonControlsProps {
     drag?: boolean;
     keyboard?: boolean;
     moveSpeed?: number;
     lookSpeed?: number;
     invert?: boolean | number;
 }
-declare const GlyphcssFirstPersonControls: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphFirstPersonControls: vue.DefineComponent<vue.ExtractPropTypes<{
     drag: {
         type: BooleanConstructor;
         default: boolean;
@@ -526,10 +765,10 @@ declare const GlyphcssFirstPersonControls: vue.DefineComponent<vue.ExtractPropTy
     lookSpeed: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssAxesHelperProps {
+interface GlyphAxesHelperProps {
     size?: number;
 }
-declare const GlyphcssAxesHelper: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphAxesHelper: vue.DefineComponent<vue.ExtractPropTypes<{
     size: {
         type: NumberConstructor;
         default: number;
@@ -543,12 +782,12 @@ declare const GlyphcssAxesHelper: vue.DefineComponent<vue.ExtractPropTypes<{
     size: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface GlyphcssDirectionalLightHelperProps {
+interface GlyphDirectionalLightHelperProps {
     position?: Vec3;
     color?: string;
     size?: number;
 }
-declare const GlyphcssDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const GlyphDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTypes<{
     position: {
         type: PropType<Vec3>;
         default: () => number[];
@@ -575,26 +814,26 @@ declare const GlyphcssDirectionalLightHelper: vue.DefineComponent<vue.ExtractPro
         default: number;
     };
 }>> & Readonly<{}>, {
-    position: Vec3;
     size: number;
     color: string;
+    position: Vec3;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface UseGlyphcssAnimationResultVue {
+interface UseGlyphAnimationResultVue {
     /** Attach to a mesh handle when not passing `root` directly. */
-    ref: Ref<GlyphcssAnimationTarget | null>;
+    ref: Ref<GlyphAnimationTarget | null>;
     /** The active mixer, or null if inputs are not ready yet. */
-    mixer: ComputedRef<GlyphcssAnimationMixer | null>;
+    mixer: ComputedRef<GlyphAnimationMixer | null>;
     /** Resolved clip list. */
-    clips: ComputedRef<GlyphcssAnimationClip[]>;
+    clips: ComputedRef<GlyphAnimationClip[]>;
     /** Clip names in input order. */
     names: ComputedRef<string[]>;
     /**
      * Lazy action proxy keyed by clip name. Accessing `actions.value["walk"]`
      * instantiates the action via the mixer. Returns null when mixer is null.
      */
-    actions: ComputedRef<Record<string, GlyphcssAnimationAction | null>>;
+    actions: ComputedRef<Record<string, GlyphAnimationAction | null>>;
 }
-declare function useGlyphcssAnimation(clips: MaybeRef<GlyphcssAnimationClip[] | undefined>, controller: MaybeRef<ParseAnimationController | undefined>, root?: MaybeRef<GlyphcssAnimationTarget | null | undefined>): UseGlyphcssAnimationResultVue;
+declare function useGlyphAnimation(clips: MaybeRef<GlyphAnimationClip[] | undefined>, controller: MaybeRef<ParseAnimationController | undefined>, root?: MaybeRef<GlyphAnimationTarget | null | undefined>): UseGlyphAnimationResultVue;
 
-export { GlyphcssAxesHelper, type GlyphcssAxesHelperProps, GlyphcssPerspectiveCamera as GlyphcssCamera, GlyphcssCameraContextKey, type GlyphcssCameraContextValue, type GlyphcssPerspectiveCameraProps as GlyphcssCameraProps, GlyphcssDirectionalLightHelper, type GlyphcssDirectionalLightHelperProps, GlyphcssFirstPersonControls, type GlyphcssFirstPersonControlsProps, GlyphcssHotspot, type GlyphcssHotspotProps, GlyphcssMapControls, type GlyphcssMapControlsProps, GlyphcssMesh, type GlyphcssMeshProps, GlyphcssOrbitControls, type GlyphcssOrbitControlsProps, GlyphcssOrthographicCamera, type GlyphcssOrthographicCameraProps, GlyphcssPerspectiveCamera, type GlyphcssPerspectiveCameraProps, GlyphcssScene, GlyphcssSceneContextKey, type GlyphcssSceneContextValue, type GlyphcssSceneProps, type UseGlyphcssAnimationResultVue, useGlyphcssAnimation, useGlyphcssCamera, useGlyphcssSceneContext };
+export { GlyphAxesHelper, type GlyphAxesHelperProps, GlyphOrthographicCamera as GlyphCamera, GlyphCameraContextKey, type GlyphCameraContextValue, type GlyphOrthographicCameraProps as GlyphCameraProps, GlyphDirectionalLightHelper, type GlyphDirectionalLightHelperProps, GlyphFirstPersonControls, type GlyphFirstPersonControlsProps, GlyphGround, type GlyphGroundProps, GlyphHotspot, type GlyphHotspotProps, GlyphMapControls, type GlyphMapControlsProps, GlyphMesh, type GlyphMeshProps, GlyphOrbitControls, type GlyphOrbitControlsProps, GlyphOrthographicCamera, type GlyphOrthographicCameraProps, GlyphPerspectiveCamera, type GlyphPerspectiveCameraProps, GlyphScene, GlyphSceneContextKey, type GlyphSceneContextValue, type GlyphSceneProps, type UseGlyphAnimationResultVue, useGlyphAnimation, useGlyphCamera, useGlyphSceneContext };