@flare-engine/render 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1092 @@
+// src/draw-order.ts
+function sortByDrawOrder(items, length) {
+  const n = length ?? items.length;
+  for (let i = 1; i < n; i++) {
+    const item = items[i];
+    let j = i - 1;
+    while (j >= 0 && items[j].z > item.z) {
+      items[j + 1] = items[j];
+      j--;
+    }
+    items[j + 1] = item;
+  }
+  return items;
+}
+function drawOrderCompare(a, b) {
+  return a.z - b.z;
+}
+
+// src/camera2d.ts
+function pseudoRandom(seed) {
+  const x = Math.sin(seed * 12.9898 + seed * 78.233) * 43758.5453;
+  return x - Math.floor(x);
+}
+var PERM = new Uint8Array(256);
+{
+  for (let i = 0; i < 256; i++) PERM[i] = i;
+  let s = 2654435769;
+  for (let i = 255; i > 0; i--) {
+    s = (s ^ s >>> 15) >>> 0;
+    s = Math.imul(s, 2246822507) >>> 0;
+    s = (s ^ s >>> 13) >>> 0;
+    const j = s % (i + 1);
+    const t = PERM[i];
+    PERM[i] = PERM[j];
+    PERM[j] = t;
+  }
+}
+var S = Math.SQRT1_2;
+var GRADS = [
+  [1, 0],
+  [S, S],
+  [0, 1],
+  [-S, S],
+  [-1, 0],
+  [-S, -S],
+  [0, -1],
+  [S, -S]
+];
+function grad2(hash, x, y) {
+  const g = GRADS[hash & 7];
+  return g[0] * x + g[1] * y;
+}
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function noise2d(x, y) {
+  const xi = Math.floor(x) & 255;
+  const yi = Math.floor(y) & 255;
+  const xf = x - Math.floor(x);
+  const yf = y - Math.floor(y);
+  const u = fade(xf);
+  const v = fade(yf);
+  const aa = PERM[PERM[xi] + yi];
+  const ab = PERM[PERM[xi] + yi + 1];
+  const ba = PERM[PERM[xi + 1 & 255] + yi];
+  const bb = PERM[PERM[xi + 1 & 255] + yi + 1];
+  const x1 = xf;
+  const y1 = yf;
+  const x2 = xf - 1;
+  const y2 = yf - 1;
+  const n00 = grad2(aa, x1, y1);
+  const n10 = grad2(ba, x2, y1);
+  const n01 = grad2(ab, x1, y2);
+  const n11 = grad2(bb, x2, y2);
+  const lerpX0 = n00 + u * (n10 - n00);
+  const lerpX1 = n01 + u * (n11 - n01);
+  return lerpX0 + v * (lerpX1 - lerpX0);
+}
+function fbmNoise2d(x, y) {
+  return 0.6667 * noise2d(x, y) + 0.3333 * noise2d(x * 2, y * 2);
+}
+var Camera2D = class {
+  /** Camera position (world-space center). */
+  x = 0;
+  y = 0;
+  /** Zoom level (1 = 100%). */
+  zoom = 1;
+  /** Rotation in radians. */
+  rotation = 0;
+  /** Viewport width in pixels. */
+  viewportWidth = 0;
+  /** Viewport height in pixels. */
+  viewportHeight = 0;
+  /** Optional world bounds to clamp camera position. */
+  bounds = null;
+  _follow = null;
+  _shake = null;
+  _shakePerlin = null;
+  _shakeSeed = 0;
+  _shakePerlinSeed = 0;
+  _motionScale = 1;
+  /** Set viewport dimensions. */
+  setViewport(width, height) {
+    this.viewportWidth = width;
+    this.viewportHeight = height;
+  }
+  /** Start following a target position. */
+  follow(target, options) {
+    this._follow = { target, options: options ?? {} };
+  }
+  /** Stop following. */
+  unfollow() {
+    this._follow = null;
+  }
+  /**
+   * Global motion multiplier applied to subsequent `shake()` calls. Scales
+   * both amplitude and duration. Default 1 (no-op). 0 fully suppresses
+   * shake. Intended to be driven by `@flare-engine/a11y` reduced-motion so
+   * callers don't have to guard every shake site.
+   *
+   * Only affects future `shake()` calls — does not retroactively modify an
+   * in-flight shake.
+   *
+   * Clamped to `>= 0`.
+   */
+  setMotionScale(scale) {
+    this._motionScale = scale < 0 ? 0 : scale;
+  }
+  /** Current motion scale (default 1). */
+  get motionScale() {
+    return this._motionScale;
+  }
+  /** Start camera shake. */
+  shake(intensity, duration) {
+    const k = this._motionScale;
+    if (k <= 0) {
+      this._shake = null;
+      return;
+    }
+    this._shake = {
+      intensity: intensity * k,
+      duration: duration * k,
+      elapsed: 0,
+      offsetX: 0,
+      offsetY: 0
+    };
+    this._shakeSeed++;
+  }
+  /**
+   * Start a Perlin-noise-based camera shake. Overwrites any in-flight
+   * shakePerlin (same semantics as shake()). Respects motionScale.
+   */
+  shakePerlin(intensity, duration) {
+    const k = this._motionScale;
+    if (k <= 0) {
+      this._shakePerlin = null;
+      return;
+    }
+    this._shakePerlin = {
+      intensity: intensity * k,
+      duration: duration * k,
+      elapsed: 0,
+      offsetX: 0,
+      offsetY: 0
+    };
+    this._shakePerlinSeed++;
+  }
+  /**
+   * Update camera. Call once per frame.
+   * @param dt Delta time in seconds.
+   */
+  update(dt) {
+    if (this._follow) {
+      const { target, options } = this._follow;
+      const smoothing = options.smoothing ?? 0.1;
+      const offsetX = options.offset?.x ?? 0;
+      const offsetY = options.offset?.y ?? 0;
+      const goalX = target.x + offsetX;
+      const goalY = target.y + offsetY;
+      if (options.deadZone) {
+        const dz = options.deadZone;
+        const relX = target.x - this.x;
+        const relY = target.y - this.y;
+        if (relX < dz.x) {
+          this.x += (goalX - this.x - (dz.x - relX)) * (1 - smoothing ** dt);
+        } else if (relX > dz.x + dz.width) {
+          this.x += (goalX - this.x + (relX - dz.x - dz.width)) * (1 - smoothing ** dt);
+        }
+        if (relY < dz.y) {
+          this.y += (goalY - this.y - (dz.y - relY)) * (1 - smoothing ** dt);
+        } else if (relY > dz.y + dz.height) {
+          this.y += (goalY - this.y + (relY - dz.y - dz.height)) * (1 - smoothing ** dt);
+        }
+      } else {
+        const factor = 1 - smoothing ** dt;
+        this.x += (goalX - this.x) * factor;
+        this.y += (goalY - this.y) * factor;
+      }
+    }
+    if (this.bounds) {
+      this._clampToBounds();
+    }
+    if (this._shake) {
+      this._shake.elapsed += dt;
+      if (this._shake.elapsed >= this._shake.duration) {
+        this._shake = null;
+      } else {
+        const progress = this._shake.elapsed / this._shake.duration;
+        const decay = 1 - progress;
+        const seed = this._shakeSeed + this._shake.elapsed * 100;
+        this._shake.offsetX = (pseudoRandom(seed) * 2 - 1) * this._shake.intensity * decay;
+        this._shake.offsetY = (pseudoRandom(seed + 1) * 2 - 1) * this._shake.intensity * decay;
+      }
+    }
+    if (this._shakePerlin) {
+      this._shakePerlin.elapsed += dt;
+      if (this._shakePerlin.elapsed >= this._shakePerlin.duration) {
+        this._shakePerlin = null;
+      } else {
+        const progress = this._shakePerlin.elapsed / this._shakePerlin.duration;
+        const decay = 1 - progress;
+        const t = this._shakePerlin.elapsed * 4.7 + this._shakePerlinSeed * 17.3;
+        this._shakePerlin.offsetX = fbmNoise2d(t, 0) * this._shakePerlin.intensity * decay;
+        this._shakePerlin.offsetY = fbmNoise2d(0, t + 5.4) * this._shakePerlin.intensity * decay;
+      }
+    }
+  }
+  /** Get the effective camera X (including shake + shakePerlin offsets). */
+  get effectiveX() {
+    return this.x + (this._shake?.offsetX ?? 0) + (this._shakePerlin?.offsetX ?? 0);
+  }
+  /** Get the effective camera Y (including shake + shakePerlin offsets). */
+  get effectiveY() {
+    return this.y + (this._shake?.offsetY ?? 0) + (this._shakePerlin?.offsetY ?? 0);
+  }
+  /** Convert world coordinates to screen coordinates. */
+  worldToScreen(worldX, worldY) {
+    return this.worldToScreenInto(worldX, worldY, { x: 0, y: 0 });
+  }
+  /** Zero-alloc variant — writes screen coordinates into `out`. */
+  worldToScreenInto(worldX, worldY, out) {
+    const cos = Math.cos(-this.rotation);
+    const sin = Math.sin(-this.rotation);
+    const dx = (worldX - this.effectiveX) * this.zoom;
+    const dy = (worldY - this.effectiveY) * this.zoom;
+    out.x = cos * dx - sin * dy + this.viewportWidth / 2;
+    out.y = sin * dx + cos * dy + this.viewportHeight / 2;
+    return out;
+  }
+  /** Convert screen coordinates to world coordinates. */
+  screenToWorld(screenX, screenY) {
+    return this.screenToWorldInto(screenX, screenY, { x: 0, y: 0 });
+  }
+  /** Zero-alloc variant — writes world coordinates into `out`. */
+  screenToWorldInto(screenX, screenY, out) {
+    const cx = screenX - this.viewportWidth / 2;
+    const cy = screenY - this.viewportHeight / 2;
+    const cos = Math.cos(this.rotation);
+    const sin = Math.sin(this.rotation);
+    const rx = cos * cx - sin * cy;
+    const ry = sin * cx + cos * cy;
+    out.x = rx / this.zoom + this.effectiveX;
+    out.y = ry / this.zoom + this.effectiveY;
+    return out;
+  }
+  /** Get the visible world-space bounding rect (allocates a fresh Rect). */
+  getBounds() {
+    return this.getBoundsInto({ x: 0, y: 0, width: 0, height: 0 });
+  }
+  /** Zero-alloc variant — writes the visible bounds into `out`. */
+  getBoundsInto(out) {
+    const halfW = this.viewportWidth / (2 * this.zoom);
+    const halfH = this.viewportHeight / (2 * this.zoom);
+    out.x = this.effectiveX - halfW;
+    out.y = this.effectiveY - halfH;
+    out.width = halfW * 2;
+    out.height = halfH * 2;
+    return out;
+  }
+  _clampToBounds() {
+    const b = this.bounds;
+    const halfW = this.viewportWidth / (2 * this.zoom);
+    const halfH = this.viewportHeight / (2 * this.zoom);
+    const minX = b.x + halfW;
+    const maxX = b.x + b.width - halfW;
+    const minY = b.y + halfH;
+    const maxY = b.y + b.height - halfH;
+    if (minX <= maxX) {
+      this.x = Math.max(minX, Math.min(maxX, this.x));
+    } else {
+      this.x = b.x + b.width / 2;
+    }
+    if (minY <= maxY) {
+      this.y = Math.max(minY, Math.min(maxY, this.y));
+    } else {
+      this.y = b.y + b.height / 2;
+    }
+  }
+};
+
+// src/renderer.ts
+var Renderer = class {
+  /** Current frame stats. */
+  stats = { drawCalls: 0, batchCount: 0 };
+  _canvas = null;
+  _inFrame = false;
+  /** Set the canvas to render to. Called once when canvas is available. */
+  setCanvas(canvas) {
+    this._canvas = canvas;
+  }
+  /** Get the current canvas. Throws if not in a frame. */
+  get canvas() {
+    if (!this._canvas) {
+      throw new Error("Renderer: no canvas set");
+    }
+    return this._canvas;
+  }
+  /** Whether we are currently between begin() and end(). */
+  get inFrame() {
+    return this._inFrame;
+  }
+  /**
+   * Begin a new frame. Clears the canvas and resets stats.
+   * @param clearColor 32-bit ARGB color to clear with (default black = 0xFF000000).
+   */
+  begin(clearColor = 4278190080) {
+    if (this._inFrame) {
+      throw new Error("Renderer: begin() called while already in frame");
+    }
+    this._inFrame = true;
+    this.stats.drawCalls = 0;
+    this.stats.batchCount = 0;
+    this.canvas.save();
+    this.canvas.clear(clearColor);
+  }
+  /**
+   * End the current frame. Restores canvas state.
+   */
+  end() {
+    if (!this._inFrame) {
+      throw new Error("Renderer: end() called without begin()");
+    }
+    this.canvas.restore();
+    this._inFrame = false;
+  }
+  /**
+   * Apply camera transform to the canvas.
+   * Call after begin() and before drawing.
+   */
+  applyCamera(cameraX, cameraY, zoom, rotation, viewportWidth, viewportHeight) {
+    const c = this.canvas;
+    c.translate(viewportWidth / 2, viewportHeight / 2);
+    c.scale(zoom, zoom);
+    if (rotation !== 0) {
+      c.rotate(-rotation, 0, 0);
+    }
+    c.translate(-cameraX, -cameraY);
+  }
+  /** Increment draw call counter. Called by batching systems. */
+  recordDrawCall() {
+    this.stats.drawCalls++;
+  }
+  /** Increment batch counter. */
+  recordBatch() {
+    this.stats.batchCount++;
+  }
+};
+
+// src/sprite-batch.ts
+var SpriteBatch = class {
+  _commands = [];
+  _pool = [];
+  _batches = [];
+  /** Number of queued draw commands. */
+  get count() {
+    return this._commands.length;
+  }
+  /** Queue a sprite draw from a frame.
+   *
+   *  `anchorX` / `anchorY` define the pivot point of the sprite as a
+   *  fraction of its destination size — `(0, 0)` = top-left (default),
+   *  `(0.5, 0.5)` = center, `(1, 1)` = bottom-right. `dstX` / `dstY`
+   *  then refer to the anchor point instead of the top-left corner.
+   *
+   *  `alpha` is a per-instance opacity multiplier in [0, 1]. Default 1. */
+  draw(image, frame, dstX, dstY, dstW, dstH, effect, anchorX = 0, anchorY = 0, alpha = 1, rotation = 0, stretch = false) {
+    const cmd = this._acquire();
+    const w = dstW ?? frame.w;
+    const h = dstH ?? frame.h;
+    cmd.image = image;
+    cmd.srcX = frame.x;
+    cmd.srcY = frame.y;
+    cmd.srcW = frame.w;
+    cmd.srcH = frame.h;
+    cmd.dstX = dstX - anchorX * w;
+    cmd.dstY = dstY - anchorY * h;
+    cmd.dstW = w;
+    cmd.dstH = h;
+    cmd.effect = effect;
+    cmd.alpha = alpha;
+    cmd.rotation = rotation;
+    cmd.anchorX = anchorX;
+    cmd.anchorY = anchorY;
+    cmd.stretch = stretch;
+    this._commands.push(cmd);
+  }
+  /** Queue a raw sprite draw with explicit src/dst rects. `dstX` / `dstY`
+   *  refer to the anchor point — offset by `anchorX * dstW` / `anchorY * dstH`.
+   *
+   *  `alpha` is a per-instance opacity multiplier in [0, 1]. Default 1. */
+  drawRaw(image, srcX, srcY, srcW, srcH, dstX, dstY, dstW, dstH, effect, anchorX = 0, anchorY = 0, alpha = 1, rotation = 0, stretch = false) {
+    const cmd = this._acquire();
+    cmd.image = image;
+    cmd.srcX = srcX;
+    cmd.srcY = srcY;
+    cmd.srcW = srcW;
+    cmd.srcH = srcH;
+    cmd.dstX = dstX - anchorX * dstW;
+    cmd.dstY = dstY - anchorY * dstH;
+    cmd.dstW = dstW;
+    cmd.dstH = dstH;
+    cmd.effect = effect;
+    cmd.alpha = alpha;
+    cmd.rotation = rotation;
+    cmd.anchorX = anchorX;
+    cmd.anchorY = anchorY;
+    cmd.stretch = stretch;
+    this._commands.push(cmd);
+  }
+  /**
+   * Flush all queued commands, grouped by (texture, effect, alpha) identity.
+   *
+   * @param drawAtlas Callback invoked once per batch. Receives
+   *   `(image, commands)` — all commands in a batch share the same texture,
+   *   the same effect (readable from `commands[0].effect`), and the same
+   *   alpha (readable from `commands[0].alpha`).
+   * @param renderer Optional renderer to record stats.
+   */
+  flush(drawAtlas, renderer) {
+    if (this._commands.length === 0) return;
+    const batches = this._batches;
+    for (const cmd of this._commands) {
+      let batch;
+      for (let i = 0; i < batches.length; i++) {
+        const b = batches[i];
+        if (b.image === cmd.image && b.effect === cmd.effect && b.alpha === cmd.alpha) {
+          batch = b;
+          break;
+        }
+      }
+      if (!batch) {
+        batch = { image: cmd.image, effect: cmd.effect, alpha: cmd.alpha, commands: [] };
+        batches.push(batch);
+      }
+      batch.commands.push(cmd);
+    }
+    for (let i = 0; i < batches.length; i++) {
+      const batch = batches[i];
+      drawAtlas(batch.image, batch.commands);
+      if (renderer) {
+        renderer.recordDrawCall();
+        renderer.recordBatch();
+      }
+    }
+    for (const cmd of this._commands) {
+      this._pool.push(cmd);
+    }
+    this._commands.length = 0;
+    for (let i = 0; i < batches.length; i++) {
+      batches[i].commands.length = 0;
+    }
+    batches.length = 0;
+  }
+  /** Clear all queued commands without drawing. */
+  clear() {
+    for (const cmd of this._commands) {
+      this._pool.push(cmd);
+    }
+    this._commands.length = 0;
+  }
+  _acquire() {
+    if (this._pool.length > 0) {
+      return this._pool.pop();
+    }
+    return {
+      image: null,
+      srcX: 0,
+      srcY: 0,
+      srcW: 0,
+      srcH: 0,
+      dstX: 0,
+      dstY: 0,
+      dstW: 0,
+      dstH: 0,
+      effect: void 0,
+      alpha: 1,
+      rotation: 0,
+      anchorX: 0,
+      anchorY: 0,
+      stretch: false
+    };
+  }
+};
+
+// src/sprite-effects.ts
+function tint(color, amount) {
+  return { type: "tint", color, amount };
+}
+function flash(color, durationSec) {
+  return { type: "flash", color, duration: durationSec, elapsed: 0 };
+}
+function grayscale(amount) {
+  return { type: "grayscale", amount };
+}
+function outline(color, width) {
+  return { type: "outline", color, width };
+}
+function custom(shader, uniforms) {
+  return { type: "custom", shader, uniforms };
+}
+function water(color, foamColor, waveSpeed, waveAmplitude) {
+  return { type: "water", color, foamColor, waveSpeed, waveAmplitude };
+}
+function fog(color, density = 0.5, speed = 0.3, scale = 2) {
+  return { type: "fog", color, density, speed, scale };
+}
+function fire(opts) {
+  return {
+    type: "fire",
+    color: opts.color,
+    tipColor: opts.tipColor,
+    speed: opts.speed ?? 1,
+    intensity: opts.intensity ?? 0.8
+  };
+}
+function roofsCity(opts) {
+  return {
+    type: "roofs-city",
+    skyColor: opts.skyColor,
+    roofColor: opts.roofColor,
+    scrollOffsetY: opts.scrollOffsetY ?? 0,
+    density: opts.density ?? 6,
+    resolutionW: opts.resolutionW ?? 0,
+    resolutionH: opts.resolutionH ?? 0
+  };
+}
+function forestCanopy(opts) {
+  return {
+    type: "forest-canopy",
+    skyColor: opts.skyColor,
+    leafColor: opts.leafColor,
+    scrollOffsetY: opts.scrollOffsetY ?? 0,
+    density: opts.density ?? 5,
+    resolutionW: opts.resolutionW ?? 0,
+    resolutionH: opts.resolutionH ?? 0
+  };
+}
+function riverWave(opts) {
+  return {
+    type: "river-wave",
+    waterColor: opts.waterColor,
+    foamColor: opts.foamColor,
+    scrollOffsetY: opts.scrollOffsetY ?? 0,
+    waveScale: opts.waveScale ?? 2,
+    resolutionW: opts.resolutionW ?? 0,
+    resolutionH: opts.resolutionH ?? 0
+  };
+}
+function moonCrater(opts) {
+  return {
+    type: "moon-crater",
+    moonColor: opts.moonColor,
+    craterColor: opts.craterColor,
+    scrollOffsetY: opts.scrollOffsetY ?? 0,
+    craterCount: opts.craterCount ?? 4,
+    resolutionW: opts.resolutionW ?? 0,
+    resolutionH: opts.resolutionH ?? 0
+  };
+}
+function caveInterior(opts) {
+  return {
+    type: "cave-interior",
+    caveColor: opts.caveColor,
+    glowColor: opts.glowColor,
+    scrollOffsetY: opts.scrollOffsetY ?? 0,
+    stalactiteCount: opts.stalactiteCount ?? 8,
+    resolutionW: opts.resolutionW ?? 0,
+    resolutionH: opts.resolutionH ?? 0
+  };
+}
+function mountainHills(opts) {
+  return {
+    type: "mountain-hills",
+    skyColor: opts.skyColor,
+    hillColor: opts.hillColor,
+    scrollOffsetY: opts.scrollOffsetY ?? 0,
+    ridgeScale: opts.ridgeScale ?? 1.5,
+    resolutionW: opts.resolutionW ?? 0,
+    resolutionH: opts.resolutionH ?? 0
+  };
+}
+function updateEffect(effect, dt) {
+  if (effect.type === "flash") {
+    const elapsed = effect.elapsed + dt;
+    if (elapsed >= effect.duration) return null;
+    return { type: "flash", color: effect.color, duration: effect.duration, elapsed };
+  }
+  return effect;
+}
+function flashIntensity(effect) {
+  if (effect.duration <= 0) return 0;
+  const t = effect.elapsed / effect.duration;
+  return Math.max(0, 1 - t);
+}
+
+// src/shaders.ts
+var FIRE_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float3 color;
+uniform float3 tipColor;
+uniform float speed;
+uniform float intensity;
+uniform float time;
+
+float hash(float2 p) { return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); }
+
+float vnoise(float2 p) {
+  float2 i = floor(p);
+  float2 f = fract(p);
+  float2 u = f * f * (3.0 - 2.0 * f);
+  float a = hash(i);
+  float b = hash(i + float2(1.0, 0.0));
+  float c = hash(i + float2(0.0, 1.0));
+  float d = hash(i + float2(1.0, 1.0));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+float fbm(float2 p) {
+  return 0.5 * vnoise(p) + 0.25 * vnoise(p * 2.0);
+}
+
+half4 main(float2 coord) {
+  half4 srcColor = src.eval(coord);
+  float2 uv = coord / max(resolution, float2(1.0));
+  float2 np = float2(uv.x * 4.0, uv.y * 6.0 - time * speed * 2.0);
+  float n = fbm(np);
+  float flameMask = smoothstep(0.0, intensity, n * (1.0 - uv.y));
+  float3 fireRgb = mix(color, tipColor, uv.y);
+  half4 fireColor = half4(fireRgb.r, fireRgb.g, fireRgb.b, flameMask);
+  return half4(fireColor.rgb, fireColor.a * srcColor.a);
+}
+`
+);
+var FOG_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float3 color;
+uniform float density;
+uniform float speed;
+uniform float scale;
+uniform float time;
+
+float hash(float2 p) {
+  return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453);
+}
+
+float valueNoise(float2 p) {
+  float2 i = floor(p);
+  float2 f = fract(p);
+  float2 u = f * f * (3.0 - 2.0 * f);
+  float a = hash(i);
+  float b = hash(i + float2(1.0, 0.0));
+  float c = hash(i + float2(0.0, 1.0));
+  float d = hash(i + float2(1.0, 1.0));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+float fbm(float2 p) {
+  float value = 0.0;
+  float amplitude = 0.5;
+  for (int i = 0; i < 4; i++) {
+    value += amplitude * valueNoise(p);
+    p *= 2.0;
+    amplitude *= 0.5;
+  }
+  return value;
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  float2 drift = float2(time * speed, 0.3 * time * speed);
+  float n = clamp(fbm(uv * scale + drift), 0.0, 1.0);
+  half4 srcColor = src.eval(coord);
+  half3 blended = mix(srcColor.rgb, half3(color.r, color.g, color.b), half(density * n));
+  return half4(blended, srcColor.a);
+}
+`
+);
+var WATER_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float3 color;
+uniform float3 foamColor;
+uniform float waveSpeed;
+uniform float waveAmplitude;
+uniform float time;
+
+half4 main(float2 coord) {
+  float2 uv = coord / resolution;
+  float wave1 = sin(uv.x * 6.2832 * 3.0 + time * waveSpeed * 2.0) * waveAmplitude;
+  float wave2 = sin(uv.x * 6.2832 * 5.0 - time * waveSpeed * 1.3 + 1.5) * waveAmplitude * 0.5;
+  float totalWave = wave1 + wave2;
+  float2 displaced = float2(uv.x, uv.y + totalWave);
+  displaced = clamp(displaced, float2(0.0), float2(1.0));
+  half4 c = src.eval(displaced * resolution);
+  float waveDeriv = cos(uv.x * 6.2832 * 3.0 + time * waveSpeed * 2.0) * waveAmplitude * 2.0
+                  + cos(uv.x * 6.2832 * 5.0 - time * waveSpeed * 1.3 + 1.5) * waveAmplitude;
+  float foam = smoothstep(waveAmplitude * 0.6, waveAmplitude * 1.5, waveDeriv);
+  half3 tinted = mix(c.rgb, half3(color.r, color.g, color.b), half(0.35));
+  half3 final = mix(tinted, half3(foamColor.r, foamColor.g, foamColor.b), half(foam));
+  return half4(final, c.a);
+}
+`
+);
+var ROOFS_CITY_SKSL = (
+  /* sksl */
+  `
+uniform float2 resolution;
+uniform float3 skyColor;
+uniform float3 roofColor;
+uniform float scrollOffsetY;
+uniform float density;
+
+float hash(float x) { return fract(sin(x * 127.1) * 43758.5453); }
+
+float buildingTop(float2 uv, float density) {
+  float col = floor(uv.x * density);
+  float h = 0.35 + 0.35 * hash(col);
+  float w = 0.6 + 0.3 * hash(col + 7.3);
+  float edge = step(abs(fract(uv.x * density) - 0.5), w * 0.5);
+  return edge * step(uv.y, h);
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  uv.y = uv.y + scrollOffsetY / max(resolution.y, 1.0);
+  uv.y = fract(uv.y);
+  float buildings = buildingTop(uv, density);
+  half3 col = mix(half3(skyColor.r, skyColor.g, skyColor.b),
+                  half3(roofColor.r, roofColor.g, roofColor.b),
+                  half(buildings));
+  return half4(col, 1.0);
+}
+`
+);
+var FOREST_CANOPY_SKSL = (
+  /* sksl */
+  `
+uniform float2 resolution;
+uniform float3 skyColor;
+uniform float3 leafColor;
+uniform float scrollOffsetY;
+uniform float density;
+
+float hash(float2 p) { return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); }
+
+float valueNoise(float2 p) {
+  float2 i = floor(p);
+  float2 f = fract(p);
+  float2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash(i), hash(i + float2(1.0, 0.0)), u.x),
+             mix(hash(i + float2(0.0, 1.0)), hash(i + float2(1.0, 1.0)), u.x), u.y);
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  uv.y = uv.y + scrollOffsetY / max(resolution.y, 1.0);
+  float n = valueNoise(float2(uv.x * density, uv.y * 3.0));
+  float treeLine = 0.55 + 0.25 * valueNoise(float2(uv.x * density * 0.5, 0.0));
+  float canopy = step(uv.y, treeLine) * smoothstep(0.3, 0.7, n);
+  half3 col = mix(half3(skyColor.r, skyColor.g, skyColor.b),
+                  half3(leafColor.r, leafColor.g, leafColor.b),
+                  half(canopy));
+  return half4(col, 1.0);
+}
+`
+);
+var RIVER_WAVE_SKSL = (
+  /* sksl */
+  `
+uniform float2 resolution;
+uniform float3 waterColor;
+uniform float3 foamColor;
+uniform float scrollOffsetY;
+uniform float waveScale;
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  float scroll = scrollOffsetY / max(resolution.y, 1.0);
+  float2 p = float2(uv.x, uv.y + scroll);
+  float w1 = sin(p.x * 6.2832 * waveScale + p.y * 4.0) * 0.04;
+  float w2 = sin(p.x * 6.2832 * waveScale * 1.7 - p.y * 2.5 + 1.2) * 0.02;
+  float surface = 0.5 + w1 + w2;
+  float inWater = step(uv.y, surface);
+  float crest = smoothstep(surface - 0.015, surface, uv.y) * (1.0 - inWater) +
+                smoothstep(surface + 0.015, surface, uv.y) * inWater;
+  half3 base = mix(half3(foamColor.r, foamColor.g, foamColor.b),
+                   half3(waterColor.r, waterColor.g, waterColor.b),
+                   half(inWater));
+  half3 col = mix(base, half3(foamColor.r, foamColor.g, foamColor.b), half(crest * 0.6));
+  return half4(col, 1.0);
+}
+`
+);
+var MOON_CRATER_SKSL = (
+  /* sksl */
+  `
+uniform float2 resolution;
+uniform float3 moonColor;
+uniform float3 craterColor;
+uniform float scrollOffsetY;
+uniform float craterCount;
+
+float hash(float2 p) { return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); }
+
+float crater(float2 uv, float2 center, float r) {
+  float d = length(uv - center);
+  float rim = smoothstep(r, r * 0.85, d) - smoothstep(r * 0.85, r * 0.65, d);
+  float floor_ = smoothstep(r * 0.65, r * 0.4, d);
+  return rim * 0.6 + floor_ * 0.25;
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  uv.y = uv.y + scrollOffsetY / max(resolution.y, 1.0);
+  float c = 0.0;
+  for (int i = 0; i < 6; i++) {
+    float fi = float(i);
+    float2 center = float2(hash(float2(fi, 0.0)), hash(float2(fi, 1.0)));
+    float r = 0.04 + 0.07 * hash(float2(fi, 2.0));
+    c += crater(fract(uv), center, r) * step(fi, craterCount - 1.0);
+  }
+  c = clamp(c, 0.0, 1.0);
+  half3 col = mix(half3(moonColor.r, moonColor.g, moonColor.b),
+                  half3(craterColor.r, craterColor.g, craterColor.b),
+                  half(c));
+  return half4(col, 1.0);
+}
+`
+);
+var CAVE_INTERIOR_SKSL = (
+  /* sksl */
+  `
+uniform float2 resolution;
+uniform float3 caveColor;
+uniform float3 glowColor;
+uniform float scrollOffsetY;
+uniform float stalactiteCount;
+
+float hash(float x) { return fract(sin(x * 127.1) * 43758.5453); }
+
+float stalactite(float2 uv, float count) {
+  float col = floor(uv.x * count);
+  float tip = 0.1 + 0.2 * hash(col);
+  float w = 0.3 + 0.3 * hash(col + 5.0);
+  float dx = abs(fract(uv.x * count) - 0.5) / (w * 0.5);
+  float shape = step(dx, 1.0) * step(uv.y, tip * (1.0 - clamp(dx, 0.0, 1.0)));
+  return shape;
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  uv.y = 1.0 - uv.y;
+  uv.y = uv.y + scrollOffsetY / max(resolution.y, 1.0);
+  float stalac = stalactite(uv, stalactiteCount);
+  float glow = smoothstep(0.8, 1.0, uv.y) * (1.0 - stalac);
+  half3 col = mix(half3(caveColor.r, caveColor.g, caveColor.b),
+                  half3(glowColor.r, glowColor.g, glowColor.b),
+                  half(glow));
+  col = mix(col, half3(caveColor.r, caveColor.g, caveColor.b) * half(0.3), half(stalac));
+  return half4(col, 1.0);
+}
+`
+);
+var MOUNTAIN_HILLS_SKSL = (
+  /* sksl */
+  `
+uniform float2 resolution;
+uniform float3 skyColor;
+uniform float3 hillColor;
+uniform float scrollOffsetY;
+uniform float ridgeScale;
+
+float hash(float x) { return fract(sin(x * 127.1) * 43758.5453); }
+
+float heightField(float x, float scale) {
+  float h = 0.0;
+  float amp = 0.5;
+  float freq = scale;
+  for (int i = 0; i < 4; i++) {
+    float ix = floor(x * freq);
+    float fx = fract(x * freq);
+    fx = fx * fx * (3.0 - 2.0 * fx);
+    h += amp * mix(hash(ix), hash(ix + 1.0), fx);
+    freq *= 2.0;
+    amp *= 0.5;
+  }
+  return h;
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / max(resolution, float2(1.0));
+  float scroll = scrollOffsetY / max(resolution.y, 1.0);
+  float horizon = 0.4 + 0.3 * heightField(uv.x + scroll * 0.3, ridgeScale);
+  float mountains = step(uv.y, horizon);
+  half3 col = mix(half3(skyColor.r, skyColor.g, skyColor.b),
+                  half3(hillColor.r, hillColor.g, hillColor.b),
+                  half(mountains));
+  return half4(col, 1.0);
+}
+`
+);
+
+// src/sprite-font.ts
+function parseBMFontJSON(json) {
+  const data = json;
+  const glyphs = /* @__PURE__ */ new Map();
+  for (const c of data.chars) {
+    glyphs.set(c.id, {
+      id: c.id,
+      x: c.x,
+      y: c.y,
+      width: c.width,
+      height: c.height,
+      xOffset: c.xoffset,
+      yOffset: c.yoffset,
+      xAdvance: c.xadvance
+    });
+  }
+  const kernings = /* @__PURE__ */ new Map();
+  if (data.kernings) {
+    for (const k of data.kernings) {
+      kernings.set(k.first << 16 | k.second, k.amount);
+    }
+  }
+  return {
+    lineHeight: data.common.lineHeight,
+    base: data.common.base,
+    glyphs,
+    kernings
+  };
+}
+function getKerning(font, first, second) {
+  return font.kernings.get(first << 16 | second) ?? 0;
+}
+function measureText(font, text) {
+  let width = 0;
+  let prevCode = -1;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const glyph = font.glyphs.get(code);
+    if (!glyph) continue;
+    if (prevCode >= 0) {
+      width += getKerning(font, prevCode, code);
+    }
+    width += glyph.xAdvance;
+    prevCode = code;
+  }
+  return width;
+}
+function drawText(batch, font, image, text, x, y, scale = 1) {
+  let cursorX = x;
+  let prevCode = -1;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const glyph = font.glyphs.get(code);
+    if (!glyph) continue;
+    if (prevCode >= 0) {
+      cursorX += getKerning(font, prevCode, code) * scale;
+    }
+    batch.drawRaw(
+      image,
+      glyph.x,
+      glyph.y,
+      glyph.width,
+      glyph.height,
+      cursorX + glyph.xOffset * scale,
+      y + glyph.yOffset * scale,
+      glyph.width * scale,
+      glyph.height * scale
+    );
+    cursorX += glyph.xAdvance * scale;
+    prevCode = code;
+  }
+}
+
+// src/render-system.ts
+import { defineComponent } from "@flare-engine/ecs";
+function createRenderSystem(world, query, positionDef, spriteDef, batch) {
+  const entries = [];
+  return () => {
+    let i = 0;
+    for (const entityId of query) {
+      const sprite = world.get(entityId, spriteDef);
+      if (!sprite) continue;
+      if (i >= entries.length) {
+        entries.push({ entityId, z: 0 });
+      }
+      const entry = entries[i];
+      entry.entityId = entityId;
+      entry.z = sprite.z;
+      i++;
+    }
+    const count = i;
+    if (entries.length > count * 2 && entries.length > 64) {
+      entries.length = count;
+    }
+    sortByDrawOrder(entries, count);
+    for (let j = 0; j < count; j++) {
+      const entry = entries[j];
+      const pos = world.get(entry.entityId, positionDef);
+      const sprite = world.get(entry.entityId, spriteDef);
+      if (!pos || !sprite) continue;
+      const anchor = sprite.anchor;
+      batch.draw(
+        sprite.image,
+        sprite.frame,
+        pos.x,
+        pos.y,
+        sprite.width,
+        sprite.height,
+        sprite.effect,
+        anchor ? anchor.x : 0,
+        anchor ? anchor.y : 0,
+        sprite.alpha ?? 1,
+        sprite.rotation ?? 0,
+        sprite.stretch ?? false
+      );
+    }
+  };
+}
+var Sprite = defineComponent("Sprite", () => ({
+  image: null,
+  frame: { name: "", x: 0, y: 0, w: 0, h: 0 },
+  z: 0
+}));
+export {
+  CAVE_INTERIOR_SKSL,
+  Camera2D,
+  FIRE_SKSL,
+  FOG_SKSL,
+  FOREST_CANOPY_SKSL,
+  MOON_CRATER_SKSL,
+  MOUNTAIN_HILLS_SKSL,
+  RIVER_WAVE_SKSL,
+  ROOFS_CITY_SKSL,
+  Renderer,
+  Sprite,
+  SpriteBatch,
+  WATER_SKSL,
+  caveInterior,
+  createRenderSystem,
+  custom,
+  drawOrderCompare,
+  drawText,
+  fire,
+  flash,
+  flashIntensity,
+  fog,
+  forestCanopy,
+  getKerning,
+  grayscale,
+  measureText,
+  moonCrater,
+  mountainHills,
+  outline,
+  parseBMFontJSON,
+  riverWave,
+  roofsCity,
+  sortByDrawOrder,
+  tint,
+  updateEffect,
+  water
+};
+//# sourceMappingURL=index.mjs.map