@zephyr3d/scene 0.3.1 → 0.5.0

package/dist/shaders/lighting.js

@@ -38,10 +38,14 @@ import { Application } from '../app.js';
             pb.vec3('attenuation')
         ], function() {
             this.$l.dist = pb.distance(this.lightPositionRange.xyz, ShaderFramework.getWorldPosition(this).xyz);
-            this.$l.falloff = pb.max(0, pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)));
-            this.$l.falloff2 = pb.mul(this.falloff, this.falloff);
-            this.$if(pb.greaterThan(this.falloff2, 0), function() {
-                lm.directBRDF(this, this.lightDir, pb.mul(this.attenuation, this.falloff2));
+            this.$l.a = pb.div(1, pb.add(1, pb.mul(this.dist, this.dist)));
+            this.$l.falloff = pb.mul(this.a, pb.clamp(pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)), 0, 1));
+            //this.$l.t = pb.div(pb.mul(this.dist, 16), this.lightPositionRange.w);
+            //this.$l.falloff = pb.div(1, pb.add(1, pb.mul(this.t, this.t)));
+            //this.$l.falloff = pb.div(1, )   pb.max(0, pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)));
+            //this.falloff = pb.mul(this.falloff, this.falloff);
+            this.$if(pb.greaterThan(this.falloff, 0), function() {
+                lm.directBRDF(this, this.lightDir, pb.mul(this.attenuation, this.falloff));
             });
         });
         pb.getGlobalScope()[funcNameIllumPointLight](...args);
@@ -166,12 +170,12 @@ import { Application } from '../app.js';
             this.lightDir = this.directionCutoff.xyz;
             this.$l.nl = pb.dot(this.surfaceData.normal, this.lightDir);
             this.$l.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-            this.shadowBound = pb.vec4(0, 0, 1, 1);
-            this.linearDepth = nonLinearDepthToLinear(this, this.$builtins.fragCoord.z);
-            this.splitDistances = ShaderFramework.getCascadeDistances(this);
-            this.comparison = pb.vec4(pb.greaterThan(pb.vec4(this.linearDepth), this.splitDistances));
-            this.cascadeFlags = pb.vec4(pb.float(pb.greaterThan(this.shadowCascades, 0)), pb.float(pb.greaterThan(this.shadowCascades, 1)), pb.float(pb.greaterThan(this.shadowCascades, 2)), pb.float(pb.greaterThan(this.shadowCascades, 3)));
-            this.split = pb.int(pb.dot(this.comparison, this.cascadeFlags));
+            this.$l.shadowBound = pb.vec4(0, 0, 1, 1);
+            this.$l.linearDepth = nonLinearDepthToLinear(this, this.$builtins.fragCoord.z);
+            this.$l.splitDistances = ShaderFramework.getCascadeDistances(this);
+            this.$l.comparison = pb.vec4(pb.greaterThan(pb.vec4(this.linearDepth), this.splitDistances));
+            this.$l.cascadeFlags = pb.vec4(pb.float(pb.greaterThan(this.shadowCascades, 0)), pb.float(pb.greaterThan(this.shadowCascades, 1)), pb.float(pb.greaterThan(this.shadowCascades, 2)), pb.float(pb.greaterThan(this.shadowCascades, 3)));
+            this.$l.split = pb.int(pb.dot(this.comparison, this.cascadeFlags));
             this.$l.shadowVertex = pb.vec4();
             if (Application.instance.device.type === 'webgl') {
                 this.$for(pb.int('cascade'), 0, 4, function() {

package/dist/shaders/lighting.js.map

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

package/dist/shaders/water.js

@@ -12,13 +12,13 @@ import { Application } from '../app.js';
             this.$outputs.uv2 = pb.vec2();
             this.flip = pb.int().uniform(0);
             this.viewProjMatrix = pb.mat4().uniform(0);
-            this.modelMatrix = pb.mat4().uniform(0);
-            this.gridScale = pb.float().uniform(0);
+            this.modelMatrix = pb.mat4().uniform(1);
+            this.gridScale = pb.float().uniform(1);
             this.level = pb.float().uniform(0);
             this.sizes = pb.vec4().uniform(0);
             this.croppinesses = pb.vec4().uniform(0);
-            this.offset = pb.vec2().uniform(0);
-            this.scale = pb.float().uniform(0);
+            this.offset = pb.vec2().uniform(1);
+            this.scale = pb.float().uniform(1);
             this.dx_hy_dz_dxdz0 = pb.tex2D().uniform(0);
             this.sx_sz_dxdx_dzdz0 = pb.tex2D().uniform(0);
             this.dx_hy_dz_dxdz1 = pb.tex2D().uniform(0);

package/dist/shadow/esm.js

@@ -5,23 +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/material.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;
@@ -133,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);
@@ -162,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,24 +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 { 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/material.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '@zephyr3d/device';
-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());
@@ -289,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;
@@ -345,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);
@@ -353,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);
     }

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,25 +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 { ShaderHelper } from '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/material.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '@zephyr3d/device';
-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;
@@ -192,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);
@@ -218,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/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/sheenlut.js

@@ -0,0 +1,196 @@
+import { Vector3, Vector2 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+
+const bits = new Uint32Array(1);
+//Van der Corput radical inverse
+function radicalInverse_VdC(i) {
+    bits[0] = i;
+    bits[0] = (bits[0] << 16 | bits[0] >> 16) >>> 0;
+    bits[0] = (bits[0] & 0x55555555) << 1 | (bits[0] & 0xaaaaaaaa) >>> 1 >>> 0;
+    bits[0] = (bits[0] & 0x33333333) << 2 | (bits[0] & 0xcccccccc) >>> 2 >>> 0;
+    bits[0] = (bits[0] & 0x0f0f0f0f) << 4 | (bits[0] & 0xf0f0f0f0) >>> 4 >>> 0;
+    bits[0] = (bits[0] & 0x00ff00ff) << 8 | (bits[0] & 0xff00ff00) >>> 8 >>> 0;
+    return bits[0] * 2.3283064365386963e-10; // / 0x100000000 or / 4294967296
+}
+function hammersley(i, iN, out) {
+    out.setXY(i * iN, radicalInverse_VdC(i));
+}
+function distributionCharlie(NdotH, roughness) {
+    // roughness = Math.max(roughness, 0.000001);
+    const invAlpha = 1 / roughness;
+    const cos2h = NdotH * NdotH;
+    const sin2h = 1 - cos2h;
+    return (2 + invAlpha) * Math.pow(sin2h, invAlpha * 0.5) / (2 * Math.PI);
+}
+function visibilityAshikhmin(NdotV, NdotL) {
+    return Math.min(Math.max(1 / (4 * (NdotL + NdotV - NdotL * NdotV)), 0), 1);
+}
+function hemisphereUniformSample(u, out) {
+    const phi = 2 * Math.PI * u.x;
+    const cosTheta = 1 - u.y;
+    const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+    out.setXYZ(sinTheta * Math.cos(phi), sinTheta * Math.sin(phi), cosTheta);
+}
+function dfvCharlieUniform(NdotV, roughness, numSamples) {
+    let r = 0;
+    const V = new Vector3(Math.sqrt(1 - NdotV * NdotV), 0, NdotV);
+    const u = new Vector2();
+    const H = new Vector3();
+    const L = new Vector3();
+    for(let i = 0; i < numSamples; i++){
+        hammersley(i, 1 / numSamples, u);
+        hemisphereUniformSample(u, H);
+        Vector3.scale(H, Vector3.dot(V, H) * 2, L).subBy(V);
+        const VdotH = Math.min(Math.max(Vector3.dot(V, H), 0), 1);
+        const NdotL = Math.min(Math.max(L.z, 0), 1);
+        const NdotH = Math.min(Math.max(H.z, 0), 1);
+        if (NdotL > 0) {
+            const v = visibilityAshikhmin(NdotV, NdotL);
+            // const v = visibilityCharlie(NdotV, NdotL, roughness);
+            const d = distributionCharlie(NdotH, roughness);
+            r += v * d * NdotL * VdotH;
+        }
+    }
+    return r * (4 * 2 * Math.PI / numSamples);
+}
+const _tables = function _generateTables() {
+    // float32 to float16 helpers
+    const buffer = new ArrayBuffer(4);
+    const floatView = new Float32Array(buffer);
+    const uint32View = new Uint32Array(buffer);
+    const baseTable = new Uint32Array(512);
+    const shiftTable = new Uint32Array(512);
+    for(let i = 0; i < 256; ++i){
+        const e = i - 127;
+        // very small number (0, -0)
+        if (e < -27) {
+            baseTable[i] = 0x0000;
+            baseTable[i | 0x100] = 0x8000;
+            shiftTable[i] = 24;
+            shiftTable[i | 0x100] = 24;
+        // small number (denorm)
+        } else if (e < -14) {
+            baseTable[i] = 0x0400 >> -e - 14;
+            baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
+            shiftTable[i] = -e - 1;
+            shiftTable[i | 0x100] = -e - 1;
+        // normal number
+        } else if (e <= 15) {
+            baseTable[i] = e + 15 << 10;
+            baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
+            shiftTable[i] = 13;
+            shiftTable[i | 0x100] = 13;
+        // large number (Infinity, -Infinity)
+        } else if (e < 128) {
+            baseTable[i] = 0x7c00;
+            baseTable[i | 0x100] = 0xfc00;
+            shiftTable[i] = 24;
+            shiftTable[i | 0x100] = 24;
+        // stay (NaN, Infinity, -Infinity)
+        } else {
+            baseTable[i] = 0x7c00;
+            baseTable[i | 0x100] = 0xfc00;
+            shiftTable[i] = 13;
+            shiftTable[i | 0x100] = 13;
+        }
+    }
+    // float16 to float32 helpers
+    const mantissaTable = new Uint32Array(2048);
+    const exponentTable = new Uint32Array(64);
+    const offsetTable = new Uint32Array(64);
+    for(let i = 1; i < 1024; ++i){
+        let m = i << 13; // zero pad mantissa bits
+        let e = 0; // zero exponent
+        // normalized
+        while((m & 0x00800000) === 0){
+            m <<= 1;
+            e -= 0x00800000; // decrement exponent
+        }
+        m &= ~0x00800000; // clear leading 1 bit
+        e += 0x38800000; // adjust bias
+        mantissaTable[i] = m | e;
+    }
+    for(let i = 1024; i < 2048; ++i){
+        mantissaTable[i] = 0x38000000 + (i - 1024 << 13);
+    }
+    for(let i = 1; i < 31; ++i){
+        exponentTable[i] = i << 23;
+    }
+    exponentTable[31] = 0x47800000;
+    exponentTable[32] = 0x80000000;
+    for(let i = 33; i < 63; ++i){
+        exponentTable[i] = 0x80000000 + (i - 32 << 23);
+    }
+    exponentTable[63] = 0xc7800000;
+    for(let i = 1; i < 64; ++i){
+        if (i !== 32) {
+            offsetTable[i] = 1024;
+        }
+    }
+    return {
+        floatView: floatView,
+        uint32View: uint32View,
+        baseTable: baseTable,
+        shiftTable: shiftTable,
+        mantissaTable: mantissaTable,
+        exponentTable: exponentTable,
+        offsetTable: offsetTable
+    };
+}();
+function encodeF16(val) {
+    val = Math.min(Math.max(val, -65504), 65504);
+    _tables.floatView[0] = val;
+    const f = _tables.uint32View[0];
+    const e = f >> 23 & 0x1ff;
+    return _tables.baseTable[e] + ((f & 0x007fffff) >> _tables.shiftTable[e]);
+}
+/*
+function decodeF16(val: number) {
+  const exponent = (val & 0x7c00) >> 10;
+  const fraction = val & 0x03ff;
+  return (
+    (val >> 15 ? -1 : 1) *
+    (exponent
+      ? exponent === 0x1f
+        ? fraction
+          ? NaN
+          : Infinity
+        : Math.pow(2, exponent - 15) * (1 + fraction / 0x400)
+      : 6.103515625e-5 * (fraction / 0x400))
+  );
+}
+*/ async function createSheenLUT(textureSize, texture) {
+    if (texture) {
+        if (!texture.isTexture2D()) {
+            throw new Error('can not reload sheen lut texture: invalid texture type');
+        }
+        if (texture.format !== 'rgba16f') {
+            throw new Error('can not reload sheen lut texture: invalid texture format');
+        }
+        if (texture.width !== textureSize || texture.height !== textureSize) {
+            throw new Error('can not reload sheen lut texture: invalid texture size');
+        }
+    }
+    const tex = texture || Application.instance.device.createTexture2D('rgba16f', textureSize, textureSize);
+    const image = new Uint16Array(textureSize * textureSize * 4);
+    let p = 0;
+    const one = encodeF16(1);
+    for(let y = textureSize - 1; y >= 0; y--){
+        const coord = Math.min(Math.max((y + 0.5) / textureSize, 0), 1);
+        const roughness = coord * coord;
+        for(let x = 0; x < textureSize; x++){
+            const NdotV = Math.min(Math.max((x + 0.5) / textureSize, 0), 1);
+            const c = dfvCharlieUniform(NdotV, roughness, 512);
+            const f16 = encodeF16(c);
+            image[p++] = 0;
+            image[p++] = 0;
+            image[p++] = f16;
+            image[p++] = one;
+        }
+    }
+    tex.update(image, 0, 0, textureSize, textureSize);
+    return tex;
+}
+
+export { createSheenLUT };
+//# sourceMappingURL=sheenlut.js.map

package/dist/utility/sheenlut.js.map

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

package/dist/values.js

@@ -10,6 +10,10 @@
  * Depth only render pass type
  * @public
  */ const RENDER_PASS_TYPE_DEPTH = 2;
+/**
+ * Object color render pass type
+ * @public
+ */ const RENDER_PASS_TYPE_OBJECT_COLOR = 3;
 /**
  * Builtin texture name for sheen LUT
  * @public
@@ -46,6 +50,19 @@
  * Transparent render queue type
  * @public
  */ const QUEUE_TRANSPARENT = 2;
+// Morph target attributes
+/** @internal */ const MORPH_TARGET_POSITION = 0;
+/** @internal */ const MORPH_TARGET_NORMAL = 1;
+/** @internal */ const MORPH_TARGET_TANGENT = 2;
+/** @internal */ const MORPH_TARGET_COLOR = 3;
+/** @internal */ const MORPH_TARGET_TEX0 = 4;
+/** @internal */ const MORPH_TARGET_TEX1 = 5;
+/** @internal */ const MORPH_TARGET_TEX2 = 6;
+/** @internal */ const MORPH_TARGET_TEX3 = 7;
+/** @internal */ const MAX_MORPH_ATTRIBUTES = 8;
+/** @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;
 
-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, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, 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, 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

package/dist/values.js.map

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