@volter/blender-engine 0.1.5 → 0.1.7

package/browser/three/blender-physical-material.ts

@@ -0,0 +1,162 @@
+/** Principled socket values stay Blender-owned; this file applies them to the
+ * actual Three material. Units cross the wire unchanged (turns and nanometres).
+ * Shader adjustments cover the coat IOR/tint and specular grazing behavior
+ * that MeshPhysicalMaterial does not expose as properties. */
+import * as THREE from 'three';
+import {z} from 'zod';
+import {applyGraphShader, bindGraphDraw, graphProgramKey, setGraphViewport} from './blender-graph-material';
+import {bindNamedUvChannels} from './blender-texture-samplers';
+
+const scalar = z.number().finite();
+const color = z.tuple([scalar, scalar, scalar]);
+export const physicalMaterialSchema = z.object({
+  coat: scalar, coat_roughness: scalar, coat_ior: scalar, coat_tint: color,
+  sheen: scalar, sheen_roughness: scalar, sheen_tint: color,
+  anisotropy: scalar, anisotropy_rotation: scalar,
+  specular_level: scalar, specular_tint: color,
+  film_thickness: scalar, film_ior: scalar,
+}).strict();
+type Physical = z.infer<typeof physicalMaterialSchema>;
+const defaults: Physical = {
+  coat: 0, coat_roughness: 0.03, coat_ior: 1.5, coat_tint: [1, 1, 1],
+  sheen: 0, sheen_roughness: 0.5, sheen_tint: [1, 1, 1],
+  anisotropy: 0, anisotropy_rotation: 0,
+  specular_level: 0.5, specular_tint: [1, 1, 1], film_thickness: 0, film_ior: 1.33,
+};
+const uniforms = new WeakMap<THREE.MeshPhysicalMaterial, {
+  blenderCoatIor: {value: number}; blenderCoatTint: {value: THREE.Color};
+  blenderMapClip: {value: boolean}; blenderRoughnessClip: {value: boolean}; blenderNormalClip: {value: boolean};
+  blenderWorldExtinction: {value: THREE.Vector3};
+}>();
+
+export function applyWorldExtinction(material: THREE.MeshPhysicalMaterial, extinction: THREE.Vector3): void {
+  if (!uniforms.has(material)) applyPhysicalMaterial(material);
+  uniforms.get(material)!.blenderWorldExtinction.value.copy(extinction);
+}
+
+/** A copy of `material` with its own hooks and the same physical values:
+ *  the proxy a pending graph program compiles through, whose program key is
+ *  the one `material` asks for once the graph is swapped in. */
+function graphShadow(material: THREE.MeshPhysicalMaterial): THREE.MeshPhysicalMaterial {
+  const shadow = new THREE.MeshPhysicalMaterial();
+  const held = uniforms.get(material);
+  // The hooks, then the values: `applyPhysicalMaterial` sets its defaults,
+  // which `copy` replaces with the material's own (it leaves hooks alone).
+  applyPhysicalMaterial(shadow);
+  shadow.copy(material);
+  const values = uniforms.get(shadow)!;
+  if (held) {
+    values.blenderCoatIor.value = held.blenderCoatIor.value;
+    values.blenderCoatTint.value.copy(held.blenderCoatTint.value);
+    values.blenderMapClip.value = held.blenderMapClip.value;
+    values.blenderRoughnessClip.value = held.blenderRoughnessClip.value;
+    values.blenderNormalClip.value = held.blenderNormalClip.value;
+    values.blenderWorldExtinction.value.copy(held.blenderWorldExtinction.value);
+  }
+  return shadow;
+}
+
+export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, input?: Physical,
+  clips: {map?: boolean; roughness?: boolean; normal?: boolean} = {}): void {
+  const data = input ?? defaults;
+  material.clearcoat = data.coat;
+  material.clearcoatRoughness = data.coat_roughness;
+  material.sheen = data.sheen;
+  material.sheenRoughness = data.sheen_roughness;
+  material.sheenColor.setRGB(...data.sheen_tint, THREE.LinearSRGBColorSpace);
+  material.anisotropy = data.anisotropy;
+  material.anisotropyRotation = data.anisotropy_rotation * Math.PI * 2;
+  material.specularIntensity = data.specular_level * 2;
+  material.specularColor.setRGB(...data.specular_tint, THREE.LinearSRGBColorSpace);
+  material.iridescence = data.film_thickness > 0 ? 1 : 0;
+  material.iridescenceIOR = data.film_ior;
+  material.iridescenceThicknessRange = [data.film_thickness, data.film_thickness];
+  let values = uniforms.get(material);
+  if (!values) {
+    values = {blenderCoatIor: {value: 1.5}, blenderCoatTint: {value: new THREE.Color(1, 1, 1)},
+      blenderMapClip: {value: false}, blenderRoughnessClip: {value: false}, blenderNormalClip: {value: false},
+      blenderWorldExtinction: {value: new THREE.Vector3()}};
+    uniforms.set(material, values);
+    const held = values;
+    material.customProgramCacheKey = () => `blender-principled-physical-v5${graphProgramKey(material)}`;
+    material.onBeforeRender = (renderer, scene, camera, geometry, object) => {
+      bindNamedUvChannels(material, geometry);
+      bindGraphDraw(material, geometry, renderer, scene, camera, object, graphShadow);
+      setGraphViewport(renderer);
+    };
+    material.onBeforeCompile = shader => {
+      // Three declares channels 0..3. Blender has eight named UV maps in
+      // addition to the default channel; only the used attributes survive GLSL.
+      shader.vertexShader = [4, 5, 6, 7, 8, 9].map(i => `attribute vec2 uv${i};`).join('\n') + '\n' + shader.vertexShader;
+      Object.assign(shader.uniforms, held);
+      shader.fragmentShader = `uniform float blenderCoatIor;
+        uniform vec3 blenderWorldExtinction;
+        vec3 blenderInfiniteTransmission() { return vec3(
+          blenderWorldExtinction.x>0.?0.:1., blenderWorldExtinction.y>0.?0.:1., blenderWorldExtinction.z>0.?0.:1.); }
+        uniform vec3 blenderCoatTint;
+        uniform bool blenderMapClip, blenderRoughnessClip, blenderNormalClip;
+        vec4 blenderImageSample(sampler2D image, vec2 uv, bool clipImage) {
+          vec4 pixel = texture2D(image, uv);
+          if (clipImage && (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0))))) pixel = vec4(0.0);
+          return pixel;
+        }
+      ` + shader.fragmentShader;
+      const physical = THREE.ShaderChunk.lights_physical_fragment
+        .replace('material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );',
+          'material.specularF90 = 1.0;')
+        .replace('material.clearcoatF0 = vec3( 0.04 );',
+          'material.clearcoatF0 = vec3( pow2( ( blenderCoatIor - 1.0 ) / ( blenderCoatIor + 1.0 ) ) );');
+      const normals = THREE.ShaderChunk.normal_fragment_maps
+        .replace('normal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;',
+          'vec3 blenderBaseNormal = normal; normal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0; normal.y *= normalScale.y < 0.0 ? -1.0 : 1.0;')
+        .replace('normal = normalize( normalMatrix * normal );',
+          'normal = normalize(mix(blenderBaseNormal, normalize(normalMatrix * normal), max(0.0, normalScale.x)));')
+        .replace('mapN.xy *= normalScale;',
+          'mapN.xy *= normalScale; mapN.z = mix(1.0, mapN.z, clamp(normalScale.x, 0.0, 1.0));')
+        .replaceAll('texture2D( normalMap, vNormalMapUv )', 'blenderImageSample(normalMap, vNormalMapUv, blenderNormalClip)');
+      const baseMap = THREE.ShaderChunk.map_fragment
+        .replace('texture2D( map, vMapUv )', 'blenderImageSample(map, vMapUv, blenderMapClip)')
+        // Blender's Color socket does not connect Image Alpha to Principled Alpha.
+        .replace('diffuseColor *= sampledDiffuseColor;', 'diffuseColor.rgb *= sampledDiffuseColor.rgb;');
+      const roughnessMap = THREE.ShaderChunk.roughnessmap_fragment
+        .replace('texture2D( roughnessMap, vRoughnessMapUv )', 'blenderImageSample(roughnessMap, vRoughnessMapUv, blenderRoughnessClip)');
+      const lighting = THREE.ShaderChunk.lights_fragment_begin
+        .replace('getPointLightInfo( pointLight, geometryPosition, directLight );',
+          'getPointLightInfo( pointLight, geometryPosition, directLight ); directLight.color *= exp(-blenderWorldExtinction * length(pointLight.position-geometryPosition));')
+        .replace('getSpotLightInfo( spotLight, geometryPosition, directLight );',
+          'getSpotLightInfo( spotLight, geometryPosition, directLight ); directLight.color *= exp(-blenderWorldExtinction * length(spotLight.position-geometryPosition));')
+        .replace('getDirectionalLightInfo( directionalLight, directLight );',
+          'getDirectionalLightInfo( directionalLight, directLight ); directLight.color *= blenderInfiniteTransmission();')
+        // LTC integrates the rectangle without participating media. Its center
+        // distance is the attenuation approximation; the volume pass samples
+        // the rectangle itself. Neither is claimed as path-traced area lighting.
+        .replace('rectAreaLight = rectAreaLights[ i ];',
+          'rectAreaLight = rectAreaLights[ i ]; rectAreaLight.color *= exp(-blenderWorldExtinction * length(rectAreaLight.position-geometryPosition));')
+        .replace('getAmbientLightIrradiance( ambientLightColor )', 'getAmbientLightIrradiance( ambientLightColor ) * blenderInfiniteTransmission()');
+      const environment = THREE.ShaderChunk.lights_fragment_maps
+        .replaceAll(/(getIBL(?:Irradiance|Radiance|AnisotropyRadiance)\([^;]+\))/g, '$1 * blenderInfiniteTransmission()');
+      shader.fragmentShader = shader.fragmentShader.replace('#include <lights_physical_fragment>', physical)
+        .replace('#include <lights_fragment_begin>', lighting)
+        .replace('#include <lights_fragment_maps>', environment)
+        .replace('#include <normal_fragment_maps>', normals)
+        .replace('#include <map_fragment>', baseMap)
+        .replace('#include <roughnessmap_fragment>', roughnessMap)
+        .replace('vec3 Fcc = F_Schlick', `
+          // Blender's slab_transmittance_at_angle (gpu_shader_material_principled.glsl):
+          // Beer-Lambert attenuation through a refracting coat at this view angle.
+          float coatPath = blenderCoatIor * inversesqrt(max(1e-8,
+            blenderCoatIor * blenderCoatIor - (1.0 - dotNVcc * dotNVcc)));
+          outgoingLight *= mix(vec3(1.0), pow(max(blenderCoatTint, vec3(0.0)), vec3(coatPath)), material.clearcoat);
+          vec3 Fcc = F_Schlick`);
+      // The material's node graph, when the session shipped one, drives the
+      // surface inputs it carries (`blender-graph-material.ts`).
+      applyGraphShader(material, shader);
+    };
+    material.needsUpdate = true;
+  }
+  values.blenderCoatIor.value = Math.max(1, data.coat_ior);
+  values.blenderCoatTint.value.setRGB(...data.coat_tint, THREE.LinearSRGBColorSpace);
+  values.blenderMapClip.value = clips.map === true;
+  values.blenderRoughnessClip.value = clips.roughness === true;
+  values.blenderNormalClip.value = clips.normal === true;
+}

package/browser/three/blender-presenter-change.ts

@@ -0,0 +1,24 @@
+/**
+ * WORK THAT FINISHES AFTER A FRAME WAS APPLIED, announced.
+ *
+ * A presented frame is not the last change to what the presenter draws: a
+ * PNG decodes after the frame that named it, a clone's sampler uploads after
+ * that decode, a sky is derived on a worker, the area-light tables load on
+ * demand, and a graph's program swaps in once `compileAsync` links it. A
+ * stage that draws only when something changed (`BlenderRuntimeView.onChange`)
+ * needs every one of those to say so, or the viewport holds the picture from
+ * before it -- an untextured mesh, a missing sky -- until something else
+ * happens to move. Each such completion calls {@link presenterChanged}.
+ */
+const listeners = new Set<() => void>();
+
+export function presenterChanged(): void {
+  for (const listener of [...listeners]) listener();
+}
+
+export function onPresenterChange(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}

package/browser/three/blender-runtime-geometry.ts

@@ -39,6 +39,15 @@ export interface DrawArrays {
   normals: Float32Array | null;
   /** Per drawn vertex, or null when the mesh has no UV map. */
   uv: Float32Array | null;
+  /** All named UV layers; material inputs choose their own layer per draw. */
+  uvLayers?: {name: string; data: Float32Array}[] | undefined;
+  /** The mesh's generic attribute layers a material's Attribute or Color
+   *  Attribute node can read, four floats per drawn vertex as EEVEE loads them
+   *  (`graphAttributeLayers`). */
+  attributeLayers?: {name: string; data: Float32Array}[] | undefined;
+  /** Per drawn vertex, a deformed mesh's Generated coordinates (0..1), or
+   *  null when the positions are undeformed and orco derives from them. */
+  orco?: Float32Array | null | undefined;
   indices: Uint32Array;
   groups: { start: number; count: number; materialIndex: number }[];
   /** THE BLENDER VERTEX EACH DRAWN VERTEX CAME FROM, one per drawn vertex.
@@ -58,6 +67,9 @@ export interface DrawArrays {
 interface DrawView {
   vertexCount: number;
   normals: Normal[] | null;
+  cornerNormal?: Float32Array | undefined;
+  /** Blender's stored orco (-1..1), 3 per vertex. */
+  orco?: Float32Array | undefined;
   co(i: number): THREE.Vector3;
   /** CSR faces: corner `starts[i]..starts[i+1]` hold vertex indices. */
   starts: Uint32Array;
@@ -69,6 +81,50 @@ interface DrawView {
   sharp: Iterable<[number, number]>;
   /** A corner's UV, or undefined when the mesh has no map. */
   uv: ((corner: number) => [number, number]) | null;
+  uvLayers?: {name: string; read: (corner: number) => [number, number]}[];
+  /** A corner's value of each generic attribute layer, by vertex, corner and
+   *  face; `corner` and `face` are undefined for a loose vertex. */
+  attributeLayers?: {name: string; domain: string;
+    read: (vertex: number, corner: number | undefined, face: number | undefined) => ArrayLike<number>}[];
+}
+
+/** EEVEE's float4 of an attribute value: float (f, f, f, 1), float2 (x, y, 0,
+ *  1), float3 (x, y, z, 1), a colour as itself, a byte colour decoded from
+ *  sRGB (`ColorGeometry4b::decode`). */
+const GRAPH_ATTRIBUTE_TYPES = new Set(['FLOAT', 'FLOAT2', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'BYTE_COLOR']);
+function srgbToLinear(byte: number): number {
+  const c = byte / 255;
+  return c < 0.04045 ? (c < 0 ? 0 : c * (1 / 12.92)) : ((c + 0.055) * (1 / 1.055)) ** 2.4;
+}
+function attributeFloat4(type: string, values: ArrayLike<number>, i: number): [number, number, number, number] {
+  switch (type) {
+    case 'FLOAT': { const f = Number(values[i]); return [f, f, f, 1]; }
+    case 'FLOAT2': return [Number(values[i * 2]), Number(values[i * 2 + 1]), 0, 1];
+    case 'FLOAT_VECTOR': return [Number(values[i * 3]), Number(values[i * 3 + 1]), Number(values[i * 3 + 2]), 1];
+    case 'BYTE_COLOR': return [srgbToLinear(Number(values[i * 4])), srgbToLinear(Number(values[i * 4 + 1])),
+      srgbToLinear(Number(values[i * 4 + 2])), Number(values[i * 4 + 3]) / 255];
+    default: return [Number(values[i * 4]), Number(values[i * 4 + 1]), Number(values[i * 4 + 2]), Number(values[i * 4 + 3])];
+  }
+}
+/** The readable layers of `attributes`: every generic layer of a type EEVEE
+ *  loads as a float4, on a domain a drawn vertex has a value on. UV maps stay
+ *  `uvLayers`; names Blender keeps internal (`.select_vert`, the positions,
+ *  the custom normals) are not material inputs. */
+function graphAttributeLayers(
+  attributes: readonly {name: string; domain: string; type: string; data: ArrayLike<unknown>}[],
+  flat: (data: ArrayLike<unknown>, type: string) => ArrayLike<number>,
+): NonNullable<DrawView['attributeLayers']> {
+  return attributes
+    .filter(a => GRAPH_ATTRIBUTE_TYPES.has(a.type) && a.domain !== 'EDGE' && !a.name.startsWith('.')
+      && a.name !== 'position' && a.name !== 'custom_normal' && !(a.type === 'FLOAT2' && a.domain === 'CORNER'))
+    .map(a => {
+      const values = flat(a.data, a.type);
+      const zero = [0, 0, 0, 0];
+      return {name: a.name, domain: a.domain, read: (vertex: number, corner: number | undefined, face: number | undefined) =>
+        a.domain === 'POINT' ? attributeFloat4(a.type, values, vertex)
+        : a.domain === 'CORNER' ? (corner === undefined ? zero : attributeFloat4(a.type, values, corner))
+        : face === undefined ? zero : attributeFloat4(a.type, values, face)};
+    });
 }
 
 function drawCore(view: DrawView): Omit<DrawArrays, 'hash'> {
@@ -147,28 +203,39 @@ function drawCore(view: DrawView): Omit<DrawArrays, 'hash'> {
   const positions = new Float32Array(capacity * 3),
     texcoords = new Float32Array(capacity * 2);
   const sourceVertex = new Uint32Array(capacity);
+  const uvLayers = (view.uvLayers ?? []).map(layer => ({...layer, data: new Float32Array(capacity * 2)}));
+  const attributeLayers = (view.attributeLayers ?? []).map(layer => ({...layer, data: new Float32Array(capacity * 4)}));
+  const orco = view.orco ? new Float32Array(capacity * 3) : null;
   const indices = new Uint32Array(capacity),
     shared = new Map<string, number>();
   const groups: DrawArrays['groups'] = [];
-  const normals = view.normals ? new Float32Array(capacity * 3) : null;
+  const normals = view.normals || view.cornerNormal ? new Float32Array(capacity * 3) : null;
   let count = 0,
     indexCount = 0;
-  const emit = (v: number, texture?: [number, number], normal?: Normal): number => {
+  const emit = (v: number, texture?: [number, number], normal?: Normal, sourceCorner?: number, face?: number): number => {
     const index = count++;
+    for (const layer of attributeLayers) layer.data.set(layer.read(v, sourceCorner, face), index * 4);
+    // attr_load_orco: the stored -1..1 orco, mapped to 0..1.
+    if (orco) for (let k = 0; k < 3; k++) orco[index * 3 + k] = view.orco![v * 3 + k]! * 0.5 + 0.5;
     sourceVertex[index] = v;
     view.co(v).toArray(positions, index * 3);
     if (texture) texcoords.set(texture, index * 2);
     if (normal) normals!.set(normal, index * 3);
+    if (sourceCorner !== undefined) for (const layer of uvLayers) layer.data.set(layer.read(sourceCorner), index * 2);
     return index;
   };
-  const corner = (c: number): number => {
+  const corner = (c: number, face: number): number => {
     const texture = uv?.(c);
-    const normal = view.normals?.[c];
-    if (!mixed) return emit(cornerVerts[c]!, texture, normal);
-    const key = `${smooth[c] ? find(c) : c}${texture ? `:${texture[0]}:${texture[1]}` : ''}${normal ? `:n${normal.join(':')}` : ''}`;
+    const normal: Normal | undefined = view.cornerNormal
+      ? [view.cornerNormal[c * 3]!, view.cornerNormal[c * 3 + 1]!, view.cornerNormal[c * 3 + 2]!]
+      : view.normals?.[c];
+    if (!mixed) return emit(cornerVerts[c]!, texture, normal, c, face);
+    // A POINT layer's value is the vertex's, which the smooth fan already
+    // shares; a face or corner layer splits the fan where its values differ.
+    const key = `${smooth[c] ? find(c) : c}${texture ? `:${texture[0]}:${texture[1]}` : ''}${normal ? `:n${normal.join(':')}` : ''}${uvLayers.map(layer => ':' + layer.read(c).join(':')).join('')}${attributeLayers.map(layer => layer.domain === 'POINT' ? '' : ':' + Array.from(layer.read(cornerVerts[c]!, c, face)).join(':')).join('')}`;
     let index = shared.get(key);
     if (index === undefined) {
-      index = emit(cornerVerts[c]!, texture, normal);
+      index = emit(cornerVerts[c]!, texture, normal, c, face);
       shared.set(key, index);
     }
     return index;
@@ -180,7 +247,7 @@ function drawCore(view: DrawView): Omit<DrawArrays, 'hash'> {
     const points: THREE.Vector3[] = [];
     for (let j = 0; j < length; j++) points.push(view.co(cornerVerts[faceStart + j]!));
     for (const triangle of triangulatePolygon(points).triangles)
-      for (const c of triangle) indices[indexCount++] = corner(faceStart + c);
+      for (const c of triangle) indices[indexCount++] = corner(faceStart + c, i);
     const materialIndex = view.material(i),
       previous = groups.at(-1);
     if (previous?.materialIndex === materialIndex) previous.count += indexCount - start;
@@ -191,12 +258,22 @@ function drawCore(view: DrawView): Omit<DrawArrays, 'hash'> {
     positions: positions.slice(0, count * 3),
     normals: normals?.slice(0, count * 3) ?? null,
     uv: uv ? texcoords.slice(0, count * 2) : null,
+    uvLayers: uvLayers.map(layer => ({name: layer.name, data: layer.data.slice(0, count * 2)})),
+    attributeLayers: attributeLayers.map(layer => ({name: layer.name, data: layer.data.slice(0, count * 4)})),
+    orco: orco ? orco.slice(0, count * 3) : null,
     indices: indices.slice(0, indexCount),
     sourceVertex: sourceVertex.slice(0, count),
     groups,
   };
 }
 
+/** The three attribute a graph reads Blender attribute `name` from: a GLSL
+ *  identifier spelled from the name's UTF-8 bytes, so every name has one and
+ *  no two names share one. */
+export function graphAttributeName(name: string): string {
+  return `blenderA_${Array.from(new TextEncoder().encode(name), b => b.toString(16).padStart(2, '0')).join('')}`;
+}
+
 export function geometryFromDrawArrays(
   arrays: Omit<DrawArrays, 'hash' | 'sourceVertex'> & { sourceVertex?: Uint32Array },
 ): THREE.BufferGeometry {
@@ -207,6 +284,22 @@ export function geometryFromDrawArrays(
     new THREE.BufferAttribute(arrays.uv ?? new Float32Array((arrays.positions.length / 3) * 2), 2),
   );
   geometry.setIndex(new THREE.BufferAttribute(arrays.indices, 1));
+  const channels: Record<string, number> = Object.create(null);
+  for (const [index, layer] of (arrays.uvLayers ?? []).entries()) {
+    // Blender's MAX_MTFACE is eight. Channel zero is the active render map;
+    // named inputs use their independently selectable channel, including it.
+    if (index >= 8) throw new Error('A Blender mesh supports at most eight UV maps');
+    channels[layer.name] = index + 1;
+    geometry.setAttribute(`uv${index + 1}`, new THREE.BufferAttribute(layer.data, 2));
+  }
+  geometry.userData['blenderUvChannels'] = channels;
+  for (const layer of arrays.attributeLayers ?? [])
+    geometry.setAttribute(graphAttributeName(layer.name), new THREE.BufferAttribute(layer.data, 4));
+  geometry.userData['blenderAttributes'] = (arrays.attributeLayers ?? []).map(layer => layer.name);
+  if (arrays.orco) {
+    geometry.setAttribute('blenderOrco', new THREE.BufferAttribute(arrays.orco, 3));
+    geometry.userData['blenderOrcoFromDoor'] = true;
+  }
   for (const group of arrays.groups)
     geometry.addGroup(group.start, group.count, group.materialIndex);
   if (arrays.normals) geometry.setAttribute('normal', new THREE.BufferAttribute(arrays.normals, 3));
@@ -233,7 +326,7 @@ export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays
   for (let i = 0; i < ne; i++) edges[i] = [c.edge[i * 2]!, c.edge[i * 2 + 1]!];
   const sharp: [number, number][] = [];
   for (let i = 0; i < ne; i++) if (c.edgeSharp[i] === 1) sharp.push(edges[i]!);
-  const custom = c.attributes.find((a) => a.name === 'custom_normal');
+  const custom = c.cornerNormal ? undefined : c.attributes.find((a) => a.name === 'custom_normal');
   const normalMesh = custom
     ? {
         v: Array.from(
@@ -269,6 +362,8 @@ export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays
   const view: DrawView = {
     vertexCount: nv,
     normals: normalMesh ? customCornerNormals(normalMesh, customData) : null,
+    cornerNormal: c.cornerNormal,
+    orco: c.orco,
     co: (i) => scratch.set(c.co[i * 3]!, c.co[i * 3 + 1]!, c.co[i * 3 + 2]!).clone(),
     starts: c.faceStart,
     cornerVerts: c.corner,
@@ -277,6 +372,9 @@ export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays
     edges,
     sharp,
     uv: uvData ? (corner) => [uvData[corner * 2]!, uvData[corner * 2 + 1]!] : null,
+    uvLayers: maps.map(layer => ({name: layer.name, read: (corner: number) =>
+      [Number(layer.data[corner * 2]), Number(layer.data[corner * 2 + 1])] as [number, number]})),
+    attributeLayers: graphAttributeLayers(c.attributes, data => data as ArrayLike<number>),
   };
   if (map && ATTRIBUTE_LAYOUT.FLOAT2.size !== 2) throw new Error('FLOAT2 layout');
   return { ...drawCore(view), hash };
@@ -337,6 +435,11 @@ export function drawRuntimeGeometry(data: MeshData): THREE.BufferGeometry {
     edges: data.edge_order ?? data.e ?? null,
     sharp: data.sharp ?? [],
     uv: uv ? (corner) => uv[corner]! : null,
+    uvLayers: maps.map(layer => ({name: layer.name, read: (corner: number) =>
+      (layer.data as [number, number][])[corner]!})),
+    // The JSON door nests each element's components; the reader wants them flat.
+    attributeLayers: graphAttributeLayers(data.attributes ?? [],
+      values => (Array.from(values) as (number | number[])[]).flat()),
   };
   return geometryFromDrawArrays(drawCore(view));
 }

package/browser/three/blender-runtime-lighting.ts

@@ -35,6 +35,7 @@
  * faked with a substitute light the scene never declared.
  */
 import * as THREE from 'three';
+import {presenterChanged} from './blender-presenter-change';
 import { z } from 'zod';
 import type { GradientType } from './blender-gradient-texture';
 import { hasSkyTexture, primeSkyTexture, type SkyParameters } from './blender-sky';
@@ -76,6 +77,7 @@ function prepareRectArea(): Promise<void> {
   rectAreaPromise ??= import('three/examples/jsm/lights/RectAreaLightUniformsLib.js').then(
     ({ RectAreaLightUniformsLib }) => {
       RectAreaLightUniformsLib.init();
+      presenterChanged();
     },
   );
   return rectAreaPromise;
@@ -531,6 +533,14 @@ const worldRadiance = z.object({
 });
 export const worldSchema = worldRadiance
   .extend({
+    volume: z.array(z.object({
+      kind: z.enum(['absorption', 'scatter', 'principled', 'emission']),
+      phase: z.string(), alpha: worldExpression,
+      weight: worldExpression, color: worldExpression, density: worldExpression,
+      anisotropy: worldExpression, absorption_color: worldExpression,
+      emission_color: worldExpression, emission_strength: worldExpression,
+      blackbody_intensity: worldExpression, temperature: worldExpression, blackbody_tint: worldExpression,
+    }).strict()).optional(),
     /** The world that LIGHTS the scene, present only when Blender's Light Path
      * `Is Camera Ray` split it from the world the camera photographs -- one
      * sky at two strengths is how a scene gets a bright backdrop and
@@ -757,6 +767,7 @@ export class WorldBackground {
       // composing now would paint a sky nobody asked for over the current one.
       if (this.generation !== generation || this.applied?.scene !== scene) return;
       this.compose(scene, world, expression, camera);
+      presenterChanged();
     })();
     this.pending = pending;
     pendingWorld.add(pending);