@driftengine/assets 4.8.2 → 4.8.4

package/src/index.ts

@@ -235,11 +235,16 @@ export type { Localised } from './localise.ts';
  */
 export { colliderBeside, levelsBeside } from './readModel.ts';
 /*
- * DDS block decoding, for the block-compressed textures a vehicle model carries. Baker work: RGBA
- * is larger than the source and nothing ships a block decoder into a frame.
+ * DDS for the baker: `ddsBlocks` keeps a block-compressed surface's blocks and stored chain for a
+ * `CODEC_BC` texture, and `ddsToRgba` decodes level 0 for what cannot be kept. `decodeBc` is the
+ * block decoder both share with the loader, which runs it on a device that cannot sample BC.
  */
 export { ddsToRgba, isDds } from './dds.ts';
 export type { DdsImage } from './dds.ts';
+export { ddsBlocks } from './ddsBlocks.ts';
+export { decodeBc } from './bcDecode.ts';
+export { decodeBcImage } from './bcImage.ts';
+export { flipBc5Green } from './bcFlip.ts';
 /*
  * **The offline half of the GPU-driven pipeline, which nothing outside this package could reach.**
  *

package/src/influences.ts

@@ -0,0 +1,77 @@
+/**
+ * A vertex's joint influences, sorted, cut to eight and normalised into the two sets a mesh carries.
+ *
+ * **Eight and not four, since 4.8.4.** A rig authored for eight — a face, a shoulder, a hand — loses
+ * the shape of its deformation when the four lightest are dropped, and both importers dropped them.
+ * Heaviest first is the contract the format relies on: the first set always holds the four that
+ * matter most, so a renderer or an older pipeline reading only that set keeps the best four, and
+ * the second set holds what is left. Shared by the glTF and FBX readers so both cut and order the
+ * same way.
+ *
+ * **What it gives up** is anything past eight, renormalised over what is kept, as four was before.
+ * Runs at import, off the frame, so it allocates where that is clearer.
+ */
+
+/** One joint and how much of a vertex it moves. */
+export interface Influence {
+  readonly joint: number;
+  readonly weight: number;
+}
+
+/** The four arrays a mesh's influences land in, four floats per vertex each. */
+export interface InfluenceSets {
+  readonly joints: Float32Array;
+  readonly weights: Float32Array;
+  readonly joints2: Float32Array;
+  readonly weights2: Float32Array;
+}
+
+/** What a vertex's influences needed: dropping past eight, rescaling, and a second set at all. */
+export interface InfluenceReport {
+  readonly dropped: boolean;
+  readonly rescaled: boolean;
+  readonly second: boolean;
+}
+
+/** The most influences a vertex keeps: two sets of four. */
+export const MAX_INFLUENCES = 8;
+
+const NONE: InfluenceReport = Object.freeze({ dropped: false, rescaled: false, second: false });
+
+/**
+ * Write vertex `at`'s influences into `out`, heaviest first: the four heaviest into `joints` and
+ * `weights`, the next four into `joints2` and `weights2`, normalised to sum to one over all kept.
+ * A vertex with no positive weight is left all zero and reported as nothing, because inventing an
+ * influence would move geometry nobody rigged.
+ */
+export function writeInfluences(
+  influences: readonly Influence[] | undefined,
+  out: InfluenceSets,
+  at: number,
+): InfluenceReport {
+  if (influences === undefined || influences.length === 0) return NONE;
+  /* Stable, so equal weights keep the order they arrived in: set 0 before set 1. */
+  const sorted = influences
+    .map((influence, order) => ({ ...influence, order }))
+    .filter((influence) => influence.weight > 0)
+    .sort((a, b) => b.weight - a.weight || a.order - b.order);
+  const kept = sorted.slice(0, MAX_INFLUENCES);
+  let sum = 0;
+  for (const influence of kept) sum += influence.weight;
+  if (sum <= 0) return NONE;
+  for (let i = 0; i < kept.length; i++) {
+    const influence = kept[i] as Influence;
+    const joints = i < 4 ? out.joints : out.joints2;
+    const weights = i < 4 ? out.weights : out.weights2;
+    joints[at * 4 + (i % 4)] = influence.joint;
+    weights[at * 4 + (i % 4)] = influence.weight / sum;
+  }
+  let total = 0;
+  for (const influence of sorted) total += influence.weight;
+  return {
+    dropped: sorted.length > MAX_INFLUENCES,
+    /* A tenth of a per cent, which is wider than float noise and narrower than an authoring slip. */
+    rescaled: Math.abs(total - 1) > 1e-3,
+    second: kept.length > 4,
+  };
+}

package/src/weld.ts

@@ -57,6 +57,9 @@ const ATTRIBUTES = {
   tangents: 4,
   joints: 4,
   weights: 4,
+  /* The fifth to eighth influences, which are per vertex like the first four. */
+  joints2: 4,
+  weights2: 4,
   /*
    * The four-lane per-vertex channel. It joins the key above as well as the copy below, which is
    * the behaviour that matters: two vertices at one position whose sway or sky exposure differ