@zephyr3d/scene 0.5.0 → 0.6.0

package/dist/animation/animationset.js

@@ -1,9 +1,9 @@
 import { weightedAverage } from '@zephyr3d/base';
 import { Application } from '../app.js';
 
-/**
- * Animation set
- * @public
+/**
+ * Animation set
+ * @public
  */ class AnimationSet {
     /** @internal */ _model;
     /** @internal */ _animations;
@@ -11,9 +11,9 @@ import { Application } from '../app.js';
     /** @internal */ _activeTracks;
     /** @internal */ _activeSkeletons;
     /** @internal */ _activeAnimations;
-    /**
-   * Creates an instance of AnimationSet
-   * @param scene - The scene to which the animation set belongs
+    /**
+   * Creates an instance of AnimationSet
+   * @param scene - The scene to which the animation set belongs
    */ constructor(scene, model){
         this._scene = scene;
         this._model = model;
@@ -23,30 +23,30 @@ import { Application } from '../app.js';
         this._activeSkeletons = new Map();
         this._activeAnimations = new Map();
     }
-    /**
-   * How many animations in this set
+    /**
+   * How many animations in this set
    */ get numAnimations() {
         return Object.getOwnPropertyNames(this._animations).length;
     }
-    /**
-   * Gets an animation clip by name
-   * @param name - name of the animation to get
+    /**
+   * Gets an animation clip by name
+   * @param name - name of the animation to get
    */ get(name) {
         return this._animations[name] ?? null;
     }
-    /**
-   * Adds an animation
+    /**
+   * Adds an animation
    */ add(animation) {
         this._animations[animation.name] = animation;
     }
-    /**
-   * Gets names of all the animations of the model
-   * @returns An array of string that contains the animation names
+    /**
+   * Gets names of all the animations of the model
+   * @returns An array of string that contains the animation names
    */ getAnimationNames() {
         return Object.keys(this._animations);
     }
-    /**
-   * Updates all animations of the model
+    /**
+   * Updates all animations of the model
    */ update() {
         this._activeAnimations.forEach((v, k)=>{
             if (v.fadeOut > 0 && v.fadeOutStart < 0) {
@@ -102,26 +102,26 @@ import { Application } from '../app.js';
             k.apply();
         });
     }
-    /**
-   * Checks whether an animation is playing
-   * @param name - Name of the animation to be checked
-   * @returns true if the animation is playing, otherwise false
+    /**
+   * Checks whether an animation is playing
+   * @param name - Name of the animation to be checked
+   * @returns true if the animation is playing, otherwise false
    */ isPlayingAnimation(name) {
         return name ? this._activeAnimations.has(this._animations[name]) : this._activeAnimations.size > 0;
     }
-    /**
-   * Gets the weight of specific animation which is currently playing
-   * @param name - Name of the animation
-   * @returns Weight of the animation or 0 if this animation is not playing
+    /**
+   * Gets the weight of specific animation which is currently playing
+   * @param name - Name of the animation
+   * @returns Weight of the animation or 0 if this animation is not playing
    */ getAnimationWeight(name) {
         const ani = this._animations[name];
         const info = this._activeAnimations.get(ani);
         return info?.weight ?? 0;
     }
-    /**
-   * Sets the weight of specific animation which is currently playing
-   * @param name - Name of the animation
-   * @param weight - New weight value
+    /**
+   * Sets the weight of specific animation which is currently playing
+   * @param name - Name of the animation
+   * @param weight - New weight value
    */ setAnimationWeight(name, weight) {
         const ani = this._animations[name];
         const info = this._activeAnimations.get(ani);
@@ -129,10 +129,10 @@ import { Application } from '../app.js';
             info.weight = weight;
         }
     }
-    /**
-   * Starts playing an animation of the model
-   * @param name - Name of the animation to play
-   * @param options - Playing options
+    /**
+   * Starts playing an animation of the model
+   * @param name - Name of the animation to play
+   * @param options - Playing options
    */ playAnimation(name, options) {
         const ani = this._animations[name];
         if (!ani) {
@@ -186,9 +186,9 @@ import { Application } from '../app.js';
             });
         }
     }
-    /**
-   * Stops playing an animation of the model
-   * @param name - Name of the animation to stop playing
+    /**
+   * Stops playing an animation of the model
+   * @param name - Name of the animation to stop playing
    */ stopAnimation(name, options) {
         const ani = this._animations[name];
         const info = this._activeAnimations.get(ani);

package/dist/animation/morphtrack.js

@@ -4,6 +4,8 @@ import '../utility/panorama.js';
 import '../utility/shprojection.js';
 import { Vector3 } from '@zephyr3d/base';
 import { BoundingBox } from '../utility/bounding_volume.js';
+import '../app.js';
+import '@zephyr3d/device';
 import { MAX_MORPH_TARGETS } from '../values.js';
 import { calculateMorphBoundingBox } from './morphtarget.js';
 
@@ -12,6 +14,7 @@ import { calculateMorphBoundingBox } from './morphtarget.js';
  * @public
  */ class MorphTargetTrack extends AnimationTrack {
     _state;
+    _originBox;
     _boundingBox;
     _defaultWeights;
     /**
@@ -24,6 +27,7 @@ import { calculateMorphBoundingBox } from './morphtarget.js';
             weights: new Float32Array(MAX_MORPH_TARGETS)
         };
         this._boundingBox = subMesh.targetBox;
+        this._originBox = subMesh.mesh.getBoundingVolume().toAABB();
         this._defaultWeights = assetTrack.defaultMorphWeights ?? Array.from({
             length: this._state.numTargets
         }).map(()=>0);
@@ -35,11 +39,9 @@ import { calculateMorphBoundingBox } from './morphtarget.js';
     }
     applyState(node, state) {
         node.getMorphInfo().bufferSubData(4 * 4, state.weights);
-        const animatedBoundingBox = new BoundingBox();
-        const originBoundingBox = node.getBoundingVolume().toAABB();
-        animatedBoundingBox.minPoint = Vector3.add(originBoundingBox.minPoint, state.boundingBox.minPoint);
-        animatedBoundingBox.maxPoint = Vector3.add(originBoundingBox.maxPoint, state.boundingBox.maxPoint);
-        node.setAnimatedBoundingBox(animatedBoundingBox);
+        state.boundingBox.minPoint.addBy(this._originBox.minPoint);
+        state.boundingBox.maxPoint.addBy(this._originBox.maxPoint);
+        node.setAnimatedBoundingBox(state.boundingBox);
     }
     mixState(a, b, t) {
         const state = {

package/dist/animation/morphtrack.js.map

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

package/dist/animation/skeleton.js

@@ -4,6 +4,7 @@ import '../utility/pmrem.js';
 import '../utility/panorama.js';
 import '../utility/shprojection.js';
 import { BoundingBox } from '../utility/bounding_volume.js';
+import '@zephyr3d/device';
 
 const tmpV0 = new Vector3();
 const tmpV1 = new Vector3();
@@ -62,17 +63,21 @@ const tmpV3 = new Vector3();
    */ get jointTexture() {
         return this._jointTexture;
     }
-    /** @internal */ updateJointMatrices(jointTransforms) {
+    /** @internal */ updateJointMatrices(jointTransforms, worldMatrix) {
         if (!this._jointTexture) {
             this._createJointTexture();
         }
         for(let i = 0; i < this._joints.length; i++){
             const mat = this._jointMatrices[i];
-            Matrix4x4.multiply(jointTransforms ? jointTransforms[i] : this._joints[i].worldMatrix, this._inverseBindMatrices[i], mat);
+            const jointTransform = jointTransforms ? jointTransforms[i] : this._joints[i].worldMatrix;
+            if (worldMatrix) {
+                Matrix4x4.multiplyAffine(worldMatrix, jointTransform, jointTransform);
+            }
+            Matrix4x4.multiply(jointTransform, this._inverseBindMatrices[i], mat);
         }
     }
-    /** @internal */ computeBindPose() {
-        this.updateJointMatrices(this._bindPoseMatrices);
+    /** @internal */ computeBindPose(model) {
+        this.updateJointMatrices(this._bindPoseMatrices, model.worldMatrix);
         this._jointTexture.update(this._jointMatrixArray, 0, 0, this._jointTexture.width, this._jointTexture.height);
     }
     /** @internal */ computeJoints() {
@@ -84,17 +89,14 @@ const tmpV3 = new Vector3();
         for (const mesh of this._meshes){
             this.computeBoundingBox(mesh.bounding, mesh.mesh.invWorldMatrix);
             mesh.mesh.setBoneMatrices(this.jointTexture);
-            mesh.mesh.setInvBindMatrix(mesh.mesh.invWorldMatrix);
             mesh.mesh.setAnimatedBoundingBox(mesh.bounding.boundingBox);
         }
     }
     /** @internal */ reset(model) {
-        this.computeBindPose();
+        this.computeBindPose(model);
         for (const mesh of this._meshes){
-            const invWorldMatrix = Matrix4x4.multiply(mesh.mesh.invWorldMatrix, model.worldMatrix);
-            this.computeBoundingBox(mesh.bounding, invWorldMatrix);
+            this.computeBoundingBox(mesh.bounding, mesh.mesh.invWorldMatrix);
             mesh.mesh.setBoneMatrices(this.jointTexture);
-            mesh.mesh.setInvBindMatrix(invWorldMatrix);
             mesh.mesh.setAnimatedBoundingBox(mesh.bounding.boundingBox);
         }
     }

package/dist/animation/skeleton.js.map

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

package/dist/asset/assetmanager.js

@@ -73,8 +73,8 @@ import { processMorphData } from '../animation/morphtarget.js';
    */ purgeCache() {
         for(const k in this._textures){
             this._textures[k].then((tex)=>tex?.dispose()).catch((err)=>{});
-            delete this._textures[k];
         }
+        this._textures = {};
         this._models = {};
         this._binaryDatas = {};
         this._textDatas = {};
@@ -417,7 +417,7 @@ import { processMorphData } from '../animation/morphtarget.js';
         if (loader) {
             this._builtinTextureLoaders[name] = loader;
         } else {
-            delete this._builtinTextureLoaders[name];
+            this._builtinTextureLoaders[name] = undefined;
         }
     }
     /** @internal */ setAssetNodeToSceneNode(scene, parent, model, assetNode, skeletonMeshMap, nodeMap, instancing) {

package/dist/asset/loaders/gltf/gltf_loader.js

@@ -8,12 +8,12 @@ import '../../../material/blinn.js';
 import { UnlitMaterial } from '../../../material/unlit.js';
 import '@zephyr3d/device';
 import { MORPH_TARGET_POSITION, MORPH_TARGET_NORMAL, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_TARGET_COLOR } from '../../../values.js';
+import { Application } from '../../../app.js';
 import '../../../material/meshmaterial.js';
 import '../../../material/grassmaterial.js';
 import '../../../material/terrainmaterial.js';
 import { PBRMetallicRoughnessMaterial } from '../../../material/pbrmr.js';
 import { PBRSpecularGlossinessMaterial } from '../../../material/pbrsg.js';
-import { Application } from '../../../app.js';
 import { GLTFAccessor, ComponentType } from './helpers.js';
 import { AbstractModelLoader } from '../loader.js';
 import { DracoMeshDecoder } from '../../../utility/draco/decoder.js';
@@ -265,8 +265,12 @@ import { DracoMeshDecoder } from '../../../utility/draco/decoder.js';
             if (animationData.nodes.indexOf(targetNode) < 0) {
                 animationData.nodes.push(targetNode);
             }
-            if (targetNode.skeletonAttached && animationData.skeletons.indexOf(targetNode.skeletonAttached) < 0) {
-                animationData.skeletons.push(targetNode.skeletonAttached);
+            if (targetNode.skeletonAttached) {
+                for (const skeleton of targetNode.skeletonAttached){
+                    if (animationData.skeletons.indexOf(skeleton) < 0) {
+                        animationData.skeletons.push(skeleton);
+                    }
+                }
             }
         }
         return animationData;

package/dist/asset/loaders/gltf/gltf_loader.js.map

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

package/dist/asset/loaders/image/webimage_loader.js

@@ -37,6 +37,22 @@ import { Application } from '../../../app.js';
                     } else {
                         reject('create texture from image element failed');
                     }
+                }).catch((reason)=>{
+                    const cvs = document.createElement('canvas');
+                    cvs.width = img.width;
+                    cvs.height = img.height;
+                    const ctx = cvs.getContext('2d');
+                    ctx.drawImage(img, 0, 0);
+                    const options = {
+                        texture: texture,
+                        samplerOptions
+                    };
+                    const tex = Application.instance.device.createTexture2DFromImage(cvs, srgb, options);
+                    if (tex) {
+                        resolve(tex);
+                    } else {
+                        reject('create texture from image element failed');
+                    }
                 });
             };
             img.onerror = (err)=>{

package/dist/asset/loaders/image/webimage_loader.js.map

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

package/dist/asset/model.js

@@ -23,7 +23,6 @@ import { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';
     _mesh;
     _skeleton;
     _attachToSkeleton;
-    _attachIndex;
     _meshAttached;
     _matrix;
     _worldMatrix;
@@ -45,7 +44,6 @@ import { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';
         this._skeleton = null;
         this._attachToSkeleton = null;
         this._meshAttached = false;
-        this._attachIndex = -1;
         this._matrix = null;
         this._weights = null;
         this._worldMatrix = null;
@@ -110,9 +108,6 @@ import { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';
     /** The skeleton to which the node belongs if this is a joint node */ get skeletonAttached() {
         return this._attachToSkeleton;
     }
-    /** The joint index if this is a joint node */ get attachIndex() {
-        return this._attachIndex;
-    }
     /** @internal */ computeTransforms(parentTransform) {
         this._matrix = Matrix4x4.scaling(this._scaling).rotateLeft(this._rotation).translateLeft(this._position);
         this._worldMatrix = parentTransform ? Matrix4x4.multiply(parentTransform, this._matrix) : new Matrix4x4(this._matrix);
@@ -149,11 +144,10 @@ import { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';
    * @param skeleton - The skeleton to which to node will attach
    * @param index - The joint index
    */ attachToSkeleton(skeleton, index) {
-        if (this._attachToSkeleton && skeleton !== this._attachToSkeleton) {
-            throw new Error(`joint can not attached to multiple skeletons`);
+        if (!this._attachToSkeleton) {
+            this._attachToSkeleton = new Set();
         }
-        this._attachToSkeleton = skeleton;
-        this._attachIndex = index;
+        this._attachToSkeleton.add(skeleton);
     }
     /** @internal */ setMeshAttached() {
         this._meshAttached = true;

package/dist/asset/model.js.map

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

package/dist/blitter/bilateralblur.js

@@ -0,0 +1,222 @@
+import { Blitter } from './blitter.js';
+import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
+import '../app.js';
+import { Vector2 } from '@zephyr3d/base';
+import { fetchSampler } from '../utility/misc.js';
+
+/**
+ * Bilateral blur blitter
+ * @public
+ */ class BilateralBlurBlitter extends Blitter {
+    _depthTex;
+    _sampler;
+    _blurSizeTex;
+    _blurSizeScale;
+    _blurSizeIndex;
+    _kernelRadius;
+    _cameraNearFar;
+    _depthCutoff;
+    _stepSize;
+    _uvStep;
+    _size;
+    _stdDev;
+    _offsetsAndWeights;
+    _finalPhase;
+    constructor(finalPhase){
+        super();
+        this._depthTex = null;
+        this._depthCutoff = 2;
+        this._blurSizeTex = null;
+        this._blurSizeScale = 1;
+        this._blurSizeIndex = 0;
+        this._sampler = null;
+        this._blurSizeTex = null;
+        this._kernelRadius = 8;
+        this._cameraNearFar = Vector2.zero();
+        this._size = Vector2.zero();
+        this._stdDev = 2;
+        this._offsetsAndWeights = new Float32Array(4 * (this._kernelRadius + 1));
+        this._finalPhase = !!finalPhase;
+        this._stepSize = 1;
+        this._uvStep = this._finalPhase ? new Vector2(1, 0) : new Vector2(0, 1);
+        this.calcGaussion();
+    }
+    get depthTex() {
+        return this._depthTex;
+    }
+    set depthTex(tex) {
+        this._depthTex = tex;
+    }
+    get blurSizeTex() {
+        return this._blurSizeTex;
+    }
+    set blurSizeTex(tex) {
+        this._blurSizeTex = tex;
+    }
+    get blurSizeIndex() {
+        return this._blurSizeIndex;
+    }
+    set blurSizeIndex(val) {
+        this._blurSizeIndex = val;
+    }
+    get blurSizeScale() {
+        return this._blurSizeScale;
+    }
+    set blurSizeScale(val) {
+        this._blurSizeScale = val;
+    }
+    get sampler() {
+        return this._sampler;
+    }
+    set sampler(sampler) {
+        this._sampler = sampler;
+    }
+    get cameraNearFar() {
+        return this._cameraNearFar;
+    }
+    set cameraNearFar(v) {
+        this._cameraNearFar.set(v);
+    }
+    get depthCutoff() {
+        return this._depthCutoff;
+    }
+    set depthCutoff(val) {
+        this._depthCutoff = val;
+    }
+    get size() {
+        return this._size;
+    }
+    set size(val) {
+        this._size.set(val);
+    }
+    get stepSize() {
+        return this._stepSize;
+    }
+    set stepSize(val) {
+        if (val !== this._stepSize) {
+            this._stepSize = val;
+            this.calcGaussion();
+        }
+    }
+    get stdDev() {
+        return this._stdDev;
+    }
+    set stdDev(val) {
+        if (val !== this._stdDev) {
+            this._stdDev = val;
+            this.calcGaussion();
+        }
+    }
+    get kernelRadius() {
+        return this._kernelRadius;
+    }
+    set kernelRadius(val) {
+        val = Math.max(val, 0) >> 0;
+        if (val !== this._kernelRadius) {
+            this._kernelRadius = val;
+            this._offsetsAndWeights = new Float32Array(4 * (this._kernelRadius + 1));
+            this.calcGaussion();
+            this.invalidateHash();
+        }
+    }
+    calcHash() {
+        return `${Number(!!this._blurSizeTex)}:${this._blurSizeIndex}:${this._kernelRadius}:${this._finalPhase}`;
+    }
+    calcGaussion() {
+        const kernel = [];
+        const size = this.kernelRadius * 2 + 1;
+        let sum = 0;
+        for(let x = 0; x < size; x++){
+            const value = 1 / (Math.sqrt(2 * Math.PI) * this._stdDev) * Math.exp(-((x - this.kernelRadius) ** 2) / (2 * this._stdDev ** 2));
+            kernel.push(value);
+            sum += value;
+        }
+        for(let i = 0; i <= this.kernelRadius; i++){
+            this._offsetsAndWeights[i * 4] = this._uvStep.x * i;
+            this._offsetsAndWeights[i * 4 + 1] = this._uvStep.y * i;
+            this._offsetsAndWeights[i * 4 + 2] = kernel[this.kernelRadius - i] / sum;
+            this._offsetsAndWeights[i * 4 + 3] = this._stepSize;
+        }
+    }
+    setup(scope, type) {
+        super.setup(scope, type);
+        const pb = scope.$builder;
+        if (pb.shaderKind === 'fragment') {
+            scope.depthTex = pb.tex2D().uniform(0);
+            if (this._blurSizeTex) {
+                scope.blurSizeTex = pb.tex2D().uniform(0);
+                scope.blurSizeScale = pb.float().uniform(0);
+            }
+            scope.depthCutoff = pb.float().uniform(0);
+            scope.offsetsAndWeights = pb.vec4[this._kernelRadius + 1]().uniform(0);
+            scope.cameraNearFar = pb.vec2().uniform(0);
+            scope.size = pb.vec2().uniform(0);
+        }
+    }
+    setUniforms(bindGroup, sourceTex) {
+        super.setUniforms(bindGroup, sourceTex);
+        bindGroup.setTexture('depthTex', this._depthTex, this._sampler ?? fetchSampler('clamp_nearest_nomip'));
+        if (this._blurSizeTex) {
+            bindGroup.setTexture('blurSizeTex', this._blurSizeTex, fetchSampler('clamp_linear_nomip'));
+            bindGroup.setValue('blurSizeScale', this._blurSizeScale);
+        }
+        bindGroup.setValue('depthCutoff', this._depthCutoff);
+        bindGroup.setValue('offsetsAndWeights', this._offsetsAndWeights);
+        bindGroup.setValue('cameraNearFar', this._cameraNearFar);
+        bindGroup.setValue('size', this._size);
+    }
+    filter(scope, type, srcTex, srcUV, srcLayer, sampleType) {
+        const that = this;
+        const pb = scope.$builder;
+        pb.func('getLinearDepth', [
+            pb.vec2('uv')
+        ], function() {
+            this.$l.depthValue = pb.textureSample(this.depthTex, this.uv);
+            this.$l.depth01 = pb.getDevice().type === 'webgl' ? decodeNormalizedFloatFromRGBA(this, this.depthValue) : this.depthValue.r;
+            this.$return(pb.mul(this.depth01, this.cameraNearFar.y));
+        });
+        pb.func('getLogDepth', [
+            pb.float('linearDepth')
+        ], function() {
+            this.$return(pb.log(pb.add(this.linearDepth, 1)));
+        });
+        scope.centerDepth = scope.getLogDepth(scope.getLinearDepth(srcUV));
+        scope.depthDiff = pb.div(scope.depthCutoff, pb.sub(scope.getLogDepth(scope.cameraNearFar.y), scope.getLogDepth(scope.cameraNearFar.x)));
+        scope.weightSum = scope.offsetsAndWeights[0].z;
+        scope.srcTexel = that.readTexel(scope, type, srcTex, srcUV, srcLayer, sampleType);
+        scope.colorSum = pb.mul(scope.srcTexel, scope.weightSum);
+        if (that._blurSizeTex) {
+            scope.blurSize = pb.textureSample(scope.blurSizeTex, srcUV)['rgba'[this._blurSizeIndex]];
+        }
+        scope.$for(pb.int('i'), 0, that._kernelRadius, function() {
+            this.$l.offsetAndWeight = this.offsetsAndWeights.at(pb.add(this.i, 1));
+            this.$l.weight = this.offsetAndWeight.z;
+            this.$l.offset = this.offsetAndWeight.xy;
+            if (that._blurSizeTex) {
+                this.offset = pb.mul(this.offset, this.blurSize, this.blurSizeScale);
+            }
+            this.$l.offset = pb.div(this.offset, this.size);
+            this.$l.uvRight = pb.add(srcUV, this.offset);
+            this.$l.depthRight = this.getLogDepth(this.getLinearDepth(this.uvRight));
+            this.$if(pb.lessThan(pb.abs(pb.sub(this.depthRight, this.centerDepth)), this.depthDiff), function() {
+                this.$l.srcTexelRight = that.readTexel(this, type, srcTex, this.uvRight, srcLayer, sampleType);
+                this.$l.colorWeight = pb.mul(this.weight, pb.exp(pb.neg(pb.distance(this.srcTexelRight.rgb, this.srcTexel.rgb))));
+                this.colorSum = pb.add(this.colorSum, pb.mul(this.srcTexelRight, this.colorWeight));
+                this.weightSum = pb.add(this.weightSum, this.colorWeight);
+            });
+            this.$l.uvLeft = pb.sub(srcUV, this.offset);
+            this.$l.depthLeft = this.getLogDepth(this.getLinearDepth(this.uvLeft));
+            this.$if(pb.lessThan(pb.abs(pb.sub(this.depthLeft, this.centerDepth)), this.depthDiff), function() {
+                this.$l.srcTexelLeft = that.readTexel(this, type, srcTex, this.uvLeft, srcLayer, sampleType);
+                this.$l.colorWeight = pb.mul(this.weight, pb.exp(pb.neg(pb.distance(this.srcTexelLeft.rgb, this.srcTexel.rgb))));
+                this.colorSum = pb.add(this.colorSum, pb.mul(this.srcTexelLeft, this.colorWeight));
+                this.weightSum = pb.add(this.weightSum, this.colorWeight);
+            });
+        });
+        scope.colorSum = pb.div(scope.colorSum, scope.weightSum);
+        return scope.colorSum;
+    }
+}
+
+export { BilateralBlurBlitter };
+//# sourceMappingURL=bilateralblur.js.map

package/dist/{render/temporalcache.js.map → blitter/bilateralblur.js.map}

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

package/dist/blitter/blitter.js

@@ -90,7 +90,7 @@ import { linearToGamma } from '../shaders/misc.js';
    * @returns The read texel
    */ readTexel(scope, type, srcTex, uv, srcLayer, sampleType) {
         const pb = scope.$builder;
-        if (sampleType === 'float') {
+        if (sampleType === 'float' || sampleType === 'depth') {
             switch(type){
                 case '2d':
                 case 'cube':
@@ -318,6 +318,8 @@ function createBlitProgram(type, filter, bilinearFiltering, st, flip, scaleBias)
                         this.srcTex = pb.itex2D().sampleType('sint').uniform(0);
                     } else if (st === 'uint') {
                         this.srcTex = pb.utex2D().sampleType('uint').uniform(0);
+                    } else if (st === 'depth') {
+                        this.srcTex = pb.tex2DShadow().uniform(0);
                     } else {
                         this.srcTex = pb.tex2D().sampleType(bilinearFiltering ? 'float' : 'unfilterable-float').uniform(0);
                     }
@@ -327,6 +329,8 @@ function createBlitProgram(type, filter, bilinearFiltering, st, flip, scaleBias)
                         this.srcTex = pb.itex2DArray().sampleType('sint').uniform(0);
                     } else if (st === 'uint') {
                         this.srcTex = pb.utex2DArray().sampleType('uint').uniform(0);
+                    } else if (st === 'depth') {
+                        this.srcTex = pb.tex2DArrayShadow().uniform(0);
                     } else {
                         this.srcTex = pb.tex2DArray().sampleType(bilinearFiltering ? 'float' : 'unfilterable-float').uniform(0);
                     }
@@ -337,6 +341,8 @@ function createBlitProgram(type, filter, bilinearFiltering, st, flip, scaleBias)
                         this.srcTex = pb.itexCube().sampleType('sint').uniform(0);
                     } else if (st === 'uint') {
                         this.srcTex = pb.utexCube().sampleType('uint').uniform(0);
+                    } else if (st === 'depth') {
+                        this.srcTex = pb.texCubeShadow().uniform(0);
                     } else {
                         this.srcTex = pb.texCube().sampleType(bilinearFiltering ? 'float' : 'unfilterable-float').uniform(0);
                     }

package/dist/blitter/blitter.js.map

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