@zephyr3d/scene 0.1.2 → 0.3.0

package/dist/asset/assetmanager.js

@@ -14,11 +14,9 @@ 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';
-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';
 
@@ -70,6 +68,17 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
         this._textDatas = {};
     }
     /**
+   * 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
@@ -96,11 +105,19 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
     /**
    * 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) {
+   */ 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;
@@ -108,11 +125,19 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
     /**
    * Fetches a binary resource from a given URL
    * @param url - The URL from where to fetch the resource
-   * @returns
-   */ async fetchBinaryData(url) {
+   * @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;
@@ -141,10 +166,10 @@ 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;
@@ -153,17 +178,40 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
    * 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
+   * @param options - Options for model fetching
+   *
+   * @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) {
-        const sharedModel = await this.fetchModelData(scene, url, mimeType);
-        return this.createSceneNode(scene, sharedModel);
+   */ async fetchModel(scene, url, options) {
+        const sharedModel = await this.fetchModelData(scene, url, options?.mimeType, options?.postProcess);
+        return this.createSceneNode(scene, sharedModel, !options?.disableInstancing);
     }
-    /** @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 +302,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,11 +311,18 @@ 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}`);
@@ -296,21 +351,16 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             return tex;
         }
     }
-    /** @internal */ createSceneNode(scene, model, sceneIndex) {
+    /** @internal */ createSceneNode(scene, model, instancing) {
         const group = new SceneNode(scene);
         group.name = model.name;
         let animationSet = new AnimationSet(scene);
         for(let i = 0; i < model.scenes.length; i++){
-            if (typeof sceneIndex === 'number' && sceneIndex >= 0 && i !== sceneIndex) {
-                continue;
-            } else if ((sceneIndex === undefined || sceneIndex === null) && model.activeScene >= 0 && i !== model.activeScene) {
-                continue;
-            }
             const assetScene = model.scenes[i];
             const skeletonMeshMap = new Map();
             const nodeMap = new Map();
             for(let k = 0; k < assetScene.rootNodes.length; k++){
-                this.setAssetNodeToSceneNode(scene, group, model, assetScene.rootNodes[k], skeletonMeshMap, nodeMap);
+                this.setAssetNodeToSceneNode(scene, group, model, assetScene.rootNodes[k], skeletonMeshMap, nodeMap, instancing);
             }
             for (const animationData of model.animations){
                 const animation = new AnimationClip(animationData.name, group);
@@ -323,7 +373,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){
@@ -425,7 +475,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
         };
         return info;
     }
-    /** @internal */ setAssetNodeToSceneNode(scene, parent, model, assetNode, skeletonMeshMap, nodeMap) {
+    /** @internal */ setAssetNodeToSceneNode(scene, parent, model, assetNode, skeletonMeshMap, nodeMap, instancing) {
         const node = new SceneNode(scene);
         nodeMap.set(assetNode, node);
         node.name = `${assetNode.name}`;
@@ -438,11 +488,10 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             for (const subMesh of meshData.subMeshes){
                 const meshNode = new Mesh(scene);
                 meshNode.name = subMesh.name;
-                meshNode.clipMode = GraphNode.CLIP_INHERITED;
-                meshNode.showState = GraphNode.SHOW_INHERITED;
-                meshNode.pickMode = GraphNode.PICK_INHERITED;
+                meshNode.clipTestEnabled = true;
+                meshNode.showState = 'inherit';
                 meshNode.primitive = subMesh.primitive;
-                meshNode.material = subMesh.material;
+                meshNode.material = instancing ? subMesh.material.createInstance() : subMesh.material;
                 // meshNode.drawBoundingBox = true;
                 meshNode.reparent(node);
                 if (skeleton) {
@@ -464,7 +513,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
         }
         node.reparent(parent);
         for (const child of assetNode.children){
-            this.setAssetNodeToSceneNode(scene, node, model, child, skeletonMeshMap, nodeMap);
+            this.setAssetNodeToSceneNode(scene, node, model, child, skeletonMeshMap, nodeMap, instancing);
         }
     }
     getHash(type, url, options) {

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/camera/camera.js

@@ -2,15 +2,18 @@ import { Matrix4x4, Vector4, Frustum } from '@zephyr3d/base';
 import { SceneNode } from '../scene/scene_node.js';
 import { Application } from '../app.js';
 import '../scene/octree.js';
-import '../material/material.js';
-import '@zephyr3d/device';
-import '../shaders/framework.js';
-import '../render/scatteringlut.js';
+import '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/lightmodel.js';
-import { ForwardRenderScheme } from '../render/forward.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 { SceneRenderer } from '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
 import '../render/watermesh.js';
@@ -299,8 +302,8 @@ import '../render/watermesh.js';
         device.pushDeviceStates();
         device.reverseVertexWindingOrder(false);
         device.setFramebuffer(this._framebuffer);
-        ForwardRenderScheme.setClearColor(this._clearColor);
-        ForwardRenderScheme.renderScene(scene, this, compositor, logger);
+        SceneRenderer.setClearColor(this._clearColor);
+        SceneRenderer.renderScene(scene, this, compositor, logger);
         device.popDeviceStates();
     }
     /**

package/dist/camera/camera.js.map

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