@bornengine/engine 0.4.16

package/src/shapes/index.ts

@@ -0,0 +1,120 @@
+import { Color, Rect, Vec2 } from '../core/types';
+
+// FFI declarations
+declare function bloom_draw_line(x1: number, y1: number, x2: number, y2: number, thickness: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_rect(x: number, y: number, w: number, h: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_rect_lines(x: number, y: number, w: number, h: number, thickness: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_circle(cx: number, cy: number, radius: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_circle_lines(cx: number, cy: number, radius: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_triangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_poly(cx: number, cy: number, sides: number, radius: number, rotation: number, r: number, g: number, b: number, a: number): void;
+
+// Drawing functions
+
+export function drawLine(startX: number, startY: number, endX: number, endY: number, thickness: number, color: Color): void {
+  bloom_draw_line(startX, startY, endX, endY, thickness, color.r, color.g, color.b, color.a);
+}
+
+export function drawRect(x: number, y: number, width: number, height: number, color: Color): void {
+  bloom_draw_rect(x, y, width, height, color.r, color.g, color.b, color.a);
+}
+
+export function drawRectRec(rec: Rect, color: Color): void {
+  bloom_draw_rect(rec.x, rec.y, rec.width, rec.height, color.r, color.g, color.b, color.a);
+}
+
+export function drawRectLines(x: number, y: number, width: number, height: number, thickness: number, color: Color): void {
+  bloom_draw_rect_lines(x, y, width, height, thickness, color.r, color.g, color.b, color.a);
+}
+
+export function drawCircle(centerX: number, centerY: number, radius: number, color: Color): void {
+  bloom_draw_circle(centerX, centerY, radius, color.r, color.g, color.b, color.a);
+}
+
+export function drawCircleLines(centerX: number, centerY: number, radius: number, color: Color): void {
+  bloom_draw_circle_lines(centerX, centerY, radius, color.r, color.g, color.b, color.a);
+}
+
+export function drawTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, color: Color): void {
+  bloom_draw_triangle(x1, y1, x2, y2, x3, y3, color.r, color.g, color.b, color.a);
+}
+
+export function drawPoly(centerX: number, centerY: number, sides: number, radius: number, rotation: number, color: Color): void {
+  bloom_draw_poly(centerX, centerY, sides, radius, rotation, color.r, color.g, color.b, color.a);
+}
+
+// Bezier curve drawing (pure TS — subdivides cubic bezier into line segments)
+
+export function drawBezier(
+  startX: number, startY: number,
+  cp1X: number, cp1Y: number,
+  cp2X: number, cp2Y: number,
+  endX: number, endY: number,
+  thickness: number, color: Color,
+): void {
+  const segments = 24;
+  let prevX = startX;
+  let prevY = startY;
+  for (let i = 1; i <= segments; i++) {
+    const t = i / segments;
+    const u = 1 - t;
+    const x = u * u * u * startX + 3 * u * u * t * cp1X + 3 * u * t * t * cp2X + t * t * t * endX;
+    const y = u * u * u * startY + 3 * u * u * t * cp1Y + 3 * u * t * t * cp2Y + t * t * t * endY;
+    bloom_draw_line(prevX, prevY, x, y, thickness, color.r, color.g, color.b, color.a);
+    prevX = x;
+    prevY = y;
+  }
+}
+
+// Pure TypeScript collision detection
+
+export function checkCollisionRecs(rec1: Rect, rec2: Rect): boolean {
+  return (
+    rec1.x < rec2.x + rec2.width &&
+    rec1.x + rec1.width > rec2.x &&
+    rec1.y < rec2.y + rec2.height &&
+    rec1.y + rec1.height > rec2.y
+  );
+}
+
+export function checkCollisionCircles(center1: Vec2, radius1: number, center2: Vec2, radius2: number): boolean {
+  const dx = center2.x - center1.x;
+  const dy = center2.y - center1.y;
+  const distSq = dx * dx + dy * dy;
+  const radiusSum = radius1 + radius2;
+  return distSq <= radiusSum * radiusSum;
+}
+
+export function checkCollisionCircleRec(center: Vec2, radius: number, rec: Rect): boolean {
+  const closestX = Math.max(rec.x, Math.min(center.x, rec.x + rec.width));
+  const closestY = Math.max(rec.y, Math.min(center.y, rec.y + rec.height));
+  const dx = center.x - closestX;
+  const dy = center.y - closestY;
+  return (dx * dx + dy * dy) <= radius * radius;
+}
+
+export function checkCollisionPointRec(point: Vec2, rec: Rect): boolean {
+  return (
+    point.x >= rec.x &&
+    point.x <= rec.x + rec.width &&
+    point.y >= rec.y &&
+    point.y <= rec.y + rec.height
+  );
+}
+
+export function checkCollisionPointCircle(point: Vec2, center: Vec2, radius: number): boolean {
+  const dx = point.x - center.x;
+  const dy = point.y - center.y;
+  return (dx * dx + dy * dy) <= radius * radius;
+}
+
+export function getCollisionRec(rec1: Rect, rec2: Rect): Rect {
+  const x = Math.max(rec1.x, rec2.x);
+  const y = Math.max(rec1.y, rec2.y);
+  const right = Math.min(rec1.x + rec1.width, rec2.x + rec2.width);
+  const bottom = Math.min(rec1.y + rec1.height, rec2.y + rec2.height);
+  if (right <= x || bottom <= y) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  return { x, y, width: right - x, height: bottom - y };
+}

package/src/text/index.ts

@@ -0,0 +1,48 @@
+import { Color, Font, Vec2 } from '../core/types';
+
+// FFI declarations
+declare function bloom_draw_text(text: number, x: number, y: number, size: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_measure_text(text: number, size: number): number;
+declare function bloom_load_font(path: number, size: number): number;
+declare function bloom_draw_text_ex(font: number, text: number, x: number, y: number, size: number, spacing: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_measure_text_ex(font: number, text: number, size: number, spacing: number): number;
+declare function bloom_unload_font(font: number): void;
+
+export function drawText(text: string, x: number, y: number, size: number, color: Color): void {
+  bloom_draw_text(text as any, x, y, size, color.r, color.g, color.b, color.a);
+}
+
+/// RGBA variant of `drawText`. Prefer this over passing a `Color` object on
+/// Android (aarch64): Perry 0.5.x miscompiles `color.r` field reads that feed
+/// straight into an f64 FFI slot, producing NaN for all color components and
+/// dropping the glyph quads. Passing raw numbers bypasses the object read.
+export function drawTextRgba(text: string, x: number, y: number, size: number, r: number, g: number, b: number, a: number): void {
+  bloom_draw_text(text as any, x, y, size, r, g, b, a);
+}
+
+export function measureText(text: string, size: number): number {
+  return bloom_measure_text(text as any, size);
+}
+
+export function loadFont(path: string, size: number): Font {
+  const handle = bloom_load_font(path as any, size);
+  return { handle, size };
+}
+
+export function loadFontEx(path: string, size: number): Font {
+  const handle = bloom_load_font(path as any, size);
+  return { handle, size };
+}
+
+export function unloadFont(font: Font): void {
+  bloom_unload_font(font.handle);
+}
+
+export function drawTextEx(font: Font, text: string, pos: Vec2, size: number, spacing: number, color: Color): void {
+  bloom_draw_text_ex(font.handle, text as any, pos.x, pos.y, size, spacing, color.r, color.g, color.b, color.a);
+}
+
+export function measureTextEx(font: Font, text: string, size: number, spacing: number): Vec2 {
+  const width = bloom_measure_text_ex(font.handle, text as any, size, spacing);
+  return { x: width, y: size };
+}

package/src/textures/index.ts

@@ -0,0 +1,187 @@
+import { spawn, parallelMap } from 'perry/thread';
+import { Color, Rect, Texture } from '../core/types';
+
+// FFI declarations
+declare function bloom_load_texture(path: number): number;
+declare function bloom_unload_texture(handle: number): void;
+declare function bloom_draw_texture(handle: number, x: number, y: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_texture_rec(handle: number, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_texture_pro(handle: number, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number, ox: number, oy: number, rot: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_get_texture_width(handle: number): number;
+declare function bloom_get_texture_height(handle: number): number;
+declare function bloom_load_image(path: number): number;
+declare function bloom_image_resize(handle: number, w: number, h: number): void;
+declare function bloom_image_crop(handle: number, x: number, y: number, w: number, h: number): void;
+declare function bloom_image_flip_h(handle: number): void;
+declare function bloom_image_flip_v(handle: number): void;
+declare function bloom_load_texture_from_image(handle: number): number;
+declare function bloom_gen_texture_mipmaps(handle: number): void;
+declare function bloom_set_texture_filter(handle: number, mode: number): void;
+
+export const FILTER_LINEAR = 0;
+export const FILTER_NEAREST = 1;
+
+export function setTextureFilter(texture: Texture, mode: number): void {
+  bloom_set_texture_filter(texture.handle, mode);
+}
+
+/**
+ * Load a texture from a PNG/JPEG/BMP/TGA file.
+ *
+ * On failure (missing file, undecodable data) returns a Texture with
+ * `handle === 0` and zero dimensions — drawing it is a safe no-op and the
+ * engine logs the failure once. Check `tex.handle !== 0` when you need to
+ * react to missing assets.
+ */
+export function loadTexture(path: string): Texture {
+  const id = bloom_load_texture(path as any);
+  const width = bloom_get_texture_width(id);
+  const height = bloom_get_texture_height(id);
+  return { handle: id, width, height };
+}
+
+export function unloadTexture(texture: Texture): void {
+  bloom_unload_texture(texture.handle);
+}
+
+export function drawTexture(texture: Texture, x: number, y: number, tint: Color): void {
+  bloom_draw_texture(texture.handle, x, y, tint.r, tint.g, tint.b, tint.a);
+}
+
+export function drawTextureRec(texture: Texture, source: Rect, position: { x: number; y: number }, tint: Color): void {
+  bloom_draw_texture_rec(texture.handle, source.x, source.y, source.width, source.height, position.x, position.y, tint.r, tint.g, tint.b, tint.a);
+}
+
+export function drawTexturePro(
+  texture: Texture, source: Rect, dest: Rect,
+  origin: { x: number; y: number }, rotation: number, tint: Color,
+): void {
+  bloom_draw_texture_pro(
+    texture.handle,
+    source.x, source.y, source.width, source.height,
+    dest.x, dest.y, dest.width, dest.height,
+    origin.x, origin.y, rotation,
+    tint.r, tint.g, tint.b, tint.a,
+  );
+}
+
+// Raw variant: takes primitives directly. Workaround for aarch64 Android
+// Perry miscompilation where obj.field reads feeding f64 FFI args arrive as NaN.
+export function drawTextureProRaw(
+  textureId: number,
+  sx: number, sy: number, sw: number, sh: number,
+  dx: number, dy: number, dw: number, dh: number,
+  ox: number, oy: number, rotation: number,
+  r: number, g: number, b: number, a: number,
+): void {
+  bloom_draw_texture_pro(textureId, sx, sy, sw, sh, dx, dy, dw, dh, ox, oy, rotation, r, g, b, a);
+}
+
+export function getTextureWidth(texture: Texture): number {
+  return texture.width;
+}
+
+export function getTextureHeight(texture: Texture): number {
+  return texture.height;
+}
+
+export function loadImage(path: string): number {
+  return bloom_load_image(path as any);
+}
+
+export function imageResize(imageHandle: number, width: number, height: number): void {
+  bloom_image_resize(imageHandle, width, height);
+}
+
+export function imageCrop(imageHandle: number, x: number, y: number, width: number, height: number): void {
+  bloom_image_crop(imageHandle, x, y, width, height);
+}
+
+export function imageFlipH(imageHandle: number): void {
+  bloom_image_flip_h(imageHandle);
+}
+
+export function imageFlipV(imageHandle: number): void {
+  bloom_image_flip_v(imageHandle);
+}
+
+export function loadTextureFromImage(imageHandle: number): Texture {
+  const id = bloom_load_texture_from_image(imageHandle);
+  const width = bloom_get_texture_width(id);
+  const height = bloom_get_texture_height(id);
+  return { handle: id, width, height };
+}
+
+export function genTextureMipmaps(texture: Texture): void {
+  bloom_gen_texture_mipmaps(texture.handle);
+}
+
+// Async / threaded loading
+
+declare function bloom_stage_texture(path: number): number;
+declare function bloom_commit_texture(handle: number): number;
+declare function bloom_load_render_texture(width: number, height: number): number;
+declare function bloom_unload_render_texture(handle: number): void;
+declare function bloom_begin_texture_mode(handle: number): void;
+declare function bloom_end_texture_mode(): void;
+declare function bloom_get_render_texture_texture(handle: number): number;
+
+export async function loadTextureAsync(path: string): Promise<Texture> {
+  const stagingHandle = await spawn(() => bloom_stage_texture(path as any));
+  const id = bloom_commit_texture(stagingHandle);
+  const width = bloom_get_texture_width(id);
+  const height = bloom_get_texture_height(id);
+  return { handle: id, width, height };
+}
+
+export function stageTextures(paths: string[]): number[] {
+  return parallelMap(paths, (path: string) => bloom_stage_texture(path as any));
+}
+
+export function commitTexture(stagingHandle: number): Texture {
+  const id = bloom_commit_texture(stagingHandle);
+  const width = bloom_get_texture_width(id);
+  const height = bloom_get_texture_height(id);
+  return { handle: id, width, height };
+}
+
+// ============================================================
+// Q1: Offscreen Render Targets
+// ============================================================
+
+/**
+ * Create an offscreen render texture. Rendering commands between
+ * beginTextureMode and endTextureMode draw into this texture instead
+ * of the screen. Use getRenderTextureTexture to get a Texture for
+ * drawing the result via drawTexture.
+ *
+ * NOTE: GPU implementation is a stub in this version. The FFI surface
+ * is stable; the actual render-to-texture plumbing will land in a
+ * focused GPU session.
+ */
+export function loadRenderTexture(width: number, height: number): number {
+  return bloom_load_render_texture(width, height);
+}
+
+export function unloadRenderTexture(handle: number): void {
+  bloom_unload_render_texture(handle);
+}
+
+export function beginTextureMode(handle: number): void {
+  bloom_begin_texture_mode(handle);
+}
+
+export function endTextureMode(): void {
+  bloom_end_texture_mode();
+}
+
+export function getRenderTextureTexture(handle: number): Texture {
+  // `handle`, not `id` — Texture renamed the field in v0.5 and this function
+  // was never migrated. Every draw call reads texture.handle, so the old
+  // `{ id }` shape fed `undefined` into a native f64 param the first time
+  // anyone drew a render texture (nobody had, until editor thumbnails).
+  // Width/height are 0 because the FFI only returns the texture id; callers
+  // pass explicit source rects.
+  const id = bloom_get_render_texture_texture(handle);
+  return { handle: id, width: 0, height: 0 };
+}

package/src/vfx/index.ts

@@ -0,0 +1,191 @@
+// EN-026 particles + EN-027 decals.
+//
+// Both are engine-simulated and game-drawn. You supply the material (so the
+// look stays authorable in WGSL) and the quad mesh; the engine owns the pool
+// and rewrites a dynamic instance buffer every frame. Per-frame FFI traffic is
+// therefore one `update` + one `draw` per system, regardless of how many
+// thousand particles are live.
+//
+// The instanced vertex shader receives, per instance:
+//
+//   @location(7)  instance_pos:   vec3<f32>   world position
+//   @location(8)  instance_rot_y: f32         roll (particles) / roll about
+//                                             the surface normal (decals)
+//   @location(9)  instance_scale: f32         size in metres
+//   @location(10) instance_tint:  vec4<f32>   rgba, alpha already faded
+//   @location(11) instance_extra: vec3<f32>   particles: (age01, frame, stretch)
+//                                             decals:    (frame, azimuth, elevation)
+//
+// For decals the normal is packed as two angles, so reconstruct it with:
+//   let n = vec3(sin(el)*cos(az), cos(el), sin(el)*sin(az));
+
+declare function bloom_particles_create(capacity: number): number;
+declare function bloom_particles_configure(sys: number): void;
+declare function bloom_particles_emit(sys: number, x: number, y: number, z: number, dx: number, dy: number, dz: number, count: number): void;
+declare function bloom_particles_update(sys: number, dt: number): number;
+declare function bloom_particles_instance_buffer(sys: number): number;
+declare function bloom_particles_clear(sys: number): void;
+declare function bloom_particles_live(sys: number): number;
+
+declare function bloom_decals_init(capacity: number): number;
+declare function bloom_decals_spawn(x: number, y: number, z: number, nx: number, ny: number, nz: number, size: number, roll: number): void;
+declare function bloom_decals_set_style(frame: number, r: number, g: number, b: number, a: number, life: number, fade: number): void;
+declare function bloom_decals_update(dt: number): number;
+declare function bloom_decals_instance_buffer(): number;
+declare function bloom_decals_clear(): void;
+
+declare function bloom_mesh_scratch_reset(): void;
+declare function bloom_mesh_scratch_push_f32(v: number): void;
+
+/// How one system's particles are born, move and look. Every field has a
+/// sane default; pass only what you care about.
+export interface ParticleConfig {
+  /// Seconds. `lifeVar` jitters it symmetrically.
+  life?: number;
+  lifeVar?: number;
+  /// Initial speed along the emit direction, m/s.
+  speed?: number;
+  speedVar?: number;
+  /// Half-angle of the emission cone, radians. Emitting with a zero direction
+  /// ignores this and sprays into the full sphere.
+  spread?: number;
+  /// Constant acceleration, m/s². Default is real gravity.
+  gravity?: number;
+  /// Linear drag per second. Smoke wants ~2; a spark wants ~0.
+  drag?: number;
+  /// Size in metres at birth and at death — smoke grows, sparks shrink.
+  size0?: number;
+  size1?: number;
+  sizeVar?: number;
+  /// Colour at birth and at death. Put the fade-out in `color1`'s alpha.
+  color0?: [number, number, number, number];
+  color1?: [number, number, number, number];
+  /// Billboard roll, rad/s.
+  spin?: number;
+  spinVar?: number;
+  /// Spawn jitter radius, metres.
+  posJitter?: number;
+  /// > 0 stretches the quad along velocity by this many seconds of travel.
+  /// This is the difference between a round spark and a tracer streak.
+  stretch?: number;
+  /// Fraction of emitter velocity inherited (reserved; the emitter is
+  /// stateless today).
+  inherit?: number;
+  /// Atlas frames. The shader gets a frame index in `extra.y`.
+  frames?: number;
+  /// Bounce plane. `restitution` <= 0 (the default) means no collision;
+  /// shells want ~0.35 so they clatter instead of sinking.
+  floorY?: number;
+  restitution?: number;
+}
+
+/// Allocate a pool. One system per *look* (smoke, sparks, blood) — each wants
+/// its own material and blend bucket anyway, and one draw per look is cheap.
+export function createParticleSystem(capacity: number, cfg: ParticleConfig): number {
+  const sys = bloom_particles_create(capacity);
+  if (sys > 0) configureParticleSystem(sys, cfg);
+  return sys;
+}
+
+/// Re-tune a system at runtime. Config crosses via the mesh scratch (Perry
+/// rejects JS arrays in pointer params); it is a startup-shaped call, not a
+/// per-frame one.
+export function configureParticleSystem(sys: number, cfg: ParticleConfig): void {
+  const c0 = cfg.color0 !== undefined ? cfg.color0 : [1, 1, 1, 1];
+  const c1 = cfg.color1 !== undefined ? cfg.color1 : [1, 1, 1, 0];
+  const p: number[] = new Array<number>(26);
+  p[0]  = cfg.life !== undefined ? cfg.life : 1.0;
+  p[1]  = cfg.lifeVar !== undefined ? cfg.lifeVar : 0.0;
+  p[2]  = cfg.speed !== undefined ? cfg.speed : 1.0;
+  p[3]  = cfg.speedVar !== undefined ? cfg.speedVar : 0.0;
+  p[4]  = cfg.spread !== undefined ? cfg.spread : 0.3;
+  p[5]  = cfg.gravity !== undefined ? cfg.gravity : -9.81;
+  p[6]  = cfg.drag !== undefined ? cfg.drag : 0.0;
+  p[7]  = cfg.size0 !== undefined ? cfg.size0 : 0.2;
+  p[8]  = cfg.size1 !== undefined ? cfg.size1 : 0.2;
+  p[9]  = cfg.sizeVar !== undefined ? cfg.sizeVar : 0.0;
+  p[10] = c0[0]; p[11] = c0[1]; p[12] = c0[2]; p[13] = c0[3];
+  p[14] = c1[0]; p[15] = c1[1]; p[16] = c1[2]; p[17] = c1[3];
+  p[18] = cfg.spin !== undefined ? cfg.spin : 0.0;
+  p[19] = cfg.spinVar !== undefined ? cfg.spinVar : 0.0;
+  p[20] = cfg.posJitter !== undefined ? cfg.posJitter : 0.0;
+  p[21] = cfg.stretch !== undefined ? cfg.stretch : 0.0;
+  p[22] = cfg.inherit !== undefined ? cfg.inherit : 0.0;
+  p[23] = cfg.frames !== undefined ? cfg.frames : 1.0;
+  p[24] = cfg.floorY !== undefined ? cfg.floorY : 0.0;
+  p[25] = cfg.restitution !== undefined ? cfg.restitution : 0.0;
+
+  bloom_mesh_scratch_reset();
+  for (let i = 0; i < 26; i++) bloom_mesh_scratch_push_f32(p[i]);
+  bloom_particles_configure(sys);
+}
+
+/// Spawn a burst. `dir` biases the cone — pass a surface normal for an impact,
+/// or (0,0,0) for an omnidirectional pop.
+export function emitParticles(
+  sys: number,
+  x: number, y: number, z: number,
+  dx: number, dy: number, dz: number,
+  count: number,
+): void {
+  bloom_particles_emit(sys, x, y, z, dx, dy, dz, count);
+}
+
+/// Integrate + upload. Returns the live count — pass it straight to
+/// `drawMeshWithMaterialInstanced` as the instance count.
+export function updateParticles(sys: number, dt: number): number {
+  return bloom_particles_update(sys, dt);
+}
+
+export function particleInstanceBuffer(sys: number): number {
+  return bloom_particles_instance_buffer(sys);
+}
+
+export function clearParticles(sys: number): void {
+  bloom_particles_clear(sys);
+}
+
+export function particleCount(sys: number): number {
+  return bloom_particles_live(sys);
+}
+
+// ---- Decals -----------------------------------------------------------------
+
+/// Allocate the decal ring. One ring for the whole game: decals are all the
+/// same draw (an oriented quad against an atlas), so they share a buffer and
+/// the style selects which atlas cell a given spawn uses.
+export function initDecals(capacity: number): number {
+  return bloom_decals_init(capacity);
+}
+
+/// Look + lifetime of subsequent `spawnDecal` calls. `life <= 0` = permanent
+/// (until the ring wraps); `fade` is how many trailing seconds it fades over.
+export function setDecalStyle(
+  frame: number,
+  r: number, g: number, b: number, a: number,
+  life: number, fade: number,
+): void {
+  bloom_decals_set_style(frame, r, g, b, a, life, fade);
+}
+
+/// Stick a decal to a surface. `n` is the surface normal (from your raycast);
+/// `roll` spins it about that normal so repeated hits don't look stamped.
+export function spawnDecal(
+  x: number, y: number, z: number,
+  nx: number, ny: number, nz: number,
+  size: number, roll: number,
+): void {
+  bloom_decals_spawn(x, y, z, nx, ny, nz, size, roll);
+}
+
+export function updateDecals(dt: number): number {
+  return bloom_decals_update(dt);
+}
+
+export function decalInstanceBuffer(): number {
+  return bloom_decals_instance_buffer();
+}
+
+export function clearDecals(): void {
+  bloom_decals_clear();
+}

package/src/world/index.ts

@@ -0,0 +1,24 @@
+// Bloom shared world module.
+//
+// Defines the on-disk world/prefab schema that the Bloom world editor writes
+// and every Bloom game reads. Games and the editor both import from this
+// module via `import { ... } from 'bloom/world'`.
+//
+// Files:
+//   - types.ts      schema interfaces (WorldData, PrefabData, ...)
+//   - version.ts    schema version + migration
+//   - validate.ts   runtime schema validation
+//   - loader.ts     loadWorld / instantiateWorld (reads JSON, spawns scene nodes)
+//   - render.ts     spawnWaterVolume / spawnRiver (shared by games + editor)
+//   - saver.ts      saveWorld / savePrefab (writes JSON)
+//   - prefab.ts     loadPrefab / expandPrefab / cycle detection
+//   - terrain.ts    buildHeightmapMesh / sampleHeight / raycastTerrain / defaultTerrain
+
+export * from './types';
+export * from './version';
+export * from './validate';
+export * from './loader';
+export * from './render';
+export * from './saver';
+export * from './prefab';
+export * from './terrain';