@woosh/meep-engine 2.43.46 → 2.43.47

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

@@ -26,6 +26,7 @@ import { DrawMode } from "../../mesh-v2/DrawMode.js";
 import { OctahedralUvEncoder } from "../../../impostors/octahedral/grid/OctahedralUvEncoder.js";
 import { makeSolidArrowGeometry } from "../../../../../editor/process/symbolic/makeSolidArrowGeometry.js";
 import { vec3 } from "gl-matrix";
+import Quaternion from "../../../../../core/geom/Quaternion.js";
 
 const decal_urls = `data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/staff_13_t.png
 data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_01_t.png
@@ -266,10 +267,7 @@ function grid(ecd, offset_x, offset_y, x, y, size_x, size_y, spacing, textures)
 
 }
 
-function makeNormalTestGridDecal(ecd) {
-
-    const GRID_OFFSET = new Vector3(5, 0, 5);
-
+function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
     const uv = new OctahedralUvEncoder();
 
     const GRID_SIZE = 9;
@@ -285,7 +283,7 @@ function makeNormalTestGridDecal(ecd) {
 
             uv.uv_to_unit(direction, [i / (GRID_SIZE - 1), j / (GRID_SIZE - 1)]);
 
-            vec3.negate(direction,direction);
+            vec3.negate(direction, direction);
 
             const decal = new Decal();
 
@@ -298,14 +296,14 @@ function makeNormalTestGridDecal(ecd) {
             const transform = new Transform();
             transform.position.set(
                 SPACING * i,
+                SPACING * j,
                 0,
-                SPACING * j
             );
+            transform.scale.setScalar(1);
+            transform.rotation._lookRotation(direction[0],direction[2], direction[1] , 0, 1, 0);
 
-            transform.position.add(GRID_OFFSET);
+            transform.multiplyTransforms(root_transform, transform);
 
-            transform.scale.setScalar(1);
-            transform.rotation._lookRotation(direction[0], direction[1], direction[2], 0, 1, 0);
 
             entity
                 .add(ShadedGeometry.from(DEBUG_BOX, new LineBasicMaterial(), DrawMode.LineSegments))
@@ -422,7 +420,32 @@ async function main(engine) {
 
     const task = countTask(0, ENTITY_COUNT, makeOne);
 
-    makeNormalTestGridDecal(ecd);
+    const q_down = new Quaternion();
+    q_down.lookRotation(Vector3.down)
+
+    makeNormalTestGridDecal(ecd, Transform.fromJSON({
+        position: new Vector3(5, 0, 5),
+        rotation: q_down
+    }));
+
+
+    const q_forward = new Quaternion();
+    q_forward.lookRotation(Vector3.forward)
+
+    const t_forward_grid = Transform.fromJSON({
+        position: new Vector3(5, 4, 5),
+        rotation: q_forward
+    });
+    makeNormalTestGridDecal(ecd, t_forward_grid);
+
+    new EntityBuilder()
+        .add(SGMesh.fromURL('data/models/snaps/cube_white.gltf'))
+        .add(Transform.fromJSON({
+        position:new Vector3(14,1,4.8),
+            rotation: t_forward_grid.rotation,
+            scale: new Vector3(25,25,0.1)
+        }))
+        .build(ecd);
 
     // TaskLoadingScreen.instance.load(engine, task);
 

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

@@ -63,16 +63,54 @@ export const FP_SHADER_CHUNK_ACCUMULATION = `
                 // compute normal of the decal, we get this by extracting rotation matrix and transforming (0,1,0) vector using that 
                 
                 mat4 decal_view_transform = viewMatrix*decal_transform_matrix;
+                // mat3 decal_view_transform = mat3(transpose(inverse(viewMatrix*decal_transform_matrix)));
+                // mat3 decal_view_transform = mat3(transpose(inverse(  decal_transform_matrix )));
+                                
+                // vec3 decal_normal = normalize(vec3(
+                //     decal_view_transform[1][0], decal_view_transform[1][1], decal_view_transform[1][2]
+                // )); 
+                  
+                //   vec3 decal_normal = normalize(vec3(
+                //     decal_view_transform[0][2], decal_view_transform[1][2], decal_view_transform[2][2]
+                // ));  
+                  vec3 decal_normal = normalize(vec3(
+                    decal_transform_matrix[0][2], decal_transform_matrix[1][2], decal_transform_matrix[2][2]
+                )); 
+                //
+                
+                
+                // vec3 decal_normal = normalize( ( decal_view_transform * vec3( 0.0, 1.0, 0.0 ) ).xyz );
+                // vec3 decal_normal = normalize( ( transpose(inverse(  decal_view_transform )) * vec4( 0.0, 1.0, 0.0, 0.0 ) ).xyz );
+                
+                // Get geometry normal in world-space
+                vec3 g_normal = normalize( ( transpose(viewMatrix) * vec4( geometry.normal, 0.0 ) ).xyz );
+                
+                    // material.diffuseColor = geometry.normal*0.5 + 0.5;
+                    // material.diffuseColor = normalize( ( viewMatrix * vec4( geometry.normal, 0.0 ) ).xyz )*0.5 + 0.5;
+                    // material.diffuseColor = decal_normal*0.5 + 0.5;
+                    
+                // material.diffuseColor = mix(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), decal_normal.y*0.5 + 0.5);
+                // material.diffuseColor = mix(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), g_normal.y*0.5 + 0.5);
+                // material.diffuseColor = g_normal*0.5 + 0.5;
+                // continue;
+                
+                // if(length(local_position.xyz) < 0.3){
+                //     // circle in the center
+                //     material.diffuseColor = g_normal*0.5 + 0.5;
+                // }else{
+                //     material.diffuseColor = decal_normal*0.5 + 0.5;
+                // }
+                //
+                // continue;
                 
-                vec3 decal_normal = normalize(vec3(
-                    decal_view_transform[1][0], decal_view_transform[1][1], decal_view_transform[1][2]
-                ));
+                float decal_surface_dot = dot(decal_normal, g_normal);
                 
-                float decal_surface_dot = dot(decal_normal, geometry.normal);
+                // material.diffuseColor = mix(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), decal_surface_dot);
+                // continue;
                 
                 // 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.7,0.5,decal_surface_dot);
+                float decal_surface_angle_fade = smoothstep(-0.5,-0.7,decal_surface_dot);
                 
                 if(decal_surface_angle_fade <= 0.0){
                     continue;

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