@volter/blender-engine 0.1.127 → 0.1.128

package/browser/three/blender-display-transform.ts

@@ -0,0 +1,139 @@
+import * as THREE from 'three';
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
+import displayShaders from './blender-display-shaders.json';
+import type { RenderRequest } from '../protocol';
+
+export interface BlenderDisplaySettings {
+  readonly transform: string;
+  readonly look: string;
+  /** Linear multiplier, after alpha unassociation and before the view transform. */
+  readonly exposure: number;
+  readonly gamma: number;
+}
+
+export function blenderDisplaySettingsForRender(render: Pick<RenderRequest, 'toneMapping' | 'look' | 'exposure' | 'gamma'>): BlenderDisplaySettings {
+  return {
+    transform: {none: 'Standard', filmic: 'Filmic', agx: 'AgX', neutral: 'Khronos PBR Neutral'}[render.toneMapping],
+    look: render.look ?? 'None', exposure: render.exposure, gamma: render.gamma ?? 1,
+  };
+}
+
+interface DisplayTexture {
+  readonly sampler: string;
+  readonly offset: number;
+  readonly count: number;
+  readonly linear: boolean;
+  readonly channels: number;
+  readonly size?: number;
+  readonly width?: number;
+  readonly height?: number;
+}
+interface DisplayProcessor {
+  readonly shader: string;
+  readonly textures: readonly DisplayTexture[];
+}
+const processors: Readonly<Record<string, DisplayProcessor>> = displayShaders.processors;
+
+let tableData: Promise<ArrayBuffer> | null = null;
+function loadDisplayData(): Promise<ArrayBuffer> {
+  return tableData ??= fetch(new URL('./blender-display-shaders.lut', import.meta.url))
+    .then(async response => {
+      if (!response.ok) throw new Error(`Blender display tables: ${response.status}`);
+      return response.arrayBuffer();
+    }).catch(error => { tableData = null; throw error; });
+}
+
+/** Native OCIO-generated shaders, not a resampled look+view cube. The exact
+ * operation order and tetrahedral sampling come from Blender's pinned config.
+ * Apply after scene-linear compositing; exposure precedes the view, gamma
+ * follows it. Resources belong to the mounted document, never the frame loop. */
+export class BlenderDisplayTransform {
+  private readonly material: THREE.RawShaderMaterial;
+  private readonly quad: FullScreenQuad;
+  private readonly textures: THREE.Texture[] = [];
+
+  constructor(settings: BlenderDisplaySettings, data: ArrayBuffer) {
+    const processor = processors[`${settings.transform}/${settings.look}`];
+    if (!processor) throw new Error(`Unimplemented Blender display transform: ${settings.transform}, ${settings.look}`);
+    const uniforms: Record<string, THREE.IUniform> = {
+      frame: {value: null}, exposure: {value: settings.exposure},
+      exponent: {value: 1 / Math.max(1e-7, settings.gamma)}, straightAlpha: {value: false},
+    };
+    for (const spec of processor.textures) {
+      if (spec.offset + spec.count * 4 > data.byteLength)
+        throw new Error('Invalid Blender display table');
+    }
+    for (const spec of processor.textures) {
+      const values = new Float32Array(data, spec.offset, spec.count);
+      // OCIO stores a 3D texture with blue varying fastest. Its generated GLSL
+      // samples .zyx, so retain that order rather than transposing the cube.
+      let texture: THREE.DataTexture | THREE.Data3DTexture;
+      if (spec.size) texture = new THREE.Data3DTexture(values, spec.size, spec.size, spec.size);
+      else texture = new THREE.DataTexture(values, spec.width, spec.height);
+      texture.type = THREE.FloatType;
+      texture.format = spec.channels === 1 ? THREE.RedFormat : THREE.RGBFormat;
+      // Three infers sized float formats for Red/RGBA, but not RGB. WebGL2's
+      // immutable 3D storage rejects an unsized RGB internal format.
+      texture.internalFormat = spec.channels === 1 ? 'R32F' : 'RGB32F';
+      texture.minFilter = texture.magFilter = spec.linear ? THREE.LinearFilter : THREE.NearestFilter;
+      texture.wrapS = texture.wrapT = THREE.ClampToEdgeWrapping;
+      texture.unpackAlignment = 1;
+      texture.needsUpdate = true;
+      this.textures.push(texture);
+      uniforms[spec.sampler] = {value: texture};
+    }
+    this.material = new THREE.RawShaderMaterial({
+      name: 'Blender OCIO display', glslVersion: THREE.GLSL3,
+      depthTest: false, depthWrite: false, blending: THREE.NoBlending,
+      uniforms,
+      vertexShader: `precision highp float; in vec3 position; in vec2 uv; out vec2 vUv;
+        void main(){vUv=uv;gl_Position=vec4(position,1.0);}`,
+      fragmentShader: `precision highp float; precision highp sampler3D;
+        uniform sampler2D frame; uniform float exposure; uniform float exponent;
+        uniform bool straightAlpha; in vec2 vUv; out vec4 outputColor;
+        ${processor.shader}
+        void main() {
+          vec4 pixel=texture(frame,vUv);
+          vec3 linear=pixel.rgb*(pixel.a==0.0 ? exposure : exposure/pixel.a);
+          vec3 display=clamp(pow(max(blenderDisplay(vec4(linear,1.0)).rgb,vec3(0.0)),vec3(exponent)),0.0,1.0);
+          outputColor=vec4(straightAlpha ? display : display*pixel.a,pixel.a);
+        }`,
+    });
+    this.quad = new FullScreenQuad(this.material);
+  }
+
+  render(renderer: THREE.WebGLRenderer, input: Pick<THREE.WebGLRenderTarget, 'texture'>,
+    output: THREE.WebGLRenderTarget | null, straightAlpha: boolean): void {
+    this.material.uniforms['frame']!.value = input.texture;
+    this.material.uniforms['straightAlpha']!.value = straightAlpha;
+    renderer.setRenderTarget(output);
+    this.quad.render(renderer);
+  }
+
+  /** Explicit render/compositor readback, never used by the live frame loop. */
+  encodeFrame(renderer: THREE.WebGLRenderer, pixels: Uint16Array, width: number, height: number): Uint8Array {
+    const previous = renderer.getRenderTarget();
+    const input = new THREE.DataTexture(pixels, width, height, THREE.RGBAFormat, THREE.HalfFloatType);
+    input.needsUpdate = true;
+    const output = new THREE.WebGLRenderTarget(width, height);
+    try {
+      this.render(renderer, {texture: input}, output, true);
+      const bytes = new Uint8Array(width * height * 4);
+      renderer.readRenderTargetPixels(output, 0, 0, width, height, bytes);
+      return bytes;
+    } finally {
+      renderer.setRenderTarget(previous); input.dispose(); output.dispose();
+    }
+  }
+
+  dispose(): void {
+    for (const texture of this.textures) texture.dispose();
+    this.material.dispose(); this.quad.dispose();
+  }
+}
+
+export async function createBlenderDisplayTransform(settings: BlenderDisplaySettings): Promise<BlenderDisplayTransform> {
+  if (!processors[`${settings.transform}/${settings.look}`])
+    throw new Error(`Unimplemented Blender display transform: ${settings.transform}, ${settings.look}`);
+  return new BlenderDisplayTransform(settings, await loadDisplayData());
+}

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

@@ -24,6 +24,9 @@ interface Binding {
   ramps: THREE.DataTexture[];
   /** Named UV layer to the channel the current draw's geometry holds it in. */
   channels: Record<string, number>;
+  borrowedFrom?: Binding;
+  borrowedSource?: THREE.MeshPhysicalMaterial;
+  objectInfoUniforms?: {color: THREE.IUniform<THREE.Vector4>; indexRandom: THREE.IUniform<THREE.Vector2>};
   palette?: {indices: Int32Array; sources: readonly THREE.MeshPhysicalMaterial[]};
 }
 const bindings = new WeakMap<THREE.MeshPhysicalMaterial, Binding>();
@@ -43,7 +46,7 @@ function compatiblePaletteGraphs(sources: readonly THREE.MeshPhysicalMaterial[])
   if (sources.length !== 2 || sources.some(source => pendings.has(source))) return null;
   const graphs = sources.map(source => bindings.get(source)?.compiled);
   const graph = graphs[0];
-  if (!graph || failed.has(graph.key) || graphs.some(other => !other || other.key !== graph.key ||
+  if (!graph || graph.objectInfo || failed.has(graph.key) || graphs.some(other => !other || other.key !== graph.key ||
       other.declarations !== graph.declarations || other.library !== graph.library ||
       JSON.stringify([other.uvs, other.attributes, other.outputs]) !== JSON.stringify([graph.uvs, graph.attributes, graph.outputs]))) return null;
   // Leave room for the physical material's environment and lighting samplers.
@@ -160,22 +163,42 @@ export function setMaterialGraph(
 }
 
 /** A disposable draw material borrows the source's live uniform values, never
- * its owned ramp textures or geometry-dependent UV selector. Pending graphs
- * must first draw through their source so its asynchronous compile can finish. */
-export function borrowGraphDrawBinding(source: THREE.MeshPhysicalMaterial, target: THREE.MeshPhysicalMaterial): boolean {
-  if (pendings.has(source)) return false;
+ * its owned ramp textures or geometry-dependent UV selector. Ordinary copies
+ * wait for pending graphs; retained copies draw the previous graph and start
+ * their source's compilation from their draw hook. */
+export function borrowGraphDrawBinding(source: THREE.MeshPhysicalMaterial, target: THREE.MeshPhysicalMaterial,
+  retainCurrent = false): boolean {
+  if (pendings.has(source) && !retainCurrent) return false;
   const sourceBinding = bindings.get(source);
   const binding = sourceBinding && !failed.has(sourceBinding.compiled.key) ? sourceBinding : undefined;
   const held = bindings.get(target);
   if (!binding) {
     if (held) { bindings.delete(target); target.needsUpdate = true; }
-  } else if (!held || held.compiled.key !== binding.compiled.key || held.uniforms !== binding.uniforms) {
-    bindings.set(target, {compiled: binding.compiled, uniforms: binding.uniforms, ramps: [], channels: {}});
+  } else if (!held || held.compiled.key !== binding.compiled.key || held.borrowedFrom !== binding) {
+    bindings.set(target, {compiled: binding.compiled, uniforms: binding.uniforms, ramps: [], channels: {},
+      borrowedFrom: binding, ...(retainCurrent ? {borrowedSource: source} : {})});
     target.needsUpdate = true;
   }
   return true;
 }
 
+/** Draw copies borrow authored graph values/textures, but Object Info values
+ * belong to ONE object. A distinct material identity makes Three upload them
+ * when it switches between objects sharing an authored material. */
+export function bindGraphObjectInfo(material: THREE.MeshPhysicalMaterial,
+  info: {color: readonly number[]; index: number; random: number}): void {
+  const binding=bindings.get(material);
+  if (!binding?.compiled.objectInfo) return;
+  const values=binding.objectInfoUniforms ??= {
+    color:{value:new THREE.Vector4()}, indexRandom:{value:new THREE.Vector2()},
+  };
+  if (binding.uniforms['blenderObjectColor']!==values.color) {
+    binding.uniforms={...binding.uniforms,blenderObjectColor:values.color,blenderObjectIndexRandom:values.indexRandom};
+  }
+  values.color.value.fromArray(info.color);
+  values.indexRandom.value.set(info.index,info.random);
+}
+
 /** A binding's values: uniforms, ramp tables and textures. */
 function fill(binding: Binding, compiled: CompiledGraph, texture: (image: CompiledGraph['images'][number]) => ImageTexture): void {
   binding.compiled = compiled;
@@ -287,6 +310,10 @@ function channelsMatch(compiled: CompiledGraph, channels: Record<string, number>
 export function bindGraphDraw(material: THREE.MeshPhysicalMaterial, geometry: THREE.BufferGeometry,
   renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, object: THREE.Object3D,
   shadowOf: (material: THREE.MeshPhysicalMaterial) => THREE.MeshPhysicalMaterial): void {
+  // A per-object copy can be the only visible wearer. Keep its authored
+  // material's asynchronous compilation alive while drawing the old graph.
+  const source=bindings.get(material)?.borrowedSource;
+  if(source && source!==material) bindGraphDraw(source,geometry,renderer,scene,camera,object,shadowOf);
   const retired = retiring.get(material);
   if (retired && ++retired.draws > 1) {
     retired.shadow.dispose();

package/browser/three/blender-node-graph.ts

@@ -49,7 +49,7 @@ export const GRAPH_NODE_TYPES = [
   'ShaderNodeGamma', 'ShaderNodeRGBToBW', 'ShaderNodeSeparateColor', 'ShaderNodeCombineColor',
   'ShaderNodeVectorRotate', 'ShaderNodeFresnel', 'ShaderNodeLayerWeight', 'ShaderNodeBump',
   'ShaderNodeNormalMap', 'ShaderNodeNewGeometry', 'ShaderNodeVertexColor', 'ShaderNodeAttribute',
-  'ShaderNodeRGBCurve', 'ShaderNodeVectorCurve', 'ShaderNodeFloatCurve',
+  'ShaderNodeRGBCurve', 'ShaderNodeVectorCurve', 'ShaderNodeFloatCurve', 'ShaderNodeObjectInfo',
 ] as const;
 
 const nodeSchema = z.object({
@@ -143,6 +143,8 @@ export interface CompiledGraph {
   /** The mesh attributes the graph reads, by Blender name; '' is the mesh's
    *  default colour attribute (a Color Attribute node with no layer). */
   readonly attributes: readonly string[];
+  /** Requires a draw identity with this object's native inputs. */
+  readonly objectInfo: boolean;
   /** Which surface inputs the graph drives, each a GLSL global of `type`. */
   readonly outputs: Readonly<Record<string, {readonly global: string; readonly type: GpuType}>>;
   readonly surface: MaterialGraph['surface'];
@@ -487,6 +489,15 @@ class Compiler {
         body.push(`${outputs[0]!.name} = ${this.uniform(type, prop<number | number[]>(node, 'value'))};`);
         break;
       }
+      case 'ShaderNodeObjectInfo': {
+        // node_shader_gpu_object_info / node_object_info. Location is the
+        // object's origin, never the current fragment's world position.
+        const values = ['object_matrices_get().model[3].xyz', 'blenderObjectColor',
+          'blenderObjectColor.a', 'blenderObjectIndexRandom.x',
+          this.uniform('float', prop<number>(node, 'material_index')), 'blenderObjectIndexRandom.y'];
+        values.forEach((v,i)=>{if(outputs[i]) body.push(`${outputs[i]!.name} = ${v};`);});
+        break;
+      }
       case 'ShaderNodeTexCoord': {
         // node_tex_coord's outputs, in socket order.
         this.s.uvs.add('');
@@ -946,6 +957,8 @@ class Compiler {
         [...this.s.functions, graphBody].join('\n')),
     ].join('\n');
     const program = [
+      ...(Object.values(this.graph.nodes).some(n=>n.type==='ShaderNodeObjectInfo')
+        ? ['uniform vec4 blenderObjectColor;', 'uniform vec2 blenderObjectIndexRandom;'] : []),
       ...[...this.s.uniformTypes].map(([n, t]) => `uniform ${t} ${n};`),
       ...this.images.map(i => i.tiled
         ? `uniform highp sampler2DArray ${i.uniform};\nuniform highp sampler2D ${i.uniform}Map;`
@@ -966,6 +979,7 @@ class Compiler {
       ramps: this.ramps,
       uvs: [...this.s.uvs],
       attributes: [...this.s.attributes],
+      objectInfo: Object.values(this.graph.nodes).some(n=>n.type==='ShaderNodeObjectInfo'),
       outputs,
       surface: this.graph.surface,
       closure: closure !== undefined,

package/browser/three/blender-object-info-materials.ts

@@ -0,0 +1,75 @@
+import * as THREE from 'three';
+import {bindGraphObjectInfo, materialGraph} from './blender-graph-material';
+import {syncPhysicalDrawMaterial} from './blender-physical-material';
+
+export interface BlenderObjectInfo {
+  readonly color: readonly number[];
+  readonly index: number;
+  readonly random: number;
+}
+type Draw = {source: THREE.MeshPhysicalMaterial; mesh: THREE.Mesh; material: THREE.MeshPhysicalMaterial; version:number};
+
+/** Per-object shader inputs cannot be shared between material identities:
+ * Three skips uploads when successive objects wear the same material. Keep
+ * small draw copies, sharing every image/ramp, rather than copying geometry or
+ * flattening Random to a constant. Instance/palette optimization stays out of
+ * these draws until it can carry every native per-instance input. */
+export class BlenderObjectInfoMaterials {
+  private readonly draws=new Map<string,Draw>();
+  private readonly sources=new Map<THREE.MeshPhysicalMaterial,string|null>();
+  private used=new Set<string>();
+
+  begin(): void {this.used.clear();this.sources.clear();}
+
+  get(source: THREE.Material, mesh: THREE.Mesh): THREE.Material {
+    if (!(source instanceof THREE.MeshPhysicalMaterial)) return source;
+    const graph=materialGraph(source);
+    this.sources.set(source,graph?.key??null);
+    if (!graph?.objectInfo) return source;
+    const info=mesh.userData['blenderObjectInfo'] as BlenderObjectInfo|undefined;
+    if (!info) throw new Error(`Object Info inputs missing for Blender object ${mesh.name}`);
+    const key=`${mesh.uuid}:${source.uuid}`;
+    this.used.add(key);
+    let draw=this.draws.get(key);
+    if (!draw) {
+      const material=syncPhysicalDrawMaterial(source,undefined,true);
+      if (!material) return source;
+      draw={source,mesh,material,version:source.version};
+      this.draws.set(key,draw);
+    }
+    this.sync(draw,info);
+    return draw.material;
+  }
+
+  end(): void {
+    for(const [key,draw] of this.draws) if(!this.used.has(key)) {
+      draw.material.dispose();this.draws.delete(key);
+    }
+  }
+
+  /** A pending authored graph can finish without another native export. */
+  needsRemap(): boolean {
+    return [...this.sources].some(([source,key])=>(materialGraph(source)?.key??null)!==key);
+  }
+
+  refresh(): void {
+    for(const draw of this.draws.values()) {
+      const info=draw.mesh.userData['blenderObjectInfo'] as BlenderObjectInfo|undefined;
+      if (!info) throw new Error(`Object Info inputs missing for Blender object ${draw.mesh.name}`);
+      this.sync(draw,info);
+    }
+  }
+
+  private sync(draw:Draw,info:BlenderObjectInfo): void {
+    if(!syncPhysicalDrawMaterial(draw.source,draw.material,true))
+      throw new Error(`Object Info material ${draw.source.name} lost its draw binding`);
+    if(draw.version!==draw.source.version) draw.material.needsUpdate=true;
+    draw.version=draw.source.version;
+    bindGraphObjectInfo(draw.material,info);
+  }
+
+  clear(): void {
+    for(const draw of this.draws.values()) draw.material.dispose();
+    this.draws.clear();this.sources.clear();this.used.clear();
+  }
+}

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

@@ -140,10 +140,11 @@ export function physicalPaletteMaterial(compiled: CompiledGraph, sources: readon
 
 /** Copy physical values into an independently cached draw form. Textures and
  * graph uniform values remain borrowed from the authoritative source material. */
-export function syncPhysicalDrawMaterial(source: THREE.Material, target?: THREE.MeshPhysicalMaterial): THREE.MeshPhysicalMaterial | null {
+export function syncPhysicalDrawMaterial(source: THREE.Material, target?: THREE.MeshPhysicalMaterial,
+  retainCurrentGraph = false): THREE.MeshPhysicalMaterial | null {
   if (!(source instanceof THREE.MeshPhysicalMaterial) || !uniforms.has(source) || !materialDrawHooksSupported(source)) return null;
   const copy = target ?? graphShadow(source);
-  if (!borrowGraphDrawBinding(source, copy)) {
+  if (!borrowGraphDrawBinding(source, copy, retainCurrentGraph)) {
     if (!target) copy.dispose();
     return null;
   }

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

@@ -240,7 +240,7 @@ const BONE_SOLID_VERTEX = /* glsl */ `
  * ONLY THE `_fragment` HALF: three PREPENDS `colorspace_pars_fragment` to every
  * `ShaderMaterial` already, so including it here declared `LinearTransferOETF`,
  * `sRGBTransferEOTF` and `sRGBTransferOETF` twice and the whole program refused
- * to compile ("function already has a body", measured live in `volter-model-editor console`).
+ * to compile ("function already has a body", measured live in `cyclotron console`).
  */
 const BONE_SOLID_FRAGMENT = /* glsl */ `
   varying vec3 vColor;

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

@@ -264,7 +264,7 @@ export const SOLID_LIGHTS: readonly {
  * and AgX within 3, so the curve is NOT what row 1's 13-vs-30 spread was made
  * of and the stage keeps its own operator).
  *
- * THE ROUNDS, on a `model-editor create` scaffold driven through `volter-model-editor
+ * THE ROUNDS, on a `cyclotron create` scaffold driven through `cyclotron
  * screenshot editor`, 30x30 means (std 0 — every patch inside one flat face)
  * of the factory cube's three visible faces against Blender 5.2's own frame,
  * (141,143,145) top / (129,131,131) left / (111,112,113) front:
@@ -435,6 +435,7 @@ export type WorldExpression =
     }
   | {
       kind: 'sky';
+      sky_model?: 'SINGLE_SCATTERING' | 'MULTIPLE_SCATTERING' | undefined;
       sun_elevation: number;
       sun_rotation: number;
       altitude: number;
@@ -531,6 +532,7 @@ const worldExpression: z.ZodType<WorldExpression> = z.lazy(() =>
     z
       .object({
         kind: z.literal('sky'),
+        sky_model: z.enum(['SINGLE_SCATTERING', 'MULTIPLE_SCATTERING']).optional(),
         sun_elevation: scalar,
         sun_rotation: scalar,
         altitude: scalar,

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

@@ -28,6 +28,7 @@ import { fitModelDirectionalShadow, visibleShadowReceivers } from './blender-run
 import { volumeMesh, volumeSchema } from './blender-runtime-volume';
 import { applyPhysicalMaterial, applyWorldExtinction, physicalMaterialSchema } from './blender-physical-material';
 import { prepareGraphGeometry, setMaterialGraph } from './blender-graph-material';
+import {BlenderObjectInfoMaterials} from './blender-object-info-materials';
 import { type CompiledGraph, compileMaterialGraph, graphSeeThrough, materialGraphSchema } from './blender-node-graph';
 import {worldMedium, WorldVolumePass} from './blender-world-volume';
 import { BlenderTextureSamplers } from './blender-texture-samplers';
@@ -525,6 +526,9 @@ export const frameSchema = z
            *  the evaluated bounds (`blender-graph-material.ts`'s orco). */
           texspace: z.tuple([z.tuple([scalar, scalar, scalar]), z.tuple([scalar, scalar, scalar])]).optional(),
           default_color: z.string().optional(),
+          object_info: z.object({
+            color:z.tuple([scalar,scalar,scalar,scalar]),index:scalar,random:scalar,
+          }).strict().optional(),
         })
         .strict(),
     ),
@@ -661,6 +665,7 @@ export class BlenderRuntimeView {
     { signature: string; mesh: ReturnType<typeof volumeMesh> }
   >();
   private readonly materials = new Map<string, THREE.MeshPhysicalMaterial>();
+  private readonly objectInfoMaterials=new BlenderObjectInfoMaterials();
   private readonly lights = new Map<string, THREE.Light>();
   private readonly lighting = new ViewportLighting();
   private readonly world = new WorldBackground();
@@ -1253,6 +1258,7 @@ export class BlenderRuntimeView {
   private applyWorkbench(): void {
     const solid = this.workbench && !this.rendered;
     const used = new Set<string>();
+    this.objectInfoMaterials.begin();
     for (const obj of this.frame?.objects ?? []) {
       if (obj.mesh === null || obj.volume) continue;
       const mesh = this.objects.get(obj.id) as THREE.Mesh | undefined;
@@ -1260,10 +1266,12 @@ export class BlenderRuntimeView {
       const slots: readonly (string | null)[] = obj.materials.length ? obj.materials : [null];
       const shown = slots.map((id) => {
         const authored = id === null ? this.fallback : (this.materials.get(id) ?? this.fallback);
-        return solid ? this.workbenchFor(id, authored.side, used) : authored;
+        return solid ? this.workbenchFor(id, authored.side, used) : this.objectInfoMaterials.get(authored,mesh);
       });
       mesh.material = obj.materials.length ? shown : shown[0]!;
+      prepareGraphGeometry(mesh);
     }
+    this.objectInfoMaterials.end();
     // Released as soon as no surface wears it: a dragged viewport colour makes one per value.
     for (const [key, material] of this.workbenchMaterials) {
       if (used.has(key)) continue;
@@ -1300,6 +1308,10 @@ export class BlenderRuntimeView {
    * actual camera. Transparent instance runs are camera-order dependent. */
   prepareDraw(camera: THREE.Camera, options?: {interactive: boolean; height: number; multiDraw?: boolean; renderer?: THREE.WebGLRenderer}): () => void {
     try {
+      if (!this.workbench || this.rendered) {
+        if(this.objectInfoMaterials.needsRemap()) this.applyWorkbench();
+        this.objectInfoMaterials.refresh();
+      }
       const start = performance.now();
       this.instances.prepareDraw(camera);
       this.root.updateMatrixWorld(true);
@@ -2052,6 +2064,8 @@ export class BlenderRuntimeView {
       else delete object.userData['blenderTexspace'];
       if (obj.default_color !== undefined) object.userData['blenderDefaultColor'] = obj.default_color;
       else delete object.userData['blenderDefaultColor'];
+      if(obj.object_info) object.userData['blenderObjectInfo']=obj.object_info;
+      else delete object.userData['blenderObjectInfo'];
       if (obj.mesh !== null) {
         const mesh = object as THREE.Mesh;
         mesh.geometry = this.meshes.get(obj.mesh)!.geometry;
@@ -2397,6 +2411,7 @@ export class BlenderRuntimeView {
   }
 
   private clear() {
+    this.objectInfoMaterials.clear();
     this.materialRanges.clear();
     this.motionGeometry.clear();
     this.transparentInstances.clear();

package/browser/three/blender-single-scattering-sky.ts

@@ -0,0 +1,128 @@
+/* SPDX-FileCopyrightText: 2011-2020 Blender Authors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Single-scattering precomputation from intern/sky/source/sky_single_scattering.cpp,
+ * Blender revision 071e080 (the public source retained on this machine).
+ * The atmosphere, quadrature, spectrum and nonlinear LUT layout are Blender's.
+ * Float operations retain the native model's precision at Earth-scale positions.
+ */
+import type {SkyParameters} from './blender-sky';
+
+const f = Math.fround;
+const RAYLEIGH_SCALE = 8000, MIE_SCALE = 1200, MIE_COEFF = f(2e-5);
+const MIE_G = f(0.76), SQR_G = f(MIE_G * MIE_G);
+const EARTH_RADIUS = 6360000, ATMOSPHERE_RADIUS = 6420000;
+const PI = f(Math.PI), HALF_PI = f(Math.PI / 2), TWO_PI = f(Math.PI * 2);
+const IRRADIANCE = [1.45756829855593, 1.5659630555973838, 1.6514844906767046, 1.7149624273720931, 1.7579798380502054, 1.7825640788592454, 1.7909510847583856, 1.7854155013341066, 1.7681555486430685, 1.741220696472504, 1.7064712716494368, 1.6655608745273989, 1.6199343724245185, 1.5708359736889208, 1.5193233505930548, 1.466284949652144, 1.4124585274017245, 1.358449619703841, 1.3047491384473928, 1.2517496327261082, 1.1997599875542062].map(f);
+const RAYLEIGH_COEFF = [5.424820087636473e-05, 4.418549866505454e-05, 3.635151910165377e-05, 3.017929012024763e-05, 2.526320226989157e-05, 2.130859310621843e-05, 1.809838025320633e-05, 1.547057129129042e-05, 1.33028497733685e-05, 1.150184784075764e-05, 9.99557429990163e-06, 8.72799973630707e-06, 7.65513700977967e-06, 6.74217203751443e-06, 5.96134125832052e-06, 5.2903459806581e-06, 4.71115687557433e-06, 4.20910481110487e-06, 3.77218381260133e-06, 3.3905125547728e-06, 3.05591531679811e-06].map(f);
+const OZONE_COEFF = [3.25126849861e-09, 5.85395365047e-09, 1.977191155085e-08, 7.309568762914e-08, 2.0084561514287e-07, 4.0383958096161e-07, 6.3551335912363e-07, 9.670704118097e-07, 1.5479740042441e-06, 2.09038647223331e-06, 2.46128056164565e-06, 2.73551299461512e-06, 2.15125863128643e-06, 1.59051840791988e-06, 1.12356197979857e-06, 7.3527551487574e-07, 4.6450130357806e-07, 3.3096079921048e-07, 2.2512612292678e-07, 1.487912926649e-07, 1.6828623364192e-07].map(f);
+const CMF_XYZ = [[0.001368, 3.9e-05, 0.006450001], [0.01431, 0.000396, 0.06785001], [0.13438, 0.004, 0.6456], [0.34828, 0.023, 1.74706], [0.2908, 0.06, 1.6692], [0.09564, 0.13902, 0.8129501], [0.0049, 0.323, 0.272], [0.06327, 0.71, 0.07824999], [0.2904, 0.954, 0.0203], [0.5945, 0.995, 0.0039], [0.9163, 0.87, 0.001650001], [1.0622, 0.631, 0.0008], [0.8544499, 0.381, 0.00019], [0.4479, 0.175, 2e-05], [0.1649, 0.061, 0.0], [0.04677, 0.017, 0.0], [0.01135916, 0.004102, 0.0], [0.002899327, 0.001047, 0.0], [0.0006900786, 0.0002492, 0.0], [0.0001661505, 6e-05, 0.0], [4.150994e-05, 1.499e-05, 0.0]].map(row => row.map(f));
+const QUADRATURE_NODES = [0.006811185292, 0.03614807107, 0.09004346519, 0.1706680068, 0.2818362161, 0.4303406404, 0.6296271457, 0.9145252695].map(f);
+const QUADRATURE_WEIGHTS = [0.01750893642, 0.04135477391, 0.06678839063, 0.09507698807, 0.1283416365, 0.1707430204, 0.2327233347, 0.3562490486].map(f);
+
+type V = readonly [number, number, number];
+const add = (a: V, b: V): V => [f(a[0] + b[0]), f(a[1] + b[1]), f(a[2] + b[2])];
+const scale = (a: V, b: number): V => [f(a[0] * b), f(a[1] * b), f(a[2] * b)];
+const multiply = (a: V, b: V): V => [f(a[0] * b[0]), f(a[1] * b[1]), f(a[2] * b[2])];
+const dot = (a: V, b: V): number => f(f(f(a[0] * b[0]) + f(a[1] * b[1])) + f(a[2] * b[2]));
+const length = (a: V): number => f(Math.sqrt(dot(a, a)));
+const direction = (latitude: number, longitude: number): V => [
+  f(f(Math.cos(latitude)) * f(Math.cos(longitude))),
+  f(f(Math.cos(latitude)) * f(Math.sin(longitude))), f(Math.sin(latitude)),
+];
+
+function atmosphereDistance(position: V, ray: V): number {
+  const b = f(2 * dot(ray, position));
+  const c = f(dot(position, position) - f(ATMOSPHERE_RADIUS * ATMOSPHERE_RADIUS));
+  return f(f(-b + f(Math.sqrt(f(f(b * b) - f(4 * c))))) / 2);
+}
+
+function earthBlocks(position: V, ray: V): boolean {
+  if (ray[2] >= 0) return false;
+  const b = f(2 * dot(ray, position));
+  const c = f(dot(position, position) - f(EARTH_RADIUS * EARTH_RADIUS));
+  return f(f(b * b) - f(4 * c)) >= 0;
+}
+
+function density(position: V): V {
+  const height = f(length(position) - EARTH_RADIUS);
+  return [f(Math.exp(f(-height / RAYLEIGH_SCALE))), f(Math.exp(f(-height / MIE_SCALE))),
+    f(Math.max(0, f(1 - f(Math.abs(f(height - 25000)) / 15000))))];
+}
+
+/** Native quadrature integrates the density factors rather than 21 spectra. */
+function opticalDepth(position: V, ray: V): V {
+  const end = add(position, scale(ray, atmosphereDistance(position, ray)));
+  const distance = length([f(end[0] - position[0]), f(end[1] - position[1]), f(end[2] - position[2])]);
+  const segment = scale(ray, distance);
+  let depth: V = [0, 0, 0];
+  for (let i = 0; i < QUADRATURE_NODES.length; i++)
+    depth = add(depth, scale(density(add(position, scale(segment, QUADRATURE_NODES[i]!))), QUADRATURE_WEIGHTS[i]!));
+  return scale(depth, distance);
+}
+
+function spectrumToXyz(spectrum: Float32Array): V {
+  let x = 0, y = 0, z = 0;
+  for (let i = 0; i < spectrum.length; i++) {
+    x = f(x + f(CMF_XYZ[i]![0]! * spectrum[i]!));
+    y = f(y + f(CMF_XYZ[i]![1]! * spectrum[i]!));
+    z = f(z + f(CMF_XYZ[i]![2]! * spectrum[i]!));
+  }
+  return [f(x * 20), f(y * 20), f(z * 20)];
+}
+
+function inscattering(ray: V, sun: V, origin: V, factors: V): V {
+  const end = add(origin, scale(ray, atmosphereDistance(origin, ray)));
+  const rayLength = length([f(end[0] - origin[0]), f(end[1] - origin[1]), f(end[2] - origin[2])]);
+  const step = f(rayLength / 32), segment = scale(ray, step);
+  const mu = dot(ray, sun), mu2 = f(mu * mu);
+  const rayleigh = f(f(f(.1875 * f(1 / Math.PI)) * f(1 + mu2)));
+  const denominator = f(f(f(8 * PI) * f(2 + SQR_G)) * f(Math.pow(f(f(1 + SQR_G) - f(f(2 * MIE_G) * mu)), 1.5)));
+  const mie = f(f(f(f(3 * f(1 - SQR_G)) * f(1 + mu2))) / denominator);
+  const result = new Float32Array(21);
+  let depth: V = [0, 0, 0], position = add(origin, scale(segment, .5));
+  for (let i = 0; i < 32; i++) {
+    const d = multiply(factors, density(position));
+    depth = add(depth, scale(d, step));
+    if (!earthBlocks(position, sun)) {
+      const total = add(depth, multiply(factors, opticalDepth(position, sun)));
+      for (let wl = 0; wl < 21; wl++) {
+        const extinction = f(f(f(total[0] * RAYLEIGH_COEFF[wl]!) + f(total[1] * f(1.11 * MIE_COEFF))) + f(total[2] * OZONE_COEFF[wl]!));
+        const attenuation = f(Math.exp(-extinction));
+        const scattering = f(f(rayleigh * f(d[0] * RAYLEIGH_COEFF[wl]!)) + f(mie * f(d[1] * MIE_COEFF)));
+        result[wl] = f(result[wl]! + f(f(f(attenuation * scattering) * IRRADIANCE[wl]!) * step));
+      }
+    }
+    position = add(position, segment);
+  }
+  return spectrumToXyz(result);
+}
+
+/** SKY_single_scattering_precompute_texture: upper sky mirrored in longitude,
+ * lower sky faded from the horizon, with more latitude samples near it. */
+export function precomputeSingleScatteringSky(p: SkyParameters, width = 512, height = 256): Float32Array {
+  const pixels = new Float32Array(width * height * 3);
+  const halfWidth = width / 2, halfHeight = height / 2;
+  const origin: V = [0, 0, f(EARTH_RADIUS + Math.min(59999, Math.max(1, f(p.altitude))))];
+  const sun = direction(f(p.sunElevation), 0);
+  const factors: V = [f(p.airDensity), f(p.aerosolDensity), f(p.ozoneDensity)];
+  const longitudeStep = f(TWO_PI / width);
+  for (let y = halfHeight; y < height; y++) {
+    const latitudeStep = f(f(y / halfHeight) - 1);
+    const latitude = f(HALF_PI * f(latitudeStep * latitudeStep));
+    for (let x = 0; x < halfWidth; x++) {
+      const longitude = f(f(longitudeStep * x) - PI);
+      const xyz = inscattering(direction(latitude, longitude), sun, origin, factors);
+      pixels.set(xyz, (y * width + x) * 3);
+      pixels.set(xyz, (y * width + width - x - 1) * 3);
+    }
+  }
+  for (let y = 0; y < halfHeight; y++) {
+    const latitudeStep = f(f(y / halfHeight) - 1);
+    const z = f(Math.sin(f(HALF_PI * f(latitudeStep * latitudeStep))));
+    let fade = 0;
+    if (z < .4) { fade = f(1 - f(z * 2.5)); fade = f(f(fade * fade) * fade); }
+    for (let x = 0; x < width * 3; x++) pixels[y * width * 3 + x] = f(pixels[halfHeight * width * 3 + x]! * fade);
+  }
+  return pixels;
+}