@oxy.so/bloom 7.1.2 → 7.1.4

package/assets/character-runtime/migrated-faces.mjs

@@ -0,0 +1,59 @@
+// Generated from shape-owned source face geometry; regenerate with scripts/generate-avatar-contours.mjs.
+export const MIGRATED_FACES = Object.freeze({
+  slender: {
+    centers: [
+      [-0.3419277108433735, 0.04819277108433735],
+      [0.09325301204819275, 0.04819277108433735],
+    ],
+    radius: 0.1740722891566265,
+  },
+  pocket: {
+    centers: [
+      [-0.3975903614457831, 0.04819277108433735],
+      [0.10843373493975902, 0.04819277108433735],
+    ],
+    radius: 0.20240963855421687,
+  },
+  petal: {
+    centers: [
+      [-0.3012048192771084, 0.04819277108433735],
+      [0.20481927710843373, 0.04819277108433735],
+    ],
+    radius: 0.20240963855421687,
+  },
+  star: {
+    centers: [
+      [-0.3253012048192771, -0.024096385542168676],
+      [0.18072289156626503, -0.024096385542168676],
+    ],
+    radius: 0.20240963855421687,
+  },
+  cloud: {
+    centers: [
+      [-0.3253012048192771, -0.0963855421686747],
+      [0.18072289156626503, -0.0963855421686747],
+    ],
+    radius: 0.20240963855421687,
+  },
+  shield: {
+    centers: [
+      [-0.3253012048192771, 0.04819277108433735],
+      [0.18072289156626503, 0.04819277108433735],
+    ],
+    radius: 0.20240963855421687,
+  },
+  pebble: {
+    centers: [
+      [-0.24096385542168675, 0],
+      [0.24096385542168675, 0],
+    ],
+    radius: 0.1927710843373494,
+  },
+  squircle: {
+    centers: [
+      [-0.24096385542168675, 0],
+      [0.24096385542168675, 0],
+    ],
+    radius: 0.1927710843373494,
+  },
+});

package/assets/character-runtime/pose-transition.mjs

@@ -0,0 +1,523 @@
+// Blend only the original engine's reflected pose blocks. Vertex/index buffers,
+// material values and shader switches are never rewritten by this adapter.
+const identity = () =>
+  new Float64Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+export function multiplyMatrix(a, b) {
+  const out = new Float64Array(16);
+  for (let c = 0; c < 4; c++)
+    for (let r = 0; r < 4; r++)
+      for (let k = 0; k < 4; k++) out[c * 4 + r] += a[k * 4 + r] * b[c * 4 + k];
+  return out;
+}
+export function inverseMatrix(m) {
+  const a = Array.from({ length: 4 }, (_, r) =>
+    Array.from({ length: 8 }, (_, c) =>
+      c < 4 ? m[c * 4 + r] : +(c - 4 === r),
+    ),
+  );
+  for (let c = 0; c < 4; c++) {
+    let pivot = c;
+    for (let r = c + 1; r < 4; r++)
+      if (Math.abs(a[r][c]) > Math.abs(a[pivot][c])) pivot = r;
+    if (Math.abs(a[pivot][c]) < 1e-10) return null;
+    [a[c], a[pivot]] = [a[pivot], a[c]];
+    const divisor = a[c][c];
+    for (let k = 0; k < 8; k++) a[c][k] /= divisor;
+    for (let r = 0; r < 4; r++)
+      if (r !== c) {
+        const f = a[r][c];
+        for (let k = 0; k < 8; k++) a[r][k] -= f * a[c][k];
+      }
+  }
+  return Float64Array.from(
+    { length: 16 },
+    (_, i) => a[i % 4][4 + Math.floor(i / 4)],
+  );
+}
+function dot(a, b) {
+  return a.reduce((s, x, i) => s + x * b[i], 0);
+}
+function normalized(a) {
+  const n = Math.hypot(...a);
+  return n > 1e-10 ? a.map((x) => x / n) : null;
+}
+function quaternion(m) {
+  const t = m[0] + m[5] + m[10];
+  let x, y, z, w, s;
+  if (t > 0) {
+    s = Math.sqrt(t + 1) * 2;
+    w = s / 4;
+    x = (m[6] - m[9]) / s;
+    y = (m[8] - m[2]) / s;
+    z = (m[1] - m[4]) / s;
+  } else if (m[0] > m[5] && m[0] > m[10]) {
+    s = Math.sqrt(1 + m[0] - m[5] - m[10]) * 2;
+    w = (m[6] - m[9]) / s;
+    x = s / 4;
+    y = (m[4] + m[1]) / s;
+    z = (m[8] + m[2]) / s;
+  } else if (m[5] > m[10]) {
+    s = Math.sqrt(1 + m[5] - m[0] - m[10]) * 2;
+    w = (m[8] - m[2]) / s;
+    x = (m[4] + m[1]) / s;
+    y = s / 4;
+    z = (m[9] + m[6]) / s;
+  } else {
+    s = Math.sqrt(1 + m[10] - m[0] - m[5]) * 2;
+    w = (m[1] - m[4]) / s;
+    x = (m[8] + m[2]) / s;
+    y = (m[9] + m[6]) / s;
+    z = s / 4;
+  }
+  return normalized([x, y, z, w]);
+}
+function decompose(m) {
+  if (
+    !Array.from(m).every(Number.isFinite) ||
+    Math.abs(m[3]) + Math.abs(m[7]) + Math.abs(m[11]) + Math.abs(m[15] - 1) >
+      1e-5
+  )
+    return null;
+  const scales = [
+    Math.hypot(m[0], m[1], m[2]),
+    Math.hypot(m[4], m[5], m[6]),
+    Math.hypot(m[8], m[9], m[10]),
+  ];
+  if (scales.some((x) => x < 1e-8)) return null;
+  const determinant =
+    m[0] * (m[5] * m[10] - m[6] * m[9]) -
+    m[4] * (m[1] * m[10] - m[2] * m[9]) +
+    m[8] * (m[1] * m[6] - m[2] * m[5]);
+  if (determinant < 0) scales[0] *= -1;
+  const rotation = identity();
+  for (let c = 0; c < 3; c++)
+    for (let r = 0; r < 3; r++) rotation[c * 4 + r] = m[c * 4 + r] / scales[c];
+  const axes = [
+    Array.from(rotation.slice(0, 3)),
+    Array.from(rotation.slice(4, 7)),
+    Array.from(rotation.slice(8, 11)),
+  ];
+  if (
+    Math.abs(dot(axes[0], axes[1])) +
+      Math.abs(dot(axes[0], axes[2])) +
+      Math.abs(dot(axes[1], axes[2])) >
+    1e-3
+  )
+    return null;
+  return { q: quaternion(rotation), s: scales, p: Array.from(m.slice(12, 15)) };
+}
+function slerp(a, b, t) {
+  let cosine = dot(a, b);
+  if (cosine < 0) {
+    b = b.map((x) => -x);
+    cosine = -cosine;
+  }
+  if (cosine > 0.9995) return normalized(a.map((x, i) => x + (b[i] - x) * t));
+  const angle = Math.acos(Math.min(1, cosine)),
+    d = Math.sin(angle);
+  return a.map(
+    (x, i) => (x * Math.sin((1 - t) * angle) + b[i] * Math.sin(t * angle)) / d,
+  );
+}
+function compose({ q: [x, y, z, w], s, p }) {
+  const m = identity();
+  m[0] = 1 - 2 * (y * y + z * z);
+  m[1] = 2 * (x * y + z * w);
+  m[2] = 2 * (x * z - y * w);
+  m[4] = 2 * (x * y - z * w);
+  m[5] = 1 - 2 * (x * x + z * z);
+  m[6] = 2 * (y * z + x * w);
+  m[8] = 2 * (x * z + y * w);
+  m[9] = 2 * (y * z - x * w);
+  m[10] = 1 - 2 * (x * x + y * y);
+  for (let c = 0; c < 3; c++) for (let r = 0; r < 3; r++) m[c * 4 + r] *= s[c];
+  m.set(p, 12);
+  return m;
+}
+export function interpolateTransform(a, b, t) {
+  if (t <= 0) return new Float64Array(a);
+  if (t >= 1) return new Float64Array(b);
+  const from = decompose(a),
+    to = decompose(b);
+  if (!from?.q || !to?.q || from.s.some((x, i) => x * to.s[i] <= 0))
+    return null;
+  return compose({
+    q: slerp(from.q, to.q, t),
+    s: from.s.map((x, i) => x + (to.s[i] - x) * t),
+    p: from.p.map((x, i) => x + (to.p[i] - x) * t),
+  });
+}
+function point(m, x, y, z) {
+  const w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  if (Math.abs(w) < 1e-10) return null;
+  return [0, 1, 2].map(
+    (r) => (m[r] * x + m[4 + r] * y + m[8 + r] * z + m[12 + r]) / w,
+  );
+}
+function camera(frame) {
+  const vp = frame.slice(0, 16),
+    inv = inverseMatrix(vp);
+  if (!inv) return null;
+  const center = point(inv, 0, 0, -1),
+    right = point(inv, 1, 0, -1),
+    up = point(inv, 0, 1, -1),
+    far = point(inv, 0, 0, 1);
+  if (!center || !right || !up || !far) return null;
+  const axes = [
+    normalized(right.map((v, i) => v - center[i])),
+    normalized(up.map((v, i) => v - center[i])),
+    normalized(center.map((v, i) => v - far[i])),
+  ];
+  if (axes.some((a) => !a)) return null;
+  const world = identity();
+  axes.forEach((a, i) => world.set(a, i * 4));
+  const position = frame[51] === 1 ? frame.slice(48, 51) : point(inv, 0, 0, 0);
+  if (!position) return null;
+  world.set(position, 12);
+  return { world, projection: multiplyMatrix(vp, world) };
+}
+export function blendFramePose(from, to, t) {
+  const out = new Float32Array(to);
+  if (t <= 0) {
+    out.set(from.subarray(0, 32), 0);
+    out.set(from.subarray(48, 51), 48);
+    return out;
+  }
+  if (t >= 1) return out;
+  const a = camera(from),
+    b = camera(to);
+  if (!a || !b || from[51] !== to[51]) return null;
+  // Interpolate within one projection family, never perspective to orthographic.
+  if (Math.abs(a.projection[15] - b.projection[15]) > 1e-4) return null;
+  const world = interpolateTransform(a.world, b.world, t);
+  if (!world) return null;
+  const view = inverseMatrix(world);
+  if (!view) return null;
+  const projection = a.projection.map((v, i) => v + (b.projection[i] - v) * t);
+  const vp = multiplyMatrix(projection, view),
+    inv = inverseMatrix(vp);
+  if (!inv) return null;
+  out.set(vp, 0);
+  out.set(inv, 16);
+  if (to[51] === 1) out.set(world.slice(12, 15), 48);
+  else for (let i = 48; i < 51; i++) out[i] = from[i] + (to[i] - from[i]) * t;
+  return out;
+}
+export function blendDrawPose(from, to, t) {
+  const out = new Float32Array(to),
+    world = interpolateTransform(from.slice(0, 16), to.slice(0, 16), t);
+  if (!world) return null;
+  const normal = inverseMatrix(world);
+  if (!normal) return null;
+  out.set(world, 0);
+  if (t <= 0) out.set(from.subarray(16, 32), 16);
+  // Native normalMatrix is an inverse-transpose of the world linear transform.
+  // Retain its unused fourth row/column and every non-pose field verbatim.
+  if (t > 0 && t < 1)
+    for (let c = 0; c < 3; c++)
+      for (let r = 0; r < 3; r++) out[16 + c * 4 + r] = normal[r * 4 + c];
+  for (const i of [37, 38, 39, 88, 89, 90, 91])
+    out[i] = from[i] + (to[i] - from[i]) * t;
+  return out;
+}
+
+export function createPoseTransition(gl, { assertAvailable = () => {} } = {}) {
+  const blocks = new WeakMap(),
+    indexed = new Map(),
+    buffers = new Map(),
+    methods = new Map();
+  const ids = new WeakMap();
+  let serial = 0;
+  const id = (value) => {
+    if (!value) return 0;
+    if (!ids.has(value)) ids.set(value, ++serial);
+    return ids.get(value);
+  };
+  let bound = null,
+    program = null,
+    vao = null,
+    frame = new Map(),
+    previous = new Map(),
+    source = null;
+  const starts = new Map();
+  let now = 0,
+    expires = 0,
+    duration = 180,
+    ready = true;
+  const counters = {
+    transitions: 0,
+    draws: 0,
+    cameras: 0,
+    joints: 0,
+    unmatched: 0,
+    unsupported: 0,
+  };
+  function programBlocks(p) {
+    let value = blocks.get(p);
+    if (!value) {
+      value = new Map();
+      blocks.set(p, value);
+    }
+    return value;
+  }
+  function bytes(data, offset = 0, length) {
+    if (!ArrayBuffer.isView(data) || !Number.isInteger(data.BYTES_PER_ELEMENT))
+      return null;
+    const count = length === undefined ? data.length - offset : length;
+    if (!Number.isInteger(count) || count < 0) return null;
+    return new Uint8Array(
+      data.buffer,
+      data.byteOffset + offset * data.BYTES_PER_ELEMENT,
+      count * data.BYTES_PER_ELEMENT,
+    ).slice();
+  }
+  function upload(range, values) {
+    gl.bindBuffer(gl.UNIFORM_BUFFER, range.buffer);
+    gl.bufferSubData(gl.UNIFORM_BUFFER, range.offset, values);
+    gl.bindBuffer(gl.UNIFORM_BUFFER, bound);
+  }
+  function rangeFor(name, size) {
+    const entry = [...(blocks.get(program)?.values() ?? [])].find(
+      (x) => x.name === name && x.binding !== undefined,
+    );
+    const range = entry && indexed.get(entry.binding),
+      data = range && buffers.get(range.buffer);
+    if (
+      !range ||
+      !data ||
+      (range.size ?? data.length) !== size ||
+      range.offset < 0 ||
+      range.offset + size > data.length
+    )
+      return null;
+    return { ...range, data, size };
+  }
+  function pose(name, range, key, blend) {
+    if (!range || frame.has(key)) return;
+    let output = new Float32Array(
+      range.data.slice(range.offset, range.offset + range.size).buffer,
+    );
+    const old = source?.get(key);
+    if (source) {
+      if (old && old.length === output.length) {
+        const indices =
+          name === 'draws'
+            ? [
+                ...Array.from({ length: 16 }, (_, i) => i),
+                37,
+                38,
+                39,
+                88,
+                89,
+                90,
+                91,
+              ]
+            : name === 'cameras'
+              ? [...Array.from({ length: 16 }, (_, i) => i), 48, 49, 50]
+              : Array.from({ length: output.length }, (_, i) => i);
+        const changed = indices.some(
+          (i) => Math.abs(old[i] - output[i]) > 1e-5,
+        );
+        if (!starts.has(key) && ready && changed) starts.set(key, null);
+        const start = starts.get(key);
+        const progress =
+          typeof start === 'number'
+            ? Math.min(1, Math.max(0, (now - start) / duration))
+            : 0;
+        if (progress === 1 || !changed) {
+          frame.set(key, output);
+          return;
+        }
+        const alpha = progress * progress * (3 - 2 * progress);
+        const mixed = blend(old, output, alpha);
+        if (mixed) {
+          output = mixed;
+          upload(range, output);
+          counters[name]++;
+        } else counters.unsupported++;
+      } else counters.unmatched++;
+    }
+    frame.set(key, new Float32Array(output));
+  }
+  function beforeDraw() {
+    if (!program || !vao) return;
+    const draw = rangeFor('DrawBlock', 368);
+    if (!draw) return;
+    // VAOs identify original geometry; range offsets disambiguate instances
+    // such as two eyes sharing a mesh. Newly introduced props have no old pose.
+    pose('draws', draw, `draw:${id(vao)}:${draw.offset}`, blendDrawPose);
+    const cameraRange = rangeFor('FrameBlock', 464);
+    pose(
+      'cameras',
+      cameraRange,
+      `frame:${id(cameraRange?.buffer)}`,
+      blendFramePose,
+    );
+    const skin = rangeFor('SkinBlock', 1536);
+    if (skin)
+      pose('joints', skin, `skin:${id(skin.buffer)}`, (a, b, t) => {
+        const out = new Float32Array(b);
+        for (let i = 0; i < 384; i += 16) {
+          // Unused joint slots can be zero matrices; leave identical slots alone.
+          if (a.subarray(i, i + 16).every((v, k) => v === b[i + k])) continue;
+          const matrix = interpolateTransform(
+            a.slice(i, i + 16),
+            b.slice(i, i + 16),
+            t,
+          );
+          if (!matrix) return null;
+          out.set(matrix, i);
+        }
+        return out;
+      });
+  }
+  const api = {
+    getUniformBlockIndex(p, name) {
+      const index = gl.getUniformBlockIndex(p, name);
+      if (index !== gl.INVALID_INDEX)
+        programBlocks(p).set(index, { ...programBlocks(p).get(index), name });
+      return index;
+    },
+    uniformBlockBinding(p, index, binding) {
+      const entries = programBlocks(p),
+        entry = entries.get(index);
+      if (entry) entry.binding = binding;
+      return gl.uniformBlockBinding(p, index, binding);
+    },
+    useProgram(p) {
+      program = p;
+      return gl.useProgram(p);
+    },
+    bindVertexArray(value) {
+      vao = value;
+      return gl.bindVertexArray(value);
+    },
+    bindBuffer(target, value) {
+      if (target === gl.UNIFORM_BUFFER) bound = value;
+      return gl.bindBuffer(target, value);
+    },
+    bindBufferRange(target, index, buffer, offset, size) {
+      if (target === gl.UNIFORM_BUFFER) {
+        bound = buffer;
+        indexed.set(index, { buffer, offset, size });
+      }
+      return gl.bindBufferRange(target, index, buffer, offset, size);
+    },
+    bindBufferBase(target, index, buffer) {
+      if (target === gl.UNIFORM_BUFFER) {
+        bound = buffer;
+        indexed.set(index, { buffer, offset: 0, size: undefined });
+      }
+      return gl.bindBufferBase(target, index, buffer);
+    },
+    bufferData(target, data, usage, offset, length) {
+      if (target === gl.UNIFORM_BUFFER && bound) {
+        const copy = bytes(data, offset, length);
+        if (copy) buffers.set(bound, copy);
+        else buffers.delete(bound);
+      }
+      return gl.bufferData(
+        target,
+        data,
+        usage,
+        ...(offset === undefined
+          ? []
+          : [offset, ...(length === undefined ? [] : [length])]),
+      );
+    },
+    bufferSubData(target, offset, data, srcOffset, length) {
+      if (target === gl.UNIFORM_BUFFER && bound) {
+        const copy = bytes(data, srcOffset, length),
+          old = buffers.get(bound);
+        if (copy && old && offset + copy.length <= old.length)
+          old.set(copy, offset);
+        else buffers.delete(bound);
+      }
+      return gl.bufferSubData(
+        target,
+        offset,
+        data,
+        ...(srcOffset === undefined
+          ? []
+          : [srcOffset, ...(length === undefined ? [] : [length])]),
+      );
+    },
+    deleteBuffer(buffer) {
+      buffers.delete(buffer);
+      return gl.deleteBuffer(buffer);
+    },
+  };
+  const context = new Proxy(gl, {
+    get(target, key) {
+      if (Object.hasOwn(api, key)) {
+        if (!methods.has(key))
+          methods.set(key, (...args) => {
+            assertAvailable();
+            return api[key](...args);
+          });
+        return methods.get(key);
+      }
+      if (methods.has(key)) return methods.get(key);
+      const value = Reflect.get(target, key, target);
+      if (typeof value !== 'function') return value;
+      const method =
+        /^draw(?:Arrays|Elements|RangeElements)(?:Instanced)?$/.test(
+          String(key),
+        )
+          ? (...args) => {
+              assertAvailable();
+              beforeDraw();
+              return value(...args);
+            }
+          : value.bind(target);
+      methods.set(key, method);
+      return method;
+    },
+  });
+  return {
+    context,
+    beginTransition(milliseconds = 180) {
+      if (!Number.isFinite(milliseconds) || milliseconds <= 0 || !previous.size)
+        return false;
+      source = new Map(previous);
+      starts.clear();
+      ready = false;
+      expires = performance.now() + 5000;
+      duration = Math.min(milliseconds, 1000);
+      counters.transitions++;
+      return true;
+    },
+    beginFrame(time = performance.now()) {
+      now = time;
+      frame = new Map();
+      if (source && now > expires) source = null;
+    },
+    presented(time = performance.now()) {
+      // Compilation and GPU completion can take longer than the blend itself.
+      // Start the clock when its source pose is actually displayed, not queued.
+      for (const [key, start] of starts)
+        if (start === null) starts.set(key, time);
+    },
+    endFrame(poseReady = true) {
+      if (frame.size) previous = frame;
+      ready = poseReady;
+    },
+    cancel() {
+      source = null;
+      starts.clear();
+    },
+    stats: () => ({
+      ...counters,
+      active: Boolean(source),
+      poses: previous.size,
+    }),
+    dispose() {
+      source = null;
+      previous.clear();
+      frame.clear();
+      buffers.clear();
+      indexed.clear();
+      methods.clear();
+    },
+  };
+}

package/assets/character-runtime/preparation-cache.mjs

@@ -0,0 +1,60 @@
+// Exact prepared-scene reuse. These buffers are owned copies, not views into
+// WASM memory or transferable worker replies. Keep the memory cost bounded.
+export function preparationKey(request) {
+  if (!request.points && !request.authoredParts) return null;
+  return JSON.stringify([
+    Array.from(request.appearance),
+    request.quality,
+    request.key,
+    request.activities,
+    request.points,
+    request.authoredParts,
+  ]);
+}
+
+export function createPreparationCache({
+  maximumBytes = 8 * 1024 * 1024,
+  maximumEntries = 16,
+} = {}) {
+  const entries = new Map();
+  let bytes = 0,
+    hits = 0,
+    misses = 0;
+  return {
+    get(key) {
+      if (key === null) return null;
+      const entry = entries.get(key);
+      if (!entry) {
+        misses++;
+        return null;
+      }
+      entries.delete(key);
+      entries.set(key, entry);
+      hits++;
+      // The receiver may transfer or mutate this result independently.
+      return entry.value.slice();
+    },
+    set(key, value) {
+      if (key === null || !(value instanceof Uint8Array) || !value.length)
+        return;
+      const cost = value.byteLength + key.length * 2;
+      if (cost > maximumBytes || maximumEntries < 1) return;
+      const previous = entries.get(key);
+      if (previous) {
+        bytes -= previous.cost;
+        entries.delete(key);
+      }
+      while (
+        entries.size &&
+        (entries.size >= maximumEntries || bytes + cost > maximumBytes)
+      ) {
+        const [oldKey, old] = entries.entries().next().value;
+        entries.delete(oldKey);
+        bytes -= old.cost;
+      }
+      entries.set(key, { value: value.slice(), cost });
+      bytes += cost;
+    },
+    stats: () => ({ entries: entries.size, bytes, maximumBytes, hits, misses }),
+  };
+}

package/assets/character-runtime/render-budget.mjs

@@ -1,6 +1,8 @@
 // One budget per document, including separately imported/versioned adapters.
-// Renderers retain their painted 2D canvas when their GPU lease is released.
-const key = Symbol.for('bloom.character.render-budget');
+// Visible moving characters share one atlas/context; admission serializes cold
+// preparation, without suspending neighbours once their first frame is painted.
+// Offscreen/still characters retain their 2D image when their lease is released.
+const key = Symbol.for('bloom.character.shared-render-budget.v1');
 export function createRenderBudget(
   limit = 4,
   schedule = (fn) => requestAnimationFrame(fn),
@@ -141,4 +143,4 @@ export function createRenderBudget(
     }),
   };
 }
-export const renderBudget = (globalThis[key] ??= createRenderBudget());
+export const renderBudget = (globalThis[key] ??= createRenderBudget(Infinity));