@woosh/meep-engine 2.42.2 → 2.42.4

package/engine/graphics/ecs/decal/v2/prototypeDecalEditor.js

@@ -0,0 +1,138 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import { SGMesh } from "../../mesh-v2/aggregate/SGMesh.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { FPDecalSystem } from "./FPDecalSystem.js";
+import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { SGMeshSystem } from "../../mesh-v2/aggregate/SGMeshSystem.js";
+import { ShadedGeometrySystem } from "../../mesh-v2/ShadedGeometrySystem.js";
+import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import ListView from "../../../../../view/common/ListView.js";
+import List from "../../../../../core/collection/list/List.js";
+import ImageView from "../../../../../view/elements/image/ImageView.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
+import ObservedInteger from "../../../../../core/model/ObservedInteger.js";
+import ObservedString from "../../../../../core/model/ObservedString.js";
+import { MouseEvents } from "../../../../input/devices/events/MouseEvents.js";
+
+class EditorState {
+    selected_entity = new ObservedInteger(-1)
+
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {ObservedString} selected
+ * @returns {ImageView|ListView}
+ */
+function makeDecalSelector({ engine, selected }) {
+    const decal_uris = new List(
+        `data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_03_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_04_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_05_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_06_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_07_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_08_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_09_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_10_t.png
+data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_11_t.png`
+            .trim()
+            .split('\n')
+            .map(s => s.trim())
+            .filter(s => s.length > 0)
+    );
+
+    const listView = new ListView(decal_uris, {
+        elementFactory(el) {
+            const element_view = new ImageView(el);
+
+            element_view.css({
+                pointerEvents: 'auto',
+                boxSizing: 'border-box',
+            });
+
+            element_view.size.setScalar(64);
+
+            const process_selection = (e) => {
+                const is_selected = e === el;
+
+                element_view.css({
+                    border: is_selected ? `2px solid red` : 'none'
+                });
+            };
+
+            element_view.bindSignal(selected.onChanged, process_selection);
+            process_selection(selected.getValue());
+
+            element_view.el.addEventListener(MouseEvents.Click, () => {
+                selected.set(el);
+            });
+
+            return element_view;
+        }
+    });
+
+    listView.css({
+        backgroundImage:
+            `url(../data/textures/utility/checkers_white_grey_256x256.png)`,
+        backgroundSize: "24px 24px", /* Must be a square */
+        backgroundPosition: "0 0, 12px 0, 12px -12px, 0px 12px"
+    });
+
+    listView.size.set(600, 128);
+
+    return listView;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    await EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        cameraFarDistance: 300
+    });
+
+    const ecd = engine.entityManager.dataset;
+
+    new EntityBuilder()
+        .add(SGMesh.fromURL("moicon/gnutti_not_optimized/model.gltf"))
+        .add(Transform.fromJSON({
+            position: { x: 10, y: 3, z: 10 },
+            scale: 1.5
+        }));
+
+    // decal selector
+
+    const selected_decal_uri = new ObservedString('');
+
+    new EntityBuilder()
+        .add(GUIElement.fromView(makeDecalSelector({ engine, selected: selected_decal_uri })))
+        .build(ecd);
+
+}
+
+new EngineHarness()
+    .initialize({
+        configuration(config, engine) {
+            const gltfAssetLoader = new GLTFAssetLoader();
+
+            config.addLoader(GameAssetType.ModelGLTF_JSON, gltfAssetLoader);
+            config.addLoader(GameAssetType.ModelGLTF, gltfAssetLoader);
+
+            config.addSystem(new FPDecalSystem(engine));
+            config.addSystem(new BehaviorSystem(engine))
+            config.addSystem(new SGMeshSystem(engine));
+            config.addSystem(new ShadedGeometrySystem(engine));
+            config.addSystem(new TransformAttachmentSystem(engine));
+
+            config.addSystem(new GUIElementSystem(engine.gui.view, engine));
+        }
+    }).then(main);

package/engine/graphics/material/manager/ManagedMaterial.js

@@ -8,6 +8,12 @@ export class ManagedMaterial {
      * @param {Material} m
      */
     constructor(m) {
+        /**
+         *
+         * @type {Material|null}
+         * @private
+         */
+        this.__source = null;
 
         /**
          *
@@ -30,6 +36,10 @@ export class ManagedMaterial {
         this.onLastReleased = new Signal();
     }
 
+    getSource() {
+        return this.__source;
+    }
+
     /**
      *
      * @returns {Material}

package/engine/graphics/material/manager/MaterialManager.js

@@ -8,7 +8,7 @@ export class MaterialManager {
     constructor() {
 
         /**
-         *
+         * Stores links from uncompiled (source) materials to managed containers
          * @type {HashMap<Material, ManagedMaterial>}
          * @private
          */
@@ -29,6 +29,17 @@ export class MaterialManager {
             maxWeight: 100
         });
 
+        /**
+         * Stores links from compiled materials back to the container
+         * @type {HashMap<Material, ManagedMaterial>}
+         * @private
+         */
+        this.__reverse_library = new HashMap({
+            keyHashFunction: computeMaterialHash,
+            keyEqualityFunction: computeMaterialEquality,
+            capacity: 1024
+        });
+
         this.__cache.onEvicted.add(this.__dispose_material, this);
 
         /**
@@ -55,13 +66,15 @@ export class MaterialManager {
      * @private
      */
     __handle_last_reference_removed(material) {
-        const key = material.getMaterial();
+        const compiled_material = material.getMaterial();
 
         // remove from library
-        this.__library.delete(key)
+        const source = material.getSource();
+        this.__library.delete(source);
+        this.__reverse_library.delete(compiled_material);
 
         // put material into cache
-        this.__cache.put(key, material);
+        this.__cache.put(source, material);
     }
 
     /**
@@ -118,7 +131,16 @@ export class MaterialManager {
      * @returns {Reference<Material>}
      */
     obtain(source) {
-        let material = this.__library.get(source);
+        // reverse check to see if this is actually an already compiled/managed material
+        let material = this.__reverse_library.get(source);
+
+        if (material !== undefined) {
+            // already compiled material
+            return material.getRef();
+        }
+
+        // forward check
+        material = this.__library.get(source);
 
         if (material === undefined) {
             // not found in library, check cache
@@ -138,6 +160,7 @@ export class MaterialManager {
             material.onLastReleased.addOne(this.__handle_last_reference_removed, this);
 
             this.__library.set(source, material);
+            this.__reverse_library.set(material.getMaterial(), material);
         }
 
         return material.getRef();

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

@@ -1,89 +1,93 @@
 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;
+#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) );
 
-            uint light_descriptor = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
+    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 type = (light_descriptor) & 0x3u;
-            uint light_address = light_descriptor >> 2;
-            
+        uint light_descriptor = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
 
-            if(type == 0u){
-                   // point light
-                   
-                   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 );
-            
-            }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);
+        uint type = (light_descriptor) & 0x3u;
+        uint light_address = light_descriptor >> 2;
         
-                          // compute normal of the decal
-                          vec4 decal_normal = normalize( viewMatrix*decal_transform_matrix*vec4(0.0, 0.0, 1.0, 0.0) );
-                          float decal_surface_dot = dot(decal_normal.xyz, geometry.normal);
+
+        if(type == 0u){
+            // point light
+            
+            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 );
         
-                          // 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;
-                   } 
-                          
-            }
+        }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
+                vec4 decal_normal = normalize( viewMatrix*decal_transform_matrix*vec4(0.0, 0.0, 1.0, 0.0) );
+                float decal_surface_dot = dot(decal_normal.xyz, geometry.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_DECODE_PARS.js

@@ -1,51 +1,55 @@
 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));
-        }
-    `;
+#ifndef FP_SHADER_CHUNK_DECODE_PARS
+    #define 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));
+    }
+#endif
+`;

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

@@ -1,28 +1,34 @@
-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 sampler2D fp_t_decal_atlas;
-    uniform vec2 fp_t_decal_atlas_resolution;    
-    
-    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;    
+export const FP_SHADER_CHUNK_PREAMBLE = `
+    #ifndef FP_SHADER_CHUNK_PREAMBLE
+        #define 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 sampler2D fp_t_decal_atlas;
+        uniform vec2 fp_t_decal_atlas_resolution;    
+        
+        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;    
+        
+    #endif
 `;

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.42.2",
+  "version": "2.42.4",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",