@oxy.so/bloom 7.1.1 → 7.1.3

package/assets/character-runtime/controller-mode.mjs

@@ -0,0 +1,208 @@
+import { sha256 } from './sha256.mjs';
+/** Internal adapter for the pinned, unmodified original Character WASM ABI.
+ * The public activity API binds its renderer permanently. This controller bit
+ * selects both render and input branches; it does not replace geometry or pose.
+ * Any upstream binary change requires re-disassembly and real-render validation.
+ */
+export const CONTROLLER_WASM_SHA256 =
+  'c15f3692305c1385a12524e877199ba279b8d53e6bd37a9e533d626f12fcb94b';
+const OFFSET = Object.freeze({ mode: 3015, ready: 74640, type: 74772 });
+const CHARACTER_TYPE = 4001288;
+// Read-only, null-terminated identity literals in this exact WASM image.
+// func1726 compares the requested and prepared identity strings, then stores
+// only the numeric original signature profile in the reaction controller.
+const SIGNATURE_IDENTITIES = Object.freeze({
+  blue_beret: 6968,
+  alfred: 34630,
+  purple_heart: 4922,
+  lime_frog: 22673,
+  coral_monocle: 28480,
+  gus: 8835,
+  blue_spectacles: 12573,
+  lime_headphones: 12137,
+});
+const IDENTITY_OFFSETS = [73396, 73792];
+
+export function createControllerModeAdapter(wasmUrl) {
+  let memory;
+  let verified = false;
+  let rejectInstantiation;
+  const failure = new Promise((_, reject) => {
+    rejectInstantiation = reject;
+  });
+  // A mocked module factory need not invoke instantiateWasm.
+  failure.catch(() => {});
+  const characters = new WeakMap();
+
+  const instantiateWasm = (imports, receiveInstance) => {
+    void (async () => {
+      const response = await fetch(
+        typeof wasmUrl === 'function' ? wasmUrl() : wasmUrl,
+      );
+      if (!response.ok)
+        throw new Error(`Character WASM fetch failed: ${response.status}`);
+      const bytes = await response.arrayBuffer();
+      const digest = await sha256(bytes);
+      if (digest !== CONTROLLER_WASM_SHA256)
+        throw new Error(
+          'Character controller ABI: original WASM integrity mismatch',
+        );
+      const { instance } = await WebAssembly.instantiate(bytes, imports);
+      if (!(instance.exports.Vd instanceof WebAssembly.Memory))
+        throw new Error(
+          'Character controller ABI: missing original memory export',
+        );
+      memory = instance.exports.Vd;
+      verified = true;
+      receiveInstance(instance);
+    })().catch(rejectInstantiation);
+    return {};
+  };
+
+  function register(character, activities, source) {
+    characters.set(character, {
+      activities: activities === true,
+      bound: characters.get(source)?.bound === true,
+    });
+  }
+  function unregister(character) {
+    characters.delete(character);
+  }
+  function layout(character) {
+    const record = characters.get(character);
+    if (!record?.activities || !verified || !memory || character.isDeleted?.())
+      throw new Error(
+        'Character controller ABI: unsupported or deleted character',
+      );
+    // Read a fresh view after every possible memory growth. Embind's outer
+    // handle owns one pointer to the native implementation, not the impl itself.
+    const view = new DataView(memory.buffer);
+    const handle = character.$$?.ptr;
+    if (
+      !Number.isInteger(handle) ||
+      handle <= 0 ||
+      handle % 4 ||
+      handle + 4 > view.byteLength
+    )
+      throw new Error('Character controller ABI: invalid Embind handle');
+    const impl = view.getUint32(handle, true);
+    if (
+      !impl ||
+      impl % 4 ||
+      impl + OFFSET.type + 4 > view.byteLength ||
+      view.getUint32(impl + OFFSET.type, true) !== CHARACTER_TYPE ||
+      view.getUint8(impl + OFFSET.ready) > 1 ||
+      view.getUint8(impl + OFFSET.mode) > 1
+    )
+      throw new Error('Character controller ABI: invalid pinned native layout');
+    return { record, view, address: impl + OFFSET.mode };
+  }
+  function markBound(character) {
+    const { record, view, address } = layout(character);
+    if (view.getUint8(address) === 1) record.bound = true;
+  }
+  function controllerMode(character, enabled) {
+    const { record, view, address } = layout(character);
+    if (!record.bound)
+      throw new Error(
+        'Character controller ABI: activity Restore must bind before selecting a controller',
+      );
+    if (enabled !== undefined) {
+      if (typeof enabled !== 'boolean')
+        throw new TypeError('Character controller mode must be boolean');
+      view.setUint8(address, enabled ? 1 : 0);
+    }
+    return view.getUint8(address) === 1;
+  }
+  function controllerState(character) {
+    const { record, view, address } = layout(character);
+    if (!record.bound)
+      throw new Error(
+        'Character controller ABI: activity Restore must bind before reading state',
+      );
+    const impl = address - OFFSET.mode;
+    const phase = view.getUint8(impl + 3008 + 35160);
+    const activity = view.getUint32(impl + 3008 + 35136, true);
+    const episodeId = view.getBigUint64(impl + 3008 + 35128, true);
+    if (phase > 3 || activity > 9)
+      throw new Error(
+        'Character controller ABI: invalid pinned activity state',
+      );
+    // Original func1124 starts Stop at phase3. Original func786 clears phase,
+    // current activity and episode only after its authored 3D outro finishes.
+    // copyActivityRestore reflects the requested state immediately, too early.
+    return {
+      phase,
+      activity,
+      episodeId,
+      settled: phase === 0 && activity === 0 && episodeId === 0n,
+    };
+  }
+  function controllerWithSignature(character, identity, operation) {
+    const { record, view, address } = layout(character);
+    if (!record.bound)
+      throw new Error(
+        'Character controller ABI: activity Restore must bind before selecting a signature',
+      );
+    const pointer = SIGNATURE_IDENTITIES[identity];
+    if (!Object.hasOwn(SIGNATURE_IDENTITIES, identity))
+      throw new TypeError(
+        'Character controller signature must name an original body',
+      );
+    if (typeof operation !== 'function')
+      throw new TypeError(
+        'Character controller signature operation must be synchronous',
+      );
+    const literal = new TextEncoder().encode(`${identity}\0`);
+    if (
+      pointer + literal.length > view.byteLength ||
+      !literal.every((byte, i) => view.getUint8(pointer + i) === byte)
+    )
+      throw new Error(
+        'Character controller ABI: invalid pinned signature literal',
+      );
+    const impl = address - OFFSET.mode;
+    const saved = IDENTITY_OFFSETS.map((offset) =>
+      new Uint8Array(memory.buffer, impl + offset, 12).slice(),
+    );
+    // Borrow immutable native strings only for the synchronous native call.
+    // Restore the complete libc++ string objects (including any owning heap
+    // pointers) before rendering, state serialization, or destruction can run.
+    // Keeping HERE in the appearance would also override transplanted materials.
+    try {
+      for (const offset of IDENTITY_OFFSETS) {
+        const at = impl + offset;
+        view.setUint32(at, pointer, true);
+        view.setUint32(at + 4, identity.length, true);
+        view.setUint32(at + 8, 0x80000000 | (identity.length + 1), true);
+      }
+      const result = operation();
+      if (result && typeof result.then === 'function')
+        throw new TypeError(
+          'Character controller signature operation must be synchronous',
+        );
+      return result;
+    } finally {
+      // Native calls may grow memory, invalidating the earlier DataView.
+      IDENTITY_OFFSETS.forEach((offset, i) =>
+        new Uint8Array(memory.buffer, impl + offset, 12).set(saved[i]),
+      );
+    }
+  }
+  function controllerSignature(character, identity) {
+    return controllerWithSignature(character, identity, () =>
+      character.playReaction(2),
+    );
+  }
+  return {
+    instantiateWasm,
+    failure,
+    register,
+    unregister,
+    markBound,
+    controllerMode,
+    controllerState,
+    controllerSignature,
+    controllerWithSignature,
+  };
+}

package/assets/character-runtime/cyclops-geometry.mjs

@@ -0,0 +1,180 @@
+import {
+  authoredAssemblyRecords,
+  authoredEyeRecords,
+  hasAuthoredLabel,
+  transformAuthoredRecord,
+  assembleAuthoredRecords,
+} from './authored-parts.mjs';
+import { sha256 } from './sha256.mjs';
+
+const encoder = new TextEncoder();
+const center = (bounds) => bounds.min.map((v, k) => (v + bounds.max[k]) / 2);
+const span = (bounds, axis) => bounds.max[axis] - bounds.min[axis];
+const fail = (message) => {
+  throw new Error(`Single eye: ${message}`);
+};
+
+/** Single-eye placement is body-relative, never a collapsed left/right pair.
+ * The upper-middle face keeps the eye on Todd's head rather than between its
+ * raised eye stalks; the narrow clip uses its original upper face instead.
+ */
+export function cyclopsPlacement(body, eyes, clippo = false) {
+  if (
+    (clippo && !eyes.length) ||
+    [...body.min, ...body.max].some((v) => !Number.isFinite(v))
+  )
+    fail('missing finite face bounds');
+  const radius = Math.max(
+    0.2,
+    Math.min(0.6, span(body, 0) * (clippo ? 0.32 : 0.27)),
+  );
+  const location = center(body);
+  location[1] = clippo
+    ? eyes.reduce((sum, part) => sum + center(part.bounds)[1], 0) / eyes.length
+    : body.min[1] + span(body, 1) * 0.62;
+  location[2] = clippo ? 0.13 : body.max[2] - radius * 0.18;
+  return { radius, center: location };
+}
+
+async function eyeRecord(bytes, part, origin, scale, destination, role, color) {
+  const record = await transformAuthoredRecord(bytes, part, {
+    scale,
+    origin,
+    translate: destination.map((v, k) => v - origin[k]),
+  });
+  const view = new DataView(record.bytes.buffer);
+  if (color) {
+    // Native fixed-pupil black bypasses material RGB. Disable only that flag,
+    // retaining the original eye shader and its blink/look deformation data.
+    record.bytes[88] = 0;
+    for (const offset of [28, 60])
+      color.forEach((v, k) => view.setFloat32(offset + k * 4, v, true));
+  }
+  if (role === 'iris') {
+    // Radial iris striations use surface normals rather than a new texture or
+    // dozens of draw calls. The three native normal bases receive the same
+    // perturbation, so native blink/morph interpolation remains continuous.
+    for (let i = 0; i < part.vertexCount; i++) {
+      const at = part.vertexOffset - part.start + i * 96;
+      const x = view.getFloat32(at, true) - destination[0];
+      const y = view.getFloat32(at + 4, true) - destination[1];
+      const angle = Math.atan2(y, x);
+      const groove = 0.2 * Math.sin(angle * 53) + 0.09 * Math.sin(angle * 91);
+      for (const offset of [12, 36, 60, 84]) {
+        const nx =
+          view.getFloat32(at + offset, true) + Math.cos(angle) * groove;
+        const ny =
+          view.getFloat32(at + offset + 4, true) + Math.sin(angle) * groove;
+        const nz = view.getFloat32(at + offset + 8, true);
+        const length = Math.hypot(nx, ny, nz);
+        if (length > 1e-8)
+          [nx, ny, nz].forEach((v, k) =>
+            view.setFloat32(at + offset + k * 4, v / length, true),
+          );
+      }
+    }
+  }
+  const key = await sha256(
+    encoder.encode(JSON.stringify(['cyclops-v1', record.name, role, color])),
+  );
+  record.bytes.set(encoder.encode(key), part.nameOffset - part.start);
+  record.name = key + record.name.slice(64);
+  return record;
+}
+
+/** One original native eyeball, an iris, pupil and glint. Preserves the same
+ * character controller, native eye motion and opaque work/activity payload.
+ */
+export async function composeCyclopsAssembly(module, bytes, request) {
+  if (request.authoredParts?.eyes !== 'cyclops') return bytes;
+  const target = authoredAssemblyRecords(bytes);
+  const previousEyes = authoredEyeRecords(target);
+  const prepared = module.orbitPrepareAssembly(
+    module.presetAppearance('lime_frog'),
+    request.quality,
+    `${request.key}:single-eye-source`,
+    false,
+  );
+  if (!prepared.bytes || prepared.error)
+    fail(prepared.error || 'eye source unavailable');
+  const sourceBytes = prepared.bytes.slice();
+  const source = authoredAssemblyRecords(sourceBytes);
+  const [outer, pupil] = source.records.slice(1, 3);
+  if (
+    !outer ||
+    !pupil ||
+    ![outer, pupil].every((p) =>
+      hasAuthoredLabel(sourceBytes, p, 'source_integrated_eye'),
+    )
+  )
+    fail('original eye layout changed');
+  const layout = request.faceLayout;
+  const placement = layout
+    ? {
+        radius: layout.radius * 2,
+        center: [0, 1]
+          .map((k) => (layout.centers[0][k] + layout.centers[1][k]) / 2)
+          .concat(
+            Math.max(...layout.centers.map((c) => c[2])) + layout.radius * 0.5,
+          ),
+      }
+    : cyclopsPlacement(
+        target.body.bounds,
+        previousEyes,
+        hasAuthoredLabel(bytes, target.body, 'metal'),
+      );
+  const origin = center(outer.bounds);
+  const scale = (placement.radius * 2) / span(outer.bounds, 0);
+  const white = await eyeRecord(
+    sourceBytes,
+    outer,
+    origin,
+    scale,
+    placement.center,
+    'white',
+  );
+  const pupilOrigin = center(pupil.bounds);
+  const front = white.bounds.max[2];
+  const layers = [
+    ['rim', 0.57, [0.012, 0.08, 0.075], 0, 0],
+    ['iris', 0.53, [0.035, 0.48, 0.37], 0, 0],
+    ['pupil', 0.275, [0.006, 0.012, 0.016], 0, 0],
+    ['glint', 0.065, [1, 1, 1], -0.19, 0.23],
+  ];
+  const records = [white];
+  let previousFront = front;
+  for (const [role, radius, color, x, y] of layers) {
+    const partScale = (placement.radius * radius * 2) / span(pupil.bounds, 0);
+    // Align visible fronts, not centers: iris and pupil have different depths.
+    // Equal center positions hide the smaller pupil behind the larger iris.
+    const destinationZ =
+      previousFront +
+      0.006 -
+      (pupil.bounds.max[2] - pupilOrigin[2]) * partScale;
+    const layer = await eyeRecord(
+      sourceBytes,
+      pupil,
+      pupilOrigin,
+      partScale,
+      [
+        placement.center[0] + x * placement.radius,
+        placement.center[1] + y * placement.radius,
+        destinationZ,
+      ],
+      role,
+      color,
+    );
+    records.push(layer);
+    previousFront = layer.bounds.max[2];
+  }
+  const eyeIds = new Set(previousEyes.map((p) => p.part));
+  const retained = target.records
+    .filter((p) => !eyeIds.has(p.part) && !hasAuthoredLabel(bytes, p, 'brows'))
+    .map((p) => ({
+      bytes: bytes.slice(p.start, p.end),
+      name: p.name,
+      bounds: p.bounds,
+    }));
+  retained.splice(1, 0, ...records);
+  return assembleAuthoredRecords(target, retained);
+}