@shjjs/visual-ui 1.0.0

package/es/components/commons-three-loader3/index.d.ts

@@ -0,0 +1,60 @@
+export declare const ZvCommonsThreeLoader3: import("../../utils/typescript").SFCWithInstall<import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}, {
+    props: any;
+    emit: (event: "on-load-success" | "on-play-animation", ...args: any[]) => void;
+    engine: import("@babylonjs/core").Engine;
+    scene: import("@babylonjs/core").Scene;
+    camera: import("@babylonjs/core").ArcRotateCamera;
+    directionalLight: import("@babylonjs/core").DirectionalLight;
+    directionalLightGizmo: import("@babylonjs/core").LightGizmo;
+    shadowGenerator: import("@babylonjs/core").ShadowGenerator;
+    hemisphericLight: import("@babylonjs/core").HemisphericLight;
+    hemisphericLightGizmo: import("@babylonjs/core").LightGizmo;
+    ground: import("@babylonjs/core").GroundMesh;
+    skybox: import("@babylonjs/core").Mesh;
+    meshes: import("@babylonjs/core").AbstractMesh[];
+    defaultPipeline: import("@babylonjs/core").DefaultRenderingPipeline;
+    setCamera: () => void;
+    setScene: () => void;
+    setDirectionalLight: () => void;
+    setHemisphericLight: () => void;
+    setGround: () => void;
+    setSkybox: () => void;
+    playAnimation: (name: string, option?: {
+        loop: boolean;
+        speedRatio: number;
+    }) => void;
+    setMeshes: () => Promise<void>;
+    setPipeline: () => void;
+    createScene: (engine: any) => void;
+    canvasRef: import("vue").Ref<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("on-load-success" | "on-play-animation")[], "on-load-success" | "on-play-animation", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}>> & {
+    "onOn-load-success"?: (...args: any[]) => any;
+    "onOn-play-animation"?: (...args: any[]) => any;
+}, {}, {}>> & Record<string, any>;
+export default ZvCommonsThreeLoader3;

package/es/components/commons-three-loader3/index.mjs

@@ -0,0 +1,7 @@
+import o from "./index.vue.mjs";
+import { withInstall as r } from "../../utils/install.mjs";
+const a = r(o);
+export {
+  a as ZvCommonsThreeLoader3,
+  a as default
+};

package/es/components/commons-three-loader3/index.vue.d.ts

@@ -0,0 +1,61 @@
+import * as BABYLON from '@babylonjs/core';
+declare const _sfc_main: import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}, {
+    props: any;
+    emit: (event: "on-load-success" | "on-play-animation", ...args: any[]) => void;
+    engine: BABYLON.Engine;
+    scene: BABYLON.Scene;
+    camera: BABYLON.ArcRotateCamera;
+    directionalLight: BABYLON.DirectionalLight;
+    directionalLightGizmo: BABYLON.LightGizmo;
+    shadowGenerator: BABYLON.ShadowGenerator;
+    hemisphericLight: BABYLON.HemisphericLight;
+    hemisphericLightGizmo: BABYLON.LightGizmo;
+    ground: BABYLON.GroundMesh;
+    skybox: BABYLON.Mesh;
+    meshes: BABYLON.AbstractMesh[];
+    defaultPipeline: BABYLON.DefaultRenderingPipeline;
+    setCamera: () => void;
+    setScene: () => void;
+    setDirectionalLight: () => void;
+    setHemisphericLight: () => void;
+    setGround: () => void;
+    setSkybox: () => void;
+    playAnimation: (name: string, option?: {
+        loop: boolean;
+        speedRatio: number;
+    }) => void;
+    setMeshes: () => Promise<void>;
+    setPipeline: () => void;
+    createScene: (engine: any) => void;
+    canvasRef: import("vue").Ref<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("on-load-success" | "on-play-animation")[], "on-load-success" | "on-play-animation", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}>> & {
+    "onOn-load-success"?: (...args: any[]) => any;
+    "onOn-play-animation"?: (...args: any[]) => any;
+}, {}, {}>;
+export default _sfc_main;

package/es/components/commons-three-loader3/index.vue.mjs

@@ -0,0 +1,7 @@
+import o from "./index.vue2.mjs";
+/* empty css            */
+import t from "../../_virtual/_plugin-vue_export-helper.mjs";
+const c = /* @__PURE__ */ t(o, [["__scopeId", "data-v-1bbc8faf"]]);
+export {
+  c as default
+};

package/es/components/commons-three-loader3/index.vue2.mjs

@@ -0,0 +1,202 @@
+import { defineComponent as z, ref as H, onMounted as q, onBeforeUnmount as K, watch as m, openBlock as N, createElementBlock as J, createElementVNode as W, normalizeClass as Y } from "vue";
+import "@babylonjs/loaders/glTF";
+import * as t from "@babylonjs/core";
+import { cloneDeep as b, isEqual as u } from "lodash";
+import { hex2Color4 as U, hex2Color3 as A } from "../../utils/babylon/ColorConvert.mjs";
+const X = { class: "zerov-widget" }, j = z({ name: "zv-commons-three-loader3" }), te = /* @__PURE__ */ z({
+  ...j,
+  props: {
+    basicOption: {},
+    basicEvents: {},
+    useEvents: {}
+  },
+  emits: [
+    "on-load-success",
+    "on-play-animation"
+  ],
+  setup(V, { expose: P, emit: _ }) {
+    const e = V, E = _;
+    let v, o, s, p, f, l, L, O, d, g, r, n;
+    const B = () => {
+      s || (s = new t.ArcRotateCamera(
+        "Camera",
+        e.basicOption.camera.alpha,
+        e.basicOption.camera.beta,
+        e.basicOption.camera.radius,
+        new t.Vector3(
+          e.basicOption.camera.target[0],
+          e.basicOption.camera.target[1],
+          e.basicOption.camera.target[2]
+        ),
+        o
+      )), s.alpha = e.basicOption.camera.alpha, s.beta = e.basicOption.camera.beta, s.radius = e.basicOption.camera.radius, s.target = new t.Vector3(
+        e.basicOption.camera.target[0],
+        e.basicOption.camera.target[1],
+        e.basicOption.camera.target[2]
+      ), s.lowerRadiusLimit = e.basicOption.camera.lowerRadiusLimit, s.upperRadiusLimit = e.basicOption.camera.upperRadiusLimit, s.lowerBetaLimit = t.Tools.ToRadians(e.basicOption.camera.lowerBetaLimit), s.upperBetaLimit = t.Tools.ToRadians(e.basicOption.camera.upperBetaLimit), s.useBouncingBehavior = e.basicOption.camera.useBouncingBehavior, s.wheelDeltaPercentage = e.basicOption.camera.wheelDeltaPercentage || 0.01, s.useAutoRotationBehavior = e.basicOption.camera.autoRotation, s.attachControl(y.value, !0);
+    }, S = () => {
+      o || (o = new t.Scene(v)), o.environmentTexture = t.CubeTexture.CreateFromPrefilteredData(e.basicOption.scene.environmentTexture, o), o.environmentIntensity = e.basicOption.scene.environmentIntensity, e.basicOption.scene.colorShow ? o.clearColor = U(e.basicOption.scene.color, new t.Color4(1, 1, 1, 1)) : o.clearColor = new t.Color4(0, 0, 0, 0), o.fogEnabled = e.basicOption.scene.fogEnabled, o.fogMode = e.basicOption.scene.fogMode || 1, o.fogColor = A(e.basicOption.scene.fogColor, new t.Color3(1, 1, 1)), o.fogEnd = e.basicOption.scene.fogEnd || 2e3, o.fogStart = e.basicOption.scene.fogStart || 1, o.fogDensity = e.basicOption.scene.fogDensity * 1e-4;
+    }, R = () => {
+      if (p || (p = new t.DirectionalLight("dirLight", new t.Vector3(
+        e.basicOption.directionalLight.direction[0],
+        e.basicOption.directionalLight.direction[1],
+        e.basicOption.directionalLight.direction[2]
+      ), o)), p.direction = new t.Vector3(
+        e.basicOption.directionalLight.direction[0],
+        e.basicOption.directionalLight.direction[1],
+        e.basicOption.directionalLight.direction[2]
+      ), p.position = new t.Vector3(
+        e.basicOption.directionalLight.position[0],
+        e.basicOption.directionalLight.position[1],
+        e.basicOption.directionalLight.position[2]
+      ), p.diffuse = A(e.basicOption.directionalLight.diffuse, new t.Color3(1, 1, 1)), p.intensity = e.basicOption.directionalLight.intensity, p.shadowMinZ = e.basicOption.directionalLight.shadowMinZ, p.shadowMaxZ = e.basicOption.directionalLight.shadowMaxZ, p.autoCalcShadowZBounds = e.basicOption.directionalLight.autoCalcShadowZBounds, e.basicOption.directionalLight.shadowGenerator.enable) {
+        const { mapSize: i, transparencyShadow: a, usePercentageCloserFiltering: c, bias: h } = e.basicOption.directionalLight.shadowGenerator;
+        if (!l && (l = new t.ShadowGenerator(i, p), r))
+          for (let w = 0; w < r.length; w++)
+            e.basicOption.meshes.isCasterShadow && l && l.addShadowCaster(r[w], !0);
+        l.mapSize = i, l.transparencyShadow = a, l.usePercentageCloserFiltering = c, l.bias = h;
+      } else
+        l && (l.dispose(), l = null);
+      e.basicOption.directionalLight.lightGizmo && e.basicOption.directionalLight.lightGizmo.enable ? (f || (f = new t.LightGizmo(), f.light = p), f.scaleRatio = e.basicOption.directionalLight.lightGizmo.scaleRatio) : f && (f.dispose(), f = null);
+    }, F = () => {
+      L || (L = new t.HemisphericLight("light", new t.Vector3(
+        e.basicOption.hemisphericLight.direction[0],
+        e.basicOption.hemisphericLight.direction[1],
+        e.basicOption.hemisphericLight.direction[2]
+      ), o)), L.direction = new t.Vector3(
+        e.basicOption.hemisphericLight.direction[0],
+        e.basicOption.hemisphericLight.direction[1],
+        e.basicOption.hemisphericLight.direction[2]
+      ), L.intensity = e.basicOption.hemisphericLight.intensity, L.diffuse = A(e.basicOption.hemisphericLight.diffuse, new t.Color3(1, 1, 1)), e.basicOption.hemisphericLight.lightGizmo && e.basicOption.hemisphericLight.lightGizmo.enable ? (O || (O = new t.LightGizmo(), O.light = L), O.scaleRatio = e.basicOption.hemisphericLight.lightGizmo.scaleRatio) : O && (O.dispose(), O = null);
+    }, G = () => {
+      if (e.basicOption.ground.enable) {
+        const { width: i, height: a, position: c, rotation: h, scaling: w, material: C, receiveShadows: Z } = e.basicOption.ground;
+        d || (d = t.MeshBuilder.CreateGround("ground", { width: i, height: a }, o)), d.position = new t.Vector3(
+          c[0],
+          c[1],
+          c[2]
+        ), d.rotation = new t.Vector3(
+          t.Tools.ToRadians(h[0]),
+          t.Tools.ToRadians(h[1]),
+          t.Tools.ToRadians(h[2])
+        ), d.scaling = new t.Vector3(
+          w[0],
+          w[1],
+          w[2]
+        );
+        const x = new t.StandardMaterial("", o);
+        x.emissiveTexture = new t.Texture(C.emissiveTexture, o), x.diffuseTexture = new t.Texture(C.emissiveTexture, o), x.ambientTexture = new t.Texture(C.emissiveTexture, o), x.diffuseColor = new t.Color3(1, 1, 1), x.opacityTexture = new t.Texture(C.opacityTexture, o), d.material = x, d.receiveShadows = Z;
+      } else
+        d && (d.dispose(), d = null);
+    }, M = () => {
+      if (e.basicOption.skybox.enable) {
+        const { size: i } = e.basicOption.skybox;
+        g || (g = t.MeshBuilder.CreateBox("skyBox", { size: i }, o));
+        const a = new t.StandardMaterial("skyBox", o);
+        a.backFaceCulling = !1, a.reflectionTexture = t.CubeTexture.CreateFromPrefilteredData(e.basicOption.scene.environmentTexture, o), a.reflectionTexture.coordinatesMode = t.Texture.SKYBOX_MODE, a.diffuseColor = new t.Color3(1, 1, 1), a.specularColor = new t.Color3(1, 1, 1), a.disableLighting = !0, g.material = a, g.isPickable = !1;
+      } else
+        g && (g.dispose(), g = null);
+    }, D = (i, a = {
+      loop: !1,
+      speedRatio: 1
+    }) => {
+      if (o) {
+        o.stopAllAnimations();
+        const c = o.getAnimationGroupByName(i);
+        c && (E("on-play-animation"), window.SHJParseEvent(e.useEvents, "on-play-animation"), c.start(a.loop, a.speedRatio, c.from, c.to, !1));
+      }
+    }, T = async () => {
+      r || (r = (await t.SceneLoader.ImportMeshAsync("", e.basicOption.meshes.url, "", o)).meshes), r[0].position = new t.Vector3(
+        e.basicOption.meshes.position[0],
+        e.basicOption.meshes.position[1],
+        e.basicOption.meshes.position[2]
+      ), r[0].scaling = new t.Vector3(
+        e.basicOption.meshes.scaling[0],
+        e.basicOption.meshes.scaling[1],
+        e.basicOption.meshes.scaling[2]
+      ), r[0].rotation = new t.Vector3(
+        t.Tools.ToRadians(e.basicOption.meshes.rotation[0]),
+        t.Tools.ToRadians(e.basicOption.meshes.rotation[1]),
+        t.Tools.ToRadians(e.basicOption.meshes.rotation[2])
+      );
+      for (let i = 0; i < r.length; i++)
+        r[i].isPickable = !1, r[i].receiveShadows = e.basicOption.meshes.isCasterShadow, e.basicOption.meshes.isCasterShadow && l && l.addShadowCaster(r[i], !0);
+      e.basicOption.animationGroups = o.animationGroups.map((i) => ({ uniqueId: i.uniqueId, name: i.name })), e.basicEvents && (e.basicEvents.function[0].args[0].select = o.animationGroups.map((i) => ({ name: i.name, value: i.name }))), e.basicOption.defaultAnimation && e.basicOption.defaultAnimation.name ? D(e.basicOption.defaultAnimation.name, {
+        loop: e.basicOption.defaultAnimation.loop,
+        speedRatio: e.basicOption.defaultAnimation.speedRatio
+      }) : o.animationGroups && o.animationGroups[0] && o.animationGroups[0].stop();
+    }, k = () => {
+      const i = e.basicOption.pipelineOption;
+      i && i.enabled ? (n || (n = new t.DefaultRenderingPipeline(
+        "defaultPipeline",
+        !0,
+        o,
+        [s]
+      )), n.samples = i.samples ? 4 : 1, n.fxaaEnabled = i.fxaaEnabled, n.grainEnabled = i.grainEnabled, n.grain.intensity = i.grainIntensity, n.grain.animated = i.grainAnimated, n.bloomEnabled = i.bloomEnabled, n.bloomThreshold = i.bloomThreshold, n.bloomWeight = i.bloomWeight, n.bloomKernel = i.bloomKernel, n.bloomScale = i.bloomScale, n.depthOfFieldEnabled = i.depthOfFieldEnabled, i.depthOfFieldBlurLevel < 1 ? n.depthOfFieldBlurLevel = t.DepthOfFieldEffectBlurLevel.Low : i.depthOfFieldBlurLevel < 2 ? n.depthOfFieldBlurLevel = t.DepthOfFieldEffectBlurLevel.Medium : i.depthOfFieldBlurLevel < 3 && (n.depthOfFieldBlurLevel = t.DepthOfFieldEffectBlurLevel.High), n.depthOfField.focusDistance = i.depthOfFieldFocusDistance, n.depthOfField.fStop = i.depthOfFieldFStop, n.depthOfField.focalLength = i.depthOfFieldFocalLength, n.chromaticAberrationEnabled = i.chromaticAberrationEnabled, n.chromaticAberration.aberrationAmount = i.chromaticAberrationAberrationAmount, n.chromaticAberration.radialIntensity = i.chromaticAberrationRadialIntensity, i.chromaticAberrationDirection === 0 ? (n.chromaticAberration.direction.x = 0, n.chromaticAberration.direction.y = 0) : (n.chromaticAberration.direction.x = Math.sin(i.chromaticAberrationDirection), n.chromaticAberration.direction.y = Math.cos(i.chromaticAberrationDirection)), n.sharpenEnabled = i.sharpenEnabled, n.sharpen.edgeAmount = i.sharpenEdgeAmount, n.sharpen.colorAmount = i.sharpenColorAmount) : n && (n.dispose(), n = null);
+    }, I = function(i) {
+      S(), B(), F(), R(), G(), M(), T(), k(), E("on-load-success"), window.SHJParseEvent(e.useEvents, "on-load-success");
+    }, y = H();
+    return q(() => {
+      v = new t.Engine(y.value, !0), v && e.basicOption.meshes.url && (I(), v.runRenderLoop(function() {
+        o && o.render();
+      }));
+    }), K(() => {
+      o.dispose(), v.dispose();
+    }), P({
+      playAnimation: (i, a) => {
+        const c = i[0].value, h = {
+          loop: i[1].keys[0].defaultValue,
+          speedRatio: i[1].keys[1].defaultValue
+        };
+        D(c, h);
+      }
+    }), m(() => b(e.basicOption.camera), (i, a) => {
+      !u(i, a) && s && B();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.scene), (i, a) => {
+      !u(i, a) && o && S();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.directionalLight), (i, a) => {
+      u(i, a) || R();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.hemisphericLight), (i, a) => {
+      u(i, a) || F();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.ground), (i, a) => {
+      u(i, a) || G();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.skybox), (i, a) => {
+      u(i, a) || M();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.meshes), (i, a) => {
+      !u(i, a) && r && i.url === a.url && T();
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.meshes.url), (i, a) => {
+      u(i, a) || (o.meshes.forEach((c, h) => {
+        h > 1 && c.dispose();
+      }), r = null, T());
+    }, {
+      deep: !0
+    }), m(() => b(e.basicOption.pipelineOption), (i, a) => {
+      u(i, a) || k();
+    }, {
+      deep: !0
+    }), (i, a) => (N(), J("div", X, [
+      W("canvas", {
+        ref_key: "canvasRef",
+        ref: y,
+        class: Y(["widget", { show: !0 }])
+      }, null, 512)
+    ]));
+  }
+});
+export {
+  te as default
+};

package/es/components/commons-vr-photo/index.d.ts

@@ -0,0 +1,59 @@
+export declare const ZvCommonsVrPhoto: import("../../utils/typescript").SFCWithInstall<import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}, {
+    props: any;
+    useBabylonScene: (basicOption: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            canvas: HTMLCanvasElement;
+            option: any;
+            createScene(): import("@babylonjs/core").Scene;
+            run(): any;
+            dispose(): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any): {
+                scene: import("@babylonjs/core").Scene;
+                engine: import("@babylonjs/core").Engine;
+                canvas: HTMLCanvasElement;
+                option: any;
+                createScene(): import("@babylonjs/core").Scene;
+                run(): any;
+                dispose(): void;
+            };
+        };
+        loadingStatus: import("vue").Ref<any>;
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylon: import("vue").Ref<{
+        scene: import("@babylonjs/core").Scene;
+        engine: import("@babylonjs/core").Engine;
+        canvas: HTMLCanvasElement;
+        option: any;
+        createScene(): import("@babylonjs/core").Scene;
+        run(): any;
+        dispose(): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any): {
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            canvas: HTMLCanvasElement;
+            option: any;
+            createScene(): import("@babylonjs/core").Scene;
+            run(): any;
+            dispose(): void;
+        };
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}>>, {}, {}>> & Record<string, any>;
+export default ZvCommonsVrPhoto;

package/es/components/commons-vr-photo/index.mjs

@@ -0,0 +1,7 @@
+import o from "./index.vue.mjs";
+import { withInstall as t } from "../../utils/install.mjs";
+const s = t(o);
+export {
+  s as ZvCommonsVrPhoto,
+  s as default
+};

package/es/components/commons-vr-photo/index.vue.d.ts

@@ -0,0 +1,60 @@
+import { Scene, Engine } from '@babylonjs/core';
+declare const _sfc_main: import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}, {
+    props: any;
+    useBabylonScene: (basicOption: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: Scene;
+            engine: Engine;
+            canvas: HTMLCanvasElement;
+            option: any;
+            createScene(): Scene;
+            run(): any;
+            dispose(): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any): {
+                scene: Scene;
+                engine: Engine;
+                canvas: HTMLCanvasElement;
+                option: any;
+                createScene(): Scene;
+                run(): any;
+                dispose(): void;
+            };
+        };
+        loadingStatus: import("vue").Ref<any>;
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylon: import("vue").Ref<{
+        scene: Scene;
+        engine: Engine;
+        canvas: HTMLCanvasElement;
+        option: any;
+        createScene(): Scene;
+        run(): any;
+        dispose(): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any): {
+            scene: Scene;
+            engine: Engine;
+            canvas: HTMLCanvasElement;
+            option: any;
+            createScene(): Scene;
+            run(): any;
+            dispose(): void;
+        };
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _sfc_main;

package/es/components/commons-vr-photo/index.vue.mjs

@@ -0,0 +1,76 @@
+var y = Object.defineProperty;
+var _ = (n, e, o) => e in n ? y(n, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : n[e] = o;
+var h = (n, e, o) => _(n, typeof e != "symbol" ? e + "" : e, o);
+import { defineComponent as b, watch as M, openBlock as R, createElementBlock as S, createElementVNode as E, ref as v, onMounted as B, onBeforeUnmount as z } from "vue";
+import "@babylonjs/loaders/glTF";
+import { cloneDeep as O, isEqual as P } from "lodash";
+import { Engine as C, Scene as D, ArcRotateCamera as L, Vector3 as k, PhotoDome as m, PointerEventTypes as A } from "@babylonjs/core";
+const I = { class: "zerov-widget" }, T = b({ name: "zv-commons-vr-photo" }), F = /* @__PURE__ */ b({
+  ...T,
+  props: {
+    basicOption: {}
+  },
+  setup(n) {
+    const e = n, o = (l) => {
+      const i = v(), p = v();
+      class d {
+        constructor(s, t) {
+          h(this, "scene");
+          h(this, "engine");
+          this.canvas = s, this.option = t, this.engine = new C(this.canvas, !0, {}, !1), p.value = !0, window.addEventListener("resize", () => {
+            this.engine.resize();
+          }), this.scene = this.createScene();
+        }
+        createScene() {
+          const s = new D(this.engine), t = new L("Camera", -Math.PI / 2, Math.PI / 2, 5, k.Zero(), s);
+          t.attachControl(i.value, !0), t.useAutoRotationBehavior = this.option.cameraAutoRotation, t.inputs.attached.mousewheel.detachControl();
+          const r = new m("", this.option.url, {
+            resolution: this.option.resolution || 32,
+            size: 1e3,
+            useDirectMapping: !1
+          }, s);
+          if (this.option.isReversal && (t.angularSensibilityX = -t.angularSensibilityX, t.angularSensibilityY = -t.angularSensibilityY), this.option.imageMode && (r.imageMode = m[this.option.imageMode]), r.fovMultiplier = this.option.defaultFov || 1, this.option.isScale) {
+            let a = r.fovMultiplier;
+            s.onPointerObservable.add(
+              (w) => {
+                r !== void 0 && (a += w.event.wheelDelta * -5e-4, a < 0 && (a = 0), a > 2 && (a = 2), r.fovMultiplier = a);
+              },
+              A.POINTERWHEEL
+            );
+          }
+          return setTimeout(() => {
+            p.value = !1;
+          }, 200), s;
+        }
+        run() {
+          return this.engine.runRenderLoop(() => {
+            this.scene.render();
+          }), this;
+        }
+        dispose() {
+          this.scene && this.engine && (this.scene.dispose(), this.engine.dispose());
+        }
+      }
+      const c = v();
+      return B(() => {
+        c.value = new d(i.value, l).run();
+      }), z(() => {
+        c.value && c.value.dispose();
+      }), { canvasRef: i, babylon: c, Babylon: d, loadingStatus: p };
+    }, { canvasRef: f, babylon: u, Babylon: g } = o(e.basicOption);
+    return M(() => O(e.basicOption), (l, i) => {
+      !P(l, i) && u.value && (u.value.dispose(), u.value = new g(f.value, e.basicOption).run());
+    }, {
+      deep: !0
+    }), (l, i) => (R(), S("div", I, [
+      E("canvas", {
+        ref_key: "canvasRef",
+        ref: f,
+        class: "widget"
+      }, null, 512)
+    ]));
+  }
+});
+export {
+  F as default
+};

package/es/components/commons-vr-photo/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/components/commons-vr-video/index.d.ts

@@ -0,0 +1,59 @@
+export declare const ZvCommonsVrVideo: import("../../utils/typescript").SFCWithInstall<import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}, {
+    props: any;
+    useBabylonScene: (basicOption: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            canvas: HTMLCanvasElement;
+            option: any;
+            createScene(): import("@babylonjs/core").Scene;
+            run(): any;
+            dispose(): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any): {
+                scene: import("@babylonjs/core").Scene;
+                engine: import("@babylonjs/core").Engine;
+                canvas: HTMLCanvasElement;
+                option: any;
+                createScene(): import("@babylonjs/core").Scene;
+                run(): any;
+                dispose(): void;
+            };
+        };
+        loadingStatus: import("vue").Ref<any>;
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylon: import("vue").Ref<{
+        scene: import("@babylonjs/core").Scene;
+        engine: import("@babylonjs/core").Engine;
+        canvas: HTMLCanvasElement;
+        option: any;
+        createScene(): import("@babylonjs/core").Scene;
+        run(): any;
+        dispose(): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any): {
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            canvas: HTMLCanvasElement;
+            option: any;
+            createScene(): import("@babylonjs/core").Scene;
+            run(): any;
+            dispose(): void;
+        };
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}>>, {}, {}>> & Record<string, any>;
+export default ZvCommonsVrVideo;

package/es/components/commons-vr-video/index.mjs

@@ -0,0 +1,7 @@
+import o from "./index.vue.mjs";
+import { withInstall as m } from "../../utils/install.mjs";
+const i = m(o);
+export {
+  i as ZvCommonsVrVideo,
+  i as default
+};