hj-gis-sdk 1.0.0 → 1.0.2

package/hj-gis-sdk/addons/loader/loader.ts

@@ -0,0 +1,3 @@
+export interface Loader<T> {
+  loader: (opts: any) => Promise<T>
+}

package/hj-gis-sdk/addons/node/base.ts

@@ -0,0 +1,131 @@
+/**
+ * 节点基类模块，提供节点树的基础实现
+ * 用于表示场景中的对象，支持父子关系、变换和数据存储
+ */
+import { Vector3, Euler } from '@math.gl/core'
+
+import UERPC from '../../core/ue-rpc'
+import { OTransform } from '../transform'
+
+/**
+ * 节点基类，用于表示场景中的对象
+ * 支持父子关系、变换、数据存储和节点查找
+ * @template T 节点数据类型
+ */
+export default class Node<T = any> {
+  /** 父节点 */
+  parent: Node | undefined
+  /** 根节点 */
+  root: Node | undefined
+  /** 节点唯一标识符 */
+  private _key: string | undefined
+  /** 节点变换信息 */
+  protected _transform: OTransform | undefined
+  /** 是否为根节点 */
+  isRoot: boolean
+  /** 节点附加数据 */
+  data?: T
+
+  /** 子节点列表 */
+  protected _children: Node[]
+
+  /**
+   * 构造函数
+   * @param key 节点唯一标识符
+   * @param data 节点附加数据
+   * @param transform 节点变换信息
+   */
+  constructor(key?: string, data?: T, transform?: OTransform) {
+    this._children = []
+    this._key = key
+    this.isRoot = true
+    this.data = data
+    if (transform) {
+      this._transform = new OTransform(
+        new Vector3(),
+        new Euler(),
+        new Vector3(1, 1, 1)
+      )
+    } else {
+      this._transform = OTransform.default()
+    }
+  }
+
+  /**
+   * 获取节点唯一标识符
+   */
+  get key() {
+    return this._key
+  }
+
+  /**
+   * 获取节点变换信息
+   */
+  get transform() {
+    return this._transform
+  }
+
+  /**
+   * 获取子节点列表
+   */
+  get children() {
+    return this._children
+  }
+
+  /**
+   * 添加子节点
+   * @param child 要添加的子节点
+   */
+  add(child: Node) {
+    // this.children.push(child)
+    child.parent = this
+    this._children.push(child)
+    child.isRoot = false
+  }
+
+  /**
+   * 脱离父节点
+   */
+  detach() {
+    if (this.parent) {
+      this.parent.removeChild(this)
+    }
+    this.isRoot = true
+  }
+
+  remove() {
+    if (this.parent) {
+      this.detach()
+    }   
+  }
+
+  /**
+   * 移除子节点
+   * @param child 要移除的子节点
+   */
+  removeChild(child: Node) {
+    child.parent = undefined
+    let index = this._children.findIndex((c) => c !== child)
+    if (index > -1) {
+      this._children.splice(index, 1)
+    }
+  }
+
+  /**
+   * 根据key查找子节点
+   * @param key 要查找的节点key
+   * @returns 找到的节点或undefined
+   */
+  findChild(key: string): Node | undefined {
+    if (this.key === key) {
+      return this
+    }
+    for (let i = 0; i < this._children.length; i++) {
+      let child = this._children[i]
+      let found = child.findChild(key)
+      if (found) {
+        return found
+      }
+    }
+  }
+}

package/hj-gis-sdk/addons/node/ue-node.ts

@@ -0,0 +1,147 @@
+/**
+ * UE RPC 节点模块，提供与 UE 通信的节点实现
+ * 用于表示与 Unreal Engine 通信的场景对象
+ */
+import { Euler, Vector3 } from '@math.gl/core'
+import UERPC from '../../core/ue-rpc'
+
+import Node from './base'
+import { Transform } from '../transform'
+import World from '../world'
+import { Collector, createDeepProxy } from '../proxy'
+
+/**
+ * 资源类型枚举，用于标识不同类型的资源
+ */
+export enum AssetType {
+  /** 其他类型资源 */
+  Other = 'other',
+  /** 地图资源 */
+  Map = 'map',
+  /** 蓝图资源 */
+  Blueprint = 'blueprint',
+  /** 静态网格资源 */
+  StaticMesh = 'static_mesh',
+  /** 骨骼网格资源 */
+  SkeletalMesh = 'skeletal_mesh'
+}
+
+/**
+ * 节点数据类型，包含资源类型信息
+ */
+type Data = {
+  /** 资源类型 */
+  assetType: AssetType
+}
+
+/**
+ * UE RPC 节点类，继承自 Node，用于与 Unreal Engine 通信
+ * 支持变换同步、远程更新和子节点管理
+ */
+export default class UERPCNode extends Node<Data> {
+  /** RPC 通信实例 */
+  protected _rpc: UERPC
+  /** 节点变换信息 */
+  protected _transform: Transform | undefined
+  /** 所属世界实例 */
+  world?: World
+  /** 变更收集器，用于跟踪变换属性的变化 */
+  protected _collector: Collector
+  /** 远程更新标志，用于防止循环更新 */
+  protected _remoteUpdateFlag: boolean
+
+  tag?: string
+
+  /**
+   * 构造函数
+   * @param rpc RPC 通信实例
+   * @param key 节点唯一标识符
+   * @param data 节点数据
+   * @param transform 节点变换信息
+   */
+  constructor(
+    rpc: UERPC,
+    key?: string,
+    data?: Data,
+    transform?: Transform,
+    tag?: string
+  ) {
+    super(key, data)
+    this._rpc = rpc
+    if (transform) {
+      this._transform = transform
+    } else {
+      this._transform = Transform.default()
+    }
+    this._remoteUpdateFlag = false
+    this._collector = new Collector(this._triggerRemoteUpdate.bind(this))
+    this.tag = tag
+  }
+
+  /**
+   * 获取变换信息的深度代理，用于跟踪属性变化
+   */
+  get transform() {
+    return createDeepProxy(this._transform!, {}, this._collector)
+  }
+
+  set transform(transform: Transform) {
+    this._transform = transform
+    this._triggerRemoteUpdate()
+  }
+
+  /**
+   * 添加子节点
+   * @param child 要添加的子节点
+   * @throws 非根节点添加子节点时抛出错误
+   */
+  add(child: UERPCNode) {
+    // throw new Error("UERPCNode can't add child")
+    if (this.isRoot) {
+      super.add(child)
+      child.world = this.world
+    } else {
+      throw new Error("UERPCNode can't add child , except root node")
+    }
+  }
+
+  __dangerousRawAdd(child: UERPCNode) {
+    super.add(child)
+  }
+
+  /**
+   * 脱离父节点
+   */
+  async detach() {
+    super.detach()
+  }
+
+  async remove() {
+    super.remove()
+    await this._rpc.destroyActorByHandle(this.key!)
+  }
+  /**
+   * 移除子节点
+   * @param child 要移除的子节点
+   */
+  async removeChild(child: Node) {
+    super.removeChild(child)
+    await this._rpc.destroyActorByHandle(this.key!)
+  }
+
+  protected _triggerRemoteUpdate() {
+    if (!this._remoteUpdateFlag) {
+      this._remoteUpdateFlag = true
+      Promise.resolve().then(() => this._remoteUpdate())
+    }
+  }
+
+  /**
+   * 远程更新节点变换到 UE
+   * 向 UE 发送变换数据，更新 Actor 的位置、旋转和缩放
+   */
+  protected _remoteUpdate() {
+    this._rpc.setActorTransformByHandle(this.key!, this.transform.toRPCJSON())
+    this._remoteUpdateFlag = false
+  }
+}

package/hj-gis-sdk/addons/proxy.ts

@@ -0,0 +1,200 @@
+/**
+ * 代理模块，提供深度代理和变动收集功能
+ * 用于跟踪对象的属性变化并在事件循环结束后统一处理
+ */
+
+/**
+ * 变动接口，用于描述对象的属性变动
+ */
+export interface Change {
+  /** 变动目标对象 */
+  target: object
+  /** 变动的属性名或符号 */
+  prop: string | symbol
+  /** 变动后的值 */
+  value: any
+  /** 变动类型 */
+  type: 'set' | 'delete'
+}
+
+// 定义自定义处理器接口
+export interface DeepProxyHandler {
+  /**
+   * 拦截属性读取
+   */
+  get?: <T extends object>(
+    target: T,
+    prop: string | symbol,
+    receiver: any
+  ) => void
+  /**
+   * 拦截属性赋值
+   */
+  set?: <T extends object>(
+    target: T,
+    prop: string | symbol,
+    value: any,
+    receiver: any
+  ) => boolean
+  /**
+   * 拦截属性删除
+   */
+  deleteProperty?: <T extends object>(
+    target: T,
+    prop: string | symbol
+  ) => boolean
+  /**
+   * 拦截 in 操作符
+   */
+  has?: <T extends object>(target: T, prop: string | symbol) => boolean
+  /**
+   * 拦截 Object.getOwnPropertyNames 等方法
+   */
+  ownKeys?: <T extends object>(target: T) => (string | symbol)[]
+}
+
+/**
+ * 收集器类，用于收集对象变动并在事件循环结束后触发回调
+ */
+export class Collector {
+  /**
+   * 收集到的变动列表
+   */
+  private changes: Change[] = []
+  /**
+   * 标志位，用于确保只有一个 setTimeout 在运行
+   */
+  private isTimeoutSet: boolean = false
+  /**
+   * 变动回调函数
+   */
+  private callback: (changes: Change[]) => void
+
+  /**
+   * 创建收集器实例
+   * @param callback 变动回调函数，在事件循环结束后调用
+   */
+  constructor(callback: (changes: Change[]) => void) {
+    this.callback = callback
+  }
+
+  /**
+   * 添加变动
+   * @param change 变动对象
+   */
+  addChange(change: Change): void {
+    this.changes.push(change)
+    this.scheduleCallback()
+  }
+
+  /**
+   * 调度回调函数，确保在事件循环结束后执行
+   */
+  private scheduleCallback(): void {
+    if (!this.isTimeoutSet) {
+      this.isTimeoutSet = true
+      // setTimeout(() => {
+      Promise.resolve().then(() => this.triggerCallback())
+      // }, 0);
+    }
+  }
+
+  /**
+   * 触发回调函数
+   */
+  private triggerCallback(): void {
+    if (this.changes.length > 0) {
+      this.callback([...this.changes]) // 传递变动的副本
+      this.changes = [] // 清空变动列表
+    }
+    this.isTimeoutSet = false
+  }
+}
+
+/**
+ * 创建深度代理，递归地为对象及其所有子对象创建 Proxy
+ * @param target 要代理的目标对象
+ * @param handler 自定义处理器
+ * @param collector 变动收集器，用于收集对象变动
+ * @returns 代理后的对象
+ */
+export function createDeepProxy<T extends object>(
+  target: T,
+  handler: DeepProxyHandler = {},
+  collector?: Collector
+): T {
+  // 递归创建 Proxy 的核心函数
+  const proxyHandler: ProxyHandler<T> = {
+    // 拦截属性读取
+    get(target: T, prop: string | symbol, receiver: any): any {
+      // 先调用自定义 handler 的 get（如果有）
+      if (handler.get) {
+        handler.get(target, prop, receiver)
+      }
+
+      // 获取属性值
+      const result = Reflect.get(target, prop, receiver)
+
+      // 如果读取的属性是对象/数组且不是 null，递归创建 Proxy
+      if (
+        result !== null &&
+        (typeof result === 'object' || Array.isArray(result))
+      ) {
+        return createDeepProxy(result as object, handler, collector)
+      }
+      return result
+    },
+
+    // 拦截属性赋值
+    set(target: T, prop: string | symbol, value: any, receiver: any): boolean {
+      // 先调用自定义 handler 的 set（如果有）
+      if (handler.set) {
+        handler.set(target, prop, value, receiver)
+      }
+
+      // 赋值时，如果新值是对象/数组，也需要代理
+      const newValue =
+        value !== null && (typeof value === 'object' || Array.isArray(value))
+          ? createDeepProxy(value as object, handler, collector)
+          : value
+
+      // 如果有收集器，收集变动
+      if (collector) {
+        collector.addChange({
+          target,
+          prop,
+          value: newValue,
+          type: 'set'
+        })
+      }
+
+      return Reflect.set(target, prop, newValue, receiver)
+    },
+
+    // 拦截属性删除
+    deleteProperty(target: T, prop: string | symbol): boolean {
+      // 先调用自定义 handler 的 deleteProperty（如果有）
+      if (handler.deleteProperty) {
+        handler.deleteProperty(target, prop)
+      }
+
+      // 如果有收集器，收集变动
+      if (collector) {
+        collector.addChange({
+          target,
+          prop,
+          value: undefined,
+          type: 'delete'
+        })
+      }
+
+      return Reflect.deleteProperty(target, prop)
+    },
+
+    // 可选：拦截其他操作（如 has 等）
+    ...handler // 合并自定义 handler 的其他拦截器
+  }
+
+  // 为目标对象创建 Proxy
+  return new Proxy<T>(target, proxyHandler)
+}

package/hj-gis-sdk/addons/tools/base.ts

@@ -0,0 +1,11 @@
+import UERPC from 'hj-gis-sdk/core/ue-rpc'
+
+export default class Tool {
+  protected _rpc: UERPC
+  constructor(rpc: UERPC) {
+    this._rpc = rpc
+  }
+  excute(params?: any) {
+    throw new Error('Method not implemented.')
+  }
+}

package/hj-gis-sdk/addons/tools/building.ts

@@ -0,0 +1,84 @@
+import Tool from './base'
+import UERPC from '../../core/ue-rpc'
+import { RPCTransform } from '../transform'
+
+export default class Building extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+  async expand(id: string, params: ExpandParams) {
+    await this._rpc.callModule('Building', 'Expand', {
+      BuildingId: id,
+      Spacing: params.spacing,
+      Duration: params.duration || 2000
+    })
+    let handler = new BuildingHandler(id, this._rpc)
+    return handler
+  }
+}
+
+type ExpandParams = {
+  spacing: number // 展开间距（UU），控制各部分分离的距离
+  duration: number // 动画时长（秒）
+}
+
+type ExpandFloorParams = {
+  floorIndex: number //楼层索引（从0起），未提供则由 UE 侧默认规则确定
+  direction?: RPCTransform['Location'] //展开方向向量（世界坐标系）
+  distance: number
+  expandHeight?: number //单层向外的高度/间距
+  duration: number //单层向外的高度/间距
+}
+
+enum Status {
+  Expanded = 'Expanded',
+  ExpandFloor = 'ExpandFloor',
+  Collapsed = 'Collapsed'
+}
+
+export class BuildingHandler {
+  private _id: string
+  private _rpc: UERPC
+  private _status: Status
+  constructor(id: string, rpc: UERPC, status?: Status) {
+    this._id = id
+    this._rpc = rpc
+    this._status = status || Status.Collapsed
+  }
+  get status() {
+    return this._status
+  }
+  get id() {
+    return this._id
+  }
+  async expand(params: ExpandParams) {
+    await this._rpc.callModule('Building', 'ExpandFloor', {
+      BuildingId: this._id,
+      Spacing: params.spacing,
+      Duration: params.duration || 2
+    })
+  }
+
+  async expandFloor(params: ExpandFloorParams) {
+    let _params: any = {
+      BuildingId: this._id,
+      Distance: params.distance,
+      ExpandHeight: params.expandHeight,
+      Duration: params.duration || 2
+    }
+    if (params.direction) {
+      _params.Direction = {
+        X: params.direction.X,
+        Y: params.direction.Y,
+        Z: params.direction.Z
+      }
+    }
+    return this._rpc.callModule('Building', 'ExpandFloor', _params)
+  }
+  async collapse(duration: number = 2) {
+    return this._rpc.callModule('Building', 'Collapse', {
+      BuildingId: this._id,
+      duration: duration || 2
+    })
+  }
+}

package/hj-gis-sdk/addons/tools/daytime.ts

@@ -0,0 +1,14 @@
+import UERPC from 'hj-gis-sdk/core/ue-rpc'
+import Tool from './base'
+
+export default class Daytime extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+
+  setDaytime(hh: string, mm: string) {
+    return this._rpc.callModule('Environment', 'SetDaytime', {
+      value: `${hh}${mm}`
+    })
+  }
+}

package/hj-gis-sdk/addons/tools/fence.ts

@@ -0,0 +1,105 @@
+import Tool from './base'
+import UERPC from '../../core/ue-rpc'
+import { RPCTransform } from '../transform'
+
+/**
+ * 坐标向量接口
+ */
+interface Vector3 {
+  X: number
+  Y: number
+  Z: number
+}
+
+/**
+ * 颜色接口
+ */
+interface Color {
+  R: number
+  G: number
+  B: number
+  A: number
+}
+
+/**
+ * 材质枚举类型
+ */
+type MaterialEnum = 'Material_A' | 'Material_B' | 'Material_C'
+
+/**
+ * 围栏创建参数
+ */
+interface FenceCreateParams {
+  /** 世界坐标顶点数组（至少3点，按围栏边顺序排列） */
+  vectorArray: Vector3[]
+  /** 围栏高度（UU），未提供默认 5.0 */
+  height?: number
+  /** 材质枚举（示例 A/B/C），不同值对应不同材质路径 */
+  materialEnum?: MaterialEnum
+  /** 围栏颜色（R/G/B/A），范围 0–255；内部按 0–1 归一化后应用 */
+  color?: Color
+}
+
+/**
+ * 围栏参数类型
+ */
+type FenceParams = FenceCreateParams | {}
+
+/**
+ * 围栏工具类，用于创建和删除电子围栏
+ */
+export default class Fence extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+
+  async create(params: FenceCreateParams): Promise<FenceHandler> {
+    let response = this._rpc.callModule('Box', 'Create', {
+      VectorArray: params.vectorArray,
+      Height: params.height,
+      MaterialEnum: params.materialEnum,
+      Color: params.color
+    })
+    const { FenceID } = await response
+    let handler = new FenceHandler(this._rpc, FenceID, FenceStatus.Created)
+    return handler
+  }
+}
+
+enum FenceStatus {
+  UnCreated = 'UnCreated',
+  /** 围栏已创建 */
+  Created = 'Created',
+  /** 围栏已删除 */
+  Removed = 'Removed'
+}
+
+type CreateParams = {
+  vectorArray: RPCTransform['Location'][] //世界坐标顶点数组（至少3点，按围栏边顺序排列）。
+  height?: number //围栏高度（UU），未提供默认 5.0。
+  materialEnum: MaterialEnum // 材质枚举（示例 A/B/C），不同值对应不同材质路径
+}
+
+class FenceHandler {
+  private _id: string | undefined
+  private _rpc: UERPC
+  private _status: FenceStatus | undefined
+  get id() {
+    return this._id
+  }
+  constructor(rpc: UERPC, id?: string, status?: FenceStatus) {
+    this._id = id
+    this._rpc = rpc
+    this._status = status || FenceStatus.UnCreated
+  }
+
+  get status() {
+    return this._status
+  }
+
+  async remove() {
+    return this._rpc.callModule('Box', 'Delete', {
+      FenceID: this.id
+    })
+  }
+}