@woosh/meep-engine 2.43.6 → 2.43.8

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -32,7 +32,6 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
          */
         this.__temp_hit = new SurfacePoint3();
 
-
         /**
          *
          * @type {boolean}
@@ -112,17 +111,17 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             let a, b, c;
 
-            if(indices !== null) {
+            if (indices !== null) {
                 assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
 
                 a = indices[index3];
                 b = indices[index3 + 1];
                 c = indices[index3 + 2];
-            }else{
+            } else {
                 // implicit indices
                 a = index3;
-                b = index3+1;
-                c = index3+2;
+                b = index3 + 1;
+                c = index3 + 2;
             }
 
             const vertices = this.__buffer_vertices;
@@ -168,6 +167,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
                 if (d < this.__nearest_distance) {
                     this.__nearest_hit.copy(temp_hit);
+                    this.__nearest_hit.index = index;
+
                     this.__nearest_distance = d;
 
                     this.__hit_found = true;

package/engine/graphics/impostors/octahedral/README.md

@@ -18,6 +18,9 @@ This is inherently a deferred rendering technique, where an impostor asset is re
 * Animations are not supported, neither vertex, nor pixel-shader based ones. The whole impostor can move around and be transformed, but the contents are static and pre-baked.
 * When camera moves too close to the impostor, or an extreme projection is applied - artefacts will become visible. In case of camera getting too close - parts of the mesh that are occluded by outer shell will not become visible in the impostor, as that information is simply not captured. In cases of extreme projection - certain parts of the captured G-Buffer may undergo warping and stretching converting a handful of baked pixel to a larger number of on-screen pixels, creating pixelation and smearing. Note that impostors are not a replacement for your meshes, so use them sensibly.
 
+## Drawing
+### reconstruction of image from multiple perspectives
+- based on MO95 and TSK07
 
 ---
 references:
@@ -28,3 +31,4 @@ references:
 - [2018] https://github.com/wojtekpil/Godot-Octahedral-Impostors
 - [2011] BN11 : "Real-time Realistic Rendering and Lighting of Forests" by Eric Bruneton, Fabrice Neyret
 - [2007] TSK07: "Fast (Spherical) Light Field Rendering with Per-Pixel Depth." by Severin Todt, Christof Rezk-Salama and Andreas Kolb
+- [1995] MO95: Nelson Max and Keiichi Ohsaki. Rendering trees from precomputed z-buffer views. In Eurographics Rendering Workshop, pages 45–54, 1995

package/engine/graphics/impostors/octahedral/prototypeBaker.js

@@ -47,14 +47,15 @@ async function main(engine) {
     baker.renderer = renderer;
 
 
-    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
     // const path = 'data/models/LowPolyTownshipSet/Barrel/model.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
     // const path = 'data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf';
     // const path = 'data/models/MOBA and Tower Defense/Tree_01.gltf';
     // const path = 'data/models/samples/transform-hierarchy.glb';
-    const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    // const path = 'data/models/snaps/cube_blue.gltf';
     // const path = 'moicon/gnutti_not_optimized/model.gltf';
     // const path = 'moicon/isiflow_Oct_15_21/1/model.gltf';
     // const path = 'moicon/Kople/EVCharger1.gltf';
@@ -65,7 +66,7 @@ async function main(engine) {
     const id = baker.bake({
         objects,
         frames: 24,
-        resolution: 1024,
+        resolution: 2048,
         type: ImpostorCaptureType.Hemisphere
     });
     // console.profileEnd('bake');
@@ -97,8 +98,8 @@ async function main(engine) {
     const entity_impostor = make_impostor_entity(id, t0);
     entity_impostor.build(ecd);
 
-    const entity_impostor_wireframe = make_impostor_wireframe(id, t0);
-    entity_impostor_wireframe.build(ecd);
+    // const entity_impostor_wireframe = make_impostor_wireframe(id, t0);
+    // entity_impostor_wireframe.build(ecd);
 
     const t1 = new Transform();
     t1.copy(t0);

package/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js

@@ -25,20 +25,150 @@ const shader_vx = `
        
     out vec3 local_ray_near;
     out vec3 local_ray_far;
+    
+    flat out vec2 frame1;
+    out vec2 uv_frame1;
+    out vec2 xy_frame1;
 
     uniform mat4 modelViewMatrix;
     uniform mat4 projectionMatrix;
     uniform mat3 normalMatrix;
+    uniform mat4 modelMatrix;
     
     uniform vec3 uOffset;
     uniform float uRadius;
     uniform float uFrames;
     
+    uniform bool uIsFullSphere;
+    
+    vec2 VecToSphereOct(vec3 pivotToCamera)
+    {
+        vec3 octant = sign(pivotToCamera);
+    
+        //  |x| + |y| + |z| = 1
+        float sum = dot(pivotToCamera, octant);
+        vec3 octahedron = pivotToCamera / sum;
+    
+        if (octahedron.y < 0.0){
+            vec3 absolute = abs(octahedron);
+            octahedron.xz = octant.xz * vec2(1.0 - absolute.z, 1.0 - absolute.x);
+        }
+        return octahedron.xz;
+    }
+    
+    //for hemisphere
+    vec2 VecToHemiSphereOct(vec3 vec)
+    {        
+        vec.y = max(vec.y, 0.001);
+        vec = normalize(vec);
+        vec3 octant = sign(vec);
+    
+        //  |x| + |y| + |z| = 1
+        float sum = dot(vec, octant);
+        vec3 octahedron = vec / sum;
+    
+        return vec2(
+            octahedron.x + octahedron.z,
+            octahedron.z - octahedron.x
+        );
+    }
+    //for hemisphere
+    vec3 OctaHemiSphereEnc(vec2 coord)
+    {
+        coord = vec2(coord.x + coord.y, coord.x - coord.y) * 0.5;
+        vec3 vec = vec3(coord.x, 1.0 - dot(vec2(1.0, 1.0), abs(coord.xy)), coord.y);
+        return vec;
+    }
+    //for sphere
+    vec3 OctaSphereEnc(vec2 coord)
+    {
+        vec3 vec = vec3(coord.x, 1.0 - dot(vec2(1.0), abs(coord)), coord.y);
+        if (vec.y < 0.0)
+        {   
+            vec.x = (vec.x >=0.0 ? 1.0: -1.0)* (1.0 - abs(vec.z));
+            vec.z = (vec.z >=0.0 ? 1.0: -1.0)* (1.0 - abs(vec.x));
+        }
+        return vec;
+    }
+    vec2 VectorToGrid(vec3 vec)
+    {
+        if (uIsFullSphere)
+        {
+            return VecToSphereOct(vec);
+        }
+        else
+        {
+            return VecToHemiSphereOct(vec);
+        }
+    }
+    
+    vec3 GridToVector(vec2 coord)
+    {
+        if (uIsFullSphere)
+        {
+            return OctaSphereEnc(coord);
+        }
+        else
+        {
+            return OctaHemiSphereEnc(coord);
+        }
+    }
+    
+    vec3 FrameXYToRay(vec2 frame, vec2 frameCountMinusOne)
+    {
+        //divide frame x y by framecount minus one to get 0-1
+        vec2 f = (frame.xy/ frameCountMinusOne);
+        //bias and scale to -1 to 1
+    
+        vec3 vec = GridToVector(f);
+        vec = normalize(vec);
+        return vec;
+    }
+    
+    vec4 TriangleInterpolate(vec2 uv){
+        uv = fract(uv);
+    
+        vec2 omuv = vec2(1.0, 1.0) - uv.xy;
+    
+        vec4 res = vec4(0, 0, 0, 0);
+        //frame 0
+        res.x = min(omuv.x, omuv.y);
+        //frame 1
+        res.y = abs(dot(uv, vec2(1.0, -1.0)));
+        //frame 2
+        res.z = min(uv.x, uv.y);
+        //mask
+        res.w = clamp(ceil(uv.x-uv.y),0.0, 1.0);
+    
+        return res;
+    }
+    
+    void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
+    {
+        vec3 up = vec3(0,1,0);
+            //cross product doesnt work if we look directly from bottom
+        if (abs(plane_normal.y) > 0.999f)
+        {
+            up = vec3(0,0,1);
+        }
+        plane_x = normalize(cross(plane_normal, up));
+        plane_y = normalize(cross(plane_x, plane_normal));
+    }
+   
+    
     void main() {
         vUv = uv;
         
         vec2 framesMinusOne = uFrames - vec2(1.0);
         
+        vec3 cameraPos_WS = (projectionMatrix * vec4(vec3(0), 1.0)).xyz;
+        vec3 cameraPos_OS = (inverse(modelMatrix) * vec4(cameraPos_WS, 1.0)).xyz;
+        
+        //TODO: check if this is correct. We are using orho projected images, so
+        // camera far away
+        vec3 pivotToCameraRay = (cameraPos_OS) * 10.0;
+        vec3 pivotToCameraDir = normalize(cameraPos_OS);
+	
         mat4 m4 = modelViewMatrix;
         
         m4[0][0] = 1.0;
@@ -65,6 +195,7 @@ const shader_vx = `
         
         vec3 transformedNormal = normalize(normalMatrix * normal);
         
+
         vec4 mvPosition = m4 * vec4( object_scale*(position+uOffset/card_diameter), 1.0 );
                 
         gl_Position = projectionMatrix * mvPosition;
@@ -75,6 +206,10 @@ const shader_vx = `
         //get 2D projection of this vertex in normalized device coordinates
         vec2 pos = gl_Position.xy/gl_Position.w;
        
+        vec3 projected = position;
+        vec3 vertexToCameraRay = (pivotToCameraRay - (projected));
+        vec3 vertexToCameraDir = normalize(vertexToCameraRay);
+       
         //compute ray's start and end as inversion of this coordinates
         //in near and far clip planes
         vec4 near_4 = inverse_matrix * (vec4(pos, -1.0, 1.0));       
@@ -82,6 +217,29 @@ const shader_vx = `
         
         local_ray_near = near_4.xyz / near_4.w;
         local_ray_far = far_4.xyz/ far_4.w;
+        
+        //
+        vec3 view_direction = normalize(local_ray_near-local_ray_far);
+        
+        vec2 octahedral_uv = clamp(VectorToGrid(view_direction)*0.5 + 0.5, 0.0, 1.0);
+        vec2 grid =  octahedral_uv * vec2(uFrames - 1.0);
+        
+        vec2 gridFrac = fract(grid);
+        vec2 gridFloor = floor(grid);
+        
+        vec4 weights = TriangleInterpolate( gridFrac ); 
+        
+        vec2 frame1 = gridFloor;  
+        vec2 frame2 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
+        vec2 frame3 = gridFloor + vec2(1.0,1.0);
+        
+        vec3 plane_x1, plane_y1, plane_x2, plane_y2, plane_x3, plane_y3;
+        vec3 projectedQuadADir = FrameXYToRay(frame1, framesMinusOne);
+        calcuateXYbasis(projectedQuadADir, plane_x1, plane_y1);
+        
+        uv_frame1 = virtualPlaneUV(projectedQuadADir, plane_x1, plane_y1, pivotToCameraRay, vertexToCameraRay, scale);
+	    xy_frame1 = projectOnPlaneBasis(-vertexToCameraDir, projectedQuadADir, plane_x1, plane_y1).xy;
+        
     }
 `;
 const shader_fg = `
@@ -194,20 +352,25 @@ const shader_fg = `
         return result;
     }
     
-    vec2 recalculateUV(vec2 uv_f,  vec2 frame, vec2 xy_f, vec2 frame_size, float d_scale, sampler2D depthTexture)
+    vec4 ImposterBlendWeightsNearest(sampler2D tex, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec4 ddxy)
     {
-        //clamp for parallax sampling
-        uv_f = clamp(uv_f, vec2(0), vec2(1));
-        vec2 uv_quad = frame_size * (frame + uv_f);
-        //paralax
-        float n_depth = (texture( depthTexture, uv_quad, -16.0 )).a;
-        uv_f = xy_f * (0.5-n_depth) * d_scale + uv_f;
-        //clamp parallax offset
-        uv_f = clamp(uv_f, vec2(0), vec2(1));
-        uv_f =  frame_size * (frame + uv_f);
-        //clamped full UV
-        return clamp(uv_f, vec2(0), vec2(1));
+        vec4 samp0 = textureGrad(tex, frame0, ddxy.xy, ddxy.zw);
+        vec4 samp1 = textureGrad(tex, frame1, ddxy.xy, ddxy.zw);
+        vec4 samp2 = textureGrad(tex, frame2, ddxy.xy, ddxy.zw);
+    
+        vec4 result;
+    
+        if(weights.x > weights.y && weights.x > weights.z){
+            result = samp0;
+        }if(weights.y > weights.z){
+            result = samp1;
+        }else{
+            result = samp2;
+        }
+    
+        return result;
     }
+        
     
     void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
     {
@@ -237,10 +400,14 @@ const shader_fg = `
         vec2 source_uv = (frame + frame_uv)*frame_size;
         
         float n_depth = texture(gBuffer, source_uv).a;
-    
-        vec2 offset = clamp(length(frame_uv*2.0 - 1.0)*vec2(0.5-n_depth )*depth_scale, 0.0, 1.0);
+            
+        vec2 offset = clamp(length(frame_uv*2.0 - 1.0) * vec2(0.5-n_depth ) * depth_scale,0.0, 1.0);
         
-        return clamp(( frame + frame_uv+offset)*frame_size,0.0, 1.0);
+        vec2 uv_f = clamp(frame_uv+offset, 0.0, 1.0);
+        
+        uv_f = ( frame + uv_f)*frame_size;
+        
+        return clamp(uv_f,0.0, 1.0);
         // return source_uv;
     }
     
@@ -255,23 +422,30 @@ const shader_fg = `
                 
         vec4 weights = TriangleInterpolate( gridFrac ); 
         
+        vec2 frame_uv = vUv;
+        
         //3 nearest frames
         vec2 frame0 = gridFloor;
         vec2 frame1 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
         vec2 frame2 = gridFloor + vec2(1.0,1.0);
         
+        vec2 uv0 = recompute_uv(frame0, frame_uv, tGeometry);
+        vec2 uv1 = recompute_uv(frame1, frame_uv, tGeometry);
+        vec2 uv2 = recompute_uv(frame2, frame_uv, tGeometry);
+        
         vec4 ddxy = vec4( dFdx(vUv.xy), dFdy(vUv.xy) );
         
-        vec2 frame_uv = vUv;
         vec2 frame_size = vec2(1.0/ uFrames);
                 
         vec4 texel_color = ImposterBlendWeights(
+        // vec4 texel_color = ImposterBlendWeightsNearest(
             tBase,
-            (frame0 + frame_uv) * frame_size,
-            (frame1 + frame_uv) * frame_size,
-            (frame2 + frame_uv) * frame_size,
+            uv0,
+            uv1,
+            uv2,
             weights, ddxy
-        );        
+        );
+        
         
         // texel_color = vec4(texel_color.aaa, 1.0);
         

package/engine/graphics/micron/plugin/GLTFAssetTransformer.js

@@ -59,14 +59,14 @@ function ensureProxy(object) {
 export class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
-     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} [cache]
      */
     constructor(cache) {
         super();
 
         /**
          *
-         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>|undefined}
          * @private
          */
         this.__cache = cache;

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -47,39 +47,13 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         });
 
-        /**
-         *
-         * @type {AsyncRemoteHashMap<THREE.BufferGeometry, MicronGeometry>}
-         * @private
-         */
-        this.__persisted_geometry = new AsyncRemoteHashMap({
-            keyHashFunction: computeGeometryHash,
-            keyEqualityFunction: computeGeometryEquality,
-            keySerializationAdapter: new BufferGeometrySerializationAdapter(),
-            valueSerializationAdapter: new MicronGeometryBinarySerializationAdapter(),
-            storageKeyPrefix: STORAGE_KEY,
-
-        });
-
-        /**
-         *
-         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
-         * @private
-         */
-        this.__cache = new CachedAsyncMap(
-            new AsyncMapWrapper(new Cache({
-                keyHashFunction: computeGeometryHash,
-                keyEqualityFunction: computeGeometryEquality
-            })),
-            this.__persisted_geometry
-        );
 
         /**
          *
          * @type {GLTFAssetTransformer}
          * @private
          */
-        this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
+        this.__asset_transformer = new GLTFAssetTransformer();
 
         /**
          *
@@ -159,8 +133,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         am.registerTransformer("model/gltf", this.__asset_transformer);
         am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
-        this.__persisted_geometry.attach_storage(engine.storage);
-
         engine.entityManager.on.systemAdded.add(this.__handle_system_added, this);
         engine.entityManager.on.systemRemoved.add(this.__handle_system_removed, this);
 
@@ -172,8 +144,6 @@ export class MicronRenderPlugin extends EnginePlugin {
     async shutdown() {
         const engine = this.engine;
 
-        this.__persisted_geometry.detach_storage();
-
         const am = engine.assetManager;
 
         am.unregisterTransformer("model/gltf", this.__asset_transformer);

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -4,6 +4,8 @@ import { ShadedGeometryFlags } from "../../../ecs/mesh-v2/ShadedGeometryFlags.js
 import { MaterialVertexSpec, MaterialVertexSpecFlags } from "../../render/v1/MaterialVertexSpec.js";
 import { compute_geometry_polycount } from "../../../geometry/compute_geometry_polycount.js";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
+import { MICRON_GEOMETRY_FIELD } from "../../MICRON_GEOMETRY_FIELD.js";
+import { assert } from "../../../../../core/assert.js";
 
 /**
  *
@@ -27,7 +29,7 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
     /**
      *
-     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} [cache]
      */
     constructor(cache) {
         super();
@@ -54,7 +56,7 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
         /**
          *
-         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>|undefined}
          * @private
          */
         this.__cache = cache;
@@ -73,7 +75,18 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
      * @private
      */
     __obtain_micron_geometry(sg) {
-        const geometry_id = sg.geometry.id;
+        const buffer_geometry = sg.geometry;
+
+        const attached_micron_data = buffer_geometry[MICRON_GEOMETRY_FIELD];
+
+        if (attached_micron_data !== undefined) {
+            assert.equal(attached_micron_data.isMicronGeometry, true, `geometry[${MICRON_GEOMETRY_FIELD}].isMicronGeometry !== true`);
+
+            // data was found directly on the geometry
+            return attached_micron_data;
+        }
+
+        const geometry_id = buffer_geometry.id;
 
         const micron_geometry = this.__geometry_map.get(geometry_id);
 
@@ -84,8 +97,11 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
         } else {
 
             // no micron geometry
-            if (!this.__geometry_building_promises.has(geometry_id)) {
-                const p = this.__cache.get(sg.geometry);
+            if (
+                this.__cache !== undefined // cache is attached
+                && !this.__geometry_building_promises.has(geometry_id)
+            ) {
+                const p = this.__cache.get(buffer_geometry);
 
                 this.__geometry_building_promises.set(geometry_id, p);
 
@@ -98,7 +114,9 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
                 p.finally(() => {
                     this.__geometry_building_promises.delete(geometry_id);
                 });
+
             }
+
             return undefined;
         }
 

package/engine/graphics/micron/simplifyGeometry.js

@@ -1,6 +1,8 @@
 import { TopoMesh } from "../../../core/geom/3d/topology/struct/TopoMesh.js";
 import { simplifyTopoMesh } from "../../../core/geom/3d/topology/simplify/simplifyTopoMesh.js";
-import { topoMeshToBufferGeometry } from "../../../core/geom/3d/topology/topoMeshToBufferGeometry.js";
+import {
+    topo_mesh_to_three_buffer_geometry
+} from "../../../core/geom/3d/topology/topo_mesh_to_three_buffer_geometry.js";
 
 /**
  *
@@ -20,5 +22,5 @@ function simplifyGeometry(input, target) {
 
     simplifyTopoMesh(topo, target);
 
-    return topoMeshToBufferGeometry(topo);
+    return topo_mesh_to_three_buffer_geometry(topo);
 }

package/engine/graphics/sh3/LightProbeVolume.js

@@ -28,6 +28,7 @@ import { applyTransformToThreeObject } from "../ecs/mesh/applyTransformToThreeOb
 import { build_three_object } from "../ecs/mesh-v2/build_three_object.js";
 import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
 import { v3_length_sqr } from "../../../core/geom/v3_length_sqr.js";
+import { sh3_dering_optimize_positive } from "../../../core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js";
 
 const TEMP_CONTACT = new SurfacePoint3();
 
@@ -171,11 +172,11 @@ function fromCubeRenderTarget(data, renderer, cubeRenderTarget) {
             const color_b = data[i + 2] * weight_conv;
 
             // accumulate
-            for (let j = 0; j < 27; j += 3) {
+            for (let j = 0; j < 9; j++) {
 
-                coefficients[j] += sh_basis[j] * color_r;
-                coefficients[j + 1] += sh_basis[j] * color_g;
-                coefficients[j + 2] += sh_basis[j] * color_b;
+                coefficients[j * 3] += sh_basis[j] * color_r;
+                coefficients[j * 3 + 1] += sh_basis[j] * color_g;
+                coefficients[j * 3 + 2] += sh_basis[j] * color_b;
 
             }
 
@@ -192,6 +193,8 @@ function fromCubeRenderTarget(data, renderer, cubeRenderTarget) {
 
     }
 
+    sh3_dering_optimize_positive(coefficients, 0, coefficients, 0, 3);
+
     return coefficients;
 
 }
@@ -239,6 +242,8 @@ class CubeRenderer {
          * @private
          */
         this.__scene = new Scene();
+        // this.__scene.autoUpdate = false;
+        // this.__scene.matrixAutoUpdate = false;
     }
 
     /**
@@ -251,7 +256,18 @@ class CubeRenderer {
         ecd.traverseEntities([ShadedGeometry, Transform], (sg, t, entity) => {
             const object3D = build_three_object(sg);
 
-            object3D.material = sg.material.clone();
+            const source_material = sg.material;
+
+            //
+            // if (source_material.isMeshStandardMaterial === true) {
+            //     object3D.material = new MeshStandardMaterial({
+            //         map: source_material.map,
+            //     });
+            //
+            //     object3D.material.color.copy(source_material.color);
+            // } else {
+                object3D.material = source_material.clone();
+            // }
 
             applyTransformToThreeObject(object3D, t);
 
@@ -312,6 +328,13 @@ class CubeRenderer {
         renderer.autoClear = true;
 
         this.__cube_camera.position.fromArray(position, position_offset);
+
+        this.__cube_camera.children.forEach(c => {
+            c.updateProjectionMatrix();
+            c.updateMatrix();
+            c.updateMatrixWorld(true);
+        });
+
         this.__cube_camera.update(renderer, this.__scene);
 
 

package/engine/graphics/sh3/README.md

@@ -0,0 +1,3 @@
+Path tracing ideas:
+* [smallpt](https://www.kevinbeason.com/smallpt/) (100 line c implementation of path tracer)
+* [three path tracer](https://github.com/gkjohnson/three-gpu-pathtracer)

package/engine/graphics/sh3/SH3VisualisationMaterial.js

@@ -65,6 +65,7 @@ export class SH3VisualisationMaterial extends ShaderMaterial {
         super({
             fragmentShader: shader_fg,
             vertexShader: shader_vx,
+            lights: false,
             uniforms: {
                 intensity: {
                     value: 1,