@volter/blender-engine 0.1.135 → 0.1.137

package/browser/session.py

@@ -1216,11 +1216,16 @@ def _depsgraph_placements(frame, depsgraph):
             continue
         if not instance.show_self:
             continue
+        # AN UNSUPPORTED PLACEMENT IS LEFT OUT, NAMED ONCE (`warn`): raising here
+        # lost the whole frame, so one odd instance kept the entire scene from
+        # opening. The native exporter skips the same duplis.
         if (instance.instance_object is not None and instance.object.data != instance.instance_object.data and
                 (instance.object.data is None or geometry.get(source.name) != instance.object.data.as_pointer())):
-            raise NotImplementedError("Depsgraph instance geometry differs from its native source: %s" % source.name)
+            warn("Depsgraph instances of %r are not drawn: their geometry differs from the exported source" % source.name)
+            continue
         if row is None or (source.type == "MESH" and row["mesh"] is None):
-            raise NotImplementedError("Depsgraph instance source has no native exported geometry: %s" % source.name)
+            warn("Depsgraph instances of %r are not drawn: the source has no exported geometry" % source.name)
+            continue
         if row["mesh"] is None:
             if source.type not in ("EMPTY", "CAMERA"):
                 warn("Depsgraph instance %r of type %s is not drawn" % (source.name, source.type))
@@ -1228,7 +1233,8 @@ def _depsgraph_placements(frame, depsgraph):
         owner = instance.parent.original if instance.parent is not None else None
         owner_row = by_name.get(owner.name) if owner is not None else None
         if owner is not None and owner_row is None:
-            raise NotImplementedError("Depsgraph instance owner is not exported: %s" % owner.name)
+            warn("Depsgraph instances owned by %r are not drawn: the owner is not exported" % owner.name)
+            continue
         persistent = list(instance.persistent_id)
         particle_index = persistent[0]
         psys = instance.particle_system
@@ -1687,7 +1693,11 @@ class Session:
             for row in frame["objects"]:
                 if not any(m in graphs for m in row["materials"] if m is not None):
                     continue
-                obj = by_name.get(row["name"])
+                # An instance source from a collection outside the scene is exported
+                # too (`instance_sources`) and shares these graphs; its Object Info
+                # and Particle Info inputs come from the file's own objects. Only
+                # those few rows miss the scene's map.
+                obj = by_name.get(row["name"]) or bpy.data.objects.get(row["name"])
                 if obj is not None:
                     row["object_info"] = {
                         "color": [float(v) for v in obj.color],

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

@@ -7,7 +7,7 @@ import {z} from 'zod';
 import {applyGraphShader, bindGraphDraw, bindPaletteGraph, borrowGraphDrawBinding, graphProgramKey, graphUvChannels, setGraphViewport} from './blender-graph-material';
 import type {CompiledGraph} from './blender-node-graph';
 import {bindNamedUvChannels} from './blender-texture-samplers';
-import {copyWorldVisibility,worldVisibilityShader,worldVisibilityUniforms} from './blender-world-visibility';
+import {WORLD_VISIBILITY,copyWorldVisibility,worldVisibilityShader,worldVisibilityUniforms} from './blender-world-visibility';
 
 const scalar = z.number().finite();
 const color = z.tuple([scalar, scalar, scalar]);
@@ -195,7 +195,7 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
       blenderWorldExtinction: {value: new THREE.Vector3()}};
     uniforms.set(material, values);
     const held = values;
-    material.customProgramCacheKey = () => `blender-principled-physical-v6${graphProgramKey(material)}`;
+    material.customProgramCacheKey = () => `blender-principled-physical-v6${WORLD_VISIBILITY ? '-atlas' : ''}${graphProgramKey(material)}`;
     material.onBeforeRender = (renderer, scene, camera, geometry, object) => {
       bindNamedUvChannels(material, geometry);
       bindGraphDraw(material, geometry, renderer, scene, camera, object, graphShadow);
@@ -213,12 +213,16 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
         .map(i => (i <= 3 ? `#ifndef USE_UV${i}\nattribute vec2 uv${i};\n#endif` : `attribute vec2 uv${i};`))
         .join('\n') + '\n' + shader.vertexShader;
       Object.assign(shader.uniforms, held);
-      worldVisibilityUniforms(material,shader.uniforms);
-      shader.vertexShader='varying vec3 blenderWorldPosition;\n'+shader.vertexShader;
-      shader.vertexShader=shader.vertexShader.replace('#include <worldpos_vertex>',
-        '#include <worldpos_vertex>\n#if defined(USE_ENVMAP) || defined(USE_SHADOWMAP) || defined(USE_TRANSMISSION)\nblenderWorldPosition=worldPosition.xyz;\n#else\nblenderWorldPosition=(modelMatrix*vec4(transformed,1.)).xyz;\n#endif');
-      shader.fragmentShader=shader.fragmentShader.replace('#include <envmap_physical_pars_fragment>',
-        '#include <envmap_physical_pars_fragment>\n'+worldVisibilityShader);
+      // The sky-light atlas exists in the shader only while it is on: its three
+      // samplers would count against every material's sixteen (WORLD_VISIBILITY).
+      if (WORLD_VISIBILITY) {
+        worldVisibilityUniforms(material,shader.uniforms);
+        shader.vertexShader='varying vec3 blenderWorldPosition;\n'+shader.vertexShader;
+        shader.vertexShader=shader.vertexShader.replace('#include <worldpos_vertex>',
+          '#include <worldpos_vertex>\n#if defined(USE_ENVMAP) || defined(USE_SHADOWMAP) || defined(USE_TRANSMISSION)\nblenderWorldPosition=worldPosition.xyz;\n#else\nblenderWorldPosition=(modelMatrix*vec4(transformed,1.)).xyz;\n#endif');
+        shader.fragmentShader=shader.fragmentShader.replace('#include <envmap_physical_pars_fragment>',
+          '#include <envmap_physical_pars_fragment>\n'+worldVisibilityShader);
+      }
       shader.fragmentShader = `uniform float blenderCoatIor;
         uniform vec3 blenderWorldExtinction;
         vec3 blenderInfiniteTransmission() { return vec3(
@@ -263,11 +267,13 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
         .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
+      const visible = WORLD_VISIBILITY ? THREE.ShaderChunk.lights_fragment_maps
         .replace('getIBLIrradiance( geometryNormal )',
           'blenderWorldIrradiance( geometryNormal, getIBLIrradiance( geometryNormal ) )')
         .replaceAll(/(getIBL(?:Radiance|AnisotropyRadiance)\([^;]+\))/g,
           '$1 * blenderWorldReflectionVisibility(geometryViewDir,geometryNormal,material.roughness)')
+        : THREE.ShaderChunk.lights_fragment_maps;
+      const environment = visible
         .replaceAll(/(getIBL(?:Irradiance|Radiance|AnisotropyRadiance)\([^;]+\))/g, '$1 * blenderInfiniteTransmission()');
       shader.fragmentShader = shader.fragmentShader.replace('#include <lights_physical_fragment>', physical)
         .replace('#include <lights_fragment_begin>', lighting)

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

@@ -27,7 +27,7 @@ import {
   worldSchema,
 } from './blender-runtime-lighting';
 import { fitModelDirectionalShadow, visibleShadowReceivers } from './blender-runtime-shadows';
-import {BlenderWorldVisibility,bindWorldVisibility} from './blender-world-visibility';
+import {BlenderWorldVisibility,WORLD_VISIBILITY,bindWorldVisibility} from './blender-world-visibility';
 import { volumeMesh, volumeSchema } from './blender-runtime-volume';
 import { applyPhysicalMaterial, applyWorldExtinction, physicalMaterialSchema } from './blender-physical-material';
 import { prepareGraphGeometry, setMaterialGraph } from './blender-graph-material';
@@ -799,7 +799,7 @@ export class BlenderRuntimeView {
    *  (`blender-workbench-material.ts`) over their viewport display. */
   private workbench = false;
   private readonly workbenchMaterials = new Map<string, THREE.Material>();
-  private readonly fallback = new THREE.MeshPhysicalMaterial({ color: 0xb9bec6, roughness: 0.72, side: THREE.DoubleSide });
+  private readonly fallback = new THREE.MeshPhysicalMaterial({ color: 0xb9bec6, roughness: 0.72, side: THREE.DoubleSide, shadowSide: THREE.BackSide });
   /** Base Color images, by image name -- ONE texture per image however many
    *  materials read it, and the cache OWNS it: a material points at one and
    *  never disposes it. Held with the size and revision the resident bytes
@@ -1429,13 +1429,15 @@ export class BlenderRuntimeView {
       // objects. Fit shadows for that draw, rather than the camera's pose
       // when Rendered shading was first entered. Captures use this path too.
       if (this.rendered) this.applyShadows(true, camera);
-      this.worldVisibility.sync(this.objects.values(),this.world.lightingTexture(),this.root,this.rendered);
-      for(const material of [...this.materials.values(),this.fallback])bindWorldVisibility(material,this.worldVisibility);
-      for(const object of this.objects.values()) {
-        const mesh=object as THREE.Mesh;if(!mesh.isMesh)continue;
-        for(const material of Array.isArray(mesh.material)?mesh.material:[mesh.material])bindWorldVisibility(material,this.worldVisibility);
+      if (WORLD_VISIBILITY) {
+        this.worldVisibility.sync(this.objects.values(),this.world.lightingTexture(),this.root,this.rendered);
+        for(const material of [...this.materials.values(),this.fallback])bindWorldVisibility(material,this.worldVisibility);
+        for(const object of this.objects.values()) {
+          const mesh=object as THREE.Mesh;if(!mesh.isMesh)continue;
+          for(const material of Array.isArray(mesh.material)?mesh.material:[mesh.material])bindWorldVisibility(material,this.worldVisibility);
+        }
+        if(options?.renderer)this.worldVisibility.prepare(options.renderer);
       }
-      if(options?.renderer)this.worldVisibility.prepare(options.renderer);
       const opaqueDone = performance.now();
       const motion = this.motionGeometry.prepare(camera, !this.rendered && (this.mode ?? this.frame?.mode) === 'OBJECT' &&
         options?.interactive === true, options?.height ?? 0);
@@ -1995,7 +1997,11 @@ export class BlenderRuntimeView {
     for (const [id, data] of Object.entries(next.materials)) {
       // Cycles intersects and shades both faces, including an arcade viewed
       // from underneath. Three's front-face default drops those surfaces.
-      const material = this.materials.get(id) ?? new THREE.MeshPhysicalMaterial({ side: THREE.DoubleSide });
+      // The shadow map keeps the back faces a front-faced material draws
+      // there: a two-sided depth pass puts every lit face into its own map, and
+      // the normal offset cannot hold that off at grazing light.
+      const material = this.materials.get(id) ??
+        new THREE.MeshPhysicalMaterial({ side: THREE.DoubleSide, shadowSide: THREE.BackSide });
       material.name = data.name;
       // A LINKED BASE COLOUR REPLACES THE SOCKET'S VALUE, it does not multiply
       // it. Python's `_reduce` fills `color` from the Base Color socket's

package/browser/three/blender-world-visibility.ts

@@ -4,6 +4,20 @@
  * directional quadrature, not indirect light transport. */
 import * as THREE from 'three';
 
+/** SKY-LIGHT OCCLUSION IS OFF IN EVERY VIEW, and compiled out of every material. Its
+ *  sixteen 512-square tiles each span the whole scene, so a 360 m level gets
+ *  about a metre per texel, and each lookup is one nearest texel answering
+ *  yes or no. Faceted surfaces then occlude their own sky at random pixels --
+ *  static on every polygon in Rendered and Play -- and narrow specular lobes,
+ *  dominated by a few of the sixteen directions, plausibly flash as the camera
+ *  moves. It measured right in a closed room a few metres across. Turn it back
+ *  on once its lookups are filtered and its resolution follows the scene's size
+ *  (docs/BLENDER-RENDERING-PARITY.md lists the rest). Off, the view neither
+ *  syncs nor draws the atlas (`blender-runtime-view.ts`), and physical
+ *  materials declare none of its samplers (`blender-physical-material.ts`):
+ *  three of them counted against a material's sixteen even while unused. */
+export const WORLD_VISIBILITY = false;
+
 const SAMPLE_COUNT=16, TILES=4, TILE_SIZE=512;
 type Segment={mesh:THREE.Mesh; geometry:THREE.BufferGeometry; position:THREE.BufferAttribute|THREE.InterleavedBufferAttribute;
  index:THREE.BufferAttribute|null; positionVersion:number; indexVersion:number; start:number; count:number;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.135",
+  "version": "0.1.137",
   "publishConfig": {
     "access": "public"
   },