traffic-laser/src/hook/useLaser.ts

import { sdkFactory, SDK, SDKProps, Pos3D, Mode } from "@/sdk";
import { store } from "@/store";
import { loadLib } from "@/utils";
import { Message } from "@kankan/components/index";
import { ui18n } from "@/lang";
import { DataSetAtom } from "@/sdk";
import {laserModeStack} from "@/hook/custom";

let sdk: SDK;
export const useSDK = () => sdk;
export const setSDK = (ssdk: SDK) => (sdk = ssdk);

export const useDataset = (dataset: DataSetAtom) => {
  const sdkDatasets = sdk.scene.getDataSets();
  const rdataset = sdkDatasets.find((atom) => atom.id === dataset.id);

  if (rdataset) {
    const flyToRaw = rdataset.flyTo.bind(rdataset);
    rdataset.flyTo = () => {
      const success = flyToRaw();
      useCanFly(success);
      return success;
    };
  }

  return rdataset;
};

const listenLoaded: Function[] = [];
export const useAsyncSDK = () => {
  if (sdk) {
    return Promise.resolve(sdk);
  } else {
    return new Promise<SDK>((resolve) => {
      listenLoaded.push(resolve);
    });
  }
};

let initial = false;
export const loadSetupLaser = async () => {
  if (initial) {
    return useAsyncSDK();
  }
  initial = true;
  const libs = [
    `./static/lib/proj4/proj4.js`,
    `./static/lib/jquery/jquery-3.1.1.min.js`,
    `./static/lib/other/BinaryHeap.js`,
    `./static/lib/tween/tween.min.js`,
  ];
  await Promise.all(libs.map(loadLib));
  await loadLib(`./static/lib/potree/potree.js`);
};

export const setupLaser = async (
  props: Omit<SDKProps, "store"> & { store: typeof store }
) => {
  await loadSetupLaser();
  return new Promise<SDK>((resolve) => {
    sdk = sdkFactory(props as any);
    sdk.scene.on("allLoaded", () => {
      console.error("allloaded")
      resolve(sdk)
    });
  }).then((sdk) => {
    for (const fn of listenLoaded) {
      setTimeout(fn, 0, sdk);
    }
    listenLoaded.length = 0;
    return sdk;
  });
};

export const useCanFly = (
  pos: Pos3D | Pos3D[] | ReturnType<SDK["gotoEntity"]>,
  message = ui18n.t("scene.flyUnImages")
) => {
  let isFly = true;

  if (["tooFar"].includes(pos as string)) {
    if (pos === "posNoChange") {
      message = ui18n.t("scene.flyCurrent");
    }
    isFly = false;
  }

  if (laserModeStack.current.value.value === Mode.pano && isFly) {
    if (typeof pos === "string") {
      isFly = true;
    } else if (typeof pos === "boolean") {
      isFly = pos;
    } else {
      const poss = Array.isArray(pos) ? pos : [pos as Pos3D];
      isFly = sdk.scene.canShapeToPanoMode(poss);
    }
  }

  isFly || Message.warning(message);
  return isFly;
};

export const useFlyTag = (pos: Pos3D) => {
  let isFly = useCanFly(pos);
  return sdk.scene.comeToTag(pos);
};

export const useFlyEntity = (
  pos: Pos3D | Pos3D[],
  ...args: Parameters<SDK["gotoEntity"]>
) => {
  console.error(args);
  return useCanFly(sdk.gotoEntity(...args));
};
export const useFlyMeasure = (
  pos: Pos3D | Pos3D[],
  ...args: Parameters<SDK["scene"]["comeToMeasure"]>
) => {
  let isFly = useCanFly(pos);
  return sdk.scene.comeToMeasure(...args);
};