@zephyr3d/scene 0.1.0

package/dist/scene/mesh.js

@@ -0,0 +1,215 @@
+import { Vector4 } from '@zephyr3d/base';
+import { GraphNode } from './graph_node.js';
+import { Application } from '../app.js';
+import { BoxFrameShape } from '../shapes/box.js';
+import { StandardMaterial } from '../material/standard.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import { LambertLightModel } from '../material/lightmodel.js';
+import '../material/material.js';
+import '@zephyr3d/device';
+import '../shaders/framework.js';
+import '../render/scatteringlut.js';
+
+/**
+ * Mesh node
+ * @public
+ */ class Mesh extends GraphNode {
+    /** @internal */ _primitive;
+    /** @internal */ _material;
+    /** @internal */ _castShadow;
+    /** @internal */ _bboxChangeCallback;
+    /** @internal */ _animatedBoundingBox;
+    /** @internal */ _boneMatrices;
+    /** @internal */ _invBindMatrix;
+    /** @internal */ _instanceHash;
+    /** @internal */ _batchable;
+    /** @internal */ _boundingBoxNode;
+    /** @internal */ _instanceColor;
+    /**
+   * Creates an instance of mesh node
+   * @param scene - The scene to which the mesh node belongs
+   */ constructor(scene, primitive, material){
+        super(scene);
+        this._primitive = null;
+        this._material = null;
+        this._castShadow = true;
+        this._animatedBoundingBox = null;
+        this._boneMatrices = null;
+        this._invBindMatrix = null;
+        this._instanceHash = null;
+        this._boundingBoxNode = null;
+        this._instanceColor = Vector4.zero();
+        this._batchable = Application.instance.deviceType !== 'webgl';
+        this._bboxChangeCallback = this._onBoundingboxChange.bind(this);
+        // use setter
+        this.primitive = primitive ?? null;
+        this.material = material ?? Mesh._getDefaultMaterial();
+    }
+    /**
+   * {@inheritDoc Drawable.getName}
+   */ getName() {
+        return this._name;
+    }
+    /**
+   * {@inheritDoc BatchDrawable.getInstanceId}
+   */ getInstanceId(renderPass) {
+        return `${this._instanceHash}:${this.worldMatrixDet >= 0}`;
+    }
+    /**
+   * {@inheritDoc Drawable.getInstanceColor}
+   */ getInstanceColor() {
+        return this._instanceColor;
+    }
+    /**
+   * {@inheritDoc Drawable.getPickTarget }
+   */ getPickTarget() {
+        return this;
+    }
+    /** Wether the mesh node casts shadows */ get castShadow() {
+        return this._castShadow;
+    }
+    set castShadow(b) {
+        this._castShadow = b;
+    }
+    /** Primitive of the mesh */ get primitive() {
+        return this._primitive;
+    }
+    set primitive(prim) {
+        if (prim !== this._primitive) {
+            if (this._primitive) {
+                this._primitive.removeBoundingboxChangeCallback(this._bboxChangeCallback);
+            }
+            this._primitive = prim || null;
+            if (this._primitive) {
+                this._primitive.addBoundingboxChangeCallback(this._bboxChangeCallback);
+            }
+            this._instanceHash = this._primitive && this._material ? `${this.constructor.name}:${this._scene.id}:${this._primitive.id}:${this._material.id}` : null;
+            this.invalidateBoundingVolume();
+        }
+    }
+    /** Material of the mesh */ get material() {
+        return this._material;
+    }
+    set material(m) {
+        if (this._material !== m) {
+            this._material = m;
+            this._instanceHash = this._primitive && this._material ? `${this.constructor.name}:${this._scene.id}:${this._primitive.id}:${this._material.id}` : null;
+        }
+    }
+    /** Wether to draw the bounding box of the mesh node */ get drawBoundingBox() {
+        return !!this._boundingBoxNode;
+    }
+    set drawBoundingBox(val) {
+        if (!!this._boundingBoxNode !== !!val) {
+            if (!val) {
+                this._boundingBoxNode.remove();
+                this._boundingBoxNode = null;
+            } else {
+                if (!Mesh._defaultBoxFrame) {
+                    Mesh._defaultBoxFrame = new BoxFrameShape({
+                        size: 1
+                    });
+                }
+                this._boundingBoxNode = new Mesh(this._scene, Mesh._defaultBoxFrame).reparent(this);
+                this._boundingBoxNode.scale.set(this.getBoundingVolume().toAABB().size);
+                this._boundingBoxNode.position.set(this.getBoundingVolume().toAABB().minPoint);
+            }
+        }
+    }
+    /**
+   * {@inheritDoc SceneNode.isMesh}
+   */ isMesh() {
+        return true;
+    }
+    /**
+   * Sets the bounding box for animation
+   * @param bbox - The bounding box for animation
+   */ setAnimatedBoundingBox(bbox) {
+        this._animatedBoundingBox = bbox;
+        this.invalidateBoundingVolume();
+    }
+    /**
+   * Sets the texture that contains the bone matrices for skeletal animation
+   * @param matrices - The texture that contains the bone matrices
+   */ setBoneMatrices(matrices) {
+        this._boneMatrices = matrices;
+    }
+    /**
+   * Sets the inverse bind matrix for skeletal animation
+   * @param matrix - The matrix to set
+   */ setInvBindMatrix(matrix) {
+        this._invBindMatrix = matrix;
+    }
+    /**
+   * {@inheritDoc Drawable.isBatchable}
+   */ isBatchable() {
+        return this._batchable && !this._boneMatrices;
+    }
+    /** Disposes the mesh node */ dispose() {
+        this._primitive = null;
+        this._material = null;
+        super.dispose();
+    }
+    /**
+   * {@inheritDoc Drawable.isTransparency}
+   */ isTransparency() {
+        return !!this.material?.isTransparent();
+    }
+    /**
+   * {@inheritDoc Drawable.isUnlit}
+   */ isUnlit() {
+        return !this.material?.supportLighting();
+    }
+    /**
+   * {@inheritDoc Drawable.draw}
+   */ draw(ctx) {
+        this.material.draw(this.primitive, ctx);
+    }
+    /**
+   * {@inheritDoc Drawable.getBoneMatrices}
+   */ getBoneMatrices() {
+        return this._boneMatrices;
+    }
+    /**
+   * {@inheritDoc Drawable.getInvBindMatrix}
+   */ getInvBindMatrix() {
+        return this._invBindMatrix;
+    }
+    /**
+   * {@inheritDoc Drawable.getXForm}
+   */ getXForm() {
+        // mesh transform should be ignored when skinned
+        return this;
+    }
+    /** @internal */ computeBoundingVolume(bv) {
+        let bbox;
+        if (this._animatedBoundingBox) {
+            bbox = this._animatedBoundingBox;
+        } else {
+            const primitive = this.primitive;
+            bbox = primitive ? primitive.getBoundingVolume() : null;
+        }
+        if (bbox && this._boundingBoxNode) {
+            this._boundingBoxNode.scale.set(bbox.toAABB().size);
+            this._boundingBoxNode.position.set(bbox.toAABB().minPoint);
+        }
+        return bbox;
+    }
+    /** @internal */ _onBoundingboxChange() {
+        this.invalidateBoundingVolume();
+    }
+    /** @internal */ static _defaultMaterial = null;
+    /** @internal */ static _defaultBoxFrame = null;
+    /** @internal */ static _getDefaultMaterial() {
+        if (!this._defaultMaterial) {
+            this._defaultMaterial = new StandardMaterial();
+            this._defaultMaterial.lightModel = new LambertLightModel();
+        }
+        return this._defaultMaterial;
+    }
+}
+
+export { Mesh };
+//# sourceMappingURL=mesh.js.map

package/dist/scene/mesh.js.map

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

package/dist/scene/model.js

@@ -0,0 +1,111 @@
+import { AnimationClip } from '../animation/animation.js';
+import { GraphNode } from './graph_node.js';
+
+/**
+ * Model node
+ * @public
+ */ class Model extends GraphNode {
+    /** @internal */ _animations;
+    /** @internal */ _animationIndex;
+    /** @internal */ _updateCallback;
+    /**
+   * Creates an instance of model node
+   * @param scene - The scene to which the model belongs
+   */ constructor(scene){
+        super(scene);
+        this._animations = {};
+        this._animationIndex = 0;
+        this._updateCallback = (evt)=>{
+            if (this.attached) {
+                this.update();
+            }
+        };
+    }
+    /**
+   * Creates a new animation for the model
+   * @param name - Name of the animation to be created
+   * @returns The created animation
+   */ createAnimation(name) {
+        if (!name) {
+            for(;;){
+                name = `animation${this._animationIndex++}`;
+                if (!this._animationIndex[name]) {
+                    break;
+                }
+            }
+        }
+        if (this._animations[name]) {
+            console.error(`Model.createAnimation() failed: animation '${name}' already exists`);
+            return null;
+        } else {
+            const ani = new AnimationClip(name, this);
+            this._animations[name] = ani;
+            return ani;
+        }
+    }
+    /**
+   * Deletes an animation of this model
+   * @param name - Name of the animation to be deleted
+   */ deleteAnimation(name) {
+        this.stopAnimation(name);
+        delete this._animations[name];
+    }
+    /**
+   * Gets names of all the animations of the model
+   * @returns An array of string that contains the animation names
+   */ getAnimationNames() {
+        return Object.keys(this._animations);
+    }
+    /**
+   * Updates all animations of the model
+   */ update() {
+        for(const k in this._animations){
+            this._animations[k].update();
+        }
+    }
+    /**
+   * Checks whether an animation is playing
+   * @param name - Name of the animation to be checked
+   * @returns true if the animation is playing, otherwise false
+   */ isPlayingAnimation(name) {
+        if (name) {
+            return this._animations[name]?.isPlaying();
+        } else {
+            for(const k in this._animations){
+                if (this._animations[k].isPlaying()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    /**
+   * Starts playing an animation of the model
+   * @param name - Name of the animation to play
+   * @param repeat - The repeat times, 0 for always repeating
+   */ playAnimation(name, repeat = 1) {
+        const ani = this._animations[name];
+        if (ani && !ani.isPlaying()) {
+            for (const name of this.getAnimationNames()){
+                if (this.isPlayingAnimation(name)) {
+                    this.stopAnimation(name);
+                }
+            }
+            ani.play(repeat, 1);
+            this.scene.on('sceneupdate', this._updateCallback);
+        }
+    }
+    /**
+   * Stops playing an animation of the model
+   * @param name - Name of the animation to stop playing
+   */ stopAnimation(name) {
+        const isPlaying = this.isPlayingAnimation();
+        this._animations[name]?.stop();
+        if (isPlaying && !this.isPlayingAnimation()) {
+            this.scene.off('sceneupdate', this._updateCallback);
+        }
+    }
+}
+
+export { Model };
+//# sourceMappingURL=model.js.map

package/dist/scene/model.js.map

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