@aura3d/rendering 1.0.6

package/src/ArchitecturalLightingFixtures.ts

@@ -0,0 +1,241 @@
+export type ArchitecturalLightingPresetId =
+  | "sunrise"
+  | "morning"
+  | "noon"
+  | "afternoon"
+  | "golden-hour"
+  | "sunset"
+  | "dusk"
+  | "night";
+
+export type ArchitecturalLightType = "point" | "spot" | "area";
+export type ArchitecturalRgb = readonly [number, number, number];
+export type ArchitecturalVector3 = readonly [number, number, number];
+
+export interface ArchitecturalLightingFixtureOptions {
+  readonly preset?: ArchitecturalLightingPresetId;
+  readonly interiorLightsEnabled?: boolean;
+}
+
+export interface ArchitecturalInteriorLight {
+  readonly id: string;
+  readonly type: ArchitecturalLightType;
+  readonly position: ArchitecturalVector3;
+  readonly color: ArchitecturalRgb;
+  readonly intensityLumens: number;
+  readonly rangeMeters: number;
+  readonly enabled: boolean;
+  readonly temperatureKelvin: number;
+}
+
+export interface ArchitecturalLightingFixture {
+  readonly id: "external-parity-old-branch-architectural-lighting-fixture";
+  readonly source: "origin-master-arch-viz-lighting-controller-adapted";
+  readonly preset: ArchitecturalLightingPresetId;
+  readonly presetLabel: string;
+  readonly timeOfDayHours: number;
+  readonly sunDirection: ArchitecturalVector3;
+  readonly sunColor: ArchitecturalRgb;
+  readonly skyColor: ArchitecturalRgb;
+  readonly sunIntensity: number;
+  readonly ambientIntensity: number;
+  readonly interiorLightsEnabled: boolean;
+  readonly interiorLights: readonly ArchitecturalInteriorLight[];
+  readonly activeInteriorLightCount: number;
+  readonly kelvinRange: readonly [number, number];
+  readonly supportedCurrentRendererLights: readonly ArchitecturalLightType[];
+  readonly blockedLightClaims: readonly string[];
+  readonly hash: string;
+  readonly claimBoundary: string;
+}
+
+const presetDescriptors: Record<ArchitecturalLightingPresetId, {
+  readonly label: string;
+  readonly timeOfDayHours: number;
+  readonly sunIntensity: number;
+  readonly sunColor: ArchitecturalRgb;
+  readonly skyColor: ArchitecturalRgb;
+  readonly ambientIntensity: number;
+  readonly interiorLightsOn: boolean;
+}> = {
+  sunrise: {
+    label: "Sunrise",
+    timeOfDayHours: 6,
+    sunIntensity: 1.5,
+    sunColor: [1, 0.7, 0.4],
+    skyColor: [0.95, 0.7, 0.6],
+    ambientIntensity: 0.15,
+    interiorLightsOn: true
+  },
+  morning: {
+    label: "Morning",
+    timeOfDayHours: 9,
+    sunIntensity: 2.8,
+    sunColor: [1, 0.95, 0.88],
+    skyColor: [0.6, 0.85, 0.95],
+    ambientIntensity: 0.25,
+    interiorLightsOn: false
+  },
+  noon: {
+    label: "Noon",
+    timeOfDayHours: 12,
+    sunIntensity: 4.5,
+    sunColor: [1, 0.98, 0.95],
+    skyColor: [0.53, 0.81, 0.92],
+    ambientIntensity: 0.35,
+    interiorLightsOn: false
+  },
+  afternoon: {
+    label: "Afternoon",
+    timeOfDayHours: 15,
+    sunIntensity: 3.2,
+    sunColor: [1, 0.94, 0.85],
+    skyColor: [0.58, 0.83, 0.93],
+    ambientIntensity: 0.28,
+    interiorLightsOn: false
+  },
+  "golden-hour": {
+    label: "Golden Hour",
+    timeOfDayHours: 18,
+    sunIntensity: 2,
+    sunColor: [1, 0.75, 0.5],
+    skyColor: [0.95, 0.75, 0.6],
+    ambientIntensity: 0.2,
+    interiorLightsOn: true
+  },
+  sunset: {
+    label: "Sunset",
+    timeOfDayHours: 19.5,
+    sunIntensity: 1.2,
+    sunColor: [1, 0.5, 0.3],
+    skyColor: [0.9, 0.5, 0.4],
+    ambientIntensity: 0.15,
+    interiorLightsOn: true
+  },
+  dusk: {
+    label: "Dusk",
+    timeOfDayHours: 20.5,
+    sunIntensity: 0.3,
+    sunColor: [0.7, 0.6, 0.9],
+    skyColor: [0.25, 0.35, 0.65],
+    ambientIntensity: 0.08,
+    interiorLightsOn: true
+  },
+  night: {
+    label: "Night",
+    timeOfDayHours: 23,
+    sunIntensity: 0.15,
+    sunColor: [0.7, 0.75, 0.9],
+    skyColor: [0.02, 0.03, 0.08],
+    ambientIntensity: 0.05,
+    interiorLightsOn: true
+  }
+};
+
+const interiorLightDescriptors: readonly Omit<ArchitecturalInteriorLight, "color" | "enabled">[] = [
+  { id: "living-ceiling-1", type: "point", position: [0, 2.7, -2], intensityLumens: 800, rangeMeters: 5, temperatureKelvin: 3000 },
+  { id: "living-ceiling-2", type: "point", position: [0, 2.7, 2], intensityLumens: 800, rangeMeters: 5, temperatureKelvin: 3000 },
+  { id: "kitchen-task-1", type: "spot", position: [-3, 2.5, -1], intensityLumens: 1200, rangeMeters: 4, temperatureKelvin: 4000 },
+  { id: "kitchen-task-2", type: "spot", position: [-3, 2.5, 1], intensityLumens: 1200, rangeMeters: 4, temperatureKelvin: 4000 },
+  { id: "bedroom-ambient", type: "point", position: [4, 2.6, 0], intensityLumens: 600, rangeMeters: 6, temperatureKelvin: 2700 },
+  { id: "study-desk", type: "spot", position: [3.5, 1.2, -2.5], intensityLumens: 400, rangeMeters: 2.5, temperatureKelvin: 4500 },
+  { id: "hallway-1", type: "point", position: [0, 2.5, 5], intensityLumens: 500, rangeMeters: 4, temperatureKelvin: 3500 },
+  { id: "hallway-2", type: "point", position: [0, 2.5, -5], intensityLumens: 500, rangeMeters: 4, temperatureKelvin: 3500 },
+  { id: "bathroom-main", type: "area", position: [-4, 2.4, 3], intensityLumens: 900, rangeMeters: 3, temperatureKelvin: 5000 },
+  { id: "accent-wall", type: "spot", position: [-5.5, 1.5, 0], intensityLumens: 300, rangeMeters: 3, temperatureKelvin: 3200 }
+];
+
+export function createArchitecturalLightingFixture(options: ArchitecturalLightingFixtureOptions = {}): ArchitecturalLightingFixture {
+  const preset = options.preset ?? "noon";
+  const descriptor = presetDescriptors[preset];
+  const interiorLightsEnabled = options.interiorLightsEnabled ?? descriptor.interiorLightsOn;
+  const interiorLights = interiorLightDescriptors.map((light) => ({
+    ...light,
+    color: kelvinToRgb(light.temperatureKelvin),
+    enabled: interiorLightsEnabled
+  }));
+  const enabledLights = interiorLights.filter((light) => light.enabled);
+  const kelvinValues = interiorLights.map((light) => light.temperatureKelvin);
+  const sunDirection = directionForTimeOfDay(descriptor.timeOfDayHours);
+  return {
+    id: "external-parity-old-branch-architectural-lighting-fixture",
+    source: "origin-master-arch-viz-lighting-controller-adapted",
+    preset,
+    presetLabel: descriptor.label,
+    timeOfDayHours: descriptor.timeOfDayHours,
+    sunDirection,
+    sunColor: descriptor.sunColor,
+    skyColor: descriptor.skyColor,
+    sunIntensity: descriptor.sunIntensity,
+    ambientIntensity: descriptor.ambientIntensity,
+    interiorLightsEnabled,
+    interiorLights,
+    activeInteriorLightCount: enabledLights.length,
+    kelvinRange: [Math.min(...kelvinValues), Math.max(...kelvinValues)],
+    supportedCurrentRendererLights: ["point", "spot"],
+    blockedLightClaims: [
+      "physically accurate global illumination",
+      "photometric area-light shading parity",
+      "Unity/Unreal architectural lighting workflow parity"
+    ],
+    hash: hashLighting(preset, sunDirection, descriptor, interiorLights),
+    claimBoundary: "Deterministic time-of-day sun, Kelvin interior-light metadata, and bounded current-renderer point/spot light evidence adapted from the old arch-viz LightingController; this does not claim GI, baked lighting, photometric area-light, or Unity/Unreal lighting-workflow parity."
+  };
+}
+
+function directionForTimeOfDay(timeOfDayHours: number): ArchitecturalVector3 {
+  const hourAngle = (timeOfDayHours - 6) * 15;
+  const elevation = Math.sin(hourAngle * Math.PI / 180) * 60;
+  const azimuth = (hourAngle - 90) * Math.PI / 180;
+  const x = Math.cos(azimuth) * 50;
+  const y = Math.max(elevation, -10);
+  const z = Math.sin(azimuth) * 50;
+  const length = Math.hypot(x, y, z) || 1;
+  return [
+    Number((-x / length).toFixed(4)),
+    Number((-y / length).toFixed(4)),
+    Number((-z / length).toFixed(4))
+  ];
+}
+
+function kelvinToRgb(kelvin: number): ArchitecturalRgb {
+  const temp = kelvin / 100;
+  const red = temp <= 66 ? 255 : clamp(329.698727446 * Math.pow(temp - 60, -0.1332047592), 0, 255);
+  const green = temp <= 66
+    ? clamp(99.4708025861 * Math.log(temp) - 161.1195681661, 0, 255)
+    : clamp(288.1221695283 * Math.pow(temp - 60, -0.0755148492), 0, 255);
+  const blue = temp >= 66 ? 255 : temp <= 19 ? 0 : clamp(138.5177312231 * Math.log(temp - 10) - 305.0447927307, 0, 255);
+  return [roundColor(red / 255), roundColor(green / 255), roundColor(blue / 255)];
+}
+
+function hashLighting(
+  preset: ArchitecturalLightingPresetId,
+  sunDirection: ArchitecturalVector3,
+  descriptor: (typeof presetDescriptors)[ArchitecturalLightingPresetId],
+  lights: readonly ArchitecturalInteriorLight[]
+): string {
+  let hash = 0x811c9dc5;
+  for (const value of [
+    preset.length,
+    descriptor.timeOfDayHours,
+    descriptor.sunIntensity,
+    descriptor.ambientIntensity,
+    ...sunDirection,
+    ...lights.flatMap((light) => [light.intensityLumens, light.rangeMeters, light.temperatureKelvin, light.enabled ? 1 : 0])
+  ]) {
+    const scaled = Math.round(value * 10_000);
+    hash ^= scaled & 0xff;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+    hash ^= (scaled >>> 8) & 0xff;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function roundColor(value: number): number {
+  return Number(clamp(value, 0, 1).toFixed(4));
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}

package/src/ArchitecturalMaterialCatalog.ts

@@ -0,0 +1,130 @@
+import { PBRMaterial } from "./PBRMaterial";
+import { TexturedPBRMaterial } from "./TexturedPBRMaterial";
+import { type ProceduralTextureFixtureKind, createProceduralTexture } from "./ProceduralTextureFixtures";
+
+export type ArchitecturalMaterialCategory = "wood" | "stone" | "metal" | "fabric" | "glass" | "ceramic";
+
+export interface ArchitecturalMaterialDescriptor {
+  readonly id: string;
+  readonly label: string;
+  readonly category: ArchitecturalMaterialCategory;
+  readonly baseColor: readonly [number, number, number, number];
+  readonly roughness: number;
+  readonly metallic: number;
+  readonly normalStrength: number;
+  readonly ambientOcclusion: number;
+  readonly alpha?: number;
+  readonly textureFixture?: ProceduralTextureFixtureKind;
+  readonly knownLimits: readonly string[];
+}
+
+export interface ArchitecturalMaterialCatalogSummary {
+  readonly materialCount: number;
+  readonly categories: readonly ArchitecturalMaterialCategory[];
+  readonly categoryCounts: Readonly<Record<ArchitecturalMaterialCategory, number>>;
+  readonly texturedMaterialCount: number;
+  readonly source: "origin-master-examples-arch-viz-material-library-adapted";
+  readonly claimBoundary: string;
+}
+
+const knownLimits = [
+  "Adapted from the old arch-viz material library as deterministic current-engine PBR presets.",
+  "These are procedural/local material presets, not scanned production material assets or Unity/Unreal physical material parity evidence."
+] as const;
+
+const catalog = [
+  material("oak", "Oak Wood", "wood", [0.545, 0.396, 0.259, 1], 0.65, 0, 0.8, 0.85, "wood-plank"),
+  material("walnut", "Walnut Wood", "wood", [0.361, 0.239, 0.176, 1], 0.6, 0, 0.75, 0.8, "wood-plank"),
+  material("pine", "Pine Wood", "wood", [0.816, 0.694, 0.502, 1], 0.7, 0, 0.6, 0.9, "wood-plank"),
+  material("mahogany", "Mahogany Wood", "wood", [0.502, 0.227, 0.145, 1], 0.55, 0, 0.7, 0.82, "wood-plank"),
+  material("birch", "Birch Wood", "wood", [0.937, 0.878, 0.737, 1], 0.68, 0, 0.5, 0.92, "wood-plank"),
+  material("teak", "Teak Wood", "wood", [0.682, 0.478, 0.278, 1], 0.5, 0, 0.65, 0.88, "wood-plank"),
+  material("marble-carrara", "Carrara Marble", "stone", [0.94, 0.93, 0.91, 1], 0.25, 0, 0.4, 0.95, "marble"),
+  material("granite-black", "Black Granite", "stone", [0.12, 0.12, 0.13, 1], 0.15, 0, 0.3, 0.7, "marble"),
+  material("limestone", "Limestone", "stone", [0.847, 0.812, 0.729, 1], 0.75, 0, 0.6, 0.85, "concrete-asphalt"),
+  material("concrete", "Polished Concrete", "stone", [0.502, 0.502, 0.502, 1], 0.6, 0, 0.5, 0.8, "concrete-asphalt"),
+  material("slate", "Slate Stone", "stone", [0.259, 0.275, 0.29, 1], 0.7, 0, 0.7, 0.75, "concrete-asphalt"),
+  material("sandstone", "Sandstone", "stone", [0.761, 0.643, 0.467, 1], 0.8, 0, 0.65, 0.83, "concrete-asphalt"),
+  material("chrome", "Polished Chrome", "metal", [0.549, 0.556, 0.554, 1], 0.05, 1, 0.1, 1),
+  material("steel-brushed", "Brushed Steel", "metal", [0.651, 0.651, 0.651, 1], 0.3, 1, 0.4, 0.95, "sci-fi-panel"),
+  material("copper", "Polished Copper", "metal", [0.955, 0.637, 0.538, 1], 0.2, 1, 0.2, 0.98),
+  material("brass", "Polished Brass", "metal", [0.875, 0.78, 0.455, 1], 0.25, 1, 0.15, 0.97),
+  material("aluminum", "Brushed Aluminum", "metal", [0.913, 0.921, 0.925, 1], 0.35, 1, 0.3, 0.96, "sci-fi-panel"),
+  material("metal-black", "Matte Black Metal", "metal", [0.02, 0.02, 0.02, 1], 0.6, 1, 0.2, 0.75),
+  material("cotton", "Cotton Fabric", "fabric", [0.863, 0.859, 0.847, 1], 0.85, 0, 0.6, 0.88),
+  material("velvet", "Velvet Fabric", "fabric", [0.122, 0.161, 0.267, 1], 0.9, 0, 0.8, 0.7),
+  material("leather", "Leather", "fabric", [0.435, 0.286, 0.184, 1], 0.55, 0, 0.5, 0.82),
+  material("linen", "Linen Fabric", "fabric", [0.906, 0.878, 0.831, 1], 0.88, 0, 0.7, 0.86),
+  material("wool", "Wool Fabric", "fabric", [0.584, 0.541, 0.494, 1], 0.92, 0, 0.75, 0.84),
+  material("glass-clear", "Clear Glass", "glass", [0.95, 0.95, 0.95, 0.38], 0.05, 0, 0.1, 1),
+  material("glass-frosted", "Frosted Glass", "glass", [0.9, 0.9, 0.9, 0.62], 0.4, 0, 0.6, 0.95),
+  material("glass-tinted", "Tinted Glass", "glass", [0.651, 0.753, 0.769, 0.58], 0.08, 0, 0.1, 0.98),
+  material("glass-smoked", "Smoked Glass", "glass", [0.275, 0.275, 0.275, 0.52], 0.1, 0, 0.1, 0.85),
+  material("ceramic-white", "White Ceramic", "ceramic", [0.961, 0.961, 0.961, 1], 0.15, 0, 0.2, 0.98),
+  material("terracotta", "Terracotta", "ceramic", [0.729, 0.376, 0.278, 1], 0.7, 0, 0.5, 0.85),
+  material("tile-glazed", "Glazed Tile", "ceramic", [0.847, 0.831, 0.804, 1], 0.12, 0, 0.15, 0.96),
+  material("porcelain", "Porcelain", "ceramic", [0.941, 0.933, 0.922, 1], 0.18, 0, 0.25, 0.97)
+] as const satisfies readonly ArchitecturalMaterialDescriptor[];
+
+export function createArchitecturalMaterialCatalog(): readonly ArchitecturalMaterialDescriptor[] {
+  return catalog;
+}
+
+export function architecturalMaterialCatalogSummary(): ArchitecturalMaterialCatalogSummary {
+  const categories = ["wood", "stone", "metal", "fabric", "glass", "ceramic"] as const;
+  return {
+    materialCount: catalog.length,
+    categories,
+    categoryCounts: Object.fromEntries(categories.map((category) => [
+      category,
+      catalog.filter((entry) => entry.category === category).length
+    ])) as Readonly<Record<ArchitecturalMaterialCategory, number>>,
+    texturedMaterialCount: catalog.filter((entry) => entry.textureFixture).length,
+    source: "origin-master-examples-arch-viz-material-library-adapted",
+    claimBoundary: "Catalog proves a deterministic local architectural material taxonomy for browser examples; it does not prove scanned material, Unity, or Unreal parity."
+  };
+}
+
+export function architecturalMaterialDescriptor(id: string): ArchitecturalMaterialDescriptor {
+  const descriptor = catalog.find((entry) => entry.id === id);
+  if (!descriptor) throw new RangeError(`Unknown architectural material preset: ${id}`);
+  return descriptor;
+}
+
+export function createArchitecturalMaterial(id: string): PBRMaterial | TexturedPBRMaterial {
+  const descriptor = architecturalMaterialDescriptor(id);
+  const renderState = descriptor.category === "glass"
+    ? { cullMode: "none" as const, blend: true, depthWrite: false }
+    : { cullMode: "none" as const };
+  if (descriptor.textureFixture) {
+    return new TexturedPBRMaterial({
+      name: `architectural-${descriptor.id}`,
+      baseColor: descriptor.baseColor,
+      baseColorTexture: createProceduralTexture(descriptor.textureFixture, { width: 96, height: 96, label: `architectural-${descriptor.id}-texture` }),
+      roughness: descriptor.roughness,
+      metallic: descriptor.metallic,
+      renderState
+    });
+  }
+  return new PBRMaterial({
+    name: `architectural-${descriptor.id}`,
+    baseColor: descriptor.baseColor,
+    roughness: descriptor.roughness,
+    metallic: descriptor.metallic,
+    renderState
+  });
+}
+
+function material(
+  id: string,
+  label: string,
+  category: ArchitecturalMaterialCategory,
+  baseColor: readonly [number, number, number, number],
+  roughness: number,
+  metallic: number,
+  normalStrength: number,
+  ambientOcclusion: number,
+  textureFixture?: ProceduralTextureFixtureKind
+): ArchitecturalMaterialDescriptor {
+  return { id, label, category, baseColor, roughness, metallic, normalStrength, ambientOcclusion, textureFixture, knownLimits };
+}

package/src/ArchitecturalMeasurementFixtures.ts

@@ -0,0 +1,155 @@
+export type ArchitecturalMeasurementType = "distance" | "area" | "angle" | "height";
+export type ArchitecturalMeasurementUnit = "metric" | "imperial";
+export type ArchitecturalPoint3 = readonly [number, number, number];
+
+export interface ArchitecturalMeasurementOptions {
+  readonly unit?: ArchitecturalMeasurementUnit;
+  readonly precision?: number;
+  readonly snapTolerance?: number;
+}
+
+export interface ArchitecturalMeasurementResult {
+  readonly type: ArchitecturalMeasurementType;
+  readonly value: number;
+  readonly unit: string;
+  readonly label: string;
+  readonly points: readonly ArchitecturalPoint3[];
+}
+
+export interface ArchitecturalMeasurementFixture {
+  readonly id: "external-parity-old-branch-architectural-measurement-fixture";
+  readonly source: "origin-master-arch-viz-measurement-tool-adapted";
+  readonly snapEnabled: boolean;
+  readonly snapTolerance: number;
+  readonly snapPointCount: number;
+  readonly distance: ArchitecturalMeasurementResult;
+  readonly area: ArchitecturalMeasurementResult;
+  readonly angle: ArchitecturalMeasurementResult;
+  readonly height: ArchitecturalMeasurementResult;
+  readonly hash: string;
+  readonly claimBoundary: string;
+}
+
+const defaultSnapPoints: readonly ArchitecturalPoint3[] = [
+  [-6, 0, -6], [6, 0, -6], [6, 0, 6], [-6, 0, 6],
+  [-6, 3, -6], [6, 3, -6], [6, 3, 6], [-6, 3, 6],
+  [0, 0, -6], [0, 0, 6], [-6, 0, 0], [6, 0, 0],
+  [0, 0, 0],
+  [-3, 0, -6], [-3, 2.1, -6], [3, 1, 6], [3, 2.5, 6]
+] as const;
+
+export function createArchitecturalMeasurementFixture(options: ArchitecturalMeasurementOptions = {}): ArchitecturalMeasurementFixture {
+  const unit = options.unit ?? "metric";
+  const precision = Math.max(0, Math.min(4, Math.floor(options.precision ?? 2)));
+  const snapTolerance = finiteNonNegative(options.snapTolerance ?? 0.12, "snapTolerance");
+  const distancePoints = snapPoints([[-6.04, 0, -6.03], [6.02, 0, -6.01]], snapTolerance);
+  const areaPoints = snapPoints([[-6, 0, -6], [6, 0, -6], [6, 0, 6], [-6, 0, 6]], snapTolerance);
+  const anglePoints = snapPoints([[6, 0, -6], [0.02, 0, -5.98], [0.01, 0, 0.03]], snapTolerance);
+  const heightPoints = snapPoints([[-3.02, 0.01, -6], [-3.01, 2.09, -6.01]], snapTolerance);
+  const distance = measurement("distance", distancePoints, unit, precision);
+  const area = measurement("area", areaPoints, unit, precision);
+  const angle = measurement("angle", anglePoints, unit, precision);
+  const height = measurement("height", heightPoints, unit, precision);
+  return {
+    id: "external-parity-old-branch-architectural-measurement-fixture",
+    source: "origin-master-arch-viz-measurement-tool-adapted",
+    snapEnabled: true,
+    snapTolerance,
+    snapPointCount: defaultSnapPoints.length,
+    distance,
+    area,
+    angle,
+    height,
+    hash: hashMeasurements([distance, area, angle, height]),
+    claimBoundary: "Deterministic snap-point distance, area, angle, and height measurement math adapted from the old arch-viz measurement tool; this is architectural workflow evidence, not CAD/BIM dimensioning, IFC import, triangle picking, or legal measurement accuracy."
+  };
+}
+
+function measurement(type: ArchitecturalMeasurementType, points: readonly ArchitecturalPoint3[], unit: ArchitecturalMeasurementUnit, precision: number): ArchitecturalMeasurementResult {
+  const value = type === "distance"
+    ? distance(points[0]!, points[1]!)
+    : type === "area"
+      ? polygonAreaXZ(points)
+      : type === "angle"
+        ? angleDegrees(points[0]!, points[1]!, points[2]!)
+        : Math.abs((points[1]?.[1] ?? 0) - (points[0]?.[1] ?? 0));
+  return {
+    type,
+    value: Number(value.toFixed(4)),
+    unit: type === "angle" ? "deg" : unit === "metric" ? type === "area" ? "m2" : "m" : type === "area" ? "ft2" : "ft",
+    label: type === "angle" ? `${value.toFixed(precision)} deg` : type === "area" ? formatArea(value, unit, precision) : formatDistance(value, unit, precision),
+    points
+  };
+}
+
+function snapPoints(points: readonly ArchitecturalPoint3[], tolerance: number): readonly ArchitecturalPoint3[] {
+  return points.map((point) => {
+    let nearest = point;
+    let nearestDistance = tolerance;
+    for (const snap of defaultSnapPoints) {
+      const d = distance(point, snap);
+      if (d < nearestDistance) {
+        nearest = snap;
+        nearestDistance = d;
+      }
+    }
+    return nearest;
+  });
+}
+
+function distance(left: ArchitecturalPoint3, right: ArchitecturalPoint3): number {
+  return Math.hypot(right[0] - left[0], right[1] - left[1], right[2] - left[2]);
+}
+
+function polygonAreaXZ(points: readonly ArchitecturalPoint3[]): number {
+  let area = 0;
+  for (let index = 0; index < points.length; index += 1) {
+    const current = points[index]!;
+    const next = points[(index + 1) % points.length]!;
+    area += current[0] * next[2] - next[0] * current[2];
+  }
+  return Math.abs(area) / 2;
+}
+
+function angleDegrees(left: ArchitecturalPoint3, vertex: ArchitecturalPoint3, right: ArchitecturalPoint3): number {
+  const a = normalize([left[0] - vertex[0], left[1] - vertex[1], left[2] - vertex[2]]);
+  const b = normalize([right[0] - vertex[0], right[1] - vertex[1], right[2] - vertex[2]]);
+  const dot = Math.max(-1, Math.min(1, a[0] * b[0] + a[1] * b[1] + a[2] * b[2]));
+  return Math.acos(dot) * 180 / Math.PI;
+}
+
+function normalize(value: ArchitecturalPoint3): ArchitecturalPoint3 {
+  const length = Math.hypot(value[0], value[1], value[2]) || 1;
+  return [value[0] / length, value[1] / length, value[2] / length];
+}
+
+function formatDistance(meters: number, unit: ArchitecturalMeasurementUnit, precision: number): string {
+  if (unit === "metric") return meters < 1 ? `${(meters * 100).toFixed(precision)} cm` : `${meters.toFixed(precision)} m`;
+  const feet = meters * 3.28084;
+  const wholeFeet = Math.floor(feet);
+  const inches = (feet % 1) * 12;
+  return wholeFeet === 0 ? `${inches.toFixed(precision)} in` : `${wholeFeet} ft ${inches.toFixed(precision)} in`;
+}
+
+function formatArea(squareMeters: number, unit: ArchitecturalMeasurementUnit, precision: number): string {
+  return unit === "metric" ? `${squareMeters.toFixed(precision)} m2` : `${(squareMeters * 10.7639).toFixed(precision)} ft2`;
+}
+
+function hashMeasurements(measurements: readonly ArchitecturalMeasurementResult[]): string {
+  let hash = 0x811c9dc5;
+  for (const result of measurements) {
+    const scaled = Math.round(result.value * 10_000);
+    hash ^= scaled & 0xff;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+    hash ^= (scaled >>> 8) & 0xff;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+    hash ^= result.type.charCodeAt(0);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function finiteNonNegative(value: number, label: string): number {
+  if (!Number.isFinite(value) || value < 0) throw new RangeError(`Architectural measurement ${label} must be finite and non-negative.`);
+  return value;
+}

package/src/BRDFLut.ts

@@ -0,0 +1,47 @@
+import { generateApproximateBrdfLutPixels, type Rgba8EnvironmentMapSource } from "./EnvironmentMapResources";
+
+export interface ExternalParityBrdfLut {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8Array;
+  readonly textureLabel: string;
+  readonly diagnostics: {
+    readonly byteLength: number;
+    readonly nonZeroPixels: number;
+    readonly monotonicRoughnessTrend: boolean;
+  };
+}
+
+export function createExternalParityBrdfLut(size = 64): ExternalParityBrdfLut {
+  if (!Number.isInteger(size) || size < 16) {
+    throw new RangeError("ExternalParity BRDF LUT size must be an integer >= 16.");
+  }
+  const source = generateApproximateBrdfLutPixels({ width: size, height: size });
+  return {
+    width: source.width,
+    height: source.height,
+    data: new Uint8Array(source.data),
+    textureLabel: "external-parity-brdf-lut",
+    diagnostics: {
+      byteLength: source.data.byteLength,
+      nonZeroPixels: countNonZeroPixels(source),
+      monotonicRoughnessTrend: roughnessTrend(source)
+    }
+  };
+}
+
+function countNonZeroPixels(source: Rgba8EnvironmentMapSource): number {
+  let count = 0;
+  for (let index = 0; index < source.data.length; index += 4) {
+    if ((source.data[index] ?? 0) + (source.data[index + 1] ?? 0) + (source.data[index + 2] ?? 0) > 0) count += 1;
+  }
+  return count;
+}
+
+function roughnessTrend(source: Rgba8EnvironmentMapSource): boolean {
+  const sampleX = Math.max(0, Math.min(source.width - 1, Math.floor(source.width * 0.5)));
+  const firstRow = source.data[sampleX * 4] ?? 0;
+  const lastRowOffset = ((source.height - 1) * source.width + sampleX) * 4;
+  const lastRow = source.data[lastRowOffset] ?? 0;
+  return firstRow !== lastRow;
+}