@woosh/meep-engine 2.40.0 → 2.41.0

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

@@ -0,0 +1,306 @@
+import { GLSL3, NoBlending, RawShaderMaterial, Vector3 } from "three";
+import chunk_preamble from './glsl/common.glsl';
+
+const shader_vx = `
+    
+    in vec2 uv;
+    in vec3 position;
+    
+    out vec2 vUv;
+    out vec4 plane0;
+    out vec4 plane1;
+    out vec4 plane2;
+    
+    ${chunk_preamble}
+    
+    void ImposterVertex( inout ImposterData imp )
+    {
+        //incoming vertex, object space
+        vec4 vertex = imp.vertex;
+        
+        //camera in object space
+        vec3 objectSpaceCameraPos = mul( unity_WorldToObject, float4(_WorldSpaceCameraPos.xyz,1) ).xyz;
+        vec2 texcoord = imp.uv;
+        float4x4 objectToWorld = unity_ObjectToWorld;
+        float4x4 worldToObject = unity_WorldToObject;
+    
+        vec3 imposterPivotOffset = _ImposterOffset.xyz;
+        half framesMinusOne = _ImposterFrames-1;
+        
+        float3 objectScale = float3(length(float3(objectToWorld[0].x, objectToWorld[1].x, objectToWorld[2].x)),
+                                    length(float3(objectToWorld[0].y, objectToWorld[1].y, objectToWorld[2].y)),
+                                    length(float3(objectToWorld[0].z, objectToWorld[1].z, objectToWorld[2].z)));
+                 
+        //pivot to camera ray
+        float3 pivotToCameraRay = normalize(objectSpaceCameraPos.xyz-imposterPivotOffset.xyz);
+    
+        //scale uv to single frame
+        texcoord = vec2(texcoord.x,texcoord.y)*(1.0/_ImposterFrames.x);  
+        
+        //radius * 2 * unity scaling
+        vec2 size = _ImposterSize.xx * 2.0; // * objectScale.xx; //unity_BillboardSize.xy                 
+        
+        vec3 projected = SpriteProjection( pivotToCameraRay, _ImposterFrames, size, texcoord.xy );
+    
+        //this creates the proper offset for vertices to camera facing billboard
+        vec3 vertexOffset = projected + imposterPivotOffset;
+        //subtract from camera pos 
+        vertexOffset = normalize(objectSpaceCameraPos-vertexOffset);
+        //then add the original projected world
+        vertexOffset += projected;
+        //remove position of vertex
+        vertexOffset -= vertex.xyz;
+        //add pivot
+        vertexOffset += imposterPivotOffset;
+    
+        //camera to projection vector
+        vec3 rayDirectionLocal = (imposterPivotOffset + projected) - objectSpaceCameraPos;
+                     
+        //projected position to camera ray
+        vec3 projInterpolated = normalize( objectSpaceCameraPos - (projected + imposterPivotOffset) ); 
+        
+        Ray rayLocal;
+        rayLocal.Origin = objectSpaceCameraPos-imposterPivotOffset; 
+        rayLocal.Direction = rayDirectionLocal; 
+        
+        vec2 grid = VectorToGrid( pivotToCameraRay );
+        vec2 gridRaw = grid;
+        grid = saturate((grid+1.0)*0.5); //bias and scale to 0 to 1 
+        grid *= framesMinusOne;
+        
+        vec2 gridFrac = frac(grid);
+        
+        vec2 gridFloor = floor(grid);
+        
+        vec4 weights = TriangleInterpolate( gridFrac ); 
+        
+        //3 nearest frames
+        vec2 frame0 = gridFloor;
+        vec2 frame1 = gridFloor + lerp(vec2(0,1),vec2(1,0),weights.w);
+        vec2 frame2 = gridFloor + vec2(1,1);
+        
+        //convert frame coordinate to octahedron direction
+        vec3 frame0ray = FrameXYToRay(frame0, framesMinusOne.xx);
+        vec3 frame1ray = FrameXYToRay(frame1, framesMinusOne.xx);
+        vec3 frame2ray = FrameXYToRay(frame2, framesMinusOne.xx);
+        
+        vec3 planeCenter = vec3(0,0,0);
+        
+        vec3 plane0x;
+        vec3 plane0normal = frame0ray;
+        vec3 plane0z;
+        vec3 frame0local = FrameTransform( projInterpolated, frame0ray, plane0x, plane0z );
+        frame0local.xz = frame0local.xz/_ImposterFrames.xx; //for displacement
+        
+        //virtual plane UV coordinates
+        vec2 vUv0 = VirtualPlaneUV( plane0normal, plane0x, plane0z, planeCenter, size, rayLocal );
+        vUv0 /= _ImposterFrames.xx;   
+        
+        vec3 plane1x; 
+        vec3 plane1normal = frame1ray;
+        vec3 plane1z;
+        vec3 frame1local = FrameTransform( projInterpolated, frame1ray, plane1x, plane1z);
+        frame1local.xz = frame1local.xz/_ImposterFrames.xx; //for displacement
+        
+        //virtual plane UV coordinates
+        vec2 vUv1 = VirtualPlaneUV( plane1normal, plane1x, plane1z, planeCenter, size, rayLocal );
+        vUv1 /= _ImposterFrames.xx;
+        
+        vec3 plane2x;
+        vec3 plane2normal = frame2ray;
+        vec3 plane2z;
+        vec3 frame2local = FrameTransform( projInterpolated, frame2ray, plane2x, plane2z );
+        frame2local.xz = frame2local.xz/_ImposterFrames.xx; //for displacement
+        
+        //virtual plane UV coordinates
+        vec2 vUv2 = VirtualPlaneUV( plane2normal, plane2x, plane2z, planeCenter, size, rayLocal );
+        vUv2 /= _ImposterFrames.xx;
+        
+        //add offset here
+        imp.vertex.xyz += vertexOffset;
+        //overwrite others
+        imp.uv = texcoord;
+        imp.grid = grid;
+        imp.frame0 = vec4(vUv0.xy,frame0local.xz);
+        imp.frame1 = vec4(vUv1.xy,frame1local.xz);
+        imp.frame2 = vec4(vUv2.xy,frame2local.xz);
+    }
+    
+    void main() {
+        vUv = uv;
+        
+        ImposterData imp;
+        imp.vertex = vec4(position, 1.0);
+        imp.uv = uv;
+        
+        ImposterVertex(imp);
+        
+        gl_Position = imp.vertex;
+        
+        float3 normalWorld = UnityObjectToWorldDir(v.normal.xyz);
+        float3 tangentWorld = UnityObjectToWorldDir(v.tangent.xyz);
+        float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld, v.tangent.w);
+        o.tangentWorld = tangentToWorld[0];
+        o.bitangentWorld = tangentToWorld[1];
+        o.normalWorld = tangentToWorld[2];
+        
+        //surface
+        o.texCoord.xy = imp.uv;
+        o.texCoord.zw = imp.grid;
+        o.plane0 = imp.frame0;
+        o.plane1 = imp.frame1;
+        o.plane2 = imp.frame2;
+    }
+`;
+const shader_fg = `
+    
+    in vec2 vUv;
+    
+    in vec4 plane0;
+    in vec4 plane1;
+    in vec4 plane2;
+    
+    struct Material{
+        vec3 diffuse;
+        vec3 normal;
+        float depth;
+        float occlusion;
+        float roughness;
+        float metalness;
+    };
+    
+    void ImposterSample( in ImposterData imp, out vec4 baseTex, out vec4 worldNormal )//, out half depth )
+    {
+        vec2 fracGrid = frac(imp.grid);
+        
+        vec4 weights = TriangleInterpolate( fracGrid );
+          
+        vec2 gridSnap = floor(imp.grid) / _ImposterFrames.xx;
+            
+        vec2 frame0 = gridSnap;
+        vec2 frame1 = gridSnap + (lerp(vec2(0,1),vec2(1,0),weights.w)/_ImposterFrames.xx);
+        vec2 frame2 = gridSnap + (vec2(1,1)/_ImposterFrames.xx);
+        
+        vec2 vp0uv = frame0 + imp.frame0.xy;
+        vec2 vp1uv = frame1 + imp.frame1.xy; 
+        vec2 vp2uv = frame2 + imp.frame2.xy;
+       
+        //resolution of atlas (Square)
+        float textureDims = _ImposterBaseTex_TexelSize.z;
+        //fractional frame size, ex 2048/12 = 170.6
+        float frameSize = textureDims/_ImposterFrames; 
+        //actual atlas resolution used, ex 170*12 = 2040
+        float actualDims = floor(frameSize) * _ImposterFrames; 
+        //the scale factor to apply to UV coordinate, ex 2048/2040 = 0.99609375
+        float scaleFactor = actualDims / textureDims;
+       
+        vp0uv *= scaleFactor;
+        vp1uv *= scaleFactor;
+        vp2uv *= scaleFactor;
+       
+        //clamp out neighboring frames TODO maybe discard instead?
+        vec2 gridSize = 1.0/_ImposterFrames.xx;
+        gridSize *= _ImposterBaseTex_TexelSize.zw;
+        gridSize *= _ImposterBaseTex_TexelSize.xy;
+        float2 border = _ImposterBaseTex_TexelSize.xy*_ImposterBorderClamp;
+        
+        //vp0uv = clamp(vp0uv,frame0+border,frame0+gridSize-border);
+        //vp1uv = clamp(vp1uv,frame1+border,frame1+gridSize-border);
+        //vp2uv = clamp(vp2uv,frame2+border,frame2+gridSize-border);
+       
+        //for parallax modify
+        vec4 n0 = tex2Dlod( _ImposterWorldNormalDepthTex, vec4(vp0uv, 0, 1 ) );
+        vec4 n1 = tex2Dlod( _ImposterWorldNormalDepthTex, vec4(vp1uv, 0, 1 ) );
+        vec4 n2 = tex2Dlod( _ImposterWorldNormalDepthTex, vec4(vp2uv, 0, 1 ) );
+            
+        half n0s = 0.5-n0.a;    
+        half n1s = 0.5-n1.a;
+        half n2s = 0.5-n2.a;
+        
+        vec2 n0p = imp.frame0.zw * n0s;
+        vec2 n1p = imp.frame1.zw * n1s;
+        vec2 n2p = imp.frame2.zw * n2s;
+        
+        //add parallax shift 
+        vp0uv += n0p;
+        vp1uv += n1p;
+        vp2uv += n2p;
+        
+        //clamp out neighboring frames TODO maybe discard instead?
+        vp0uv = clamp(vp0uv,frame0+border,frame0+gridSize-border);
+        vp1uv = clamp(vp1uv,frame1+border,frame1+gridSize-border);
+        vp2uv = clamp(vp2uv,frame2+border,frame2+gridSize-border);
+        
+        vec2 ddxy = vec2( ddx(imp.uv.x), ddy(imp.uv.y) );
+        
+        worldNormal = ImposterBlendWeights( _ImposterWorldNormalDepthTex, imp.uv, vp0uv, vp1uv, vp2uv, weights, ddxy );
+        baseTex = ImposterBlendWeights( _ImposterBaseTex, imp.uv, vp0uv, vp1uv, vp2uv, weights, ddxy );
+            
+        //pixel depth offset
+        //half pdo = 1-baseTex.a;
+        //float3 objectScale = float3(length(float3(unity_ObjectToWorld[0].x, unity_ObjectToWorld[1].x, unity_ObjectToWorld[2].x)),
+        //                        length(float3(unity_ObjectToWorld[0].y, unity_ObjectToWorld[1].y, unity_ObjectToWorld[2].y)),
+        //                        length(float3(unity_ObjectToWorld[0].z, unity_ObjectToWorld[1].z, unity_ObjectToWorld[2].z)));
+        //vec2 size = _ImposterSize.xx * 2.0;// * objectScale.xx;  
+        //vec3 viewWorld = mul( UNITY_MATRIX_VP, float4(0,0,1,0) ).xyz;
+        //pdo *= size * abs(dot(normalize(imp.viewDirWorld.xyz),viewWorld));
+        //depth = pdo;
+    }
+    
+    void main(){
+    
+    }
+`;
+
+export class ImpostorShaderStandard extends RawShaderMaterial {
+    constructor() {
+        super({
+            fragmentShader: shader_fg,
+            vertexShader: shader_vx,
+            uniforms: {
+                /**
+                 * RGB + Alpha
+                 */
+                tBase: {
+                    value: null
+                },
+                /**
+                 * Normal+Depth
+                 */
+                tGeometry: {
+                    value: null
+                },
+                /**
+                 * Material properties: Occlusion, Roughness, Metalness
+                 * Alpha unused
+                 */
+                tMaterial: {
+                    value: null
+                },
+                /**
+                 * Number of frames
+                 */
+                uFrames: {
+                    value: 0
+                },
+                /**
+                 * Radius of bounding sphere of the impostor
+                 */
+                uRadius: {
+                    value: 0
+                },
+                /**
+                 * Impostor offset
+                 */
+                uOffset: {
+                    value: new Vector3(0, 0, 0)
+                }
+            },
+            glslVersion: GLSL3
+        });
+
+        // Save some effort by disabling blending
+        this.blending = NoBlending;
+
+    }
+}

package/engine/graphics/impostors/octahedral/shader/glsl/common.glsl

@@ -0,0 +1,206 @@
+struct ImposterData
+{
+    vec2 uv;
+    vec2 grid;
+    vec4 frame0;
+    vec4 frame1;
+    vec4 frame2;
+    vec4 vertex;
+};
+
+struct Ray
+{
+    vec3 Origin;
+    vec3 Direction;
+};
+
+//for hemisphere
+vec3 OctaHemiEnc(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)
+    {
+        vec2 flip = vec.xz >= 0.0 ? vec2(1.0, 1.0) : vec2(-1.0, -1.0);
+        vec.xz = (1-abs(vec.zx)) * flip;
+    }
+    return vec;
+}
+
+vec3 GridToVector(vec2 coord)
+{
+    vec3 vec;
+    if (_ImposterFullSphere)
+    {
+        vec = OctaSphereEnc(coord);
+    }
+    else
+    {
+        vec = OctaHemiEnc(coord);
+    }
+    return vec;
+}
+
+//for hemisphere
+vec2 VecToHemiOct(vec3 vec)
+{
+    vec.xz /= dot(1.0, abs(vec));
+    return vec2(vec.x + vec.z, vec.x - vec.z);
+}
+
+vec2 VecToSphereOct(vec3 vec)
+{
+    vec.xz /= dot(1, abs(vec));
+    if (vec.y <= 0)
+    {
+        vec2 flip = vec.xz >= 0 ? vec2(1, 1) : vec2(-1, -1);
+        vec.xz = (1-abs(vec.zx)) * flip;
+    }
+    return vec.xz;
+}
+
+vec2 VectorToGrid(vec3 vec)
+{
+    vec2 coord;
+
+    if (_ImposterFullSphere)
+    {
+        coord = VecToSphereOct(vec);
+    }
+    else
+    {
+        vec.y = max(0.001, vec.y);
+        vec = normalize(vec);
+        coord = VecToHemiOct(vec);
+    }
+    return coord;
+}
+
+vec3 SpriteProjection(vec3 pivotToCameraRayLocal, float frames, vec2 size, vec2 coord){
+    vec3 gridVec = pivotToCameraRayLocal;
+
+    //octahedron vector, pivot to camera
+    vec3 y = normalize(gridVec);
+
+    vec3 x = normalize(cross(y, vec3(0.0, 1.0, 0.0)));
+    vec3 z = normalize(cross(x, y));
+
+    vec2 uv = ((coord*frames)-0.5) * 2.0;//-1 to 1
+
+    vec3 newX = x * uv.x;
+    vec3 newZ = z * uv.y;
+
+    vec2 halfSize = size*0.5;
+
+    newX *= halfSize.x;
+    newZ *= halfSize.y;
+
+    vec3 res = newX + newZ;
+
+    return res;
+}
+
+vec4 TriangleInterpolate(vec2 uv){
+    uv = frac(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 = saturate(ceil(uv.x-uv.y));
+
+    return res;
+}
+
+//frame and framecout, returns
+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
+    f = (f-0.5)*2.0;
+
+    //convert to vector, either full sphere or hemi sphere
+    vec3 vec = GridToVector(f);
+
+    vec = normalize(vec);
+
+    return vec;
+}
+
+vec3 ITBasis(vec3 vec, vec3 basedX, vec3 basedY, vec3 basedZ)
+{
+    return vec3(dot(basedX, vec), dot(basedY, vec), dot(basedZ, vec));
+}
+
+vec3 FrameTransform(vec3 projRay, vec3 frameRay, out vec3 worldX, out vec3 worldZ)
+{
+    //TODO something might be wrong here
+    worldX = normalize(vec3(-frameRay.z, 0, frameRay.x));
+    worldZ = normalize(cross(worldX, frameRay));
+
+    projRay *= -1.0;
+
+    vec3 local = normalize(ITBasis(projRay, worldX, frameRay, worldZ));
+    return local;
+}
+
+
+vec4 ImposterBlendWeights(sampler2D tex, vec2 uv, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec2 ddxy)
+{
+    vec4 samp0 = tex2Dgrad(tex, frame0, ddxy.x, ddxy.y);
+    vec4 samp1 = tex2Dgrad(tex, frame1, ddxy.x, ddxy.y);
+    vec4 samp2 = tex2Dgrad(tex, frame2, ddxy.x, ddxy.y);
+
+    //vec4 samp0 = tex2Dlod( tex, float4(frame0,0,0) );
+    //vec4 samp1 = tex2Dlod( tex, float4(frame1,0,0) );
+    //vec4 samp2 = tex2Dlod( tex, float4(frame2,0,0) );
+
+    vec4 result = samp0*weights.x + samp1*weights.y + samp2*weights.z;
+
+    return result;
+}
+
+vec2 VirtualPlaneUV(vec3 planeNormal, vec3 planeX, vec3 planeZ, vec3 center, vec2 uvScale, Ray rayLocal){
+    float normalDotOrigin = dot(planeNormal, rayLocal.Origin);
+    float normalDotCenter = dot(planeNormal, center);
+    float normalDotRay = dot(planeNormal, rayLocal.Direction);
+
+    float planeDistance = normalDotOrigin-normalDotCenter;
+    planeDistance *= -1.0;
+
+    float intersect = planeDistance / normalDotRay;
+
+    vec3 intersection = ((rayLocal.Direction * intersect) + rayLocal.Origin) - center;
+
+    float dx = dot(planeX, intersection);
+    float dz = dot(planeZ, intersection);
+
+    vec2 uv = vec2(0, 0);
+
+    if (intersect > 0)
+    {
+        uv = vec2(dx, dz);
+    }
+    else
+    {
+        uv = vec2(0, 0);
+    }
+
+    uv /= uvScale;
+    uv += vec2(0.5, 0.5);
+    return uv;
+}

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -1,6 +1,6 @@
 import { HashMap } from "../../../core/collection/HashMap.js";
-import { computeGeometryHash } from "../../asset/loaders/geometry/geometry/computeGeometryHash.js";
-import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../geometry/buffered/computeGeometryHash.js";
+import { computeGeometryEquality } from "../geometry/buffered/computeGeometryEquality.js";
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
 import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";

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

@@ -3,8 +3,8 @@ import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
 import { Cache } from "../../../../core/cache/Cache.js";
-import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
-import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../geometry/buffered/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../geometry/buffered/computeGeometryEquality.js";
 import { CachedAsyncMap } from "../../../../core/collection/map/CachedAsyncMap.js";
 import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteHashMap.js";
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";

package/engine/graphics/particles/node-based/codegen/CodeGenerator.js

@@ -14,6 +14,6 @@ export class CodeGenerator {
                  uniforms
              }) {
 
-
+        throw new Error('Not Implemented');
     }
 }

package/engine/graphics/particles/node-based/nodes/noise/CurlNoiseNode.js

@@ -24,7 +24,7 @@ export class CurlNoiseNode extends ShaderNode {
                 ],
                 ParticleDataTypes.Vector3
             )
-        ))
+        ));
     }
 
     generate_code(instance, output, context, port_variables) {

package/engine/graphics/render/forward_plus/LightManager.js

@@ -303,6 +303,31 @@ export class LightManager {
         this.__visible_bvh_needs_update = true;
     }
 
+    /**
+     * Please set this to false if you have a lot of overlapping decals in the scene
+     * Overlapping decals can provide filtering artifacts due to incorrect mipmap level detection by WebGL
+     * see article: https://0fps.net/2013/07/09/texture-atlases-wrapping-and-mip-mapping/
+     * NOTE: the technique mentioned in the article above is not implemented, as it would require significant increase in number of texture fetches
+     * @param {boolean} v
+     */
+    set decal_filtering_enabled(v) {
+        const t = this.__decal_atlas_texture;
+
+        if (t.generateMipmaps === v) {
+            return;
+        }
+
+        t.generateMipmaps = v;
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    get decal_filtering_enabled() {
+        return this.__decal_atlas_texture.generateMipmaps;
+    }
+
     __update_decal_atlas_texture() {
         const sampler = this.__decal_atlas.sampler;
 

package/engine/graphics/render/forward_plus/data/TextureBackedMemoryRegion.js

@@ -1,7 +1,9 @@
-import { DataTexture, NearestFilter, RedFormat, UnsignedByteType } from "three";
+import { ClampToEdgeWrapping, DataTexture, NearestFilter, RedFormat, UnsignedByteType } from "three";
 import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { assert } from "../../../../../core/assert.js";
-import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import {
+    DataType2TypedArrayConstructorMapping
+} from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { NumericType } from "./NumericType.js";
 import { computeDataType } from "./computeDataType.js";
@@ -63,6 +65,8 @@ export class TextureBackedMemoryRegion {
         this.__texture.format = RedFormat;
         this.__texture.magFilter = NearestFilter;
         this.__texture.minFilter = NearestFilter;
+        this.__texture.wrapS = ClampToEdgeWrapping;
+        this.__texture.wrapT = ClampToEdgeWrapping;
         this.__texture.generateMipmaps = false;
 
         /**

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

@@ -53,30 +53,25 @@ export const FP_SHADER_CHUNK_ACCUMULATION = `
                    vec4 local_position = decal_transform_matrix*vec4(v_world_position, 1.0);
                    
                    if(max3(abs(local_position.xyz)) < 0.5){
-                          // material.diffuseColor = material.diffuseColor*(0.8) + (local_position.xyz + 0.5)*0.2; // display UV
-                          
+                   
                           // 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);
-                          // float decal_surface_angle_fade = decal_surface_dot;
-
-
+                         
                           vec2 decal_uv = (local_position.xy + 0.5)*light_data_4.zw + light_data_4.xy;
                           
-                          //material.diffuseColor = material.diffuseColor*(0.8) + vec3(decal_uv + 0.5, 0.0)*0.2; // display UV
                           
-
                           vec4 decal_color = texture(fp_t_decal_atlas, decal_uv);
+                          
                           float decal_alpha = decal_color.a * decal_surface_angle_fade;
-                          // float decal_alpha = decal_color.a;
-
+        
                           material.diffuseColor = material.diffuseColor*(1.0-decal_alpha) + decal_color.xyz*decal_alpha;
 
                    }