@aura3d/rendering 1.0.6

package/src/MaterialBinding.ts

@@ -0,0 +1,131 @@
+import { Material } from "./Material";
+import { MaterialInstance } from "./MaterialInstance";
+import { type RenderShaderProgram, type UniformValue } from "./RenderDevice";
+import { TextureBinding } from "./TextureBinding";
+
+export interface MaterialBindingResult {
+  readonly shader: RenderShaderProgram;
+  readonly uniforms: ReadonlyMap<string, UniformValue>;
+  readonly diagnostics: readonly string[];
+  readonly warnings: readonly string[];
+}
+
+export class MaterialBinding {
+  bind(materialLike: Material | MaterialInstance, shader: RenderShaderProgram): MaterialBindingResult {
+    const material = materialLike instanceof MaterialInstance ? materialLike.baseMaterial : materialLike;
+    const uniforms = materialLike.getParameters();
+    const diagnostics: string[] = [];
+    const warnings: string[] = [];
+
+    for (const attribute of material.requiredAttributes) {
+      if (!shader.reflection.attributes.has(attribute)) {
+        diagnostics.push(`Missing shader attribute: ${attribute}`);
+      }
+    }
+    for (const uniform of material.requiredUniforms) {
+      if (!shader.reflection.uniforms.has(uniform)) {
+        diagnostics.push(`Missing shader uniform: ${uniform}`);
+      }
+      if (!uniforms.has(uniform)) {
+        diagnostics.push(`Missing material parameter: ${uniform}`);
+      }
+    }
+    for (const uniform of material.uniformSchema) {
+      if (uniform.required !== false && !shader.reflection.uniforms.has(uniform.name)) {
+        diagnostics.push(`Missing shader uniform declared by material schema: ${uniform.name}`);
+      }
+      const value = uniforms.get(uniform.name);
+      if (value === undefined) {
+        if (uniform.required !== false) {
+          diagnostics.push(`Missing material parameter declared by schema: ${uniform.name}`);
+        }
+        continue;
+      }
+      const typeDiagnostic = validateUniformSchemaValue(uniform.name, uniform.kind, value);
+      if (typeDiagnostic) {
+        diagnostics.push(typeDiagnostic);
+      }
+    }
+    for (const [name, value] of uniforms) {
+      if (value instanceof TextureBinding) {
+        const validation = value.validate();
+        diagnostics.push(...validation.diagnostics);
+        warnings.push(...validation.warnings);
+      } else {
+        const valueDiagnostics = uniformValueDiagnostics(name, value);
+        if (valueDiagnostics.length > 0) {
+          diagnostics.push(...valueDiagnostics);
+        }
+      }
+    }
+    if (diagnostics.length > 0) {
+      throw new MaterialBindingError("Material binding validation failed", diagnostics);
+    }
+    return { shader, uniforms, diagnostics: warnings, warnings };
+  }
+}
+
+export class MaterialBindingError extends Error {
+  constructor(
+    message: string,
+    public readonly diagnostics: readonly string[]
+  ) {
+    super(message);
+    this.name = "MaterialBindingError";
+  }
+}
+
+function uniformValueDiagnostics(name: string, value: unknown): readonly string[] {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? [] : [`Unsupported uniform value for ${name}: non-finite number`];
+  }
+  if (ArrayBuffer.isView(value)) {
+    const values = Array.from(value as Float32Array | Int32Array | Uint32Array);
+    return values.every(Number.isFinite) ? [] : [`Unsupported uniform value for ${name}: typed array contains non-finite values`];
+  }
+  if (Array.isArray(value)) {
+    return value.every((entry) => typeof entry === "number" && Number.isFinite(entry))
+      ? []
+      : [`Unsupported uniform value for ${name}: array must contain finite numbers`];
+  }
+  return [`Unsupported uniform value for ${name}`];
+}
+
+function validateUniformSchemaValue(name: string, kind: string, value: UniformValue): string | null {
+  if (kind === "any") {
+    return null;
+  }
+  if (kind === "texture2d" || kind === "textureCube") {
+    return value instanceof TextureBinding ? null : `Material uniform ${name} must be ${kind}`;
+  }
+  if (value instanceof TextureBinding) {
+    return `Material uniform ${name} must be ${kind}, got texture binding`;
+  }
+  const numbers = typeof value === "number"
+    ? [value]
+    : ArrayBuffer.isView(value)
+      ? Array.from(value as Float32Array | Int32Array | Uint32Array)
+      : Array.from(value);
+  const expected = scalarCount(kind);
+  if (numbers.length !== expected) {
+    return `Material uniform ${name} must be ${kind} with ${expected} scalar values, got ${numbers.length}`;
+  }
+  return numbers.every(Number.isFinite) ? null : `Material uniform ${name} must contain finite ${kind} scalar values`;
+}
+
+function scalarCount(kind: string): number {
+  switch (kind) {
+    case "float":
+      return 1;
+    case "vec2":
+      return 2;
+    case "vec3":
+      return 3;
+    case "vec4":
+      return 4;
+    case "mat4":
+      return 16;
+    default:
+      return 0;
+  }
+}

package/src/MaterialInstance.ts

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,272 @@
+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

@@ -0,0 +1,123 @@
+import { Geometry, type Bounds3 } from "./Geometry";
+import { IndexBuffer } from "./IndexBuffer";
+import { VertexBuffer } from "./VertexBuffer";
+
+export interface MorphTargetDelta {
+  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/MorphUnlitMaterial.ts

@@ -0,0 +1,54 @@
+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_morphWeights", kind: "vec4", required: false },
+        { name: "u_morphTargetCount", kind: "float", 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
+  ]);
+}