@zephyr3d/scene 0.1.2 → 0.2.0

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/utility/shprojection.js

@@ -1,7 +1,6 @@
 import { Vector3, halfToFloat, unpackFloat3, SH, nextPowerOf2 } from '@zephyr3d/base';
 import { Application } from '../app.js';
 import { Blitter } from '../blitter/blitter.js';
-import '../shaders/framework.js';
 import '@zephyr3d/device';
 import { CopyBlitter } from '../blitter/copy.js';
 

package/dist/utility/shprojection.js.map

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

package/dist/values.js

@@ -1,7 +1,7 @@
 /**
  * Forward render pass type
  * @public
- */ const RENDER_PASS_TYPE_FORWARD = 0;
+ */ const RENDER_PASS_TYPE_LIGHT = 0;
 /**
  * Shadow map render pass type
  * @public
@@ -9,12 +9,7 @@
 /**
  * Depth only render pass type
  * @public
- */ const RENDER_PASS_TYPE_DEPTH_ONLY = 2;
-/**
- * Max light count for forward rendering
- * @internal
- */ const MAX_FORWARD_LIGHT_COUNT = 8;
-/** @internal */ const DEBUG_CASCADED_SHADOW_MAPS = false;
+ */ const RENDER_PASS_TYPE_DEPTH = 2;
 /**
  * Builtin texture name for sheen LUT
  * @public
@@ -43,6 +38,14 @@
  * Max light size for clustered lighting
  * @public
  */ const MAX_CLUSTERED_LIGHTS = 255;
+/**
+ * Opaque render queue type
+ * @public
+ */ const QUEUE_OPAQUE = 1;
+/**
+ * Transparent render queue type
+ * @public
+ */ const QUEUE_TRANSPARENT = 2;
 
-export { BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, DEBUG_CASCADED_SHADOW_MAPS, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, MAX_FORWARD_LIGHT_COUNT, RENDER_PASS_TYPE_DEPTH_ONLY, RENDER_PASS_TYPE_FORWARD, 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, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zephyr3d/scene",
-	"version": "0.1.2",
+	"version": "0.2.0",
 	"description": "scene system for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
@@ -45,7 +45,7 @@
 		"@rollup/pluginutils": "^5.0.2",
 		"@swc/core": "^1.3.62",
 		"@zephyr3d/base": "^0.1.2",
-		"@zephyr3d/device": "^0.1.2",
+		"@zephyr3d/device": "^0.2.0",
 		"cross-env": "^7.0.3",
 		"rollup": "^3.15.0",
 		"rollup-plugin-copy": "^3.4.0",
@@ -57,7 +57,7 @@
 	},
 	"peerDependencies": {
 		"@zephyr3d/base": "^0.1.2",
-		"@zephyr3d/device": "^0.1.2"
+		"@zephyr3d/device": "^0.2.0"
 	},
 	"dependencies": {
 		"@webgpu/types": "^0.1.31"