lecodes-viewer 0.19.0

package/src/viewer2d/createViewer2d.ts

@@ -0,0 +1,438 @@
+// Web host for the creator-2d wasm engine. Mirrors viewer/createViewer.ts but for the lightweight
+// 2D stack: it creates a WebGL2 context, instantiates creator2d.wasm, drives a host-owned RAF loop
+// (TS update(dt) → native render(nowMs)), and returns the `_creator2d` bridge object the worker SDK
+// (packages/worker/src/2d/) calls through. A 2D-only project never loads Filament.
+//
+// All native entry points take plain numbers, so most methods are direct passthroughs. The few that
+// move buffers (textures, animation frames, tile data, out-pointers) malloc → copy HEAP → free.
+//
+// ⚠ ALLOW_MEMORY_GROWTH: a cached HEAPF32/HEAPU8 view detaches when the wasm heap grows. We always
+// re-read module.HEAPF32/HEAPU8 right before use (never cache a view across an allocation).
+
+// @ts-ignore - emscripten ESM factory
+import createModule from './creator2d.js'
+import wasmUrl from './creator2d.wasm?url'
+import { getBuffer } from '../utils/fetch'
+import { viewScale } from '../ui/viewScale'
+import type { CanvasHost } from '../canvas/createCanvasHost'
+
+export type Viewer2dOptions = {
+  /** Pixels-per-world-unit at camera zoom 1 is the engine default (1). Linear texture filtering off
+   *  by default (crisp pixel art). */
+  linearFilter?: boolean
+}
+
+export type AnimEvent = { entityId: number; clipId: number; type: number } // type: 0 loop, 1 complete
+
+export const createViewer2d = async (canvas: HTMLCanvasElement, options: Viewer2dOptions = {}, canvasHost?: CanvasHost) => {
+  const wasmBinary = await fetch(wasmUrl).then(r => r.arrayBuffer())
+
+  const glOptions: WebGLContextAttributes & { majorVersion?: number; minorVersion?: number } = {
+    alpha: false,
+    depth: true,
+    stencil: true,
+    antialias: false,
+    premultipliedAlpha: false,
+    desynchronized: false,
+    powerPreference: 'high-performance',
+    failIfMajorPerformanceCaveat: false,
+    majorVersion: 2,
+    minorVersion: 0,
+  }
+  const gl = canvas.getContext('webgl2', glOptions)!
+  // creator-2d's c2dInit registers this context with emscripten's GL layer (see init.cpp EM_ASM).
+  ;(window as any).creator2d_glContext = gl
+  ;(window as any).creator2d_glOptions = glOptions
+
+  const module = await createModule({ wasmBinary, canvas })
+
+  module._c2dInit()
+  if (options.linearFilter) module._c2dSetDefaultFilter(true)
+  module._c2dSetViewport(canvas.width, canvas.height)
+
+  // Resolution factor (devicePixelRatio × CSS zoom) the backing store renders at, set by _onResize.
+  // The 2D engine couples world-units to viewport px (1 world unit == 1 px at camera zoom 1), so a
+  // backing grown by `factor` would shrink the world on screen. We compensate by multiplying every
+  // scene's camera zoom by the factor (tracking the user's own zoom per scene so a resize can
+  // reapply it), and by scaling screen↔world inputs. At factor 1 this is all identity — behavior is
+  // unchanged on a DPR-1 display with no zoom. See docs/simulator-plan.md phase 3.
+  let factor = 1
+  const userZoom = new Map<number, number>() // sceneId → the zoom the SDK set (pre-factor)
+
+  // --- malloc helpers ------------------------------------------------------------------------
+  const withFloats = <T>(values: ArrayLike<number>, fn: (ptr: number) => T): T => {
+    const ptr = module._malloc(values.length * 4)
+    module.HEAPF32.set(values as any, ptr / 4)
+    try { return fn(ptr) } finally { module._free(ptr) }
+  }
+  // readFloats returns a native float output with NO per-call allocation: one wasm scratch buffer
+  // (malloc'd once — its address is stable across heap growth) plus one reused JS output array. The
+  // returned array is SHARED and valid only until the next readFloats call, so every caller must
+  // consume it immediately — they do: each getter reads it straight into a Vec2 / object / fields,
+  // none retains it or holds two results at once. We index a FRESH module.HEAPF32 each call because
+  // emscripten swaps that view when the heap grows (updateMemoryViews); the scratch address survives.
+  const READ_SCRATCH = 192 // ≥ the largest reader (physicsRaycastAll = 32 hits × 6 floats)
+  const readScratchPtr = module._malloc(READ_SCRATCH * 4)
+  const readScratchOut = new Float32Array(READ_SCRATCH) // standalone buffer — unaffected by growth
+  const readFloats = (n: number, fn: (ptr: number) => void): Float32Array => {
+    fn(readScratchPtr)
+    const base = readScratchPtr >> 2
+    const heap = module.HEAPF32
+    for (let i = 0; i < n; i++) readScratchOut[i] = heap[base + i]
+    return readScratchOut
+  }
+
+  // --- host-driven loop ----------------------------------------------------------------------
+  // Game logic runs in TS update callbacks (worker SDK onUpdate); animations + batching run native.
+  const updateCallbacks = new Set<(dt: number) => void>()
+  let running = false
+  let lastNow = 0
+
+  const frame = (now: number) => {
+    if (!running) return
+    const dt = lastNow === 0 ? 0 : Math.min(0.05, (now - lastNow) / 1000)
+    lastNow = now
+    for (const cb of updateCallbacks) cb(dt)
+    module._c2dRender(now)
+    requestAnimationFrame(frame)
+  }
+
+  const start = () => {
+    if (running) return
+    running = true
+    lastNow = 0
+    canvas.style.display = 'block'
+    requestAnimationFrame(frame)
+  }
+  const stop = () => { running = false }
+
+  // --- scene pointer input ----------------------------------------------------------------------
+  // Deliver raw canvas pointer phases (logical px relative to the canvas) to the SDK, which hit-tests
+  // + tracks. pointerdown is on the canvas; move/up/cancel are on window so a drag continues outside.
+  let pointerCb: ((phase: number, id: number, x: number, y: number) => void) | null = null
+  const activePointers = new Set<number>()
+  const localXY = (e: PointerEvent): [number, number] => {
+    const r = canvas.getBoundingClientRect()
+    // clientX/rect are VISUAL px under the simulator's CSS zoom; deliver logical px to the SDK.
+    const scale = viewScale(canvas)
+    return [(e.clientX - r.left) / scale, (e.clientY - r.top) / scale]
+  }
+  const onPointerDown = (e: PointerEvent) => {
+    if (!pointerCb) return
+    activePointers.add(e.pointerId)
+    try { canvas.setPointerCapture(e.pointerId) } catch {}
+    const [x, y] = localXY(e); pointerCb(0, e.pointerId, x, y)
+  }
+  const onPointerMove = (e: PointerEvent) => {
+    if (!pointerCb || !activePointers.has(e.pointerId)) return
+    const [x, y] = localXY(e); pointerCb(1, e.pointerId, x, y)
+  }
+  const onPointerUp = (e: PointerEvent) => {
+    if (!pointerCb || !activePointers.delete(e.pointerId)) return
+    const [x, y] = localXY(e); pointerCb(2, e.pointerId, x, y)
+  }
+  const onPointerCancel = (e: PointerEvent) => {
+    if (!pointerCb || !activePointers.delete(e.pointerId)) return
+    const [x, y] = localXY(e); pointerCb(3, e.pointerId, x, y)
+  }
+  let pointerListenersAttached = false
+  const setPointerListeners = (on: boolean) => {
+    if (on === pointerListenersAttached) return
+    pointerListenersAttached = on
+    if (on) {
+      canvas.addEventListener('pointerdown', onPointerDown)
+      window.addEventListener('pointermove', onPointerMove)
+      window.addEventListener('pointerup', onPointerUp)
+      window.addEventListener('pointercancel', onPointerCancel)
+    } else {
+      canvas.removeEventListener('pointerdown', onPointerDown)
+      window.removeEventListener('pointermove', onPointerMove)
+      window.removeEventListener('pointerup', onPointerUp)
+      window.removeEventListener('pointercancel', onPointerCancel)
+    }
+  }
+
+  return {
+    /** Redraw the current frame synchronously; true when a frame was drawn. No update callbacks —
+     *  logic must not double-step. Hosts call this right before reading the canvas back; see
+     *  createViewer.ts _renderNow. */
+    _renderNow: (): boolean => {
+      if (!running) return false
+      module._c2dRender(performance.now())
+      return true
+    },
+    backend: 'sokol',
+
+    // --- lifecycle / loop ---
+    version: () => module._creator2dVersion(),
+    render: (nowMs: number) => module._c2dRender(nowMs),
+    onUpdate: (cb: (dt: number) => void) => { updateCallbacks.add(cb) },
+    offUpdate: (cb: (dt: number) => void) => { updateCallbacks.delete(cb) },
+    setOnAnimEvent: (cb: (e: AnimEvent) => void) => {
+      module.onAnimEvent = (entityId: number, clipId: number, type: number) => cb({ entityId, clipId, type })
+    },
+    // Per-frame aspect update(dt) dispatch, fired from inside c2dRender: early = before the physics
+    // step, late = after animations / just before draw. Single-slot (the SDK registers one dispatcher
+    // per phase that iterates its own updater list). See init.cpp / lib.js.
+    setEarlyUpdate: (cb: (dt: number) => void) => { module.onEarlyUpdate = cb },
+    setLateUpdate: (cb: (dt: number) => void) => { module.onLateUpdate = cb },
+    // Engine clock multiplier (SDK Time.scale / Time.paused). Bound only when the wasm exports it.
+    ...((module as any)._c2dSetTimeScale ? { setTimeScale: (scale: number) => (module as any)._c2dSetTimeScale(scale) } : {}),
+    setOnPointer: (cb: (phase: number, pointerId: number, x: number, y: number) => void) => {
+      pointerCb = cb
+      setPointerListeners(true)
+    },
+    setClearColor: (r: number, g: number, b: number, a: number) => module._c2dSetClearColor(r, g, b, a),
+
+    // --- scenes ---
+    createScene: (): number => {
+      const id = module._c2dCreateScene()
+      // Default zoom 1, pre-scaled by the factor so an app that never touches the camera still
+      // renders the world at native size on a HiDPI / zoomed viewport.
+      userZoom.set(id, 1)
+      module._c2dCameraSetZoom(id, factor)
+      return id
+    },
+    destroyScene: (sceneId: number) => { userZoom.delete(sceneId); module._c2dDestroyScene(sceneId) },
+    openScene: (sceneId: number) => { module._c2dOpenScene(sceneId); start() },
+    closeScene: () => { module._c2dCloseScene(); stop(); canvas.style.display = 'none' },
+    sceneSetClearColor: (sceneId: number, r: number, g: number, b: number, a: number) =>
+      module._c2dSceneSetClearColor(sceneId, r, g, b, a),
+    addEntityToScene: (sceneId: number, entityId: number) => module._c2dAddEntityToScene(sceneId, entityId),
+    removeEntityFromScene: (sceneId: number, entityId: number) => module._c2dRemoveEntityFromScene(sceneId, entityId),
+    setLayerYSort: (sceneId: number, layer: number, enabled: boolean) => module._c2dSetLayerYSort(sceneId, layer, enabled),
+
+    // --- camera ---
+    cameraSetPosition: (sceneId: number, x: number, y: number) => module._c2dCameraSetPosition(sceneId, x, y),
+    cameraSetZoom: (sceneId: number, zoom: number) => {
+      userZoom.set(sceneId, zoom)
+      module._c2dCameraSetZoom(sceneId, zoom * factor)
+    },
+    cameraSetRotation: (sceneId: number, deg: number) => module._c2dCameraSetRotation(sceneId, deg),
+    cameraScreenToWorld: (sceneId: number, sx: number, sy: number): Float32Array =>
+      // Screen inputs are logical px; the native viewport is backing px → scale up by the factor.
+      readFloats(2, ptr => module._c2dCameraScreenToWorld(sceneId, sx * factor, sy * factor, ptr)),
+    cameraWorldToScreen: (sceneId: number, wx: number, wy: number): Float32Array => {
+      // Native returns backing px → bring back to logical px.
+      const o = readFloats(2, ptr => module._c2dCameraWorldToScreen(sceneId, wx, wy, ptr))
+      o[0] /= factor; o[1] /= factor
+      return o
+    },
+
+    // --- entities / transforms ---
+    createEntity: (): number => module._c2dCreateEntity(),
+    destroyEntity: (entityId: number) => module._c2dDestroyEntity(entityId),
+    setPosition: (entityId: number, x: number, y: number) => module._c2dSetPosition(entityId, x, y),
+    setRotation: (entityId: number, deg: number) => module._c2dSetRotation(entityId, deg),
+    setScale: (entityId: number, sx: number, sy: number) => module._c2dSetScale(entityId, sx, sy),
+    setLayer: (entityId: number, layer: number) => module._c2dSetLayer(entityId, layer),
+    setZ: (entityId: number, z: number) => module._c2dSetZ(entityId, z),
+    setVisible: (entityId: number, visible: boolean) => module._c2dSetVisible(entityId, visible),
+    getPosition: (entityId: number): Float32Array => readFloats(2, ptr => module._c2dGetPosition(entityId, ptr)),
+
+    // --- hierarchy ---
+    setParent: (childId: number, parentId: number, keepWorld: boolean) => module._c2dSetParent(childId, parentId, keepWorld),
+    getParent: (entityId: number): number => module._c2dGetParent(entityId),
+    getChildCount: (entityId: number): number => module._c2dGetChildCount(entityId),
+    getChild: (entityId: number, index: number): number => module._c2dGetChild(entityId, index),
+    getWorldPosition: (entityId: number): Float32Array => readFloats(2, ptr => module._c2dGetWorldPosition(entityId, ptr)),
+    getWorldMatrix: (entityId: number): Float32Array => readFloats(6, ptr => module._c2dGetWorldMatrix(entityId, ptr)),
+    worldToLocal: (entityId: number, wx: number, wy: number): Float32Array =>
+      readFloats(2, ptr => module._c2dWorldToLocal(entityId, wx, wy, ptr)),
+    localToWorld: (entityId: number, lx: number, ly: number): Float32Array =>
+      readFloats(2, ptr => module._c2dLocalToWorld(entityId, lx, ly, ptr)),
+    getLocalTransform: (entityId: number): Float32Array => readFloats(5, ptr => module._c2dGetLocalTransform(entityId, ptr)),
+
+    // --- sprite component ---
+    setSprite: (entityId: number, textureId: number) => module._c2dSetSprite(entityId, textureId),
+    setSpriteFrame: (entityId: number, u0: number, v0: number, u1: number, v1: number) =>
+      module._c2dSetSpriteFrame(entityId, u0, v0, u1, v1),
+    setSpriteFramePx: (entityId: number, px: number, py: number, pw: number, ph: number) =>
+      module._c2dSetSpriteFramePx(entityId, px, py, pw, ph),
+    setSpriteSize: (entityId: number, w: number, h: number) => module._c2dSetSpriteSize(entityId, w, h),
+    setSpriteAnchor: (entityId: number, ax: number, ay: number) => module._c2dSetSpriteAnchor(entityId, ax, ay),
+    setSpriteColor: (entityId: number, r: number, g: number, b: number) => module._c2dSetSpriteColor(entityId, r, g, b),
+    setSpriteOpacity: (entityId: number, a: number) => module._c2dSetSpriteOpacity(entityId, a),
+    setSpriteFlip: (entityId: number, flipX: boolean, flipY: boolean) => module._c2dSetSpriteFlip(entityId, flipX, flipY),
+
+    // --- textures (systemId = a fetch buffer id; we hand the raw bytes to native stb_image) ---
+    createTexture: (systemId: number, onComplete: (texId: number, w: number, h: number) => void, onReject: (e: any) => void) => {
+      try {
+        const buf = getBuffer(systemId)
+        const bytes = new Uint8Array(buf)
+        const ptr = module._malloc(bytes.length)
+        module.HEAPU8.set(bytes, ptr)
+        const texId = module._c2dCreateTexture(ptr, bytes.length)
+        module._free(ptr)
+        if (texId === 0) { onReject(new Error('creator-2d: texture decode failed')); return }
+        onComplete(texId, module._c2dGetTextureWidth(texId), module._c2dGetTextureHeight(texId))
+      } catch (e) {
+        onReject(e)
+      }
+    },
+    getTextureWidth: (texId: number): number => module._c2dGetTextureWidth(texId),
+    getTextureHeight: (texId: number): number => module._c2dGetTextureHeight(texId),
+    destroyTexture: (texId: number) => module._c2dDestroyTexture(texId),
+    setDefaultFilter: (linear: boolean) => module._c2dSetDefaultFilter(linear),
+
+    // --- textures from a _creatorCanvas surface (straight RGBA8 pixels → sokol image; no decode) ---
+    createTextureFromCanvas: (surfaceId: number): number => {
+      const surf = canvasHost?.readSurface(surfaceId)
+      if (!surf) return 0
+      const bytes = new Uint8Array(surf.data.buffer, surf.data.byteOffset, surf.data.byteLength)
+      const ptr = module._malloc(bytes.length)
+      module.HEAPU8.set(bytes, ptr)
+      const texId = module._c2dCreateTextureFromRGBA(ptr, surf.width, surf.height)
+      module._free(ptr)
+      return texId
+    },
+    updateTextureFromCanvas: (texId: number, surfaceId: number): void => {
+      const surf = canvasHost?.readSurface(surfaceId)
+      if (!surf) return
+      const bytes = new Uint8Array(surf.data.buffer, surf.data.byteOffset, surf.data.byteLength)
+      const ptr = module._malloc(bytes.length)
+      module.HEAPU8.set(bytes, ptr)
+      module._c2dUpdateTextureFromRGBA(texId, ptr, surf.width, surf.height)
+      module._free(ptr)
+    },
+
+    // --- animation (frames = flat [u0,v0,u1,v1]*frameCount) ---
+    defineAnimation: (entityId: number, frames: Float32Array, fps: number, loop: boolean): number =>
+      withFloats(frames, ptr => module._c2dDefineAnimation(entityId, ptr, frames.length / 4, fps, loop)),
+    playAnimation: (entityId: number, clipId: number) => module._c2dPlayAnimation(entityId, clipId),
+    stopAnimation: (entityId: number) => module._c2dStopAnimation(entityId),
+    setAnimationSpeed: (entityId: number, speed: number) => module._c2dSetAnimationSpeed(entityId, speed),
+    getAnimationFrame: (entityId: number): number => module._c2dGetAnimationFrame(entityId),
+
+    // --- tilemap ---
+    createTilemap: (textureId: number, cols: number, rows: number, tileW: number, tileH: number,
+                    atlasCols: number, atlasRows: number, data: Int32Array): number => {
+      const ptr = module._malloc(data.length * 4)
+      module.HEAPU32.set(new Uint32Array(data.buffer, data.byteOffset, data.length), ptr / 4)
+      const id = module._c2dCreateTilemap(textureId, cols, rows, tileW, tileH, atlasCols, atlasRows, ptr)
+      module._free(ptr)
+      return id
+    },
+    setTile: (tilemapId: number, x: number, y: number, index: number) => module._c2dSetTile(tilemapId, x, y, index),
+
+    // --- bulk hot-path ---
+    bulkSetPositions: (ids: Uint32Array, xy: Float32Array, count: number) => {
+      const idPtr = module._malloc(ids.length * 4)
+      const xyPtr = module._malloc(xy.length * 4)
+      module.HEAPU32.set(ids, idPtr / 4)
+      module.HEAPF32.set(xy, xyPtr / 4)
+      module._c2dBulkSetPositions(idPtr, xyPtr, count)
+      module._free(idPtr)
+      module._free(xyPtr)
+    },
+
+    // --- physics (Box2D v3; present only in CREATOR_2D_PHYSICS builds) ---
+    physicsHasSupport: (): boolean => !!module._c2dPhysicsHasSupport && !!module._c2dPhysicsHasSupport(),
+    physicsConfigure: (gx: number, gy: number, ppm: number, subSteps: number) => module._c2dPhysicsConfigure(gx, gy, ppm, subSteps),
+    setInterpolation: (enabled: boolean) => module._c2dSetInterpolation?.(enabled),
+    setOnPhysicsEvent: (cb: (a: number, b: number, type: number, px: number, py: number, nx: number, ny: number, speed: number) => void) => { module.onPhysicsEvent = cb },
+    physicsCreateBody: (entityId: number, motionType: number): number => module._c2dPhysicsCreateBody(entityId, motionType),
+    physicsRemoveBody: (h: number) => module._c2dPhysicsRemoveBody(h),
+    physicsAddBox: (h: number, hw: number, hh: number, ox: number, oy: number, friction: number, bounce: number, isSensor: boolean, category: number, mask: number) =>
+      module._c2dPhysicsAddBox(h, hw, hh, ox, oy, friction, bounce, isSensor, category, mask),
+    physicsAddCircle: (h: number, radius: number, ox: number, oy: number, friction: number, bounce: number, isSensor: boolean, category: number, mask: number) =>
+      module._c2dPhysicsAddCircle(h, radius, ox, oy, friction, bounce, isSensor, category, mask),
+    physicsAddCapsule: (h: number, x1: number, y1: number, x2: number, y2: number, radius: number, friction: number, bounce: number, isSensor: boolean, category: number, mask: number) =>
+      module._c2dPhysicsAddCapsule(h, x1, y1, x2, y2, radius, friction, bounce, isSensor, category, mask),
+    physicsAddSegment: (h: number, x1: number, y1: number, x2: number, y2: number, friction: number, bounce: number, category: number, mask: number) =>
+      module._c2dPhysicsAddSegment(h, x1, y1, x2, y2, friction, bounce, category, mask),
+    physicsAddPolygon: (h: number, pts: Float32Array, count: number, friction: number, bounce: number, isSensor: boolean, category: number, mask: number) =>
+      withFloats(pts, (ptr) => module._c2dPhysicsAddPolygon(h, ptr, count, friction, bounce, isSensor, category, mask)),
+    physicsAddChain: (h: number, pts: Float32Array, count: number, isLoop: boolean, friction: number, bounce: number, category: number, mask: number) =>
+      withFloats(pts, (ptr) => module._c2dPhysicsAddChain(h, ptr, count, isLoop, friction, bounce, category, mask)),
+    physicsClearShapes: (h: number) => module._c2dPhysicsClearShapes(h),
+    physicsSetContactEvents: (h: number, enabled: boolean) => module._c2dPhysicsSetContactEvents(h, enabled),
+    physicsSetLinearVelocity: (h: number, x: number, y: number) => module._c2dPhysicsSetLinearVelocity(h, x, y),
+    physicsGetLinearVelocity: (h: number): Float32Array => readFloats(2, (ptr) => module._c2dPhysicsGetLinearVelocity(h, ptr)),
+    physicsSetAngularVelocity: (h: number, degPerSec: number) => module._c2dPhysicsSetAngularVelocity(h, degPerSec),
+    physicsGetAngularVelocity: (h: number): number => module._c2dPhysicsGetAngularVelocity(h),
+    physicsApplyLinearImpulse: (h: number, x: number, y: number) => module._c2dPhysicsApplyLinearImpulse(h, x, y),
+    physicsApplyImpulseAt: (h: number, x: number, y: number, px: number, py: number) => module._c2dPhysicsApplyImpulseAt(h, x, y, px, py),
+    physicsApplyForce: (h: number, x: number, y: number) => module._c2dPhysicsApplyForce(h, x, y),
+    physicsSetFromEntity: (h: number) => module._c2dPhysicsSetFromEntity(h),
+    physicsSetFixedRotation: (h: number, enabled: boolean) => module._c2dPhysicsSetFixedRotation(h, enabled),
+    physicsSetGravityScale: (h: number, scale: number) => module._c2dPhysicsSetGravityScale(h, scale),
+    physicsSetLinearDamping: (h: number, damping: number) => module._c2dPhysicsSetLinearDamping(h, damping),
+    physicsSetAngularDamping: (h: number, damping: number) => module._c2dPhysicsSetAngularDamping(h, damping),
+    physicsSetBullet: (h: number, enabled: boolean) => module._c2dPhysicsSetBullet(h, enabled),
+    physicsSetEnabled: (h: number, enabled: boolean) => module._c2dPhysicsSetEnabled(h, enabled),
+    physicsSetAwake: (h: number, awake: boolean) => module._c2dPhysicsSetAwake(h, awake),
+    physicsSetMass: (h: number, mass: number) => module._c2dPhysicsSetMass(h, mass),
+    physicsGetMass: (h: number): number => module._c2dPhysicsGetMass(h),
+    physicsSetMotionType: (h: number, motionType: number) => module._c2dPhysicsSetMotionType(h, motionType),
+    physicsSetFriction: (h: number, friction: number) => module._c2dPhysicsSetFriction(h, friction),
+    physicsSetBounce: (h: number, bounce: number) => module._c2dPhysicsSetBounce(h, bounce),
+    physicsSetFilter: (h: number, category: number, mask: number) => module._c2dPhysicsSetFilter(h, category, mask),
+    physicsRaycastClosest: (x0: number, y0: number, x1: number, y1: number, mask: number, ignore: Float32Array, ignoreCount: number): Float32Array =>
+      withFloats(ignore, (ig) => readFloats(7, (out) => module._c2dPhysicsRaycastClosest(x0, y0, x1, y1, mask, ig, ignoreCount, out))),
+    physicsRaycastAll: (x0: number, y0: number, x1: number, y1: number, mask: number, ignore: Float32Array, ignoreCount: number, maxHits: number): Float32Array =>
+      withFloats(ignore, (ig) => {
+        let n = 0
+        const r = readFloats(maxHits * 6, (out) => { n = module._c2dPhysicsRaycastAll(x0, y0, x1, y1, mask, ig, ignoreCount, out, maxHits) })
+        return r.subarray(0, n * 6)   // trim: the scratch is shared and only the first n*6 are ours
+      }),
+    physicsOverlap: (pts: Float32Array, count: number, radius: number, mask: number, ignore: Float32Array, ignoreCount: number, maxHits: number): Float32Array =>
+      withFloats(pts, (p) => withFloats(ignore, (ig) => {
+        let n = 0
+        const r = readFloats(maxHits, (out) => { n = module._c2dPhysicsOverlap(p, count, radius, mask, ig, ignoreCount, out, maxHits) })
+        return r.subarray(0, n)
+      })),
+    characterCreate: (entityId: number, x1: number, y1: number, x2: number, y2: number, radius: number, maxSlopeDeg: number, category: number, mask: number): number =>
+      module._c2dCharacterCreate(entityId, x1, y1, x2, y2, radius, maxSlopeDeg, category, mask),
+    characterDestroy: (id: number) => module._c2dCharacterDestroy(id),
+    characterMove: (id: number, x: number) => module._c2dCharacterMove(id, x),
+    characterMoveFree: (id: number, x: number, y: number) => module._c2dCharacterMoveFree(id, x, y),
+    characterSetVerticalVelocity: (id: number, vy: number) => module._c2dCharacterSetVerticalVelocity(id, vy),
+    characterSetVelocity: (id: number, x: number, y: number) => module._c2dCharacterSetVelocity(id, x, y),
+    characterSetGravityScale: (id: number, s: number) => module._c2dCharacterSetGravityScale(id, s),
+    characterSetMaxSlope: (id: number, deg: number) => module._c2dCharacterSetMaxSlope(id, deg),
+    characterSetFilter: (id: number, category: number, mask: number) => module._c2dCharacterSetFilter(id, category, mask),
+    characterSetDropThrough: (id: number, entityId: number) => module._c2dCharacterSetDropThrough(id, entityId),
+    characterSetCapsule: (id: number, x1: number, y1: number, x2: number, y2: number, radius: number): boolean =>
+      !!module._c2dCharacterSetCapsule(id, x1, y1, x2, y2, radius),
+    characterSetFromEntity: (id: number) => module._c2dCharacterSetFromEntity(id),
+    characterGetState: (id: number, out: Float32Array) => { out.set(readFloats(8, (ptr) => module._c2dCharacterGetState(id, ptr)).subarray(0, 8)) },
+    characterGetCollisions: (id: number, maxN: number): Float32Array => {
+      let n = 0
+      const r = readFloats(maxN * 3, (out) => { n = module._c2dCharacterGetCollisions(id, out, maxN) })
+      return r.subarray(0, n * 3)
+    },
+    physicsSetOneWay: (h: number, nx: number, ny: number, arcDeg: number, enabled: boolean) =>
+      module._c2dPhysicsSetOneWay(h, nx, ny, arcDeg, enabled),
+    physicsOverlapPoint: (x: number, y: number, mask: number, ignore: Float32Array, ignoreCount: number): number =>
+      withFloats(ignore, (ig) => module._c2dPhysicsOverlapPoint(x, y, mask, ig, ignoreCount)),
+    pickSprite: (sceneId: number, wx: number, wy: number): number => module._c2dPickSprite(sceneId, wx, wy),
+
+    // --- host plumbing ---
+    _onResize(width: number, height: number, resFactor = 1) {
+      factor = resFactor
+      // Backing store in device px, CSS box pinned to logical px (host-shared crispness pattern).
+      canvas.width = Math.max(1, Math.round(width * resFactor))
+      canvas.height = Math.max(1, Math.round(height * resFactor))
+      canvas.style.width = width + "px"
+      canvas.style.height = height + "px"
+      module._c2dSetViewport(canvas.width, canvas.height)
+      // Re-apply every scene's camera zoom against the new factor so the world keeps its on-screen size.
+      for (const [sid, z] of userZoom) module._c2dCameraSetZoom(sid, z * factor)
+    },
+    _dispose() {
+      stop()
+      setPointerListeners(false)
+      pointerCb = null
+      module._c2dCloseScene()
+      try { module._c2dShutdown() } catch {}
+      gl.getExtension('WEBGL_lose_context')?.loseContext()
+      if ((window as any).creator2d_glContext === gl) {
+        ;(window as any).creator2d_glContext = null
+        ;(window as any).creator2d_glOptions = null
+      }
+    },
+  }
+}
+
+export type Creator2dViewer = Awaited<ReturnType<typeof createViewer2d>>

package/src/viewer2d/creator2d.js

@@ -0,0 +1,14 @@
+var creator2d = (() => {
+  
+  return (
+async function(moduleArg = {}) {
+  var moduleRtn;
+
+var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var ENVIRONMENT_IS_WEB=true;var ENVIRONMENT_IS_WORKER=false;var arguments_=[];var thisProgram="./this.program";var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var wasmMemory;var ABORT=false;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAP64,HEAPU64,HEAPF64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["cb"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("creator2d.wasm")}return new URL("creator2d.wasm",import.meta.url).href}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["bb"];updateMemoryViews();removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod,inst))})})}wasmBinaryFile??=findWasmBinary();try{var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}catch(e){readyPromiseReject(e);return Promise.reject(e)}}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}}var exceptionLast=0;var uncaughtExceptionCount=0;var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=ptr;uncaughtExceptionCount++;throw exceptionLast};var __abort_js=()=>abort("");function _c2dAnimEvent(entityId,clipId,type){if(Module.onAnimEvent)Module.onAnimEvent(entityId,clipId,type)}function _c2dEarlyUpdate(dt){if(Module.onEarlyUpdate)Module.onEarlyUpdate(dt)}function _c2dLateUpdate(dt){if(Module.onLateUpdate)Module.onLateUpdate(dt)}function _c2dPhysicsEvent(entityA,entityB,type){if(Module.onPhysicsEvent)Module.onPhysicsEvent(entityA,entityB,type)}var _emscripten_get_now=()=>performance.now();var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);HEAP64[ptime>>3]=BigInt(nsec);return 0}var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{readEmAsmArgsArray.length=0;var ch;while(ch=HEAPU8[sigPtr++]){var wide=ch!=105;wide&=ch!=112;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?HEAPU32[buf>>2]:ch==106?HEAP64[buf>>3]:ch==105?HEAP32[buf>>2]:HEAPF64[buf>>3]);buf+=wide?8:4}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);return ASM_CONSTS[code](...args)};var _emscripten_asm_const_int=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var GLctx;var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance=ctx=>!!(ctx.dibvbi=ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance=ctx=>!!(ctx.mdibvbi=ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));var webgl_enable_EXT_polygon_offset_clamp=ctx=>!!(ctx.extPolygonOffsetClamp=ctx.getExtension("EXT_polygon_offset_clamp"));var webgl_enable_EXT_clip_control=ctx=>!!(ctx.extClipControl=ctx.getExtension("EXT_clip_control"));var webgl_enable_WEBGL_polygon_mode=ctx=>!!(ctx.webglPolygonMode=ctx.getExtension("WEBGL_polygon_mode"));var webgl_enable_WEBGL_multi_draw=ctx=>!!(ctx.multiDrawWebgl=ctx.getExtension("WEBGL_multi_draw"));var getEmscriptenSupportedExtensions=ctx=>{var supportedExtensions=["EXT_color_buffer_float","EXT_conservative_depth","EXT_disjoint_timer_query_webgl2","EXT_texture_norm16","NV_shader_noperspective_interpolation","WEBGL_clip_cull_distance","EXT_clip_control","EXT_color_buffer_half_float","EXT_depth_clamp","EXT_float_blend","EXT_polygon_offset_clamp","EXT_texture_compression_bptc","EXT_texture_compression_rgtc","EXT_texture_filter_anisotropic","KHR_parallel_shader_compile","OES_texture_float_linear","WEBGL_blend_func_extended","WEBGL_compressed_texture_astc","WEBGL_compressed_texture_etc","WEBGL_compressed_texture_etc1","WEBGL_compressed_texture_s3tc","WEBGL_compressed_texture_s3tc_srgb","WEBGL_debug_renderer_info","WEBGL_debug_shaders","WEBGL_lose_context","WEBGL_multi_draw","WEBGL_polygon_mode"];return(ctx.getSupportedExtensions()||[]).filter(ext=>supportedExtensions.includes(ext))};var registerPreMainLoop=f=>{typeof MainLoop!="undefined"&&MainLoop.preMainLoop.push(f)};var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead=NaN)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var GL={counter:1,buffers:[],mappedBuffers:{},programs:[],framebuffers:[],renderbuffers:[],textures:[],shaders:[],vaos:[],contexts:[],offscreenCanvases:{},queries:[],samplers:[],transformFeedbacks:[],syncs:[],byteSizeByTypeRoot:5120,byteSizeByType:[1,1,2,2,4,4,4,2,3,4,8],stringCache:{},stringiCache:{},unpackAlignment:4,unpackRowLength:0,recordError:errorCode=>{if(!GL.lastError){GL.lastError=errorCode}},getNewId:table=>{var ret=GL.counter++;for(var i=table.length;i<ret;i++){table[i]=null}while(table[ret]){ret=GL.counter++}return ret},genObject:(n,buffers,createFunction,objectTable)=>{for(var i=0;i<n;i++){var buffer=GLctx[createFunction]();var id=buffer&&GL.getNewId(objectTable);if(buffer){buffer.name=id;objectTable[id]=buffer}else{GL.recordError(1282)}HEAP32[buffers+i*4>>2]=id}},MAX_TEMP_BUFFER_SIZE:2097152,numTempVertexBuffersPerSize:64,log2ceilLookup:i=>32-Math.clz32(i===0?0:i-1),generateTempBuffers:(quads,context)=>{var largestIndex=GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);context.tempVertexBufferCounters1=[];context.tempVertexBufferCounters2=[];context.tempVertexBufferCounters1.length=context.tempVertexBufferCounters2.length=largestIndex+1;context.tempVertexBuffers1=[];context.tempVertexBuffers2=[];context.tempVertexBuffers1.length=context.tempVertexBuffers2.length=largestIndex+1;context.tempIndexBuffers=[];context.tempIndexBuffers.length=largestIndex+1;for(var i=0;i<=largestIndex;++i){context.tempIndexBuffers[i]=null;context.tempVertexBufferCounters1[i]=context.tempVertexBufferCounters2[i]=0;var ringbufferLength=GL.numTempVertexBuffersPerSize;context.tempVertexBuffers1[i]=[];context.tempVertexBuffers2[i]=[];var ringbuffer1=context.tempVertexBuffers1[i];var ringbuffer2=context.tempVertexBuffers2[i];ringbuffer1.length=ringbuffer2.length=ringbufferLength;for(var j=0;j<ringbufferLength;++j){ringbuffer1[j]=ringbuffer2[j]=null}}if(quads){context.tempQuadIndexBuffer=GLctx.createBuffer();context.GLctx.bindBuffer(34963,context.tempQuadIndexBuffer);var numIndexes=GL.MAX_TEMP_BUFFER_SIZE>>1;var quadIndexes=new Uint16Array(numIndexes);var i=0,v=0;while(1){quadIndexes[i++]=v;if(i>=numIndexes)break;quadIndexes[i++]=v+1;if(i>=numIndexes)break;quadIndexes[i++]=v+2;if(i>=numIndexes)break;quadIndexes[i++]=v;if(i>=numIndexes)break;quadIndexes[i++]=v+2;if(i>=numIndexes)break;quadIndexes[i++]=v+3;if(i>=numIndexes)break;v+=4}context.GLctx.bufferData(34963,quadIndexes,35044);context.GLctx.bindBuffer(34963,null)}},getTempVertexBuffer:sizeBytes=>{var idx=GL.log2ceilLookup(sizeBytes);var ringbuffer=GL.currentContext.tempVertexBuffers1[idx];var nextFreeBufferIndex=GL.currentContext.tempVertexBufferCounters1[idx];GL.currentContext.tempVertexBufferCounters1[idx]=GL.currentContext.tempVertexBufferCounters1[idx]+1&GL.numTempVertexBuffersPerSize-1;var vbo=ringbuffer[nextFreeBufferIndex];if(vbo){return vbo}var prevVBO=GLctx.getParameter(34964);ringbuffer[nextFreeBufferIndex]=GLctx.createBuffer();GLctx.bindBuffer(34962,ringbuffer[nextFreeBufferIndex]);GLctx.bufferData(34962,1<<idx,35048);GLctx.bindBuffer(34962,prevVBO);return ringbuffer[nextFreeBufferIndex]},getTempIndexBuffer:sizeBytes=>{var idx=GL.log2ceilLookup(sizeBytes);var ibo=GL.currentContext.tempIndexBuffers[idx];if(ibo){return ibo}var prevIBO=GLctx.getParameter(34965);GL.currentContext.tempIndexBuffers[idx]=GLctx.createBuffer();GLctx.bindBuffer(34963,GL.currentContext.tempIndexBuffers[idx]);GLctx.bufferData(34963,1<<idx,35048);GLctx.bindBuffer(34963,prevIBO);return GL.currentContext.tempIndexBuffers[idx]},newRenderingFrameStarted:()=>{if(!GL.currentContext){return}var vb=GL.currentContext.tempVertexBuffers1;GL.currentContext.tempVertexBuffers1=GL.currentContext.tempVertexBuffers2;GL.currentContext.tempVertexBuffers2=vb;vb=GL.currentContext.tempVertexBufferCounters1;GL.currentContext.tempVertexBufferCounters1=GL.currentContext.tempVertexBufferCounters2;GL.currentContext.tempVertexBufferCounters2=vb;var largestIndex=GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);for(var i=0;i<=largestIndex;++i){GL.currentContext.tempVertexBufferCounters1[i]=0}},getSource:(shader,count,string,length)=>{var source="";for(var i=0;i<count;++i){var len=length?HEAPU32[length+i*4>>2]:undefined;source+=UTF8ToString(HEAPU32[string+i*4>>2],len)}return source},calcBufLength:(size,type,stride,count)=>{if(stride>0){return count*stride}var typeSize=GL.byteSizeByType[type-GL.byteSizeByTypeRoot];return size*typeSize*count},usedTempBuffers:[],preDrawHandleClientVertexAttribBindings:count=>{GL.resetBufferBinding=false;for(var i=0;i<GL.currentContext.maxVertexAttribs;++i){var cb=GL.currentContext.clientBuffers[i];if(!cb.clientside||!cb.enabled)continue;GL.resetBufferBinding=true;var size=GL.calcBufLength(cb.size,cb.type,cb.stride,count);var buf=GL.getTempVertexBuffer(size);GLctx.bindBuffer(34962,buf);GLctx.bufferSubData(34962,0,HEAPU8.subarray(cb.ptr,cb.ptr+size));cb.vertexAttribPointerAdaptor.call(GLctx,i,cb.size,cb.type,cb.normalized,cb.stride,0)}},postDrawHandleClientVertexAttribBindings:()=>{if(GL.resetBufferBinding){GLctx.bindBuffer(34962,GL.buffers[GLctx.currentArrayBufferBinding])}},createContext:(canvas,webGLContextAttributes)=>{if(!canvas.getContextSafariWebGL2Fixed){canvas.getContextSafariWebGL2Fixed=canvas.getContext;function fixedGetContext(ver,attrs){var gl=canvas.getContextSafariWebGL2Fixed(ver,attrs);return ver=="webgl"==gl instanceof WebGLRenderingContext?gl:null}canvas.getContext=fixedGetContext}var ctx=canvas.getContext("webgl2",webGLContextAttributes);if(!ctx)return 0;var handle=GL.registerContext(ctx,webGLContextAttributes);return handle},registerContext:(ctx,webGLContextAttributes)=>{var handle=GL.getNewId(GL.contexts);var context={handle,attributes:webGLContextAttributes,version:webGLContextAttributes.majorVersion,GLctx:ctx};if(ctx.canvas)ctx.canvas.GLctxObject=context;GL.contexts[handle]=context;if(typeof webGLContextAttributes.enableExtensionsByDefault=="undefined"||webGLContextAttributes.enableExtensionsByDefault){GL.initExtensions(context)}context.maxVertexAttribs=context.GLctx.getParameter(34921);context.clientBuffers=[];for(var i=0;i<context.maxVertexAttribs;i++){context.clientBuffers[i]={enabled:false,clientside:false,size:0,type:0,normalized:0,stride:0,ptr:0,vertexAttribPointerAdaptor:null}}GL.generateTempBuffers(false,context);return handle},makeContextCurrent:contextHandle=>{GL.currentContext=GL.contexts[contextHandle];Module["ctx"]=GLctx=GL.currentContext?.GLctx;return!(contextHandle&&!GLctx)},getContext:contextHandle=>GL.contexts[contextHandle],deleteContext:contextHandle=>{if(GL.currentContext===GL.contexts[contextHandle]){GL.currentContext=null}if(typeof JSEvents=="object"){JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas)}if(GL.contexts[contextHandle]?.GLctx.canvas){GL.contexts[contextHandle].GLctx.canvas.GLctxObject=undefined}GL.contexts[contextHandle]=null},initExtensions:context=>{context||=GL.currentContext;if(context.initExtensionsDone)return;context.initExtensionsDone=true;var GLctx=context.GLctx;webgl_enable_WEBGL_multi_draw(GLctx);webgl_enable_EXT_polygon_offset_clamp(GLctx);webgl_enable_EXT_clip_control(GLctx);webgl_enable_WEBGL_polygon_mode(GLctx);webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);if(context.version>=2){GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query_webgl2")}if(context.version<2||!GLctx.disjointTimerQueryExt){GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query")}getEmscriptenSupportedExtensions(GLctx).forEach(ext=>{if(!ext.includes("lose_context")&&!ext.includes("debug")){GLctx.getExtension(ext)}})}};var _glActiveTexture=x0=>GLctx.activeTexture(x0);var _glAttachShader=(program,shader)=>{GLctx.attachShader(GL.programs[program],GL.shaders[shader])};var _glBindBuffer=(target,buffer)=>{if(buffer&&!GL.buffers[buffer]){var b=GLctx.createBuffer();b.name=buffer;GL.buffers[buffer]=b}if(target==34962){GLctx.currentArrayBufferBinding=buffer}else if(target==34963){GLctx.currentElementArrayBufferBinding=buffer}if(target==35051){GLctx.currentPixelPackBufferBinding=buffer}else if(target==35052){GLctx.currentPixelUnpackBufferBinding=buffer}GLctx.bindBuffer(target,GL.buffers[buffer])};var _glBindBufferBase=(target,index,buffer)=>{GLctx.bindBufferBase(target,index,GL.buffers[buffer])};var _glBindBufferRange=(target,index,buffer,offset,ptrsize)=>{GLctx.bindBufferRange(target,index,GL.buffers[buffer],offset,ptrsize)};var _glBindFramebuffer=(target,framebuffer)=>{GLctx.bindFramebuffer(target,GL.framebuffers[framebuffer])};var _glBindRenderbuffer=(target,renderbuffer)=>{GLctx.bindRenderbuffer(target,GL.renderbuffers[renderbuffer])};var _glBindSampler=(unit,sampler)=>{GLctx.bindSampler(unit,GL.samplers[sampler])};var _glBindTexture=(target,texture)=>{GLctx.bindTexture(target,GL.textures[texture])};var _glBindVertexArray=vao=>{GLctx.bindVertexArray(GL.vaos[vao]);var ibo=GLctx.getParameter(34965);GLctx.currentElementArrayBufferBinding=ibo?ibo.name|0:0};var _glBlendColor=(x0,x1,x2,x3)=>GLctx.blendColor(x0,x1,x2,x3);var _glBlendEquationSeparate=(x0,x1)=>GLctx.blendEquationSeparate(x0,x1);var _glBlendFuncSeparate=(x0,x1,x2,x3)=>GLctx.blendFuncSeparate(x0,x1,x2,x3);var _glBlitFramebuffer=(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)=>GLctx.blitFramebuffer(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9);var _glBufferData=(target,size,data,usage)=>{if(true){if(data&&size){GLctx.bufferData(target,HEAPU8,usage,data,size)}else{GLctx.bufferData(target,size,usage)}return}};var _glBufferSubData=(target,offset,size,data)=>{if(true){size&&GLctx.bufferSubData(target,offset,HEAPU8,data,size);return}};var _glCheckFramebufferStatus=x0=>GLctx.checkFramebufferStatus(x0);var _glClearBufferfi=(x0,x1,x2,x3)=>GLctx.clearBufferfi(x0,x1,x2,x3);var _glClearBufferfv=(buffer,drawbuffer,value)=>{GLctx.clearBufferfv(buffer,drawbuffer,HEAPF32,value>>2)};var _glClearBufferiv=(buffer,drawbuffer,value)=>{GLctx.clearBufferiv(buffer,drawbuffer,HEAP32,value>>2)};var _glColorMask=(red,green,blue,alpha)=>{GLctx.colorMask(!!red,!!green,!!blue,!!alpha)};var _glCompileShader=shader=>{GLctx.compileShader(GL.shaders[shader])};var _glCompressedTexSubImage2D=(target,level,xoffset,yoffset,width,height,format,imageSize,data)=>{if(true){if(GLctx.currentPixelUnpackBufferBinding||!imageSize){GLctx.compressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data);return}GLctx.compressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,HEAPU8,data,imageSize);return}};var _glCompressedTexSubImage3D=(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data)}else{GLctx.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,HEAPU8,data,imageSize)}};var _glCreateProgram=()=>{var id=GL.getNewId(GL.programs);var program=GLctx.createProgram();program.name=id;program.maxUniformLength=program.maxAttributeLength=program.maxUniformBlockNameLength=0;program.uniformIdCounter=1;GL.programs[id]=program;return id};var _glCreateShader=shaderType=>{var id=GL.getNewId(GL.shaders);GL.shaders[id]=GLctx.createShader(shaderType);return id};var _glCullFace=x0=>GLctx.cullFace(x0);var _glDeleteBuffers=(n,buffers)=>{for(var i=0;i<n;i++){var id=HEAP32[buffers+i*4>>2];var buffer=GL.buffers[id];if(!buffer)continue;GLctx.deleteBuffer(buffer);buffer.name=0;GL.buffers[id]=null;if(id==GLctx.currentArrayBufferBinding)GLctx.currentArrayBufferBinding=0;if(id==GLctx.currentElementArrayBufferBinding)GLctx.currentElementArrayBufferBinding=0;if(id==GLctx.currentPixelPackBufferBinding)GLctx.currentPixelPackBufferBinding=0;if(id==GLctx.currentPixelUnpackBufferBinding)GLctx.currentPixelUnpackBufferBinding=0}};var _glDeleteFramebuffers=(n,framebuffers)=>{for(var i=0;i<n;++i){var id=HEAP32[framebuffers+i*4>>2];var framebuffer=GL.framebuffers[id];if(!framebuffer)continue;GLctx.deleteFramebuffer(framebuffer);framebuffer.name=0;GL.framebuffers[id]=null}};var _glDeleteProgram=id=>{if(!id)return;var program=GL.programs[id];if(!program){GL.recordError(1281);return}GLctx.deleteProgram(program);program.name=0;GL.programs[id]=null};var _glDeleteRenderbuffers=(n,renderbuffers)=>{for(var i=0;i<n;i++){var id=HEAP32[renderbuffers+i*4>>2];var renderbuffer=GL.renderbuffers[id];if(!renderbuffer)continue;GLctx.deleteRenderbuffer(renderbuffer);renderbuffer.name=0;GL.renderbuffers[id]=null}};var _glDeleteSamplers=(n,samplers)=>{for(var i=0;i<n;i++){var id=HEAP32[samplers+i*4>>2];var sampler=GL.samplers[id];if(!sampler)continue;GLctx.deleteSampler(sampler);sampler.name=0;GL.samplers[id]=null}};var _glDeleteShader=id=>{if(!id)return;var shader=GL.shaders[id];if(!shader){GL.recordError(1281);return}GLctx.deleteShader(shader);GL.shaders[id]=null};var _glDeleteTextures=(n,textures)=>{for(var i=0;i<n;i++){var id=HEAP32[textures+i*4>>2];var texture=GL.textures[id];if(!texture)continue;GLctx.deleteTexture(texture);texture.name=0;GL.textures[id]=null}};var _glDeleteVertexArrays=(n,vaos)=>{for(var i=0;i<n;i++){var id=HEAP32[vaos+i*4>>2];GLctx.deleteVertexArray(GL.vaos[id]);GL.vaos[id]=null}};var _glDepthFunc=x0=>GLctx.depthFunc(x0);var _glDepthMask=flag=>{GLctx.depthMask(!!flag)};var _glDisable=x0=>GLctx.disable(x0);var _glDisableVertexAttribArray=index=>{var cb=GL.currentContext.clientBuffers[index];cb.enabled=false;GLctx.disableVertexAttribArray(index)};var _glDrawArrays=(mode,first,count)=>{GL.preDrawHandleClientVertexAttribBindings(first+count);GLctx.drawArrays(mode,first,count);GL.postDrawHandleClientVertexAttribBindings()};var _glDrawArraysInstanced=(mode,first,count,primcount)=>{GLctx.drawArraysInstanced(mode,first,count,primcount)};var tempFixedLengthArray=[];var _glDrawBuffers=(n,bufs)=>{var bufArray=tempFixedLengthArray[n];for(var i=0;i<n;i++){bufArray[i]=HEAP32[bufs+i*4>>2]}GLctx.drawBuffers(bufArray)};var _glDrawElements=(mode,count,type,indices)=>{var buf;var vertexes=0;if(!GLctx.currentElementArrayBufferBinding){var size=GL.calcBufLength(1,type,0,count);buf=GL.getTempIndexBuffer(size);GLctx.bindBuffer(34963,buf);GLctx.bufferSubData(34963,0,HEAPU8.subarray(indices,indices+size));if(count>0){for(var i=0;i<GL.currentContext.maxVertexAttribs;++i){var cb=GL.currentContext.clientBuffers[i];if(cb.clientside&&cb.enabled){let arrayClass;switch(type){case 5121:arrayClass=Uint8Array;break;case 5123:arrayClass=Uint16Array;break;case 5125:arrayClass=Uint32Array;break;default:GL.recordError(1282);return}vertexes=new arrayClass(HEAPU8.buffer,indices,count).reduce((max,current)=>Math.max(max,current))+1;break}}}indices=0}GL.preDrawHandleClientVertexAttribBindings(vertexes);GLctx.drawElements(mode,count,type,indices);GL.postDrawHandleClientVertexAttribBindings(count);if(!GLctx.currentElementArrayBufferBinding){GLctx.bindBuffer(34963,null)}};var _glDrawElementsInstanced=(mode,count,type,indices,primcount)=>{GLctx.drawElementsInstanced(mode,count,type,indices,primcount)};var _glEnable=x0=>GLctx.enable(x0);var _glEnableVertexAttribArray=index=>{var cb=GL.currentContext.clientBuffers[index];cb.enabled=true;GLctx.enableVertexAttribArray(index)};var _glFramebufferRenderbuffer=(target,attachment,renderbuffertarget,renderbuffer)=>{GLctx.framebufferRenderbuffer(target,attachment,renderbuffertarget,GL.renderbuffers[renderbuffer])};var _glFramebufferTexture2D=(target,attachment,textarget,texture,level)=>{GLctx.framebufferTexture2D(target,attachment,textarget,GL.textures[texture],level)};var _glFramebufferTextureLayer=(target,attachment,texture,level,layer)=>{GLctx.framebufferTextureLayer(target,attachment,GL.textures[texture],level,layer)};var _glFrontFace=x0=>GLctx.frontFace(x0);var _glGenBuffers=(n,buffers)=>{GL.genObject(n,buffers,"createBuffer",GL.buffers)};var _glGenFramebuffers=(n,ids)=>{GL.genObject(n,ids,"createFramebuffer",GL.framebuffers)};var _glGenRenderbuffers=(n,renderbuffers)=>{GL.genObject(n,renderbuffers,"createRenderbuffer",GL.renderbuffers)};var _glGenSamplers=(n,samplers)=>{GL.genObject(n,samplers,"createSampler",GL.samplers)};var _glGenTextures=(n,textures)=>{GL.genObject(n,textures,"createTexture",GL.textures)};var _glGenVertexArrays=(n,arrays)=>{GL.genObject(n,arrays,"createVertexArray",GL.vaos)};var _glGetAttribLocation=(program,name)=>GLctx.getAttribLocation(GL.programs[program],UTF8ToString(name));var writeI53ToI64=(ptr,num)=>{HEAPU32[ptr>>2]=num;var lower=HEAPU32[ptr>>2];HEAPU32[ptr+4>>2]=(num-lower)/4294967296};var webglGetExtensions=()=>{var exts=getEmscriptenSupportedExtensions(GLctx);exts=exts.concat(exts.map(e=>"GL_"+e));return exts};var emscriptenWebGLGet=(name_,p,type)=>{if(!p){GL.recordError(1281);return}var ret=undefined;switch(name_){case 36346:ret=1;break;case 36344:if(type!=0&&type!=1){GL.recordError(1280)}return;case 34814:case 36345:ret=0;break;case 34466:var formats=GLctx.getParameter(34467);ret=formats?formats.length:0;break;case 33309:if(GL.currentContext.version<2){GL.recordError(1282);return}ret=webglGetExtensions().length;break;case 33307:case 33308:if(GL.currentContext.version<2){GL.recordError(1280);return}ret=name_==33307?3:0;break}if(ret===undefined){var result=GLctx.getParameter(name_);switch(typeof result){case"number":ret=result;break;case"boolean":ret=result?1:0;break;case"string":GL.recordError(1280);return;case"object":if(result===null){switch(name_){case 34964:case 35725:case 34965:case 36006:case 36007:case 32873:case 34229:case 36662:case 36663:case 35053:case 35055:case 36010:case 35097:case 35869:case 32874:case 36389:case 35983:case 35368:case 34068:{ret=0;break}default:{GL.recordError(1280);return}}}else if(result instanceof Float32Array||result instanceof Uint32Array||result instanceof Int32Array||result instanceof Array){for(var i=0;i<result.length;++i){switch(type){case 0:HEAP32[p+i*4>>2]=result[i];break;case 2:HEAPF32[p+i*4>>2]=result[i];break;case 4:HEAP8[p+i]=result[i]?1:0;break}}return}else{try{ret=result.name|0}catch(e){GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);return}}break;default:GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof result}!`);return}}switch(type){case 1:writeI53ToI64(p,ret);break;case 0:HEAP32[p>>2]=ret;break;case 2:HEAPF32[p>>2]=ret;break;case 4:HEAP8[p]=ret?1:0;break}};var _glGetIntegerv=(name_,p)=>emscriptenWebGLGet(name_,p,0);var _glGetProgramInfoLog=(program,maxLength,length,infoLog)=>{var log=GLctx.getProgramInfoLog(GL.programs[program]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _glGetProgramiv=(program,pname,p)=>{if(!p){GL.recordError(1281);return}if(program>=GL.counter){GL.recordError(1281);return}program=GL.programs[program];if(pname==35716){var log=GLctx.getProgramInfoLog(program);if(log===null)log="(unknown error)";HEAP32[p>>2]=log.length+1}else if(pname==35719){if(!program.maxUniformLength){var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(var i=0;i<numActiveUniforms;++i){program.maxUniformLength=Math.max(program.maxUniformLength,GLctx.getActiveUniform(program,i).name.length+1)}}HEAP32[p>>2]=program.maxUniformLength}else if(pname==35722){if(!program.maxAttributeLength){var numActiveAttributes=GLctx.getProgramParameter(program,35721);for(var i=0;i<numActiveAttributes;++i){program.maxAttributeLength=Math.max(program.maxAttributeLength,GLctx.getActiveAttrib(program,i).name.length+1)}}HEAP32[p>>2]=program.maxAttributeLength}else if(pname==35381){if(!program.maxUniformBlockNameLength){var numActiveUniformBlocks=GLctx.getProgramParameter(program,35382);for(var i=0;i<numActiveUniformBlocks;++i){program.maxUniformBlockNameLength=Math.max(program.maxUniformBlockNameLength,GLctx.getActiveUniformBlockName(program,i).length+1)}}HEAP32[p>>2]=program.maxUniformBlockNameLength}else{HEAP32[p>>2]=GLctx.getProgramParameter(program,pname)}};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var _glGetShaderInfoLog=(shader,maxLength,length,infoLog)=>{var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _glGetShaderiv=(shader,pname,p)=>{if(!p){GL.recordError(1281);return}if(pname==35716){var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var logLength=log?log.length+1:0;HEAP32[p>>2]=logLength}else if(pname==35720){var source=GLctx.getShaderSource(GL.shaders[shader]);var sourceLength=source?source.length+1:0;HEAP32[p>>2]=sourceLength}else{HEAP32[p>>2]=GLctx.getShaderParameter(GL.shaders[shader],pname)}};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToNewUTF8=str=>{var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8(str,ret,size);return ret};var _glGetStringi=(name,index)=>{if(GL.currentContext.version<2){GL.recordError(1282);return 0}var stringiCache=GL.stringiCache[name];if(stringiCache){if(index<0||index>=stringiCache.length){GL.recordError(1281);return 0}return stringiCache[index]}switch(name){case 7939:var exts=webglGetExtensions().map(stringToNewUTF8);stringiCache=GL.stringiCache[name]=exts;if(index<0||index>=stringiCache.length){GL.recordError(1281);return 0}return stringiCache[index];default:GL.recordError(1280);return 0}};var jstoi_q=str=>parseInt(str);var webglGetLeftBracePos=name=>name.slice(-1)=="]"&&name.lastIndexOf("[");var webglPrepareUniformLocationsBeforeFirstUse=program=>{var uniformLocsById=program.uniformLocsById,uniformSizeAndIdsByName=program.uniformSizeAndIdsByName,i,j;if(!uniformLocsById){program.uniformLocsById=uniformLocsById={};program.uniformArrayNamesById={};var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(i=0;i<numActiveUniforms;++i){var u=GLctx.getActiveUniform(program,i);var nm=u.name;var sz=u.size;var lb=webglGetLeftBracePos(nm);var arrayName=lb>0?nm.slice(0,lb):nm;var id=program.uniformIdCounter;program.uniformIdCounter+=sz;uniformSizeAndIdsByName[arrayName]=[sz,id];for(j=0;j<sz;++j){uniformLocsById[id]=j;program.uniformArrayNamesById[id++]=arrayName}}}};var _glGetUniformLocation=(program,name)=>{name=UTF8ToString(name);if(program=GL.programs[program]){webglPrepareUniformLocationsBeforeFirstUse(program);var uniformLocsById=program.uniformLocsById;var arrayIndex=0;var uniformBaseName=name;var leftBrace=webglGetLeftBracePos(name);if(leftBrace>0){arrayIndex=jstoi_q(name.slice(leftBrace+1))>>>0;uniformBaseName=name.slice(0,leftBrace)}var sizeAndId=program.uniformSizeAndIdsByName[uniformBaseName];if(sizeAndId&&arrayIndex<sizeAndId[0]){arrayIndex+=sizeAndId[1];if(uniformLocsById[arrayIndex]=uniformLocsById[arrayIndex]||GLctx.getUniformLocation(program,name)){return arrayIndex}}}else{GL.recordError(1281)}return-1};var _glInvalidateFramebuffer=(target,numAttachments,attachments)=>{var list=tempFixedLengthArray[numAttachments];for(var i=0;i<numAttachments;i++){list[i]=HEAP32[attachments+i*4>>2]}GLctx.invalidateFramebuffer(target,list)};var _glLinkProgram=program=>{program=GL.programs[program];GLctx.linkProgram(program);program.uniformLocsById=0;program.uniformSizeAndIdsByName={}};var _glPixelStorei=(pname,param)=>{if(pname==3317){GL.unpackAlignment=param}else if(pname==3314){GL.unpackRowLength=param}GLctx.pixelStorei(pname,param)};var _glPolygonOffset=(x0,x1)=>GLctx.polygonOffset(x0,x1);var _glReadBuffer=x0=>GLctx.readBuffer(x0);var _glRenderbufferStorageMultisample=(x0,x1,x2,x3,x4)=>GLctx.renderbufferStorageMultisample(x0,x1,x2,x3,x4);var _glSamplerParameterf=(sampler,pname,param)=>{GLctx.samplerParameterf(GL.samplers[sampler],pname,param)};var _glSamplerParameteri=(sampler,pname,param)=>{GLctx.samplerParameteri(GL.samplers[sampler],pname,param)};var _glScissor=(x0,x1,x2,x3)=>GLctx.scissor(x0,x1,x2,x3);var _glShaderSource=(shader,count,string,length)=>{var source=GL.getSource(shader,count,string,length);GLctx.shaderSource(GL.shaders[shader],source)};var _glStencilFunc=(x0,x1,x2)=>GLctx.stencilFunc(x0,x1,x2);var _glStencilFuncSeparate=(x0,x1,x2,x3)=>GLctx.stencilFuncSeparate(x0,x1,x2,x3);var _glStencilMask=x0=>GLctx.stencilMask(x0);var _glStencilOp=(x0,x1,x2)=>GLctx.stencilOp(x0,x1,x2);var _glStencilOpSeparate=(x0,x1,x2,x3)=>GLctx.stencilOpSeparate(x0,x1,x2,x3);var _glTexStorage2D=(x0,x1,x2,x3,x4)=>GLctx.texStorage2D(x0,x1,x2,x3,x4);var _glTexStorage3D=(x0,x1,x2,x3,x4,x5)=>GLctx.texStorage3D(x0,x1,x2,x3,x4,x5);var computeUnpackAlignedImageSize=(width,height,sizePerPixel)=>{function roundedToNextMultipleOf(x,y){return x+y-1&-y}var plainRowSize=(GL.unpackRowLength||width)*sizePerPixel;var alignedRowSize=roundedToNextMultipleOf(plainRowSize,GL.unpackAlignment);return height*alignedRowSize};var colorChannelsInGlTextureFormat=format=>{var colorChannels={5:3,6:4,8:2,29502:3,29504:4,26917:2,26918:2,29846:3,29847:4};return colorChannels[format-6402]||1};var heapObjectForWebGLType=type=>{type-=5120;if(type==0)return HEAP8;if(type==1)return HEAPU8;if(type==2)return HEAP16;if(type==4)return HEAP32;if(type==6)return HEAPF32;if(type==5||type==28922||type==28520||type==30779||type==30782)return HEAPU32;return HEAPU16};var toTypedArrayIndex=(pointer,heap)=>pointer>>>31-Math.clz32(heap.BYTES_PER_ELEMENT);var emscriptenWebGLGetTexPixelData=(type,format,width,height,pixels,internalFormat)=>{var heap=heapObjectForWebGLType(type);var sizePerPixel=colorChannelsInGlTextureFormat(format)*heap.BYTES_PER_ELEMENT;var bytes=computeUnpackAlignedImageSize(width,height,sizePerPixel);return heap.subarray(toTypedArrayIndex(pixels,heap),toTypedArrayIndex(pixels+bytes,heap))};var _glTexSubImage2D=(target,level,xoffset,yoffset,width,height,format,type,pixels)=>{if(true){if(GLctx.currentPixelUnpackBufferBinding){GLctx.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);return}if(pixels){var heap=heapObjectForWebGLType(type);GLctx.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,heap,toTypedArrayIndex(pixels,heap));return}}var pixelData=pixels?emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,0):null;GLctx.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixelData)};var _glTexSubImage3D=(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels)}else if(pixels){var heap=heapObjectForWebGLType(type);GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,heap,toTypedArrayIndex(pixels,heap))}else{GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,null)}};var webglGetUniformLocation=location=>{var p=GLctx.currentProgram;if(p){var webglLoc=p.uniformLocsById[location];if(typeof webglLoc=="number"){p.uniformLocsById[location]=webglLoc=GLctx.getUniformLocation(p,p.uniformArrayNamesById[location]+(webglLoc>0?`[${webglLoc}]`:""))}return webglLoc}else{GL.recordError(1282)}};var _glUniform1fv=(location,count,value)=>{count&&GLctx.uniform1fv(webglGetUniformLocation(location),HEAPF32,value>>2,count)};var _glUniform1i=(location,v0)=>{GLctx.uniform1i(webglGetUniformLocation(location),v0)};var _glUniform1iv=(location,count,value)=>{count&&GLctx.uniform1iv(webglGetUniformLocation(location),HEAP32,value>>2,count)};var _glUniform2fv=(location,count,value)=>{count&&GLctx.uniform2fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*2)};var _glUniform2iv=(location,count,value)=>{count&&GLctx.uniform2iv(webglGetUniformLocation(location),HEAP32,value>>2,count*2)};var _glUniform3fv=(location,count,value)=>{count&&GLctx.uniform3fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*3)};var _glUniform3iv=(location,count,value)=>{count&&GLctx.uniform3iv(webglGetUniformLocation(location),HEAP32,value>>2,count*3)};var _glUniform4fv=(location,count,value)=>{count&&GLctx.uniform4fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*4)};var _glUniform4iv=(location,count,value)=>{count&&GLctx.uniform4iv(webglGetUniformLocation(location),HEAP32,value>>2,count*4)};var _glUniformMatrix4fv=(location,count,transpose,value)=>{count&&GLctx.uniformMatrix4fv(webglGetUniformLocation(location),!!transpose,HEAPF32,value>>2,count*16)};var _glUseProgram=program=>{program=GL.programs[program];GLctx.useProgram(program);GLctx.currentProgram=program};var _glVertexAttribDivisor=(index,divisor)=>{GLctx.vertexAttribDivisor(index,divisor)};var _glVertexAttribIPointer=(index,size,type,stride,ptr)=>{var cb=GL.currentContext.clientBuffers[index];if(!GLctx.currentArrayBufferBinding){cb.size=size;cb.type=type;cb.normalized=false;cb.stride=stride;cb.ptr=ptr;cb.clientside=true;cb.vertexAttribPointerAdaptor=function(index,size,type,normalized,stride,ptr){this.vertexAttribIPointer(index,size,type,stride,ptr)};return}cb.clientside=false;GLctx.vertexAttribIPointer(index,size,type,stride,ptr)};var _glVertexAttribPointer=(index,size,type,normalized,stride,ptr)=>{var cb=GL.currentContext.clientBuffers[index];if(!GLctx.currentArrayBufferBinding){cb.size=size;cb.type=type;cb.normalized=normalized;cb.stride=stride;cb.ptr=ptr;cb.clientside=true;cb.vertexAttribPointerAdaptor=function(index,size,type,normalized,stride,ptr){this.vertexAttribPointer(index,size,type,normalized,stride,ptr)};return}cb.clientside=false;GLctx.vertexAttribPointer(index,size,type,!!normalized,stride,ptr)};var _glViewport=(x0,x1,x2,x3)=>GLctx.viewport(x0,x1,x2,x3);registerPreMainLoop(()=>GL.newRenderingFrameStarted());for(let i=0;i<32;++i)tempFixedLengthArray.push(new Array(i));{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"]}Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["GL"]=GL;var ASM_CONSTS={10156:()=>{const ctx=Module.creator2d_glContext||typeof window!=="undefined"&&window.creator2d_glContext;const opts=Module.creator2d_glOptions||typeof window!=="undefined"&&window.creator2d_glOptions||{};const handle=GL.registerContext(ctx,opts);GL.makeContextCurrent(handle)}};function slog_js_log(level,c_str){const str=UTF8ToString(c_str);switch(level){case 0:console.error(str);break;case 1:console.error(str);break;case 2:console.warn(str);break;default:console.info(str);break}}var wasmImports={K:___cxa_throw,Xa:__abort_js,Ea:_c2dAnimEvent,S:_c2dEarlyUpdate,N:_c2dLateUpdate,Ba:_c2dPhysicsEvent,Wa:_clock_time_get,ab:_emscripten_asm_const_int,Va:_emscripten_get_now,Ua:_emscripten_resize_heap,q:_glActiveTexture,t:_glAttachShader,b:_glBindBuffer,w:_glBindBufferBase,wa:_glBindBufferRange,g:_glBindFramebuffer,Ga:_glBindRenderbuffer,p:_glBindSampler,f:_glBindTexture,v:_glBindVertexArray,B:_glBlendColor,C:_glBlendEquationSeparate,D:_glBlendFuncSeparate,ba:_glBlitFramebuffer,Qa:_glBufferData,M:_glBufferSubData,Ya:_glCheckFramebufferStatus,Aa:_glClearBufferfi,F:_glClearBufferfv,za:_glClearBufferiv,n:_glColorMask,$a:_glCompileShader,Y:_glCompressedTexSubImage2D,W:_glCompressedTexSubImage3D,La:_glCreateProgram,U:_glCreateShader,A:_glCullFace,Z:_glDeleteBuffers,u:_glDeleteFramebuffers,k:_glDeleteProgram,O:_glDeleteRenderbuffers,P:_glDeleteSamplers,j:_glDeleteShader,o:_glDeleteTextures,Sa:_glDeleteVertexArrays,r:_glDepthFunc,s:_glDepthMask,c:_glDisable,y:_glDisableVertexAttribArray,da:_glDrawArrays,ea:_glDrawArraysInstanced,G:_glDrawBuffers,fa:_glDrawElements,ha:_glDrawElementsInstanced,e:_glEnable,sa:_glEnableVertexAttribArray,i:_glFramebufferRenderbuffer,h:_glFramebufferTexture2D,Za:_glFramebufferTextureLayer,z:_glFrontFace,Ra:_glGenBuffers,R:_glGenFramebuffers,Ha:_glGenRenderbuffers,Ma:_glGenSamplers,Pa:_glGenTextures,ga:_glGenVertexArrays,Ia:_glGetAttribLocation,a:_glGetIntegerv,Ka:_glGetProgramInfoLog,I:_glGetProgramiv,_a:_glGetShaderInfoLog,Q:_glGetShaderiv,ra:_glGetStringi,H:_glGetUniformLocation,aa:_glInvalidateFramebuffer,J:_glLinkProgram,Ta:_glPixelStorei,E:_glPolygonOffset,ca:_glReadBuffer,Fa:_glRenderbufferStorageMultisample,L:_glSamplerParameterf,d:_glSamplerParameteri,Ca:_glScissor,T:_glShaderSource,$:_glStencilFunc,ya:_glStencilFuncSeparate,m:_glStencilMask,_:_glStencilOp,xa:_glStencilOpSeparate,Oa:_glTexStorage2D,Na:_glTexStorage3D,X:_glTexSubImage2D,V:_glTexSubImage3D,qa:_glUniform1fv,Ja:_glUniform1i,ma:_glUniform1iv,pa:_glUniform2fv,la:_glUniform2iv,oa:_glUniform3fv,ka:_glUniform3iv,na:_glUniform4fv,ja:_glUniform4iv,ia:_glUniformMatrix4fv,l:_glUseProgram,ta:_glVertexAttribDivisor,ua:_glVertexAttribIPointer,va:_glVertexAttribPointer,Da:_glViewport,x:slog_js_log};var wasmExports=await createWasm();var ___wasm_call_ctors=wasmExports["cb"];var _creator2dVersion=Module["_creator2dVersion"]=wasmExports["db"];var _c2dInit=Module["_c2dInit"]=wasmExports["eb"];var _c2dInitMetal=Module["_c2dInitMetal"]=wasmExports["fb"];var _c2dInitHeadless=Module["_c2dInitHeadless"]=wasmExports["gb"];var _c2dTickHeadless=Module["_c2dTickHeadless"]=wasmExports["hb"];var _c2dReadDrawList=Module["_c2dReadDrawList"]=wasmExports["ib"];var _c2dShutdown=Module["_c2dShutdown"]=wasmExports["jb"];var _c2dSetViewport=Module["_c2dSetViewport"]=wasmExports["kb"];var _c2dSetDensity=Module["_c2dSetDensity"]=wasmExports["lb"];var _c2dSetClearColor=Module["_c2dSetClearColor"]=wasmExports["mb"];var _c2dSetGLFramebuffer=Module["_c2dSetGLFramebuffer"]=wasmExports["nb"];var _c2dResetStateCache=Module["_c2dResetStateCache"]=wasmExports["ob"];var _c2dRender=Module["_c2dRender"]=wasmExports["pb"];var _c2dRenderMetal=Module["_c2dRenderMetal"]=wasmExports["qb"];var _c2dCreateScene=Module["_c2dCreateScene"]=wasmExports["rb"];var _c2dDestroyScene=Module["_c2dDestroyScene"]=wasmExports["sb"];var _c2dOpenScene=Module["_c2dOpenScene"]=wasmExports["tb"];var _c2dCloseScene=Module["_c2dCloseScene"]=wasmExports["ub"];var _c2dSceneSetClearColor=Module["_c2dSceneSetClearColor"]=wasmExports["vb"];var _c2dAddEntityToScene=Module["_c2dAddEntityToScene"]=wasmExports["wb"];var _c2dRemoveEntityFromScene=Module["_c2dRemoveEntityFromScene"]=wasmExports["xb"];var _c2dSetLayerYSort=Module["_c2dSetLayerYSort"]=wasmExports["yb"];var _c2dCameraSetPosition=Module["_c2dCameraSetPosition"]=wasmExports["zb"];var _c2dCameraSetZoom=Module["_c2dCameraSetZoom"]=wasmExports["Ab"];var _c2dCameraSetRotation=Module["_c2dCameraSetRotation"]=wasmExports["Bb"];var _c2dCameraScreenToWorld=Module["_c2dCameraScreenToWorld"]=wasmExports["Cb"];var _c2dCameraWorldToScreen=Module["_c2dCameraWorldToScreen"]=wasmExports["Db"];var _c2dCreateEntity=Module["_c2dCreateEntity"]=wasmExports["Eb"];var _c2dDestroyEntity=Module["_c2dDestroyEntity"]=wasmExports["Fb"];var _c2dSetParent=Module["_c2dSetParent"]=wasmExports["Gb"];var _c2dSetPosition=Module["_c2dSetPosition"]=wasmExports["Hb"];var _c2dSetRotation=Module["_c2dSetRotation"]=wasmExports["Ib"];var _c2dSetScale=Module["_c2dSetScale"]=wasmExports["Jb"];var _c2dSetLayer=Module["_c2dSetLayer"]=wasmExports["Kb"];var _c2dSetZ=Module["_c2dSetZ"]=wasmExports["Lb"];var _c2dSetVisible=Module["_c2dSetVisible"]=wasmExports["Mb"];var _c2dGetPosition=Module["_c2dGetPosition"]=wasmExports["Nb"];var _c2dGetParent=Module["_c2dGetParent"]=wasmExports["Ob"];var _c2dGetChildCount=Module["_c2dGetChildCount"]=wasmExports["Pb"];var _c2dGetChild=Module["_c2dGetChild"]=wasmExports["Qb"];var _c2dGetWorldPosition=Module["_c2dGetWorldPosition"]=wasmExports["Rb"];var _c2dGetWorldMatrix=Module["_c2dGetWorldMatrix"]=wasmExports["Sb"];var _c2dWorldToLocal=Module["_c2dWorldToLocal"]=wasmExports["Tb"];var _c2dLocalToWorld=Module["_c2dLocalToWorld"]=wasmExports["Ub"];var _c2dGetLocalTransform=Module["_c2dGetLocalTransform"]=wasmExports["Vb"];var _c2dPickSprite=Module["_c2dPickSprite"]=wasmExports["Wb"];var _c2dSetSprite=Module["_c2dSetSprite"]=wasmExports["Xb"];var _c2dSetSpriteFrame=Module["_c2dSetSpriteFrame"]=wasmExports["Yb"];var _c2dSetSpriteFramePx=Module["_c2dSetSpriteFramePx"]=wasmExports["Zb"];var _c2dSetSpriteSize=Module["_c2dSetSpriteSize"]=wasmExports["_b"];var _c2dSetSpriteAnchor=Module["_c2dSetSpriteAnchor"]=wasmExports["$b"];var _c2dSetSpriteColor=Module["_c2dSetSpriteColor"]=wasmExports["ac"];var _c2dSetSpriteOpacity=Module["_c2dSetSpriteOpacity"]=wasmExports["bc"];var _c2dSetSpriteFlip=Module["_c2dSetSpriteFlip"]=wasmExports["cc"];var _c2dSetDefaultFilter=Module["_c2dSetDefaultFilter"]=wasmExports["dc"];var _c2dBulkSetPositions=Module["_c2dBulkSetPositions"]=wasmExports["ec"];var _c2dCreateTexture=Module["_c2dCreateTexture"]=wasmExports["fc"];var _c2dCreateTextureFromRGBA=Module["_c2dCreateTextureFromRGBA"]=wasmExports["gc"];var _c2dUpdateTextureFromRGBA=Module["_c2dUpdateTextureFromRGBA"]=wasmExports["hc"];var _c2dGetTextureWidth=Module["_c2dGetTextureWidth"]=wasmExports["ic"];var _c2dGetTextureHeight=Module["_c2dGetTextureHeight"]=wasmExports["jc"];var _c2dDestroyTexture=Module["_c2dDestroyTexture"]=wasmExports["kc"];var _c2dDefineAnimation=Module["_c2dDefineAnimation"]=wasmExports["lc"];var _c2dPlayAnimation=Module["_c2dPlayAnimation"]=wasmExports["mc"];var _c2dStopAnimation=Module["_c2dStopAnimation"]=wasmExports["nc"];var _c2dSetAnimationSpeed=Module["_c2dSetAnimationSpeed"]=wasmExports["oc"];var _c2dGetAnimationFrame=Module["_c2dGetAnimationFrame"]=wasmExports["pc"];var _c2dCreateTilemap=Module["_c2dCreateTilemap"]=wasmExports["qc"];var _c2dSetTile=Module["_c2dSetTile"]=wasmExports["rc"];var _free=Module["_free"]=wasmExports["sc"];var _malloc=Module["_malloc"]=wasmExports["tc"];var _c2dPhysicsHasSupport=Module["_c2dPhysicsHasSupport"]=wasmExports["uc"];var _c2dSetInterpolation=Module["_c2dSetInterpolation"]=wasmExports["vc"];var _c2dPhysicsConfigure=Module["_c2dPhysicsConfigure"]=wasmExports["wc"];var _c2dPhysicsCreateBody=Module["_c2dPhysicsCreateBody"]=wasmExports["xc"];var _c2dPhysicsRemoveBody=Module["_c2dPhysicsRemoveBody"]=wasmExports["yc"];var _c2dPhysicsAddBox=Module["_c2dPhysicsAddBox"]=wasmExports["zc"];var _c2dPhysicsAddCircle=Module["_c2dPhysicsAddCircle"]=wasmExports["Ac"];var _c2dPhysicsAddCapsule=Module["_c2dPhysicsAddCapsule"]=wasmExports["Bc"];var _c2dPhysicsAddSegment=Module["_c2dPhysicsAddSegment"]=wasmExports["Cc"];var _c2dPhysicsAddPolygon=Module["_c2dPhysicsAddPolygon"]=wasmExports["Dc"];var _c2dPhysicsSetLinearVelocity=Module["_c2dPhysicsSetLinearVelocity"]=wasmExports["Ec"];var _c2dPhysicsGetLinearVelocity=Module["_c2dPhysicsGetLinearVelocity"]=wasmExports["Fc"];var _c2dPhysicsSetAngularVelocity=Module["_c2dPhysicsSetAngularVelocity"]=wasmExports["Gc"];var _c2dPhysicsApplyLinearImpulse=Module["_c2dPhysicsApplyLinearImpulse"]=wasmExports["Hc"];var _c2dPhysicsApplyForce=Module["_c2dPhysicsApplyForce"]=wasmExports["Ic"];var _c2dPhysicsSetTransform=Module["_c2dPhysicsSetTransform"]=wasmExports["Jc"];var _c2dPhysicsSetFixedRotation=Module["_c2dPhysicsSetFixedRotation"]=wasmExports["Kc"];var _c2dPhysicsSetGravityScale=Module["_c2dPhysicsSetGravityScale"]=wasmExports["Lc"];var _c2dPhysicsSetLinearDamping=Module["_c2dPhysicsSetLinearDamping"]=wasmExports["Mc"];var _c2dPhysicsSetBullet=Module["_c2dPhysicsSetBullet"]=wasmExports["Nc"];var _c2dPhysicsSetEnabled=Module["_c2dPhysicsSetEnabled"]=wasmExports["Oc"];var _c2dPhysicsRaycastClosest=Module["_c2dPhysicsRaycastClosest"]=wasmExports["Pc"];var _c2dPhysicsOverlapPoint=Module["_c2dPhysicsOverlapPoint"]=wasmExports["Qc"];function run(){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}function preInit(){if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}preInit();run();moduleRtn=readyPromise;
+
+
+  return moduleRtn;
+}
+);
+})();
+export default creator2d;