@aura3d/rendering 1.4.0 → 1.4.2

package/src/TexturedUnlitMaterial.ts

@@ -1,67 +0,0 @@
-import { Material, type RenderState } from "./Material";
-import { DEFAULT_TEXTURED_UNLIT_SHADER_NAME } from "./ShaderLibrary";
-import { Sampler } from "./Sampler";
-import { Texture } from "./Texture";
-import { TextureBinding } from "./TextureBinding";
-
-export interface TexturedUnlitMaterialOptions {
-  readonly name?: string;
-  readonly texture: Texture;
-  readonly sampler?: Sampler;
-  readonly textureTransform?: {
-    readonly offset?: readonly [number, number];
-    readonly scale?: readonly [number, number];
-    readonly rotation?: number;
-  };
-  readonly color?: readonly [number, number, number, number];
-  readonly renderState?: Partial<RenderState>;
-}
-
-export class TexturedUnlitMaterial extends Material {
-  constructor(options: TexturedUnlitMaterialOptions) {
-    const color = options.color ?? [1, 1, 1, 1];
-    validateColor(color);
-    super({
-      name: options.name ?? "textured-unlit",
-      shaderKey: DEFAULT_TEXTURED_UNLIT_SHADER_NAME,
-      renderState: options.renderState,
-      parameters: {
-        u_baseColor: color,
-        u_baseColorTexture: new TextureBinding({
-          name: "u_baseColorTexture",
-          texture: options.texture,
-          sampler: options.sampler,
-          transform: options.textureTransform
-        }),
-        u_baseColorTextureOffset: options.textureTransform?.offset ?? [0, 0],
-        u_baseColorTextureScale: options.textureTransform?.scale ?? [1, 1],
-        u_baseColorTextureRotation: options.textureTransform?.rotation ?? 0,
-        u_modelViewProjection: identityMatrix()
-      },
-      requiredAttributes: ["a_position", "a_uv"],
-      uniformSchema: [
-        { name: "u_baseColor", kind: "vec4" },
-        { name: "u_baseColorTexture", kind: "texture2d" },
-        { name: "u_baseColorTextureOffset", kind: "vec2" },
-        { name: "u_baseColorTextureScale", kind: "vec2" },
-        { name: "u_baseColorTextureRotation", kind: "float" },
-        { name: "u_modelViewProjection", kind: "mat4" }
-      ]
-    });
-  }
-}
-
-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("TexturedUnlitMaterial 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
-  ]);
-}

package/src/ToneMapping.ts

@@ -1,105 +0,0 @@
-import {
-  applyToneMappingPreset,
-  createToneMappingCalibration,
-  toneMapFloatPixels,
-  toneMapPixels,
-  toneMappingPresets,
-  type HdrToneMappingResult,
-  type PostProcessColorSpace,
-  type ToneMappingCalibration,
-  type ToneMappingOperator,
-  type ToneMappingOptions,
-  type ToneMappingPreset,
-  type ToneMappingPresetName,
-  type ToneMappingPresetResult,
-  type ToneMappingResult
-} from "./PostProcessPass";
-
-export type ExternalParityToneMappingIntent = "product-catalog" | "material-review" | "interior" | "interactive" | "debug";
-
-export interface ExternalParityToneMappingPolicy {
-  readonly intent: ExternalParityToneMappingIntent;
-  readonly operator: ToneMappingOperator;
-  readonly exposure: number;
-  readonly whitePoint: number;
-  readonly gamma: number;
-  readonly inputColorSpace: PostProcessColorSpace;
-  readonly outputColorSpace: PostProcessColorSpace;
-  readonly preset: ToneMappingPresetName;
-  readonly calibration: ToneMappingCalibration;
-}
-
-const INTENT_PRESETS: Readonly<Record<ExternalParityToneMappingIntent, ToneMappingPresetName>> = {
-  "product-catalog": "cinematic",
-  "material-review": "realistic",
-  interior: "natural",
-  interactive: "vibrant",
-  debug: "natural"
-};
-
-export function createExternalParityToneMappingPolicy(
-  intent: ExternalParityToneMappingIntent,
-  overrides: ToneMappingOptions = {}
-): ExternalParityToneMappingPolicy {
-  const presetName = INTENT_PRESETS[intent];
-  const preset = toneMappingPresets[presetName];
-  const toneMapping = {
-    ...preset.toneMapping,
-    ...overrides
-  };
-  return {
-    intent,
-    operator: toneMapping.operator,
-    exposure: toneMapping.exposure,
-    whitePoint: toneMapping.whitePoint,
-    gamma: toneMapping.gamma,
-    inputColorSpace: toneMapping.inputColorSpace,
-    outputColorSpace: toneMapping.outputColorSpace,
-    preset: presetName,
-    calibration: createToneMappingCalibration(toneMapping)
-  };
-}
-
-export function toneMapExternalParityPixels(
-  pixels: Uint8Array,
-  width: number,
-  height: number,
-  policy: ExternalParityToneMappingPolicy
-): ToneMappingResult {
-  return toneMapPixels(pixels, width, height, {
-    exposure: policy.exposure,
-    whitePoint: policy.whitePoint,
-    gamma: policy.gamma,
-    operator: policy.operator,
-    inputColorSpace: policy.inputColorSpace,
-    outputColorSpace: policy.outputColorSpace
-  });
-}
-
-export function toneMapExternalParityHdrPixels(
-  pixels: Float32Array,
-  width: number,
-  height: number,
-  policy: ExternalParityToneMappingPolicy
-): HdrToneMappingResult {
-  return toneMapFloatPixels(pixels, width, height, {
-    exposure: policy.exposure,
-    whitePoint: policy.whitePoint,
-    gamma: policy.gamma,
-    operator: policy.operator,
-    outputColorSpace: policy.outputColorSpace
-  });
-}
-
-export function applyExternalParityToneMappingPreset(
-  pixels: Uint8Array,
-  width: number,
-  height: number,
-  intent: ExternalParityToneMappingIntent
-): ToneMappingPresetResult {
-  return applyToneMappingPreset(pixels, width, height, INTENT_PRESETS[intent]);
-}
-
-export function listExternalParityToneMappingPresets(): readonly ToneMappingPreset[] {
-  return Object.values(toneMappingPresets);
-}

package/src/UniformBinder.ts

@@ -1,16 +0,0 @@
-import type { UniformValue } from "./RenderDevice";
-
-export class UniformBinder {
-  private readonly cache = new Map<string, UniformValue>();
-
-  set(name: string, value: UniformValue): boolean {
-    const previous = this.cache.get(name);
-    if (previous === value) return false;
-    this.cache.set(name, value);
-    return true;
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-}

package/src/UniformLayout.ts

@@ -1,129 +0,0 @@
-export type UniformFieldType = "float" | "vec2" | "vec3" | "vec4" | "mat4";
-
-export interface UniformFieldDescriptor {
-  readonly name: string;
-  readonly type: UniformFieldType;
-  readonly arrayLength?: number;
-}
-
-export interface UniformFieldLayout extends UniformFieldDescriptor {
-  readonly offset: number;
-  readonly byteLength: number;
-  readonly alignment: number;
-}
-
-export class UniformLayout {
-  public readonly fields: readonly UniformFieldLayout[];
-  public readonly byteLength: number;
-
-  constructor(fields: readonly UniformFieldDescriptor[]) {
-    if (fields.length === 0) {
-      throw new Error("UniformLayout requires at least one field");
-    }
-    const seen = new Set<string>();
-    const layouts: UniformFieldLayout[] = [];
-    let offset = 0;
-
-    for (const field of fields) {
-      if (!field.name.trim()) {
-        throw new Error("Uniform field name is required");
-      }
-      if (seen.has(field.name)) {
-        throw new Error(`Duplicate uniform field: ${field.name}`);
-      }
-      seen.add(field.name);
-      const arrayLength = field.arrayLength ?? 1;
-      if (!Number.isInteger(arrayLength) || arrayLength <= 0) {
-        throw new Error(`Uniform field ${field.name} arrayLength must be a positive integer`);
-      }
-      const alignment = fieldAlignment(field.type, arrayLength);
-      offset = alignTo(offset, alignment);
-      const byteLength = fieldByteLength(field.type, arrayLength);
-      layouts.push({ ...field, arrayLength, offset, byteLength, alignment });
-      offset += byteLength;
-    }
-
-    this.fields = layouts;
-    this.byteLength = alignTo(offset, 16);
-  }
-
-  getField(name: string): UniformFieldLayout {
-    const field = this.fields.find((candidate) => candidate.name === name);
-    if (!field) {
-      throw new Error(`Uniform field is not in layout: ${name}`);
-    }
-    return field;
-  }
-
-  pack(values: Readonly<Record<string, number | readonly number[] | Float32Array>>): Float32Array {
-    const output = new Float32Array(this.byteLength / 4);
-    for (const field of this.fields) {
-      const value = values[field.name];
-      if (value === undefined) {
-        throw new Error(`Missing uniform value for ${field.name}`);
-      }
-      const numbers = typeof value === "number" ? [value] : Array.from(value);
-      const required = scalarCount(field.type) * (field.arrayLength ?? 1);
-      if (numbers.length !== required) {
-        throw new Error(`Uniform ${field.name} requires ${required} scalar values, got ${numbers.length}`);
-      }
-      if (!numbers.every(Number.isFinite)) {
-        throw new Error(`Uniform ${field.name} must contain finite values`);
-      }
-      const scalars = scalarCount(field.type);
-      if ((field.arrayLength ?? 1) > 1) {
-        const stride = fieldArrayStride(field.type);
-        for (let index = 0; index < (field.arrayLength ?? 1); index += 1) {
-          output.set(numbers.slice(index * scalars, (index + 1) * scalars), (field.offset + index * stride) / 4);
-        }
-      } else {
-        output.set(numbers, field.offset / 4);
-      }
-    }
-    return output;
-  }
-}
-
-function fieldAlignment(type: UniformFieldType, arrayLength: number): number {
-  if (arrayLength > 1) {
-    return 16;
-  }
-  switch (type) {
-    case "float":
-      return 4;
-    case "vec2":
-      return 8;
-    case "vec3":
-    case "vec4":
-    case "mat4":
-      return 16;
-  }
-}
-
-function fieldByteLength(type: UniformFieldType, arrayLength: number): number {
-  const base = fieldArrayStride(type);
-  return arrayLength > 1 ? base * arrayLength : type === "mat4" ? 64 : scalarCount(type) * 4;
-}
-
-function fieldArrayStride(type: UniformFieldType): number {
-  return alignTo(type === "mat4" ? 64 : scalarCount(type) * 4, 16);
-}
-
-function scalarCount(type: UniformFieldType): number {
-  switch (type) {
-    case "float":
-      return 1;
-    case "vec2":
-      return 2;
-    case "vec3":
-      return 3;
-    case "vec4":
-      return 4;
-    case "mat4":
-      return 16;
-  }
-}
-
-function alignTo(value: number, alignment: number): number {
-  return Math.ceil(value / alignment) * alignment;
-}

package/src/UnlitMaterial.ts

@@ -1,75 +0,0 @@
-import { Material, type RenderState } from "./Material";
-import { DEFAULT_UNLIT_SHADER_NAME } from "./ShaderLibrary";
-
-export interface UnlitMaterialOptions {
-  readonly name?: string;
-  readonly color?: readonly [number, number, number, number];
-  readonly pointSize?: number;
-  readonly roundPoints?: boolean;
-  readonly renderState?: Partial<RenderState>;
-}
-
-export class UnlitMaterial extends Material {
-  constructor(options: UnlitMaterialOptions = {}) {
-    const color = options.color ?? [1, 1, 1, 1];
-    validateColor(color);
-    validatePointSize(options.pointSize ?? 7);
-    super({
-      name: options.name ?? "unlit",
-      shaderKey: DEFAULT_UNLIT_SHADER_NAME,
-      renderState: options.renderState,
-      parameters: {
-        u_baseColor: color,
-        u_pointSize: options.pointSize ?? 7,
-        u_roundPoints: options.roundPoints === true ? 1 : 0,
-        u_modelViewProjection: identityMatrix()
-      },
-      requiredAttributes: ["a_position"],
-      uniformSchema: [
-        { name: "u_baseColor", kind: "vec4" },
-        { name: "u_pointSize", kind: "float" },
-        { name: "u_roundPoints", kind: "float" },
-        { name: "u_modelViewProjection", kind: "mat4" }
-      ]
-    });
-  }
-
-  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];
-  }
-
-  set pointSize(value: number) {
-    validatePointSize(value);
-    this.setParameter("u_pointSize", value);
-  }
-
-  get pointSize(): number {
-    return this.getParameter("u_pointSize") as 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("UnlitMaterial color must contain four finite values in [0, 1]");
-  }
-}
-
-function validatePointSize(pointSize: number): void {
-  if (!Number.isFinite(pointSize) || pointSize <= 0 || pointSize > 128) {
-    throw new RangeError("UnlitMaterial pointSize must be finite and in (0, 128]");
-  }
-}
-
-function identityMatrix(): Float32Array {
-  return new Float32Array([
-    1, 0, 0, 0,
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1
-  ]);
-}