fuse-code/src/sdk/sdk.ts

import cover from './cover'
import { loadLib } from '@/utils'

import type { ModelAttrs, Model, GuidePath, GuidePaths } from '@/store'
import type { Emitter } from 'mitt'


type SceneModelAttrs = ModelAttrs & { select: boolean }
export type SceneModel = ToChangeAPI<Omit<SceneModelAttrs, 'position' | 'rotation'>>
  & { 
    bus: Emitter<
      Pick<SceneModelAttrs, 'select'> & 
      { 
        loadError: void,
        loadDone: void, 
        loadProgress: number,
        changeSelect: boolean,
        transformChanged: {
          position?: SceneLocalPos,
          scale?: number,
          rotation?: SceneLocalPos,
          bottom?: number
        }
      }
    > 
    destroy: () => void 
    enterRotateMode: () => void
    enterMoveMode: () => void
    leaveTransform: () => void
  }

export type ModelAttrRange = {
  [key in 'opacity' | 'bottom' | 'scale' as `${key}Range`]: {
    min: number,
    max: number,
    step: number
  }
}

export type AddModelProps = Pick<Model, 'type' | 'url' | 'id'> 
  & ModelAttrs 
  & ModelAttrRange

export type SceneGuidePath = Pick<GuidePath, 'position' | 'target' | 'speed' | 'time'>
export interface SceneGuide {
  bus: Emitter<{ changePoint: number; playComplete: void }>
  play: () => void
  pause: () => void
  clear: () => void
}

export type ScenePos = { localPos: SceneLocalPos, modelId: Model['id'] }
export type ScreenPos = { 
  trueSide: boolean,
  pos: ScreenLocalPos, 
  modelId: Model['id'] 
}

export interface CameraComeToProps { 
  position: SceneLocalPos; 
  target?: SceneLocalPos; 
  dur?: number, 
  modelId?: Model['id'], 
  distance?: 1 | 2 | 3 
}

export type CalcPathProps = [[SceneGuidePath, SceneGuidePath], Partial<Pick<SceneGuidePath, 'time' | 'speed'>>]

export interface SDK {
  layout: HTMLDivElement,
  sceneBus: Emitter<{ 'cameraChange': void }>
  addModel: (props: AddModelProps) => SceneModel
  calcPathInfo: (paths: CalcPathProps[0], info: CalcPathProps[1]) => Required<CalcPathProps[1]>
  getPositionByScreen: (screenPos: ScreenLocalPos, modelId?: Model['id']) => ScenePos | null
  getScreenByPosition: (localPos: SceneLocalPos, modelId?: Model['id']) => ScreenPos | null
  screenshot: (width: number, height: number) => Promise<string>
  getPose: () => { position: SceneLocalPos, target: SceneLocalPos }
  comeTo: (pos: CameraComeToProps) => void
  enterSceneGuide: (data: SceneGuidePath[]) => SceneGuide
}
  


export let sdk: SDK
export type InialSDKProps = { layout: HTMLDivElement }
let initialed = false
export const initialSDK = async (props: InialSDKProps) => {
  if (initialed) return;
  initialed = true
  const libs = [
    `./lib/proj4/proj4.js`,
    `./lib/jquery/jquery-3.1.1.min.js`,
    `./lib/other/BinaryHeap.js`,
    `./lib/tween/tween.min.js`,
  ]
  await Promise.all(libs.map(loadLib))
  await loadLib(`./lib/potree/potree.js`)

  const localSdk = cover(props.layout, true) as unknown as SDK

  sdk = localSdk
  sdk.layout = props.layout
}

export default sdk