@zephyr3d/scene 0.5.0 → 0.6.0

package/dist/scene/terrain/heightfield.js

@@ -23,7 +23,7 @@ import { BoundingBox } from '../../utility/bounding_volume.js';
         for(let i = 0; i < this._heights.length; i++){
             this._heights[i] = vertices[i].y;
         }
-        this.createChildNode(this._rootNode, 0, 0, res_x, res_y, vertices);
+        this.createChildNode(this._rootNode, 0, 0, res_x - 1, res_y - 1, vertices);
         return true;
     }
     getHeight(x, y) {
@@ -121,12 +121,6 @@ import { BoundingBox } from '../../utility/bounding_volume.js';
     allocNode() {
         return {
             bbox: new BoundingBox(),
-            h: [
-                0,
-                0,
-                0,
-                0
-            ],
             rc: {
                 x: 0,
                 y: 0,
@@ -152,31 +146,38 @@ import { BoundingBox } from '../../utility/bounding_volume.js';
         node.rc.y = y;
         node.rc.w = w;
         node.rc.h = h;
-        if (w <= 2 && h <= 2) {
+        if (w <= 16 && h <= 16) {
             node.left = null;
             node.right = null;
-            node.h[0] = this.getHeight(x, y);
-            node.h[1] = this.getHeight(x + 1, y);
-            node.h[2] = this.getHeight(x + 1, y + 1);
-            node.h[3] = this.getHeight(x, y + 1);
-            const hMin = Math.min(...node.h);
-            const hMax = Math.max(...node.h);
-            node.bbox = new BoundingBox(new Vector3(x * this._spacingX, hMin, y * this._spacingZ), new Vector3((x + 1) * this._spacingX, hMax, (y + 1) * this._spacingZ));
+            let hMin = Infinity;
+            let hMax = -Infinity;
+            for(let i = x; i <= x + w; i++){
+                for(let j = y; j <= y + h; j++){
+                    const h = this.getHeight(i, j);
+                    if (h > hMax) {
+                        hMax = h;
+                    }
+                    if (h < hMin) {
+                        hMin = h;
+                    }
+                }
+            }
+            node.bbox = new BoundingBox(new Vector3(x * this._spacingX, hMin, y * this._spacingZ), new Vector3((x + w) * this._spacingX, hMax, (y + h) * this._spacingZ));
         } else {
             if (w >= h) {
-                const w1 = w + 1 >> 1;
-                const w2 = w - w1 + 1;
+                const w1 = w >> 1;
+                const w2 = w - w1;
                 node.left = this.allocNode();
                 this.createChildNode(node.left, x, y, w1, h, vertices);
                 node.right = this.allocNode();
-                this.createChildNode(node.right, x + w1 - 1, y, w2, h, vertices);
+                this.createChildNode(node.right, x + w1, y, w2, h, vertices);
             } else {
-                const h1 = h + 1 >> 1;
-                const h2 = h - h1 + 1;
+                const h1 = h >> 1;
+                const h2 = h - h1;
                 node.left = this.allocNode();
                 this.createChildNode(node.left, x, y, w, h1, vertices);
                 node.right = this.allocNode();
-                this.createChildNode(node.right, x, y + h1 - 1, w, h2, vertices);
+                this.createChildNode(node.right, x, y + h1, w, h2, vertices);
             }
             node.bbox.beginExtend();
             node.bbox.extend(node.left.bbox.minPoint);
@@ -187,45 +188,126 @@ import { BoundingBox } from '../../utility/bounding_volume.js';
         return true;
     }
     rayIntersect(ray) {
-        return this.rayIntersectR(ray, this._rootNode);
-    }
-    rayIntersectR(ray, node) {
-        const d = ray.bboxIntersectionTestEx(node.bbox);
-        if (d === null) {
-            return null;
+        return this.rayIntersectRecursive(ray);
+    }
+    rayIntersectLeaf(ray, node) {
+        let x0 = ray.origin.x;
+        let y0 = ray.origin.z;
+        let dx = ray.direction.x;
+        let dy = ray.direction.z;
+        const gridSizeX = this._spacingX;
+        const gridSizeY = this._spacingZ;
+        const x = node.rc.x;
+        const y = node.rc.y;
+        const w = node.rc.w;
+        const h = node.rc.h;
+        const epsl = 0.001;
+        let tx = 0;
+        let ty = 0;
+        const xmin = x * gridSizeX;
+        const xmax = xmin + w * gridSizeX;
+        const ymin = y * gridSizeY;
+        const ymax = ymin + h * gridSizeY;
+        const xcenter = (xmin + xmax) / 2;
+        const ycenter = (ymin + ymax) / 2;
+        let mirrorx = false;
+        let mirrory = false;
+        if (dx < 0) {
+            dx = -dx;
+            x0 += 2 * (xcenter - x0);
+            mirrorx = true;
         }
-        if (node.left && node.right) {
-            const l = this.rayIntersectR(ray, node.left);
-            const r = this.rayIntersectR(ray, node.right);
-            if (l !== null && r !== null) {
-                return l < r ? l : r;
-            } else {
-                return l === null ? r : l;
+        if (dy < 0) {
+            dy = -dy;
+            y0 += 2 * (ycenter - y0);
+            mirrory = true;
+        }
+        if (x0 < xmin) {
+            tx = (xmin - x0) / dx;
+        } else if (x0 > xmax) {
+            return;
+        }
+        if (y0 < ymin) {
+            ty = (ymin - y0) / dy;
+        } else if (y0 > ymax) {
+            return;
+        }
+        const t = tx > ty ? tx : ty;
+        x0 += t * dx;
+        y0 += t * dy;
+        let u = Math.floor((x0 - xmin + epsl) / gridSizeX);
+        let v = Math.floor((y0 - ymin + epsl) / gridSizeY);
+        while(u >= 0 && u <= w && v >= 0 && v <= h){
+            if (u < w && v < h) {
+                const m = x + (mirrorx ? w - u - 1 : u);
+                const n = y + (mirrory ? h - v - 1 : v);
+                const v00 = new Vector3(m * this._spacingX, this.getHeight(m, n), n * this._spacingZ);
+                const v01 = new Vector3((m + 1) * this._spacingX, this.getHeight(m + 1, n), n * this._spacingZ);
+                const v11 = new Vector3((m + 1) * this._spacingX, this.getHeight(m + 1, n + 1), (n + 1) * this._spacingZ);
+                const v10 = new Vector3(m * this._spacingX, this.getHeight(m, n + 1), (n + 1) * this._spacingZ);
+                let intersected = false;
+                let dist1 = ray.intersectionTestTriangle(v00, v01, v10, false);
+                if (dist1 !== null && dist1 > 0) {
+                    intersected = true;
+                } else {
+                    dist1 = Number.MAX_VALUE;
+                }
+                let dist2 = ray.intersectionTestTriangle(v10, v01, v11, false);
+                if (dist2 !== null && dist2 > 0) {
+                    intersected = true;
+                } else {
+                    dist2 = Number.MAX_VALUE;
+                }
+                if (intersected) {
+                    return dist1 < dist2 ? dist1 : dist2;
+                }
             }
-        } else {
-            const v00 = new Vector3(node.bbox.minPoint.x, node.h[0], node.bbox.minPoint.z);
-            const v01 = new Vector3(node.bbox.maxPoint.x, node.h[1], node.bbox.minPoint.z);
-            const v11 = new Vector3(node.bbox.maxPoint.x, node.h[2], node.bbox.maxPoint.z);
-            const v10 = new Vector3(node.bbox.minPoint.x, node.h[3], node.bbox.maxPoint.z);
-            let intersected = false;
-            let dist1 = ray.intersectionTestTriangle(v00, v01, v10, false);
-            if (dist1 !== null && dist1 > 0) {
-                intersected = true;
-            } else {
-                dist1 = Number.MAX_VALUE;
+            let d = Infinity;
+            if (dx > 0) {
+                const x1 = (u + x + 1) * gridSizeX;
+                d = Math.min(d, (x1 - x0) / dx);
             }
-            let dist2 = ray.intersectionTestTriangle(v10, v01, v11, false);
-            if (dist2 !== null && dist2 > 0) {
-                intersected = true;
-            } else {
-                dist2 = Number.MAX_VALUE;
+            if (dy !== 0) {
+                const y1 = (v + y + 1) * gridSizeY;
+                d = Math.min(d, (y1 - y0) / dy);
             }
-            if (!intersected) {
-                return null;
+            x0 += d * dx;
+            y0 += d * dy;
+            u = Math.floor((x0 - xmin + epsl) / gridSizeX);
+            v = Math.floor((y0 - ymin + epsl) / gridSizeY);
+        }
+        return null;
+    }
+    rayIntersectRecursive(ray) {
+        const q = [
+            this._rootNode
+        ];
+        while(q.length > 0){
+            const node = q.shift();
+            if (!node.left) {
+                const d = this.rayIntersectLeaf(ray, node);
+                if (d !== null) {
+                    return d;
+                }
             } else {
-                return dist1 < dist2 ? dist1 : dist2;
+                const dl = ray.bboxIntersectionTestEx(node.left.bbox);
+                const dr = ray.bboxIntersectionTestEx(node.right.bbox);
+                if (dl !== null && dr !== null) {
+                    if (dl < dr) {
+                        q.unshift(node.right);
+                        q.unshift(node.left);
+                    } else {
+                        q.unshift(node.left);
+                        q.unshift(node.right);
+                    }
+                } else if (dl !== null) {
+                    q.unshift(node.left);
+                } else if (dr !== null) {
+                    q.unshift(node.right);
+                }
             }
         }
+        return null;
     }
 }
 /** @internal */ class HeightField {

package/dist/scene/terrain/heightfield.js.map

@@ -1 +1 @@
-{"version":3,"file":"heightfield.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"heightfield.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/scene/terrain/patch.js

@@ -81,7 +81,9 @@ import { mixinDrawable } from '../../render/drawable_mixin.js';
         return this._terrain.getInstanceColor();
     }
     getPickTarget() {
-        return this._terrain;
+        return {
+            node: this._terrain
+        };
     }
     getMaterial() {
         return this._terrain.material;
@@ -105,9 +107,6 @@ import { mixinDrawable } from '../../render/drawable_mixin.js';
     getBoneMatrices() {
         return null;
     }
-    getInvBindMatrix() {
-        return null;
-    }
     getMorphData() {
         return null;
     }

package/dist/scene/terrain/patch.js.map

@@ -1 +1 @@
-{"version":3,"file":"patch.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"patch.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/scene/terrain/terrain.js

@@ -201,7 +201,7 @@ import { GrassMaterial } from '../../material/grassmaterial.js';
     /**
    * {@inheritDoc SceneNode.computeBoundingVolume}
    * @override
-   */ computeBoundingVolume(bv) {
+   */ computeBoundingVolume() {
         return this._quadtree ? this._quadtree.getHeightField().getBBoxTree().getRootNode().bbox : null;
     }
     /**

package/dist/scene/xform.js

@@ -205,7 +205,7 @@ import { makeEventTarget, ObservableVector3, ObservableQuaternion, Matrix4x4, Ve
         this.parent = p;
         return this;
     }
-    /** @internal */ getTag() {
+    /** @internal */ get transformTag() {
         return this._transformTag;
     }
     /** @internal */ syncTRS() {
@@ -221,15 +221,13 @@ import { makeEventTarget, ObservableVector3, ObservableQuaternion, Matrix4x4, Ve
         if (invalidateLocal) {
             this._localMatrix = null;
         }
-        if (this._worldMatrix) {
-            this._worldMatrix = null;
-            this._invWorldMatrix = null;
-            this._transformTag++;
-            for (const child of this._children){
-                child._onTransformChanged(false);
-            }
-        }
+        this._worldMatrix = null;
+        this._invWorldMatrix = null;
         this._worldMatrixDet = null;
+        this._transformTag++;
+        for (const child of this._children){
+            child._onTransformChanged(false);
+        }
     }
     /** @internal */ _setParent(p) {
         if (this._parent !== p) {

package/dist/scene/xform.js.map

@@ -1 +1 @@
-{"version":3,"file":"xform.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"xform.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/misc.js

@@ -252,6 +252,15 @@ import { PBPrimitiveType, PBInsideFunctionScope } from '@zephyr3d/device';
     });
     return pb.getGlobalScope()[funcName](color);
 }
+/** @internal */ function fetchNormalizedFloatForDevice(scope, tex, uv, level) {
+    const pb = scope.$builder;
+    const texel = level === undefined || level === null ? pb.textureSample(tex, uv) : pb.textureSampleLevel(tex, uv, level);
+    if (pb.getDevice().type === 'webgl') {
+        return decodeNormalizedFloatFromRGBA(scope, texel);
+    } else {
+        return texel;
+    }
+}
 
-export { decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, gammaToLinear, linearToGamma };
+export { decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, fetchNormalizedFloatForDevice, gammaToLinear, linearToGamma };
 //# sourceMappingURL=misc.js.map

package/dist/shaders/misc.js.map

@@ -1 +1 @@
-{"version":3,"file":"misc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"misc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/noise.js

@@ -1,32 +1,82 @@
 /**
- * Generate single float noise from a vec2
+ * Generate random float value from a vec2
  *
  * @param scope - Current shader scope
  * @param p - random seed
- * @returns a float noise value
+ * @returns random float value
  *
  * @public
- */ function noisef(scope, p) {
+ */ function hash(scope, p) {
     const pb = scope.$builder;
-    const funcNameHash = 'Z_hashf';
-    const funcNameNoise = 'Z_noisef';
-    pb.func(funcNameHash, [
+    const funcName = 'Z_hashf';
+    pb.func(funcName, [
         pb.vec2('p')
     ], function() {
-        this.h = pb.dot(this.p, pb.vec2(127.1, 311.7));
+        this.h = pb.dot(this.p, pb.vec2(12.9898, 78.233));
         this.$return(pb.fract(pb.mul(pb.sin(this.h), 43758.5453123)));
     });
+    return scope[funcName](p);
+}
+/**
+ * Generate random float value from a vec2
+ *
+ * @param scope - Current shader scope
+ * @param p - random seed
+ * @returns random float value
+ *
+ * @public
+ */ function gradient(scope, p, t) {
+    const pb = scope.$builder;
+    const funcName = 'Z_gradient2f';
+    pb.func(funcName, [
+        pb.vec2('p'),
+        pb.float('t')
+    ], function() {
+        this.$l.rand = hash(this, this.p);
+        this.$l.angle = pb.mul(pb.add(this.t, Math.PI * 2), this.rand);
+        this.$return(pb.vec2(pb.cos(this.angle), pb.sin(this.angle)));
+    });
+    return scope[funcName](p, t);
+}
+/**
+ * Generate a float perlin noise value from a vec2
+ *
+ * @param scope - Current shader scope
+ * @param p - 2d vector
+ * @returns a float noise value
+ *
+ * @public
+ */ function perlinNoise2D(scope, p) {
+    return perlinNoise3D(scope, scope.$builder.vec3(p, 0));
+}
+/**
+ * Generate a float perlin noise value from a vec3
+ *
+ * @param scope - Current shader scope
+ * @param p - 3d vector
+ * @returns a float noise value
+ *
+ * @public
+ */ function perlinNoise3D(scope, p) {
+    const pb = scope.$builder;
+    const funcNameNoise = 'Z_perlinNoise3D';
     pb.func(funcNameNoise, [
-        pb.vec2('p')
+        pb.vec3('p')
     ], function() {
-        this.i = pb.floor(this.p);
-        this.f = pb.fract(this.p);
+        this.i = pb.floor(this.p.xy);
+        this.f = pb.sub(this.p.xy, this.i);
         this.u = pb.mul(this.f, this.f, pb.sub(3, pb.mul(this.f, 2)));
-        this.h1 = this[funcNameHash](this.i);
-        this.h2 = this[funcNameHash](pb.add(this.i, pb.vec2(1, 0)));
-        this.h3 = this[funcNameHash](pb.add(this.i, pb.vec2(0, 1)));
-        this.h4 = this[funcNameHash](pb.add(this.i, pb.vec2(1, 1)));
-        this.$return(pb.add(-1, pb.mul(2, pb.mix(pb.mix(this.h1, this.h2, this.u.x), pb.mix(this.h3, this.h4, this.u.x), this.u.y))));
+        this.h1 = gradient(this, this.i, this.p.z);
+        this.h2 = gradient(this, pb.add(this.i, pb.vec2(1, 0)), this.p.z);
+        this.h3 = gradient(this, pb.add(this.i, pb.vec2(0, 1)), this.p.z);
+        this.h4 = gradient(this, pb.add(this.i, pb.vec2(1, 1)), this.p.z);
+        this.$l.tl = pb.dot(this.h1, this.f);
+        this.$l.tr = pb.dot(this.h2, pb.sub(this.f, pb.vec2(1, 0)));
+        this.$l.bl = pb.dot(this.h3, pb.sub(this.f, pb.vec2(0, 1)));
+        this.$l.br = pb.dot(this.h4, pb.sub(this.f, pb.vec2(1, 1)));
+        this.$l.noise = pb.mix(pb.mix(this.tl, this.tr, this.u.x), pb.mix(this.bl, this.br, this.u.x), this.u.y);
+        this.noise = pb.add(pb.mul(this.noise, 0.5), 0.5);
+        this.$return(this.noise);
     });
     return scope[funcNameNoise](p);
 }
@@ -152,6 +202,21 @@
     });
     return pb.getGlobalScope()[funcName](p);
 }
+/**
+ * Calculate interleaved gradient noise
+ *
+ * @param scope - current shader scope
+ * @param c - 2d position at where to calculate noise
+ * @returns noise value
+ *
+ * @public
+ */ function interleavedGradientNoise(scope, c) {
+    const pb = scope.$builder;
+    const x = 0.06711056;
+    const y = 0.00583715;
+    const z = 52.9829189;
+    return pb.fract(pb.mul(z, pb.fract(pb.dot(c, pb.vec2(x, y)))));
+}
 
-export { noise3D, noisef, smoothNoise3D, worleyFBM, worleyNoise };
+export { gradient, hash, interleavedGradientNoise, noise3D, perlinNoise2D, perlinNoise3D, smoothNoise3D, worleyFBM, worleyNoise };
 //# sourceMappingURL=noise.js.map

package/dist/shaders/noise.js.map

@@ -1 +1 @@
-{"version":3,"file":"noise.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"noise.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/shadow.js

@@ -3,6 +3,7 @@ import { Application } from '../app.js';
 import { LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
 import { encodeNormalizedFloatToRGBA, decode2HalfFromRGBA, decodeNormalizedFloatFromRGBA } from './misc.js';
 import { ShaderHelper } from '../material/shader/helper.js';
+import { interleavedGradientNoise } from './noise.js';
 
 /*
   const PCF_KERNEL_3x3 = [
@@ -354,15 +355,6 @@ function getShadowMapSize(scope) {
     });
     return pb.getGlobalScope()[funcNameComputeReceiverPlaneDepthBias](texCoord);
 }
-// reference: github.com/google/filament
-function interleavedGradientNoise(scope, c) {
-    const pb = scope.$builder;
-    const x = 0.06711056;
-    const y = 0.00583715;
-    const z = 52.9829189;
-    return pb.fract(pb.mul(z, pb.fract(pb.dot(c, pb.vec2(x, y)))));
-}
-// reference: github.com/google/filament
 function getRandomRotationMatrix(scope, fragCoord) {
     const funcNameGetRandomRotationMatrix = 'lib_getRandomRotationMatrix';
     const pb = scope.$builder;

package/dist/shaders/shadow.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"shadow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}