@glyphcss/vue 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,600 @@
+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 * 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';
+
+interface GlyphcssSceneProps {
+    mode?: RenderMode;
+    glyphPalette?: string;
+    useColors?: boolean;
+    cols?: number;
+    rows?: number;
+    cellAspect?: number;
+    directionalLight?: GlyphcssDirectionalLight;
+    ambientLight?: GlyphcssAmbientLight;
+    class?: string;
+}
+declare const GlyphcssScene: vue.DefineComponent<vue.ExtractPropTypes<{
+    mode: {
+        type: PropType<RenderMode>;
+        default: undefined;
+    };
+    glyphPalette: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    useColors: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    cols: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    cellAspect: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    directionalLight: {
+        type: PropType<GlyphcssDirectionalLight>;
+        default: undefined;
+    };
+    ambientLight: {
+        type: PropType<GlyphcssAmbientLight>;
+        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<{
+    mode: {
+        type: PropType<RenderMode>;
+        default: undefined;
+    };
+    glyphPalette: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    useColors: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    cols: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    cellAspect: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    directionalLight: {
+        type: PropType<GlyphcssDirectionalLight>;
+        default: undefined;
+    };
+    ambientLight: {
+        type: PropType<GlyphcssAmbientLight>;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    mode: RenderMode;
+    glyphPalette: string;
+    useColors: boolean;
+    cols: number;
+    rows: number;
+    cellAspect: number;
+    directionalLight: GlyphcssDirectionalLight;
+    ambientLight: GlyphcssAmbientLight;
+    class: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssMeshProps {
+    id?: string;
+    triangles?: GlyphcssTriangle[];
+    position?: Vec3;
+    scale?: number | Vec3;
+    rotation?: Vec3;
+    class?: string;
+}
+declare const GlyphcssMesh: vue.DefineComponent<vue.ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    triangles: {
+        type: PropType<GlyphcssTriangle[]>;
+        default: () => never[];
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        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<{
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    triangles: {
+        type: PropType<GlyphcssTriangle[]>;
+        default: () => never[];
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    id: string;
+    triangles: GlyphcssTriangle[];
+    position: Vec3;
+    scale: number | Vec3;
+    rotation: Vec3;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssHotspotProps {
+    id: string;
+    at: Vec3;
+    size?: [number, number];
+}
+declare const GlyphcssHotspot: vue.DefineComponent<vue.ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    at: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: PropType<[number, number]>;
+        default: undefined;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "click"[], "click", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    at: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: PropType<[number, number]>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: [number, number];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssSceneContextValue {
+    sceneRef: ShallowRef<GlyphcssSceneHandle | null>;
+}
+declare const GlyphcssSceneContextKey: InjectionKey<GlyphcssSceneContextValue>;
+
+declare function useGlyphcssSceneContext(): GlyphcssSceneContextValue;
+
+interface GlyphcssPerspectiveCameraProps {
+    rotX?: number;
+    rotY?: number;
+    distance?: number;
+    scale?: number;
+    stretch?: number;
+    center?: [number, number];
+}
+declare const GlyphcssPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+    rotX: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    rotY: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    distance: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    scale: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    stretch: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    center: {
+        type: PropType<[number, number]>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    rotX: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    rotY: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    distance: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    scale: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    stretch: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    center: {
+        type: PropType<[number, number]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    scale: number;
+    rotX: number;
+    rotY: number;
+    distance: number;
+    stretch: number;
+    center: [number, number];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssOrthographicCameraProps {
+    rotX?: number;
+    rotY?: number;
+    zoom?: number;
+    center?: [number, number];
+}
+declare const GlyphcssOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+    rotX: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    rotY: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    zoom: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    center: {
+        type: PropType<[number, number]>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    rotX: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    rotY: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    zoom: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    center: {
+        type: PropType<[number, number]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    rotX: number;
+    rotY: number;
+    center: [number, number];
+    zoom: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssCameraContextValue {
+    cameraRef: ShallowRef<GlyphcssCamera | null>;
+    rerender: () => void;
+}
+declare const GlyphcssCameraContextKey: InjectionKey<GlyphcssCameraContextValue>;
+
+declare function useGlyphcssCamera(): GlyphcssCameraContextValue;
+
+interface GlyphcssOrbitControlsProps {
+    drag?: boolean;
+    wheel?: boolean;
+    invert?: boolean | number;
+    animate?: false | {
+        speed?: number;
+        axis?: "x" | "y";
+        pauseOnInteraction?: boolean;
+    };
+}
+declare const GlyphcssOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: () => boolean | number;
+        default: boolean;
+    };
+    animate: {
+        type: () => false | {
+            speed?: number;
+            axis?: "x" | "y";
+            pauseOnInteraction?: boolean;
+        };
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: () => boolean | number;
+        default: boolean;
+    };
+    animate: {
+        type: () => false | {
+            speed?: number;
+            axis?: "x" | "y";
+            pauseOnInteraction?: boolean;
+        };
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    drag: boolean;
+    wheel: boolean;
+    invert: number | boolean;
+    animate: false | {
+        speed?: number;
+        axis?: "x" | "y";
+        pauseOnInteraction?: boolean;
+    };
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssMapControlsProps {
+    drag?: boolean;
+    wheel?: boolean;
+    invert?: boolean | number;
+    animate?: false | {
+        speed?: number;
+        axis?: "x" | "y";
+        pauseOnInteraction?: boolean;
+    };
+}
+declare const GlyphcssMapControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: () => boolean | number;
+        default: boolean;
+    };
+    animate: {
+        type: () => false | {
+            speed?: number;
+            axis?: "x" | "y";
+            pauseOnInteraction?: boolean;
+        };
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: () => boolean | number;
+        default: boolean;
+    };
+    animate: {
+        type: () => false | {
+            speed?: number;
+            axis?: "x" | "y";
+            pauseOnInteraction?: boolean;
+        };
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    drag: boolean;
+    wheel: boolean;
+    invert: number | boolean;
+    animate: false | {
+        speed?: number;
+        axis?: "x" | "y";
+        pauseOnInteraction?: boolean;
+    };
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssFirstPersonControlsProps {
+    drag?: boolean;
+    keyboard?: boolean;
+    moveSpeed?: number;
+    lookSpeed?: number;
+    invert?: boolean | number;
+}
+declare const GlyphcssFirstPersonControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveSpeed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lookSpeed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    invert: {
+        type: () => boolean | number;
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveSpeed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lookSpeed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    invert: {
+        type: () => boolean | number;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    drag: boolean;
+    invert: number | boolean;
+    keyboard: boolean;
+    moveSpeed: number;
+    lookSpeed: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssAxesHelperProps {
+    size?: number;
+}
+declare const GlyphcssAxesHelper: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface GlyphcssDirectionalLightHelperProps {
+    position?: Vec3;
+    color?: string;
+    size?: number;
+}
+declare const GlyphcssDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTypes<{
+    position: {
+        type: PropType<Vec3>;
+        default: () => number[];
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    position: {
+        type: PropType<Vec3>;
+        default: () => number[];
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    position: Vec3;
+    size: number;
+    color: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface UseGlyphcssAnimationResultVue {
+    /** Attach to a mesh handle when not passing `root` directly. */
+    ref: Ref<GlyphcssAnimationTarget | null>;
+    /** The active mixer, or null if inputs are not ready yet. */
+    mixer: ComputedRef<GlyphcssAnimationMixer | null>;
+    /** Resolved clip list. */
+    clips: ComputedRef<GlyphcssAnimationClip[]>;
+    /** 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>>;
+}
+declare function useGlyphcssAnimation(clips: MaybeRef<GlyphcssAnimationClip[] | undefined>, controller: MaybeRef<ParseAnimationController | undefined>, root?: MaybeRef<GlyphcssAnimationTarget | null | undefined>): UseGlyphcssAnimationResultVue;
+
+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 };

package/dist/index.js

@@ -0,0 +1 @@
+import{CAMERA_BACKFACE_CULL_EPS as Ns,VOXEL_CAMERA_CULL_AXIS_EPS as zs,VOXEL_CAMERA_CULL_NORMAL_LIMIT as Ks,normalizePolygons as Xs,mergePolygons as Ys,coverPlanarPolygons as _s,optimizeMeshPolygons as Ds,cullInteriorPolygons as Is,cameraCullNormalGroups as Us,cameraCullNormalGroupsFromPolygons as qs,cameraCullNormalKey as $s,cameraCullVisibleSignature as Js,cameraFacingDepth as Ws,isAxisAlignedSurfaceNormal as Qs,isVoxelCameraCullableNormalGroups as Zs,normalFacesCamera as eo,polygonCssSurfaceNormal as to,polygonFacesCamera as so,parseObj as oo,parseMtl as no,parseGltf as ro,bakeSolidTextureSamples as lo,bakeSolidTextureSampledPolygons as ao,loadMesh as co,createIsometricCamera as io,parseVox as po,polygonFaces as uo,computeShapeLighting as mo,parseColor as yo,parsePureColor as ho,parseHexColor as fo,parseRgbColor as Go,formatColor as Co,clampChannel as go,shadeColor as vo,rotateVec3 as bo,inverseRotateVec3 as xo,axesHelperPolygons as Po,arrowPolygons as Ao,ringPolygons as So,octahedronPolygons as wo,buildSceneContext as Ro,computeSceneBbox as Oo,BASE_TILE as Mo,DEFAULT_CAMERA_STATE as Lo,DEFAULT_PROJECTION as To,normalizeInvertMultiplier as Ho,createGlyphcssAnimationMixer as Vo,LoopOnce as ko,LoopRepeat as jo,LoopPingPong as Bo}from"@glyphcss/core";import{defineComponent as X,h as Y,provide as _,shallowRef as k,onMounted as D,onBeforeUnmount as I,watch as U}from"vue";import{createGlyphcssScene as q,injectGlyphcssBaseStyles as $}from"glyphcss";var i=Symbol("glyphcss-scene");var x=X({name:"GlyphcssScene",inheritAttrs:!1,props:{mode:{type:String,default:void 0},glyphPalette:{type:String,default:void 0},useColors:{type:Boolean,default:void 0},cols:{type:Number,default:void 0},rows:{type:Number,default:void 0},cellAspect:{type:Number,default:void 0},directionalLight:{type:Object,default:void 0},ambientLight:{type:Object,default:void 0},class:{type:String,default:void 0}},setup(e,{slots:a,attrs:c}){let n=k(null),s=k(null);return _(i,{sceneRef:s}),D(()=>{let o=n.value;if(!o)return;$(o.ownerDocument??void 0);let t={};e.mode!==void 0&&(t.mode=e.mode),e.glyphPalette!==void 0&&(t.glyphPalette=e.glyphPalette),e.useColors!==void 0&&(t.useColors=e.useColors),e.cols!==void 0&&(t.cols=e.cols),e.rows!==void 0&&(t.rows=e.rows),e.cellAspect!==void 0&&(t.cellAspect=e.cellAspect),e.directionalLight!==void 0&&(t.directionalLight=e.directionalLight),e.ambientLight!==void 0&&(t.ambientLight=e.ambientLight),s.value=q(o,t)}),I(()=>{s.value?.destroy(),s.value=null}),U(()=>({mode:e.mode,glyphPalette:e.glyphPalette,useColors:e.useColors,cols:e.cols,rows:e.rows,cellAspect:e.cellAspect,directionalLight:e.directionalLight,ambientLight:e.ambientLight}),o=>{let t=s.value;if(!t)return;let r={};o.mode!==void 0&&(r.mode=o.mode),o.glyphPalette!==void 0&&(r.glyphPalette=o.glyphPalette),o.useColors!==void 0&&(r.useColors=o.useColors),o.cols!==void 0&&(r.cols=o.cols),o.rows!==void 0&&(r.rows=o.rows),o.cellAspect!==void 0&&(r.cellAspect=o.cellAspect),o.directionalLight!==void 0&&(r.directionalLight=o.directionalLight),o.ambientLight!==void 0&&(r.ambientLight=o.ambientLight),Object.keys(r).length>0&&t.setOptions(r)},{deep:!1}),()=>{let o=`glyphcss-host${e.class?` ${e.class}`:""}`;return Y("div",{ref:n,class:o,...Object.fromEntries(Object.entries(c).filter(([t])=>t!=="class"))},a.default?.())}}});import{defineComponent as J,h as W,inject as Q,onMounted as Z,onBeforeUnmount as ee,watch as j,shallowRef as te}from"vue";var P=J({name:"GlyphcssMesh",props:{id:{type:String,default:void 0},triangles:{type:Array,default:()=>[]},position:{type:Array,default:void 0},scale:{type:[Number,Array],default:void 0},rotation:{type:Array,default:void 0},class:{type:String,default:void 0}},setup(e,{slots:a}){let c=Q(i);if(!c)throw new Error("glyphcss: GlyphcssMesh must be used inside a GlyphcssScene.");let{sceneRef:n}=c,s=te(null);function o(){let l={};return e.position&&(l.position=e.position),e.scale!==void 0&&(l.scale=e.scale),e.rotation&&(l.rotation=e.rotation),l}function t(){let l=n.value;if(!l)return;let m=l.add(e.triangles??[],o());s.value=m}function r(){s.value?.dispose(),s.value=null}return Z(t),ee(r),j(()=>e.triangles,()=>{r(),t()}),j(()=>({position:e.position,scale:e.scale,rotation:e.rotation}),()=>{let l=s.value;l&&(l.setTransform(o()),n.value?.rerender())},{deep:!1}),()=>{let l=`glyphcss-mesh${e.class?` ${e.class}`:""}`;return W("div",{"data-glyphcss-mesh-id":e.id,class:l},a.default?.())}}});import{defineComponent as se,inject as oe,onMounted as ne,onBeforeUnmount as re,watch as le,shallowRef as ae}from"vue";var A=se({name:"GlyphcssHotspot",props:{id:{type:String,required:!0},at:{type:Array,required:!0},size:{type:Array,default:void 0}},emits:["click"],setup(e,{emit:a}){let c=oe(i);if(!c)throw new Error("glyphcss: GlyphcssHotspot must be used inside a GlyphcssScene.");let{sceneRef:n}=c,s=ae(null);function o(){let r=n.value;if(!r)return;let l=r.addHotspot({id:e.id,at:e.at,size:e.size},()=>a("click"));s.value=l}function t(){s.value?.remove(),s.value=null}return ne(o),re(t),le(()=>({id:e.id,at:e.at,size:e.size}),()=>{t(),o()},{deep:!1}),()=>null}});import{inject as ce}from"vue";function S(){let e=ce(i);if(!e)throw new Error("glyphcss: must be used inside a GlyphcssScene.");return e}import{defineComponent as ie,inject as pe,provide as ue,shallowRef as me,watch as ye,onMounted as he}from"vue";import{createGlyphcssPerspectiveCamera as fe}from"glyphcss";var f=Symbol("glyphcss-camera");var G=ie({name:"GlyphcssPerspectiveCamera",props:{rotX:{type:Number,default:void 0},rotY:{type:Number,default:void 0},distance:{type:Number,default:void 0},scale:{type:Number,default:void 0},stretch:{type:Number,default:void 0},center:{type:Array,default:void 0}},setup(e,{slots:a}){let c=pe(i);if(!c)throw new Error("glyphcss: GlyphcssPerspectiveCamera must be used inside a GlyphcssScene.");let{sceneRef:n}=c,s=me(null);function o(){n.value?.rerender()}return ue(f,{cameraRef:s,rerender:o}),he(()=>{let t={};e.rotX!==void 0&&(t.rotX=e.rotX),e.rotY!==void 0&&(t.rotY=e.rotY),e.distance!==void 0&&(t.distance=e.distance),e.scale!==void 0&&(t.scale=e.scale),e.stretch!==void 0&&(t.stretch=e.stretch),e.center!==void 0&&(t.center=e.center);let r=fe(t);s.value=r;let l=n.value;l&&(l.setOptions({camera:r}),l.rerender())}),ye(()=>({rotX:e.rotX,rotY:e.rotY,distance:e.distance,scale:e.scale,stretch:e.stretch}),t=>{let r=s.value;if(!r)return;let l=!1;t.rotX!==void 0&&r.rotX!==t.rotX&&(r.rotX=t.rotX,l=!0),t.rotY!==void 0&&r.rotY!==t.rotY&&(r.rotY=t.rotY,l=!0),t.distance!==void 0&&r.distance!==t.distance&&(r.distance=t.distance,l=!0),t.scale!==void 0&&r.scale!==t.scale&&(r.scale=t.scale,l=!0),t.stretch!==void 0&&r.stretch!==t.stretch&&(r.stretch=t.stretch,l=!0),l&&n.value?.rerender()}),()=>a.default?.()??null}});import{defineComponent as de,inject as Ge,provide as Ce,shallowRef as ge,watch as ve,onMounted as be}from"vue";import{createGlyphcssOrthographicCamera as xe}from"glyphcss";var w=de({name:"GlyphcssOrthographicCamera",props:{rotX:{type:Number,default:void 0},rotY:{type:Number,default:void 0},zoom:{type:Number,default:void 0},center:{type:Array,default:void 0}},setup(e,{slots:a}){let c=Ge(i);if(!c)throw new Error("glyphcss: GlyphcssOrthographicCamera must be used inside a GlyphcssScene.");let{sceneRef:n}=c,s=ge(null);function o(){n.value?.rerender()}return Ce(f,{cameraRef:s,rerender:o}),be(()=>{let t={};e.rotX!==void 0&&(t.rotX=e.rotX),e.rotY!==void 0&&(t.rotY=e.rotY),e.zoom!==void 0&&(t.zoom=e.zoom),e.center!==void 0&&(t.center=e.center);let r=xe(t);s.value=r;let l=n.value;l&&(l.setOptions({camera:r}),l.rerender())}),ve(()=>({rotX:e.rotX,rotY:e.rotY,zoom:e.zoom}),t=>{let r=s.value;if(!r)return;let l=!1;t.rotX!==void 0&&r.rotX!==t.rotX&&(r.rotX=t.rotX,l=!0),t.rotY!==void 0&&r.rotY!==t.rotY&&(r.rotY=t.rotY,l=!0),t.zoom!==void 0&&r.scale!==t.zoom&&(r.scale=t.zoom,l=!0),l&&n.value?.rerender()}),()=>a.default?.()??null}});import{inject as Pe}from"vue";function R(){let e=Pe(f);if(!e)throw new Error("glyphcss: useGlyphcssCamera must be used inside a GlyphcssCamera component.");return e}import{defineComponent as Ae,inject as Se,onMounted as we,onBeforeUnmount as Re,watch as Oe,shallowRef as Me}from"vue";import{createGlyphcssOrbitControls as Le}from"glyphcss";var O=Ae({name:"GlyphcssOrbitControls",props:{drag:{type:Boolean,default:!0},wheel:{type:Boolean,default:!0},invert:{type:[Boolean,Number],default:!1},animate:{type:[Boolean,Object],default:!1}},setup(e){let a=Se(i);if(!a)throw new Error("glyphcss: GlyphcssOrbitControls must be used inside a GlyphcssScene.");let{sceneRef:c}=a,n=Me(null);return we(()=>{let s=c.value;if(!s)return;let o={drag:e.drag,wheel:e.wheel,invert:e.invert,animate:e.animate===!1?!1:e.animate};n.value=Le(s,o)}),Re(()=>{n.value?.destroy(),n.value=null}),Oe(()=>({drag:e.drag,wheel:e.wheel,invert:e.invert,animate:e.animate}),s=>{n.value?.update({drag:s.drag,wheel:s.wheel,invert:s.invert,animate:s.animate===!1?!1:s.animate})}),()=>null}});import{defineComponent as Te,inject as He,onMounted as Ve,onBeforeUnmount as ke,watch as je,shallowRef as Be}from"vue";import{createGlyphcssMapControls as Ee}from"glyphcss";var M=Te({name:"GlyphcssMapControls",props:{drag:{type:Boolean,default:!0},wheel:{type:Boolean,default:!0},invert:{type:[Boolean,Number],default:!1},animate:{type:[Boolean,Object],default:!1}},setup(e){let a=He(i);if(!a)throw new Error("glyphcss: GlyphcssMapControls must be used inside a GlyphcssScene.");let{sceneRef:c}=a,n=Be(null);return Ve(()=>{let s=c.value;if(!s)return;let o={drag:e.drag,wheel:e.wheel,invert:e.invert,animate:e.animate===!1?!1:e.animate};n.value=Ee(s,o)}),ke(()=>{n.value?.destroy(),n.value=null}),je(()=>({drag:e.drag,wheel:e.wheel,invert:e.invert,animate:e.animate}),s=>{n.value?.update({drag:s.drag,wheel:s.wheel,invert:s.invert,animate:s.animate===!1?!1:s.animate})}),()=>null}});import{defineComponent as Fe,inject as Ne,onMounted as ze,onBeforeUnmount as Ke,watch as Xe,shallowRef as Ye}from"vue";import{createGlyphcssFirstPersonControls as _e}from"glyphcss";var L=Fe({name:"GlyphcssFirstPersonControls",props:{drag:{type:Boolean,default:!0},keyboard:{type:Boolean,default:!0},moveSpeed:{type:Number,default:.05},lookSpeed:{type:Number,default:.004},invert:{type:[Boolean,Number],default:!1}},setup(e){let a=Ne(i);if(!a)throw new Error("glyphcss: GlyphcssFirstPersonControls must be used inside a GlyphcssScene.");let{sceneRef:c}=a,n=Ye(null);return ze(()=>{let s=c.value;if(!s)return;let o={drag:e.drag,keyboard:e.keyboard,moveSpeed:e.moveSpeed,lookSpeed:e.lookSpeed,invert:e.invert};n.value=_e(s,o)}),Ke(()=>{n.value?.destroy(),n.value=null}),Xe(()=>({drag:e.drag,keyboard:e.keyboard,moveSpeed:e.moveSpeed,lookSpeed:e.lookSpeed,invert:e.invert}),s=>{n.value?.update(s)}),()=>null}});import{defineComponent as De,inject as Ie,onMounted as Ue,onBeforeUnmount as qe,watch as $e,computed as Je,shallowRef as We}from"vue";function Qe(e){let a=e,c=a*.05,n=[];function s(o,t,r){let l=[o[0]-c,o[1]-c,o[2]],m=[t[0]-c,t[1]-c,t[2]],y=[t[0]+c,t[1]+c,t[2]],d=[o[0]+c,o[1]+c,o[2]];n.push({vertices:[l,m,y],color:r}),n.push({vertices:[l,y,d],color:r})}return s([0,0,0],[a,0,0],"#ff0000"),s([0,0,0],[0,a,0],"#00ff00"),s([0,0,0],[0,0,a],"#0000ff"),n}var T=De({name:"GlyphcssAxesHelper",props:{size:{type:Number,default:1}},setup(e){let a=Ie(i);if(!a)throw new Error("glyphcss: GlyphcssAxesHelper must be used inside a GlyphcssScene.");let{sceneRef:c}=a,n=We(null),s=Je(()=>Qe(e.size??1));function o(){let t=c.value;t&&(n.value=t.add(s.value))}return Ue(o),qe(()=>{n.value?.dispose(),n.value=null}),$e(s,()=>{n.value?.dispose(),n.value=null,o()}),()=>null}});import{defineComponent as Ze,inject as et,onMounted as tt,onBeforeUnmount as st,watch as ot,computed as nt,shallowRef as rt}from"vue";function lt(e,a,c){let[n,s,o]=e,t=c,r=[n,s,o+t],l=[n,s,o-t],m=[n+t,s,o],y=[n-t,s,o],d=[n,s+t,o],g=[n,s-t,o];return[{vertices:[r,m,d],color:a},{vertices:[r,d,y],color:a},{vertices:[r,y,g],color:a},{vertices:[r,g,m],color:a},{vertices:[l,d,m],color:a},{vertices:[l,y,d],color:a},{vertices:[l,g,y],color:a},{vertices:[l,m,g],color:a}]}var H=Ze({name:"GlyphcssDirectionalLightHelper",props:{position:{type:Array,default:()=>[1,1,1]},color:{type:String,default:"#ffff00"},size:{type:Number,default:.1}},setup(e){let a=et(i);if(!a)throw new Error("glyphcss: GlyphcssDirectionalLightHelper must be used inside a GlyphcssScene.");let{sceneRef:c}=a,n=rt(null),s=nt(()=>lt(e.position??[1,1,1],e.color??"#ffff00",e.size??.1));function o(){let t=c.value;t&&(n.value=t.add(s.value))}return tt(o),st(()=>{n.value?.dispose(),n.value=null}),ot(s,()=>{n.value?.dispose(),n.value=null,o()}),()=>null}});import{injectGlyphcssBaseStyles as B}from"glyphcss";import{ref as E,watch as at,onUnmounted as ct,computed as v}from"vue";import{createGlyphcssAnimationMixer as it}from"@glyphcss/core";function C(e){return e&&typeof e=="object"&&"value"in e?e.value:e}function V(e,a,c){let n=E(null),s=null,o=null,t=null,r=E(0);function l(){return c==null?n.value:C(c)??n.value}function m(){o!==null&&(cancelAnimationFrame(o),o=null),t=null}function y(){m(),s&&(s.stopAllAction(),s.uncacheRoot(),s=null,r.value++)}function d(){if(o!==null)return;function p(u){if(t===null){t=u,o=requestAnimationFrame(p);return}let h=(u-t)/1e3;t=u,s?.update(h),o=requestAnimationFrame(p)}o=requestAnimationFrame(p)}function g(){y();let p=C(e),u=C(a);if(!p||p.length===0||!u)return;let h=l();h&&(s=it(h,u),r.value++,d())}let F=at(()=>{let p=C(e),u=C(a),h=c!=null?C(c):n.value;return{c:p,ctrl:u,r:h}},()=>g(),{immediate:!0,deep:!1});ct(()=>{F(),y()});let b=v(()=>C(e)??[]),N=v(()=>b.value.map(p=>p.name)),z=v(()=>(r.value,s)),K=v(()=>{r.value;let p=b.value,u={};for(let h of p)Object.defineProperty(u,h.name,{enumerable:!0,get(){if(!s)return null;try{return s.clipAction(h.name)}catch{return null}}});return u});return{ref:n,mixer:z,clips:b,names:N,actions:K}}export{Mo as BASE_TILE,Ns as CAMERA_BACKFACE_CULL_EPS,Lo as DEFAULT_CAMERA_STATE,To as DEFAULT_PROJECTION,T as GlyphcssAxesHelper,G as GlyphcssCamera,f as GlyphcssCameraContextKey,H as GlyphcssDirectionalLightHelper,L as GlyphcssFirstPersonControls,A as GlyphcssHotspot,M as GlyphcssMapControls,P as GlyphcssMesh,O as GlyphcssOrbitControls,w as GlyphcssOrthographicCamera,G as GlyphcssPerspectiveCamera,x as GlyphcssScene,i as GlyphcssSceneContextKey,ko as LoopOnce,Bo as LoopPingPong,jo as LoopRepeat,zs as VOXEL_CAMERA_CULL_AXIS_EPS,Ks as VOXEL_CAMERA_CULL_NORMAL_LIMIT,Ao as arrowPolygons,Po as axesHelperPolygons,ao as bakeSolidTextureSampledPolygons,lo as bakeSolidTextureSamples,Ro as buildSceneContext,Us as cameraCullNormalGroups,qs as cameraCullNormalGroupsFromPolygons,$s as cameraCullNormalKey,Js as cameraCullVisibleSignature,Ws as cameraFacingDepth,go as clampChannel,Oo as computeSceneBbox,mo as computeShapeLighting,_s as coverPlanarPolygons,Vo as createGlyphcssAnimationMixer,io as createIsometricCamera,Is as cullInteriorPolygons,Co as formatColor,B as injectGlyphcssBaseStyles,xo as inverseRotateVec3,Qs as isAxisAlignedSurfaceNormal,Zs as isVoxelCameraCullableNormalGroups,co as loadMesh,Ys as mergePolygons,eo as normalFacesCamera,Ho as normalizeInvertMultiplier,Xs as normalizePolygons,wo as octahedronPolygons,Ds as optimizeMeshPolygons,yo as parseColor,ro as parseGltf,fo as parseHexColor,no as parseMtl,oo as parseObj,ho as parsePureColor,Go as parseRgbColor,po as parseVox,to as polygonCssSurfaceNormal,uo as polygonFaces,so as polygonFacesCamera,So as ringPolygons,bo as rotateVec3,vo as shadeColor,V as useGlyphcssAnimation,R as useGlyphcssCamera,S as useGlyphcssSceneContext};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@glyphcss/vue",
+  "version": "0.0.1",
+  "description": "Native Vue 3 components for the glyphcss ASCII polygon mesh rendering engine.",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "glyphcss",
+    "ascii",
+    "polygon",
+    "mesh",
+    "3d",
+    "dom",
+    "vue",
+    "vue3",
+    "rendering"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apresmoi/glyphcss.git",
+    "directory": "packages/vue"
+  },
+  "bugs": {
+    "url": "https://github.com/apresmoi/glyphcss/issues"
+  },
+  "homepage": "https://github.com/apresmoi/glyphcss#readme",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@glyphcss/core": "^0.0.1",
+    "glyphcss": "^0.0.1"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
+    "happy-dom": "^20.8.9",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.12"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}