@zephyr3d/scene 0.1.1 → 0.2.0

package/dist/asset/assetmanager.js

@@ -14,7 +14,6 @@ import { ScaleTrack } from '../animation/scaletrack.js';
 import { Skeleton } from '../animation/skeleton.js';
 import { BoundingBox } from '../utility/bounding_volume.js';
 import { Application } from '../app.js';
-import '../shaders/framework.js';
 import '@zephyr3d/device';
 import { CopyBlitter } from '../blitter/copy.js';
 import { getSheenLutLoader, getTestCubemapLoader } from './builtin.js';
@@ -22,9 +21,9 @@ import { GraphNode } from '../scene/graph_node.js';
 import { BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BUILTIN_ASSET_TEST_CUBEMAP } from '../values.js';
 import { TGALoader } from './loaders/image/tga_Loader.js';
 
-/**
- * The asset manager
- * @public
+/**
+ * The asset manager
+ * @public
  */ class AssetManager {
     /** @internal */ static _builtinTextures = {};
     /** @internal */ static _builtinTextureLoaders = {
@@ -38,8 +37,8 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
     /** @internal */ _models;
     /** @internal */ _binaryDatas;
     /** @internal */ _textDatas;
-    /**
-   * Creates an instance of AssetManager
+    /**
+   * Creates an instance of AssetManager
    */ constructor(){
         this._httpRequest = new HttpRequest();
         this._textureLoaders = [
@@ -56,72 +55,99 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
         this._binaryDatas = {};
         this._textDatas = {};
     }
-    /**
-   * HttpRequest instance of the asset manager
+    /**
+   * HttpRequest instance of the asset manager
    */ get httpRequest() {
         return this._httpRequest;
     }
-    /**
-   * Removes all cached assets
+    /**
+   * Removes all cached assets
    */ clearCache() {
         this._textures = {};
         this._models = {};
         this._binaryDatas = {};
         this._textDatas = {};
     }
-    /**
-   * Adds a texture loader to the asset manager
-   *
-   * @remarks
-   * TODO: this should be a static method
-   *
-   * @param loader - The texture loader to be added
+    /**
+   * Remove and dispose all cached assets
+   */ purgeCache() {
+        for(const k in this._textures){
+            this._textures[k].then((tex)=>tex?.dispose()).catch((err)=>{});
+            delete this._textures[k];
+        }
+        this._models = {};
+        this._binaryDatas = {};
+        this._textDatas = {};
+    }
+    /**
+   * Adds a texture loader to the asset manager
+   *
+   * @remarks
+   * TODO: this should be a static method
+   *
+   * @param loader - The texture loader to be added
    */ addTextureLoader(loader) {
         if (loader) {
             this._textureLoaders.unshift(loader);
         }
     }
-    /**
-   * Adds a model loader to the asset manager
-   *
-   * @remarks
-   * TODO: this should be a static method
-   *
-   * @param loader - The model loader to be added
+    /**
+   * Adds a model loader to the asset manager
+   *
+   * @remarks
+   * TODO: this should be a static method
+   *
+   * @param loader - The model loader to be added
    */ addModelLoader(loader) {
         if (loader) {
             this._modelLoaders.unshift(loader);
         }
     }
-    /**
-   * Fetches a text resource from a given URL
-   * @param url - The URL from where to fetch the resource
-   * @returns The fetched text
-   */ async fetchTextData(url) {
+    /**
+   * Fetches a text resource from a given URL
+   * @param url - The URL from where to fetch the resource
+   * @param postProcess - A function that will be involved when the text data was loaded.
+   *
+   * @remarks
+   * If a text data has already been loaded, the function will ignore the
+   * postProcess parameter and directly return the text loaded previously.
+   * To load the same text with different postProcess parameters,
+   * use different AssetManager instances separately.
+   *
+   * @returns The fetched text
+   */ async fetchTextData(url, postProcess) {
         let P = this._textDatas[url];
         if (!P) {
-            P = this.loadTextData(url);
+            P = this.loadTextData(url, postProcess);
             this._textDatas[url] = P;
         }
         return P;
     }
-    /**
-   * Fetches a binary resource from a given URL
-   * @param url - The URL from where to fetch the resource
-   * @returns
-   */ async fetchBinaryData(url) {
+    /**
+   * Fetches a binary resource from a given URL
+   * @param url - The URL from where to fetch the resource
+   * @param postProcess - A function that will be involved when the binary data was loaded.
+   *
+   * @remarks
+   * If a binary data has already been loaded, the function will ignore the
+   * postProcess parameter and directly return the data loaded previously.
+   * To load the same data with different postProcess parameters,
+   * use different AssetManager instances separately.
+   *
+   * @returns Binary data as ArrayBuffer
+   */ async fetchBinaryData(url, postProcess) {
         let P = this._binaryDatas[url];
         if (!P) {
-            P = this.loadBinaryData(url);
+            P = this.loadBinaryData(url, postProcess);
             this._binaryDatas[url] = P;
         }
         return P;
     }
-    /**
-   * Fetches a texture resource from a given URL
-   * @param url - The URL from where to fetch the resource
-   * @param options - Options for texture fetching
-   * @returns The fetched texture
+    /**
+   * Fetches a texture resource from a given URL
+   * @param url - The URL from where to fetch the resource
+   * @param options - Options for texture fetching
+   * @returns The fetched texture
    */ async fetchTexture(url, options) {
         if (options?.texture) {
             return this.loadTexture(url, options.mimeType ?? null, !options.linearColorSpace, options.samplerOptions, options.texture);
@@ -141,29 +167,53 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             return P;
         }
     }
-    /** @internal */ async fetchModelData(scene, url, mimeType) {
+    /** @internal */ async fetchModelData(scene, url, mimeType, postProcess) {
         let P = this._models[url];
         if (!P) {
-            P = this.loadModel(url, mimeType);
+            P = this.loadModel(url, mimeType, postProcess);
             this._models[url] = P;
         }
         return P;
     }
-    /**
-   * Fetches a model resource from a given URL and adds it to a scene
-   * @param scene - The scene to which the model node belongs
-   * @param url - The URL from where to fetch the resource
-   * @param mimeType - The MIME type of the model resource
-   * @returns The created model node
-   */ async fetchModel(scene, url, mimeType) {
-        const sharedModel = await this.fetchModelData(scene, url, mimeType);
+    /**
+   * Fetches a model resource from a given URL and adds it to a scene
+   * @param scene - The scene to which the model node belongs
+   * @param url - The URL from where to fetch the resource
+   * @param mimeType - The MIME type of the model resource, if not provided, model type will be determined by file extension
+   * @param postProcess - A function that will be involved when the model was loaded.
+   *
+   * @remarks
+   * If a model has already been loaded, the function will ignore the
+   * postProcess parameter and directly return the model loaded previously.
+   * To load the same model with different postProcess parameters,
+   * use different AssetManager instances separately.
+   *
+   * @returns The created model node
+   */ async fetchModel(scene, url, mimeType, postProcess) {
+        const sharedModel = await this.fetchModelData(scene, url, mimeType, postProcess);
         return this.createSceneNode(scene, sharedModel);
     }
-    /** @internal */ async loadTextData(url) {
-        return this._httpRequest.requestText(url);
+    /** @internal */ async loadTextData(url, postProcess) {
+        let text = await this._httpRequest.requestText(url);
+        if (postProcess) {
+            try {
+                text = postProcess(text);
+            } catch (err) {
+                throw new Error(`Load text data post process failed: ${err}`);
+            }
+        }
+        return text;
     }
-    /** @internal */ async loadBinaryData(url) {
-        return this._httpRequest.requestArrayBuffer(url);
+    /** @internal */ async loadBinaryData(url, postProcess) {
+        let data = await this._httpRequest.requestArrayBuffer(url);
+        if (postProcess) {
+            try {
+                data = postProcess(data);
+            } catch (err) {
+                throw new Error(`Load binary data post process failed: ${err}`);
+            }
+        }
+        return data;
     }
     /** @internal */ async loadTexture(url, mimeType, srgb, samplerOptions, texture) {
         const data = await this._httpRequest.requestArrayBuffer(url);
@@ -254,7 +304,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             return tex;
         }
     }
-    /** @internal */ async loadModel(url, mimeType, name) {
+    /** @internal */ async loadModel(url, mimeType, postProcess) {
         const data = await this.httpRequest.requestBlob(url);
         const filename = new URL(url, new URL(location.href).origin).pathname.split('/').filter((val)=>!!val).slice(-1)[0];
         const p = filename ? filename.lastIndexOf('.') : -1;
@@ -263,19 +313,26 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             if (!loader.supportExtension(ext) && !loader.supportMIMEType(mimeType || data.type)) {
                 continue;
             }
-            const model = await loader.load(this, url, mimeType || data.type, data);
+            let model = await loader.load(this, url, mimeType || data.type, data);
             if (!model) {
                 throw new Error(`Load asset failed: ${url}`);
             }
-            model.name = name || filename;
+            if (postProcess) {
+                try {
+                    model = postProcess(model);
+                } catch (err) {
+                    throw new Error(`Model loader post process failed: ${err}`);
+                }
+            }
+            model.name = filename;
             return model;
         }
         throw new Error(`Can not find loader for asset ${url}`);
     }
-    /**
-   * Fetches a built-in texture
-   * @param name - Name of the built-in texture
-   * @returns The built-in texture
+    /**
+   * Fetches a built-in texture
+   * @param name - Name of the built-in texture
+   * @returns The built-in texture
    */ async fetchBuiltinTexture(name, texture) {
         const loader = AssetManager._builtinTextureLoaders[name];
         if (!loader) {
@@ -323,7 +380,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
                     } else if (track.type === 'rotation') {
                         animation.addTrack(nodeMap.get(track.node), new RotationTrack(track.interpolator));
                     } else {
-                        throw new Error(`Could not load model: invalid animation track type: ${track.type}`);
+                        console.error(`Invalid animation track type: ${track.type}`);
                     }
                 }
                 for (const sk of animationData.skeletons){
@@ -346,10 +403,10 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             animationSet
         };
     }
-    /**
-   * Sets the loader for a given builtin-texture
-   * @param name - Name of the builtin texture
-   * @param loader - Loader for the builtin texture
+    /**
+   * Sets the loader for a given builtin-texture
+   * @param name - Name of the builtin texture
+   * @param loader - Loader for the builtin texture
    */ static setBuiltinTextureLoader(name, loader) {
         if (loader) {
             this._builtinTextureLoaders[name] = loader;

package/dist/asset/assetmanager.js.map

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

package/dist/asset/builtin.js

@@ -349,12 +349,12 @@ interface MicrofacetDistributionSample {
         const image = new Uint16Array(textureSize * textureSize * 4);
         let p = 0;
         const one = encodeF16(1);
-        for(let y = 0; y < textureSize; y++){
+        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, 4096);
+                const c = dfvCharlieUniform(NdotV, roughness, 512);
                 const f16 = encodeF16(c);
                 image[p++] = 0;
                 image[p++] = 0;

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

@@ -2,16 +2,17 @@ import { Matrix4x4, Vector3, Quaternion, Interpolator, Vector4 } from '@zephyr3d
 import { AssetScene, AssetSkeleton, SharedModel } from '../../model.js';
 import { BoundingBox } from '../../../utility/bounding_volume.js';
 import { Primitive } from '../../../render/primitive.js';
-import '../../../material/material.js';
-import '@zephyr3d/device';
-import '../../../shaders/framework.js';
-import { Application } from '../../../app.js';
-import '../../../render/scatteringlut.js';
+import '../../../material/shader/helper.js';
 import '../../../material/lambert.js';
 import '../../../material/blinn.js';
 import { UnlitMaterial } from '../../../material/unlit.js';
-import { PBRSpecularGlossinessMaterial, PBRMetallicRoughnessMaterial } from '../../../material/pbr.js';
-import '../../../material/lightmodel.js';
+import '../../../material/material.js';
+import '../../../material/meshmaterial.js';
+import '../../../material/grassmaterial.js';
+import '../../../material/terrainmaterial.js';
+import { PBRMetallicRoughnessMaterial } from '../../../material/pbrmr.js';
+import { PBRSpecularGlossinessMaterial } from '../../../material/pbrsg.js';
+import { Application } from '../../../app.js';
 import { GLTFAccessor, ComponentType } from './helpers.js';
 import { AbstractModelLoader } from '../loader.js';
 
@@ -379,13 +380,13 @@ import { AbstractModelLoader } from '../loader.js';
     async _createMaterial(assetManager, assetMaterial) {
         if (assetMaterial.type === 'unlit') {
             const unlitAssetMaterial = assetMaterial;
-            const unlitMaterial = new UnlitMaterial; //new NewLambertMaterial();// new TestLitMaterial();// new UnlitMaterial();
+            const unlitMaterial = new UnlitMaterial(); //new NewLambertMaterial();// new TestLitMaterial();// new UnlitMaterial();
             unlitMaterial.albedoColor = unlitAssetMaterial.diffuse ?? Vector4.one();
             if (unlitAssetMaterial.diffuseMap) {
                 unlitMaterial.albedoTexture = unlitAssetMaterial.diffuseMap.texture;
                 unlitMaterial.albedoTextureSampler = unlitAssetMaterial.diffuseMap.sampler;
                 unlitMaterial.albedoTexCoordIndex = unlitAssetMaterial.diffuseMap.texCoord;
-                unlitMaterial.albedoTexMatrix = unlitAssetMaterial.diffuseMap.transform;
+                unlitMaterial.albedoTexCoordMatrix = unlitAssetMaterial.diffuseMap.transform;
             }
             unlitMaterial.vertexColor = unlitAssetMaterial.common.vertexColor;
             if (assetMaterial.common.alphaMode === 'blend') {
@@ -401,33 +402,48 @@ import { AbstractModelLoader } from '../loader.js';
         } else if (assetMaterial.type === 'pbrSpecularGlossiness') {
             const assetPBRMaterial = assetMaterial;
             const pbrMaterial = new PBRSpecularGlossinessMaterial();
-            pbrMaterial.lightModel.ior = assetPBRMaterial.ior;
-            pbrMaterial.lightModel.albedo = assetPBRMaterial.diffuse;
-            pbrMaterial.lightModel.specularFactor = new Vector4(assetPBRMaterial.specular.x, assetPBRMaterial.specular.y, assetPBRMaterial.specular.z, 1);
-            pbrMaterial.lightModel.glossinessFactor = assetPBRMaterial.glossness;
+            pbrMaterial.ior = assetPBRMaterial.ior;
+            pbrMaterial.albedoColor = assetPBRMaterial.diffuse;
+            pbrMaterial.specularFactor = new Vector4(assetPBRMaterial.specular.x, assetPBRMaterial.specular.y, assetPBRMaterial.specular.z, 1);
+            pbrMaterial.glossinessFactor = assetPBRMaterial.glossness;
             if (assetPBRMaterial.diffuseMap) {
-                pbrMaterial.lightModel.setAlbedoMap(assetPBRMaterial.diffuseMap.texture, assetPBRMaterial.diffuseMap.sampler, assetPBRMaterial.diffuseMap.texCoord, assetPBRMaterial.diffuseMap.transform);
+                pbrMaterial.albedoTexture = assetPBRMaterial.diffuseMap.texture;
+                pbrMaterial.albedoTextureSampler = assetPBRMaterial.diffuseMap.sampler;
+                pbrMaterial.albedoTexCoordIndex = assetPBRMaterial.diffuseMap.texCoord;
+                pbrMaterial.albedoTexCoordMatrix = assetPBRMaterial.diffuseMap.transform;
             }
             if (assetPBRMaterial.common.normalMap) {
-                pbrMaterial.lightModel.setNormalMap(assetPBRMaterial.common.normalMap.texture, assetPBRMaterial.common.normalMap.sampler, assetPBRMaterial.common.normalMap.texCoord, assetPBRMaterial.common.normalMap.transform);
+                pbrMaterial.normalTexture = assetPBRMaterial.common.normalMap.texture;
+                pbrMaterial.normalTextureSampler = assetPBRMaterial.common.normalMap.sampler;
+                pbrMaterial.normalTexCoordIndex = assetPBRMaterial.common.normalMap.texCoord;
+                pbrMaterial.normalTexCoordMatrix = assetPBRMaterial.common.normalMap.transform;
             }
-            pbrMaterial.lightModel.normalScale = assetPBRMaterial.common.bumpScale;
+            pbrMaterial.normalScale = assetPBRMaterial.common.bumpScale;
             if (assetPBRMaterial.common.emissiveMap) {
-                pbrMaterial.lightModel.setEmissiveMap(assetPBRMaterial.common.emissiveMap.texture, assetPBRMaterial.common.emissiveMap.sampler, assetPBRMaterial.common.emissiveMap.texCoord, assetPBRMaterial.common.emissiveMap.transform);
+                pbrMaterial.emissiveTexture = assetPBRMaterial.common.emissiveMap.texture;
+                pbrMaterial.emissiveTextureSampler = assetPBRMaterial.common.emissiveMap.sampler;
+                pbrMaterial.emissiveTexCoordIndex = assetPBRMaterial.common.emissiveMap.texCoord;
+                pbrMaterial.emissiveTexCoordMatrix = assetPBRMaterial.common.emissiveMap.transform;
             }
-            pbrMaterial.lightModel.emissiveColor = assetPBRMaterial.common.emissiveColor;
-            pbrMaterial.lightModel.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
+            pbrMaterial.emissiveColor = assetPBRMaterial.common.emissiveColor;
+            pbrMaterial.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
             if (assetPBRMaterial.common.occlusionMap) {
-                pbrMaterial.lightModel.setOcclusionMap(assetPBRMaterial.common.occlusionMap.texture, assetPBRMaterial.common.occlusionMap.sampler, assetPBRMaterial.common.occlusionMap.texCoord, assetPBRMaterial.common.occlusionMap.transform);
+                pbrMaterial.occlusionTexture = assetPBRMaterial.common.occlusionMap.texture;
+                pbrMaterial.occlusionTextureSampler = assetPBRMaterial.common.occlusionMap.sampler;
+                pbrMaterial.occlusionTexCoordIndex = assetPBRMaterial.common.occlusionMap.texCoord;
+                pbrMaterial.occlusionTexCoordMatrix = assetPBRMaterial.common.occlusionMap.transform;
             }
-            pbrMaterial.lightModel.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
+            pbrMaterial.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
             if (assetPBRMaterial.specularGlossnessMap) {
-                pbrMaterial.lightModel.setSpecularMap(assetPBRMaterial.specularGlossnessMap.texture, assetPBRMaterial.specularGlossnessMap.sampler, assetPBRMaterial.specularGlossnessMap.texCoord, assetPBRMaterial.specularGlossnessMap.transform);
+                pbrMaterial.specularTexture = assetPBRMaterial.specularGlossnessMap.texture;
+                pbrMaterial.specularTextureSampler = assetPBRMaterial.specularGlossnessMap.sampler;
+                pbrMaterial.specularTexCoordIndex = assetPBRMaterial.specularGlossnessMap.texCoord;
+                pbrMaterial.specularTexCoordMatrix = assetPBRMaterial.specularGlossnessMap.transform;
             }
             pbrMaterial.vertexTangent = assetPBRMaterial.common.useTangent;
             pbrMaterial.vertexColor = assetPBRMaterial.common.vertexColor;
             if (assetPBRMaterial.common.alphaMode === 'blend') {
-                pbrMaterial.alphaBlend = true;
+                pbrMaterial.blendMode = 'blend';
             } else if (assetPBRMaterial.common.alphaMode === 'mask') {
                 pbrMaterial.alphaCutoff = assetPBRMaterial.common.alphaCutoff;
             }
@@ -440,73 +456,103 @@ import { AbstractModelLoader } from '../loader.js';
         } else if (assetMaterial.type === 'pbrMetallicRoughness') {
             const assetPBRMaterial = assetMaterial;
             const pbrMaterial = new PBRMetallicRoughnessMaterial();
-            pbrMaterial.lightModel.ior = assetPBRMaterial.ior;
-            pbrMaterial.lightModel.albedo = assetPBRMaterial.diffuse;
-            pbrMaterial.lightModel.metallic = assetPBRMaterial.metallic;
-            pbrMaterial.lightModel.roughness = assetPBRMaterial.roughness;
+            pbrMaterial.ior = assetPBRMaterial.ior;
+            pbrMaterial.albedoColor = assetPBRMaterial.diffuse;
+            pbrMaterial.metallic = assetPBRMaterial.metallic;
+            pbrMaterial.roughness = assetPBRMaterial.roughness;
             if (assetPBRMaterial.diffuseMap) {
-                pbrMaterial.lightModel.setAlbedoMap(assetPBRMaterial.diffuseMap.texture, assetPBRMaterial.diffuseMap.sampler, assetPBRMaterial.diffuseMap.texCoord, assetPBRMaterial.diffuseMap.transform);
+                pbrMaterial.albedoTexture = assetPBRMaterial.diffuseMap.texture;
+                pbrMaterial.albedoTextureSampler = assetPBRMaterial.diffuseMap.sampler;
+                pbrMaterial.albedoTexCoordIndex = assetPBRMaterial.diffuseMap.texCoord;
+                pbrMaterial.albedoTexCoordMatrix = assetPBRMaterial.diffuseMap.transform;
             }
             if (assetPBRMaterial.common.normalMap) {
-                pbrMaterial.lightModel.setNormalMap(assetPBRMaterial.common.normalMap.texture, assetPBRMaterial.common.normalMap.sampler, assetPBRMaterial.common.normalMap.texCoord, assetPBRMaterial.common.normalMap.transform);
+                pbrMaterial.normalTexture = assetPBRMaterial.common.normalMap.texture;
+                pbrMaterial.normalTextureSampler = assetPBRMaterial.common.normalMap.sampler;
+                pbrMaterial.normalTexCoordIndex = assetPBRMaterial.common.normalMap.texCoord;
+                pbrMaterial.normalTexCoordMatrix = assetPBRMaterial.common.normalMap.transform;
             }
-            pbrMaterial.lightModel.normalScale = assetPBRMaterial.common.bumpScale;
+            pbrMaterial.normalScale = assetPBRMaterial.common.bumpScale;
             if (assetPBRMaterial.common.emissiveMap) {
-                pbrMaterial.lightModel.setEmissiveMap(assetPBRMaterial.common.emissiveMap.texture, assetPBRMaterial.common.emissiveMap.sampler, assetPBRMaterial.common.emissiveMap.texCoord, assetPBRMaterial.common.emissiveMap.transform);
+                pbrMaterial.emissiveTexture = assetPBRMaterial.common.emissiveMap.texture;
+                pbrMaterial.emissiveTextureSampler = assetPBRMaterial.common.emissiveMap.sampler;
+                pbrMaterial.emissiveTexCoordIndex = assetPBRMaterial.common.emissiveMap.texCoord;
+                pbrMaterial.emissiveTexCoordMatrix = assetPBRMaterial.common.emissiveMap.transform;
             }
-            pbrMaterial.lightModel.emissiveColor = assetPBRMaterial.common.emissiveColor;
-            pbrMaterial.lightModel.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
+            pbrMaterial.emissiveColor = assetPBRMaterial.common.emissiveColor;
+            pbrMaterial.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
             if (assetPBRMaterial.common.occlusionMap) {
-                pbrMaterial.lightModel.setOcclusionMap(assetPBRMaterial.common.occlusionMap.texture, assetPBRMaterial.common.occlusionMap.sampler, assetPBRMaterial.common.occlusionMap.texCoord, assetPBRMaterial.common.occlusionMap.transform);
+                pbrMaterial.occlusionTexture = assetPBRMaterial.common.occlusionMap.texture;
+                pbrMaterial.occlusionTextureSampler = assetPBRMaterial.common.occlusionMap.sampler;
+                pbrMaterial.occlusionTexCoordIndex = assetPBRMaterial.common.occlusionMap.texCoord;
+                pbrMaterial.occlusionTexCoordMatrix = assetPBRMaterial.common.occlusionMap.transform;
+                pbrMaterial.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
             }
-            pbrMaterial.lightModel.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
             if (assetPBRMaterial.metallicMap) {
-                pbrMaterial.lightModel.setMetallicMap(assetPBRMaterial.metallicMap.texture, assetPBRMaterial.metallicMap.sampler, assetPBRMaterial.metallicMap.texCoord, assetPBRMaterial.metallicMap.transform);
+                pbrMaterial.metallicRoughnessTexture = assetPBRMaterial.metallicMap.texture;
+                pbrMaterial.metallicRoughnessTextureSampler = assetPBRMaterial.metallicMap.sampler;
+                pbrMaterial.metallicRoughnessTexCoordIndex = assetPBRMaterial.metallicMap.texCoord;
+                pbrMaterial.metallicRoughnessTexCoordMatrix = assetPBRMaterial.metallicMap.transform;
             }
-            pbrMaterial.lightModel.metallicIndex = assetPBRMaterial.metallicIndex;
-            pbrMaterial.lightModel.roughnessIndex = assetPBRMaterial.roughnessIndex;
-            pbrMaterial.lightModel.specularFactor = assetPBRMaterial.specularFactor;
+            pbrMaterial.specularFactor = assetPBRMaterial.specularFactor;
             if (assetPBRMaterial.specularMap) {
-                pbrMaterial.lightModel.setSpecularMap(assetPBRMaterial.specularMap.texture, assetPBRMaterial.specularMap.sampler, assetPBRMaterial.specularMap.texCoord, assetPBRMaterial.specularMap.transform);
+                pbrMaterial.specularTexture = assetPBRMaterial.specularMap.texture;
+                pbrMaterial.specularTextureSampler = assetPBRMaterial.specularMap.sampler;
+                pbrMaterial.specularTexCoordIndex = assetPBRMaterial.specularMap.texCoord;
+                pbrMaterial.specularTexCoordMatrix = assetPBRMaterial.specularMap.transform;
             }
             if (assetPBRMaterial.specularColorMap) {
-                pbrMaterial.lightModel.setSpecularColorMap(assetPBRMaterial.specularColorMap.texture, assetPBRMaterial.specularColorMap.sampler, assetPBRMaterial.specularColorMap.texCoord, assetPBRMaterial.specularColorMap.transform);
+                pbrMaterial.specularColorTexture = assetPBRMaterial.specularColorMap.texture;
+                pbrMaterial.specularColorTextureSampler = assetPBRMaterial.specularColorMap.sampler;
+                pbrMaterial.specularColorTexCoordIndex = assetPBRMaterial.specularColorMap.texCoord;
+                pbrMaterial.specularColorTexCoordMatrix = assetPBRMaterial.specularColorMap.transform;
             }
             if (assetPBRMaterial.sheen) {
                 const sheen = assetPBRMaterial.sheen;
-                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)
-        );
-        */ if (sheen.sheenColorMap) {
-                    pbrMaterial.lightModel.setSheenColorMap(sheen.sheenColorMap.texture, sheen.sheenColorMap.sampler, sheen.sheenColorMap.texCoord, sheen.sheenColorMap.transform);
+                pbrMaterial.sheen = true;
+                pbrMaterial.sheenColorFactor = sheen.sheenColorFactor;
+                pbrMaterial.sheenRoughnessFactor = sheen.sheenRoughnessFactor;
+                if (sheen.sheenColorMap) {
+                    pbrMaterial.sheenColorTexture = sheen.sheenColorMap.texture;
+                    pbrMaterial.sheenColorTextureSampler = sheen.sheenColorMap.sampler;
+                    pbrMaterial.sheenColorTexCoordIndex = sheen.sheenColorMap.texCoord;
+                    pbrMaterial.sheenColorTexCoordMatrix = sheen.sheenColorMap.transform;
                 }
                 if (sheen.sheenRoughnessMap) {
-                    pbrMaterial.lightModel.setSheenRoughnessMap(sheen.sheenRoughnessMap.texture, sheen.sheenRoughnessMap.sampler, sheen.sheenRoughnessMap.texCoord, sheen.sheenRoughnessMap.transform);
+                    pbrMaterial.sheenRoughnessTexture = sheen.sheenRoughnessMap.texture;
+                    pbrMaterial.sheenRoughnessTextureSampler = sheen.sheenRoughnessMap.sampler;
+                    pbrMaterial.sheenRoughnessTexCoordIndex = sheen.sheenRoughnessMap.texCoord;
+                    pbrMaterial.sheenRoughnessTexCoordMatrix = sheen.sheenRoughnessMap.transform;
                 }
             }
             if (assetPBRMaterial.clearcoat) {
                 const cc = assetPBRMaterial.clearcoat;
-                pbrMaterial.lightModel.useClearcoat = true;
-                pbrMaterial.lightModel.clearcoatIntensity = cc.clearCoatFactor;
-                pbrMaterial.lightModel.clearcoatRoughnessFactor = cc.clearCoatRoughnessFactor;
+                pbrMaterial.clearcoat = true;
+                pbrMaterial.clearcoatIntensity = cc.clearCoatFactor;
+                pbrMaterial.clearcoatRoughnessFactor = cc.clearCoatRoughnessFactor;
                 if (cc.clearCoatIntensityMap) {
-                    pbrMaterial.lightModel.setClearcoatIntensityMap(cc.clearCoatIntensityMap.texture, cc.clearCoatIntensityMap.sampler, cc.clearCoatIntensityMap.texCoord, cc.clearCoatIntensityMap.transform);
+                    pbrMaterial.clearcoatIntensityTexture = cc.clearCoatIntensityMap.texture;
+                    pbrMaterial.clearcoatIntensityTextureSampler = cc.clearCoatIntensityMap.sampler;
+                    pbrMaterial.clearcoatIntensityTexCoordIndex = cc.clearCoatIntensityMap.texCoord;
+                    pbrMaterial.clearcoatIntensityTexCoordMatrix = cc.clearCoatIntensityMap.transform;
                 }
                 if (cc.clearCoatRoughnessMap) {
-                    pbrMaterial.lightModel.setClearcoatRoughnessMap(cc.clearCoatRoughnessMap.texture, cc.clearCoatRoughnessMap.sampler, cc.clearCoatRoughnessMap.texCoord, cc.clearCoatRoughnessMap.transform);
+                    pbrMaterial.clearcoatRoughnessTexture = cc.clearCoatRoughnessMap.texture;
+                    pbrMaterial.clearcoatRoughnessTextureSampler = cc.clearCoatRoughnessMap.sampler;
+                    pbrMaterial.clearcoatRoughnessTexCoordIndex = cc.clearCoatRoughnessMap.texCoord;
+                    pbrMaterial.clearcoatRoughnessTexCoordMatrix = cc.clearCoatRoughnessMap.transform;
                 }
                 if (cc.clearCoatNormalMap) {
-                    pbrMaterial.lightModel.setClearcoatNormalMap(cc.clearCoatNormalMap.texture, cc.clearCoatNormalMap.sampler, cc.clearCoatNormalMap.texCoord, cc.clearCoatNormalMap.transform);
+                    pbrMaterial.clearcoatNormalTexture = cc.clearCoatNormalMap.texture;
+                    pbrMaterial.clearcoatNormalTextureSampler = cc.clearCoatNormalMap.sampler;
+                    pbrMaterial.clearcoatNormalTexCoordIndex = cc.clearCoatNormalMap.texCoord;
+                    pbrMaterial.clearcoatNormalTexCoordMatrix = cc.clearCoatNormalMap.transform;
                 }
             }
             pbrMaterial.vertexTangent = assetPBRMaterial.common.useTangent;
             pbrMaterial.vertexColor = assetPBRMaterial.common.vertexColor;
             if (assetPBRMaterial.common.alphaMode === 'blend') {
-                pbrMaterial.alphaBlend = true;
+                pbrMaterial.blendMode = 'blend';
             } else if (assetPBRMaterial.common.alphaMode === 'mask') {
                 pbrMaterial.alphaCutoff = assetPBRMaterial.common.alphaCutoff;
             }
@@ -875,7 +921,7 @@ import { AbstractModelLoader } from '../loader.js';
         const accessor = gltf._accessors[accessorIndex];
         const componentCount = accessor.getComponentCount(accessor.type);
         const normalized = !!accessor.normalized;
-        const hash = `${accessorIndex}:${!!semantic}:${Number(normalized)}`;
+        const hash = `${accessorIndex}:${semantic || ''}:${Number(normalized)}`;
         let buffer = gltf._bufferCache[hash];
         if (!buffer) {
             let data = accessor.getNormalizedDeinterlacedView(gltf);

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

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

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

@@ -126,7 +126,7 @@ const _f16one = floatToHalf(1);
         for(let j = 0; j < height; j++){
             const scanline = [];
             let rgbe = d8.slice(pos, pos += 4);
-            const isNewRLE = rgbe[0] == 2 && rgbe[1] == 2 && rgbe[2] == (width >> 8 & 0xFF) && rgbe[3] == (width & 0xFF);
+            const isNewRLE = rgbe[0] == 2 && rgbe[1] == 2 && rgbe[2] == (width >> 8 & 0xff) && rgbe[3] == (width & 0xff);
             if (isNewRLE && width >= 8 && width < 32768) {
                 for(let i = 0; i < 4; i++){
                     let ptr = i * width;

package/dist/blitter/blitter.js

@@ -1,7 +1,6 @@
 import { Vector4 } from '@zephyr3d/base';
 import { Application } from '../app.js';
 import { Primitive } from '../render/primitive.js';
-import '../shaders/framework.js';
 import { linearToGamma } from '../shaders/misc.js';
 
 /**

package/dist/blitter/blitter.js.map

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

package/dist/blitter/depthlimitedgaussion.js

@@ -1,5 +1,4 @@
 import { Blitter } from './blitter.js';
-import '../shaders/framework.js';
 import { decodeNormalizedFloatFromRGBA, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
 import '../app.js';
 import { Vector2 } from '@zephyr3d/base';

package/dist/blitter/depthlimitedgaussion.js.map

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

package/dist/blitter/gaussianblur.js

@@ -1,5 +1,4 @@
 import { Blitter } from './blitter.js';
-import '../shaders/framework.js';
 import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
 import '../app.js';
 

package/dist/blitter/gaussianblur.js.map

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