@woosh/meep-engine 2.43.52 → 2.44.0

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

@@ -1,15 +1,10 @@
 export const FP_SHADER_CHUNK_ACCUMULATION = `
 #ifndef FP_SHADER_CHUNK_ACCUMULATION
     #define 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;
+    for(uint i=0u; i < fp_cluster_metadata.y; i++){
+        uint lookup_index = fp_cluster_metadata.x + i;
 
         uint light_descriptor = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
 
@@ -39,60 +34,6 @@ export const FP_SHADER_CHUNK_ACCUMULATION = `
             fp_getPointDirectLightIrradiance( pointlight, directLight, vViewPosition );
             RE_Direct( directLight, geometry, material, reflectedLight );
         
-        }else if(type == 3u){
-            // decal
-            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);
-            vec4 light_data_2 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+2u), 0);
-            vec4 light_data_3 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+3u), 0);
-            
-            mat4 decal_transform_matrix = mat4(
-                  light_data_0,
-                  light_data_1,
-                  light_data_2,
-                  light_data_3
-            );
-            
-            vec4 local_position = decal_transform_matrix*vec4(v_world_position, 1.0);
-            
-            if(max3(abs(local_position.xyz)) < 0.5){
-                
-                // we're inside decal volume
-                vec4 light_data_4 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+4u), 0);
-                
-                // compute normal of the decal, we get this by extracting rotation matrix and transforming (0,1,0) vector using that 
-                vec3 decal_normal = normalize(vec3(
-                    decal_transform_matrix[0][2], decal_transform_matrix[1][2], decal_transform_matrix[2][2]
-                )); 
-                
-                // Get geometry normal in world-space
-                vec3 g_normal = normalize( ( transpose(viewMatrix) * vec4( geometry.normal, 0.0 ) ).xyz );
-                                
-                float decal_surface_dot = dot(decal_normal, g_normal);
-                                
-                // we fade out decals when the projection angle to the surface gets too steep
-                // 0.7 is cos(45deg) and 0.5 is cos(60deg), dot returns cos of angle between two normals
-                float decal_surface_angle_fade = smoothstep(-0.5,-0.7,decal_surface_dot);
-                
-                if(decal_surface_angle_fade <= 0.0){
-                    continue;
-                }
-                
-                vec2 decal_local_uv = (local_position.xy + 0.5);
-                vec2 decal_uv = decal_local_uv*light_data_4.zw + light_data_4.xy;
-                                
-                vec4 decal_color = texture2D(fp_t_decal_atlas,decal_uv, -0.2);
-                
-                // compute decal alpha
-                float decal_alpha = decal_color.a * decal_surface_angle_fade;
-                
-                if(decal_alpha < 0.003){
-                    continue;
-                }
-                
-                material.diffuseColor = material.diffuseColor*(1.0-decal_alpha) + decal_color.xyz*decal_alpha;
-            } 
-                      
         }
     }
 #endif

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

@@ -0,0 +1,70 @@
+export const FP_SHADER_CHUNK_APPLY_DECALS = `
+#ifndef FP_SHADER_CHUNK_APPLY_DECALS
+    #define FP_SHADER_CHUNK_APPLY_DECALS
+    
+    // process decals
+    for(uint i=0u; i < fp_cluster_metadata.w; i++){
+        uint lookup_index = fp_cluster_metadata.z + i;
+
+        uint light_descriptor = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
+
+        uint type = (light_descriptor) & 0x3u;
+        uint light_address = light_descriptor >> 2;
+        
+        // decal
+        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);
+        vec4 light_data_2 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+2u), 0);
+        vec4 light_data_3 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+3u), 0);
+        
+        mat4 decal_transform_matrix = mat4(
+              light_data_0,
+              light_data_1,
+              light_data_2,
+              light_data_3
+        );
+        
+        vec4 local_position = decal_transform_matrix*vec4(v_world_position, 1.0);
+        
+        if(max3(abs(local_position.xyz)) < 0.5){
+            
+            // we're inside decal volume
+            vec4 light_data_4 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+4u), 0);
+            
+            // compute normal of the decal, we get this by extracting rotation matrix and transforming (0,1,0) vector using that 
+            vec3 decal_normal = normalize(vec3(
+                decal_transform_matrix[0][2], decal_transform_matrix[1][2], decal_transform_matrix[2][2]
+            )); 
+            
+            // Get geometry normal in world-space
+            vec3 g_normal = normalize( ( transpose(viewMatrix) * vec4( normal, 0.0 ) ).xyz );
+                            
+            float decal_surface_dot = dot(decal_normal, g_normal);
+                            
+            // we fade out decals when the projection angle to the surface gets too steep
+            // 0.7 is cos(45deg) and 0.5 is cos(60deg), dot returns cos of angle between two normals
+            float decal_surface_angle_fade = smoothstep(-0.5,-0.7,decal_surface_dot);
+            
+            if(decal_surface_angle_fade <= 0.0){
+                continue;
+            }
+            
+            vec2 decal_local_uv = (local_position.xy + 0.5);
+            vec2 decal_uv = decal_local_uv*light_data_4.zw + light_data_4.xy;
+                            
+            vec4 decal_color = texture2D(fp_t_decal_atlas,decal_uv, -0.2);
+            
+            // compute decal alpha
+            float decal_alpha = decal_color.a * decal_surface_angle_fade;
+            
+            if(decal_alpha < 0.003){
+                continue;
+            }
+            
+            material.diffuseColor = material.diffuseColor*(1.0-decal_alpha) + decal_color.xyz*decal_alpha;
+        } 
+                      
+    }
+    
+#endif
+`;

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

@@ -0,0 +1,11 @@
+export const FP_SHADER_CHUNK_LOAD_METADATA = `
+#ifndef FP_SHADER_CHUNK_LOAD_METADATA
+    #define FP_SHADER_CHUNK_LOAD_METADATA
+
+    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) );
+
+    uvec4 fp_cluster_metadata = texelFetch( fp_t_light_tiles, v3_cluster_position, 0 ).rgba;
+    
+#endif
+`;

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

@@ -4,13 +4,16 @@ 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";
+import { insert_before } from "../../../../../core/primitives/strings/insert_before.js";
+import { FP_SHADER_CHUNK_APPLY_DECALS } from "./FP_SHADER_CHUNK_APPLY_DECALS.js";
+import { FP_SHADER_CHUNK_LOAD_METADATA } from "./FP_SHADER_CHUNK_LOAD_METADATA.js";
 
 const three_chunk_accummulation_mark = '#include <lights_fragment_begin>';
 
 const accumulation_pars = `
         vec3 clip_v = vec3( vec2(gl_FragCoord.x, gl_FragCoord.y) / fp_resolution, convert_depth_to_linear(gl_FragCoord.z));
         clip_v.x = 1.0 - clip_v.x;
-       ${FP_SHADER_CHUNK_ACCUMULATION}
+       ${FP_SHADER_CHUNK_LOAD_METADATA}
     `;
 
 const preamble = `
@@ -38,15 +41,19 @@ export function fp_build_fragment_shader(base) {
             `;
     }
 
-    result = result + base
+    result = result + base;
+
+    result = insert_after(result, 'void main() {', accumulation_pars);
 
     result = insert_after(result, '#include <lights_pars_begin>', FP_SHADER_CHUNK_DECODE_PARS);
 
+    result = insert_before(result, '#include <lights_fragment_begin>', FP_SHADER_CHUNK_APPLY_DECALS);
+
     result = insert_after_or_replace(
         result,
         three_chunk_accummulation_mark,
         FP_INJECTION_POINT_ACCUMULATION,
-        accumulation_pars
+        FP_SHADER_CHUNK_ACCUMULATION
     );
 
     return result;

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

@@ -4,11 +4,12 @@ import { FP_INJECTION_POINT_ACCUMULATION } from "./FP_INJECTION_POINT_ACCUMULATI
 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";
+import { FP_SHADER_CHUNK_LOAD_METADATA } from "./FP_SHADER_CHUNK_LOAD_METADATA.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}
+       ${FP_SHADER_CHUNK_LOAD_METADATA}
     `;
 
 const three_chunk_accummulation_mark = '#include <lights_fragment_end>';
@@ -22,13 +23,15 @@ export function fp_build_vertex_lighting_shared(base) {
 
     let result = FP_SHADER_CHUNK_PREAMBLE + base;
 
+    result = insert_after(result, 'void main() {', accumulation_pars);
+
     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
+        FP_SHADER_CHUNK_ACCUMULATION
     );
 
     return result;

package/engine/graphics/render/forward_plus/prototype/prototypeLightManager.js

@@ -1558,12 +1558,11 @@ function draw_camera_view_planes() {
     });
 }
 
-// prepare_scene_2();
+prepare_scene_2();
 // prepare_scene_decal_0();
 // prepare_scene_decal_1();
-prepare_scene_decal_2();
+// prepare_scene_decal_2();
 // prepare_scene_9();
-// prepare_scene_2();
 // prepare_scene_0();
 animate();
 

package/engine/intelligence/behavior/SelectorBehavior.js

@@ -1,6 +1,9 @@
 import { CompositeBehavior } from "./composite/CompositeBehavior.js";
 import { BehaviorStatus } from "./BehaviorStatus.js";
 
+/**
+ * Will try every child behaviour in order until one succeeds or if all fail - the selector behavior will fail too
+ */
 export class SelectorBehavior extends CompositeBehavior {
     constructor() {
         super();
@@ -35,23 +38,50 @@ export class SelectorBehavior extends CompositeBehavior {
                 return s;
             }
 
+            this.__currentBehaviour.finalize();
+
             //Continue search for a fallback until the last child
             const children = this.__children;
-            if (this.__currentBehaviourIndex + 1 >= children.length) {
+
+            this.__currentBehaviourIndex++;
+
+            if (this.__currentBehaviourIndex >= children.length) {
+                this.__currentBehaviour = null;
+
                 return BehaviorStatus.Failed;
             }
 
-            this.__currentBehaviourIndex++;
             this.__currentBehaviour = children[this.__currentBehaviourIndex];
+
+            this.__currentBehaviour.initialize(this.context);
+        }
+    }
+
+    finalize() {
+        if (this.__currentBehaviour !== null) {
+            this.__currentBehaviour.finalize();
+            this.__currentBehaviour = null;
         }
     }
 
     initialize(context) {
         super.initialize(context);
-     
-        this.__currentBehaviourIndex = 0;
-        this.__currentBehaviour = this.__children[0];
 
-        this.__currentBehaviour.initialize();
+        const children = this.__children;
+
+        if (children.length > 0) {
+
+            this.__currentBehaviourIndex = 0;
+            this.__currentBehaviour = children[0];
+
+            this.__currentBehaviour.initialize();
+
+        } else {
+            // no children
+
+            this.__currentBehaviourIndex = -1;
+            this.__currentBehaviour = null;
+
+        }
     }
 }

package/engine/sound/sopra/AbstractAudioClip.js

@@ -0,0 +1,29 @@
+/**
+ * Base class for all audio clips
+ */
+export class AbstractAudioClip {
+    /**
+     * Parent clip, if set - will propagate various parameters to the child at play-time
+     * @type {null}
+     */
+    parent = null;
+
+    /**
+     * Relative offset from source
+     * @type {number}
+     */
+    pitch = 0;
+
+    /**
+     * Gain offset in decibel
+     * @type {number}
+     */
+    gain = 0;
+
+    /**
+     * Output channel, if not set - will use a settings from parent
+     * @type {null}
+     */
+    channel = null;
+
+}

package/engine/sound/sopra/ContainerAudioClip.js

@@ -0,0 +1,13 @@
+import { AbstractAudioClip } from "./AbstractAudioClip.js";
+
+/**
+ * Base container class
+ */
+export class ContainerAudioClip extends AbstractAudioClip {
+
+    /**
+     *
+     * @type {AbstractAudioClip[]}
+     */
+    children = []
+}

package/engine/sound/sopra/README.md

@@ -0,0 +1 @@
+Loosely based on concepts from FMOD and Wwise

package/engine/sound/sopra/RandomContainerAudioClip.js

@@ -0,0 +1,15 @@
+import { ContainerAudioClip } from "./ContainerAudioClip.js";
+
+/**
+ * When being played back, will play a random child element
+ */
+export class RandomContainerAudioClip extends ContainerAudioClip {
+
+
+    /**
+     * Try not to repeat last X played sounds
+     * @type {number}
+     */
+    avoid_repeating_last = 1;
+
+}

package/engine/sound/sopra/SequenceContainerAudioClip.js

@@ -0,0 +1,8 @@
+import { ContainerAudioClip } from "./ContainerAudioClip.js";
+
+/**
+ * Plays all children in sequence
+ */
+export class SequenceContainerAudioClip extends ContainerAudioClip {
+
+}

package/engine/sound/sopra/SilenceAudioClip.js

@@ -0,0 +1,15 @@
+import { AbstractAudioClip } from "./AbstractAudioClip.js";
+
+/**
+ * Represents dead air
+ * @example useful for introducing pauses in sequences
+ */
+export class SilenceAudioClip extends AbstractAudioClip {
+
+    /**
+     * Duration of the silence
+     * @type {number}
+     */
+    duration = 0;
+
+}

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.52",
+  "version": "2.44.0",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",