@shjjs/visual-ui 1.0.0

package/es/components/commons-product-model/index.d.ts

@@ -0,0 +1,142 @@
+export declare const ZvCommonsProductModel: import("../../utils/typescript").SFCWithInstall<import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}, {
+    emit: (event: "on-load-success" | "on-play-animation", ...args: any[]) => void;
+    props: any;
+    useBabylonScene: (basicOption: any, basicEvents: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            environmentHelper: import("@babylonjs/core").EnvironmentHelper;
+            shadowsLight: import("@babylonjs/core").DirectionalLight;
+            shadowGenerator: import("@babylonjs/core").ShadowGenerator;
+            defaultPipeline: import("@babylonjs/core").DefaultRenderingPipeline;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): import("@babylonjs/core").Scene;
+            updateScenePipeline(pipelineOption: any): void;
+            updateScene(sceneOption: any): void;
+            updateShadowsLight(shadowOption: any): void;
+            updateCamera(cameraOption: any): void;
+            updateDefaultEnvironment(environment: any): void;
+            updateMeshs(scene: import("@babylonjs/core").Scene): void;
+            run(): any;
+            dispose(): void;
+            playAnimation(name: string, option?: {
+                loop: boolean;
+                speedRatio: number;
+            }): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any, events: any): {
+                scene: import("@babylonjs/core").Scene;
+                engine: import("@babylonjs/core").Engine;
+                environmentHelper: import("@babylonjs/core").EnvironmentHelper;
+                shadowsLight: import("@babylonjs/core").DirectionalLight;
+                shadowGenerator: import("@babylonjs/core").ShadowGenerator;
+                defaultPipeline: import("@babylonjs/core").DefaultRenderingPipeline;
+                canvas: HTMLCanvasElement;
+                option: any;
+                events: any;
+                createScene(): import("@babylonjs/core").Scene;
+                updateScenePipeline(pipelineOption: any): void;
+                updateScene(sceneOption: any): void;
+                updateShadowsLight(shadowOption: any): void;
+                updateCamera(cameraOption: any): void;
+                updateDefaultEnvironment(environment: any): void;
+                updateMeshs(scene: import("@babylonjs/core").Scene): void;
+                run(): any;
+                dispose(): void;
+                playAnimation(name: string, option?: {
+                    loop: boolean;
+                    speedRatio: number;
+                }): void;
+            };
+        };
+        babylonLoadingStatus: import("vue").Ref<boolean>;
+        babylonLoadingTitle: import("vue").Ref<any>;
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylon: import("vue").Ref<{
+        scene: import("@babylonjs/core").Scene;
+        engine: import("@babylonjs/core").Engine;
+        environmentHelper: import("@babylonjs/core").EnvironmentHelper;
+        shadowsLight: import("@babylonjs/core").DirectionalLight;
+        shadowGenerator: import("@babylonjs/core").ShadowGenerator;
+        defaultPipeline: import("@babylonjs/core").DefaultRenderingPipeline;
+        canvas: HTMLCanvasElement;
+        option: any;
+        events: any;
+        createScene(): import("@babylonjs/core").Scene;
+        updateScenePipeline(pipelineOption: any): void;
+        updateScene(sceneOption: any): void;
+        updateShadowsLight(shadowOption: any): void;
+        updateCamera(cameraOption: any): void;
+        updateDefaultEnvironment(environment: any): void;
+        updateMeshs(scene: import("@babylonjs/core").Scene): void;
+        run(): any;
+        dispose(): void;
+        playAnimation(name: string, option?: {
+            loop: boolean;
+            speedRatio: number;
+        }): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any, events: any): {
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            environmentHelper: import("@babylonjs/core").EnvironmentHelper;
+            shadowsLight: import("@babylonjs/core").DirectionalLight;
+            shadowGenerator: import("@babylonjs/core").ShadowGenerator;
+            defaultPipeline: import("@babylonjs/core").DefaultRenderingPipeline;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): import("@babylonjs/core").Scene;
+            updateScenePipeline(pipelineOption: any): void;
+            updateScene(sceneOption: any): void;
+            updateShadowsLight(shadowOption: any): void;
+            updateCamera(cameraOption: any): void;
+            updateDefaultEnvironment(environment: any): void;
+            updateMeshs(scene: import("@babylonjs/core").Scene): void;
+            run(): any;
+            dispose(): void;
+            playAnimation(name: string, option?: {
+                loop: boolean;
+                speedRatio: number;
+            }): void;
+        };
+    };
+    babylonLoadingStatus: import("vue").Ref<boolean>;
+    babylonLoadingTitle: 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 ZvCommonsProductModel;

package/es/components/commons-product-model/index.mjs

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

package/es/components/commons-product-model/index.vue.d.ts

@@ -0,0 +1,143 @@
+import { Scene, Engine, DirectionalLight, ShadowGenerator, EnvironmentHelper, DefaultRenderingPipeline } 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;
+    };
+}, {
+    emit: (event: "on-load-success" | "on-play-animation", ...args: any[]) => void;
+    props: any;
+    useBabylonScene: (basicOption: any, basicEvents: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: Scene;
+            engine: Engine;
+            environmentHelper: EnvironmentHelper;
+            shadowsLight: DirectionalLight;
+            shadowGenerator: ShadowGenerator;
+            defaultPipeline: DefaultRenderingPipeline;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): Scene;
+            updateScenePipeline(pipelineOption: any): void;
+            updateScene(sceneOption: any): void;
+            updateShadowsLight(shadowOption: any): void;
+            updateCamera(cameraOption: any): void;
+            updateDefaultEnvironment(environment: any): void;
+            updateMeshs(scene: Scene): void;
+            run(): any;
+            dispose(): void;
+            playAnimation(name: string, option?: {
+                loop: boolean;
+                speedRatio: number;
+            }): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any, events: any): {
+                scene: Scene;
+                engine: Engine;
+                environmentHelper: EnvironmentHelper;
+                shadowsLight: DirectionalLight;
+                shadowGenerator: ShadowGenerator;
+                defaultPipeline: DefaultRenderingPipeline;
+                canvas: HTMLCanvasElement;
+                option: any;
+                events: any;
+                createScene(): Scene;
+                updateScenePipeline(pipelineOption: any): void;
+                updateScene(sceneOption: any): void;
+                updateShadowsLight(shadowOption: any): void;
+                updateCamera(cameraOption: any): void;
+                updateDefaultEnvironment(environment: any): void;
+                updateMeshs(scene: Scene): void;
+                run(): any;
+                dispose(): void;
+                playAnimation(name: string, option?: {
+                    loop: boolean;
+                    speedRatio: number;
+                }): void;
+            };
+        };
+        babylonLoadingStatus: import("vue").Ref<boolean>;
+        babylonLoadingTitle: import("vue").Ref<any>;
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylon: import("vue").Ref<{
+        scene: Scene;
+        engine: Engine;
+        environmentHelper: EnvironmentHelper;
+        shadowsLight: DirectionalLight;
+        shadowGenerator: ShadowGenerator;
+        defaultPipeline: DefaultRenderingPipeline;
+        canvas: HTMLCanvasElement;
+        option: any;
+        events: any;
+        createScene(): Scene;
+        updateScenePipeline(pipelineOption: any): void;
+        updateScene(sceneOption: any): void;
+        updateShadowsLight(shadowOption: any): void;
+        updateCamera(cameraOption: any): void;
+        updateDefaultEnvironment(environment: any): void;
+        updateMeshs(scene: Scene): void;
+        run(): any;
+        dispose(): void;
+        playAnimation(name: string, option?: {
+            loop: boolean;
+            speedRatio: number;
+        }): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any, events: any): {
+            scene: Scene;
+            engine: Engine;
+            environmentHelper: EnvironmentHelper;
+            shadowsLight: DirectionalLight;
+            shadowGenerator: ShadowGenerator;
+            defaultPipeline: DefaultRenderingPipeline;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): Scene;
+            updateScenePipeline(pipelineOption: any): void;
+            updateScene(sceneOption: any): void;
+            updateShadowsLight(shadowOption: any): void;
+            updateCamera(cameraOption: any): void;
+            updateDefaultEnvironment(environment: any): void;
+            updateMeshs(scene: Scene): void;
+            run(): any;
+            dispose(): void;
+            playAnimation(name: string, option?: {
+                loop: boolean;
+                speedRatio: number;
+            }): void;
+        };
+    };
+    babylonLoadingStatus: import("vue").Ref<boolean>;
+    babylonLoadingTitle: 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-product-model/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 p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-4eda2982"]]);
+export {
+  p as default
+};

package/es/components/commons-product-model/index.vue2.mjs

@@ -0,0 +1,239 @@
+var U = Object.defineProperty;
+var W = (h, l, g) => l in h ? U(h, l, { enumerable: !0, configurable: !0, writable: !0, value: g }) : h[l] = g;
+var d = (h, l, g) => W(h, typeof l != "symbol" ? l + "" : l, g);
+import { defineComponent as k, watch as c, openBlock as F, createElementBlock as G, createElementVNode as V, normalizeClass as K, unref as A, toDisplayString as q, createCommentVNode as N, ref as L, onMounted as J, onBeforeUnmount as Y } from "vue";
+import "@babylonjs/loaders/glTF";
+import { cloneDeep as f, isEqual as m } from "lodash";
+import { useResizeObserver as j } from "@vueuse/core";
+import { Engine as Q, Scene as X, Color4 as S, Color3 as b, DefaultRenderingPipeline as Z, DepthOfFieldEffectBlurLevel as C, Vector3 as v, DirectionalLight as $, ShadowGenerator as O, Tools as z, SceneLoader as ee } from "@babylonjs/core";
+import { hex2Color4 as T, hex2Color3 as w } from "../../utils/babylon/ColorConvert.mjs";
+const te = { class: "zerov-widget" }, ie = k({ name: "zv-commons-product-model" }), he = /* @__PURE__ */ k({
+  ...ie,
+  props: {
+    basicOption: {},
+    basicEvents: {},
+    useEvents: {}
+  },
+  emits: [
+    "on-load-success",
+    "on-play-animation"
+  ],
+  setup(h, { expose: l, emit: g }) {
+    const x = g, o = h, I = (t, s) => {
+      const u = L(), y = L(), P = L(!0);
+      class H {
+        // eslint-disable-next-line no-useless-constructor
+        constructor(e) {
+          // optional, but needed due to interface definitions
+          d(this, "loadingUIBackgroundColor");
+          this.loadingUIText = e;
+        }
+        displayLoadingUI() {
+          u.value && (P.value = !0);
+        }
+        hideLoadingUI() {
+          u.value && (P.value = !1);
+        }
+      }
+      class B {
+        constructor(e, i, n) {
+          d(this, "scene");
+          d(this, "engine");
+          // 默认环境
+          d(this, "environmentHelper");
+          d(this, "shadowsLight");
+          // 全局阴影
+          d(this, "shadowGenerator");
+          // 默认后期
+          d(this, "defaultPipeline");
+          this.canvas = e, this.option = i, this.events = n;
+          try {
+            this.engine = new Q(this.canvas, !0, {}, !1), this.engine.loadingScreen = new H(""), window.addEventListener("resize", () => {
+              this.engine.resize();
+            }), this.scene = this.createScene();
+          } catch {
+          }
+        }
+        createScene() {
+          return this.engine.displayLoadingUI(), this.scene = new X(this.engine), this.option.scene.colorShow ? this.scene.clearColor = T(this.option.scene.color, new S(0, 0, 0, 0)) : this.scene.clearColor = new S(0, 0, 0, 0), this.scene.fogEnabled = this.option.scene.fogEnabled, this.scene.fogMode = this.option.scene.fogMode || 1, this.scene.fogColor = w(this.option.scene.fogColor, new b(1, 1, 1)), this.scene.fogEnd = this.option.scene.fogEnd || 60, this.scene.fogStart = this.option.scene.fogStart || 1, this.scene.fogDensity = this.option.scene.fogDensity || 0.1, this.scene.createDefaultCamera(!0, !1, !0), this.updateMeshs(this.scene), this.scene;
+        }
+        updateScenePipeline(e) {
+          this.scene.activeCamera && e && (e.enabled ? (this.defaultPipeline || (this.defaultPipeline = new Z(
+            "defaultPipeline",
+            !0,
+            this.scene,
+            [this.scene.activeCamera]
+          )), this.defaultPipeline.samples = e.samples ? 4 : 1, this.defaultPipeline.fxaaEnabled = e.fxaaEnabled, this.defaultPipeline.grainEnabled = e.grainEnabled, this.defaultPipeline.grain.intensity = e.grainIntensity, this.defaultPipeline.grain.animated = e.grainAnimated, this.defaultPipeline.bloomEnabled = e.bloomEnabled, this.defaultPipeline.bloomThreshold = e.bloomThreshold, this.defaultPipeline.bloomWeight = e.bloomWeight, this.defaultPipeline.bloomKernel = e.bloomKernel, this.defaultPipeline.bloomScale = e.bloomScale, this.defaultPipeline.depthOfFieldEnabled = e.depthOfFieldEnabled, e.depthOfFieldBlurLevel < 1 ? this.defaultPipeline.depthOfFieldBlurLevel = C.Low : e.depthOfFieldBlurLevel < 2 ? this.defaultPipeline.depthOfFieldBlurLevel = C.Medium : e.depthOfFieldBlurLevel < 3 && (this.defaultPipeline.depthOfFieldBlurLevel = C.High), this.defaultPipeline.depthOfField.focusDistance = e.depthOfFieldFocusDistance, this.defaultPipeline.depthOfField.fStop = e.depthOfFieldFStop, this.defaultPipeline.depthOfField.focalLength = e.depthOfFieldFocalLength, this.defaultPipeline.chromaticAberrationEnabled = e.chromaticAberrationEnabled, this.defaultPipeline.chromaticAberration.aberrationAmount = e.chromaticAberrationAberrationAmount, this.defaultPipeline.chromaticAberration.radialIntensity = e.chromaticAberrationRadialIntensity, e.chromaticAberrationDirection === 0 ? (this.defaultPipeline.chromaticAberration.direction.x = 0, this.defaultPipeline.chromaticAberration.direction.y = 0) : (this.defaultPipeline.chromaticAberration.direction.x = Math.sin(e.chromaticAberrationDirection), this.defaultPipeline.chromaticAberration.direction.y = Math.cos(e.chromaticAberrationDirection)), this.defaultPipeline.sharpenEnabled = e.sharpenEnabled, this.defaultPipeline.sharpen.edgeAmount = e.sharpenEdgeAmount, this.defaultPipeline.sharpen.colorAmount = e.sharpenColorAmount) : this.defaultPipeline && (this.defaultPipeline.dispose(), this.defaultPipeline = null));
+        }
+        updateScene(e) {
+          e.colorShow ? this.scene.clearColor = T(e.color, new S(1, 1, 1, 1)) : this.scene.clearColor = new S(0, 0, 0, 0), this.scene.fogEnabled = e.fogEnabled, this.scene.fogMode = e.fogMode || 1, this.scene.fogColor = w(e.fogColor, new b(1, 1, 1)), this.scene.fogEnd = e.fogEnd || 60, this.scene.fogStart = e.fogStart || 1, this.scene.fogDensity = e.fogDensity || 0.1;
+        }
+        updateShadowsLight(e) {
+          if (e.show) {
+            if (this.shadowsLight) {
+              this.shadowsLight.direction = new v(...e.direction), this.shadowsLight.position = new v(...e.position), this.shadowsLight.intensity = e.intensity, this.shadowsLight.diffuse = w(e.diffuse, b.White()), this.shadowGenerator.mapSize = e.mapSize;
+              return;
+            }
+            this.shadowsLight = new $("shadowsLight", new v(...e.direction), this.scene), this.shadowsLight.intensity = e.intensity || 0.6, this.shadowsLight.diffuse = w(e.diffuse, b.White()), this.shadowsLight.position = new v(...e.position), this.shadowGenerator = new O(e.mapSize, this.shadowsLight);
+          } else
+            this.shadowsLight && (this.shadowsLight.dispose(), this.shadowsLight = null);
+        }
+        updateCamera(e) {
+          const i = this.scene.activeCamera;
+          i && (e.radius && (i.radius = e.radius), i.beta = z.ToRadians(e.beta), i.alpha = z.ToRadians(e.alpha), i.useAutoRotationBehavior = e.autoRotation, i.wheelDeltaPercentage = e.wheelDeltaPercentage || 0.01, i.lowerRadiusLimit = e.lowerRadiusLimit, i.upperRadiusLimit = e.upperRadiusLimit, i.lowerBetaLimit = 0, i.upperBetaLimit = Math.PI / 2.1);
+        }
+        updateDefaultEnvironment(e) {
+          this.environmentHelper && this.environmentHelper.dispose(), this.environmentHelper = this.scene.createDefaultEnvironment({
+            // 是否创建地面
+            createGround: e.createGround,
+            // 地面颜色
+            groundColor: w(e.groundColor, new b(1, 1, 1)),
+            // 地面大小
+            groundSize: e.groundSize || 15,
+            // 地面透明度
+            groundOpacity: e.groundOpacity || 1,
+            // 使地面能够接收阴影。
+            enableGroundShadow: e.enableGroundShadow,
+            // 接收阴影等级
+            groundShadowLevel: e.groundShadowLevel || 0.5,
+            // 地面反射
+            enableGroundMirror: e.enableGroundMirror === void 0 ? !0 : e.enableGroundMirror,
+            // 地面反射大小比率
+            groundMirrorSizeRatio: e.groundMirrorSizeRatio || 0.3,
+            // 地面反射模糊大小
+            groundMirrorBlurKernel: e.groundMirrorBlurKernel || 64,
+            // 指定地面反射镜的可见性。
+            groundMirrorAmount: e.groundMirrorAmount || 1,
+            // 指定地面镜反射率权重。这使用背景材质的标准重量来设置菲涅耳效果的镜子。
+            groundMirrorFresnelWeight: e.groundMirrorFresnelWeight || 1,
+            // 指定应用于地面垂直位置的偏移
+            groundYBias: e.groundYBias || 0,
+            // 创建天空盒
+            createSkybox: e.createSkybox,
+            // 天空盒大小
+            skyboxSize: e.skyboxSize || 20,
+            ...e.skyboxTexture ? { skyboxTexture: e.skyboxTexture } : {},
+            // 天空盒颜色
+            // 自动计算元素的大小以最适合场景。
+            sizeAuto: !0,
+            // 如果autoSize不为true，rootMesh的默认位置。
+            // rootPosition: Vector3,
+            // 环境贴图
+            ...e.environmentTexture ? { environmentTexture: e.environmentTexture } : {},
+            // 相机曝光
+            cameraExposure: e.cameraExposure || 0.6,
+            // 相机对比度
+            cameraContrast: e.cameraContrast || 1.6
+          }), this.environmentHelper.ground && (this.environmentHelper.ground.position.y += 0.01);
+        }
+        updateMeshs(e) {
+          e.meshes.forEach((i) => setTimeout(() => i.dispose())), ee.ImportMeshAsync("", this.option.meshs.url, "", e, (i) => {
+            y.value = (i.loaded / i.total * 100).toFixed(2);
+          }).then((i) => {
+            const n = i.meshes;
+            if (this.option.animationGroups = e.animationGroups.map((r) => ({
+              uniqueId: r.uniqueId,
+              name: r.name
+            })), this.events && (this.events.function[0].args[0].select = e.animationGroups.map((r) => ({
+              name: r.name,
+              value: r.name
+            }))), this.option.defaultAnimation && this.option.defaultAnimation.name ? this.playAnimation(this.option.defaultAnimation.name, {
+              loop: this.option.defaultAnimation.loop,
+              speedRatio: this.option.defaultAnimation.speedRatio
+            }) : e.animationGroups && e.animationGroups[0] && e.animationGroups[0].stop(), this.updateShadowsLight(this.option.shadow), e.createDefaultCamera(!0, !0, !0), this.updateCamera(this.option.camera), this.updateScenePipeline(this.option.pipelineOption), this.updateDefaultEnvironment(this.option.environment), this.option.meshs.isCasterShadow && this.shadowGenerator) {
+              this.shadowGenerator.addShadowCaster(e.meshes[0], !0);
+              for (let r = 0; r < n.length; r++)
+                n[r].receiveShadows = !1;
+            }
+            n[0].position = new v(...this.option.meshs.position), setTimeout(() => {
+              this.engine.hideLoadingUI(), x("on-load-success"), window.SHJParseEvent(o.useEvents, "on-load-success");
+            }, 100);
+          });
+        }
+        run() {
+          return this.engine.runRenderLoop(() => {
+            this.scene.render();
+          }), this;
+        }
+        dispose() {
+          this.scene && this.engine && (this.scene.dispose(), this.engine.dispose());
+        }
+        playAnimation(e, i = {
+          loop: !1,
+          speedRatio: 1
+        }) {
+          if (this.scene) {
+            this.scene.stopAllAnimations();
+            const n = this.scene.getAnimationGroupByName(e);
+            n && (x("on-play-animation"), window.SHJParseEvent(o.useEvents, "on-play-animation"), n.start(i.loop, i.speedRatio, n.from, n.to, !1));
+          }
+        }
+      }
+      const p = L();
+      return J(() => {
+        t.meshs && (p.value = new B(u.value, t, s).run(), j(u.value, (D) => {
+          p.value && p.value.engine.resize();
+        }));
+      }), Y(() => {
+        p.value && p.value.dispose();
+      }), {
+        canvasRef: u,
+        babylon: p,
+        Babylon: B,
+        babylonLoadingStatus: P,
+        babylonLoadingTitle: y
+      };
+    }, { canvasRef: E, babylon: a, Babylon: M, babylonLoadingStatus: R, babylonLoadingTitle: _ } = I(o.basicOption, o.basicEvents);
+    return l({
+      playAnimation: (t, s) => {
+        const u = t[0].value, y = {
+          loop: t[1].keys[0].defaultValue,
+          speedRatio: t[1].keys[1].defaultValue
+        };
+        a.value.playAnimation(u, y);
+      }
+    }), c(() => f(o.basicOption.environment), (t, s) => {
+      !m(t, s) && a.value && a.value.updateDefaultEnvironment(t);
+    }, {
+      deep: !0
+    }), c(() => f(o.basicOption.shadow), (t, s) => {
+      !m(t, s) && a.value && a.value.updateShadowsLight(t);
+    }, {
+      deep: !0
+    }), c(() => f(o.basicOption.camera), (t, s) => {
+      !m(t, s) && a.value && a.value.updateCamera(t);
+    }, {
+      deep: !0
+    }), c(() => f(o.basicOption.meshs), (t, s) => {
+      !m(t, s) && a.value && (a.value.dispose(), a.value = new M(E.value, o.basicOption, o.basicEvents).run());
+    }, {
+      deep: !0
+    }), c(() => f(o.basicOption.defaultAnimation), (t, s) => {
+      !m(t, s) && a.value && (a.value.dispose(), a.value = new M(E.value, o.basicOption, o.basicEvents).run());
+    }, {
+      deep: !0
+    }), c(() => f(o.basicOption.scene), (t, s) => {
+      !m(t, s) && a.value && a.value.updateScene(t);
+    }, {
+      deep: !0
+    }), c(() => f(o.basicOption.pipelineOption), (t, s) => {
+      !m(t, s) && a.value && a.value.updateScenePipeline(t);
+    }, {
+      deep: !0
+    }), (t, s) => (F(), G("div", te, [
+      V("canvas", {
+        ref_key: "canvasRef",
+        ref: E,
+        class: K(["widget", { show: !A(R) }])
+      }, null, 2),
+      A(R) ? (F(), G("div", {
+        key: 0,
+        ref: "babylonLoadingRef",
+        class: "babylon-loading"
+      }, " 正在加载模型...(" + q(A(_)) + "%) ", 513)) : N("", !0)
+    ]));
+  }
+});
+export {
+  he as default
+};

package/es/components/commons-qrcode/index.d.ts

@@ -0,0 +1,2 @@
+export declare const ZvCommonsQrcode: any;
+export default ZvCommonsQrcode;

package/es/components/commons-qrcode/index.mjs

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

package/es/components/commons-qrcode/index.vue.d.ts

@@ -0,0 +1,90 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+}, {
+    QrcodeVue: import("vue").DefineComponent<{
+        renderAs: {
+            type: import("vue").PropType<import("qrcode.vue").RenderAs>;
+            required: boolean;
+            default: string;
+            validator: (as: any) => boolean;
+        };
+        value: {
+            type: StringConstructor;
+            required: boolean;
+            default: string;
+        };
+        size: {
+            type: NumberConstructor;
+            default: number;
+        };
+        level: {
+            type: import("vue").PropType<import("qrcode.vue").Level>;
+            default: string;
+            validator: (l: any) => boolean;
+        };
+        background: {
+            type: StringConstructor;
+            default: string;
+        };
+        foreground: {
+            type: StringConstructor;
+            default: string;
+        };
+        margin: {
+            type: NumberConstructor;
+            required: boolean;
+            default: number;
+        };
+    }, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        renderAs: {
+            type: import("vue").PropType<import("qrcode.vue").RenderAs>;
+            required: boolean;
+            default: string;
+            validator: (as: any) => boolean;
+        };
+        value: {
+            type: StringConstructor;
+            required: boolean;
+            default: string;
+        };
+        size: {
+            type: NumberConstructor;
+            default: number;
+        };
+        level: {
+            type: import("vue").PropType<import("qrcode.vue").Level>;
+            default: string;
+            validator: (l: any) => boolean;
+        };
+        background: {
+            type: StringConstructor;
+            default: string;
+        };
+        foreground: {
+            type: StringConstructor;
+            default: string;
+        };
+        margin: {
+            type: NumberConstructor;
+            required: boolean;
+            default: number;
+        };
+    }>>, {
+        value: string;
+        size: number;
+        level: import("qrcode.vue").Level;
+        background: string;
+        foreground: string;
+        margin: number;
+        renderAs: import("qrcode.vue").RenderAs;
+    }, {}>;
+}, 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-qrcode/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 p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-106420a4"]]);
+export {
+  p as default
+};

package/es/components/commons-qrcode/index.vue2.mjs

@@ -0,0 +1,21 @@
+import { defineComponent as e, openBlock as r, createBlock as n } from "vue";
+import a from "qrcode.vue";
+const c = e({ name: "zv-commons-qrcode" }), i = /* @__PURE__ */ e({
+  ...c,
+  props: {
+    basicOption: {}
+  },
+  setup(s) {
+    return (o, l) => (r(), n(a, {
+      value: o.basicOption.value,
+      class: "qrcode",
+      level: o.basicOption.level,
+      background: o.basicOption.background,
+      foreground: o.basicOption.foreground,
+      "render-as": "svg"
+    }, null, 8, ["value", "level", "background", "foreground"]));
+  }
+});
+export {
+  i as default
+};