Merge branch 'v1.7.0' of http://192.168.0.115:3000/bill/fuse-code into v1.7.0

src/api/fuse-model.ts

@@ -1,54 +1,52 @@
-import axios from './instance'
-import { 
+import axios from "./instance";
+import {
   FUSE_MODEL_LIST,
   FUSE_INSERT_MODEL,
   FUSE_UPDATE_MODEL,
   FUSE_DELETE_MODEL,
-} from './constant'
-import { params } from '@/env'
-
-import { Scene, SceneStatus, SceneType } from './scene'
+} from "./constant";
+import { params } from "@/env";
 
+import { Scene, SceneStatus, SceneType } from "./scene";
 
 export interface FuseModelAttrs {
-  show: boolean,
-  scale: number,
-  opacity: number,
-  bottom: number,
-  position: SceneLocalPos,
-  rotation: SceneLocalPos
+  show: boolean;
+  scale: number;
+  opacity: number;
+  bottom: number;
+  position: SceneLocalPos;
+  rotation: SceneLocalPos;
 }
 
 export interface FuseModel extends FuseModelAttrs {
-  id: string
-  modelId: number
-  fusionNumId: number,
-  url: string
-  title: string
-  fusionId: number,
-  modelType: string,
-  type: SceneType
-  size: number,
-  status: SceneStatus,
+  id: string;
+  modelId: number;
+  fusionNumId: number;
+  url: string;
+  title: string;
+  fusionId: number;
+  modelType: string;
+  type: SceneType;
+  size: number;
+  status: SceneStatus;
   raw?: any;
-  time: string
+  time: string;
 }
 
 interface ServiceFuseModel {
-  fusionId: number
-  hide: number,
-  opacity: number
-  bottom: number
-  fusionNumId: number,
+  fusionId: number;
+  hide: number;
+  opacity: number;
+  bottom: number;
+  fusionNumId: number;
   transform: {
-    position: SceneLocalPos, 
-    rotation: SceneLocalPos, 
-    scale: [number, number, number]
-  },
-  sceneData: Scene
+    position: SceneLocalPos;
+    rotation: SceneLocalPos;
+    scale: [number, number, number];
+  };
+  sceneData: Scene;
 }
 
-
 const serviceToLocal = (
   serviceModel: ServiceFuseModel,
   test = false
@@ -105,56 +103,63 @@ const serviceToLocal = (
   };
 };
 
-const localToService = (model: FuseModel): Omit<ServiceFuseModel, 'sceneData'> => ({
+const localToService = (
+  model: FuseModel
+): Omit<ServiceFuseModel, "sceneData"> => ({
   fusionId: model.fusionId,
   hide: Number(!model.show),
   opacity: model.opacity,
   fusionNumId: model.fusionNumId,
   bottom: model.bottom,
   transform: {
-    position: model.position, 
-    rotation: model.rotation, 
-    scale: [model.scale, model.scale, model.scale]
-  }
-})
+    position: model.position,
+    rotation: model.rotation,
+    scale: [model.scale, model.scale, model.scale],
+  },
+});
 
-export type FuseModels = FuseModel[]
+export type FuseModels = FuseModel[];
 
 export const fetchFuseModels = async () => {
-  const serviceModels = await axios.get<ServiceFuseModel[]>(FUSE_MODEL_LIST, { params: { caseId: params.caseId } })
-  console.error(serviceModels.map((item, index) => serviceToLocal(item, index == 0)))
-  return serviceModels.map((item, index) => serviceToLocal(item, index == 0))
-} 
+  const serviceModels = await axios.get<ServiceFuseModel[]>(FUSE_MODEL_LIST, {
+    params: { caseId: params.caseId },
+  });
+  console.error(
+    serviceModels.map((item, index) => serviceToLocal(item, index == 0))
+  );
+  return serviceModels.map((item, index) => serviceToLocal(item, index == 0));
+};
 
 export const postAddFuseModel = async (model: FuseModel) => {
-  const upload = localToService(model)
+  const upload = localToService(model);
   const serviceModel = await axios<ServiceFuseModel>({
     url: FUSE_INSERT_MODEL,
-    method: 'POST',
+    method: "POST",
     data: {
       caseId: params.caseId,
       modelId: model.modelId,
       hide: upload.hide,
       transform: upload.transform,
       opacity: upload.opacity,
-      bottom: upload.bottom
-    }
-  })
-  return serviceToLocal(serviceModel)
-}
+      bottom: upload.bottom,
+    },
+  });
+  return serviceToLocal(serviceModel);
+};
 
 export const postUpdateFuseModels = (model: FuseModel) => {
-  const upload = localToService(model)
+  const upload = localToService(model);
   return axios.post<undefined>(FUSE_UPDATE_MODEL, {
     fusionNumId: upload.fusionNumId,
     hide: upload.hide,
     transform: upload.transform,
     opacity: upload.opacity,
-    bottom: upload.bottom
-  })
-}
+    bottom: upload.bottom,
+  });
+};
 
 export const postDeleteFuseModel = (model: FuseModel) => {
-  return axios.post<undefined>(FUSE_DELETE_MODEL, { fusionNumId: model.fusionNumId })
-}
-
+  return axios.post<undefined>(FUSE_DELETE_MODEL, {
+    fusionNumId: model.fusionNumId,
+  });
+};

src/api/scene.ts

@@ -1,17 +1,6 @@
 import axios from './instance'
 import { MODEL_LIST, MODEL_SIGN, SCENE_LIST_ALL } from './constant'
 import { params } from '@/env'
-import type { PagingResult } from './index'
-
-export enum SceneType {
-  SWKK = 0,
-  SWKJ = 1,
-  SWSS = 2,
-  SWMX = 3,
-  SWSSMX = 4,
-  SWYDSS = 5,
-  SWYDMX = 6,
-}
 
 export enum SceneStatus {
   DEL = -1,
@@ -22,6 +11,15 @@ export enum SceneStatus {
   RERUN = 4,
 }
 
+export enum SceneType {
+  SWKK = 0,
+  SWKJ = 1,
+  SWSS = 2,
+  SWMX = 3,
+  SWSSMX = 4,
+  SWYDSS = 5,
+  SWYDMX = 6,
+}
 export const SceneTypeDesc: Record<SceneType, string>  = {
   [SceneType.SWKK]: '八目',
   [SceneType.SWKJ]: '双目转台',
@@ -32,6 +30,8 @@ export const SceneTypeDesc: Record<SceneType, string>  = {
   [SceneType.SWYDMX]: '激光移动Mesh场景'
 }
 
+
+
 export interface Scene {
   createTime: string
   id: number

src/layout/edit/fuse-left-pano.vue

@@ -1,6 +1,6 @@
 <template>
   <LeftPano>
-    <ModelList 
+    <ModelList
       :can-change="custom.modelsChangeStore"
       @delete-model="modelDelete"
       @click-model="modelChangeSelect"
@@ -12,44 +12,42 @@
       </template>
     </ModelList>
   </LeftPano>
-
 </template>
 
 <script lang="ts" setup>
-import { watchEffect, ref } from 'vue'
-import { custom } from '@/env'
-import { getSceneModel } from '@/sdk'
-import { fuseModels, getFuseModelShowVariable } from '@/store'
+import { watchEffect, ref } from "vue";
+import { custom } from "@/env";
+import { activeModel, getSceneModel } from "@/sdk";
+import { fuseModels, getFuseModelShowVariable } from "@/store";
 
-import ModelList from '../model-list/index.vue'
-import SelectModel from './scene-select.vue'
-import { LeftPano } from '@/layout'
+import ModelList from "../model-list/index.vue";
+import SelectModel from "./scene-select.vue";
+import { LeftPano } from "@/layout";
 
-import type { FuseModel } from '@/store'
+import type { FuseModel } from "@/store";
 
 const modelChangeSelect = (model: FuseModel) => {
   if (getFuseModelShowVariable(model).value) {
     if (custom.currentModel !== model) {
-      getSceneModel(model)?.changeSelect(true)
-      custom.currentModel = model
+      getSceneModel(model)?.changeSelect(true);
+      activeModel({ active: model, showMode: "fuse" });
     } else {
-      getSceneModel(custom.currentModel)?.changeSelect(false)
-      custom.currentModel = null
+      getSceneModel(custom.currentModel)?.changeSelect(false);
+      activeModel({ showMode: "fuse" });
     }
   }
-}
+};
 
 watchEffect(() => {
   if (custom.currentModel && !getFuseModelShowVariable(custom.currentModel).value) {
-    custom.currentModel = null
+    activeModel({ showMode: "fuse" });
   }
-})
+});
 
 const modelDelete = (model: FuseModel) => {
-  const index = fuseModels.value.indexOf(model)
+  const index = fuseModels.value.indexOf(model);
   if (~index) {
-    fuseModels.value.splice(index, 1)
+    fuseModels.value.splice(index, 1);
   }
-}
-
-</script>
+};
+</script>

src/layout/model-list/index.vue

@@ -44,7 +44,7 @@ import { computed, watchEffect } from "vue";
 import { custom } from "@/env";
 import List from "@/components/list/index.vue";
 import ModelSign from "./sign.vue";
-import { getSupperPanoModel } from "@/sdk/association";
+import { activeModel, getSupperPanoModel } from "@/sdk/association";
 import { fuseModels, getFuseModelShowVariable } from "@/store";
 
 import type { FuseModel } from "@/store";
@@ -76,18 +76,16 @@ const modelList = computed(() =>
 const modelChangeSelect = (model: FuseModel, mode: "pano" | "fuse") => {
   if (getFuseModelShowVariable(model).value) {
     if (custom.currentModel === model && mode === custom.showMode) {
-      custom.currentModel = null;
-      custom.showMode = "fuse";
+      activeModel({ showMode: "fuse" });
     } else {
-      custom.currentModel = model;
-      custom.showMode = mode;
+      activeModel({ showMode: mode, active: model });
     }
   }
 };
 
 watchEffect(() => {
   if (custom.currentModel && !getFuseModelShowVariable(custom.currentModel).value) {
-    custom.currentModel = null;
+    activeModel({ showMode: "fuse" });
   }
 });
 const modelDelete = (model: FuseModel) => {

src/model/platform.ts

@@ -1,7 +1,7 @@
 import { watchEffect, nextTick } from 'vue'
 import { fuseModelsLoaded, scenes, SceneType, setting, caseProject } from '@/store'
 import { fuseModel } from './'
-import { initialSDK, initialed as fuseInitialed, sdk as fuseSDK, analysisPose, analysisPoseInfo } from '@/sdk'
+import { initialSDK, initialed as fuseInitialed, sdk as fuseSDK, analysisPose, analysisPoseInfo, setPose } from '@/sdk'
 import { asyncTimeout } from '@/utils'
 import { aMapToWgs84 } from "@/utils/coord";
 
@@ -97,8 +97,8 @@ export async function exposeFactory(type: ModelType, win?: any): Promise<ModelEx
           }
         },
         async setView(flyData: string) {
-          const pose = analysisPoseInfo(JSON.parse(flyData))
-          sdk.comeTo({ dur: 300, ...pose })
+          console.error(JSON.parse(flyData))
+          setPose(JSON.parse(flyData), sdk)
         }
       }
     },

src/sdk/association/fuseMode.ts

@@ -144,48 +144,56 @@ const setModels = (sdk: SDK, models: FuseModels, oldModels: FuseModels) => {
   }
 };
 
+export const activeModel = (status: {
+  showMode: "fuse" | "pano";
+  active?: FuseModel;
+}) => {
+  const oldStatus = {
+    showMode: custom.showMode,
+    active: custom.currentModel,
+  };
+  if (
+    toRaw(status.active) === toRaw(oldStatus.active) &&
+    status.showMode === oldStatus.showMode
+  ) {
+    return;
+  }
 
-export const associationModels = (sdk: SDK) => {
-  // watch(
-  //   () => custom.currentModel === item,
-  //   (selected) => {
-  //     isUnSet || getSceneModel(item)?.changeSelect(selected);
-  //   }
-  // );
-
-  watch(
-    () => ({
-      showMode: custom.showMode,
-      active: custom.currentModel,
-    }),
-    (status, oldStatus, onCleanup) => {
-      const model = status.active && getSceneModel(status.active)!;
-      const oldModel = oldStatus.active && getSceneModel(oldStatus.active)!;
+  const model = status.active && getSceneModel(status.active)!;
+  const oldModel = oldStatus.active && getSceneModel(oldStatus.active)!;
 
-      if (status.showMode !== 'pano' && model) {
-        model && model.changeSelect(true);
-      }
+  if (status.showMode !== "pano" && model) {
+    model && model.changeSelect(true);
+  }
 
-      if (model && status.active === oldStatus.active) {
-        if (status.showMode === "pano") {
-          model && model.flyInPano();
-        } else {
-          model && model.flyOutPano();
-        }
-      } else {
-        if (oldStatus.showMode !== status.showMode) {
-          if (oldStatus.showMode === "pano") {
-            oldModel && oldModel.flyOutPano();
-          }
-        }
-        if (status.showMode === "pano") {
-          model && model.flyInPano();
-        } else {
-          console.log('select')
-        }
+  if (model && status.active === oldStatus.active) {
+    if (status.showMode === "pano") {
+      model && model.flyInPano();
+    } else {
+      model && model.flyOutPano();
+    }
+  } else {
+    if (oldStatus.showMode !== status.showMode) {
+      if (oldStatus.showMode === "pano") {
+        oldModel && oldModel.flyOutPano();
       }
     }
-  );
+    if (status.showMode === "pano") {
+      model && model.flyInPano();
+    } else {
+      console.log("select");
+    }
+  }
+
+  custom.currentModel = status.active!;
+  custom.showMode = status.showMode;
+};
+
+export const associationModels = (sdk: SDK) => {
+  sdk.sceneBus.on("modeChange", (mode) => {
+    console.log("scene出发modeChange", mode);
+    custom.showMode = mode;
+  });
 
   const getModels = () =>
     fuseModels.value.filter(

src/sdk/association/guide.ts

@@ -1,62 +1,48 @@
-import { sdk } from '../sdk'
-import { toRaw, ref, watch, watchEffect } from 'vue'
-import { 
-  viewModeStack, 
-  showLeftPanoStack, 
-  custom, 
-} from '@/env'
-import { 
-  togetherCallback,
-  asyncTimeout
-} from '@/utils'
-import { 
-  fuseModels, 
-  isEdit, 
-  sysBus, 
-  fuseModelsLoaded,
-  getGuidePaths
-} from '@/store'
-
-import type { FuseModel, FuseModels, Guide, GuidePath } from '@/store'
-import { analysisPoseInfo } from '.'
+import { sdk } from "../sdk";
+import { toRaw, ref, watch, watchEffect } from "vue";
+import { viewModeStack, showLeftPanoStack, custom } from "@/env";
+import { togetherCallback, asyncTimeout } from "@/utils";
+import { fuseModels, isEdit, sysBus, fuseModelsLoaded } from "@/store";
+import type { FuseModel, FuseModels, Guide, GuidePath } from "@/store";
+import { analysisPoseInfo } from ".";
 
 // -----------------导览关联--------------------
 
 const fullView = async (fn: () => void) => {
   const popViewMode = togetherCallback([
-    viewModeStack.push(ref('full')),
-    showLeftPanoStack.push(ref(false))
-  ])
+    viewModeStack.push(ref("full")),
+    showLeftPanoStack.push(ref(false)),
+  ]);
   let isFull = false;
   try {
-    await document.documentElement.requestFullscreen()
+    await document.documentElement.requestFullscreen();
     isFull = true;
   } catch {}
-  
-  const driving = () => document.fullscreenElement || fn()
-  const stop = (ev: KeyboardEvent) => ev.key == "Escape" && fn()
+
+  const driving = () => document.fullscreenElement || fn();
+  const stop = (ev: KeyboardEvent) => ev.key == "Escape" && fn();
 
   if (isFull) {
-    document.addEventListener('fullscreenchange', driving)
-    document.addEventListener('fullscreenerror', fn)
+    document.addEventListener("fullscreenchange", driving);
+    document.addEventListener("fullscreenerror", fn);
   } else {
-    document.addEventListener("keyup", stop)
+    document.addEventListener("keyup", stop);
   }
 
   return () => {
-    popViewMode()
+    popViewMode();
     if (isFull) {
-      document.fullscreenElement && document.exitFullscreen()
-      document.removeEventListener('fullscreenchange', driving)
-      document.removeEventListener('fullscreenerror', fn)
+      document.fullscreenElement && document.exitFullscreen();
+      document.removeEventListener("fullscreenchange", driving);
+      document.removeEventListener("fullscreenerror", fn);
     } else {
-      document.removeEventListener("keyup", stop)
+      document.removeEventListener("keyup", stop);
     }
-  }
-}
+  };
+};
 
 export const recovery = async (guide: Guide) => {
-  let rFuseModels: (FuseModel & {viewShow: boolean})[];
+  let rFuseModels: (FuseModel & { viewShow: boolean })[];
   try {
     if (!guide.recoveryContent) {
       throw "没有recovery";
@@ -65,111 +51,128 @@ export const recovery = async (guide: Guide) => {
   } catch (e) {
     return () => {};
   }
-  const initFuseModels = JSON.parse(JSON.stringify(fuseModels.value)) as FuseModels;
-  const initViewShow = fuseModels.value.map(item => custom.showModelsMap.get(item))
-
-
-  console.error(initFuseModels, rFuseModels)
-  const setModels = async (models:  (FuseModel & {viewShow: boolean})[]) => {
+  const initFuseModels = JSON.parse(
+    JSON.stringify(fuseModels.value)
+  ) as FuseModels;
+  const initViewShow = fuseModels.value.map((item) =>
+    custom.showModelsMap.get(item)
+  );
+
+  const setModels = async (models: (FuseModel & { viewShow: boolean })[]) => {
     for (let i = 0; i < models.length; i++) {
-      const ndx = fuseModels.value.findIndex(({ modelId }) => modelId === models[i].modelId);
+      const ndx = fuseModels.value.findIndex(
+        ({ modelId }) => modelId === models[i].modelId
+      );
       if (~ndx) {
         Object.assign(fuseModels.value[ndx], models[i]);
-        custom.showModelsMap.set(toRaw(fuseModels.value[ndx]), models[i].viewShow)
+        custom.showModelsMap.set(
+          toRaw(fuseModels.value[ndx]),
+          models[i].viewShow
+        );
       } else {
         fuseModels.value.push(models[i]);
-        custom.showModelsMap.set(toRaw(models[i]), models[i].viewShow)
+        custom.showModelsMap.set(toRaw(models[i]), models[i].viewShow);
       }
     }
     // console.log(models)
     for (let i = 0; i < fuseModels.value.length; i++) {
-      const ndx = models.findIndex(({ modelId }) => modelId === fuseModels.value[i].modelId);
+      const ndx = models.findIndex(
+        ({ modelId }) => modelId === fuseModels.value[i].modelId
+      );
       if (!~ndx) {
         fuseModels.value.splice(i, 1);
-        i--
+        i--;
       }
     }
 
-    await asyncTimeout(100)
+    await asyncTimeout(100);
     await new Promise<void>((resolve) => {
       const stop = watchEffect(() => {
         if (fuseModelsLoaded.value) {
-          setTimeout(() => stop())
-          resolve()
+          setTimeout(() => stop());
+          resolve();
         }
-      })
-    })
+      });
+    });
   };
-  
-  
+
   for (let i = 0; i < fuseModels.value.length; i++) {
-    const ndx = rFuseModels.findIndex(({ modelId }) => modelId === fuseModels.value[i].modelId);
+    const ndx = rFuseModels.findIndex(
+      ({ modelId }) => modelId === fuseModels.value[i].modelId
+    );
     if (!~ndx) {
-      rFuseModels.push({...fuseModels.value[i], viewShow: false})
+      rFuseModels.push({ ...fuseModels.value[i], viewShow: false });
     }
   }
 
   await setModels(rFuseModels);
-  return () => 
-    setModels(initFuseModels.map((item, i) => ({...item, viewShow: initViewShow[i]!})));
-  
+  return () =>
+    setModels(
+      initFuseModels.map((item, i) => ({ ...item, viewShow: initViewShow[i]! }))
+    );
 };
 
 export enum ScenePlayIngEnum {
   ing = 1,
   stop = 0,
-  ready = 2
+  ready = 2,
 }
-export const isScenePlayIng = ref<ScenePlayIngEnum>(ScenePlayIngEnum.stop)
-let pauseRecovery: () => void
-export const playSceneGuide = async (paths: GuidePath[], changeIndexCallback?: (index: number) => void, forceFull = false) => {
+export const isScenePlayIng = ref<ScenePlayIngEnum>(ScenePlayIngEnum.stop);
+let pauseRecovery: () => void;
+export const playSceneGuide = async (
+  paths: GuidePath[],
+  changeIndexCallback?: (index: number) => void,
+  forceFull = false
+) => {
   if (isScenePlayIng.value) {
-    throw new Error('导览正在播放')
+    throw new Error("导览正在播放");
   }
-  isScenePlayIng.value = ScenePlayIngEnum.ready
+  isScenePlayIng.value = ScenePlayIngEnum.ready;
   // pauseRecovery = await recovery(guide)
-  isScenePlayIng.value = ScenePlayIngEnum.ing
+  isScenePlayIng.value = ScenePlayIngEnum.ing;
 
-  const sceneGuide = sdk.enterSceneGuide(paths.map(path => ({ ...path, ...analysisPoseInfo(path)})))
+  const sceneGuide = sdk.enterSceneGuide(
+    paths.map((path) => ({ ...path, ...analysisPoseInfo(path) }))
+  );
 
-  changeIndexCallback && sceneGuide.bus.on('changePoint', changeIndexCallback)
+  changeIndexCallback && sceneGuide.bus.on("changePoint", changeIndexCallback);
 
-  const quitHandler = pauseSceneGuide
-  const clearHandler = !forceFull && isEdit.value ? null : await fullView(quitHandler)
+  const quitHandler = pauseSceneGuide;
+  const clearHandler =
+    !forceFull && isEdit.value ? null : await fullView(quitHandler);
   if (!clearHandler) {
-    sysBus.on('leave', quitHandler, { last: true })
-    sysBus.on('save', quitHandler, { last: true })
+    sysBus.on("leave", quitHandler, { last: true });
+    sysBus.on("save", quitHandler, { last: true });
   }
 
-  sceneGuide.play()
+  sceneGuide.play();
   const reces = [
-    new Promise(resolve => sceneGuide.bus.on('playComplete', resolve)),
-    new Promise<void>(resolve => {
+    new Promise((resolve) => sceneGuide.bus.on("playComplete", resolve)),
+    new Promise<void>((resolve) => {
       const stop = watch(isScenePlayIng, () => {
         if (!isScenePlayIng.value) {
-          resolve()
-          sceneGuide.pause()
-          stop()
+          resolve();
+          sceneGuide.pause();
+          stop();
         }
-      })
+      });
     }),
-  ]
+  ];
+
+  await Promise.race(reces);
+  pauseSceneGuide();
 
-  await Promise.race(reces)
-  pauseSceneGuide()
-  
   if (clearHandler) {
-    clearHandler()
+    clearHandler();
   } else {
-    sysBus.off('leave', quitHandler)
-    sysBus.off('save', quitHandler)
+    sysBus.off("leave", quitHandler);
+    sysBus.off("save", quitHandler);
   }
-  sceneGuide.clear()
-  sceneGuide.bus.off('changePoint')
-}
+  sceneGuide.clear();
+  sceneGuide.bus.off("changePoint");
+};
 
 export const pauseSceneGuide = () => {
-  isScenePlayIng.value = ScenePlayIngEnum.stop
-  pauseRecovery && pauseRecovery()
-}
-
+  isScenePlayIng.value = ScenePlayIngEnum.stop;
+  pauseRecovery && pauseRecovery();
+};

src/sdk/association/index.ts

@@ -1,19 +1,18 @@
-import { nextTick, ref, toRaw, watchEffect } from "vue"
-import {Pose, SceneModel, sdk, SDK } from "../sdk"
-import { associationModels, sceneModelMap } from "./fuseMode"
-import { FuseModel, fuseModelsLoaded, GuidePath, setting } from "@/store"
-import { associationTaggings } from "./tagging"
-import { associationSetting } from "./setting"
-import { associationMessaures } from "./measure"
-
+import { nextTick, ref, toRaw, watchEffect } from "vue";
+import { Pose, SceneModel, sdk, SDK } from "../sdk";
+import { activeModel, associationModels, sceneModelMap } from "./fuseMode";
+import { FuseModel, fuseModelsLoaded, GuidePath, setting } from "@/store";
+import { associationTaggings } from "./tagging";
+import { associationSetting } from "./setting";
+import { associationMessaures } from "./measure";
+import { custom } from "@/env";
 
 export const getSupperPanoModel = () => {
   const supperModel = ref<FuseModel | null>(null);
 
-  
   const interval = setInterval(() => {
     if (!sdk) return;
-    clearInterval(interval)
+    clearInterval(interval);
 
     sdk.sceneBus.on("cameraChange", () => {
       const data = sdk.canTurnToPanoMode();
@@ -27,19 +26,18 @@ export const getSupperPanoModel = () => {
       }
       supperModel.value = null;
     });
-  }, 16)
-  
+  }, 16);
 
   return supperModel;
 };
 
 export const analysisPose = (pose: Pose) => {
-  if ('model' in pose && pose.model) {
-    let info: GuidePath['panoInfo'] | undefined = undefined
-    let fuseMode: FuseModel
+  if ("model" in pose && pose.model) {
+    let info: GuidePath["panoInfo"] | undefined = undefined;
+    let fuseMode: FuseModel;
     for (const [k, v] of Array.from(sceneModelMap.entries())) {
       if (toRaw(v) === toRaw(pose.model)) {
-        fuseMode = toRaw(k)
+        fuseMode = toRaw(k);
       }
     }
     if (fuseMode!) {
@@ -47,28 +45,28 @@ export const analysisPose = (pose: Pose) => {
         panoId: pose.panoId,
         modelId: fuseMode.id,
         posInModel: pose.posInModel,
-        rotInModel: pose.rotInModel
-      }
+        rotInModel: pose.rotInModel,
+      };
       return {
         position: pose.position,
         target: pose.target,
-        panoInfo: info
-      }
+        panoInfo: info,
+      };
     }
-  } 
-  return pose
-}
+  }
+  return pose;
+};
 
 export const analysisPoseInfo = (info: ReturnType<typeof analysisPose>) => {
-  let pose: Pose = { target: info.target, position: info.position }
-  if ('panoInfo' in info && info.panoInfo) {
-    let sceneModel: SceneModel
+  let pose: Pose = { target: info.target, position: info.position };
+  if ("panoInfo" in info && info.panoInfo) {
+    let sceneModel: SceneModel;
     for (const [k, v] of Array.from(sceneModelMap.entries())) {
       if (k.id === info.panoInfo.modelId) {
-        sceneModel = toRaw(v)
+        sceneModel = toRaw(v);
       }
     }
-    
+
     if (sceneModel!) {
       pose = {
         ...pose,
@@ -76,28 +74,46 @@ export const analysisPoseInfo = (info: ReturnType<typeof analysisPose>) => {
         panoId: info.panoInfo.panoId,
         posInModel: info.panoInfo.posInModel,
         rotInModel: info.panoInfo.rotInModel,
-      }
+      };
     }
   }
-  return pose
-}
+  return pose;
+};
+
+export const setPose = (info: ReturnType<typeof analysisPose>, _sdk = sdk) => {
+  const pose = analysisPoseInfo(info);
+  if ("model" in pose) {
+    setTimeout(() => {
+      for (const [k, v] of Array.from(sceneModelMap.entries())) {
+        if (toRaw(v) === toRaw(pose.model)) {
+          activeModel({ showMode: "pano", active: k });
+          return;
+        }
+      }
+    }, 300);
+  } else {
+    activeModel({ showMode: "fuse" });
+  }
+  setTimeout(() => {
+    sdk.comeTo({ ...pose, dur: 300 });
+  });
+};
 
 export const setupAssociation = (mountEl: HTMLDivElement, sdk: SDK) => {
-  associationModels(sdk)
+  associationModels(sdk);
 
   const stopWatch = watchEffect(() => {
     if (fuseModelsLoaded.value && setting.value) {
-      associationTaggings(sdk, mountEl)
-      associationMessaures(sdk)
-      associationSetting(sdk, mountEl)
-      nextTick(() => stopWatch())
+      associationTaggings(sdk, mountEl);
+      associationMessaures(sdk);
+      associationSetting(sdk, mountEl);
+      nextTick(() => stopWatch());
     }
-  })
-}
-
+  });
+};
 
-export * from './fuseMode'
-export * from './guide'
-export * from './measure'
-export * from './setting'
-export * from './tagging'
+export * from "./fuseMode";
+export * from "./guide";
+export * from "./measure";
+export * from "./setting";
+export * from "./tagging";

src/sdk/association/setting.ts

@@ -1,7 +1,7 @@
 import { setting } from "@/store";
 import { nextTick, watchEffect } from "vue";
 import { SDK } from "../sdk";
-import { analysisPoseInfo } from ".";
+import { setPose } from ".";
 
 export const associationSetting = (sdk: SDK, mountEl: HTMLDivElement) => {
   watchEffect(() => {
@@ -10,8 +10,7 @@ export const associationSetting = (sdk: SDK, mountEl: HTMLDivElement) => {
 
   const stopWatchPose = watchEffect(() => {
     if (!setting.value?.pose) return;
-    console.error('comeTo', analysisPoseInfo(setting.value.pose))
-    sdk.comeTo(analysisPoseInfo(setting.value.pose));
+    setPose(setting.value?.pose)
     nextTick(() => stopWatchPose());
   });
 

src/sdk/sdk.ts

@@ -72,10 +72,7 @@ export type AddModelProps = Pick<FuseModel, "url" | "id"> &
     fromType: any;
   } & ModelAttrRange;
 
-export type SceneGuidePath = Pick<
-  GuidePath,
-  "speed" | "time"
-> & Pose;
+export type SceneGuidePath = Pick<GuidePath, "speed" | "time"> & Pose;
 export interface SceneGuide {
   bus: Emitter<{ changePoint: number; playComplete: void }>;
   play: () => void;
@@ -133,21 +130,26 @@ export type StartMeasure<T extends StoreMeasure["type"]> = Measure<T> & {
   }>;
 };
 
-export type Pose = {
-  position: SceneLocalPos; 
-  target: SceneLocalPos,
-} | {
-  panoId: any,
-  model: SceneModel,
-  posInModel: SceneLocalPos,
-  rotInModel: SceneLocalPos,
-  position: SceneLocalPos; 
-  target: SceneLocalPos,
-}
+export type Pose =
+  | {
+      position: SceneLocalPos;
+      target: SceneLocalPos;
+    }
+  | {
+      panoId: any;
+      model: SceneModel;
+      posInModel: SceneLocalPos;
+      rotInModel: SceneLocalPos;
+      position: SceneLocalPos;
+      target: SceneLocalPos;
+    };
 
 export interface SDK {
   layout: HTMLDivElement;
-  sceneBus: Emitter<{ cameraChange: SceneLocalPos }>;
+  sceneBus: Emitter<{
+    cameraChange: SceneLocalPos;
+    modeChange: "pano" | "fuse";
+  }>;
   setBackdrop: (
     drop: string,
     type: SettingResourceType,

src/views/guide/edit-paths.vue

@@ -88,7 +88,7 @@ import {
   pauseSceneGuide,
   isScenePlayIng,
   analysisPose,
-  analysisPoseInfo,
+  setPose,
 } from "@/sdk";
 import {
   createGuidePath,
@@ -98,13 +98,12 @@ import {
   getGuidePaths,
   guidePaths,
 } from "@/store";
-import { Dialog, Message } from "bill/index";
+import { Dialog } from "bill/index";
 import { useViewStack } from "@/hook";
-import { nextTick, onUnmounted, ref, toRaw, watch, watchEffect } from "vue";
+import { nextTick, onUnmounted, ref, watch, watchEffect } from "vue";
 import {
   showRightPanoStack,
   showLeftCtrlPanoStack,
-  bottomBarHeightStack,
   showLeftPanoStack,
   showRightCtrlPanoStack,
   getResource,
@@ -196,7 +195,7 @@ const deleteAll = async () => {
 };
 
 const changeCurrent = (path: GuidePath) => {
-  sdk.comeTo({ dur: 300, ...path, ...analysisPoseInfo(path) });
+  setPose(path);
   current.value = path;
 };
 

src/views/merge/index.vue

@@ -145,10 +145,10 @@ useViewStack(autoSaveFuseModels);
 
 useViewStack(() => {
   const stopWatch = watchEffect(() => {
-    if (custom.showMode === "fuse") {
-      sdk.showGrid();
-    } else {
+    if (custom.showMode === "pano") {
       sdk.hideGrid();
+    } else {
+      sdk.showGrid();
     }
   });
   return () => {