@oxy.so/bloom 7.1.1 → 7.1.4

package/assets/character-runtime/catalog-parts.mjs

@@ -0,0 +1,362 @@
+// Compatibility comes from original native donor meshes, never a fake enabled
+// catalog selection. Source assemblies and the target's activity payload stay
+// in the original renderer.
+import { decodeAppearance, encodeAppearance } from './appearance-codec.mjs';
+import {
+  authoredAssemblyRecords,
+  authoredEyeRecords,
+  assembleAuthoredRecords,
+  fitCatalogPartRecords,
+  transformAuthoredRecord,
+} from './authored-parts.mjs';
+import { NATIVE_PARTS } from './character-recipe.mjs';
+import { sha256 } from './sha256.mjs';
+const encoder = new TextEncoder();
+const fail = (message) => {
+  throw Error(`Catalog avatar parts: ${message}`);
+};
+const references = new Map();
+let retainedBytes = 0;
+const MAXIMUM_BYTES = 8 * 1024 * 1024;
+const originalPaint = new Map();
+/** Read an unnamed paint from the actual original body material, not a palette approximation. */
+export function originalBodyColor(module, preset) {
+  if (originalPaint.has(preset)) return originalPaint.get(preset);
+  const result = module.orbitPrepareAssembly(
+    module.presetAppearance(preset),
+    0,
+    `original-paint:${preset}`,
+    false,
+  );
+  if (!result.bytes || result.error)
+    fail(result.error || 'original body paint missing');
+  const bytes = result.bytes,
+    view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (
+    bytes.length < 48 ||
+    view.getUint32(0, true) < 1 ||
+    view.getUint32(28, true) !== 1
+  )
+    fail('unrecognized original body paint layout');
+  const rgb = [0, 1, 2].map((k) => view.getFloat32(32 + k * 4, true));
+  if (rgb.some((v) => !Number.isFinite(v) || v < 0 || v > 1))
+    fail('invalid original body paint');
+  const hex =
+    '#' +
+    rgb
+      .map((v) =>
+        Math.round(v * 255)
+          .toString(16)
+          .padStart(2, '0'),
+      )
+      .join('');
+  originalPaint.set(preset, hex);
+  return hex;
+}
+/** Editable backing paint, with the original RGB retained for unnamed colors. */
+export function originalPalettePaint(module, preset) {
+  const color = decodeAppearance(module.presetAppearance(preset)).color;
+  return module.catalog(1).some((item) => item.id === color)
+    ? { color }
+    : { color: 'yellow', bodyColor: originalBodyColor(module, preset) };
+}
+export function recordHasLabel(info, part, label) {
+  const needle = encoder.encode(label),
+    bytes = info.bytes;
+  for (
+    let at = part.start + 24;
+    at + 4 + needle.length <= part.nameOffset - 4;
+    at++
+  )
+    if (
+      new DataView(bytes.buffer, bytes.byteOffset + at, 4).getUint32(
+        0,
+        true,
+      ) === needle.length &&
+      needle.every((v, i) => bytes[at + 4 + i] === v)
+    )
+      return true;
+  return false;
+}
+function isCategory(info, part, category) {
+  const ids =
+    category === 'eyes'
+      ? [...NATIVE_PARTS.eyes, 'source_integrated_eye', 'brows']
+      : NATIVE_PARTS[category].filter((id) => id !== 'none');
+  return ids.some((id) => recordHasLabel(info, part, id));
+}
+function record(info, part) {
+  return {
+    bytes: info.bytes.slice(part.start, part.end),
+    name: part.name,
+    bounds: part.bounds,
+  };
+}
+function mappedFaceReference(module, appearance, request) {
+  const result = module.orbitPrepareAssembly(
+    appearance,
+    request.quality,
+    `${request.key}:uncovered-donor`,
+    false,
+  );
+  if (!result.bytes || result.error) return null;
+  const info = authoredAssemblyRecords(result.bytes.slice());
+  return info.records.slice(1).some((part) => isCategory(info, part, 'eyes'))
+    ? info
+    : null;
+}
+async function reference(module, category, id, request) {
+  const key = JSON.stringify([category, id, request.quality]);
+  if (references.has(key)) {
+    const cached = references.get(key);
+    references.delete(key);
+    references.set(key, cached);
+    return cached;
+  }
+  if (category === 'eyes' && id === 'todd') {
+    const result = module.orbitPrepareAssembly(
+      module.presetAppearance('lime_frog'),
+      request.quality,
+      `${request.key}:donor:eyes:todd`,
+      false,
+    );
+    if (!result.bytes || result.error)
+      fail(result.error || 'Todd eye donor missing');
+    const info = authoredAssemblyRecords(result.bytes.slice());
+    if (!authoredEyeRecords(info).length) fail('Todd eye meshes missing');
+    return info;
+  }
+  if (category === 'accessory' && id === 'felipe_beret') {
+    const result = module.orbitPrepareAssembly(
+      module.presetAppearance('blue_beret'),
+      request.quality,
+      `${request.key}:donor:accessory:felipe_beret`,
+      false,
+    );
+    if (!result.bytes || result.error)
+      fail(result.error || 'Felipe beret donor missing');
+    const info = authoredAssemblyRecords(result.bytes.slice());
+    if (
+      !info.records
+        .slice(1)
+        .some((part) => recordHasLabel(info, part, 'beret'))
+    )
+      fail('Felipe beret mesh missing');
+    return info;
+  }
+  const shapes = module.catalog(0).map((item) => item.id),
+    eyes =
+      category === 'eyes'
+        ? [id]
+        : ['oval', ...NATIVE_PARTS.eyes.filter((id) => id !== 'oval')];
+  let donor;
+  for (const shape of ['circle', ...shapes.filter((id) => id !== 'circle')]) {
+    for (const eye of eyes) {
+      const appearance = encodeAppearance({
+        version: 1,
+        shape,
+        color: 'blue',
+        eyes: eye,
+        eyewear: category === 'eyewear' ? id : 'none',
+        accessories: category === 'accessory' ? [id] : [],
+        accessoryColors: {},
+        constrained: 0,
+        depth: 0.5,
+        model: null,
+        rig: null,
+        hereCharacter: null,
+      });
+      const result = module.orbitPrepareAssembly(
+        appearance,
+        request.quality,
+        `${request.key}:donor:${category}:${id}:${shape}:${eye}`,
+        false,
+      );
+      if (!result.bytes || result.error) continue;
+      let info = authoredAssemblyRecords(result.bytes.slice());
+      if (!info.records.slice(1).some((part) => recordHasLabel(info, part, id)))
+        continue;
+      if (
+        !info.records.slice(1).some((part) => isCategory(info, part, 'eyes'))
+      ) {
+        const exposed = decodeAppearance(appearance);
+        exposed.eyewear = 'none';
+        const face = mappedFaceReference(
+          module,
+          encodeAppearance(exposed),
+          request,
+        );
+        if (!face) continue;
+        const records = info.records.map((part) => record(info, part));
+        records.splice(
+          1,
+          0,
+          ...face.records
+            .slice(1)
+            .filter((part) => isCategory(face, part, 'eyes'))
+            .map((part) => record(face, part)),
+        );
+        info = authoredAssemblyRecords(
+          await assembleAuthoredRecords(info, records),
+        );
+      }
+      donor = info;
+      break;
+    }
+    if (donor) break;
+  }
+  if (!donor) fail(`no original donor for ${category}:${id}`);
+  if (donor.bytes.length <= MAXIMUM_BYTES) {
+    references.set(key, donor);
+    retainedBytes += donor.bytes.length;
+    while (references.size > 24 || retainedBytes > MAXIMUM_BYTES) {
+      const first = references.keys().next().value;
+      retainedBytes -= references.get(first).bytes.length;
+      references.delete(first);
+    }
+  }
+  return donor;
+}
+/** Keep actual named-preset geometry/default pieces when only parts or paint
+ * change. Original untouched presets never enter this adapter. */
+export async function composePresetBody(module, bytes, request) {
+  const preset = request.authoredParts?.bodyPreset;
+  if (!preset) return bytes;
+  const prepared = module.orbitPrepareAssembly(
+    module.presetAppearance(preset),
+    request.quality,
+    `${request.key}:body:${preset}`,
+    request.activities,
+  );
+  if (!prepared.bytes || prepared.error)
+    fail(prepared.error || 'original preset body missing');
+  const source = authoredAssemblyRecords(prepared.bytes.slice()),
+    target = authoredAssemblyRecords(bytes),
+    records = source.records.map((part) => record(source, part));
+  if (
+    !source.records.slice(1).some((part) => isCategory(source, part, 'eyes'))
+  ) {
+    // Opaque sunglasses legitimately omit the original eye meshes. Recover the
+    // engine's actual hidden-eye reference without changing the preserved body.
+    const exposed = decodeAppearance(module.presetAppearance(preset));
+    exposed.hereCharacter = null;
+    exposed.eyewear = 'none';
+    if (exposed.model) exposed.model.eyewear = null;
+    const result = module.orbitPrepareAssembly(
+      encodeAppearance(exposed),
+      request.quality,
+      `${request.key}:hidden-eyes:${preset}`,
+      false,
+    );
+    if (!result.bytes || result.error)
+      fail(result.error || 'hidden original eye reference missing');
+    const face = authoredAssemblyRecords(result.bytes.slice()),
+      eyes = face.records
+        .slice(1)
+        .filter((part) => isCategory(face, part, 'eyes'));
+    if (!eyes.length) fail('hidden original eye classification missing');
+    records.splice(1, 0, ...eyes.map((part) => record(face, part)));
+  }
+
+  if (request.authoredParts.paintBody) {
+    const out = new DataView(records[0].bytes.buffer),
+      sourceView = new DataView(source.bytes.buffer, source.bytes.byteOffset),
+      targetView = new DataView(target.bytes.buffer, target.bytes.byteOffset);
+    if (
+      sourceView.getUint32(source.body.start + 24, true) !== 1 ||
+      targetView.getUint32(target.body.start + 24, true) !== 1
+    )
+      fail('unrecognized body paint layout');
+    for (const at of [28, 60])
+      for (let k = 0; k < 3; k++)
+        out.setFloat32(
+          at + k * 4,
+          targetView.getFloat32(target.body.start + at + k * 4, true),
+          true,
+        );
+    const hash = await sha256(records[0].bytes);
+    records[0].bytes.set(
+      encoder.encode(hash),
+      source.body.nameOffset - source.body.start,
+    );
+    records[0].name = hash + source.body.name.slice(64);
+  }
+  // Preserve the body's actual authored activity payload and fitted hands,
+  // instead of borrowing the neutral backing circle's fit.
+  const footer = source.footer.slice(),
+    view = new DataView(footer.buffer);
+  for (let k = 0; k < 3; k++) {
+    view.setFloat32(28 + k * 4, source.body.bounds.min[k], true);
+    view.setFloat32(40 + k * 4, source.body.bounds.max[k], true);
+  }
+  return assembleAuthoredRecords(
+    { ...source, body: { ...source.body, name: records[0].name }, footer },
+    records,
+  );
+}
+/** Native catalog pieces can be transplanted onto any actual body. */
+export async function composeCatalogParts(
+  module,
+  bytes,
+  request,
+  categories = ['eyes', 'eyewear', 'accessory'],
+) {
+  let info = authoredAssemblyRecords(bytes);
+  for (const category of categories) {
+    const id = request.authoredParts?.[category];
+    if (!id) continue;
+    // An authored body's own eye style already has its exact sculpted layout.
+    if (
+      category === 'eyes' &&
+      request.authoredParts.bodyPreset &&
+      authoredEyeRecords(info).length &&
+      authoredEyeRecords(info).every((p) => recordHasLabel(info, p, id))
+    )
+      continue;
+    const virtual =
+      (category === 'accessory' && id === 'felipe_beret') ||
+      (category === 'eyes' && id === 'todd');
+    if (!NATIVE_PARTS[category].includes(id) && !virtual) continue;
+    const records = info.records.map((part) => record(info, part));
+    const removed = new Set(
+      info.records
+        .slice(1)
+        .filter((part) => isCategory(info, part, category))
+        .map((part) => part.part),
+    );
+    if (category === 'eyes' && !removed.size)
+      fail('target face classification missing');
+    let fitted = [];
+    if (id !== 'none') {
+      const donor = await reference(module, category, id, request);
+      const transforms = fitCatalogPartRecords(
+        info,
+        donor,
+        category,
+        id === 'felipe_beret' ? 'beret' : id,
+        {
+          singleEye: request.authoredParts?.eyes === 'cyclops',
+          faceLayout: request.faceLayout,
+        },
+      );
+      fitted = await Promise.all(
+        transforms.map(({ part, ...transform }) =>
+          transformAuthoredRecord(donor.bytes, part, transform),
+        ),
+      );
+    }
+    const kept = records.filter((_, index) => !removed.has(index));
+    const at = category === 'eyes' ? 1 : kept.length;
+    kept.splice(at, 0, ...fitted);
+    bytes = await assembleAuthoredRecords(info, kept);
+    info = authoredAssemblyRecords(bytes);
+  }
+  return bytes;
+}
+export function catalogPartCacheStats() {
+  return {
+    entries: references.size,
+    bytes: retainedBytes,
+    maximumBytes: MAXIMUM_BYTES,
+  };
+}

package/assets/character-runtime/character-recipe.mjs

@@ -0,0 +1,247 @@
+/** Resolve editable defaults without passing virtual catalog IDs to the engine. */
+import { MIGRATED_CONTOURS } from './migrated-contours.mjs';
+export function isLegacyRecipe(props) {
+  return !props.config.character || props.config.character.preset === 'bloom';
+}
+export const MIGRATED_SHAPE_IDS = Object.freeze([
+  'slender',
+  'pocket',
+  'petal',
+  'star',
+  'cloud',
+  'shield',
+  'pebble',
+  'squircle',
+]);
+export function withCharacterGeometry(props) {
+  const shape = props.config.character?.selections?.shape;
+  if (!Object.hasOwn(MIGRATED_CONTOURS, shape)) return props;
+  return {
+    ...props,
+    legacy: props.legacy?.points
+      ? props.legacy
+      : { points: MIGRATED_CONTOURS[shape] },
+  };
+}
+const PRESET_DEFAULTS = Object.freeze({
+  blue_beret: {
+    shape: 'six_lobed_flower',
+    eyes: 'oval',
+    eyewear: 'none',
+    accessory: 'felipe_beret',
+  },
+  alfred: {
+    shape: 'rounded_triangle',
+    eyes: 'sleepy_lids',
+    eyewear: 'tall_oval_frames',
+    accessory: 'bow',
+  },
+  purple_heart: {
+    shape: 'heart',
+    eyes: 'oval',
+    eyewear: 'round_sunglasses',
+    accessory: 'none',
+  },
+  lime_frog: {
+    shape: 'rounded_head_two_ears',
+    eyes: 'todd',
+    eyewear: 'none',
+    accessory: 'bow',
+  },
+  coral_monocle: {
+    shape: 'twelve_scalloped_rosette',
+    eyes: 'double_highlights',
+    eyewear: 'monocle',
+    accessory: 'none',
+  },
+  gus: {
+    shape: 'rounded_diamond',
+    eyes: 'oval',
+    eyewear: 'classic_sunglasses',
+    accessory: 'orb',
+  },
+  blue_spectacles: {
+    shape: 'rounded_cube',
+    eyes: 'crescent_inset',
+    eyewear: 'tall_oval_frames',
+    accessory: 'three_lobe',
+  },
+  lime_headphones: {
+    shape: 'circle_two_ears',
+    eyes: 'swept_lids',
+    eyewear: 'none',
+    accessory: 'headphones',
+  },
+});
+export function characterRecipe(props) {
+  if (props.legacy && isLegacyRecipe(props))
+    return {
+      preset: 'legacy',
+      selections: {
+        shape: props.legacy.shape ?? 'circle',
+        eyes: props.legacy.eyes ?? 'oval',
+        ...props.legacy.selections,
+      },
+      ...props.legacy.patch,
+      ...(props.legacy.eyeSpacing !== undefined
+        ? { eyeSpacing: props.legacy.eyeSpacing }
+        : {}),
+    };
+  const recipe = props.config.character;
+  if (recipe?.preset !== 'clippo') return recipe;
+  return {
+    ...recipe,
+    selections: { shape: 'clippo', eyes: 'clippo', ...recipe.selections },
+    // A palette selection is an explicit replacement of the preset's grey.
+    ...(!recipe.bodyColor && !recipe.selections?.color
+      ? { bodyColor: '#999b9d' }
+      : {}),
+  };
+}
+
+export function authoredPartsFor(props) {
+  const recipe = characterRecipe(props);
+  const selections = recipe?.selections ?? {};
+  const customized = Boolean(
+    props.legacy || recipe?.bodyColor || Object.keys(selections).length,
+  );
+  const defaults = !isLegacyRecipe(props)
+    ? PRESET_DEFAULTS[recipe.preset]
+    : undefined;
+  const selectedShape = selections.shape ?? defaults?.shape;
+  const shape =
+    selectedShape === 'todd' ? 'rounded_head_two_ears' : selectedShape;
+  const eyes =
+    selections.eyes ??
+    defaults?.eyes ??
+    (customized && recipe?.preset === 'lime_frog' ? 'todd' : undefined);
+  const accessory =
+    selections.accessory ??
+    defaults?.accessory ??
+    (customized && recipe?.preset === 'blue_beret'
+      ? 'felipe_beret'
+      : undefined);
+  if (!customized) return {};
+  const bodyPreset =
+    !shape &&
+    !isLegacyRecipe(props) &&
+    ORIGINAL_PRESETS.includes(recipe?.preset)
+      ? recipe.preset
+      : undefined;
+  return {
+    ...(bodyPreset ? { bodyPreset } : {}),
+    ...(bodyPreset &&
+    (recipe.bodyColor || selections.color || bodyPreset !== recipe.preset)
+      ? { paintBody: true }
+      : {}),
+    ...(selections.shape === 'clippo' ? { shape: 'clippo' } : {}),
+    ...((!isLegacyRecipe(props) || !props.legacy?.points) &&
+    (MIGRATED_SHAPE_IDS.includes(shape) || NATIVE_PARTS.shape.includes(shape))
+      ? { faceShape: shape }
+      : {}),
+    ...(eyes ? { eyes } : {}),
+    ...((selections.eyewear ?? defaults?.eyewear)
+      ? { eyewear: selections.eyewear ?? defaults?.eyewear }
+      : {}),
+    ...(accessory ? { accessory } : {}),
+  };
+}
+export const ORIGINAL_PRESETS = Object.freeze([
+  'blue_beret',
+  'alfred',
+  'purple_heart',
+  'lime_frog',
+  'coral_monocle',
+  'gus',
+  'blue_spectacles',
+  'lime_headphones',
+]);
+// Exact shapes reported by the original engine's eight named appearances.
+const BODY_SIGNATURES = Object.freeze({
+  six_lobed_flower: 'blue_beret',
+  rounded_triangle: 'alfred',
+  heart: 'purple_heart',
+  rounded_head_two_ears: 'lime_frog',
+  twelve_scalloped_rosette: 'coral_monocle',
+  rounded_diamond: 'gus',
+  rounded_cube: 'blue_spectacles',
+  circle_two_ears: 'lime_headphones',
+  todd: 'lime_frog',
+});
+/** The body's authored reaction follows its geometry, independently of its pieces. */
+export function bodySignatureFor(props) {
+  const recipe = characterRecipe(props),
+    parts = authoredPartsFor(props);
+  if (parts.bodyPreset) return parts.bodyPreset;
+  if (
+    !isLegacyRecipe(props) &&
+    !recipe.selections?.shape &&
+    ORIGINAL_PRESETS.includes(recipe.preset)
+  )
+    return recipe.preset;
+  // Distinct migrated contours and Clippo use Todd's original signature as the
+  // shared standard; they never fall back to the original Wave/maracas.
+  if (props.legacy?.points) return 'lime_frog';
+  return (
+    BODY_SIGNATURES[
+      recipe.selections?.shape ?? PRESET_DEFAULTS[recipe.preset]?.shape
+    ] ?? 'lime_frog'
+  );
+}
+/** Prepared authored bodies retain their actual defaults, not the fitting scene's catalog selections. */
+export function bodySelectionDefaults(preset, appearance) {
+  return {
+    shape: appearance.shape,
+    eyes: preset === 'lime_frog' ? 'todd' : appearance.eyes,
+    eyewear: appearance.eyewear ?? 'none',
+    accessory:
+      preset === 'blue_beret'
+        ? 'felipe_beret'
+        : (appearance.accessories?.[0] ?? 'none'),
+  };
+}
+export const NATIVE_PARTS = Object.freeze({
+  shape: Object.freeze([
+    'circle',
+    'rounded_triangle',
+    'capsule',
+    'rounded_head_two_ears',
+    'six_lobed_flower',
+    'heart',
+    'four_lobed_butterfly',
+    'circle_two_ears',
+    'twelve_scalloped_rosette',
+    'rounded_cube',
+    'rounded_diamond',
+  ]),
+  eyes: Object.freeze([
+    'swept_lids',
+    'oval',
+    'sparkle_capsules',
+    'highlight_capsules',
+    'dots',
+    'double_highlights',
+    'round_inset',
+    'crescent_inset',
+    'sleepy_lids',
+  ]),
+  eyewear: Object.freeze([
+    'none',
+    'monocle',
+    'tall_oval_frames',
+    'separate_trapezoid_lenses',
+    'classic_sunglasses',
+    'round_sunglasses',
+  ]),
+  accessory: Object.freeze([
+    'none',
+    'headphones',
+    'bow',
+    'beanie',
+    'hat',
+    'beret',
+    'orb',
+    'three_lobe',
+    'crown',
+  ]),
+});