@zephyr3d/scene 0.4.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/esm.js

@@ -5,22 +5,9 @@ import '@zephyr3d/device';
 import { decodeNormalizedFloatFromRGBA, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
 import { GaussianBlurBlitter } from '../blitter/gaussianblur.js';
 import { computeShadowMapDepth, filterShadowESM } from '../shaders/shadow.js';
-import '../scene/octree.js';
 import { LIGHT_TYPE_POINT } from '../values.js';
+import { ShadowMapper } from './shadowmapper.js';
 import { ShaderHelper } from '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '../render/renderer.js';
-import '../render/sky.js';
-import '../render/clipmap.js';
-import { TemporalCache } from '../render/temporalcache.js';
-import '../render/watermesh.js';
 
 class BlurBlitter extends GaussianBlurBlitter {
     _packFloat;
@@ -132,13 +119,12 @@ class BlurBlitter extends GaussianBlurBlitter {
         };
         shadowMapParams.implData = implData;
         const colorFormat = this.getShadowMapColorFormat(shadowMapParams);
-        const target = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].target;
         const shadowMapWidth = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].width;
         const shadowMapHeight = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].height;
         if (this._blur) {
             shadowMapParams.implData = {
-                blurFramebuffer: TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, shadowMapParams.numShadowCascades, colorFormat, null, target, null, false),
-                blurFramebuffer2: TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, shadowMapParams.numShadowCascades, colorFormat, null, target, null, this._mipmap)
+                blurFramebuffer: ShadowMapper.fetchTemporalFramebuffer(true, shadowMapParams.lightType, shadowMapParams.numShadowCascades, shadowMapWidth, shadowMapHeight, colorFormat, null, false),
+                blurFramebuffer2: ShadowMapper.fetchTemporalFramebuffer(true, shadowMapParams.lightType, shadowMapParams.numShadowCascades, shadowMapWidth, shadowMapHeight, colorFormat, null, true)
             };
         }
         shadowMapParams.shadowMap = this.getShadowMap(shadowMapParams);
@@ -161,11 +147,7 @@ class BlurBlitter extends GaussianBlurBlitter {
         }
     }
     releaseTemporalResources(shadowMapParams) {
-        const implData = shadowMapParams.implData;
-        if (implData) {
-            TemporalCache.releaseFramebuffer(implData.blurFramebuffer);
-            TemporalCache.releaseFramebuffer(implData.blurFramebuffer2);
-        }
+        return;
     }
     getDepthScale() {
         return this._depthScale;

package/dist/shadow/esm.js.map

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

package/dist/shadow/shadowmapper.js

@@ -6,23 +6,8 @@ import { VSM } from './vsm.js';
 import { PCFPD } from './pcf_pd.js';
 import { PCFOPT } from './pcf_opt.js';
 import { Application } from '../app.js';
-import '../scene/octree.js';
-import { LIGHT_TYPE_NONE, LIGHT_TYPE_DIRECTIONAL } from '../values.js';
-import '@zephyr3d/device';
+import { LIGHT_TYPE_NONE, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT } from '../values.js';
 import { ShaderHelper } from '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '../render/renderer.js';
-import '../render/sky.js';
-import '../render/clipmap.js';
-import { TemporalCache } from '../render/temporalcache.js';
-import '../render/watermesh.js';
 
 const tmpMatrix = new Matrix4x4();
 const tmpFrustum = new Frustum(Matrix4x4.identity());
@@ -65,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;
@@ -288,7 +273,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         if (ctx.shadowMapInfo) {
             for (const k of ctx.shadowMapInfo.keys()){
                 const shadowMapParams = ctx.shadowMapInfo.get(k);
-                TemporalCache.releaseFramebuffer(shadowMapParams.shadowMapFramebuffer);
+                ctx.device.pool.releaseFrameBuffer(shadowMapParams.shadowMapFramebuffer);
                 shadowMapParams.impl.releaseTemporalResources(shadowMapParams);
                 shadowMapParams.lightType = LIGHT_TYPE_NONE;
                 shadowMapParams.depthClampEnabled = false;
@@ -344,6 +329,26 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                 return null;
         }
     }
+    /** @internal */ static fetchTemporalFramebuffer(autoRelease, lightType, numCascades, width, height, colorFormat, depthFormat, mipmapping) {
+        const device = Application.instance.device;
+        const useTextureArray = numCascades > 1 && device.type !== 'webgl';
+        const colorAttachments = colorFormat ? useTextureArray ? [
+            device.pool.fetchTemporalTexture2DArray(false, colorFormat, width, height, numCascades, mipmapping)
+        ] : lightType === LIGHT_TYPE_POINT ? [
+            device.pool.fetchTemporalTextureCube(false, colorFormat, width, mipmapping)
+        ] : [
+            device.pool.fetchTemporalTexture2D(false, colorFormat, width, height, mipmapping)
+        ] : null;
+        const depthAttachment = depthFormat ? useTextureArray ? device.pool.fetchTemporalTexture2DArray(false, depthFormat, width, height, numCascades, false) : device.type !== 'webgl' && lightType === LIGHT_TYPE_POINT ? device.pool.fetchTemporalTextureCube(false, depthFormat, width, false) : device.pool.fetchTemporalTexture2D(false, depthFormat, width, height, false) : null;
+        const fb = device.pool.createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment);
+        if (colorAttachments) {
+            device.pool.releaseTexture(colorAttachments[0]);
+        }
+        if (depthAttachment) {
+            device.pool.releaseTexture(depthAttachment);
+        }
+        return fb;
+    }
     /** @internal */ updateResources(shadowMapParams) {
         const device = Application.instance.device;
         const colorFormat = shadowMapParams.impl.getShadowMapColorFormat(shadowMapParams);
@@ -352,9 +357,29 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         const useTextureArray = numCascades > 1 && device.type !== 'webgl';
         const shadowMapWidth = numCascades > 1 && !useTextureArray ? 2 * this._config.shadowMapSize : this._config.shadowMapSize;
         const shadowMapHeight = numCascades > 2 && !useTextureArray ? 2 * this._config.shadowMapSize : this._config.shadowMapSize;
-        const colorTarget = useTextureArray ? '2darray' : this._light.isPointLight() ? 'cube' : '2d';
-        const depthTarget = device.type === 'webgl' ? '2d' : colorTarget;
-        shadowMapParams.shadowMapFramebuffer = TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, numCascades, colorFormat, depthFormat, colorTarget, depthTarget, false, 1);
+        /*
+    const colorAttachments = colorFormat
+      ? useTextureArray
+        ? [device.pool.fetchTemporalTexture2DArray(false, colorFormat, shadowMapWidth, shadowMapHeight, numCascades, false)]
+        : this._light.isPointLight()
+          ? [device.pool.fetchTemporalTextureCube(false, colorFormat, shadowMapWidth, false)]
+          : [device.pool.fetchTemporalTexture2D(false, colorFormat, shadowMapWidth, shadowMapHeight, false)]
+      : null;
+    const depthAttachment = depthFormat
+      ? useTextureArray
+        ? device.pool.fetchTemporalTexture2DArray(false, depthFormat, shadowMapWidth, shadowMapHeight, numCascades, false)
+        : device.type !== 'webgl' && this._light.isPointLight()
+          ? device.pool.fetchTemporalTextureCube(false, depthFormat, shadowMapWidth, false)
+          : device.pool.fetchTemporalTexture2D(false, depthFormat, shadowMapWidth, shadowMapHeight, false)
+      : null;
+    shadowMapParams.shadowMapFramebuffer = device.pool.createTemporalFramebuffer(false, colorAttachments, depthAttachment);
+    if (colorAttachments) {
+      device.pool.releaseTexture(colorAttachments[0]);
+    }
+    if (depthAttachment) {
+      device.pool.releaseTexture(depthAttachment);
+    }
+    */ shadowMapParams.shadowMapFramebuffer = ShadowMapper.fetchTemporalFramebuffer(false, this._light.lightType, numCascades, shadowMapWidth, shadowMapHeight, colorFormat, depthFormat);
         shadowMapParams.impl = this._impl;
         this._impl.updateResources(shadowMapParams);
     }
@@ -410,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) {
@@ -550,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);
@@ -582,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));
@@ -617,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;
@@ -673,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/shadow/shadowmapper.js.map

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

package/dist/shadow/vsm.js

@@ -4,24 +4,8 @@ import { decodeNormalizedFloatFromRGBA, decode2HalfFromRGBA, encode2HalfToRGBA }
 import { Application } from '../app.js';
 import { computeShadowMapDepth, filterShadowVSM } from '../shaders/shadow.js';
 import { ShadowMapper } from './shadowmapper.js';
-import '@zephyr3d/base';
-import '../scene/octree.js';
 import { LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
-import '@zephyr3d/device';
 import { ShaderHelper } from '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '../render/renderer.js';
-import '../render/sky.js';
-import '../render/clipmap.js';
-import { TemporalCache } from '../render/temporalcache.js';
-import '../render/watermesh.js';
 
 class VSMBlitter extends Blitter {
     _phase;
@@ -191,13 +175,13 @@ class VSMBlitter extends Blitter {
     }
     doUpdateResources(shadowMapParams) {
         const colorFormat = this.getShadowMapColorFormat(shadowMapParams);
-        const target = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].target;
+        //const target = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].target;
         const shadowMapWidth = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].width;
         const shadowMapHeight = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].height;
         if (this._blur) {
             shadowMapParams.implData = {
-                blurFramebuffer: TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, shadowMapParams.numShadowCascades, colorFormat, null, target, null, false),
-                blurFramebuffer2: TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, shadowMapParams.numShadowCascades, colorFormat, null, target, null, this._mipmap)
+                blurFramebuffer: ShadowMapper.fetchTemporalFramebuffer(true, shadowMapParams.lightType, shadowMapParams.numShadowCascades, shadowMapWidth, shadowMapHeight, colorFormat, null, false),
+                blurFramebuffer2: ShadowMapper.fetchTemporalFramebuffer(true, shadowMapParams.lightType, shadowMapParams.numShadowCascades, shadowMapWidth, shadowMapHeight, colorFormat, null, this._mipmap)
             };
         }
         shadowMapParams.shadowMap = this.getShadowMap(shadowMapParams);
@@ -217,11 +201,7 @@ class VSMBlitter extends Blitter {
         }
     }
     releaseTemporalResources(shadowMapParams) {
-        const implData = shadowMapParams.implData;
-        if (implData) {
-            TemporalCache.releaseFramebuffer(implData.blurFramebuffer);
-            TemporalCache.releaseFramebuffer(implData.blurFramebuffer2);
-        }
+        return;
     }
     getShaderHash() {
         return '';

package/dist/shadow/vsm.js.map

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

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/draco/decoder.js

@@ -0,0 +1,116 @@
+class DracoMeshDecoder {
+    _module;
+    _decoder;
+    _mesh;
+    constructor(data, decoderModule){
+        this._module = decoderModule;
+        this._decoder = new this._module.Decoder();
+        const buffer = new this._module.DecoderBuffer();
+        buffer.Init(data, data.byteLength);
+        const geometryType = this._decoder.GetEncodedGeometryType(buffer);
+        if (geometryType !== this._module.TRIANGULAR_MESH) {
+            this._module.destroy(buffer);
+            this._module.destroy(this._decoder);
+            this._decoder = null;
+            throw new Error(`Unsupported geometry type: ${geometryType}`);
+        }
+        this._mesh = new this._module.Mesh();
+        const status = this._decoder.DecodeBufferToMesh(buffer, this._mesh);
+        this._module.destroy(buffer);
+        if (!status.ok() || this._mesh.ptr === 0) {
+            this._module.destroy(this._decoder);
+            this._decoder = null;
+            this._module.destroy(this._mesh);
+            this._mesh = null;
+            throw new Error(status.error_msg());
+        }
+    }
+    getIndexBuffer() {
+        if (!this._decoder || !this._mesh) {
+            return null;
+        }
+        const numFaces = this._mesh.num_faces();
+        const numIndices = numFaces * 3;
+        // Uint32
+        const indexBuffer = new Uint32Array(numIndices);
+        const ptr = this._module._malloc(indexBuffer.byteLength);
+        this._decoder.GetTrianglesUInt32Array(this._mesh, indexBuffer.byteLength, ptr);
+        const tmpBuffer = new Uint32Array(this._module.HEAPU32.buffer, ptr, numIndices);
+        indexBuffer.set(tmpBuffer);
+        this._module._free(ptr);
+        return indexBuffer;
+    }
+    getAttributeBuffer(id, buffer) {
+        if (!this._decoder || !this._mesh) {
+            return null;
+        }
+        const attribute = this._decoder.GetAttributeByUniqueId(this._mesh, id);
+        if (!attribute) {
+            return null;
+        }
+        const numComponents = attribute.num_components();
+        const numPoints = this._mesh.num_points();
+        const numValues = numPoints * numComponents;
+        if (buffer.length !== numValues) {
+            console.error(`getAttributeBuffer(): buffer length must be ${numValues}`);
+            return null;
+        }
+        const ptr = this._module._malloc(buffer.byteLength);
+        this._decoder.GetAttributeDataArrayForAllPoints(this._mesh, attribute, this.getDracoDataType(buffer), buffer.byteLength, ptr);
+        const tmpBuffer = new buffer.constructor(this.getDracoHeap(buffer).buffer, ptr, numValues);
+        buffer.set(tmpBuffer);
+        this._module._free(ptr);
+        return buffer;
+    }
+    getDracoDataType(buffer) {
+        if (buffer instanceof Float32Array) {
+            return this._module.DT_FLOAT32;
+        }
+        if (buffer instanceof Int8Array) {
+            return this._module.DT_INT8;
+        }
+        if (buffer instanceof Int16Array) {
+            return this._module.DT_INT16;
+        }
+        if (buffer instanceof Int32Array) {
+            return this._module.DT_INT32;
+        }
+        if (buffer instanceof Uint8Array) {
+            return this._module.DT_UINT8;
+        }
+        if (buffer instanceof Uint16Array) {
+            return this._module.DT_UINT16;
+        }
+        if (buffer instanceof Uint32Array) {
+            return this._module.DT_UINT32;
+        }
+        throw new Error(`getDracoDataType(): invalid buffer type`);
+    }
+    getDracoHeap(buffer) {
+        if (buffer instanceof Float32Array) {
+            return this._module.HEAPF32;
+        }
+        if (buffer instanceof Int8Array) {
+            return this._module.HEAP8;
+        }
+        if (buffer instanceof Int16Array) {
+            return this._module.HEAP16;
+        }
+        if (buffer instanceof Int32Array) {
+            return this._module.HEAP32;
+        }
+        if (buffer instanceof Uint8Array) {
+            return this._module.HEAPU8;
+        }
+        if (buffer instanceof Uint16Array) {
+            return this._module.HEAPU16;
+        }
+        if (buffer instanceof Uint32Array) {
+            return this._module.HEAPU32;
+        }
+        throw new Error(`getDracoHeap(): invalid buffer type`);
+    }
+}
+
+export { DracoMeshDecoder };
+//# sourceMappingURL=decoder.js.map

package/dist/utility/draco/decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}