fuse-code/src/sdk/association/guide.ts

import { SceneGuide, sdk } from "../sdk";
import { toRaw, ref, watch, watchEffect, computed } from "vue";
import { viewModeStack, showLeftPanoStack, custom, showTaggingsStack, showPathsStack, showMeasuresStack, showSearchStack } from "@/env";
import { togetherCallback, asyncTimeout } from "@/utils";
import { fuseModels, isEdit, sysBus, fuseModelsLoaded, selectPaths } from "@/store";
import type { FuseModel, FuseModels, Guide, GuidePath } from "@/store";
import { analysisPoseInfo } from ".";
import { fullView, isScenePlayRun, pauseScene, playScene } from "@/utils/full";
import { animationGroup, currentTime, play } from "./animation";

// -----------------导览关联--------------------

export const recovery = async (guide: Guide) => {
  let rFuseModels: (FuseModel & { viewShow: boolean })[];
  try {
    if (!guide.recoveryContent) {
      throw "没有recovery";
    }
    rFuseModels = JSON.parse(guide.recoveryContent);
  } catch (e) {
    return () => {};
  }
  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
      );
      if (~ndx) {
        Object.assign(fuseModels.value[ndx], models[i]);
        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);
      }
    }
    // console.log(models)
    for (let i = 0; i < fuseModels.value.length; i++) {
      const ndx = models.findIndex(
        ({ modelId }) => modelId === fuseModels.value[i].modelId
      );
      if (!~ndx) {
        fuseModels.value.splice(i, 1);
        i--;
      }
    }

    await asyncTimeout(100);
    await new Promise<void>((resolve) => {
      const stop = watchEffect(() => {
        if (fuseModelsLoaded.value) {
          setTimeout(() => stop());
          resolve();
        }
      });
    });
  };

  for (let i = 0; i < fuseModels.value.length; i++) {
    const ndx = rFuseModels.findIndex(
      ({ modelId }) => modelId === fuseModels.value[i].modelId
    );
    if (!~ndx) {
      rFuseModels.push({ ...fuseModels.value[i], viewShow: false });
    }
  }

  await setModels(rFuseModels);
  return () =>
    setModels(
      initFuseModels.map((item, i) => ({ ...item, viewShow: initViewShow[i]! }))
    );
};

export const playSceneGuide = (
  paths: GuidePath[],
  changeIndexCallback?: (index: number) => void,
  forceFull = false,
  guide?: Guide
) => {
  let sceneGuide: SceneGuide;
  currentTime.value = 0
  let pop: (() => void) | null = null
  return playScene(
    {
      create: () => {
        sceneGuide = sdk.enterSceneGuide(
          paths.map((path) => ({ ...path, ...analysisPoseInfo(path) }))
        );
        sceneGuide.bus.on("changePoint", (index) => {
          if (paths[index - 1].playAnimation) {
            play.value = true
          }
          changeIndexCallback && changeIndexCallback(index);
        });
        const oldSelect = [...selectPaths.selects.value]
        const oldUSelect = [...selectPaths.unSelects.value]
        selectPaths.all.value = guide ? guide.showPath :  true
        pop = togetherCallback([
          showTaggingsStack.push(computed(() => guide ? guide.showTagging : true)),
          () => {
            oldSelect.forEach(item => selectPaths.updateSelectId(item.id, true))
            oldUSelect.forEach(item => selectPaths.updateSelectId(item.id, false))
          },
          // showPathsStack.push(computed(() => guide ? guide.showPath : true)),
          showMeasuresStack.push(computed(() => guide ? guide.showMeasure : true)),
          showSearchStack.push(ref(false))
        ])
      },
      play: () => {
        sceneGuide.play();
        return new Promise((resolve) =>
          sceneGuide.bus.on("playComplete", resolve)
        );
      },
      pause: () => {
        sceneGuide.pause();
        play.value = false
      },
      clear: () => {
        currentTime.value = 0
        sceneGuide.clear();
        pop && pop()
        sceneGuide.bus.off("changePoint");
      },
    },
    forceFull
  );
};

export const pauseSceneGuide = pauseScene;
export const isScenePlayIng = isScenePlayRun;