lecodes-gl-lite 2.0.0

package/src/vendor/creator-nav/js/index.ts

@@ -0,0 +1,400 @@
+// creator-nav's TypeScript side over the wasm build (dist/creatorNav.js):
+//
+//   • `createNavBridge(getBuffer)` — the `_creatorNav` object the WEB hosts (viewer, viewer-lite,
+//     lecodes-headless) hand to the app: the same method shapes as creator-pkg's
+//     creatorNavHandler.cpp, so the SDK never knows which host it runs on. The wasm loads lazily on
+//     `ready()`; a project without navigation never pays for it.
+//   • `NavBuilder` + `readNgeo` — the CLI's `lecodes navmesh bake`: a geometry dump (the desktop
+//     host's `physicsStaticGeometry`) → Recast → LNAV bytes.
+//
+// Parameter layouts mirror include/creator-nav/creator-nav.h (CNAV_BUILD_* / CNAV_AGENT_* /
+// CNAV_READ_*) — keep the three in step.
+
+import createCreatorNav, { type CreatorNavModule } from "../dist/creatorNav.js"
+
+export const BUILD = {
+  CELL_SIZE: 0, CELL_HEIGHT: 1, AGENT_RADIUS: 2, AGENT_HEIGHT: 3, AGENT_MAX_CLIMB: 4, AGENT_MAX_SLOPE: 5,
+  TILE_SIZE: 6, REGION_MIN_SIZE: 7, REGION_MERGE_SIZE: 8, EDGE_MAX_LEN: 9, EDGE_MAX_ERROR: 10,
+  VERTS_PER_POLY: 11, DETAIL_SAMPLE_DIST: 12, DETAIL_MAX_ERROR: 13, FILTER_LOW_HANGING: 14,
+  FILTER_LEDGES: 15, FILTER_LOW_HEIGHT: 16, COUNT: 17,
+} as const
+
+export const AGENT = {
+  RADIUS: 0, HEIGHT: 1, MAX_SPEED: 2, MAX_ACCELERATION: 3, COLLISION_QUERY_RANGE: 4, PATH_OPTIMIZATION_RANGE: 5,
+  SEPARATION_WEIGHT: 6, AVOIDANCE: 7, INCLUDE_FLAGS: 8, EXCLUDE_FLAGS: 9, ANTICIPATE_TURNS: 10,
+  OPTIMIZE_VIS: 11, OPTIMIZE_TOPO: 12, COUNT: 13,
+} as const
+
+export const READ = {
+  POS_X: 0, POS_Y: 1, POS_Z: 2, VEL_X: 3, VEL_Y: 4, VEL_Z: 5, DVEL_X: 6, DVEL_Y: 7, DVEL_Z: 8,
+  STATE: 9, TARGET_STATE: 10, REMAINING: 11, PARTIAL: 12, STRIDE: 13,
+} as const
+
+export const AREA_UNWALKABLE = 255
+export const FLAGS_ALL = 0xffff
+
+export type BuildParams = Partial<{
+  cellSize: number, cellHeight: number, agentRadius: number, agentHeight: number, agentMaxClimb: number,
+  agentMaxSlope: number, tileSize: number, regionMinSize: number, regionMergeSize: number, edgeMaxLen: number,
+  edgeMaxError: number, vertsPerPoly: number, detailSampleDist: number, detailMaxError: number,
+}>
+
+const BUILD_KEYS: Record<keyof Required<BuildParams>, number> = {
+  cellSize: BUILD.CELL_SIZE, cellHeight: BUILD.CELL_HEIGHT, agentRadius: BUILD.AGENT_RADIUS, agentHeight: BUILD.AGENT_HEIGHT,
+  agentMaxClimb: BUILD.AGENT_MAX_CLIMB, agentMaxSlope: BUILD.AGENT_MAX_SLOPE, tileSize: BUILD.TILE_SIZE,
+  regionMinSize: BUILD.REGION_MIN_SIZE, regionMergeSize: BUILD.REGION_MERGE_SIZE, edgeMaxLen: BUILD.EDGE_MAX_LEN,
+  edgeMaxError: BUILD.EDGE_MAX_ERROR, vertsPerPoly: BUILD.VERTS_PER_POLY, detailSampleDist: BUILD.DETAIL_SAMPLE_DIST,
+  detailMaxError: BUILD.DETAIL_MAX_ERROR,
+}
+
+let modulePromise: Promise<CreatorNavModule> | null = null
+/** The wasm module, loaded once per process (lazy). */
+export const loadCreatorNav = (): Promise<CreatorNavModule> => (modulePromise ??= createCreatorNav())
+
+// ---- heap helpers --------------------------------------------------------------------------------
+
+const withF32 = <T>(mod: CreatorNavModule, values: ArrayLike<number>, fn: (ptr: number) => T): T => {
+  const ptr = mod._malloc(Math.max(4, values.length * 4))
+  mod.HEAPF32.set(values, ptr >> 2)
+  try { return fn(ptr) } finally { mod._free(ptr) }
+}
+
+const withString = <T>(mod: CreatorNavModule, s: string | null, fn: (ptr: number) => T): T => {
+  if (s === null) return fn(0)
+  const n = mod.lengthBytesUTF8(s) + 1
+  const ptr = mod._malloc(n)
+  mod.stringToUTF8(s, ptr, n)
+  try { return fn(ptr) } finally { mod._free(ptr) }
+}
+
+// ---- NGEO — the host's geometry dump -------------------------------------------------------------
+
+export type NgeoData = {
+  /** 9 floats per triangle (three xyz), world space */
+  triangles: Float32Array
+  /** one area byte per triangle */
+  areas: Uint8Array
+  triangleCount: number
+  bodyCount: number
+}
+
+/** Parse a `physicsStaticGeometry` dump ('NGEO' u32 · version · triangleCount · bodyCount · records). */
+export const readNgeo = (bytes: Uint8Array): NgeoData => {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  if (bytes.byteLength < 16 || dv.getUint32(0, true) !== 0x4f45474e) throw new Error("not an NGEO geometry dump")
+  const version = dv.getUint32(4, true)
+  if (version !== 1) throw new Error(`NGEO version ${version}, expected 1`)
+  const triangleCount = dv.getUint32(8, true)
+  const bodyCount = dv.getUint32(12, true)
+  const triangles = new Float32Array(triangleCount * 9)
+  const areas = new Uint8Array(triangleCount)
+  let at = 16
+  for (let i = 0; i < triangleCount; i++) {
+    for (let k = 0; k < 9; k++) { triangles[i * 9 + k] = dv.getFloat32(at, true); at += 4 }
+    areas[i] = dv.getUint32(at, true) & 0xff
+    at += 4
+  }
+  return { triangles, areas, triangleCount, bodyCount }
+}
+
+// ---- NavBuilder — Recast over the wasm ------------------------------------------------------------
+
+export type BuildResult = {
+  data: Uint8Array
+  tiles: number
+  polys: number
+  bounds: { min: [number, number, number], max: [number, number, number] }
+  /** seconds */
+  time: number
+}
+
+export class NavBuilder {
+  private handle: number
+
+  constructor(private readonly mod: CreatorNavModule, params: BuildParams = {}) {
+    const p = new Float32Array(BUILD.COUNT)
+    withF32(mod, p, (ptr) => { mod._cnavBuildDefaults(ptr); p.set(mod.HEAPF32.subarray(ptr >> 2, (ptr >> 2) + BUILD.COUNT)) })
+    for (const [key, value] of Object.entries(params)) {
+      if (value === undefined) continue
+      const idx = BUILD_KEYS[key as keyof BuildParams]
+      if (idx === undefined) throw new Error(`NavBuilder: unknown build parameter "${key}"`)
+      p[idx] = value
+    }
+    this.handle = withF32(mod, p, (ptr) => mod._cnavBuildCreate(ptr))
+  }
+
+  /** Indexed triangles; `area` for every triangle unless `areas` (one byte per triangle) is given. */
+  addTriangles(xyz: Float32Array, indices: Int32Array | Uint32Array, area = 0, areas?: Uint8Array): void {
+    const mod = this.mod
+    const vp = mod._malloc(xyz.byteLength)
+    mod.HEAPF32.set(xyz, vp >> 2)
+    const ip = mod._malloc(indices.byteLength)
+    mod.HEAP32.set(indices as unknown as Int32Array, ip >> 2)
+    let ap = 0
+    if (areas) { ap = mod._malloc(areas.byteLength); mod.HEAPU8.set(areas, ap) }
+    const ok = mod._cnavBuildAddTriangles(this.handle, vp, xyz.length / 3, ip, indices.length / 3, area, ap)
+    mod._free(vp); mod._free(ip); if (ap) mod._free(ap)
+    if (!ok) throw new Error(`NavBuilder.addTriangles: ${this.lastError()}`)
+  }
+
+  /** An unindexed soup (9 floats per triangle) — the NGEO dump's shape. */
+  addSoup(triangles: Float32Array, areas?: Uint8Array): void {
+    const n = triangles.length / 3
+    const indices = new Int32Array(n)
+    for (let i = 0; i < n; i++) indices[i] = i
+    this.addTriangles(triangles, indices, 0, areas)
+  }
+
+  addVolume(hullXZ: ArrayLike<number>, minY: number, maxY: number, area: number): void {
+    const ok = withF32(this.mod, hullXZ, (ptr) => this.mod._cnavBuildAddVolume(this.handle, ptr, hullXZ.length / 2, minY, maxY, area))
+    if (!ok) throw new Error(`NavBuilder.addVolume: ${this.lastError()}`)
+  }
+
+  addLink(a: ArrayLike<number>, b: ArrayLike<number>, radius: number, bidirectional = true, area = 0, userId = 0): void {
+    const ok = withF32(this.mod, [ a[0]!, a[1]!, a[2]!, b[0]!, b[1]!, b[2]! ], (ptr) =>
+      this.mod._cnavBuildAddLink(this.handle, ptr, ptr + 12, radius, bidirectional ? 1 : 0, area, userId))
+    if (!ok) throw new Error(`NavBuilder.addLink: ${this.lastError()}`)
+  }
+
+  run(meta: object | null = null, onProgress?: (tile: number, tileCount: number, message: string | null) => void): BuildResult {
+    const mod = this.mod
+    const t0 = performance.now()
+    let cb = 0
+    if (onProgress) {
+      cb = mod.addFunction((tile: number, count: number, msg: number) => {
+        onProgress(tile, count, msg ? mod.UTF8ToString(msg) : null)
+      }, "viiii")
+    }
+    const ok = withString(mod, meta ? JSON.stringify(meta) : null, (mp) => mod._cnavBuildRun(this.handle, mp, cb, 0))
+    if (cb) mod.removeFunction(cb)
+    if (!ok) throw new Error(`navmesh build failed: ${this.lastError()}`)
+    const sizePtr = mod._malloc(4)
+    const dataPtr = mod._cnavBuildData(this.handle, sizePtr)
+    const size = mod.HEAPU32[sizePtr >> 2]!
+    mod._free(sizePtr)
+    const data = new Uint8Array(mod.HEAPU8.subarray(dataPtr, dataPtr + size))   // a copy
+    const bp = mod._malloc(24)
+    mod._cnavBuildBounds(this.handle, bp, bp + 12)
+    const b = mod.HEAPF32.subarray(bp >> 2, (bp >> 2) + 6)
+    const bounds = { min: [ b[0]!, b[1]!, b[2]! ] as [number, number, number], max: [ b[3]!, b[4]!, b[5]! ] as [number, number, number] }
+    mod._free(bp)
+    return { data, tiles: mod._cnavBuildTileCount(this.handle), polys: mod._cnavBuildPolyCount(this.handle), bounds, time: (performance.now() - t0) / 1000 }
+  }
+
+  lastError(): string { return this.mod.UTF8ToString(this.mod._cnavLastError()) }
+
+  destroy(): void {
+    if (this.handle) { this.mod._cnavBuildDestroy(this.handle); this.handle = 0 }
+  }
+}
+
+/** The polygon mesh of an LNAV file as a triangle soup (xyz per vertex) — the CLI's `--obj` debug dump. */
+export const navMeshTriangles = (mod: CreatorNavModule, data: Uint8Array): Float32Array => {
+  const ptr = mod._malloc(data.byteLength)
+  mod.HEAPU8.set(data, ptr)
+  const mesh = mod._cnavMeshLoad(ptr, data.byteLength)
+  mod._free(ptr)
+  if (!mesh) throw new Error(`navmesh load failed: ${mod.UTF8ToString(mod._cnavLastError())}`)
+  const n = mod._cnavDebugTriangles(mesh, 0, 0)
+  const out = new Float32Array(n * 3)
+  if (n > 0) {
+    const op = mod._malloc(n * 12)
+    mod._cnavDebugTriangles(mesh, op, n)
+    out.set(mod.HEAPF32.subarray(op >> 2, (op >> 2) + n * 3))
+    mod._free(op)
+  }
+  mod._cnavMeshDestroy(mesh)
+  return out
+}
+
+// ---- the `_creatorNav` bridge for the web hosts ---------------------------------------------------
+
+export type NavBridge = {
+  /** Web hosts only: load the wasm. Native hosts have no such method (the SDK awaits it when present). */
+  ready(): Promise<void>
+  lastError(): string
+  load(systemId: number): number
+  unload(meshId: number): void
+  header(meshId: number): string
+  polyCount(meshId: number): number
+  setAreaCost(meshId: number, area: number, cost: number): void
+  findPath(meshId: number, fx: number, fy: number, fz: number, tx: number, ty: number, tz: number, ex: number, ey: number, ez: number, include: number, exclude: number, out: Float32Array): number
+  nearest(meshId: number, x: number, y: number, z: number, ex: number, ey: number, ez: number, include: number, exclude: number, out: Float32Array): boolean
+  raycast(meshId: number, fx: number, fy: number, fz: number, tx: number, ty: number, tz: number, include: number, exclude: number, out: Float32Array): boolean
+  randomPoint(meshId: number, cx: number, cy: number, cz: number, radius: number, seed: number, include: number, exclude: number, out: Float32Array): boolean
+  debugTriangles(meshId: number): Float32Array
+  crowdCreate(meshId: number, maxAgents: number, maxRadius: number): number
+  crowdDestroy(crowdId: number): void
+  crowdAdd(crowdId: number, x: number, y: number, z: number, params: Float32Array): number
+  crowdRemove(crowdId: number, agent: number): void
+  crowdSetParams(crowdId: number, agent: number, params: Float32Array): void
+  crowdSetTarget(crowdId: number, agent: number, x: number, y: number, z: number): boolean
+  crowdSetVelocity(crowdId: number, agent: number, vx: number, vy: number, vz: number): void
+  crowdResetTarget(crowdId: number, agent: number): void
+  crowdWarp(crowdId: number, agent: number, x: number, y: number, z: number): boolean
+  crowdUpdate(crowdId: number, dt: number): void
+  crowdRead(crowdId: number, out: Float32Array): number
+}
+
+/** The web hosts' `_creatorNav`. `getBuffer` resolves a fetch system id to its bytes (the host's
+ *  fetch store — viewer-lite's `getBuffer`, the renderer's `services.getBuffer`). */
+export const createNavBridge = (getBuffer: (systemId: number) => ArrayBuffer | Uint8Array | null | undefined): NavBridge => {
+  let mod: CreatorNavModule | null = null
+  const meshes = new Map<number, number>()      // meshId → cnavMesh*
+  const crowds = new Map<number, { ptr: number, max: number, buf: number }>()
+  let nextId = 1
+  // scratch heap for small in/out arrays (48 floats: enough for every fixed-size argument set)
+  let scratch = 0
+  const s = (): number => scratch || (scratch = mod!._malloc(48 * 4))
+  const sf = (offset: number, values: ArrayLike<number>): number => {
+    const ptr = s() + offset * 4
+    mod!.HEAPF32.set(values, ptr >> 2)
+    return ptr
+  }
+  const readF = (ptr: number, n: number, out: Float32Array): void => { out.set(mod!.HEAPF32.subarray(ptr >> 2, (ptr >> 2) + n)) }
+  const need = (): CreatorNavModule => {
+    if (!mod) throw new Error("_creatorNav: call ready() before loading a navmesh")
+    return mod
+  }
+
+  return {
+    async ready() { mod = await loadCreatorNav() },
+    lastError() { return mod ? mod.UTF8ToString(mod._cnavLastError()) : "wasm not loaded" },
+
+    load(systemId) {
+      const m = need()
+      const buf = getBuffer(systemId)
+      if (!buf) return 0
+      const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf)
+      const ptr = m._malloc(bytes.byteLength)
+      m.HEAPU8.set(bytes, ptr)
+      const mesh = m._cnavMeshLoad(ptr, bytes.byteLength)
+      m._free(ptr)
+      if (!mesh) return 0
+      const id = nextId++
+      meshes.set(id, mesh)
+      return id
+    },
+    unload(meshId) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return
+      for (const [ cid, c ] of crowds) { need()._cnavCrowdDestroy(c.ptr); need()._free(c.buf); crowds.delete(cid) }
+      need()._cnavMeshDestroy(mesh)
+      meshes.delete(meshId)
+    },
+    header(meshId) {
+      const mesh = meshes.get(meshId)
+      return mesh ? need().UTF8ToString(need()._cnavMeshHeader(mesh)) : ""
+    },
+    polyCount(meshId) {
+      const mesh = meshes.get(meshId)
+      return mesh ? need()._cnavMeshPolyCount(mesh) : 0
+    },
+    setAreaCost(meshId, area, cost) {
+      const mesh = meshes.get(meshId)
+      if (mesh) need()._cnavMeshSetAreaCost(mesh, area, cost)
+    },
+
+    findPath(meshId, fx, fy, fz, tx, ty, tz, ex, ey, ez, include, exclude, out) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return 0
+      const m = need()
+      const n = Math.floor(out.length / 3)
+      const from = sf(0, [ fx, fy, fz ]), to = sf(3, [ tx, ty, tz ]), ext = ex > 0 ? sf(6, [ ex, ey, ez ]) : 0
+      const partial = s() + 9 * 4
+      m.HEAP32[partial >> 2] = 0
+      const outPtr = m._malloc(Math.max(1, n) * 12)
+      const count = m._cnavFindPath(mesh, from, to, ext, include, exclude, outPtr, n, partial)
+      if (count > 0) readF(outPtr, count * 3, out)
+      const isPartial = m.HEAPU8[partial] !== 0
+      m._free(outPtr)
+      return isPartial ? -count : count
+    },
+    nearest(meshId, x, y, z, ex, ey, ez, include, exclude, out) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return false
+      const m = need()
+      const p = sf(0, [ x, y, z ]), ext = ex > 0 ? sf(3, [ ex, ey, ez ]) : 0, o = s() + 6 * 4
+      const ok = m._cnavNearest(mesh, p, ext, include, exclude, o) !== 0
+      if (ok) readF(o, 3, out)
+      return ok
+    },
+    raycast(meshId, fx, fy, fz, tx, ty, tz, include, exclude, out) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return true
+      const m = need()
+      const from = sf(0, [ fx, fy, fz ]), to = sf(3, [ tx, ty, tz ]), hit = s() + 6 * 4, nrm = s() + 9 * 4
+      const blocked = m._cnavRaycast(mesh, from, to, include, exclude, hit, nrm) !== 0
+      readF(hit, 6, out)
+      return blocked
+    },
+    randomPoint(meshId, cx, cy, cz, radius, seed, include, exclude, out) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return false
+      const m = need()
+      const c = radius > 0 ? sf(0, [ cx, cy, cz ]) : 0, o = s() + 3 * 4
+      const ok = m._cnavRandomPoint(mesh, c, radius, seed >>> 0, include, exclude, o) !== 0
+      if (ok) readF(o, 3, out)
+      return ok
+    },
+    debugTriangles(meshId) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return new Float32Array(0)
+      const m = need()
+      const n = m._cnavDebugTriangles(mesh, 0, 0)
+      const ptr = m._malloc(Math.max(1, n) * 12)
+      m._cnavDebugTriangles(mesh, ptr, n)
+      const out = new Float32Array(n * 3)
+      readF(ptr, n * 3, out)
+      m._free(ptr)
+      return out
+    },
+
+    crowdCreate(meshId, maxAgents, maxRadius) {
+      const mesh = meshes.get(meshId)
+      if (!mesh) return 0
+      const m = need()
+      const ptr = m._cnavCrowdCreate(mesh, maxAgents, maxRadius)
+      if (!ptr) return 0
+      const id = nextId++
+      crowds.set(id, { ptr, max: maxAgents, buf: m._malloc(maxAgents * READ.STRIDE * 4) })
+      return id
+    },
+    crowdDestroy(crowdId) {
+      const c = crowds.get(crowdId)
+      if (!c) return
+      need()._cnavCrowdDestroy(c.ptr)
+      need()._free(c.buf)
+      crowds.delete(crowdId)
+    },
+    crowdAdd(crowdId, x, y, z, params) {
+      const c = crowds.get(crowdId)
+      if (!c) return -1
+      const pos = sf(0, [ x, y, z ]), p = sf(3, params)
+      return need()._cnavCrowdAdd(c.ptr, pos, params.length >= AGENT.COUNT ? p : 0)
+    },
+    crowdRemove(crowdId, agent) { const c = crowds.get(crowdId); if (c) need()._cnavCrowdRemove(c.ptr, agent) },
+    crowdSetParams(crowdId, agent, params) {
+      const c = crowds.get(crowdId)
+      if (c && params.length >= AGENT.COUNT) need()._cnavCrowdSetParams(c.ptr, agent, sf(0, params))
+    },
+    crowdSetTarget(crowdId, agent, x, y, z) {
+      const c = crowds.get(crowdId)
+      return c ? need()._cnavCrowdSetTarget(c.ptr, agent, sf(0, [ x, y, z ])) !== 0 : false
+    },
+    crowdSetVelocity(crowdId, agent, vx, vy, vz) { const c = crowds.get(crowdId); if (c) need()._cnavCrowdSetVelocity(c.ptr, agent, sf(0, [ vx, vy, vz ])) },
+    crowdResetTarget(crowdId, agent) { const c = crowds.get(crowdId); if (c) need()._cnavCrowdResetTarget(c.ptr, agent) },
+    crowdWarp(crowdId, agent, x, y, z) {
+      const c = crowds.get(crowdId)
+      return c ? need()._cnavCrowdWarp(c.ptr, agent, sf(0, [ x, y, z ])) !== 0 : false
+    },
+    crowdUpdate(crowdId, dt) { const c = crowds.get(crowdId); if (c) need()._cnavCrowdUpdate(c.ptr, dt) },
+    crowdRead(crowdId, out) {
+      const c = crowds.get(crowdId)
+      if (!c || out.length < c.max * READ.STRIDE) return 0
+      const n = need()._cnavCrowdRead(c.ptr, c.buf)
+      readF(c.buf, c.max * READ.STRIDE, out)
+      return n
+    },
+  }
+}

package/src/vendor/creator-particles/dist/creatorParticles.d.ts

@@ -0,0 +1,43 @@
+// Type surface of the single-file Emscripten module build-wasm.sh emits next to this file.
+// The exported C functions take heap pointers; use js/index.ts rather than this directly.
+// Keep in step with the CPART_EXPORTS list in CMakeLists.txt and include/creator-particles/creator-particles.h.
+
+export interface CreatorParticlesModule {
+  HEAPU8: Uint8Array
+  HEAP32: Int32Array
+  HEAPU32: Uint32Array
+  HEAPF32: Float32Array
+  _malloc(bytes: number): number
+  _free(ptr: number): void
+
+  _cpartCreate(key: number, maxParticles: number): number
+  _cpartDestroy(key: number): void
+  _cpartExists(key: number): number
+  _cpartReset(): void
+  _cpartSetConfig(key: number, data: number, length: number): void
+  _cpartSpawn(key: number, count: number): void
+  _cpartSetVisible(key: number, visible: number): void
+  _cpartMode(key: number): number
+  _cpartOrder(key: number): number
+  _cpartCapacity(key: number): number
+  _cpartGeometryVersion(key: number): number
+  _cpartMeshVertexCount(key: number): number
+  _cpartMeshIndexCount(key: number): number
+  _cpartIndexPatternCount(key: number): number
+  _cpartWriteIndexPattern(key: number, out: number): void
+  _cpartUpdate(key: number, dt: number, world16: number, cameraPos3: number): void
+  _cpartAlive(key: number): number
+  _cpartVertexCount(key: number): number
+  _cpartVertexData(key: number): number
+  _cpartVertexStride(key: number): number
+  _cpartIndexCount(key: number): number
+  _cpartNoiseCreate(): number
+  _cpartNoiseSetFrequency(id: number, frequency: number): void
+  _cpartNoiseSetOctaves(id: number, octaves: number): void
+  _cpartNoiseSetLacunarity(id: number, lacunarity: number): void
+  _cpartNoiseSetGain(id: number, gain: number): void
+  _cpartNoise2D(id: number, x: number, y: number): number
+  _cpartNoise3D(id: number, x: number, y: number, z: number): number
+}
+
+export default function createCreatorParticles(): Promise<CreatorParticlesModule>