@zephyr3d/scene 0.1.0

package/dist/asset/loaders/loader.js

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

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

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

package/dist/asset/model.js

@@ -0,0 +1,264 @@
+import { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';
+
+/**
+ * Named object interface for model loading
+ * @public
+ */ class NamedObject {
+    name;
+    /**
+   * Creates an instance of NamedObject
+   * @param name - Name of the object
+   */ constructor(name){
+        this.name = name;
+    }
+}
+/**
+ * Heirarchical node interface for model loading
+ * @public
+ */ class AssetHierarchyNode extends NamedObject {
+    _parent;
+    _position;
+    _rotation;
+    _scaling;
+    _mesh;
+    _skeleton;
+    _attachToSkeleton;
+    _attachIndex;
+    _meshAttached;
+    _matrix;
+    _worldMatrix;
+    _children;
+    /**
+   * Creates an instance of AssetHierarchyNode
+   * @param name - Name of the node
+   * @param parent - Parent of the node
+   */ constructor(name, parent){
+        super(name);
+        this._parent = null;
+        this._position = Vector3.zero();
+        this._rotation = Quaternion.identity();
+        this._scaling = Vector3.one();
+        this._children = [];
+        this._mesh = null;
+        this._skeleton = null;
+        this._attachToSkeleton = null;
+        this._meshAttached = false;
+        this._attachIndex = -1;
+        this._matrix = null;
+        this._worldMatrix = null;
+        parent?.addChild(this);
+    }
+    /** Parent of the node */ get parent() {
+        return this._parent;
+    }
+    /** Local transformation matrix of the node */ get matrix() {
+        return this._matrix;
+    }
+    /** World transformation matrix of the node */ get worldMatrix() {
+        return this._worldMatrix;
+    }
+    /** Mesh data of the node, or null if this is not a mesh node */ get mesh() {
+        return this._mesh;
+    }
+    set mesh(data) {
+        this._mesh = data;
+        this.setMeshAttached();
+    }
+    /** The skeleton used to control the node */ get skeleton() {
+        return this._skeleton;
+    }
+    set skeleton(skeleton) {
+        this._skeleton = skeleton;
+    }
+    /** The translation of the node */ get position() {
+        return this._position;
+    }
+    set position(val) {
+        this._position = val;
+    }
+    /** The rotation of the node */ get rotation() {
+        return this._rotation;
+    }
+    set rotation(val) {
+        this._rotation = val;
+    }
+    /** The scale of the node */ get scaling() {
+        return this._scaling;
+    }
+    set scaling(val) {
+        this._scaling = val;
+    }
+    /** true if the node is parent of a mesh node */ get meshAttached() {
+        return this._meshAttached;
+    }
+    /** Children of the node */ get children() {
+        return this._children;
+    }
+    /** The skeleton to which the node belongs if this is a joint node */ get skeletonAttached() {
+        return this._attachToSkeleton;
+    }
+    /** The joint index if this is a joint node */ get attachIndex() {
+        return this._attachIndex;
+    }
+    /** @internal */ computeTransforms(parentTransform) {
+        this._matrix = Matrix4x4.scaling(this._scaling).rotateLeft(this._rotation).translateLeft(this._position);
+        this._worldMatrix = parentTransform ? Matrix4x4.multiply(parentTransform, this._matrix) : new Matrix4x4(this._matrix);
+        for (const child of this._children){
+            child.computeTransforms(this._worldMatrix);
+        }
+    }
+    /**
+   * Adds a child to this node
+   * @param child - The child node to be added
+   */ addChild(child) {
+        if (!child || child.parent) {
+            throw new Error('AssetHierarchyNode.addChild(): invalid child node');
+        }
+        this._children.push(child);
+        child._parent = this;
+        if (child.meshAttached) {
+            this.setMeshAttached();
+        }
+    }
+    /**
+   * Removes a child of this node
+   * @param child - The child node to be removed
+   */ removeChild(child) {
+        const index = this._children.indexOf(child);
+        if (index < 0) {
+            throw new Error('AssetHierarchyNode.removeChild(): invalid child node');
+        }
+        this._children[index]._parent = null;
+        this._children.splice(index, 1);
+    }
+    /**
+   * Attach this node to a skeleton
+   * @param skeleton - The skeleton to which to node will attach
+   * @param index - The joint index
+   */ attachToSkeleton(skeleton, index) {
+        if (this._attachToSkeleton && skeleton !== this._attachToSkeleton) {
+            throw new Error(`joint can not attached to multiple skeletons`);
+        }
+        this._attachToSkeleton = skeleton;
+        this._attachIndex = index;
+    }
+    /** @internal */ setMeshAttached() {
+        this._meshAttached = true;
+        this._parent?.setMeshAttached();
+    }
+}
+/**
+ * Skeleton information for model loading
+ * @public
+ */ class AssetSkeleton extends NamedObject {
+    /** The pivot node */ pivot;
+    /** Joints of the skeleton */ joints;
+    /** Inverse of the binding matrices of the joints */ inverseBindMatrices;
+    /** Binding pose matrices of the joints */ bindPoseMatrices;
+    /**
+   * Creates an instance of AssetSkeleton
+   * @param name - Name of the skeleton
+   */ constructor(name){
+        super(name);
+        this.name = name;
+        this.pivot = null;
+        this.joints = [];
+        this.inverseBindMatrices = [];
+        this.bindPoseMatrices = [];
+    }
+    /**
+   * Adds a joint to the skeleton
+   * @param joint - The joint node
+   * @param inverseBindMatrix - Inverse binding matrix of the joint
+   */ addJoint(joint, inverseBindMatrix) {
+        joint.attachToSkeleton(this, this.joints.length);
+        this.joints.push(joint);
+        this.inverseBindMatrices.push(inverseBindMatrix);
+        this.bindPoseMatrices.push(joint.worldMatrix);
+    }
+}
+/**
+ * Scene for model loading
+ * @public
+ */ class AssetScene extends NamedObject {
+    /** Root nodes of the scene */ rootNodes;
+    /**
+   * Creates an instance of AssetScene
+   * @param name - Name of the scene
+   */ constructor(name){
+        super(name);
+        this.rootNodes = [];
+    }
+}
+/**
+ * Model information that can be shared by multiple model nodes
+ * @public
+ */ class SharedModel {
+    /** @internal */ _name;
+    /** @internal */ _skeletons;
+    /** @internal */ _nodes;
+    /** @internal */ _animations;
+    /** @internal */ _scenes;
+    /** @internal */ _activeScene;
+    /**
+   * Creates an instance of SharedModel
+   * @param name - Name of the model
+   */ constructor(name){
+        this._name = name || '';
+        this._skeletons = [];
+        this._nodes = [];
+        this._scenes = [];
+        this._animations = [];
+        this._activeScene = -1;
+    }
+    /** Name of the model */ get name() {
+        return this._name;
+    }
+    set name(val) {
+        this._name = val;
+    }
+    /** All scenes that the model contains */ get scenes() {
+        return this._scenes;
+    }
+    /** All animations that the model contains */ get animations() {
+        return this._animations;
+    }
+    /** All skeletons that the model contains */ get skeletons() {
+        return this._skeletons;
+    }
+    /** All nodes that the model contains */ get nodes() {
+        return this._nodes;
+    }
+    /** The active scene of the model */ get activeScene() {
+        return this._activeScene;
+    }
+    set activeScene(val) {
+        this._activeScene = val;
+    }
+    /**
+   * Adds a node to the scene
+   * @param parent - Under which node the node should be added
+   * @param index - Index of the node
+   * @param name - Name of the node
+   * @returns The added node
+   */ addNode(parent, index, name) {
+        const childNode = new AssetHierarchyNode(name, parent);
+        this._nodes[index] = childNode;
+        return childNode;
+    }
+    /**
+   * Adds a skeleton to the scene
+   * @param skeleton - The skeleton to be added
+   */ addSkeleton(skeleton) {
+        this._skeletons.push(skeleton);
+    }
+    /**
+   * Adds an animation to the scene
+   * @param animation - The animation to be added
+   */ addAnimation(animation) {
+        this._animations.push(animation);
+    }
+}
+
+export { AssetHierarchyNode, AssetScene, AssetSkeleton, NamedObject, SharedModel };
+//# sourceMappingURL=model.js.map

package/dist/asset/model.js.map

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