@woosh/meep-engine 2.33.24 → 2.33.28

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -1,4 +1,3 @@
-import { max2 } from "../../../../../../core/math/max2.js";
 import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
 import {
     LinearFilter,
@@ -14,6 +13,7 @@ import { BlendingType } from "../../../../texture/sampler/BlendingType.js";
 import { DepthLimitedBlur } from "../DepthLimitedBlur.js";
 import { renderScreenSpace } from "../../../utils/renderScreenSpace.js";
 import { StandardFrameBuffers } from "../../../../StandardFrameBuffers.js";
+import { CompositingStages } from "../../../../composit/CompositingStages.js";
 
 export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
     constructor() {
@@ -160,9 +160,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         uniforms.bias.value = 0.5;
         uniforms.intensity.value = 0.18;
 
-        const depth_range = far - near;
-
-        uniforms.scale.value = 5 * max2(1, depth_range / 30);
+        // scale is divided by camera far in the shader, we unbias it here
+        // TODO remove this term from the shader
+        uniforms.scale.value = far * 0.25;
 
         uniforms.kernelRadius.value = 30;
         uniforms.minResolution.value = 0;
@@ -184,12 +184,14 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
     /**
      *
-     * @param {WebGLRenderer} renderer
-     * @param {Camera} camera
-     * @param {Scene} scene
      * @private
      */
-    __render(renderer, camera, scene) {
+    __render() {
+        const engine = this.engine;
+        const graphics = engine.graphics;
+
+        const renderer = graphics.renderer;
+
         this.__prepare_draw();
 
         const __old_state_rt = renderer.getRenderTarget();
@@ -295,6 +297,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__composit_layer = graphics.layerComposer.createLayer({}, BlendingType.Multiply);
         this.__composit_layer.name = 'Ambient Occlusion';
 
+        // apply ambient occlusion on opaque pass, otherwise it would occlude transparent geometry
+        this.__composit_layer.stage = CompositingStages.POST_OPAQUE;
+
         const material = this.__material;
         const uniforms = material.uniforms;
 
@@ -309,7 +314,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             this.setNormalBufferUsage(true);
         }
 
-        graphics.on.preComposite.add(this.__render, this);
+        this.__composit_layer.on.preRender.add(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
         this.__update_render_target_size();
@@ -330,7 +335,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         // remove the layer
         graphics.layerComposer.remove(this.__composit_layer);
 
-        graphics.on.preComposite.remove(this.__render, this);
+        this.__composit_layer.on.preRender.remove(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
         return super.shutdown();

package/engine/graphics/render/forward_plus/materials/FP_INJECTION_POINT_ACCUMULATION.js

@@ -0,0 +1 @@
+export const FP_INJECTION_POINT_ACCUMULATION = '//@injection_point FORWARD_PLUS:accumulation';

package/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_ACCUMULATION.js

@@ -0,0 +1,32 @@
+export const FP_SHADER_CHUNK_ACCUMULATION = `
+        ivec3 v3_cluster_resolution = textureSize(fp_t_light_tiles, 0);
+        ivec3 v3_cluster_position = ivec3(  clip_v.x * float(v3_cluster_resolution.x), clip_v.y*float(v3_cluster_resolution.y),  (clip_v.z)*float(v3_cluster_resolution.z) );
+   
+        uvec3 cluster_metadata = texelFetch(fp_t_light_tiles, v3_cluster_position , 0).rgb;
+        
+        // read light data
+        for(uint i=0u; i < cluster_metadata.y; i++){
+            uint lookup_index = cluster_metadata.x + i;
+
+            uint light_address = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
+
+            vec4 light_data_0 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address), 0);
+            vec4 light_data_1 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+1u), 0);
+
+            vec3 light_position = light_data_0.xyz;
+            float light_radius = light_data_0.w;
+
+            vec3 light_color = light_data_1.xyz;
+            float light_intensity = light_data_1.w;
+
+            PointLight pointlight;
+
+            pointlight.position = light_position;
+            pointlight.distance = light_radius;
+            pointlight.color = light_color*light_intensity;
+            pointlight.decay = 1.0;
+
+            fp_getPointDirectLightIrradiance( pointlight, directLight, vViewPosition );
+            RE_Direct( directLight, geometry, material, reflectedLight );
+        }
+       `;

package/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_DECODE_PARS.js

@@ -0,0 +1,51 @@
+export const FP_SHADER_CHUNK_DECODE_PARS = `
+        // don't rely on three.js light number define to ensure that point light calculations are available
+        #if NUM_POINT_LIGHTS < 1
+            struct PointLight {
+                vec3 position;
+                vec3 color;
+                float distance;
+                float decay;
+            };
+        #endif
+        
+        // directLight is an out parameter as having it as a return value caused compiler errors on some devices
+        void fp_getPointDirectLightIrradiance( const in PointLight pointLight, out IncidentLight directLight, vec3 viewPosition ) {
+        
+            // TODO consider moving light position transformation to view-space over to CPU
+            vec3 lVector = (viewMatrix*vec4(pointLight.position,1.0)).xyz + viewPosition;
+            
+            directLight.direction = normalize( lVector );
+            
+            float lightDistance = length( lVector );
+            
+            directLight.color = pointLight.color;
+            directLight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
+            directLight.visible = ( directLight.color != vec3( 0.0 ) );
+        }
+        
+        float convert_depth_to_linear(in float d){
+            float d_n = 2.0*d - 1.0;
+        
+            float f = fp_f_camera_far;
+            float n = fp_f_camera_near;
+        
+            float fn = f*n;
+            
+            float z_diff = f - n;
+            
+            float denominator = (f + n - d_n * z_diff );
+        
+            float z_view = (2.0*fn) / denominator;
+        
+            return (z_view - n) / z_diff;
+        }
+        
+        ivec2 address_to_data_texture_coordinates(uint address){
+            // Lookup texture has 128 width
+            uint lookup_index_x = address % 128u;
+            uint lookup_index_y = address >> 7;
+            
+            return ivec2(int(lookup_index_x),int(lookup_index_y));
+        }
+    `;

package/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_PREAMBLE.js

@@ -0,0 +1,25 @@
+export const FP_SHADER_CHUNK_PREAMBLE = `precision mediump usampler3D;
+    precision mediump usampler2D;
+    
+    uniform usampler3D fp_t_light_tiles;
+    
+    uniform usampler2D fp_t_light_lookup;
+    uniform sampler2D fp_t_light_data;
+    
+    uniform vec3 fp_v3_light_cluster_resolution;
+    
+    uniform float fp_f_camera_near;
+    uniform float fp_f_camera_far;
+    
+    #define gl_FragDepthEXT gl_FragDepth
+    #define texture2D texture
+    #define textureCube texture
+    #define texture2DProj textureProj
+    #define texture2DLodEXT textureLod
+    #define texture2DProjLodEXT textureProjLod
+    #define textureCubeLodEXT textureLod
+    #define texture2DGradEXT textureGrad
+    #define texture2DProjGradEXT textureProjGrad
+    #define textureCubeGradEXT textureGrad
+    
+    uniform vec2 fp_resolution;`;

package/engine/graphics/render/forward_plus/materials/FPlusDebugMaterial.js

@@ -36,7 +36,7 @@ const f_shader = `
     
     uniform sampler2D t_heatmap_lookup;
     
-    uniform vec2 resolution;
+    uniform vec2 fp_resolution;
     
     uniform mat4 projectionMatrix;
     
@@ -79,7 +79,7 @@ const f_shader = `
     
     void main(){
     
-            vec3 clip_v = vec3(gl_FragCoord.xy / resolution, convert_depth_to_linear( gl_FragCoord.z));
+            vec3 clip_v = vec3(gl_FragCoord.xy / fp_resolution, convert_depth_to_linear( gl_FragCoord.z));
        
             ivec3 v3_cluster_resolution = textureSize(fp_t_light_tiles, 0);
             ivec3 v3_cluster_position = ivec3( ( 1.0 - clip_v.x) * float(v3_cluster_resolution.x), clip_v.y*float(v3_cluster_resolution.y), (clip_v.z)*float(v3_cluster_resolution.z) );
@@ -119,7 +119,7 @@ export class FPlusDebugMaterial extends ShaderMaterial {
                     type: 'f',
                     value: 0
                 },
-                resolution: {
+                fp_resolution: {
                     type: 'v2',
                     value: new Vector2()
                 },

package/engine/graphics/render/forward_plus/materials/ForwardPlusThreeMaterial.js

@@ -29,7 +29,7 @@ export class ForwardPlusThreeMaterial extends ShaderMaterial {
                     type: 'f',
                     value: 0
                 },
-                resolution: {
+                fp_resolution: {
                     type: 'v2',
                     value: new Vector2()
                 }

package/engine/graphics/render/forward_plus/materials/fp_build_fragment_shader.js

@@ -1,4 +1,25 @@
-import { insert_after } from "./insert_after.js";
+import { insert_after } from "../../../../../core/primitives/strings/insert_after.js";
+import { insert_after_or_replace } from "../../../../../core/primitives/strings/insert_after_or_replace.js";
+import { FP_SHADER_CHUNK_ACCUMULATION } from "./FP_SHADER_CHUNK_ACCUMULATION.js";
+import { FP_SHADER_CHUNK_DECODE_PARS } from "./FP_SHADER_CHUNK_DECODE_PARS.js";
+import { FP_INJECTION_POINT_ACCUMULATION } from "./FP_INJECTION_POINT_ACCUMULATION.js";
+import { FP_SHADER_CHUNK_PREAMBLE } from "./FP_SHADER_CHUNK_PREAMBLE.js";
+
+const three_chunk_accummulation_mark = '#include <lights_fragment_end>';
+
+const accumulation_pars = `
+        vec3 clip_v = vec3( vec2(gl_FragCoord.x, gl_FragCoord.y) / fp_resolution, convert_depth_to_linear(gl_FragCoord.z));
+       ${FP_SHADER_CHUNK_ACCUMULATION}
+    `;
+
+const preamble = `
+    ${FP_SHADER_CHUNK_PREAMBLE}
+    
+    varying vec3 v_world_position;
+    
+    out highp vec4 pc_fragColor;
+    #define gl_FragColor pc_fragColor
+    `;
 
 /**
  *
@@ -6,126 +27,16 @@ import { insert_after } from "./insert_after.js";
  * @returns {string}
  */
 export function fp_build_fragment_shader(base) {
-    const v0 = `
-    precision mediump usampler3D;
-    precision mediump usampler2D;
-    
-    uniform usampler3D fp_t_light_tiles;
-    
-    uniform usampler2D fp_t_light_lookup;
-    uniform sampler2D fp_t_light_data;
-    
-    uniform vec3 fp_v3_light_cluster_resolution;
-    
-    uniform float fp_f_camera_near;
-    uniform float fp_f_camera_far;
-    
-    uniform vec2 resolution;
-    
-    varying vec3 v_world_position;
-    
-    out highp vec4 pc_fragColor;
-    #define gl_FragColor pc_fragColor
-
-    #define gl_FragDepthEXT gl_FragDepth
-    #define texture2D texture
-    #define textureCube texture
-    #define texture2DProj textureProj
-    #define texture2DLodEXT textureLod
-    #define texture2DProjLodEXT textureProjLod
-    #define textureCubeLodEXT textureLod
-    #define texture2DGradEXT textureGrad
-    #define texture2DProjGradEXT textureProjGrad
-    #define textureCubeGradEXT textureGrad
-    ` + base;
-
-    const v1 = insert_after(v0, '#include <lights_pars_begin>', `
-        // don't rely on three.js light number define to ensure that point light calculations are available
-        #if NUM_POINT_LIGHTS < 1
-            struct PointLight {
-                vec3 position;
-                vec3 color;
-                float distance;
-                float decay;
-            };
-        #endif
-        
-        // directLight is an out parameter as having it as a return value caused compiler errors on some devices
-        void fp_getPointDirectLightIrradiance( const in PointLight pointLight, out IncidentLight directLight ) {
-        
-            // TODO consider moving light position transformation to view-space over to CPU
-            vec3 lVector = (viewMatrix*vec4(pointLight.position,1.0)).xyz + vViewPosition;
-            
-            directLight.direction = normalize( lVector );
-            
-            float lightDistance = length( lVector );
-            
-            directLight.color = pointLight.color;
-            directLight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
-            directLight.visible = ( directLight.color != vec3( 0.0 ) );
-        }
-        
-        float convert_depth_to_linear(in float d){
-            float d_n = 2.0*d - 1.0;
-        
-            float f = fp_f_camera_far;
-            float n = fp_f_camera_near;
-        
-            float fn = f*n;
-            
-            float z_diff = f - n;
-            
-            float denominator = (f + n - d_n * z_diff );
-        
-            float z_view = (2.0*fn) / denominator;
-        
-            return (z_view - n) / z_diff;
-        }
-        
-        ivec2 address_to_data_texture_coordinates(uint address){
-            // Lookup texture has 128 width
-            uint lookup_index_x = address % 128u;
-            uint lookup_index_y = address >> 7;
-            
-            return ivec2(int(lookup_index_x),int(lookup_index_y));
-        }
-    `);
-
-    const v2 = insert_after(v1, '#include <lights_fragment_end>', `
-        vec3 clip_v = vec3( vec2(gl_FragCoord.x, gl_FragCoord.y) / resolution, convert_depth_to_linear(gl_FragCoord.z));
-   
-        ivec3 v3_cluster_resolution = textureSize(fp_t_light_tiles, 0);
-        ivec3 v3_cluster_position = ivec3(  clip_v.x * float(v3_cluster_resolution.x), clip_v.y*float(v3_cluster_resolution.y),  (clip_v.z)*float(v3_cluster_resolution.z) );
-   
-        uvec3 cluster_metadata = texelFetch(fp_t_light_tiles, v3_cluster_position , 0).rgb;
-        
-        // read light data
-        for(uint i=0u; i < cluster_metadata.y; i++){
-            uint lookup_index = cluster_metadata.x + i;
-
-            uint light_address = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
-
-            vec4 light_data_0 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address), 0);
-            vec4 light_data_1 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+1u), 0);
-
-            vec3 light_position = light_data_0.xyz;
-            float light_radius = light_data_0.w;
-
-            vec3 light_color = light_data_1.xyz;
-            float light_intensity = light_data_1.w;
-
-            PointLight pointlight;
+    let result = preamble + base;
 
-            pointlight.position = light_position;
-            pointlight.distance = light_radius;
-            pointlight.color = light_color*light_intensity;
-            pointlight.decay = 1.0;
+    result = insert_after(result, '#include <lights_pars_begin>', FP_SHADER_CHUNK_DECODE_PARS);
 
-            fp_getPointDirectLightIrradiance( pointlight, directLight );
-            RE_Direct( directLight, geometry, material, reflectedLight );
-        }
-       
-    `);
+    result = insert_after_or_replace(
+        result,
+        three_chunk_accummulation_mark,
+        FP_INJECTION_POINT_ACCUMULATION,
+        accumulation_pars
+    );
 
-    return v2;
+    return result;
 }

package/engine/graphics/render/forward_plus/materials/fp_build_vertex_lighting_shared.js

@@ -0,0 +1,35 @@
+import { insert_after } from "../../../../../core/primitives/strings/insert_after.js";
+import { insert_after_or_replace } from "../../../../../core/primitives/strings/insert_after_or_replace.js";
+import { FP_INJECTION_POINT_ACCUMULATION } from "./FP_INJECTION_POINT_ACCUMULATION.js";
+import { FP_SHADER_CHUNK_ACCUMULATION } from "./FP_SHADER_CHUNK_ACCUMULATION.js";
+import { FP_SHADER_CHUNK_PREAMBLE } from "./FP_SHADER_CHUNK_PREAMBLE.js";
+import { FP_SHADER_CHUNK_DECODE_PARS } from "./FP_SHADER_CHUNK_DECODE_PARS.js";
+
+const accumulation_pars = `
+        vec3 fp_normalized_screen_position = ((gl_Position.xyz / gl_Position.w)+vec3(1.0))*0.5; 
+        vec3 clip_v = vec3( vec2(fp_normalized_screen_position.x, fp_normalized_screen_position.y), convert_depth_to_linear(fp_normalized_screen_position.z));
+       ${FP_SHADER_CHUNK_ACCUMULATION}
+    `;
+
+const three_chunk_accummulation_mark = '#include <lights_fragment_end>';
+
+/**
+ *
+ * @param {string} base
+ * @returns {string}
+ */
+export function fp_build_vertex_lighting_shared(base) {
+
+    let result = FP_SHADER_CHUNK_PREAMBLE + base;
+
+    result = insert_after(result, '#include <lights_pars_begin>', FP_SHADER_CHUNK_DECODE_PARS);
+
+    result = insert_after_or_replace(
+        result,
+        three_chunk_accummulation_mark,
+        FP_INJECTION_POINT_ACCUMULATION,
+        accumulation_pars
+    );
+
+    return result;
+}

package/engine/graphics/render/forward_plus/materials/fp_build_vertex_shader.js

@@ -1,4 +1,4 @@
-import { insert_after } from "./insert_after.js";
+import { insert_after } from "../../../../../core/primitives/strings/insert_after.js";
 
 /**
  *
@@ -12,13 +12,12 @@ export function fp_build_vertex_shader(base) {
     #define attribute in
     #define varying out
     #define texture2D texture
+    
+    varying vec3 v_world_position;
     ` + base;
 
-    const v0 = insert_after(a, '#include <clipping_planes_pars_vertex>', `
-    varying vec3 v_world_position;
-    `);
 
-    const v1 = insert_after(v0, '#include <worldpos_vertex>', `
+    const v1 = insert_after(a, '#include <worldpos_vertex>', `
         #if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )
             // worldPosition comes from 'worldpos_vertex' shader chunk
             v_world_position = worldPosition.xyz;

package/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js

@@ -4,6 +4,7 @@ import { GLSL3, Vector2 } from "three";
 import { isLitMaterial } from "./isLitMaterial.js";
 import { fp_build_fragment_shader } from "../materials/fp_build_fragment_shader.js";
 import { fp_build_vertex_shader } from "../materials/fp_build_vertex_shader.js";
+import { fp_build_vertex_lighting_shared } from "../materials/fp_build_vertex_lighting_shared.js";
 
 export class MaterialTransformer extends AbstractMaterialTransformer {
 
@@ -39,7 +40,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
                 type: 'f',
                 value: 0
             },
-            resolution: {
+            fp_resolution: {
                 type: 'v2',
                 value: resolution
             }
@@ -50,8 +51,14 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
 
             shader.glslVersion = GLSL3;
 
-            shader.vertexShader = fp_build_vertex_shader(shader.vertexShader);
-            shader.fragmentShader = fp_build_fragment_shader(shader.fragmentShader);
+            if (shader.defines.LIGHTING_VERTEX_ONLY === true) {
+                // Lambertial vertex-space lighting
+                shader.vertexShader = fp_build_vertex_lighting_shared(shader.vertexShader);
+            } else {
+
+                shader.vertexShader = fp_build_vertex_shader(shader.vertexShader);
+                shader.fragmentShader = fp_build_fragment_shader(shader.fragmentShader);
+            }
         };
     }