@zephyr3d/scene 0.5.0 → 0.6.0

package/dist/shaders/water.js.map

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

package/dist/shadow/shadowmapper.js

@@ -50,8 +50,8 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             shadowMapSize: 1024,
             numCascades: 1,
             splitLambda: 0.5,
-            depthBias: 0.05,
-            normalBias: 0.05,
+            depthBias: 0.5,
+            normalBias: 0.2,
             nearClip: 1
         };
         this._resourceDirty = true;
@@ -435,7 +435,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         up.setXYZ(0, 1, 0);
         lightCamera.lookAt(center, target, up);
         lightCamera.position.set(center);
-        lightCamera.setOrtho(-radius, radius, -radius, radius, -radius, radius);
+        lightCamera.setOrtho(-radius, radius, -radius, radius, -radius, Math.max(Vector3.distance(center, sceneCamera.getWorldPosition()), sceneCamera.getFarPlane()));
         center.setXYZ(0, 0, 0);
         lightCamera.viewProjectionMatrix.transformPointP(center, center);
         if (cropMatrix) {
@@ -575,11 +575,11 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         }
         return result;
     }
-    /** @internal */ calcDepthBiasParams(shadowMapCamera, shadowMapSize, depthBias, normalBias, depthScale, result) {
-        const sizeNear = Math.min(shadowMapCamera.getProjectionMatrix().getNearPlaneWidth(), shadowMapCamera.getProjectionMatrix().getNearPlaneHeight());
-        const sizeFar = Math.min(shadowMapCamera.getProjectionMatrix().getFarPlaneWidth(), shadowMapCamera.getProjectionMatrix().getFarPlaneHeight());
-        const scaleFactor = sizeNear / shadowMapSize / 2;
-        result.setXYZW(depthBias * scaleFactor, normalBias * scaleFactor, depthScale, sizeFar / sizeNear);
+    /** @internal */ calcDepthBiasParams(camera, shadowMapSize, depthBias, normalBias, depthScale, result) {
+        const sizeNear = Math.min(camera.getProjectionMatrix().getNearPlaneWidth(), camera.getProjectionMatrix().getNearPlaneHeight());
+        const sizeFar = Math.min(camera.getProjectionMatrix().getFarPlaneWidth(), camera.getProjectionMatrix().getFarPlaneHeight());
+        const scaleFactor = sizeNear / shadowMapSize * 2;
+        result.setXYZW(depthBias * scaleFactor, normalBias * 0.0001, depthScale, sizeFar / sizeNear);
     }
     /** @internal */ postRenderShadowMap(shadowMapParams) {
         this._impl.postRenderShadowMap(shadowMapParams);
@@ -607,7 +607,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         if (this._light.isPointLight()) {
             const shadowMapRenderCamera = ShadowMapper.fetchCameraForScene(scene);
             this.createLightCameraPoint(shadowMapRenderCamera);
-            this.calcDepthBiasParams(shadowMapRenderCamera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
+            this.calcDepthBiasParams(camera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
             shadowMapParams.cameraParams.setXYZW(shadowMapRenderCamera.getNearPlane(), shadowMapRenderCamera.getFarPlane(), this._config.shadowMapSize, this._shadowDistance);
             device.setFramebuffer(fb);
             shadowMapParams.shadowMatrices.set(Matrix4x4.transpose(shadowMapRenderCamera.viewMatrix));
@@ -642,7 +642,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                     const border = shadowMapParams.impl.getShadowMapBorder(shadowMapParams); //20 / this._config.shadowMapSize;
                     this.createLightCameraDirectional(shadowRegion, cascadeCamera, shadowMapRenderCamera, snapMatrix, border);
                     this.createLightCameraDirectional(shadowRegion, cascadeCamera, shadowMapCullCamera, null, border);
-                    this.calcDepthBiasParams(shadowMapRenderCamera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[split]);
+                    this.calcDepthBiasParams(camera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[split]);
                     shadowMapParams.depthBiasScales[split] = 1;
                     // Incorrect calculation
                     // shadowMapParams.depthBiasScales[split] = shadowMapParams.depthBiasValues[0].x !== 0 ? shadowMapParams.depthBiasValues[split].x / shadowMapParams.depthBiasValues[0].x : 1;
@@ -698,7 +698,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                 } else {
                     this.createLightCameraSpot(shadowMapRenderCamera);
                 }
-                this.calcDepthBiasParams(shadowMapRenderCamera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
+                this.calcDepthBiasParams(camera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
                 shadowMapParams.cameraParams.setXYZW(shadowMapRenderCamera.getNearPlane(), shadowMapRenderCamera.getFarPlane(), this._config.shadowMapSize, this._shadowDistance);
                 device.setFramebuffer(fb);
                 shadowMapRenderCamera.setProjectionMatrix(Matrix4x4.multiply(snapMatrix, shadowMapRenderCamera.getProjectionMatrix()));

package/dist/shapes/cylinder.js

@@ -14,11 +14,12 @@ import { Shape } from './shape.js';
     }
     /** @internal */ createDefaultOptions() {
         const options = super.createDefaultOptions();
-        options.topRadius = 1;
         options.bottomRadius = 1;
+        options.topRadius = 1;
         options.heightDetail = 1;
         options.radialDetail = 20;
         options.height = 1;
+        options.anchor = 0;
         return options;
     }
     /** @internal */ addPatch(x, y, indices) {
@@ -30,17 +31,17 @@ import { Shape } from './shape.js';
         indices.push(lt, lb, rb, lt, rb, rt);
     }
     /** @internal */ _createArrays(vertices, normals, uvs, indices) {
-        const slope = (this._options.bottomRadius - this._options.topRadius) / this._options.height;
+        const slope = (this._options.topRadius - this._options.bottomRadius) / this._options.height;
         for(let y = 0; y <= this._options.heightDetail; y++){
             const v = y / this._options.heightDetail;
-            const radius = (this._options.bottomRadius - this._options.topRadius) * v + this._options.topRadius;
+            const radius = (this._options.topRadius - this._options.bottomRadius) * v + this._options.bottomRadius;
             for(let x = 0; x <= this._options.radialDetail; x++){
                 const u = x / this._options.radialDetail;
                 const theta = u * Math.PI * 2;
                 const sinTheta = Math.sin(theta);
                 const cosTheta = Math.cos(theta);
                 const m = 1 / Math.sqrt(sinTheta * sinTheta + slope * slope + cosTheta * cosTheta);
-                vertices.push(radius * sinTheta, (v - 0.5) * this._options.height, radius * cosTheta);
+                vertices.push(radius * sinTheta, (v - this._options.anchor) * this._options.height, radius * cosTheta);
                 normals.push(sinTheta * m, slope * m, cosTheta * m);
                 uvs.push(u, 1 - v);
                 if (y < this._options.heightDetail && x < this._options.radialDetail) {
@@ -60,7 +61,7 @@ import { Shape } from './shape.js';
         this.createAndSetVertexBuffer('normal_f32x3', new Float32Array(normals));
         this.createAndSetVertexBuffer('tex0_f32x2', new Float32Array(uvs));
         this.createAndSetIndexBuffer(new Uint16Array(indices));
-        const radiusMax = Math.max(this._options.topRadius, this._options.bottomRadius);
+        const radiusMax = Math.max(this._options.bottomRadius, this._options.topRadius);
         this.setBoundingVolume(new BoundingBox(new Vector3(-radiusMax, 0, -radiusMax), new Vector3(radiusMax, this._options.height, radiusMax)));
         this.indexCount = indices.length;
         return true;

package/dist/shapes/cylinder.js.map

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

package/dist/utility/bounding_volume.js

@@ -1,5 +1,4 @@
 import { AABB, Frustum, ClipState } from '@zephyr3d/base';
-import { AABBTree } from './aabbtree.js';
 
 /**
  * The bounding box class
@@ -25,57 +24,6 @@ import { AABBTree } from './aabbtree.js';
         return this;
     }
 }
-/**
- * Bounding box tree
- * @public
- */ class BoundingBoxTree extends AABBTree {
-    constructor(arg){
-        super(arg);
-    }
-    /** {@inheritDoc BoundingVolume.clone} */ clone() {
-        return new BoundingBoxTree(this);
-    }
-    /** {@inheritDoc BoundingVolume.transform} */ transform(matrix) {
-        const newBV = new BoundingBoxTree(this);
-        newBV.transform(matrix);
-        return newBV;
-    }
-    /** {@inheritDoc BoundingVolume.behindPlane} */ behindPlane(plane) {
-        return this.toAABB().behindPlane(plane);
-    }
-    /** {@inheritDoc BoundingVolume.outsideFrustum} */ outsideFrustum(frustum) {
-        const aabb = this.getTopLevelAABB();
-        if (aabb) {
-            return (frustum instanceof Frustum ? aabb.getClipStateWithFrustum(frustum) : aabb.getClipState(frustum)) === ClipState.NOT_CLIPPED;
-        } else {
-            return false;
-        }
-    }
-    /** {@inheritDoc BoundingVolume.toAABB} */ toAABB() {
-        return this.getTopLevelAABB();
-    }
-} /*
-export class BoundingFrustum implements BoundingVolume {
-    protected _frustum: Frustum;
-    constructor ();
-    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
-    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
-        if (arg0 instanceof BoundingFrustum) {
-            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
-        } else if (arg0 instanceof Frustum) {
-            this._frustum = new Frustum (arg0);
-        } else if (arg0 instanceof Matrix4x4) {
-            this._frustum = new Frustum (arg0);
-        } else {
-            this._frustum = null;
-        }
-    }
-    clone (): BoundingVolume {
-        return new BoundingFrustum (this);
-    }
-    transform (matrix: Matrix4x4)
-}
-*/
 
-export { BoundingBox, BoundingBoxTree };
+export { BoundingBox };
 //# sourceMappingURL=bounding_volume.js.map

package/dist/utility/bounding_volume.js.map

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

package/dist/utility/misc.js

@@ -0,0 +1,93 @@
+import { Application } from '../app.js';
+import '@zephyr3d/base';
+import '@zephyr3d/device';
+import { CopyBlitter } from '../blitter/copy.js';
+
+const samplerOptions = {
+    clamp_linear: {
+        addressU: 'clamp',
+        addressV: 'clamp',
+        magFilter: 'linear',
+        minFilter: 'linear',
+        mipFilter: 'linear'
+    },
+    clamp_linear_nomip: {
+        addressU: 'clamp',
+        addressV: 'clamp',
+        magFilter: 'linear',
+        minFilter: 'linear',
+        mipFilter: 'none'
+    },
+    clamp_nearest: {
+        addressU: 'clamp',
+        addressV: 'clamp',
+        magFilter: 'nearest',
+        minFilter: 'nearest',
+        mipFilter: 'nearest'
+    },
+    clamp_nearest_nomip: {
+        addressU: 'clamp',
+        addressV: 'clamp',
+        magFilter: 'nearest',
+        minFilter: 'nearest',
+        mipFilter: 'none'
+    },
+    repeat_linear: {
+        addressU: 'repeat',
+        addressV: 'repeat',
+        magFilter: 'linear',
+        minFilter: 'linear',
+        mipFilter: 'linear'
+    },
+    repeat_linear_nomip: {
+        addressU: 'repeat',
+        addressV: 'repeat',
+        magFilter: 'linear',
+        minFilter: 'linear',
+        mipFilter: 'none'
+    },
+    repeat_nearest: {
+        addressU: 'repeat',
+        addressV: 'repeat',
+        magFilter: 'nearest',
+        minFilter: 'nearest',
+        mipFilter: 'nearest'
+    },
+    repeat_nearest_nomip: {
+        addressU: 'repeat',
+        addressV: 'repeat',
+        magFilter: 'nearest',
+        minFilter: 'nearest',
+        mipFilter: 'none'
+    }
+};
+const samplers = {};
+let copyBlitter = null;
+let defaultCopyRenderState = null;
+function fetchSampler(type) {
+    let sampler = samplers[type];
+    if (!sampler) {
+        const opt = samplerOptions[type];
+        if (opt) {
+            sampler = Application.instance.device.createSampler(opt);
+            samplers[type] = sampler;
+        }
+    }
+    return sampler;
+}
+function copyTexture(src, dest, sampler = null, renderState = null, layer = 0, srgbOut = false) {
+    if (!renderState && !defaultCopyRenderState) {
+        defaultCopyRenderState = src.device.createRenderStateSet();
+        defaultCopyRenderState.useDepthState().enableTest(false).enableWrite(false);
+        defaultCopyRenderState.useRasterizerState().setCullMode('none');
+    }
+    if (!copyBlitter) {
+        copyBlitter = new CopyBlitter();
+    }
+    copyBlitter.renderStates = renderState ?? defaultCopyRenderState;
+    copyBlitter.srgbOut = srgbOut;
+    copyBlitter.blit(src, dest, layer, sampler);
+}
+
+export { copyTexture, fetchSampler };
+//# sourceMappingURL=misc.js.map

package/dist/utility/misc.js.map

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

package/dist/utility/shprojection.js

@@ -3,6 +3,7 @@ import { Application } from '../app.js';
 import { Blitter } from '../blitter/blitter.js';
 import '@zephyr3d/device';
 import { CopyBlitter } from '../blitter/copy.js';
+import { fetchSampler } from './misc.js';
 
 class ReduceBlitter extends Blitter {
     _width;
@@ -277,13 +278,7 @@ async function doProjectCubemap(srcTexture, coeff) {
         device.setFramebuffer(null);
         framebuffer.dispose();
         const blitter = new ReduceBlitter();
-        const sampler = device.createSampler({
-            addressU: 'clamp',
-            addressV: 'clamp',
-            magFilter: 'nearest',
-            minFilter: 'nearest',
-            mipFilter: 'none'
-        });
+        const sampler = fetchSampler('clamp_nearest_nomip');
         for(let i = 1; i < tmpTextures.length; i++){
             blitter.width = tmpTextures[i - 1].width;
             blitter.blit(tmpTextures[i - 1], tmpTextures[i], sampler);

package/dist/utility/shprojection.js.map

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

package/dist/utility/textures/ggxlut.js

@@ -0,0 +1,213 @@
+import { Application } from '../../app.js';
+
+const ggxLut = new Map();
+function getGGXLUT(size) {
+    let lut = ggxLut.get(size);
+    if (!lut) {
+        lut = createGGXLUT(size);
+        ggxLut.set(size, lut);
+    }
+    return lut;
+}
+function createGGXLUT(size) {
+    const device = Application.instance.device;
+    const program = device.buildRenderProgram({
+        vertex (pb) {
+            this.$inputs.pos = pb.vec2().attrib('position');
+            this.$outputs.uv = pb.vec2();
+            pb.main(function() {
+                this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                if (device.type === 'webgpu') {
+                    this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                }
+            });
+        },
+        fragment (pb) {
+            this.$outputs.color = pb.vec4();
+            const SAMPLE_COUNT = 1024;
+            if (device.type === 'webgl') {
+                pb.func('radicalInverse_VdC', [
+                    pb.int('bits')
+                ], function() {
+                    this.$l.rand = pb.float(0);
+                    this.$l.denom = pb.float(1);
+                    this.$l.invBase = pb.float(0.5);
+                    this.$l.n = this.bits;
+                    this.$for(pb.int('i'), 0, 32, function() {
+                        this.denom = pb.mul(this.denom, 2);
+                        this.rand = pb.add(this.rand, pb.div(pb.mod(pb.float(this.n), 2), this.denom));
+                        this.n = pb.div(this.n, 2);
+                        this.$if(pb.equal(this.n, 0), function() {
+                            this.$break();
+                        });
+                    });
+                    this.$return(this.rand);
+                });
+                pb.func('hammersley2d', [
+                    pb.int('i'),
+                    pb.int('N')
+                ], function() {
+                    this.$return(pb.vec2(pb.div(pb.float(this.i), pb.float(this.N)), this.radicalInverse_VdC(this.i)));
+                });
+            } else {
+                pb.func('radicalInverse_VdC', [
+                    pb.uint('bits')
+                ], function() {
+                    this.$l.n = this.bits;
+                    this.n = pb.compOr(pb.sal(this.n, 16), pb.sar(this.n, 16));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xaaaaaaaa), 1));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xcccccccc), 2));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0f0f0f0f), 4), pb.sar(pb.compAnd(this.n, 0xf0f0f0f0), 4));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00ff00ff), 8), pb.sar(pb.compAnd(this.n, 0xff00ff00), 8));
+                    this.$return(pb.mul(pb.float(this.n), 2.3283064365386963e-10));
+                });
+                pb.func('hammersley2d', [
+                    pb.int('i'),
+                    pb.int('N')
+                ], function() {
+                    this.$return(pb.vec2(pb.div(pb.float(this.i), pb.float(this.N)), this.radicalInverse_VdC(pb.uint(this.i))));
+                });
+            }
+            pb.func('generateTBN', [
+                pb.vec3('normal')
+            ], function() {
+                this.$l.bitangent = pb.vec3(0, 1, 0);
+                this.$l.NoU = this.normal.y;
+                this.$l.epsl = 0.0000001;
+                this.$if(pb.lessThanEqual(pb.sub(1, pb.abs(this.normal.y)), this.epsl), function() {
+                    this.bitangent = this.$choice(pb.greaterThan(this.normal.y, 0), pb.vec3(0, 0, 1), pb.vec3(0, 0, -1));
+                });
+                this.$l.tangent = pb.normalize(pb.cross(this.bitangent, this.normal));
+                this.bitangent = pb.cross(this.normal, this.tangent);
+                this.$return(pb.mat3(this.tangent, this.bitangent, this.normal));
+            });
+            pb.func('D_Charlie', [
+                pb.float('sheenRoughness'),
+                pb.float('NdotH')
+            ], function() {
+                this.$l.roughness = pb.max(this.sheenRoughness, 0.000001);
+                this.$l.invR = pb.div(1, this.roughness);
+                this.$l.cos2h = pb.mul(this.NdotH, this.NdotH);
+                this.$l.sin2h = pb.sub(1, this.cos2h);
+                this.$return(pb.div(pb.mul(pb.add(this.invR, 2), pb.pow(this.sin2h, pb.mul(this.invR, 0.5))), Math.PI * 2));
+            });
+            pb.func('smithGGXCorrelated', [
+                pb.float('NoV'),
+                pb.float('NoL'),
+                pb.float('roughness')
+            ], function() {
+                this.$l.a2 = pb.mul(this.roughness, this.roughness, this.roughness, this.roughness);
+                this.$l.GGXV = pb.mul(this.NoL, pb.sqrt(pb.add(pb.mul(this.NoV, this.NoV, pb.sub(1, this.a2)), this.a2)));
+                this.$l.GGXL = pb.mul(this.NoV, pb.sqrt(pb.add(pb.mul(this.NoL, this.NoL, pb.sub(1, this.a2)), this.a2)));
+                this.$return(pb.div(0.5, pb.add(this.GGXV, this.GGXL)));
+            });
+            pb.func('V_Ashikhmin', [
+                pb.float('NdotL'),
+                pb.float('NdotV')
+            ], function() {
+                this.$return(pb.clamp(pb.div(1, pb.mul(pb.sub(pb.add(this.NdotL, this.NdotV), pb.mul(this.NdotL, this.NdotV)), 4)), 0, 1));
+            });
+            pb.func('importanceSample', [
+                pb.vec2('xi'),
+                pb.vec3('normal'),
+                pb.float('roughness'),
+                pb.vec3('ggx').out(),
+                pb.vec3('charlie').out()
+            ], function() {
+                this.$l.alphaRoughness = pb.mul(this.roughness, this.roughness);
+                this.$l.cosTheta = pb.clamp(pb.sqrt(pb.div(pb.sub(1, this.xi.y), pb.add(1, pb.mul(pb.sub(pb.mul(this.alphaRoughness, this.alphaRoughness), 1), this.xi.y)))), 0, 1);
+                this.$l.sinTheta = pb.sqrt(pb.sub(1, pb.mul(this.cosTheta, this.cosTheta)));
+                this.$l.phi = pb.mul(this.xi.x, Math.PI * 2);
+                this.$l.TBN = this.generateTBN(this.normal);
+                this.$l.localSpaceDir = pb.normalize(pb.vec3(pb.mul(this.sinTheta, pb.cos(this.phi)), pb.mul(this.sinTheta, pb.sin(this.phi)), this.cosTheta));
+                this.ggx = pb.mul(this.TBN, this.localSpaceDir);
+                this.sinTheta = pb.pow(this.xi.y, pb.div(this.alphaRoughness, pb.add(pb.mul(this.alphaRoughness, 2), 1)));
+                this.cosTheta = pb.sqrt(pb.sub(1, pb.mul(this.sinTheta, this.sinTheta)));
+                this.localSpaceDir = pb.normalize(pb.vec3(pb.mul(this.sinTheta, pb.cos(this.phi)), pb.mul(this.sinTheta, pb.sin(this.phi)), this.cosTheta));
+                this.charlie = pb.mul(this.TBN, this.localSpaceDir);
+            });
+            pb.func('integrateBRDF', [
+                pb.float('NoV'),
+                pb.float('roughness')
+            ], function() {
+                this.$l.V = pb.vec3(pb.sub(1, pb.mul(this.NoV, this.NoV)), 0, this.NoV);
+                this.$l.a = pb.float(0);
+                this.$l.b = pb.float(0);
+                this.$l.c = pb.float(0);
+                this.$l.n = pb.vec3(0, 0, 1);
+                this.$for(pb.int('i'), 0, SAMPLE_COUNT, function() {
+                    this.$l.xi = this.hammersley2d(this.i, SAMPLE_COUNT);
+                    this.$l.ggxSample = pb.vec3();
+                    this.$l.charlieSample = pb.vec3();
+                    this.importanceSample(this.xi, this.n, this.roughness, this.ggxSample, this.charlieSample);
+                    this.$l.ggxL = pb.normalize(pb.reflect(pb.neg(this.V), this.ggxSample.xyz));
+                    this.$l.ggxNoL = pb.clamp(this.ggxL.z, 0, 1);
+                    this.$l.ggxNoH = pb.clamp(this.ggxSample.z, 0, 1);
+                    this.$l.ggxVoH = pb.clamp(pb.dot(this.V, this.ggxSample.xyz), 0, 1);
+                    this.$l.charlieL = pb.normalize(pb.reflect(pb.neg(this.V), this.charlieSample.xyz));
+                    this.$l.charlieNoL = pb.clamp(this.charlieL.z, 0, 1);
+                    this.$l.charlieNoH = pb.clamp(this.charlieSample.z, 0, 1);
+                    this.$l.charlieVoH = pb.clamp(pb.dot(this.V, this.charlieSample.xyz), 0, 1);
+                    this.$if(pb.greaterThan(this.ggxNoL, 0), function() {
+                        this.$l.pdf = pb.div(pb.mul(this.smithGGXCorrelated(this.NoV, this.ggxNoL, this.roughness), this.ggxVoH, this.ggxNoL), this.ggxNoH);
+                        this.$l.Fc = pb.pow(pb.sub(1, this.ggxVoH), 5);
+                        this.a = pb.add(this.a, pb.mul(pb.sub(1, this.Fc), this.pdf));
+                        this.b = pb.add(this.b, pb.mul(this.Fc, this.pdf));
+                    });
+                    this.$if(pb.greaterThan(this.charlieNoL, 0), function() {
+                        this.$l.sheenDistribution = this.D_Charlie(this.roughness, this.charlieNoH);
+                        this.$l.sheenVis = this.V_Ashikhmin(this.charlieNoL, this.NoV);
+                        this.c = pb.add(this.c, pb.mul(this.sheenVis, this.sheenDistribution, this.charlieNoL, this.charlieVoH));
+                    });
+                });
+                this.$return(pb.div(pb.vec3(pb.mul(this.a, 4), pb.mul(this.b, 4), pb.mul(this.c, 8 * Math.PI)), SAMPLE_COUNT));
+            });
+            pb.main(function() {
+                this.$outputs.color = pb.vec4(this.integrateBRDF(this.$inputs.uv.x, this.$inputs.uv.y), 1);
+            });
+        }
+    });
+    const vertexLayout = device.createVertexLayout({
+        vertexBuffers: [
+            {
+                buffer: device.createVertexBuffer('position_f32x2', new Float32Array([
+                    -1,
+                    -1,
+                    1,
+                    -1,
+                    -1,
+                    1,
+                    1,
+                    1
+                ]))
+            }
+        ]
+    });
+    const rs = device.createRenderStateSet();
+    rs.useRasterizerState().setCullMode('none');
+    rs.useDepthState().enableTest(false).enableWrite(false);
+    const tex = device.createTexture2D('rgba8unorm', size, size, {
+        samplerOptions: {
+            mipFilter: 'none'
+        }
+    });
+    tex.name = 'GGXLUT';
+    const fb = device.createFrameBuffer([
+        tex
+    ], null);
+    device.pushDeviceStates();
+    device.setProgram(program);
+    device.setVertexLayout(vertexLayout);
+    device.setRenderStates(rs);
+    device.setFramebuffer(fb);
+    device.draw('triangle-strip', 0, 4);
+    device.popDeviceStates();
+    fb.dispose();
+    vertexLayout.dispose();
+    program.dispose();
+    return tex;
+}
+
+export { getGGXLUT };
+//# sourceMappingURL=ggxlut.js.map

package/dist/utility/textures/ggxlut.js.map

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

package/dist/utility/textures/gradientnoise.js

@@ -0,0 +1,61 @@
+import { drawFullscreenQuad } from '../../render/fullscreenquad.js';
+import '@zephyr3d/device';
+import { perlinNoise3D } from '../../shaders/noise.js';
+import '../../app.js';
+
+let gradientNoiseProgram = null;
+let gradientNoiseBindGroup = null;
+/** @internal */ function createGradientNoiseTexture(device, size, uvscale, mono = false, seed = 0) {
+    if (!gradientNoiseProgram) {
+        gradientNoiseProgram = device.buildRenderProgram({
+            vertex (pb) {
+                this.$inputs.pos = pb.vec2().attrib('position');
+                this.$outputs.uv = pb.vec2();
+                pb.main(function() {
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                    this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                    if (device.type === 'webgpu') {
+                        this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                    }
+                });
+            },
+            fragment (pb) {
+                this.$outputs.color = pb.vec4();
+                this.uvScale = pb.float().uniform(0);
+                this.seed = pb.float().uniform(0);
+                this.mono = pb.int().uniform(0);
+                pb.main(function() {
+                    this.$l.p = pb.vec3(pb.mul(this.$inputs.uv, this.uvScale), this.seed);
+                    this.$l.r = perlinNoise3D(this, this.p);
+                    //this.$l.r = gradient(this, this.p.xy, this.p.z).x;
+                    this.$if(pb.notEqual(this.mono, 0), function() {
+                        this.$outputs.color = pb.vec4(pb.vec3(this.r), 1);
+                    }).$else(function() {
+                        this.$l.g = perlinNoise3D(this, pb.vec3(pb.mul(this.$inputs.uv, this.uvScale), pb.add(this.seed, 1.9)));
+                        this.$l.b = perlinNoise3D(this, pb.vec3(pb.mul(this.$inputs.uv, this.uvScale), pb.add(this.seed, 2.3)));
+                        this.$outputs.color = pb.vec4(this.r, this.g, this.b, 1);
+                    });
+                });
+            }
+        });
+        gradientNoiseBindGroup = device.createBindGroup(gradientNoiseProgram.bindGroupLayouts[0]);
+    }
+    const tex = device.createTexture2D('rgba8unorm', size, size);
+    const fb = device.createFrameBuffer([
+        tex
+    ], null);
+    gradientNoiseBindGroup.setValue('uvScale', uvscale);
+    gradientNoiseBindGroup.setValue('seed', seed);
+    gradientNoiseBindGroup.setValue('mono', mono ? 1 : 0);
+    device.pushDeviceStates();
+    device.setFramebuffer(fb);
+    device.setProgram(gradientNoiseProgram);
+    device.setBindGroup(0, gradientNoiseBindGroup);
+    drawFullscreenQuad();
+    device.popDeviceStates();
+    fb.dispose();
+    return tex;
+}
+
+export { createGradientNoiseTexture };
+//# sourceMappingURL=gradientnoise.js.map

package/dist/utility/textures/gradientnoise.js.map

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

package/dist/utility/textures/randomnoise.js

@@ -0,0 +1,41 @@
+import { drawFullscreenQuad } from '../../render/fullscreenquad.js';
+
+let randomNoiseProgram = null;
+/** @internal */ function createRandomNoiseTexture(device, size) {
+    if (!randomNoiseProgram) {
+        randomNoiseProgram = device.buildRenderProgram({
+            vertex (pb) {
+                this.$inputs.pos = pb.vec2().attrib('position');
+                this.$outputs.uv = pb.vec2();
+                pb.main(function() {
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                    this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                    if (device.type === 'webgpu') {
+                        this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                    }
+                });
+            },
+            fragment (pb) {
+                this.$outputs.color = pb.vec4();
+                pb.main(function() {
+                    this.$l.noise = pb.fract(pb.mul(pb.sin(pb.dot(this.$inputs.uv, pb.vec2(12.9898, 78.233))), 43758.5453));
+                    this.$outputs.color = pb.vec4(pb.vec3(this.noise), 1);
+                });
+            }
+        });
+    }
+    const tex = device.createTexture2D('rgba8unorm', size, size);
+    const fb = device.createFrameBuffer([
+        tex
+    ], null);
+    device.pushDeviceStates();
+    device.setFramebuffer(fb);
+    device.setProgram(randomNoiseProgram);
+    drawFullscreenQuad();
+    device.popDeviceStates();
+    fb.dispose();
+    return tex;
+}
+
+export { createRandomNoiseTexture };
+//# sourceMappingURL=randomnoise.js.map

package/dist/utility/textures/randomnoise.js.map

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

package/dist/values.js

@@ -63,6 +63,13 @@
 /** @internal */ const MAX_MORPH_TARGETS = 256;
 /** @internal */ const MORPH_WEIGHTS_VECTOR_COUNT = MAX_MORPH_TARGETS + 3 >> 2;
 /** @internal */ const MORPH_ATTRIBUTE_VECTOR_COUNT = MAX_MORPH_ATTRIBUTES + 3 >> 2;
+var MaterialVaryingFlags;
+(function(MaterialVaryingFlags) {
+    MaterialVaryingFlags[MaterialVaryingFlags["MORPH_ANIMATION"] = 1] = "MORPH_ANIMATION";
+    MaterialVaryingFlags[MaterialVaryingFlags["SKIN_ANIMATION"] = 2] = "SKIN_ANIMATION";
+    MaterialVaryingFlags[MaterialVaryingFlags["INSTANCING"] = 4] = "INSTANCING";
+    MaterialVaryingFlags[MaterialVaryingFlags["SSR_STORE_ROUGHNESS"] = 8] = "SSR_STORE_ROUGHNESS";
+})(MaterialVaryingFlags || (MaterialVaryingFlags = {}));
 
-export { BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP };
+export { BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MaterialVaryingFlags, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP };
 //# sourceMappingURL=values.js.map