@zephyr3d/scene 0.1.0 → 0.1.2

package/dist/asset/builtin.js

@@ -2,13 +2,13 @@ import { Vector4, Vector3, Vector2 } from '@zephyr3d/base';
 import { BUILTIN_ASSET_TEXTURE_SHEEN_LUT } from '../values.js';
 import { Application } from '../app.js';
 
-/*
-interface MicrofacetDistributionSample {
-  pdf?: number;
-  cosTheta?: number;
-  sinTheta?: number;
-  phi?: number;
-}
+/*
+interface MicrofacetDistributionSample {
+  pdf?: number;
+  cosTheta?: number;
+  sinTheta?: number;
+  phi?: number;
+}
 */ /** @internal */ function getTestCubemapLoader() {
     return async function(assetManager) {
         const tex = Application.instance.device.createCubeTexture('rgba8unorm', 32, {
@@ -53,57 +53,57 @@ interface MicrofacetDistributionSample {
     function hammersley(i, iN, out) {
         out.setXY(i * iN, radicalInverse_VdC(i));
     }
-    /*
-  function hammersley(i: number, iN: number, out: Vector2) {
-    const tof = 0.5 / 0x80000000;
-    let bits = i;
-    bits = (bits << 16) | (bits >>> 16);
-    bits = ((bits & 0x55555555) << 1) | ((bits & 0xAAAAAAAA) >>> 1);
-    bits = ((bits & 0x33333333) << 2) | ((bits & 0xCCCCCCCC) >>> 2);
-    bits = ((bits & 0x0F0F0F0F) << 4) | ((bits & 0xF0F0F0F0) >>> 4);
-    bits = ((bits & 0x00FF00FF) << 8) | ((bits & 0xFF00FF00) >>> 8);
-    out.setXY(i * iN, (bits >>> 0) * tof);
-  }
-  */ /*
-  function generateTBN(normal: Vector3, out: Matrix3x3) {
-    bitangent.setXYZ(0.0, 1.0, 0.0);
-    const NdotUp = Vector3.dot(normal, up);
-    const epsilon = 0.0000001;
-    if (1.0 - Math.abs(NdotUp) <= epsilon) {
-      // Sampling +Y or -Y, so we need a more robust bitangent.
-      if (NdotUp > 0.0) {
-        bitangent.setXYZ(0.0, 0.0, 1.0);
-      } else {
-        bitangent.setXYZ(0.0, 0.0, -1.0);
-      }
-    }
-    Vector3.cross(bitangent, normal, tangent).inplaceNormalize();
-    Vector3.cross(normal, tangent, bitangent);
-    out.setCol(0, tangent);
-    out.setCol(1, bitangent);
-    out.setCol(2, normal);
-  }
-  function mix(x: number, y: number, a: number): number {
-    return x * (1 - a) + y * a;
-  }
-  function l(x: number, alphaG: number): number {
-    const oneMinusAlphaSq = (1 - alphaG) * (1 - alphaG);
-    const a = mix(21.5473, 25.3245, oneMinusAlphaSq);
-    const b = mix(3.82987, 3.32435, oneMinusAlphaSq);
-    const c = mix(0.19823, 0.16801, oneMinusAlphaSq);
-    const d = mix(-1.9776, -1.27393, oneMinusAlphaSq);
-    const e = mix(-4.32054, -4.85967, oneMinusAlphaSq);
-    return a / (1 + b * Math.pow(x, c)) + d * x + e;
-  }
-  function lambdaSheen(cosTheta: number, alphaG: number): number {
-    return Math.abs(cosTheta) < 0.5
-      ? Math.exp(l(Math.abs(cosTheta), alphaG))
-      : Math.exp(2 * l(0.5, alphaG) - l(1 - Math.abs(cosTheta), alphaG));
-  }
-  function visibilityCharlie(NdotV: number, NdotL: number, a: number): number {
-    const alphaG = a;
-    return 1 / ((1 + lambdaSheen(NdotV, alphaG) + lambdaSheen(NdotL, alphaG)) * (4 * NdotV * NdotL));
-  }
+    /*
+  function hammersley(i: number, iN: number, out: Vector2) {
+    const tof = 0.5 / 0x80000000;
+    let bits = i;
+    bits = (bits << 16) | (bits >>> 16);
+    bits = ((bits & 0x55555555) << 1) | ((bits & 0xAAAAAAAA) >>> 1);
+    bits = ((bits & 0x33333333) << 2) | ((bits & 0xCCCCCCCC) >>> 2);
+    bits = ((bits & 0x0F0F0F0F) << 4) | ((bits & 0xF0F0F0F0) >>> 4);
+    bits = ((bits & 0x00FF00FF) << 8) | ((bits & 0xFF00FF00) >>> 8);
+    out.setXY(i * iN, (bits >>> 0) * tof);
+  }
+  */ /*
+  function generateTBN(normal: Vector3, out: Matrix3x3) {
+    bitangent.setXYZ(0.0, 1.0, 0.0);
+    const NdotUp = Vector3.dot(normal, up);
+    const epsilon = 0.0000001;
+    if (1.0 - Math.abs(NdotUp) <= epsilon) {
+      // Sampling +Y or -Y, so we need a more robust bitangent.
+      if (NdotUp > 0.0) {
+        bitangent.setXYZ(0.0, 0.0, 1.0);
+      } else {
+        bitangent.setXYZ(0.0, 0.0, -1.0);
+      }
+    }
+    Vector3.cross(bitangent, normal, tangent).inplaceNormalize();
+    Vector3.cross(normal, tangent, bitangent);
+    out.setCol(0, tangent);
+    out.setCol(1, bitangent);
+    out.setCol(2, normal);
+  }
+  function mix(x: number, y: number, a: number): number {
+    return x * (1 - a) + y * a;
+  }
+  function l(x: number, alphaG: number): number {
+    const oneMinusAlphaSq = (1 - alphaG) * (1 - alphaG);
+    const a = mix(21.5473, 25.3245, oneMinusAlphaSq);
+    const b = mix(3.82987, 3.32435, oneMinusAlphaSq);
+    const c = mix(0.19823, 0.16801, oneMinusAlphaSq);
+    const d = mix(-1.9776, -1.27393, oneMinusAlphaSq);
+    const e = mix(-4.32054, -4.85967, oneMinusAlphaSq);
+    return a / (1 + b * Math.pow(x, c)) + d * x + e;
+  }
+  function lambdaSheen(cosTheta: number, alphaG: number): number {
+    return Math.abs(cosTheta) < 0.5
+      ? Math.exp(l(Math.abs(cosTheta), alphaG))
+      : Math.exp(2 * l(0.5, alphaG) - l(1 - Math.abs(cosTheta), alphaG));
+  }
+  function visibilityCharlie(NdotV: number, NdotL: number, a: number): number {
+    const alphaG = a;
+    return 1 / ((1 + lambdaSheen(NdotV, alphaG) + lambdaSheen(NdotL, alphaG)) * (4 * NdotV * NdotL));
+  }
   */ function distributionCharlie(NdotH, roughness) {
         // roughness = Math.max(roughness, 0.000001);
         const invAlpha = 1 / roughness;
@@ -111,90 +111,90 @@ interface MicrofacetDistributionSample {
         const sin2h = 1 - cos2h;
         return (2 + invAlpha) * Math.pow(sin2h, invAlpha * 0.5) / (2 * Math.PI);
     }
-    /*
-  function charlie(xi: Vector2, roughness: number, sample: MicrofacetDistributionSample) {
-    const alpha = roughness * roughness;
-    sample.sinTheta = Math.pow(xi.y, alpha / (2 * alpha + 1));
-    sample.cosTheta = Math.sqrt(1 - sample.sinTheta * sample.sinTheta);
-    sample.phi = 2 * Math.PI * xi.x;
-    sample.pdf = distributionCharlie(sample.cosTheta, Math.max(alpha, 0.000001)) / 4;
-  }
-  function getImportanceSample(
-    sampleIndex: number,
-    sampleCount: number,
-    N: Vector3,
-    roughness: number,
-    out: Vector4
-  ) {
-    // generate a quasi monte carlo point in the unit square [0.1)^2
-    hammersley(sampleIndex, 1 / sampleCount, xi);
-    // generate the points on the hemisphere with a fitting mapping for
-    // the distribution (e.g. lambertian uses a cosine importance)
-    charlie(xi, roughness, importanceSample);
-
-    // transform the hemisphere sample to the normal coordinate frame
-    // i.e. rotate the hemisphere to the normal direction
-    localSpaceDirection
-      .setXYZ(
-        importanceSample.sinTheta * Math.cos(importanceSample.phi),
-        importanceSample.sinTheta * Math.sin(importanceSample.phi),
-        importanceSample.cosTheta
-      )
-      .inplaceNormalize();
-    generateTBN(N, TBN);
-    TBN.transform(localSpaceDirection, direction);
-    out.setXYZW(direction.x, direction.y, direction.z, importanceSample.pdf);
-  }
-  function lut(NdotV: number, roughness: number, numSamples: number, out: Vector4) {
-    V.setXYZ(Math.sqrt(1 - NdotV * NdotV), 0, NdotV);
-    N.setXYZ(0, 0, 1);
-    const A = 0;
-    const B = 0;
-    let C = 0;
-    const importanceSample = new Vector4();
-    for (let i = 0; i < numSamples; i++) {
-      getImportanceSample(i, numSamples, N, roughness, importanceSample);
-      H.setXYZ(importanceSample.x, importanceSample.y, importanceSample.z);
-      // do reflect L = normalize(reflect(-V, H)) = normalize(-V - 2.0 * dot(H, -V) * H) = normalize(2 * dot(H, V) * H - V)
-      Vector3.scale(H, Vector3.dot(V, H) * 2, L)
-        .subBy(V)
-        .inplaceNormalize();
-      const NdotL = Math.min(Math.max(L.z, 0), 1);
-      const NdotH = Math.min(Math.max(H.z, 0), 1);
-      const VdotH = Math.min(Math.max(Vector3.dot(V, H), 0), 1);
-      if (NdotL > 0) {
-        const sheenDistribution = distributionCharlie(NdotH, roughness);
-        // const sheenVisibility = visibilityAshikhmin(NdotV, NdotL);
-        const sheenVisibility = visibilityCharlie(NdotV, NdotL, roughness);
-        C += sheenVisibility * sheenDistribution * NdotL * VdotH;
-      }
-    }
-    out.setXYZW(4 * A, 4 * B, 4 * 2 * Math.PI * C, 0).scaleBy(1 / numSamples);
-  }
-
-  async function createSheenLUT(): Promise<Texture2D> {
-    const tex = Application.instance.device.createTexture2D('rgba8unorm', textureSize, textureSize);
-    const image = new Uint8Array(textureSize * textureSize * 4);
-    let p = 0;
-    const c = new Vector4();
-    for (let y = 0; y < textureSize; y++) {
-      const coord = Math.min(Math.max((y + 0.5) / textureSize, 0), 1);
-      const roughness = 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, 1024);
-        // const c = Math.min(Math.max(Math.round(t * 255), 0), 255);
-        lut(NdotV, roughness, 1024, c);
-        image[p++] = Math.min(Math.max(Math.round(c.x * 255), 0), 255);
-        image[p++] = Math.min(Math.max(Math.round(c.y * 255), 0), 255);
-        image[p++] = Math.min(Math.max(Math.round(c.z * 255), 0), 255);
-        image[p++] = 255;
-      }
-    }
-    tex.update(image, 0, 0, textureSize, textureSize);
-    tex.name = `builtin:${BUILTIN_ASSET_TEXTURE_SHEEN_LUT}`;
-    return tex;
-  }
+    /*
+  function charlie(xi: Vector2, roughness: number, sample: MicrofacetDistributionSample) {
+    const alpha = roughness * roughness;
+    sample.sinTheta = Math.pow(xi.y, alpha / (2 * alpha + 1));
+    sample.cosTheta = Math.sqrt(1 - sample.sinTheta * sample.sinTheta);
+    sample.phi = 2 * Math.PI * xi.x;
+    sample.pdf = distributionCharlie(sample.cosTheta, Math.max(alpha, 0.000001)) / 4;
+  }
+  function getImportanceSample(
+    sampleIndex: number,
+    sampleCount: number,
+    N: Vector3,
+    roughness: number,
+    out: Vector4
+  ) {
+    // generate a quasi monte carlo point in the unit square [0.1)^2
+    hammersley(sampleIndex, 1 / sampleCount, xi);
+    // generate the points on the hemisphere with a fitting mapping for
+    // the distribution (e.g. lambertian uses a cosine importance)
+    charlie(xi, roughness, importanceSample);
+
+    // transform the hemisphere sample to the normal coordinate frame
+    // i.e. rotate the hemisphere to the normal direction
+    localSpaceDirection
+      .setXYZ(
+        importanceSample.sinTheta * Math.cos(importanceSample.phi),
+        importanceSample.sinTheta * Math.sin(importanceSample.phi),
+        importanceSample.cosTheta
+      )
+      .inplaceNormalize();
+    generateTBN(N, TBN);
+    TBN.transform(localSpaceDirection, direction);
+    out.setXYZW(direction.x, direction.y, direction.z, importanceSample.pdf);
+  }
+  function lut(NdotV: number, roughness: number, numSamples: number, out: Vector4) {
+    V.setXYZ(Math.sqrt(1 - NdotV * NdotV), 0, NdotV);
+    N.setXYZ(0, 0, 1);
+    const A = 0;
+    const B = 0;
+    let C = 0;
+    const importanceSample = new Vector4();
+    for (let i = 0; i < numSamples; i++) {
+      getImportanceSample(i, numSamples, N, roughness, importanceSample);
+      H.setXYZ(importanceSample.x, importanceSample.y, importanceSample.z);
+      // do reflect L = normalize(reflect(-V, H)) = normalize(-V - 2.0 * dot(H, -V) * H) = normalize(2 * dot(H, V) * H - V)
+      Vector3.scale(H, Vector3.dot(V, H) * 2, L)
+        .subBy(V)
+        .inplaceNormalize();
+      const NdotL = Math.min(Math.max(L.z, 0), 1);
+      const NdotH = Math.min(Math.max(H.z, 0), 1);
+      const VdotH = Math.min(Math.max(Vector3.dot(V, H), 0), 1);
+      if (NdotL > 0) {
+        const sheenDistribution = distributionCharlie(NdotH, roughness);
+        // const sheenVisibility = visibilityAshikhmin(NdotV, NdotL);
+        const sheenVisibility = visibilityCharlie(NdotV, NdotL, roughness);
+        C += sheenVisibility * sheenDistribution * NdotL * VdotH;
+      }
+    }
+    out.setXYZW(4 * A, 4 * B, 4 * 2 * Math.PI * C, 0).scaleBy(1 / numSamples);
+  }
+
+  async function createSheenLUT(): Promise<Texture2D> {
+    const tex = Application.instance.device.createTexture2D('rgba8unorm', textureSize, textureSize);
+    const image = new Uint8Array(textureSize * textureSize * 4);
+    let p = 0;
+    const c = new Vector4();
+    for (let y = 0; y < textureSize; y++) {
+      const coord = Math.min(Math.max((y + 0.5) / textureSize, 0), 1);
+      const roughness = 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, 1024);
+        // const c = Math.min(Math.max(Math.round(t * 255), 0), 255);
+        lut(NdotV, roughness, 1024, c);
+        image[p++] = Math.min(Math.max(Math.round(c.x * 255), 0), 255);
+        image[p++] = Math.min(Math.max(Math.round(c.y * 255), 0), 255);
+        image[p++] = Math.min(Math.max(Math.round(c.z * 255), 0), 255);
+        image[p++] = 255;
+      }
+    }
+    tex.update(image, 0, 0, textureSize, textureSize);
+    tex.name = `builtin:${BUILTIN_ASSET_TEXTURE_SHEEN_LUT}`;
+    return tex;
+  }
   */ //////////////////////////////////////////////////////////////////////////////////////////////////////
     function visibilityAshikhmin(NdotV, NdotL) {
         return Math.min(Math.max(1 / (4 * (NdotL + NdotV - NdotL * NdotV)), 0), 1);
@@ -318,21 +318,21 @@ interface MicrofacetDistributionSample {
         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))
-    );
-  }
+    /*
+  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 createSheenLUTFilament(assetManager, texture) {
         if (texture) {
             if (!texture.isTexture2D()) {

package/dist/asset/loaders/dds/dds_loader.js

@@ -2,9 +2,9 @@ import { getDDSMipLevelsInfo } from './dds.js';
 import { AbstractTextureLoader } from '../loader.js';
 import { Application } from '../../../app.js';
 
-/**
- * The DDS texture loader
- * @internal
+/**
+ * The DDS texture loader
+ * @internal
  */ class DDSLoader extends AbstractTextureLoader {
     supportExtension(ext) {
         return ext === '.dds';
@@ -23,14 +23,14 @@ import { Application } from '../../../app.js';
             samplerOptions
         };
         return Application.instance.device.createTextureFromMipmapData(mipmapLevelData, srgb, options);
-    /*
-    if (mipmapLevelData.isCubemap) {
-      return Application.instance.device.createCubeTextureFromMipmapData(mipmapLevelData, options);
-    } else if (mipmapLevelData.isVolume) {
-      throw new Error(`load DDS volume texture is not supported`);
-    } else {
-      return Application.instance.device.createTexture2DFromMipmapData(mipmapLevelData, options);
-    }
+    /*
+    if (mipmapLevelData.isCubemap) {
+      return Application.instance.device.createCubeTextureFromMipmapData(mipmapLevelData, options);
+    } else if (mipmapLevelData.isVolume) {
+      throw new Error(`load DDS volume texture is not supported`);
+    } else {
+      return Application.instance.device.createTexture2DFromMipmapData(mipmapLevelData, options);
+    }
     */ }
 }
 

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

@@ -15,9 +15,9 @@ import '../../../material/lightmodel.js';
 import { GLTFAccessor, ComponentType } from './helpers.js';
 import { AbstractModelLoader } from '../loader.js';
 
-/**
- * The GLTF/GLB model loader
- * @internal
+/**
+ * The GLTF/GLB model loader
+ * @internal
  */ class GLTFLoader extends AbstractModelLoader {
     supportExtension(ext) {
         return ext === '.gltf' || ext === '.glb';
@@ -477,10 +477,10 @@ import { AbstractModelLoader } from '../loader.js';
                 pbrMaterial.lightModel.useSheen = true;
                 pbrMaterial.lightModel.sheenColorFactor = sheen.sheenColorFactor;
                 pbrMaterial.lightModel.sheenRoughnessFactor = sheen.sheenRoughnessFactor;
-                /*
-        pbrMaterial.lightModel.setSheenLut(
-          await assetManager.fetchBuiltinTexture(BUILTIN_ASSET_TEXTURE_SHEEN_LUT)
-        );
+                /*
+        pbrMaterial.lightModel.setSheenLut(
+          await assetManager.fetchBuiltinTexture(BUILTIN_ASSET_TEXTURE_SHEEN_LUT)
+        );
         */ if (sheen.sheenColorMap) {
                     pbrMaterial.lightModel.setSheenColorMap(sheen.sheenColorMap.texture, sheen.sheenColorMap.sampler, sheen.sheenColorMap.texCoord, sheen.sheenColorMap.transform);
                 }
@@ -802,9 +802,9 @@ import { AbstractModelLoader } from '../loader.js';
                 return 'point-list';
             case 1:
                 return 'line-list';
-            /* FIXME:
-      case 2: // GL_LINE_LOOP
-        return PrimitiveType.LineLoop;
+            /* FIXME:
+      case 2: // GL_LINE_LOOP
+        return PrimitiveType.LineLoop;
       */ case 3:
                 return 'line-strip';
             case 4:

package/dist/asset/loaders/hdr/hdr.js

@@ -3,9 +3,9 @@ import { floatToHalf, packFloat3 } from '@zephyr3d/base';
 import { Application } from '../../../app.js';
 
 const _f16one = floatToHalf(1);
-/**
- * The HDR texture loader
- * @internal
+/**
+ * The HDR texture loader
+ * @internal
  */ class HDRLoader extends AbstractTextureLoader {
     supportExtension(ext) {
         return ext === '.hdr';
@@ -72,8 +72,8 @@ const _f16one = floatToHalf(1);
         }
         return result;
     }
-    /*
-    Decode: rgb = pow(6 * rgbm.rgb * rgbm.a, 2.2);
+    /*
+    Decode: rgb = pow(6 * rgbm.rgb * rgbm.a, 2.2);
    */ _rgbeToRGBM(buffer) {
         const length = buffer.byteLength >> 2;
         const result = new Uint8Array(length * 4);

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

@@ -1,9 +1,9 @@
 import { AbstractTextureLoader } from '../loader.js';
 import { Application } from '../../../app.js';
 
-/**
- * TGA image loader
- * @internal
+/**
+ * TGA image loader
+ * @internal
  */ class TGALoader extends AbstractTextureLoader {
     supportExtension(ext) {
         return ext === '.tga';

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

@@ -1,9 +1,9 @@
 import { AbstractTextureLoader } from '../loader.js';
 import { Application } from '../../../app.js';
 
-/**
- * Web image loader
- * @internal
+/**
+ * Web image loader
+ * @internal
  */ class WebImageLoader extends AbstractTextureLoader {
     supportExtension(ext) {
         return ext === '.jpg' || ext === '.jpeg' || ext === '.png';

package/dist/asset/loaders/loader.js

@@ -1,27 +1,27 @@
-/**
- * Base interface for any kind loaders
- * @public
+/**
+ * Base interface for any kind loaders
+ * @public
  */ class LoaderBase {
     /** @internal */ _urlResolver;
-    /**
-   * Creates an instance of LoaderBase
+    /**
+   * Creates an instance of LoaderBase
    */ constructor(){
         this._urlResolver = null;
     }
-    /**
-   * URL resolver for the loader
+    /**
+   * URL resolver for the loader
    */ get urlResolver() {
         return this._urlResolver;
     }
     set urlResolver(resolver) {
         this._urlResolver = resolver;
     }
-    /**
-   * Sends a GET request
-   * @param url - The URL to get
-   * @param headers - The headers for the request
-   * @param crossOrigin - crossOrigin property for the request
-   * @returns Response of the request
+    /**
+   * Sends a GET request
+   * @param url - The URL to get
+   * @param headers - The headers for the request
+   * @param crossOrigin - crossOrigin property for the request
+   * @returns Response of the request
    */ async request(url, headers = {}, crossOrigin = 'anonymous') {
         url = this._urlResolver ? this._urlResolver(url) : null;
         return url ? fetch(url, {
@@ -30,14 +30,14 @@
         }) : null;
     }
 }
-/**
- * Base class for any kind of texture loaders
- * @public
+/**
+ * Base class for any kind of texture loaders
+ * @public
  */ class AbstractTextureLoader extends LoaderBase {
 }
-/**
- * Base class for any kind of model loaders
- * @public
+/**
+ * Base class for any kind of model loaders
+ * @public
  */ class AbstractModelLoader extends LoaderBase {
 }