@aethervtt/shard-dice 0.0.0-stage → 0.2.0

package/dist/skin.js

@@ -0,0 +1,313 @@
+import { defineDataType } from "@aethervtt/shard-assets";
+import { ShardError, t } from "@aethervtt/shard-core";
+import { DIE_KINDS, KIND_DEFINITIONS } from "./builtins.js";
+import { requireDie } from "./definition.js";
+import { recipeProblems } from "./effects.js";
+import { defaultLayoutFor, layoutProblems } from "./layout.js";
+import { findDiceFamily } from "./material.js";
+const VARIANT = t.struct(
+  {
+    layout: t.handle("dice/FaceLayout", {
+      description: "The face layout; null prints numbers (pips on a d6)."
+    }),
+    bevel: t.f32({ min: 0, max: 0.3, description: "Chamfer; 0 keeps the definition's." }),
+    params: t.json({
+      default: {},
+      description: "Family parameters for this kind, over the skin\u2019s."
+    })
+  },
+  { description: "What changes for one kind of die." }
+);
+const IMPACT_SOUNDS = ["resin", "metal", "wood", "glass"];
+const DiceSkin = defineDataType(
+  "dice/DiceSkin",
+  {
+    version: t.u8({ default: 1, min: 1, max: 1, description: "Format version: 1." }),
+    id: t.string({ description: "A name for tools and errors." }),
+    family: t.string({
+      default: "dice/SolidDice",
+      description: "The dice family (a material type defined with defineDiceFamily)."
+    }),
+    params: t.json({
+      default: {},
+      description: "The family's parameters: standard fields (baseColor, roughness\u2026), dice fields (markColor, edgeColor\u2026) and its own. Validated against the family's schema."
+    }),
+    variants: t.struct(
+      Object.fromEntries(DIE_KINDS.map((k) => [k, VARIANT])),
+      { description: "Per kind: layout, bevel and parameters." }
+    ),
+    sounds: t.struct(
+      {
+        impact: t.enum(IMPACT_SOUNDS, { description: "What contacts sound like." }),
+        impactEvent: t.handle("audio/AudioEvent", {
+          description: "Optional authored hit, replacing procedural contacts and landing knocks."
+        }),
+        entranceEvent: t.handle("audio/AudioEvent", {
+          description: "Optional authored sound when an entrance scene starts."
+        }),
+        resultEvent: t.handle("audio/AudioEvent", {
+          description: "Optional authored landing accent, under the one-cue budget."
+        }),
+        accent: t.enum(["", "resin-chime", "arcane-spark", "void-whump"], {
+          description: "A cue played when the dice land (with effects on). Empty: none."
+        })
+      },
+      { description: "Sounds." }
+    ),
+    effects: t.list(t.handle("dice/DiceEffectRecipe"), {
+      description: "Effect recipes, at most 4."
+    })
+  },
+  {
+    extension: "dice-skin",
+    lazyDependencies: true,
+    description: "A dice skin: family, parameters, variants, sounds, effects."
+  }
+);
+const RESERVED = ["marks", "dropped", "fade", "result", "resultTime", "alphaMode"];
+const MAX_SKIN_EFFECTS = 4;
+function checkParams(family, params, path, out) {
+  const f = findDiceFamily(family);
+  if (!f) return;
+  if (params === null || typeof params !== "object" || Array.isArray(params)) {
+    out.push(
+      new ShardError("dice/invalid-skin", `${path} must be an object of parameters`, { path })
+    );
+    return;
+  }
+  for (const key of Object.keys(params)) {
+    if (RESERVED.includes(key)) {
+      out.push(
+        new ShardError(
+          "dice/reserved-param",
+          `${path}/${key} is set by the package, not by skins`,
+          {
+            path: `${path}/${key}`,
+            hint: "Dropped dice, fades and results are the presentation\u2019s; the mark atlas is baked from the layout."
+          }
+        )
+      );
+    }
+  }
+  for (const err of f.type.schema.validate(params)) {
+    out.push(
+      new ShardError(err.code, err.message, {
+        path: `${path}${err.path && err.path !== "/" ? err.path : ""}`,
+        hint: err.hint ?? `Parameters of ${family}.`
+      })
+    );
+  }
+}
+function validateDiceSkin(skin, ctx = {}) {
+  const out = [];
+  for (const err of DiceSkin.validate(DiceSkin.serialize(skin))) out.push(err);
+  const family = findDiceFamily(skin.family);
+  if (!family) {
+    out.push(
+      new ShardError(
+        "dice/unknown-family",
+        `Skin "${skin.id}" names family "${skin.family}", which isn't defined`,
+        {
+          path: "/family",
+          hint: "Families: dice/SolidDice, dice/ResinDice, dice/MetalDice, dice/GlassDice, and those the host defines with defineDiceFamily."
+        }
+      )
+    );
+  } else {
+    checkParams(skin.family, skin.params, "/params", out);
+  }
+  for (const kind of DIE_KINDS) {
+    const variant = skin.variants[kind];
+    if (family) checkParams(skin.family, variant.params, `/variants/${kind}/params`, out);
+    if (variant.layout) {
+      const layout = ctx.layout?.(variant.layout);
+      if (!layout) {
+        out.push(
+          new ShardError(
+            "dice/unknown-layout",
+            `Skin "${skin.id}": the ${kind} layout isn't loaded`,
+            {
+              path: `/variants/${kind}/layout`
+            }
+          )
+        );
+        continue;
+      }
+      for (const id of KIND_DEFINITIONS[kind]) {
+        for (const err of layoutProblems(layout, requireDie(id))) {
+          out.push(
+            new ShardError(err.code, err.message, {
+              path: `/variants/${kind}/layout${err.path ?? ""}`,
+              hint: err.hint
+            })
+          );
+        }
+      }
+    }
+  }
+  if (skin.effects.length > MAX_SKIN_EFFECTS) {
+    out.push(
+      new ShardError(
+        "dice/recipe-bounds",
+        `Skin "${skin.id}" has ${skin.effects.length} effect recipes; at most ${MAX_SKIN_EFFECTS}`,
+        {
+          path: "/effects"
+        }
+      )
+    );
+  }
+  skin.effects.forEach((ref, i) => {
+    const recipe = ref ? ctx.recipe?.(ref) : void 0;
+    if (!recipe) {
+      out.push(
+        new ShardError(
+          "dice/unknown-recipe",
+          `Skin "${skin.id}": effect recipe ${i} isn't loaded`,
+          {
+            path: `/effects/${i}`
+          }
+        )
+      );
+      return;
+    }
+    for (const err of recipeProblems(recipe)) {
+      out.push(
+        new ShardError(err.code, err.message, {
+          path: `/effects/${i}${err.path ?? ""}`,
+          hint: err.hint
+        })
+      );
+    }
+  });
+  return out;
+}
+function diceSkin(json) {
+  return DiceSkin.deserialize(json);
+}
+function skinVariant(skin, kind, definition, layouts) {
+  const variant = skin.variants[kind];
+  const layout = (variant.layout ? layouts(variant.layout) : void 0) ?? defaultLayoutFor(requireDie(definition));
+  return {
+    layout,
+    bevel: variant.bevel > 0 ? variant.bevel : void 0,
+    params: { ...skin.params, ...variant.params }
+  };
+}
+const skinRef = (id) => ({
+  type: "dice/DiceSkin",
+  guid: `dice:skin/${id}`,
+  path: `dice:skin/${id}`
+});
+const DICE_SKINS = {
+  ivory: skinRef("ivory"),
+  obsidian: skinRef("obsidian"),
+  teal: skinRef("teal"),
+  ember: skinRef("ember"),
+  brass: skinRef("brass"),
+  frost: skinRef("frost")
+};
+const BUILTIN_SKINS = {
+  ivory: {
+    id: "ivory",
+    family: "dice/SolidDice",
+    params: {
+      baseColor: "#efe6d2",
+      roughness: 0.42,
+      markColor: "#1f1a14",
+      markRoughness: 0.7,
+      edgeColor: "#fff8ea",
+      edgeMix: 0.35,
+      fleck: 0.18,
+      fleckColor: "#c9b89a"
+    },
+    sounds: { impact: "resin" }
+  },
+  obsidian: {
+    id: "obsidian",
+    family: "dice/SolidDice",
+    params: {
+      baseColor: "#141318",
+      roughness: 0.2,
+      markColor: "#d9b45a",
+      markMetallic: 1,
+      markRoughness: 0.28,
+      markDepth: 0.8,
+      edgeColor: "#3a3642",
+      edgeMix: 0.4,
+      fleck: 0.3,
+      fleckColor: "#5b5470"
+    },
+    sounds: { impact: "resin" }
+  },
+  teal: {
+    id: "teal",
+    family: "dice/ResinDice",
+    params: {
+      baseColor: "#168c8c",
+      roughness: 0.18,
+      markColor: "#f4fff9",
+      markRoughness: 0.5,
+      edgeColor: "#37d8c9",
+      edgeMix: 0.25,
+      resinDeep: "#073f44",
+      resinGlow: "#37d8c9"
+    },
+    sounds: { impact: "resin", accent: "resin-chime" }
+  },
+  ember: {
+    id: "ember",
+    family: "dice/ResinDice",
+    params: {
+      baseColor: "#b8321a",
+      roughness: 0.2,
+      markColor: "#fff1c9",
+      markEmissive: 900,
+      edgeColor: "#ff9a3c",
+      edgeMix: 0.3,
+      resinDeep: "#3a0703",
+      resinGlow: "#ff8a2a",
+      resinLight: 5200,
+      resinSwirl: 0.75
+    },
+    sounds: { impact: "resin", accent: "arcane-spark" }
+  },
+  brass: {
+    id: "brass",
+    family: "dice/MetalDice",
+    params: {
+      baseColor: "#d7a64a",
+      roughness: 0.32,
+      markColor: "#1b120a",
+      markRoughness: 0.6,
+      markDepth: 0.9,
+      edgeColor: "#f6d68c",
+      edgeMix: 0.2
+    },
+    sounds: { impact: "metal" }
+  },
+  frost: {
+    id: "frost",
+    family: "dice/GlassDice",
+    params: {
+      baseColor: "#9fd6ff",
+      roughness: 0.05,
+      markColor: "#ffffff",
+      markEmissive: 400,
+      markDepth: 0.3,
+      edgeColor: "#e6f6ff",
+      edgeMix: 0.5,
+      glassClarity: 0.82
+    },
+    sounds: { impact: "glass", accent: "resin-chime" }
+  }
+};
+export {
+  BUILTIN_SKINS,
+  DICE_SKINS,
+  DiceSkin,
+  IMPACT_SOUNDS,
+  MAX_SKIN_EFFECTS,
+  diceSkin,
+  skinVariant,
+  validateDiceSkin
+};

package/dist/sound.d.ts

@@ -0,0 +1,33 @@
+import { type AudioClipAsset } from '@aethervtt/shard-audio';
+import type { ImpactSound } from './skin.js';
+/** Mono 16-bit PCM WAV. */
+export declare function wavBytes(samples: Float32Array, rate?: number): Uint8Array;
+/** Strength layers baked per material: soft, medium, hard. */
+export declare const IMPACT_LAYERS = 3;
+/** Variations baked per layer. */
+export declare const IMPACT_VARIATIONS = 6;
+/** The strength layer (0 soft, 1 medium, 2 hard) for a contact's strength (0..1). */
+export declare function impactLayer(strength: number): number;
+/**
+ * One impact clip's samples: a material, on the tray or die-to-die, a strength layer (0 soft to 2
+ * hard) and a variation. Die-to-die rings two bodies and has no knock.
+ */
+export declare function impactSamples(sound: ImpactSound, category: 'tray' | 'dice', layer: number, variation: number): Float32Array;
+export declare const ACCENT_CUES: readonly ['resin-chime', 'arcane-spark', 'void-whump'];
+export type AccentCue = (typeof ACCENT_CUES)[number];
+/** An accent cue: two partials (chimes and sparks), or a falling sine with breath (the whump). */
+export declare function accentSamples(cue: AccentCue): Float32Array;
+/**
+ * Impact clips per material (layers × variations, tray and die-to-die) and accent cues, baked on
+ * first use. `prepare` bakes a material's impacts ahead of a roll, so the tumble only plays them.
+ */
+export declare class DiceSoundBank {
+    private readonly impacts;
+    private readonly accents;
+    impact(sound: ImpactSound, category: 'tray' | 'dice', layer: number, variation: number): AudioClipAsset;
+    /** Every impact clip of a material, baked now; `each` sees each (to preload it). */
+    prepare(sound: ImpactSound, each?: (clip: AudioClipAsset) => void): void;
+    accent(cue: AccentCue): AudioClipAsset;
+}
+/** How strong a contact of this force is, 0..1 (Aether's curve). */
+export declare function impactStrength(force: number): number;

package/dist/sound.js

@@ -0,0 +1,296 @@
+import { audioClip } from "@aethervtt/shard-audio";
+const RATE = 32e3;
+function wavBytes(samples, rate = RATE) {
+  const bytes = new Uint8Array(44 + samples.length * 2);
+  const view = new DataView(bytes.buffer);
+  const text = (o, s) => {
+    for (let i = 0; i < s.length; i++) bytes[o + i] = s.charCodeAt(i);
+  };
+  text(0, "RIFF");
+  view.setUint32(4, 36 + samples.length * 2, true);
+  text(8, "WAVE");
+  text(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, rate, true);
+  view.setUint32(28, rate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  text(36, "data");
+  view.setUint32(40, samples.length * 2, true);
+  for (let i = 0; i < samples.length; i++) {
+    const s = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(44 + i * 2, Math.round(s * 32767), true);
+  }
+  return bytes;
+}
+function noise(seed, n) {
+  const out = new Float32Array(n);
+  let state = seed | 1;
+  for (let i = 0; i < n; i++) {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    out[i] = (state >>> 0) / 2147483648 - 1;
+  }
+  return out;
+}
+function jitter(seed) {
+  let state = seed | 1;
+  return () => {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    return (state >>> 0) / 4294967296;
+  };
+}
+function biquad(x, kind, freq, q) {
+  const w = 2 * Math.PI * Math.min(freq, RATE * 0.45) / RATE;
+  const alpha = Math.sin(w) / (2 * q);
+  const cos = Math.cos(w);
+  let b0;
+  let b1;
+  let b2;
+  if (kind === "low") {
+    b0 = (1 - cos) / 2;
+    b1 = 1 - cos;
+    b2 = (1 - cos) / 2;
+  } else {
+    b0 = alpha;
+    b1 = 0;
+    b2 = -alpha;
+  }
+  const a0 = 1 + alpha;
+  const a1 = -2 * cos;
+  const a2 = 1 - alpha;
+  let x1 = 0;
+  let x2 = 0;
+  let y1 = 0;
+  let y2 = 0;
+  for (let i = 0; i < x.length; i++) {
+    const x0 = x[i];
+    const y0 = (b0 * x0 + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2) / a0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+    x[i] = y0;
+  }
+}
+function damped(x, hz, decay, amp, phase) {
+  const w = 2 * Math.PI * Math.min(hz, RATE * 0.45) / RATE;
+  const r = Math.exp(-1 / (decay * RATE));
+  const c = 2 * r * Math.cos(w);
+  const r2 = r * r;
+  let y2 = amp * Math.sin(phase);
+  let y1 = amp * r * Math.sin(w + phase);
+  x[0] = x[0] + y2;
+  if (x.length > 1) x[1] = x[1] + y1;
+  for (let i = 2; i < x.length; i++) {
+    const y = c * y1 - r2 * y2;
+    x[i] = x[i] + y;
+    y2 = y1;
+    y1 = y;
+  }
+}
+function normalizePeak(x, peak = 0.9) {
+  let m = 0;
+  for (let i = 0; i < x.length; i++) m = Math.max(m, Math.abs(x[i]));
+  if (m > 0) for (let i = 0; i < x.length; i++) x[i] = x[i] / m * peak;
+  return x;
+}
+const IMPACTS = {
+  resin: {
+    modes: [
+      [3150, 0.016, 1],
+      [4870, 0.011, 0.7],
+      [6420, 8e-3, 0.5],
+      [8350, 6e-3, 0.32]
+    ],
+    clack: { hz: 3400, q: 0.9, decay: 35e-4, level: 0.55 },
+    knock: [165, 0.014, 0.5],
+    contact: 8e-5,
+    seconds: 0.14
+  },
+  wood: {
+    modes: [
+      [1650, 9e-3, 1],
+      [2710, 7e-3, 0.6],
+      [4050, 5e-3, 0.4]
+    ],
+    clack: { hz: 2100, q: 0.8, decay: 4e-3, level: 0.7 },
+    knock: [140, 0.016, 0.6],
+    contact: 12e-5,
+    seconds: 0.12
+  },
+  metal: {
+    modes: [
+      [5230, 0.19, 1],
+      [7940, 0.13, 0.6],
+      [9870, 0.085, 0.45],
+      [12260, 0.055, 0.3]
+    ],
+    clack: { hz: 5200, q: 1.4, decay: 2e-3, level: 0.4 },
+    knock: [180, 0.011, 0.35],
+    contact: 5e-5,
+    seconds: 0.45
+  },
+  glass: {
+    modes: [
+      [4310, 0.07, 1],
+      [6480, 0.05, 0.62],
+      [8870, 0.034, 0.42],
+      [11240, 0.022, 0.28]
+    ],
+    clack: { hz: 4600, q: 1.8, decay: 18e-4, level: 0.38 },
+    knock: [170, 0.011, 0.35],
+    contact: 6e-5,
+    seconds: 0.32
+  }
+};
+const IMPACT_LAYERS = 3;
+const IMPACT_VARIATIONS = 6;
+const CONTACT = [4.4, 2, 1];
+const CLACK = [0.5, 0.8, 1];
+const KNOCK = [1.3, 1, 0.85];
+const BRIGHT = [0.6, 0.85, 1];
+function impactLayer(strength) {
+  return strength < 0.33 ? 0 : strength < 0.66 ? 1 : 2;
+}
+function impactSamples(sound, category, layer, variation) {
+  const r = IMPACTS[sound];
+  const n = Math.round(r.seconds * RATE);
+  const x = new Float32Array(n);
+  const seed = 5370206 + variation * 7919 + layer * 104729 + (category === "dice" ? 1299709 : 0);
+  const rand = jitter(seed);
+  const contact = r.contact * CONTACT[layer];
+  const through = (hz) => 1 / (1 + (2 * hz * contact) ** 2);
+  const bodies = category === "dice" ? 2 : 1;
+  for (let body = 0; body < bodies; body++) {
+    const shift = body === 0 ? 1 : 1.07;
+    for (const [hz, decay, level] of r.modes) {
+      const f = hz * shift * (0.9 + rand() * 0.2);
+      const a = level * (0.75 + rand() * 0.5) * through(f) * (body === 0 ? 1 : 0.8);
+      damped(x, f, decay * (0.85 + rand() * 0.3), a, rand() * Math.PI * 2);
+    }
+  }
+  const clack = noise(seed ^ 2654435769, n);
+  const k = Math.exp(-1 / (r.clack.decay * RATE));
+  let env = r.clack.level * CLACK[layer];
+  for (let i = 0; i < n; i++) {
+    clack[i] = clack[i] * env;
+    env *= k;
+  }
+  biquad(
+    clack,
+    "band",
+    r.clack.hz * (0.9 + rand() * 0.2) * (category === "dice" ? 1.25 : 1) * BRIGHT[layer],
+    r.clack.q
+  );
+  for (let i = 0; i < n; i++) x[i] = x[i] + clack[i];
+  if (category === "tray") {
+    const [hz, decay, level] = r.knock;
+    damped(x, hz * (0.92 + rand() * 0.16), decay, level * KNOCK[layer], 0);
+    const felt = noise(seed ^ 2246822507, n);
+    const kf = Math.exp(-1 / (8e-3 * RATE));
+    let ef = 0.3 * KNOCK[layer];
+    for (let i = 0; i < n; i++) {
+      felt[i] = felt[i] * ef;
+      ef *= kf;
+    }
+    biquad(felt, "low", 450, 0.7);
+    for (let i = 0; i < n; i++) x[i] = x[i] + felt[i];
+  }
+  const fade = Math.round(4e-3 * RATE);
+  let dc = 0;
+  let prev = 0;
+  const hp = Math.exp(-2 * Math.PI * 30 / RATE);
+  for (let i = 0; i < n; i++) {
+    const t = i / RATE;
+    const v = x[i] * (1 - Math.exp(-t / contact)) * Math.min(1, (n - 1 - i) / fade);
+    dc = v - prev + hp * dc;
+    prev = v;
+    x[i] = dc;
+  }
+  return normalizePeak(x);
+}
+const ACCENT_CUES = ["resin-chime", "arcane-spark", "void-whump"];
+function accentSamples(cue) {
+  const whump = cue === "void-whump";
+  const seconds = whump ? 0.5 : 0.36;
+  const n = Math.round(seconds * RATE);
+  const x = new Float32Array(n);
+  if (whump) {
+    let phase = 0;
+    const breath = noise(24301, n);
+    biquad(breath, "low", 380, 0.7);
+    for (let i = 0; i < n; i++) {
+      const t = i / RATE;
+      const hz = 185 * (48 / 185) ** Math.min(1, t / 0.42);
+      phase += 2 * Math.PI * hz / RATE;
+      const env = Math.min(1, t / 0.016) * Math.exp(-t / 0.13);
+      x[i] = (Math.sin(phase) + 0.5 * breath[i]) * env;
+    }
+  } else {
+    const [a, b] = cue === "resin-chime" ? [740, 1110] : [980, 1470];
+    for (let i = 0; i < n; i++) {
+      const t = i / RATE;
+      const env = Math.min(1, t / 0.012) * Math.exp(-t / 0.09);
+      const late = t > 0.018 ? Math.exp(-(t - 0.018) / 0.09) : 0;
+      const tri = 2 / Math.PI * Math.asin(Math.sin(2 * Math.PI * b * t));
+      x[i] = Math.sin(2 * Math.PI * a * t) * env + 0.6 * tri * late;
+    }
+  }
+  return normalizePeak(x, 0.8);
+}
+class DiceSoundBank {
+  impacts = /* @__PURE__ */ new Map();
+  accents = /* @__PURE__ */ new Map();
+  impact(sound, category, layer, variation) {
+    const key = `${sound}:${category}:${layer}:${variation}`;
+    let clip = this.impacts.get(key);
+    if (!clip) {
+      clip = audioClip(wavBytes(impactSamples(sound, category, layer, variation)), {
+        id: `dice:impact/${key}`
+      });
+      this.impacts.set(key, clip);
+    }
+    return clip;
+  }
+  /** Every impact clip of a material, baked now; `each` sees each (to preload it). */
+  prepare(sound, each) {
+    for (const category of ["tray", "dice"]) {
+      for (let layer = 0; layer < IMPACT_LAYERS; layer++) {
+        for (let v = 0; v < IMPACT_VARIATIONS; v++) {
+          const key = `${sound}:${category}:${layer}:${v}`;
+          const fresh = !this.impacts.has(key);
+          const clip = this.impact(sound, category, layer, v);
+          if (fresh) each?.(clip);
+        }
+      }
+    }
+  }
+  accent(cue) {
+    let clip = this.accents.get(cue);
+    if (!clip) {
+      clip = audioClip(wavBytes(accentSamples(cue)), { id: `dice:accent/${cue}` });
+      this.accents.set(cue, clip);
+    }
+    return clip;
+  }
+}
+function impactStrength(force) {
+  return Math.min(1, Math.log1p(Math.max(0, force)) / 5.4);
+}
+export {
+  ACCENT_CUES,
+  DiceSoundBank,
+  IMPACT_LAYERS,
+  IMPACT_VARIATIONS,
+  accentSamples,
+  impactLayer,
+  impactSamples,
+  impactStrength,
+  wavBytes
+};

package/dist/studio.d.ts

@@ -0,0 +1,3 @@
+import { Texture } from '@aethervtt/shard-texture';
+/** A 256 × 128 rgba16float equirectangular studio: EnvironmentMap texture (usage 'hdr'). */
+export declare function studioEnvironment(): Texture;

package/dist/studio.js

@@ -0,0 +1,48 @@
+import { Texture, toHalf } from "@aethervtt/shard-texture";
+const BOXES = [
+  { azimuth: -35, elevation: 58, width: 26, height: 16, intensity: 7, color: [1, 0.97, 0.92] },
+  { azimuth: 140, elevation: 30, width: 34, height: 6, intensity: 3.2, color: [0.85, 0.92, 1] },
+  { azimuth: 60, elevation: 12, width: 10, height: 10, intensity: 1.6, color: [1, 0.9, 0.8] }
+];
+function studioEnvironment() {
+  const width = 256;
+  const height = 128;
+  const f = new Float32Array(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    const elevation = 90 - (y + 0.5) / height * 180;
+    const up = Math.sin(elevation * Math.PI / 180);
+    const sky = up > 0 ? 0.35 + 0.45 * up : 0.12 + 0.2 * (1 + up);
+    for (let x = 0; x < width; x++) {
+      const azimuth = (x + 0.5) / width * 360 - 180;
+      let r = sky * 0.96;
+      let g = sky * 0.98;
+      let b = sky;
+      for (const box of BOXES) {
+        let da = Math.abs(azimuth - box.azimuth);
+        if (da > 180) da = 360 - da;
+        const dx = da / box.width;
+        const dy = Math.abs(elevation - box.elevation) / box.height;
+        const k = Math.max(0, 1 - Math.max(dx, dy) ** 6);
+        if (k <= 0) continue;
+        r += box.color[0] * box.intensity * k;
+        g += box.color[1] * box.intensity * k;
+        b += box.color[2] * box.intensity * k;
+      }
+      const o = (y * width + x) * 4;
+      f[o] = r;
+      f[o + 1] = g;
+      f[o + 2] = b;
+      f[o + 3] = 1;
+    }
+  }
+  return Texture.create({
+    width,
+    height,
+    format: "rgba16float",
+    usage: "hdr",
+    mips: [new Uint8Array(toHalf(f).buffer)]
+  });
+}
+export {
+  studioEnvironment
+};