lecodes-viewer 0.19.0

package/src/viewer2d/sprite2d.ts

@@ -0,0 +1,80 @@
+// Typed surface + helpers for the creator-2d host. The raw entry points live on the object returned
+// by createViewer2d (createScene, setSprite, …); this file adds the things that don't belong in the
+// passthrough layer: the typed interface the worker SDK consumes, enums, and a runnable test scene.
+// Mirrors viewer/physics.ts.
+//
+// Conventions (mirror of creator2d.h):
+//   - World is Y-up. At camera zoom 1, one world unit == one screen pixel.
+//   - Native owns transform/sprite/animation data; TS mutates via the cheap setters below.
+//   - Animations advance in c2dRender (zero per-frame JS). Loop/complete events arrive via
+//     setOnAnimEvent, drained once per frame.
+
+import type { Creator2dViewer } from './createViewer2d'
+
+/** A normalized UV frame, [u0, v0, u1, v1] (top-left .. bottom-right). */
+export type UVFrame = readonly [number, number, number, number]
+
+export const AnimEventType = {
+  LoopReached: 0,
+  Completed: 1,
+} as const
+export type AnimEventType = (typeof AnimEventType)[keyof typeof AnimEventType]
+
+// The full bridge surface the worker SDK calls through (a structural subset of Creator2dViewer).
+export type Creator2dApi = Creator2dViewer
+
+// --- Frame helpers ----------------------------------------------------------------------------
+
+/** Slice a uniform grid atlas (e.g. a character sheet) into normalized UV frames. */
+export function gridFrames(
+  texW: number, texH: number, frameW: number, frameH: number,
+  count: number, startIndex = 0,
+): Float32Array {
+  const cols = Math.max(1, Math.floor(texW / frameW))
+  const out = new Float32Array(count * 4)
+  for (let i = 0; i < count; i++) {
+    const idx = startIndex + i
+    const cx = (idx % cols) * frameW
+    const cy = Math.floor(idx / cols) * frameH
+    out[i * 4 + 0] = cx / texW
+    out[i * 4 + 1] = cy / texH
+    out[i * 4 + 2] = (cx + frameW) / texW
+    out[i * 4 + 3] = (cy + frameH) / texH
+  }
+  return out
+}
+
+// --- Test scene -------------------------------------------------------------------------------
+// Scatters sprites of `textureId` across a Y-sorted layer so depth ordering, batching and the
+// host RAF loop can be eyeballed. Returns the scene + entity ids. Caller loads the texture (texture
+// creation is app-specific, like physics.ts's materialId).
+
+export function createSpriteTestScene(viewer: Creator2dApi, textureId: number, count = 200): { sceneId: number; entities: number[] } {
+  const sceneId = viewer.createScene()
+  viewer.sceneSetClearColor(sceneId, 0.06, 0.07, 0.10, 1)
+  viewer.setLayerYSort(sceneId, 1, true)
+
+  const w = viewer.getTextureWidth(textureId) || 32
+  const h = viewer.getTextureHeight(textureId) || 32
+  const entities: number[] = []
+
+  // deterministic scatter (no Math.random dependency for reproducibility)
+  let seed = 1234567
+  const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff }
+
+  for (let i = 0; i < count; i++) {
+    const e = viewer.createEntity()
+    viewer.setSprite(e, textureId)
+    viewer.setSpriteSize(e, w, h)
+    viewer.setSpriteAnchor(e, 0.5, 1)             // feet pivot for Y-sort
+    viewer.setPosition(e, (rnd() - 0.5) * 600, (rnd() - 0.5) * 400)
+    viewer.setLayer(e, 1)
+    viewer.addEntityToScene(sceneId, e)
+    entities.push(e)
+  }
+
+  viewer.cameraSetPosition(sceneId, 0, 0)
+  viewer.cameraSetZoom(sceneId, 1)
+  viewer.openScene(sceneId)
+  return { sceneId, entities }
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />