@zephyr3d/scene 0.4.0 → 0.6.0

package/dist/asset/assetmanager.js

@@ -1,4 +1,4 @@
-import { HttpRequest, isPowerOf2, nextPowerOf2, Vector3 } from '@zephyr3d/base';
+import { HttpRequest, isPowerOf2, nextPowerOf2 } from '@zephyr3d/base';
 import { GLTFLoader } from './loaders/gltf/gltf_loader.js';
 import { WebImageLoader } from './loaders/image/webimage_loader.js';
 import { DDSLoader } from './loaders/dds/dds_loader.js';
@@ -12,13 +12,14 @@ import { RotationTrack } from '../animation/rotationtrack.js';
 import '../animation/eulerrotationtrack.js';
 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 '@zephyr3d/device';
 import { CopyBlitter } from '../blitter/copy.js';
 import { getSheenLutLoader, getTestCubemapLoader } from './builtin.js';
-import { BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BUILTIN_ASSET_TEST_CUBEMAP } from '../values.js';
+import { BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BUILTIN_ASSET_TEST_CUBEMAP, MAX_MORPH_TARGETS } from '../values.js';
 import { TGALoader } from './loaders/image/tga_Loader.js';
+import { MorphTargetTrack } from '../animation/morphtrack.js';
+import { processMorphData } from '../animation/morphtarget.js';
 
 /**
  * The asset manager
@@ -72,8 +73,8 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
    */ purgeCache() {
         for(const k in this._textures){
             this._textures[k].then((tex)=>tex?.dispose()).catch((err)=>{});
-            delete this._textures[k];
         }
+        this._textures = {};
         this._models = {};
         this._binaryDatas = {};
         this._textDatas = {};
@@ -166,10 +167,10 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             return P;
         }
     }
-    /** @internal */ async fetchModelData(scene, url, mimeType, postProcess) {
+    /** @internal */ async fetchModelData(scene, url, options) {
         let P = this._models[url];
         if (!P) {
-            P = this.loadModel(url, mimeType, postProcess);
+            P = this.loadModel(url, options);
             this._models[url] = P;
         }
         return P;
@@ -188,7 +189,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
    *
    * @returns The created model node
    */ async fetchModel(scene, url, options) {
-        const sharedModel = await this.fetchModelData(scene, url, options?.mimeType, options?.postProcess);
+        const sharedModel = await this.fetchModelData(scene, url, options);
         return this.createSceneNode(scene, sharedModel, !!options?.enableInstancing);
     }
     /** @internal */ async loadTextData(url, postProcess) {
@@ -302,22 +303,22 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             return tex;
         }
     }
-    /** @internal */ async loadModel(url, mimeType, postProcess) {
+    /** @internal */ async loadModel(url, options) {
         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;
         const ext = p >= 0 ? filename.substring(p) : null;
         for (const loader of this._modelLoaders){
-            if (!loader.supportExtension(ext) && !loader.supportMIMEType(mimeType || data.type)) {
+            if (!loader.supportExtension(ext) && !loader.supportMIMEType(options?.mimeType || data.type)) {
                 continue;
             }
-            let model = await loader.load(this, url, mimeType || data.type, data);
+            let model = await loader.load(this, url, options?.mimeType || data.type, data, options?.dracoDecoderModule);
             if (!model) {
                 throw new Error(`Load asset failed: ${url}`);
             }
-            if (postProcess) {
+            if (options?.postProcess) {
                 try {
-                    model = postProcess(model);
+                    model = options.postProcess(model);
                 } catch (err) {
                     throw new Error(`Model loader post process failed: ${err}`);
                 }
@@ -354,7 +355,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
     /** @internal */ createSceneNode(scene, model, instancing) {
         const group = new SceneNode(scene);
         group.name = model.name;
-        let animationSet = new AnimationSet(scene);
+        let animationSet = new AnimationSet(scene, group);
         for(let i = 0; i < model.scenes.length; i++){
             const assetScene = model.scenes[i];
             const skeletonMeshMap = new Map();
@@ -363,8 +364,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
                 this.setAssetNodeToSceneNode(scene, group, model, assetScene.rootNodes[k], skeletonMeshMap, nodeMap, instancing);
             }
             for (const animationData of model.animations){
-                const animation = new AnimationClip(animationData.name, group);
-                animationSet.add(animation);
+                const animation = new AnimationClip(animationData.name);
                 for (const track of animationData.tracks){
                     if (track.type === 'translation') {
                         animation.addTrack(nodeMap.get(track.node), new TranslationTrack(track.interpolator));
@@ -372,19 +372,32 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
                         animation.addTrack(nodeMap.get(track.node), new ScaleTrack(track.interpolator));
                     } else if (track.type === 'rotation') {
                         animation.addTrack(nodeMap.get(track.node), new RotationTrack(track.interpolator));
+                    } else if (track.type === 'weights') {
+                        for (const m of track.node.mesh.subMeshes){
+                            if (track.interpolator.stride > MAX_MORPH_TARGETS) {
+                                console.error(`Morph target too large: ${track.interpolator.stride}, the maximum is ${MAX_MORPH_TARGETS}`);
+                            } else {
+                                const morphTrack = new MorphTargetTrack(track, m);
+                                animation.addTrack(m.mesh, morphTrack);
+                            }
+                        }
                     } else {
                         console.error(`Invalid animation track type: ${track.type}`);
                     }
                 }
+                if (animation.tracks.size === 0) {
+                    continue;
+                }
+                animationSet.add(animation);
                 for (const sk of animationData.skeletons){
                     const nodes = skeletonMeshMap.get(sk);
                     if (nodes) {
-                        const skeleton = new Skeleton(sk.joints.map((val)=>nodeMap.get(val)), sk.inverseBindMatrices, sk.bindPoseMatrices);
-                        skeleton.updateJointMatrices();
-                        animation.addSkeleton(skeleton, nodes.mesh, nodes.bounding.map((val)=>this.getBoundingInfo(skeleton, val)));
+                        if (!nodes.skeleton) {
+                            nodes.skeleton = new Skeleton(sk.joints.map((val)=>nodeMap.get(val)), sk.inverseBindMatrices, sk.bindPoseMatrices, nodes.mesh, nodes.bounding);
+                        }
+                        animation.addSkeleton(nodes.skeleton);
                     }
                 }
-                animation.stop();
             }
         }
         if (animationSet.numAnimations === 0) {
@@ -404,77 +417,9 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
         if (loader) {
             this._builtinTextureLoaders[name] = loader;
         } else {
-            delete this._builtinTextureLoaders[name];
+            this._builtinTextureLoaders[name] = undefined;
         }
     }
-    /** @internal */ getBoundingInfo(skeleton, meshData) {
-        const indices = [
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-        ];
-        let minx = Number.MAX_VALUE;
-        let maxx = -Number.MAX_VALUE;
-        let miny = Number.MAX_VALUE;
-        let maxy = -Number.MAX_VALUE;
-        let minz = Number.MAX_VALUE;
-        let maxz = -Number.MAX_VALUE;
-        const v = meshData.rawPositions;
-        const vert = new Vector3();
-        const tmpV0 = new Vector3();
-        const tmpV1 = new Vector3();
-        const tmpV2 = new Vector3();
-        const tmpV3 = new Vector3();
-        const numVertices = Math.floor(v.length / 3);
-        for(let i = 0; i < numVertices; i++){
-            vert.setXYZ(v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);
-            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 0]].transformPointAffine(vert, tmpV0).scaleBy(meshData.rawJointWeights[i * 4 + 0]);
-            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 1]].transformPointAffine(vert, tmpV1).scaleBy(meshData.rawJointWeights[i * 4 + 1]);
-            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 2]].transformPointAffine(vert, tmpV2).scaleBy(meshData.rawJointWeights[i * 4 + 2]);
-            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 3]].transformPointAffine(vert, tmpV3).scaleBy(meshData.rawJointWeights[i * 4 + 3]);
-            tmpV0.addBy(tmpV1).addBy(tmpV2).addBy(tmpV3);
-            if (tmpV0.x < minx) {
-                minx = tmpV0.x;
-                indices[0] = i;
-            }
-            if (tmpV0.x > maxx) {
-                maxx = tmpV0.x;
-                indices[1] = i;
-            }
-            if (tmpV0.y < miny) {
-                miny = tmpV0.y;
-                indices[2] = i;
-            }
-            if (tmpV0.y > maxy) {
-                maxy = tmpV0.y;
-                indices[3] = i;
-            }
-            if (tmpV0.z < minz) {
-                minz = tmpV0.z;
-                indices[4] = i;
-            }
-            if (tmpV0.z > maxz) {
-                maxz = tmpV0.z;
-                indices[5] = i;
-            }
-        }
-        const info = {
-            boundingVertexBlendIndices: new Float32Array(Array.from({
-                length: 6 * 4
-            }).map((val, index)=>meshData.rawBlendIndices[indices[index >> 2] * 4 + index % 4])),
-            boundingVertexJointWeights: new Float32Array(Array.from({
-                length: 6 * 4
-            }).map((val, index)=>meshData.rawJointWeights[indices[index >> 2] * 4 + index % 4])),
-            boundingVertices: Array.from({
-                length: 6
-            }).map((val, index)=>new Vector3(meshData.rawPositions[indices[index] * 3], meshData.rawPositions[indices[index] * 3 + 1], meshData.rawPositions[indices[index] * 3 + 2])),
-            boundingBox: new BoundingBox()
-        };
-        return info;
-    }
     /** @internal */ setAssetNodeToSceneNode(scene, parent, model, assetNode, skeletonMeshMap, nodeMap, instancing) {
         const node = new SceneNode(scene);
         nodeMap.set(assetNode, node);
@@ -486,27 +431,33 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
             const meshData = assetNode.mesh;
             const skeleton = assetNode.skeleton;
             for (const subMesh of meshData.subMeshes){
-                const meshNode = new Mesh(scene);
-                meshNode.name = subMesh.name;
-                meshNode.clipTestEnabled = true;
-                meshNode.showState = 'inherit';
-                meshNode.primitive = subMesh.primitive;
-                meshNode.material = instancing ? subMesh.material.createInstance() : subMesh.material;
-                // meshNode.drawBoundingBox = true;
-                meshNode.reparent(node);
-                if (skeleton) {
-                    if (!skeletonMeshMap.has(skeleton)) {
-                        skeletonMeshMap.set(skeleton, {
-                            mesh: [
-                                meshNode
-                            ],
-                            bounding: [
-                                subMesh
-                            ]
-                        });
-                    } else {
-                        skeletonMeshMap.get(skeleton).mesh.push(meshNode);
-                        skeletonMeshMap.get(skeleton).bounding.push(subMesh);
+                for (const instance of assetNode.instances){
+                    const meshNode = new Mesh(scene);
+                    meshNode.position = instance.t;
+                    meshNode.scale = instance.s;
+                    meshNode.rotation = instance.r;
+                    meshNode.name = subMesh.name;
+                    meshNode.clipTestEnabled = true;
+                    meshNode.showState = 'inherit';
+                    meshNode.primitive = subMesh.primitive;
+                    meshNode.material = instancing ? subMesh.material.createInstance() : subMesh.material;
+                    meshNode.reparent(node);
+                    subMesh.mesh = meshNode;
+                    processMorphData(subMesh, meshData.morphWeights);
+                    if (skeleton) {
+                        if (!skeletonMeshMap.has(skeleton)) {
+                            skeletonMeshMap.set(skeleton, {
+                                mesh: [
+                                    meshNode
+                                ],
+                                bounding: [
+                                    subMesh
+                                ]
+                            });
+                        } else {
+                            skeletonMeshMap.get(skeleton).mesh.push(meshNode);
+                            skeletonMeshMap.get(skeleton).bounding.push(subMesh);
+                        }
                     }
                 }
             }

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/loaders/dds/dds.js

@@ -77,6 +77,8 @@ var D3DFormat;
     D3DFormat[D3DFormat["D3DFMT_DXT3"] = FourCCToInt32('DXT3')] = "D3DFMT_DXT3";
     D3DFormat[D3DFormat["D3DFMT_DXT4"] = FourCCToInt32('DXT4')] = "D3DFMT_DXT4";
     D3DFormat[D3DFormat["D3DFMT_DXT5"] = FourCCToInt32('DXT5')] = "D3DFMT_DXT5";
+    D3DFormat[D3DFormat["D3DFMT_BC4"] = FourCCToInt32('ATI1')] = "D3DFMT_BC4";
+    D3DFormat[D3DFormat["D3DFMT_BC5"] = FourCCToInt32('ATI2')] = "D3DFMT_BC5";
     D3DFormat[D3DFormat["D3DFMT_R16F"] = 111] = "D3DFMT_R16F";
     D3DFormat[D3DFormat["D3DFMT_RG16F"] = 112] = "D3DFMT_RG16F";
     D3DFormat[D3DFormat["D3DFMT_RGBA16F"] = 113] = "D3DFMT_RGBA16F";
@@ -176,7 +178,15 @@ const dxgiFormatMap = {
     [74]: 'dxt3',
     [75]: 'dxt3-srgb',
     [77]: 'dxt5',
-    [78]: 'dxt5-srgb'
+    [78]: 'dxt5-srgb',
+    [80]: 'bc4',
+    [81]: 'bc4-signed',
+    [83]: 'bc5',
+    [84]: 'bc5-signed',
+    [95]: 'bc6h',
+    [96]: 'bc6h-signed',
+    [98]: 'bc7',
+    [99]: 'bc7-srgb'
 };
 const legacyDDSMap = [
     {
@@ -203,6 +213,62 @@ const legacyDDSMap = [
             dwFourCC: FourCCToInt32('DXT5')
         }
     },
+    {
+        format: 'bc4',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('ATI1')
+        }
+    },
+    {
+        format: 'bc4',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('BC4U')
+        }
+    },
+    {
+        format: 'bc4-signed',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('BC4S')
+        }
+    },
+    {
+        format: 'bc5',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('ATI2')
+        }
+    },
+    {
+        format: 'bc5',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('ATI2')
+        }
+    },
+    {
+        format: 'bc5',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('BC5U')
+        }
+    },
+    {
+        format: 'bc5-signed',
+        convertFlags: 0,
+        pf: {
+            dwFlags: DDPF_FOURCC,
+            dwFourCC: FourCCToInt32('BC5S')
+        }
+    },
     {
         format: 'bgra8unorm',
         convertFlags: 1,
@@ -393,7 +459,7 @@ function getMetaDataFromHeader(header, metaData) {
     if (metaData.format === null) {
         return null;
     }
-    metaData.isCompressed = metaData.format === 'dxt1' || metaData.format === 'dxt3' || metaData.format === 'dxt5';
+    metaData.isCompressed = metaData.format === 'dxt1' || metaData.format === 'dxt3' || metaData.format === 'dxt5' || metaData.format === 'bc4' || metaData.format === 'bc4-signed' || metaData.format === 'bc5' || metaData.format === 'bc5-signed' || metaData.format === 'bc6h' || metaData.format === 'bc6h-signed' || metaData.format === 'bc7' || metaData.format === 'bc7-srgb';
     metaData.dataOffset = header.ddsHeaderDX10 ? 37 * 4 : 32 * 4;
     metaData.width = header.dwWidth;
     metaData.height = header.dwHeight;
@@ -407,7 +473,7 @@ function getMetaDataFromHeader(header, metaData) {
     } else if (header.dwCaps2 & DDSCAPS2_VOLUME) {
         metaData.isVolume = true;
         metaData.depth = header.dwDepth;
-    } else if (header.ddsHeaderDX10) {
+    } else if (header.ddsHeaderDX10 && header.ddsHeaderDX10.arraySize > 1) {
         metaData.isArray = true;
         metaData.depth = header.ddsHeaderDX10.arraySize;
     }
@@ -431,9 +497,17 @@ function getMipmapData(dds, width, height, format, dataOffset) {
         case 'rgba32f':
             return new Float32Array(dds, dataOffset, width * height * 4);
         case 'dxt1':
+        case 'bc4':
+        case 'bc4-signed':
             return new Uint8Array(dds, dataOffset, Math.max(4, width) / 4 * Math.max(4, height) / 4 * 8);
         case 'dxt3':
         case 'dxt5':
+        case 'bc5':
+        case 'bc5-signed':
+        case 'bc6h':
+        case 'bc6h-signed':
+        case 'bc7':
+        case 'bc7-srgb':
             return new Uint8Array(dds, dataOffset, Math.max(4, width) / 4 * Math.max(4, height) / 4 * 16);
         default:
             return null;

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

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

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

@@ -10,7 +10,7 @@ import { Application } from '../../../app.js';
         return ext === '.dds';
     }
     supportMIMEType(mimeType) {
-        return mimeType === 'image/dds';
+        return mimeType === 'image/dds' || mimeType === 'image/x-dds';
     }
     async load(assetManager, url, mimeType, data, srgb, samplerOptions, texture) {
         const arrayBuffer = data;