@aura3d/rendering 1.4.0 → 1.4.2

package/src/MaterialInstance.ts

@@ -1,59 +0,0 @@
-import { Material } from "./Material";
-import { type UniformValue } from "./RenderDevice";
-import { TextureBinding } from "./TextureBinding";
-
-export class MaterialInstance {
-  private readonly overrides = new Map<string, UniformValue>();
-  private dirty = true;
-  private baseRevision: number;
-
-  constructor(public readonly baseMaterial: Material) {
-    this.baseRevision = baseMaterial.getRevision();
-  }
-
-  setOverride(name: string, value: UniformValue): void {
-    this.overrides.set(name, cloneUniformValue(value));
-    this.dirty = true;
-  }
-
-  clearOverride(name: string): void {
-    if (this.overrides.delete(name)) {
-      this.dirty = true;
-    }
-  }
-
-  getParameter(name: string): UniformValue | undefined {
-    const override = this.overrides.get(name);
-    if (override !== undefined) {
-      return cloneUniformValue(override);
-    }
-    return this.baseMaterial.getParameter(name);
-  }
-
-  getParameters(): ReadonlyMap<string, UniformValue> {
-    const parameters = new Map(this.baseMaterial.getParameters());
-    for (const [key, value] of this.overrides) {
-      parameters.set(key, cloneUniformValue(value));
-    }
-    return parameters;
-  }
-
-  isDirty(): boolean {
-    return this.dirty || this.baseRevision !== this.baseMaterial.getRevision();
-  }
-
-  markClean(): void {
-    this.dirty = false;
-    this.baseRevision = this.baseMaterial.getRevision();
-  }
-}
-
-function cloneUniformValue(value: UniformValue): UniformValue {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (value instanceof TextureBinding) {
-    return value;
-  }
-  return ArrayBuffer.isView(value) ? new (value.constructor as Float32ArrayConstructor)(value as Float32Array) : [...value];
-}

package/src/MaterialPresets.ts

@@ -1,272 +0,0 @@
-import { Material } from "./Material";
-import { PBRMaterial, type PBRMaterialOptions } from "./PBRMaterial";
-import { UnlitMaterial, type UnlitMaterialOptions } from "./UnlitMaterial";
-
-export type MaterialPresetKind = "unlit" | "pbr" | string;
-export type PhysicalMaterialPresetName =
-  | "gold"
-  | "silver"
-  | "copper"
-  | "iron"
-  | "aluminum"
-  | "plastic"
-  | "rubber"
-  | "wood"
-  | "concrete"
-  | "fabric"
-  | "glass"
-  | "water"
-  | "skin"
-  | "eye"
-  | "hair"
-  | "terrain"
-  | "toon";
-
-export type MaterialPresetOptions = Readonly<Record<string, unknown>>;
-
-export type MaterialFactory<TOptions extends MaterialPresetOptions = MaterialPresetOptions> = (options?: TOptions) => Material;
-
-export interface MaterialPresetDescriptor<TOptions extends MaterialPresetOptions = MaterialPresetOptions> {
-  readonly kind: MaterialPresetKind;
-  readonly description?: string;
-  readonly create: MaterialFactory<TOptions>;
-}
-
-export interface PhysicalMaterialPresetDescriptor {
-  readonly name: PhysicalMaterialPresetName;
-  readonly category: "metal" | "dielectric" | "fabric" | "transmission" | "subsurface" | "anisotropic" | "terrain" | "npr";
-  readonly source: "old-branch-material-presets";
-  readonly options: PBRMaterialOptions;
-  readonly knownLimits: readonly string[];
-}
-
-export class MaterialPresetRegistry {
-  private readonly presets = new Map<MaterialPresetKind, MaterialPresetDescriptor>();
-
-  constructor(descriptors: readonly MaterialPresetDescriptor[] = defaultMaterialPresets()) {
-    for (const descriptor of descriptors) {
-      this.register(descriptor);
-    }
-  }
-
-  register<TOptions extends MaterialPresetOptions>(descriptor: MaterialPresetDescriptor<TOptions>): void {
-    if (!descriptor.kind.trim()) {
-      throw new Error("Material preset kind is required.");
-    }
-    if (this.presets.has(descriptor.kind)) {
-      throw new Error(`Material preset already exists: ${descriptor.kind}`);
-    }
-    this.presets.set(descriptor.kind, descriptor as MaterialPresetDescriptor);
-  }
-
-  create<TOptions extends MaterialPresetOptions = MaterialPresetOptions>(kind: MaterialPresetKind, options?: TOptions): Material {
-    const descriptor = this.presets.get(kind);
-    if (!descriptor) {
-      throw new Error(`Unknown material preset: ${kind}`);
-    }
-    return descriptor.create(options);
-  }
-
-  has(kind: MaterialPresetKind): boolean {
-    return this.presets.has(kind);
-  }
-
-  list(): readonly MaterialPresetDescriptor[] {
-    return [...this.presets.values()];
-  }
-}
-
-export function defaultMaterialPresets(): readonly MaterialPresetDescriptor[] {
-  return [
-    {
-      kind: "unlit",
-      description: "Constant color material for debug, UI, and non-lighting-dependent geometry.",
-      create: (options?: MaterialPresetOptions) => new UnlitMaterial(options as UnlitMaterialOptions)
-    },
-    {
-      kind: "pbr",
-      description: "Direct-light physically based material with base color, metallic, roughness, and emissive controls.",
-      create: (options?: MaterialPresetOptions) => new PBRMaterial(options as PBRMaterialOptions)
-    },
-    ...listPhysicalMaterialPresets().map((preset): MaterialPresetDescriptor => ({
-      kind: `physical:${preset.name}`,
-      description: `Old-branch physical material preset port for ${preset.name}.`,
-      create: (options?: MaterialPresetOptions) => createPhysicalMaterialPreset(preset.name, options as Partial<PBRMaterialOptions>)
-    }))
-  ];
-}
-
-export function listPhysicalMaterialPresets(): readonly PhysicalMaterialPresetDescriptor[] {
-  return physicalMaterialPresets;
-}
-
-export function physicalMaterialPresetDescriptor(name: PhysicalMaterialPresetName): PhysicalMaterialPresetDescriptor {
-  const descriptor = physicalMaterialPresets.find((entry) => entry.name === name);
-  if (!descriptor) throw new Error(`Unknown physical material preset: ${name}`);
-  return descriptor;
-}
-
-export function createPhysicalMaterialPreset(name: PhysicalMaterialPresetName, overrides: Partial<PBRMaterialOptions> = {}): PBRMaterial {
-  const descriptor = physicalMaterialPresetDescriptor(name);
-  return new PBRMaterial({
-    ...descriptor.options,
-    ...overrides,
-    name: overrides.name ?? descriptor.options.name ?? `physical-${name}`
-  });
-}
-
-const physicalMaterialPresets: readonly PhysicalMaterialPresetDescriptor[] = [
-  physicalPreset("gold", "metal", {
-    baseColor: [1, 0.782, 0.344, 1],
-    metallic: 1,
-    roughness: 0.2,
-    specularFactor: 1
-  }, ["Gold F0/albedo values are clamped into the current [0,1] PBR parameter range."]),
-  physicalPreset("silver", "metal", {
-    baseColor: [0.972, 0.96, 0.915, 1],
-    metallic: 1,
-    roughness: 0.15,
-    specularFactor: 1
-  }, ["Silver preset uses the current direct PBR shader and generated environment resources, not measured spectral data."]),
-  physicalPreset("copper", "metal", {
-    baseColor: [0.955, 0.638, 0.538, 1],
-    metallic: 1,
-    roughness: 0.25,
-    specularFactor: 1
-  }, ["Copper preset uses bounded RGB material response rather than wavelength-dependent metal reflectance."]),
-  physicalPreset("iron", "metal", {
-    baseColor: [0.56, 0.57, 0.58, 1],
-    metallic: 1,
-    roughness: 0.4,
-    specularFactor: 0.9
-  }, ["Iron preset is a bounded rough metal preset without oxidation or anisotropic brushing."]),
-  physicalPreset("aluminum", "metal", {
-    baseColor: [0.913, 0.921, 0.925, 1],
-    metallic: 1,
-    roughness: 0.3,
-    specularFactor: 0.95
-  }, ["Aluminum preset is isotropic; brushed anisotropy must be enabled through a separate material."]),
-  physicalPreset("plastic", "dielectric", {
-    baseColor: [0.8, 0.8, 0.8, 1],
-    metallic: 0,
-    roughness: 0.5,
-    specularFactor: 0.55
-  }, ["Plastic preset is a neutral dielectric baseline without measured polymer BRDF."]),
-  physicalPreset("rubber", "dielectric", {
-    baseColor: [0.2, 0.2, 0.2, 1],
-    metallic: 0,
-    roughness: 0.9,
-    specularFactor: 0.25
-  }, ["Rubber preset is a rough dark dielectric; subsurface or tire-specific normal detail is supplied by procedural texture fixtures."]),
-  physicalPreset("wood", "dielectric", {
-    baseColor: [0.6, 0.4, 0.2, 1],
-    metallic: 0,
-    roughness: 0.7,
-    specularFactor: 0.35
-  }, ["Wood preset captures bounded base response; grain detail comes from procedural wood textures."]),
-  physicalPreset("concrete", "dielectric", {
-    baseColor: [0.5, 0.5, 0.5, 1],
-    metallic: 0,
-    roughness: 0.85,
-    specularFactor: 0.22
-  }, ["Concrete preset is a rough dielectric response without aggregate displacement."]),
-  physicalPreset("fabric", "fabric", {
-    baseColor: [0.5, 0.3, 0.2, 1],
-    metallic: 0,
-    roughness: 0.8,
-    sheenColorFactor: [0.42, 0.28, 0.22],
-    sheenRoughnessFactor: 0.3,
-    specularFactor: 0.28
-  }, ["Fabric ports old cloth sheen intent into current bounded sheen parameters; fiber scattering parity is not claimed."]),
-  physicalPreset("glass", "transmission", {
-    baseColor: [1, 1, 1, 0.62],
-    roughness: 0,
-    transmissionFactor: 1,
-    transmissionFallbackEnergy: 0.18,
-    volumeThicknessFactor: 0.5,
-    volumeAttenuationDistance: 12,
-    volumeAttenuationColor: [0.94, 0.98, 1],
-    ior: 1.5,
-    specularFactor: 1,
-    renderState: { blend: true, depthWrite: false, cullMode: "none" }
-  }, ["Glass is a bounded transmission fallback in WebGL2; refraction ray marching and Unity/Unreal glass parity remain blocked."]),
-  physicalPreset("water", "transmission", {
-    baseColor: [0, 0.3, 0.5, 0.72],
-    roughness: 0.08,
-    transmissionFactor: 0.58,
-    diffuseTransmissionFactor: 0.18,
-    diffuseTransmissionColorFactor: [0.2, 0.72, 1],
-    volumeThicknessFactor: 0.35,
-    volumeAttenuationDistance: 5,
-    volumeAttenuationColor: [0.1, 0.45, 0.72],
-    ior: 1.333,
-    specularFactor: 0.92,
-    renderState: { blend: true, depthWrite: false, cullMode: "none" }
-  }, ["Water ports old ocean color/reflectivity intent; waves, foam, planar reflection, and caustics are not claimed by this preset."]),
-  physicalPreset("skin", "subsurface", {
-    baseColor: [0.95, 0.8, 0.7, 1],
-    roughness: 0.4,
-    diffuseTransmissionFactor: 0.32,
-    diffuseTransmissionColorFactor: [1, 0.5, 0.3],
-    transmissionFallbackEnergy: 0.1,
-    sheenColorFactor: [0.55, 0.28, 0.2],
-    sheenRoughnessFactor: 0.46,
-    specularFactor: 0.46
-  }, ["Skin ports old subsurface color intent into bounded diffuse-transmission parameters; production SSS is not claimed."]),
-  physicalPreset("eye", "subsurface", {
-    baseColor: [1, 1, 1, 1],
-    roughness: 0.1,
-    diffuseTransmissionFactor: 0.24,
-    diffuseTransmissionColorFactor: [0.8, 0.5, 0.5],
-    clearcoatFactor: 0.75,
-    clearcoatRoughnessFactor: 0.04,
-    specularFactor: 1
-  }, ["Eye preset combines bounded clearcoat and diffuse transmission; cornea/iris layered geometry is not included."]),
-  physicalPreset("hair", "anisotropic", {
-    baseColor: [0.3, 0.2, 0.1, 1],
-    roughness: 0.32,
-    anisotropyStrength: 0.78,
-    anisotropyRotation: -0.15,
-    sheenColorFactor: [0.5, 0.34, 0.18],
-    sheenRoughnessFactor: 0.48,
-    specularFactor: 0.72
-  }, ["Hair ports old anisotropic highlight intent; Marschner-style strand scattering is not claimed."]),
-  physicalPreset("terrain", "terrain", {
-    baseColor: [0.34, 0.44, 0.22, 1],
-    metallic: 0,
-    roughness: 0.88,
-    specularFactor: 0.24,
-    environmentColor: [0.42, 0.48, 0.34],
-    environmentIntensity: 0.12,
-    sheenColorFactor: [0.14, 0.22, 0.1],
-    sheenRoughnessFactor: 0.72
-  }, ["Terrain ports old multi-layer terrain material intent into a bounded rough dielectric preset; splat maps, triplanar blending, and distance texture LOD are not claimed."]),
-  physicalPreset("toon", "npr", {
-    baseColor: [0.92, 0.58, 0.16, 1],
-    metallic: 0,
-    roughness: 0.64,
-    specularFactor: 0.5,
-    clearcoatFactor: 0.24,
-    clearcoatRoughnessFactor: 0.18,
-    emissiveColor: [0.08, 0.035, 0.005],
-    emissiveStrength: 0.55
-  }, ["Toon ports old cel-shading/rim-light material intent into bounded current PBR and emissive parameters; discrete lighting bands, outline rendering, and hatching are not claimed."])
-];
-
-function physicalPreset(
-  name: PhysicalMaterialPresetName,
-  category: PhysicalMaterialPresetDescriptor["category"],
-  options: PBRMaterialOptions,
-  knownLimits: readonly string[]
-): PhysicalMaterialPresetDescriptor {
-  return {
-    name,
-    category,
-    source: "old-branch-material-presets",
-    options: {
-      name: `physical-${name}`,
-      ...options
-    },
-    knownLimits
-  };
-}

package/src/MorphTarget.ts

@@ -1,124 +0,0 @@
-import { Geometry, type Bounds3 } from "./Geometry";
-import { IndexBuffer } from "./IndexBuffer";
-import { VertexBuffer } from "./VertexBuffer";
-
-export interface MorphTargetDelta {
-  readonly name?: string;
-  readonly positions?: readonly (readonly [number, number, number])[];
-  readonly normals?: readonly (readonly [number, number, number])[];
-  readonly tangents?: readonly (readonly [number, number, number])[];
-}
-
-export function applyMorphTargets(
-  geometry: Geometry,
-  targets: readonly MorphTargetDelta[],
-  weights: readonly number[]
-): Geometry {
-  if (targets.length !== weights.length) {
-    throw new Error("Morph target count must match morph weight count.");
-  }
-  const source = geometry.vertexBuffer;
-  const output = new VertexBuffer(source.format, source.vertexCount);
-  for (let vertex = 0; vertex < source.vertexCount; vertex += 1) {
-    for (const attribute of source.format.attributes) {
-      output.setAttribute(vertex, attribute.semantic, source.getAttribute(vertex, attribute.semantic));
-    }
-    if (source.format.hasAttribute("position")) {
-      output.setAttribute(vertex, "position", morphVec3(source.getAttribute(vertex, "position"), targets, weights, vertex, "positions"));
-    }
-    if (source.format.hasAttribute("normal")) {
-      output.setAttribute(vertex, "normal", normalizeVec3(morphVec3(source.getAttribute(vertex, "normal"), targets, weights, vertex, "normals")));
-    }
-    if (source.format.hasAttribute("tangent")) {
-      output.setAttribute(vertex, "tangent", morphTangent(source.getAttribute(vertex, "tangent"), targets, weights, vertex));
-    }
-  }
-  return new Geometry(output, geometry.indexBuffer ? new IndexBuffer(Array.from(geometry.indexBuffer.data), source.vertexCount) : null, geometry.topology);
-}
-
-export function computeMorphTargetEnvelopeBounds(geometry: Geometry, targets: readonly MorphTargetDelta[]): Bounds3 {
-  if (targets.length === 0 || !geometry.vertexBuffer.format.hasAttribute("position")) {
-    return geometry.bounds;
-  }
-  const min: [number, number, number] = [Infinity, Infinity, Infinity];
-  const max: [number, number, number] = [-Infinity, -Infinity, -Infinity];
-  for (let vertex = 0; vertex < geometry.vertexBuffer.vertexCount; vertex += 1) {
-    const base = geometry.vertexBuffer.getAttribute(vertex, "position");
-    const lower: [number, number, number] = [base[0] ?? 0, base[1] ?? 0, base[2] ?? 0];
-    const upper: [number, number, number] = [base[0] ?? 0, base[1] ?? 0, base[2] ?? 0];
-    for (const target of targets) {
-      const delta = target.positions?.[vertex];
-      if (!delta) continue;
-      for (let axis = 0; axis < 3; axis += 1) {
-        const value = delta[axis] ?? 0;
-        if (value < 0) lower[axis] += value;
-        if (value > 0) upper[axis] += value;
-      }
-    }
-    includeBoundsPoint(min, max, lower);
-    includeBoundsPoint(min, max, upper);
-  }
-  if (!Number.isFinite(min[0]) || !Number.isFinite(max[0])) {
-    return geometry.bounds;
-  }
-  return { min, max };
-}
-
-export function computeMorphTargetWeightedBounds(geometry: Geometry, targets: readonly MorphTargetDelta[], weights: readonly number[]): Bounds3 {
-  if (targets.length === 0 || weights.length === 0 || !geometry.vertexBuffer.format.hasAttribute("position")) {
-    return geometry.bounds;
-  }
-  const min: [number, number, number] = [Infinity, Infinity, Infinity];
-  const max: [number, number, number] = [-Infinity, -Infinity, -Infinity];
-  for (let vertex = 0; vertex < geometry.vertexBuffer.vertexCount; vertex += 1) {
-    includeBoundsPoint(min, max, morphVec3(geometry.vertexBuffer.getAttribute(vertex, "position"), targets, weights, vertex, "positions"));
-  }
-  if (!Number.isFinite(min[0]) || !Number.isFinite(max[0])) {
-    return geometry.bounds;
-  }
-  return { min, max };
-}
-
-function morphVec3(
-  base: readonly number[],
-  targets: readonly MorphTargetDelta[],
-  weights: readonly number[],
-  vertex: number,
-  key: "positions" | "normals" | "tangents"
-): readonly [number, number, number] {
-  const result: [number, number, number] = [base[0] ?? 0, base[1] ?? 0, base[2] ?? 0];
-  for (let index = 0; index < targets.length; index += 1) {
-    const weight = weights[index] ?? 0;
-    if (weight === 0) continue;
-    const delta = targets[index]?.[key]?.[vertex];
-    if (!delta) continue;
-    result[0] += delta[0] * weight;
-    result[1] += delta[1] * weight;
-    result[2] += delta[2] * weight;
-  }
-  return result;
-}
-
-function normalizeVec3(value: readonly [number, number, number]): readonly [number, number, number] {
-  const length = Math.hypot(value[0], value[1], value[2]);
-  return length > 1e-9 ? [value[0] / length, value[1] / length, value[2] / length] : [0, 0, 1];
-}
-
-function includeBoundsPoint(min: [number, number, number], max: [number, number, number], point: readonly [number, number, number]): void {
-  min[0] = Math.min(min[0], point[0]);
-  min[1] = Math.min(min[1], point[1]);
-  min[2] = Math.min(min[2], point[2]);
-  max[0] = Math.max(max[0], point[0]);
-  max[1] = Math.max(max[1], point[1]);
-  max[2] = Math.max(max[2], point[2]);
-}
-
-function morphTangent(
-  base: readonly number[],
-  targets: readonly MorphTargetDelta[],
-  weights: readonly number[],
-  vertex: number
-): readonly [number, number, number, number] {
-  const morphed = normalizeVec3(morphVec3(base, targets, weights, vertex, "tangents"));
-  return [morphed[0], morphed[1], morphed[2], base[3] ?? 1];
-}

package/src/MorphTargetPlan.ts

@@ -1,178 +0,0 @@
-// Morph-target planning + packing. Decides how a set of morph targets should be uploaded to the
-// GPU and packs the delta data accordingly:
-//
-//   - "uniform": small counts (<= the uniform cap) pack into the fixed uniform arrays the
-//     morph-unlit shader already reads (fast path, no texture).
-//   - "texture": larger counts pack position (and optional normal) deltas into an RGBA float data
-//     texture indexed by (vertex, target), lifting the flat 4-target / 64-vertex uniform ceiling up
-//     to the device's texture-size limit. This is the path that lets a real facial rig (ARKit ≈ 52
-//     blendshapes over thousands of vertices) run on the GPU.
-//   - Anything that exceeds even the texture limit falls back to the CPU morph (applyMorphTargets),
-//     which is unlimited and already morphs normals + tangents.
-//
-// Pure and deterministic: given the same targets/weights it always produces the same plan.
-
-import type { MorphTargetDelta } from "./MorphTarget";
-
-/** Fixed uniform-array fast-path capacities (must match the morph-unlit shader's array sizes). */
-export const MORPH_UNIFORM_MAX_TARGETS = 4;
-export const MORPH_UNIFORM_MAX_VERTICES = 64;
-
-export interface MorphDeviceLimits {
-  /** Max texture dimension (texels) per axis. WebGL2/WebGPU baseline is 4096+. */
-  readonly maxTextureSize: number;
-}
-
-export const DEFAULT_MORPH_DEVICE_LIMITS: MorphDeviceLimits = { maxTextureSize: 4096 };
-
-export type MorphPlanMode = "uniform" | "texture" | "cpu";
-
-export interface MorphPlanDecision {
-  readonly mode: MorphPlanMode;
-  readonly targetCount: number;
-  readonly vertexCount: number;
-  readonly morphsNormals: boolean;
-  /** Rows of texels per target in texture mode (1 = positions only, 2 = positions + normals). */
-  readonly rowsPerTarget: number;
-  readonly textureWidth: number;
-  readonly textureHeight: number;
-  /** Why this mode was chosen (telemetry / gate detail). */
-  readonly reason: string;
-}
-
-export interface MorphTargetPlan extends MorphPlanDecision {
-  /**
-   * RGBA float texels for texture mode (length = textureWidth*textureHeight*4), laid out as
-   * row-major (y = target*rowsPerTarget + attributeRow, x = vertex). Empty for non-texture modes.
-   */
-  readonly textureData: Float32Array;
-  /** Packed uniform arrays for uniform mode (positions/normals), empty for other modes. */
-  readonly uniformPositionDeltas: Float32Array;
-  readonly uniformNormalDeltas: Float32Array;
-  readonly uniformWeights: Float32Array;
-}
-
-/** Decide the upload mode + dimensions for a morph set without packing data. Deterministic. */
-export function planMorphTargets(
-  targetCount: number,
-  vertexCount: number,
-  morphsNormals: boolean,
-  limits: MorphDeviceLimits = DEFAULT_MORPH_DEVICE_LIMITS
-): MorphPlanDecision {
-  const rowsPerTarget = morphsNormals ? 2 : 1;
-  if (targetCount <= MORPH_UNIFORM_MAX_TARGETS && vertexCount <= MORPH_UNIFORM_MAX_VERTICES) {
-    return {
-      mode: "uniform",
-      targetCount,
-      vertexCount,
-      morphsNormals,
-      rowsPerTarget,
-      textureWidth: 0,
-      textureHeight: 0,
-      reason: `within uniform cap (${MORPH_UNIFORM_MAX_TARGETS} targets / ${MORPH_UNIFORM_MAX_VERTICES} verts)`
-    };
-  }
-  const textureWidth = vertexCount;
-  const textureHeight = targetCount * rowsPerTarget;
-  if (textureWidth <= limits.maxTextureSize && textureHeight <= limits.maxTextureSize) {
-    return {
-      mode: "texture",
-      targetCount,
-      vertexCount,
-      morphsNormals,
-      rowsPerTarget,
-      textureWidth,
-      textureHeight,
-      reason: `texture-backed (${textureWidth}x${textureHeight} <= ${limits.maxTextureSize})`
-    };
-  }
-  return {
-    mode: "cpu",
-    targetCount,
-    vertexCount,
-    morphsNormals,
-    rowsPerTarget,
-    textureWidth: 0,
-    textureHeight: 0,
-    reason: `exceeds texture limit ${limits.maxTextureSize}; CPU morph fallback`
-  };
-}
-
-/**
- * Plan AND pack a morph set. For "uniform" mode, fills the uniform arrays (position + normal
- * deltas). For "texture" mode, fills the RGBA float texture. "cpu" mode leaves both empty (the
- * caller should run `applyMorphTargets`). Deterministic.
- */
-export function createMorphTargetPlan(
-  targets: readonly MorphTargetDelta[],
-  weights: readonly number[],
-  vertexCount: number,
-  limits: MorphDeviceLimits = DEFAULT_MORPH_DEVICE_LIMITS
-): MorphTargetPlan {
-  if (targets.length !== weights.length) {
-    throw new Error("Morph target count must match morph weight count.");
-  }
-  const morphsNormals = targets.some((t) => t.normals && t.normals.length > 0);
-  const decision = planMorphTargets(targets.length, vertexCount, morphsNormals, limits);
-  const uniformWeights = new Float32Array(Math.max(MORPH_UNIFORM_MAX_TARGETS, targets.length));
-  for (let i = 0; i < weights.length; i += 1) uniformWeights[i] = weights[i] ?? 0;
-
-  if (decision.mode === "uniform") {
-    const positions = new Float32Array(MORPH_UNIFORM_MAX_TARGETS * MORPH_UNIFORM_MAX_VERTICES * 4);
-    const normals = new Float32Array(MORPH_UNIFORM_MAX_TARGETS * MORPH_UNIFORM_MAX_VERTICES * 4);
-    for (let t = 0; t < targets.length; t += 1) {
-      const target = targets[t]!;
-      for (let v = 0; v < vertexCount; v += 1) {
-        const offset = (t * MORPH_UNIFORM_MAX_VERTICES + v) * 4;
-        writeVec3(positions, offset, target.positions?.[v]);
-        writeVec3(normals, offset, target.normals?.[v]);
-      }
-    }
-    return {
-      ...decision,
-      textureData: new Float32Array(0),
-      uniformPositionDeltas: positions,
-      uniformNormalDeltas: normals,
-      uniformWeights: uniformWeights.slice(0, MORPH_UNIFORM_MAX_TARGETS)
-    };
-  }
-
-  if (decision.mode === "texture") {
-    const { textureWidth, textureHeight, rowsPerTarget } = decision;
-    const data = new Float32Array(textureWidth * textureHeight * 4);
-    for (let t = 0; t < targets.length; t += 1) {
-      const target = targets[t]!;
-      const posRow = t * rowsPerTarget;
-      for (let v = 0; v < vertexCount; v += 1) {
-        writeVec3(data, (posRow * textureWidth + v) * 4, target.positions?.[v]);
-        if (rowsPerTarget === 2) {
-          writeVec3(data, ((posRow + 1) * textureWidth + v) * 4, target.normals?.[v]);
-        }
-      }
-    }
-    return {
-      ...decision,
-      textureData: data,
-      uniformPositionDeltas: new Float32Array(0),
-      uniformNormalDeltas: new Float32Array(0),
-      uniformWeights
-    };
-  }
-
-  // cpu mode
-  return {
-    ...decision,
-    textureData: new Float32Array(0),
-    uniformPositionDeltas: new Float32Array(0),
-    uniformNormalDeltas: new Float32Array(0),
-    uniformWeights
-  };
-}
-
-function writeVec3(out: Float32Array, offset: number, delta: readonly number[] | undefined): void {
-  if (!delta) return;
-  out[offset] = delta[0] ?? 0;
-  out[offset + 1] = delta[1] ?? 0;
-  out[offset + 2] = delta[2] ?? 0;
-  out[offset + 3] = 0;
-}

package/src/MorphUnlitMaterial.ts

@@ -1,60 +0,0 @@
-import { Material } from "./Material";
-import { DEFAULT_MORPH_UNLIT_SHADER_NAME } from "./ShaderLibrary";
-
-export interface MorphUnlitMaterialOptions {
-  readonly name?: string;
-  readonly color?: readonly [number, number, number, number];
-}
-
-export class MorphUnlitMaterial extends Material {
-  constructor(options: MorphUnlitMaterialOptions = {}) {
-    const color = options.color ?? [1, 1, 1, 1];
-    validateColor(color);
-    super({
-      name: options.name ?? "morph-unlit",
-      shaderKey: DEFAULT_MORPH_UNLIT_SHADER_NAME,
-      parameters: {
-        u_baseColor: color,
-        u_modelViewProjection: identityMatrix()
-      },
-      requiredAttributes: ["a_position"],
-      uniformSchema: [
-        { name: "u_baseColor", kind: "vec4" },
-        { name: "u_modelViewProjection", kind: "mat4" },
-        { name: "u_morphPositionDeltas", kind: "any", required: false },
-        { name: "u_morphNormalDeltas", kind: "any", required: false },
-        { name: "u_morphWeights", kind: "vec4", required: false },
-        { name: "u_morphTargetCount", kind: "float", required: false },
-        { name: "u_morphDeltaTexture", kind: "any", required: false },
-        { name: "u_morphUsesTexture", kind: "float", required: false },
-        { name: "u_morphTextureWidth", kind: "float", required: false },
-        { name: "u_morphRowsPerTarget", kind: "float", required: false },
-        { name: "u_morphWeightArray", kind: "any", required: false }
-      ]
-    });
-  }
-
-  set color(value: readonly [number, number, number, number]) {
-    validateColor(value);
-    this.setParameter("u_baseColor", value);
-  }
-
-  get color(): readonly [number, number, number, number] {
-    return this.getParameter("u_baseColor") as readonly [number, number, number, number];
-  }
-}
-
-function validateColor(color: readonly [number, number, number, number]): void {
-  if (color.length !== 4 || color.some((channel) => channel < 0 || channel > 1 || !Number.isFinite(channel))) {
-    throw new Error("MorphUnlitMaterial color must contain four finite values in [0, 1]");
-  }
-}
-
-function identityMatrix(): Float32Array {
-  return new Float32Array([
-    1, 0, 0, 0,
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1
-  ]);
-}