lecodes-gl-lite 2.0.0

package/src/core/serialize.ts

@@ -0,0 +1,144 @@
+// scene3d JSON serializer for the lite 3D scene core. Reads ONLY core state (entities, scenes,
+// materials, textures + the animation clock) and the headless physics config, and produces the
+// semantic tree `lecodes render` emits as `scene3d`. Additive changes vs. the old Scene3dRecorder
+// serializer: the camera fov is the core's real value (60, not 45), and a playing animation reports
+// its clock `time` alongside `clip`/`speed`. Everything else in the shape is preserved
+// (tests/frame.test.ts pins the `frame` section; the whole-shape spec went with runtime/headless's
+// JS-tree tests).
+
+import { getEulerYXZDeg, getScale } from "./math3d"
+import { computeFrame } from "./frame"
+import type { SceneCore, SceneRec, UniformRec } from "./sceneCore"
+
+const round = (v: number, digits = 4): number => {
+  const f = 10 ** digits
+  const r = Math.round(v * f) / f
+  return r === 0 ? 0 : r // normalize -0
+}
+const roundVec = (v: ArrayLike<number>, digits = 4): number[] => Array.from(v, (x) => round(x, digits))
+
+const hex = (packed: number, alpha: boolean): string =>
+  "#" + (packed >>> 0).toString(16).padStart(alpha ? 8 : 6, "0")
+
+export function serialize(core: SceneCore, physicsConfig?: Record<string, unknown>): unknown {
+  const { entities, scenes, materials, textures, worldMatrixF } = core
+
+  const uniformValue = (u: UniformRec): unknown => {
+    switch (u.kind) {
+      case "rgb": return hex(u.v, false)
+      case "rgba": return hex(u.v, true)
+      case "texture": return textures.get(u.v)?.source ?? `texture#${u.v}`
+      case "null": return null
+      default: return u.v
+    }
+  }
+
+  const serializeMaterial = (id: number): Record<string, unknown> | undefined => {
+    const m = materials.get(id)
+    if (!m) return undefined
+    const out: Record<string, unknown> = { shader: m.shader.replace(/\.filamat$/, "") }
+    for (const [k, u] of Object.entries(m.uniforms)) out[k] = uniformValue(u)
+    return out
+  }
+
+  const serializeNode = (id: number): Record<string, unknown> => {
+    const e = core.ent(id)
+    const w = e.m
+    const pos = roundVec([w[12], w[13], w[14]])
+    const rot = getEulerYXZDeg(w).map((v) => round(v, 2))
+    const scl = getScale(w).map((v) => round(v, 4))
+    const kind = e.light ? "light" : e.model ? "model" : e.mesh ? "mesh" : e.particles ? "particles" : e.anchor ? "anchor" : "node"
+
+    const out: Record<string, unknown> = {}
+    if (e.name) out.name = e.name
+    out.kind = kind
+    if (pos.some((v) => v !== 0)) out.position = pos
+    if (rot.some((v) => v !== 0)) out.rotation = rot
+    if (scl.some((v) => v !== 1)) out.scale = scl
+    if (!e.visible) out.visible = false
+
+    if (e.mesh) {
+      const mesh: Record<string, unknown> = { type: e.mesh.kind === 1 ? "edges" : e.mesh.kind === 2 ? "vertices" : "triangles" }
+      if (e.mesh.size) mesh.size = roundVec(e.mesh.size)
+      if (e.mesh.center?.some((v) => round(v) !== 0)) mesh.center = roundVec(e.mesh.center)
+      out.mesh = mesh
+      const mat = serializeMaterial(e.materials[0])
+      if (mat) out.material = mat
+    }
+    if (e.model) {
+      out.model = {
+        ...(e.model.source && { source: e.model.source }),
+        ...(!e.model.loaded && { loaded: false }),
+        animations: e.model.animations.map((a) => ({ name: a.name, duration: round(a.duration, 2) })),
+      }
+    }
+    if (e.light) {
+      out.light = {
+        type: "sun",
+        direction: roundVec(e.light.direction),
+        intensity: e.light.intensity,
+        color: hex(e.light.color, false),
+        shadows: e.light.shadowsQuality,
+      }
+    }
+    if (e.particles) out.particles = e.particles
+    if (e.physics) out.physics = e.physics
+    if (e.ragdoll) out.ragdoll = e.ragdoll
+    if (e.collider) out.collider = e.collider
+    if (e.castShadows !== undefined) out.castShadows = e.castShadows
+    if (e.receiveShadows !== undefined) out.receiveShadows = e.receiveShadows
+    if (e.anchor) out.anchor = e.anchor
+
+    if (e.children.length > 0) out.children = e.children.map(serializeNode)
+    return out
+  }
+
+  const serializeScene = (s: SceneRec): Record<string, unknown> => {
+    // Roots: scene members that don't sit under another member (those appear as children).
+    const isUnderMember = (id: number): boolean => {
+      for (let p = core.ent(id).parent; p !== 0; p = core.ent(p).parent) if (s.entities.has(p)) return true
+      return false
+    }
+    const roots = [...s.entities].filter((id) => entities.has(id) && !isUnderMember(id))
+
+    const out: Record<string, unknown> = {}
+    if (s.arMode) out.ar = { mode: s.arMode }
+    if (s.skybox !== undefined) out.skybox = hex(s.skybox, false)
+    if (s.ibl !== undefined) out.environment = { intensity: s.ibl }
+    if (s.bloom) out.bloom = s.bloom
+    const override = core.cameraOverride()
+    if (override) {
+      // An inspection camera (host tooling) owns the reported view; the app's camera entity is
+      // untouched, so say so — a reader must not take these numbers for the app's camera.
+      out.camera = {
+        position: roundVec(override.eye),
+        lookAt: roundVec(override.target),
+        fov: override.fov ?? core.projectionOf(s.id).fov,
+        inspection: true,
+      }
+    } else if (s.camera !== undefined && entities.has(s.camera)) {
+      const w = worldMatrixF(s.camera)
+      const rot = getEulerYXZDeg(w).map((v) => round(v, 2))
+      out.camera = {
+        position: roundVec([w[12], w[13], w[14]]),
+        ...(rot.some((v) => v !== 0) && { rotation: rot }),
+        fov: core.projectionOf(s.id).fov,
+      }
+    }
+    if (physicsConfig) out.physics = physicsConfig
+    out.nodes = roots.map(serializeNode)
+    if (s.overlays.length > 0) {
+      out.overlays = s.overlays.map((id) => scenes.get(id)).filter(Boolean).map((o) => serializeScene(o!))
+    }
+    return out
+  }
+
+  const scene = scenes.get(core.activeSceneId()) ?? [...scenes.values()].find((s) => s.overlayOf === undefined)
+  if (!scene) return null
+  const result = serializeScene(scene)
+  // Screen-space view (active scene + overlays) — present only when the scene has a camera to project
+  // through. Deliberately additive: makes the world-space tree *evaluable* without re-doing camera math.
+  const frame = computeFrame(core, scene)
+  if (frame) result.frame = frame
+  return result
+}

package/src/gen/unsupported.gen.ts

@@ -0,0 +1,212 @@
+// GENERATED by scripts/gen-bridges.ts from sdk/src/bridges/gl.d.ts — do not edit.
+// The completeness layer of the lite 3D engine (gl-lite): a warn-once stub for each of the 190 required
+// methods of _creator. The engine spreads `...unsupported` UNDER its own methods and checks the result
+// `satisfies typeof _creator`: a contract method it does not implement is an honest stub (a warning,
+// then the type's zero), a method it implements with the wrong signature is a type error.
+import type { ClipInfo } from "lecodes-sdk/bridges/gl"
+
+const $warned = new Set<string>()
+const $warn = (name: string) => {
+  if ($warned.has(name)) return
+  $warned.add(name)
+  console.warn(`[gl-lite] ${name}: not supported by the lite 3D engine`)
+}
+
+export const unsupported = {
+  createEngine(): void { $warn("createEngine") },
+  createScene(): number { $warn("createScene"); return 0 },
+  createOverlayScene(): number { $warn("createOverlayScene"); return 0 },
+  createGLView(): void { $warn("createGLView") },
+  openScene(): void { $warn("openScene") },
+  closeScene(): void { $warn("closeScene") },
+  launchAR(): void { $warn("launchAR") },
+  stopAR(): void { $warn("stopAR") },
+  launchVR(): void { $warn("launchVR") },
+  stopVR(): void { $warn("stopVR") },
+  addEntityToScene(): void { $warn("addEntityToScene") },
+  removeEntityFromScene(): void { $warn("removeEntityFromScene") },
+  warmRender(): void { $warn("warmRender") },
+  createEntity(): { id: number } { $warn("createEntity"); return { id: 0 } },
+  cloneEntity(): { id: number } { $warn("cloneEntity"); return { id: 0 } },
+  destroyEntity(): void { $warn("destroyEntity") },
+  entityIsOwned(): boolean { $warn("entityIsOwned"); return false },
+  setMatrix(): void { $warn("setMatrix") },
+  setWorldMatrix(): void { $warn("setWorldMatrix") },
+  getChildCount(): number { $warn("getChildCount"); return 0 },
+  getChild(): number { $warn("getChild"); return 0 },
+  setPosition(): void { $warn("setPosition") },
+  setQuaternion(): void { $warn("setQuaternion") },
+  setEulerAngles(): void { $warn("setEulerAngles") },
+  setScale(): void { $warn("setScale") },
+  setParent(): void { $warn("setParent") },
+  setParentNull(): void { $warn("setParentNull") },
+  getParent(): number { $warn("getParent"); return 0 },
+  traverse(): void { $warn("traverse") },
+  createSunLight(): void { $warn("createSunLight") },
+  setDefaultIbl(): void { $warn("setDefaultIbl") },
+  setBloomOptions(): void { $warn("setBloomOptions") },
+  setSkybox(): void { $warn("setSkybox") },
+  setSceneMultiSampleAntiAliasing(): void { $warn("setSceneMultiSampleAntiAliasing") },
+  setMaterialGlobalParameter(): void { $warn("setMaterialGlobalParameter") },
+  getCameraFov(): number { $warn("getCameraFov"); return 0 },
+  getMatrix(): void { $warn("getMatrix") },
+  getWorldMatrix(): void { $warn("getWorldMatrix") },
+  getWorldPosition(): void { $warn("getWorldPosition") },
+  getWorldDirection(): void { $warn("getWorldDirection") },
+  getWorldMatrixInverse(): void { $warn("getWorldMatrixInverse") },
+  getCameraViewDirection(): void { $warn("getCameraViewDirection") },
+  setMesh(): void { $warn("setMesh") },
+  createInstancedMesh(): void { $warn("createInstancedMesh") },
+  setInstanceTransforms(): void { $warn("setInstanceTransforms") },
+  setInstancedMeshMaterial(): void { $warn("setInstancedMeshMaterial") },
+  setInstancedMeshShadows(): void { $warn("setInstancedMeshShadows") },
+  setCulling(): void { $warn("setCulling") },
+  setCastShadows(): void { $warn("setCastShadows") },
+  setReceiveShadows(): void { $warn("setReceiveShadows") },
+  createTexture(): void { $warn("createTexture") },
+  createTextureFromCanvas(): number { $warn("createTextureFromCanvas"); return 0 },
+  updateTextureFromCanvas(): void { $warn("updateTextureFromCanvas") },
+  createMaterial(): { id: number } { $warn("createMaterial"); return { id: 0 } },
+  builtinMaterial(): { id: number } | null { $warn("builtinMaterial"); return null },
+  setMaterial(): void { $warn("setMaterial") },
+  getMaterial(): number { $warn("getMaterial"); return 0 },
+  setUniformRgb(): void { $warn("setUniformRgb") },
+  setUniformRgba(): void { $warn("setUniformRgba") },
+  setUniformFloat(): void { $warn("setUniformFloat") },
+  setUniformBoolean(): void { $warn("setUniformBoolean") },
+  setUniformTexture(): void { $warn("setUniformTexture") },
+  setUniformArray(): void { $warn("setUniformArray") },
+  setUniformNull(): void { $warn("setUniformNull") },
+  attachCameraToAR(): void { $warn("attachCameraToAR") },
+  getDisplaySize(): Float32Array { $warn("getDisplaySize"); return new Float32Array(0) },
+  setVisible(): void { $warn("setVisible") },
+  isVisible(): boolean { $warn("isVisible"); return false },
+  createGlb(): void { $warn("createGlb") },
+  setGlbCulling(): void { $warn("setGlbCulling") },
+  setEarlyUpdate(): void { $warn("setEarlyUpdate") },
+  setLateUpdate(): void { $warn("setLateUpdate") },
+  setOnPhysicsEvent(): void { $warn("setOnPhysicsEvent") },
+  loadClips(): void { $warn("loadClips") },
+  createClipFromTracks(): number { $warn("createClipFromTracks"); return 0 },
+  getClipSetInfo(): ClipInfo[] { $warn("getClipSetInfo"); return [] },
+  deriveClip(): number { $warn("deriveClip"); return 0 },
+  setClipEvents(): void { $warn("setClipEvents") },
+  getGlbClipSet(): number { $warn("getGlbClipSet"); return 0 },
+  destroyClipSet(): void { $warn("destroyClipSet") },
+  animatorCreate(): number { $warn("animatorCreate"); return 0 },
+  animatorDestroy(): void { $warn("animatorDestroy") },
+  animatorBind(): number { $warn("animatorBind"); return 0 },
+  animatorBoundTracks(): number { $warn("animatorBoundTracks"); return 0 },
+  animatorSetBlend(): void { $warn("animatorSetBlend") },
+  animatorSetBlendValue(): void { $warn("animatorSetBlendValue") },
+  animatorPlay(): void { $warn("animatorPlay") },
+  animatorStop(): void { $warn("animatorStop") },
+  animatorSeek(): void { $warn("animatorSeek") },
+  animatorGetSlotTime(): number { $warn("animatorGetSlotTime"); return 0 },
+  animatorGetSlotWeight(): number { $warn("animatorGetSlotWeight"); return 0 },
+  animatorSetLayer(): void { $warn("animatorSetLayer") },
+  animatorSetGlobal(): void { $warn("animatorSetGlobal") },
+  animatorSetRootMotion(): void { $warn("animatorSetRootMotion") },
+  animatorGetRootMotion(): void { $warn("animatorGetRootMotion") },
+  setOnAnimatorEvent(): void { $warn("setOnAnimatorEvent") },
+  animatorSetFeet(): void { $warn("animatorSetFeet") },
+  animatorSlotCurveAt(): number { $warn("animatorSlotCurveAt"); return 0 },
+  animatorSlotCurveInfo(): boolean { $warn("animatorSlotCurveInfo"); return false },
+  animatorSlotTurn(): number { $warn("animatorSlotTurn"); return 0 },
+  animatorSlotTimeAtTurn(): number { $warn("animatorSlotTimeAtTurn"); return 0 },
+  animatorLayerPhase(): number { $warn("animatorLayerPhase"); return 0 },
+  animatorSeekPhase(): void { $warn("animatorSeekPhase") },
+  animatorSlotFit(): number { $warn("animatorSlotFit"); return 0 },
+  animatorSlotExit(): number { $warn("animatorSlotExit"); return 0 },
+  animatorSlotAlign(): number { $warn("animatorSlotAlign"); return 0 },
+  animatorSlotContacts(): number { $warn("animatorSlotContacts"); return 0 },
+  animatorSlotTreads(): number { $warn("animatorSlotTreads"); return 0 },
+  animatorSlotPhysics(): number { $warn("animatorSlotPhysics"); return 0 },
+  animatorSlotFeatures(): number { $warn("animatorSlotFeatures"); return 0 },
+  animatorKneeAxis(): number { $warn("animatorKneeAxis"); return 0 },
+  animatorSlotKneePole(): number { $warn("animatorSlotKneePole"); return 0 },
+  animatorSetStepWarp(): void { $warn("animatorSetStepWarp") },
+  setOnAnimatorStep(): void { $warn("setOnAnimatorStep") },
+  animatorSetMotion(): void { $warn("animatorSetMotion") },
+  animatorSetDriveInput(): void { $warn("animatorSetDriveInput") },
+  animatorSetSlotDrive(): void { $warn("animatorSetSlotDrive") },
+  animatorSetWarpParams(): void { $warn("animatorSetWarpParams") },
+  locoCreate(): number { $warn("locoCreate"); return 0 },
+  locoDestroy(): void { $warn("locoDestroy") },
+  locoSetParams(): void { $warn("locoSetParams") },
+  locoDefaults(): void { $warn("locoDefaults") },
+  locoSetEntry(): void { $warn("locoSetEntry") },
+  locoClearSet(): void { $warn("locoClearSet") },
+  locoSetInput(): void { $warn("locoSetInput") },
+  locoStep(): void { $warn("locoStep") },
+  locoUpdate(): void { $warn("locoUpdate") },
+  locoRead(): void { $warn("locoRead") },
+  locoBuildDatabase(): number { $warn("locoBuildDatabase"); return 0 },
+  setColliderFromMesh(): void { $warn("setColliderFromMesh") },
+  setColliderBox(): void { $warn("setColliderBox") },
+  setColliderSphere(): void { $warn("setColliderSphere") },
+  physicsHasSupport(): boolean { $warn("physicsHasSupport"); return false },
+  physicsConfigure(): void { $warn("physicsConfigure") },
+  setInterpolation(): void { $warn("setInterpolation") },
+  physicsBuildBox(): number { $warn("physicsBuildBox"); return 0 },
+  physicsBuildSphere(): number { $warn("physicsBuildSphere"); return 0 },
+  physicsBuildCylinder(): number { $warn("physicsBuildCylinder"); return 0 },
+  physicsBuildCapsule(): number { $warn("physicsBuildCapsule"); return 0 },
+  physicsBuildMesh(): number { $warn("physicsBuildMesh"); return 0 },
+  physicsBuildMeshFromEntity(): number { $warn("physicsBuildMeshFromEntity"); return 0 },
+  physicsDestroyShape(): void { $warn("physicsDestroyShape") },
+  physicsCreateBody(): number { $warn("physicsCreateBody"); return 0 },
+  physicsSetPickable(): void { $warn("physicsSetPickable") },
+  physicsSetFriction(): void { $warn("physicsSetFriction") },
+  physicsGetFriction(): number { $warn("physicsGetFriction"); return 0 },
+  physicsRaycast(): number { $warn("physicsRaycast"); return 0 },
+  characterCreate(): number { $warn("characterCreate"); return 0 },
+  characterDestroy(): void { $warn("characterDestroy") },
+  characterMove(): void { $warn("characterMove") },
+  characterMoveFree(): void { $warn("characterMoveFree") },
+  characterSetVerticalVelocity(): void { $warn("characterSetVerticalVelocity") },
+  characterSetVelocity(): void { $warn("characterSetVelocity") },
+  characterSetGravityScale(): void { $warn("characterSetGravityScale") },
+  characterSetMaxSlope(): void { $warn("characterSetMaxSlope") },
+  characterGetVelocity(): void { $warn("characterGetVelocity") },
+  characterGetGroundState(): number { $warn("characterGetGroundState"); return 0 },
+  characterSetPosition(): void { $warn("characterSetPosition") },
+  vehicleCreate(): number { $warn("vehicleCreate"); return 0 },
+  vehicleDestroy(): void { $warn("vehicleDestroy") },
+  vehicleSetInput(): void { $warn("vehicleSetInput") },
+  vehicleGetState(): void { $warn("vehicleGetState") },
+  vehicleReset(): void { $warn("vehicleReset") },
+  vehicleBodyId(): number { $warn("vehicleBodyId"); return 0 },
+  physicsCreateBox(): number { $warn("physicsCreateBox"); return 0 },
+  physicsCreateSphere(): number { $warn("physicsCreateSphere"); return 0 },
+  physicsCreateCylinder(): number { $warn("physicsCreateCylinder"); return 0 },
+  physicsSetLinearVelocity(): void { $warn("physicsSetLinearVelocity") },
+  physicsGetLinearVelocity(): void { $warn("physicsGetLinearVelocity") },
+  physicsApplyImpulse(): void { $warn("physicsApplyImpulse") },
+  physicsSetBodyPosition(): void { $warn("physicsSetBodyPosition") },
+  physicsRemoveBody(): void { $warn("physicsRemoveBody") },
+  createMediaPlayerTexture(): number { $warn("createMediaPlayerTexture"); return 0 },
+  getName(): string { $warn("getName"); return "" },
+  setName(): void { $warn("setName") },
+  hasMesh(): boolean { $warn("hasMesh"); return false },
+  createARController(): void { $warn("createARController") },
+  createRootAnchor(): number { $warn("createRootAnchor"); return 0 },
+  createAnchor(): number { $warn("createAnchor"); return 0 },
+  createParticleSystem(): void { $warn("createParticleSystem") },
+  spawnParticles(): void { $warn("spawnParticles") },
+  setParticleSystemConfig(): void { $warn("setParticleSystemConfig") },
+  createNoise(): number { $warn("createNoise"); return 0 },
+  setNoiseFrequency(): void { $warn("setNoiseFrequency") },
+  setNoiseOctaves(): void { $warn("setNoiseOctaves") },
+  setNoiseFractalLunacrity(): void { $warn("setNoiseFractalLunacrity") },
+  setNoiseFractalGain(): void { $warn("setNoiseFractalGain") },
+  getNoise2D(): number { $warn("getNoise2D"); return 0 },
+  getNoise3D(): number { $warn("getNoise3D"); return 0 },
+  captureImage(): void { $warn("captureImage") },
+} satisfies Partial<typeof _creator>
+
+/** The stubbed names — an engine reports its gap as the names its bridge still maps to these. */
+export const unsupportedNames = ["createEngine", "createScene", "createOverlayScene", "createGLView", "openScene", "closeScene", "launchAR", "stopAR", "launchVR", "stopVR", "addEntityToScene", "removeEntityFromScene", "warmRender", "createEntity", "cloneEntity", "destroyEntity", "entityIsOwned", "setMatrix", "setWorldMatrix", "getChildCount", "getChild", "setPosition", "setQuaternion", "setEulerAngles", "setScale", "setParent", "setParentNull", "getParent", "traverse", "createSunLight", "setDefaultIbl", "setBloomOptions", "setSkybox", "setSceneMultiSampleAntiAliasing", "setMaterialGlobalParameter", "getCameraFov", "getMatrix", "getWorldMatrix", "getWorldPosition", "getWorldDirection", "getWorldMatrixInverse", "getCameraViewDirection", "setMesh", "createInstancedMesh", "setInstanceTransforms", "setInstancedMeshMaterial", "setInstancedMeshShadows", "setCulling", "setCastShadows", "setReceiveShadows", "createTexture", "createTextureFromCanvas", "updateTextureFromCanvas", "createMaterial", "builtinMaterial", "setMaterial", "getMaterial", "setUniformRgb", "setUniformRgba", "setUniformFloat", "setUniformBoolean", "setUniformTexture", "setUniformArray", "setUniformNull", "attachCameraToAR", "getDisplaySize", "setVisible", "isVisible", "createGlb", "setGlbCulling", "setEarlyUpdate", "setLateUpdate", "setOnPhysicsEvent", "loadClips", "createClipFromTracks", "getClipSetInfo", "deriveClip", "setClipEvents", "getGlbClipSet", "destroyClipSet", "animatorCreate", "animatorDestroy", "animatorBind", "animatorBoundTracks", "animatorSetBlend", "animatorSetBlendValue", "animatorPlay", "animatorStop", "animatorSeek", "animatorGetSlotTime", "animatorGetSlotWeight", "animatorSetLayer", "animatorSetGlobal", "animatorSetRootMotion", "animatorGetRootMotion", "setOnAnimatorEvent", "animatorSetFeet", "animatorSlotCurveAt", "animatorSlotCurveInfo", "animatorSlotTurn", "animatorSlotTimeAtTurn", "animatorLayerPhase", "animatorSeekPhase", "animatorSlotFit", "animatorSlotExit", "animatorSlotAlign", "animatorSlotContacts", "animatorSlotTreads", "animatorSlotPhysics", "animatorSlotFeatures", "animatorKneeAxis", "animatorSlotKneePole", "animatorSetStepWarp", "setOnAnimatorStep", "animatorSetMotion", "animatorSetDriveInput", "animatorSetSlotDrive", "animatorSetWarpParams", "locoCreate", "locoDestroy", "locoSetParams", "locoDefaults", "locoSetEntry", "locoClearSet", "locoSetInput", "locoStep", "locoUpdate", "locoRead", "locoBuildDatabase", "setColliderFromMesh", "setColliderBox", "setColliderSphere", "physicsHasSupport", "physicsConfigure", "setInterpolation", "physicsBuildBox", "physicsBuildSphere", "physicsBuildCylinder", "physicsBuildCapsule", "physicsBuildMesh", "physicsBuildMeshFromEntity", "physicsDestroyShape", "physicsCreateBody", "physicsSetPickable", "physicsSetFriction", "physicsGetFriction", "physicsRaycast", "characterCreate", "characterDestroy", "characterMove", "characterMoveFree", "characterSetVerticalVelocity", "characterSetVelocity", "characterSetGravityScale", "characterSetMaxSlope", "characterGetVelocity", "characterGetGroundState", "characterSetPosition", "vehicleCreate", "vehicleDestroy", "vehicleSetInput", "vehicleGetState", "vehicleReset", "vehicleBodyId", "physicsCreateBox", "physicsCreateSphere", "physicsCreateCylinder", "physicsSetLinearVelocity", "physicsGetLinearVelocity", "physicsApplyImpulse", "physicsSetBodyPosition", "physicsRemoveBody", "createMediaPlayerTexture", "getName", "setName", "hasMesh", "createARController", "createRootAnchor", "createAnchor", "createParticleSystem", "spawnParticles", "setParticleSystemConfig", "createNoise", "setNoiseFrequency", "setNoiseOctaves", "setNoiseFractalLunacrity", "setNoiseFractalGain", "getNoise2D", "getNoise3D", "captureImage"] as const
+/** The contract methods `bridge` still answers with a stub. */
+export const stubbedIn = (bridge: Record<string, unknown>): string[] =>
+  unsupportedNames.filter((n) => bridge[n] === (unsupported as Record<string, unknown>)[n])

package/src/index.ts

@@ -0,0 +1,5 @@
+// lecodes-gl-lite: the LITE 3D engine — the GL-free scene core (src/core, shared with the headless
+// recorder) + its WebGL2 renderer over ogl. No wasm, no Filament. An embedder takes it as a
+// library (an editor's viewport); the web host runs Filament, not this.
+export { createViewerLite, basePropsLite } from './webgl/createViewerLite'
+export type { ViewerOptions } from './webgl/createViewerLite'

package/src/vendor/creator-anim/dist/creatorAnim.d.ts

@@ -0,0 +1,123 @@
+// 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.
+
+export interface CreatorAnimModule {
+  HEAPU8: Uint8Array
+  HEAPU16: Uint16Array
+  HEAP32: Int32Array
+  HEAPU32: Uint32Array
+  HEAPF32: Float32Array
+  _malloc(bytes: number): number
+  _free(ptr: number): void
+  UTF8ToString(ptr: number): string
+  stringToUTF8(str: string, ptr: number, maxBytes: number): void
+  lengthBytesUTF8(str: string): number
+
+  _canimClipsLoad(glb: number, size: number): number
+  _canimClipsFromTracks(names: number, data: number, length: number): number
+  _canimClipsSlice(set: number, clip: number, start: number, end: number): number
+  _canimClipsMirror(set: number, clip: number): number
+  _canimClipsSetRig(set: number, jointCount: number, parents: number, names: number, rest: number): void
+  _canimClipsDerive(set: number, clip: number, mirror: number, start: number, end: number): number
+  _canimClipsCount(set: number): number
+  _canimClipName(set: number, clip: number): number
+  _canimClipDuration(set: number, clip: number): number
+  _canimClipTrackCount(set: number, clip: number): number
+  _canimClipsSetEvents(set: number, clip: number, times: number, count: number): void
+  _canimClipsDestroy(set: number): void
+  _canimAnimatorCreate(jointCount: number, parents: number, names: number, rest: number, skin: number, tag: number): number
+  _canimAnimatorDestroy(id: number): void
+  _canimAnimatorsDestroyTagged(tag: number): void
+  _canimAnimatorCount(): number
+  _canimAnimatorJointCount(id: number): number
+  _canimAnimatorShadowedNames(id: number): number
+  _canimAnimatorRest(id: number, outTRS: number, outWrite: number): void
+  _canimAnimatorBind(id: number, set: number, clip: number, layer: number): number
+  /** since 0.20: the clip mirrored on the skeleton (absent on an older wasm build) */
+  _canimAnimatorBindMirror?(id: number, set: number, clip: number, layer: number): number
+  _canimAnimatorBoundTracks(id: number, slot: number): number
+  _canimAnimatorSetBlend(id: number, layer: number, dims: number, slots: number, positions: number, phases: number, count: number, fade: number, speed: number): void
+  _canimAnimatorSetBlendValue(id: number, layer: number, x: number, y: number): void
+  _canimAnimatorPlay(id: number, slot: number, loop: number, speed: number, fadeIn: number, fadeOut: number, restart: number): void
+  _canimAnimatorSlotSetTurn(id: number, slot: number, radians: number, enabled: number): void
+  _canimAnimatorStop(id: number, layer: number, slot: number, fade: number): void
+  _canimAnimatorSeek(id: number, slot: number, time: number): void
+  _canimAnimatorSlotTime(id: number, slot: number): number
+  _canimAnimatorSlotWeight(id: number, slot: number): number
+  _canimAnimatorSetLayer(id: number, layer: number, weight: number, additive: number, maskRoots: number): void
+  _canimAnimatorSetLayerAnticipation(id: number, layer: number, amount: number): void
+  _canimAnimatorSetGlobal(id: number, speed: number, paused: number): void
+  _canimAnimatorSeedPose(id: number, trs: number, blend: number): void
+  _canimAnimatorJointRanges(id: number, pairs: number, count: number, frames: number, out: number): number
+  _canimAnimatorSetRootMotion(id: number, bone: number, apply: number): void
+  _canimAnimatorRootMotion(id: number, out3: number): void
+  _canimAnimatorEvaluate(id: number, dt: number, lodMaskOn: number, outTRS: number, outWrite: number): number
+  _canimAnimatorEvents(id: number, outPairs: number, maxPairs: number): number
+  _canimAnimatorRootMotionFrame(id: number, out4: number): number
+  _canimAnimatorMorphCount(id: number): number
+  _canimAnimatorMorph(id: number, index: number, outJoint: number, outCount: number): number
+  _canimAnimatorSetFeet(id: number, leftChain: number, rightChain: number): void
+  _canimAnimatorFootJoint(id: number, side: number, toe: number): number
+  _canimAnimatorSlotPhase(id: number, slot: number): number
+  _canimAnimatorLayerPhase(id: number, layer: number): number
+  _canimAnimatorSeekPhase(id: number, slot: number, phase: number): void
+  _canimAnimatorSlotCurve(id: number, slot: number, which: number, out: number, max: number): number
+  _canimAnimatorSlotCurveAt(id: number, slot: number, which: number, time: number): number
+  _canimAnimatorSlotCurveInfo(id: number, slot: number, out4: number): number
+  _canimAnimatorSlotFit(id: number, slot: number, target: number, align: number, out: number, max: number): number
+  _canimAnimatorSlotExit(id: number, slot: number, target: number, tolerance: number, atContact: number, align: number): number
+  _canimAnimatorSlotAlign(id: number, a: number, b: number, offA: number, cyclesA: number, out4: number): number
+  _canimAnimatorSlotContacts(id: number, slot: number, out: number, maxSpans: number): number
+  _canimAnimatorSlotTreads(id: number, slot: number, out: number, max: number): number
+  _canimAnimatorSlotPhysics(id: number, slot: number, time: number, out11: number): number
+  _canimAnimatorSlotFeatures(id: number, slot: number, time: number, out37: number): number
+  _canimAnimatorKneeAxis(id: number, side: number, out8: number): number
+  _canimAnimatorSlotKneePole(id: number, slot: number, side: number, time: number, out6: number): number
+  _canimAnimatorSetStepWarp(id: number, on: number, stride: number, lift: number, pitchDeg: number, slopeDeg: number): void
+  _canimAnimatorStepCount(id: number): number
+  _canimAnimatorStep(id: number, index: number, out3: number): number
+  _canimAnimatorSetWorld(id: number, m16: number): void
+  _canimAnimatorSetGrounded(id: number, grounded: number): void
+  _canimAnimatorSetFeetParams(id: number, params: number, count: number): void
+  _canimAnimatorFeetDefaults(params: number): void
+  _canimAnimatorFootProbe(id: number, side: number, outFrom3: number, outTo3: number): number
+  _canimAnimatorSetGround(id: number, side: number, hit: number, x: number, y: number, z: number, nx: number, ny: number, nz: number): void
+  _canimAnimatorFootState(id: number, side: number, out8: number): number
+  _canimAnimatorJointPosition(id: number, joint: number, out3: number): number
+  _canimAnimatorIkCreate(id: number, kind: number, chain: number): number
+  _canimAnimatorIkSet(id: number, ik: number, params: number, count: number): void
+  _canimAnimatorIkDestroy(id: number, ik: number): void
+  _canimAnimatorIkCreateJoints(id: number, kind: number, root: number, mid: number, end: number): number
+  _canimAnimatorIkGet(id: number, ik: number, out: number, count: number): number
+  _canimAnimatorIkAnchor(id: number, ik: number, socket: number): void
+  _canimAnimatorIkState(id: number, ik: number, out4: number): number
+  _canimAnimatorSetSocket(id: number, set: number, name: number, joint: number, trs7: number): void
+  _canimAnimatorSocketSetWorld(id: number, set: number, name: number, m16: number): void
+  _canimAnimatorLateSolve(id: number, world16: number, localTRS: number, outWrite: number): number
+  _canimClipsSetAnchors(set: number, clip: number, bone: number, donor: number, sockets: number, spans: number, count: number): void
+  _canimAnimatorSetMotion(id: number, vx: number, vy: number, vz: number): void
+  _canimAnimatorSetDriveInput(id: number, distance: number, angle: number): void
+  _canimAnimatorSetSlotDrive(id: number, slot: number, mode: number, entry: number): void
+  _canimAnimatorSlotTurn(id: number, slot: number): number
+  _canimAnimatorSlotTimeAtTurn(id: number, slot: number, yaw: number): number
+  _canimAnimatorSetWarpParams(id: number, params: number, count: number): void
+  _canimAnimatorWarpDefaults(params: number): void
+  _canimLocoCreate(animator: number): number
+  _canimLocoDestroy(loco: number): void
+  _canimLocoDefaults(params: number): void
+  _canimLocoSetParams(loco: number, params: number, count: number): void
+  _canimLocoSetEntry(loco: number, slot: number, kind: number, angle: number, speed: number): void
+  _canimLocoClearSet(loco: number): void
+  _canimLocoSetInput(loco: number, input: number, count: number): void
+  _canimLocoStep(loco: number, dt: number, px: number, py: number, pz: number): void
+  _canimLocoUpdate(loco: number, dt: number): void
+  _canimLocoRead(loco: number, out: number, count: number): void
+  _canimLocoBuildDatabase(loco: number): number
+  _canimLocoMatchSlot(loco: number): number
+  _canimLocoMatchTime(loco: number): number
+  _canimReset(): void
+  _canimVersion(): number
+}
+
+declare const createCreatorAnim: (options?: Record<string, unknown>) => Promise<CreatorAnimModule>
+export default createCreatorAnim