@aura3d/rendering 1.0.6

package/src/TexturedUnlitMaterial.ts

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

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

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

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

@@ -0,0 +1,75 @@
+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
+  ]);
+}