@zephyr3d/scene 0.1.0

package/dist/scene/raycast_visitor.js

@@ -0,0 +1,72 @@
+import { Ray, Vector3 } from '@zephyr3d/base';
+import { OctreeNode } from './octree.js';
+
+/** @internal */ class RaycastVisitor {
+    /** @internal */ _ray;
+    /** @internal */ _rayLocal;
+    /** @internal */ _intersected;
+    /** @internal */ _intersectedDist;
+    constructor(ray, length){
+        this._ray = ray;
+        this._rayLocal = new Ray();
+        this._intersected = null;
+        this._intersectedDist = length;
+    }
+    get intersected() {
+        return this._intersected;
+    }
+    get intersectedDist() {
+        return this._intersectedDist;
+    }
+    get intersectedPoint() {
+        return Vector3.add(this._ray.origin, Vector3.scale(this._ray.direction, this._intersectedDist));
+    }
+    visit(target) {
+        if (target instanceof OctreeNode) {
+            return this.visitOctreeNode(target);
+        }
+        if (target.isMesh()) {
+            return this.visitMesh(target);
+        } else if (target.isTerrain()) {
+            return this.visitTerrain(target);
+        }
+        return false;
+    }
+    visitTerrain(node) {
+        if (!node.hidden && node.pickable) {
+            this._ray.transform(node.invWorldMatrix, this._rayLocal);
+            const d = node.rayIntersect(this._rayLocal); // this._rayLocal.bboxIntersectionTestEx(node.getBoundingVolume().toAABB());
+            if (d !== null && d < this._intersectedDist) {
+                this._intersectedDist = d;
+                this._intersected = node;
+                return true;
+            }
+        }
+        return false;
+    }
+    visitMesh(node) {
+        if (!node.hidden && node.pickable) {
+            this._ray.transform(node.invWorldMatrix, this._rayLocal);
+            const d = node.primitive.raycast(this._rayLocal);
+            if (d !== null && d < this._intersectedDist) {
+                this._intersectedDist = d;
+                this._intersected = node.getPickTarget() ?? node;
+                return true;
+            }
+        }
+        return false;
+    }
+    visitOctreeNode(node) {
+        if (node.getLevel() === 0 || this._ray.bboxIntersectionTest(node.getBoxLoosed()) !== null) {
+            const nodes = node.getNodes();
+            for(let i = 0; i < nodes.length; i++){
+                this.visit(nodes[i]);
+            }
+            return true;
+        }
+        return false;
+    }
+}
+
+export { RaycastVisitor };
+//# sourceMappingURL=raycast_visitor.js.map

package/dist/scene/raycast_visitor.js.map

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

package/dist/scene/scene.js

@@ -0,0 +1,225 @@
+import { makeEventTarget, Vector4, Vector3, Ray, nextPowerOf2 } from '@zephyr3d/base';
+import { SceneNode } from './scene_node.js';
+import { Octree } from './octree.js';
+import { OctreeUpdateVisitor } from './octree_update_visitor.js';
+import { Material } from '../material/material.js';
+import '@zephyr3d/device';
+import '../shaders/framework.js';
+import { Application } from '../app.js';
+import '../render/scatteringlut.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/lightmodel.js';
+import { RaycastVisitor } from './raycast_visitor.js';
+import { Environment } from './environment.js';
+
+/**
+ * Event that will be fired when the scene needs to be updated
+ * @public
+ */ class SceneUpdateEvent {
+    static NAME = 'sceneupdate';
+    scene;
+    type = SceneUpdateEvent.NAME;
+    constructor(scene){
+        this.scene = scene;
+    }
+}
+/**
+ * Presents a world that manages a couple of objects that will be rendered
+ * @public
+ */ class Scene extends makeEventTarget(Object)() {
+    /** @internal */ static _nextId = 0;
+    /** @internal */ _rootNode;
+    /** @internal */ _octree;
+    /** @internal */ _nodePlaceList;
+    /** @internal */ _env;
+    /** @internal */ _updateEvent;
+    /** @internal */ _updateFrame;
+    /** @internal */ _worldUnit;
+    /** @internal */ _animationSet;
+    /** @internal */ _id;
+    /**
+   * Creates an instance of scene
+   */ constructor(){
+        super();
+        this._id = ++Scene._nextId;
+        this._octree = new Octree(this, 2048, 64);
+        this._nodePlaceList = new Set();
+        this._env = new Environment();
+        this._updateEvent = new SceneUpdateEvent(this);
+        this._updateFrame = -1;
+        this._worldUnit = 1;
+        this._animationSet = [];
+        this._rootNode = new SceneNode(this);
+    }
+    /** @internal */ get animationSet() {
+        return this._animationSet;
+    }
+    /**
+   * Gets the unique identifier of the scene
+   */ get id() {
+        return this._id;
+    }
+    /** How many meters a unit corresponds to. */ get worldUnit() {
+        return this._worldUnit;
+    }
+    set worldUnit(val) {
+        this._worldUnit = val;
+    }
+    /**
+   * Gets the root scene node of the scene
+   */ get rootNode() {
+        return this._rootNode;
+    }
+    /**
+   * Gets the octree
+   */ get octree() {
+        // Make sure the octree state is up to date
+        this.updateNodePlacement(this._octree, this._nodePlaceList);
+        return this._octree;
+    }
+    /**
+   * Gets the bounding box of the scene
+   */ get boundingBox() {
+        this.updateNodePlacement(this._octree, this._nodePlaceList);
+        // this._syncBVChangedList();
+        return this._octree.getRootNode().getBox() || this._octree.getRootNode().getBoxLoosed();
+    }
+    /**
+   * The environment of the scene
+   */ get env() {
+        return this._env;
+    }
+    /**
+   * Disposes the scene
+   */ dispose() {
+        this._rootNode = null;
+    }
+    /**
+   * Cast a ray into the scene to get the closest object hit by the ray
+   * @param camera - The camera used to compute the ray
+   * @param screenX - The x position on screen
+   * @param screenY - The y position on screen
+   * @returns The closest object hit by the ray
+   */ raycast(camera, screenX, screenY) {
+        const width = camera.viewport ? camera.viewport[2] : Application.instance.device.getViewport().width;
+        const height = camera.viewport ? camera.viewport[3] : Application.instance.device.getViewport().height;
+        const ray = this.constructRay(camera, width, height, screenX, screenY);
+        const raycastVisitor = new RaycastVisitor(ray, camera.getFarPlane());
+        this.octree.getRootNode().traverse(raycastVisitor);
+        return raycastVisitor.intersected ? {
+            node: raycastVisitor.intersected,
+            dist: raycastVisitor.intersectedDist,
+            point: raycastVisitor.intersectedPoint
+        } : null;
+    }
+    /**
+   * Constructs a ray by a given camera and the position on screen
+   * @param camera - The camera used to compute the ray
+   * @param viewportWidth - Width of the viewport
+   * @param viewportHeight - Height of the viewport
+   * @param screenX - The x position on screen
+   * @param screenY - The y position on screen
+   * @param invModelMatrix - A matrix used to transform the ray
+   * @returns The constructed ray
+   */ constructRay(camera, viewportWidth, viewportHeight, screenX, screenY, invModelMatrix) {
+        const vClip = new Vector4(2 * screenX / viewportWidth - 1, 1 - 2 * screenY / viewportHeight, 1, 1);
+        const vWorld = camera.invViewProjectionMatrix.transform(vClip);
+        vWorld.scaleBy(1 / vWorld.w);
+        let vEye = camera.getWorldPosition();
+        let vDir = Vector3.sub(vWorld.xyz(), vEye).inplaceNormalize();
+        if (invModelMatrix) {
+            vEye = invModelMatrix.transformPointAffine(vEye);
+            vDir = invModelMatrix.transformVectorAffine(vDir);
+        }
+        return new Ray(vEye, vDir);
+    }
+    /** @internal */ invalidateNodePlacement(node) {
+        this._nodePlaceList.add(node);
+    }
+    /** @internal */ _xformChanged(node) {
+        this._nodePlaceList.add(node);
+    }
+    /** @internal */ frameUpdate() {
+        const frameInfo = Application.instance.device.frameInfo;
+        if (frameInfo.frameCounter !== this._updateFrame) {
+            this._updateFrame = frameInfo.frameCounter;
+            // uniform buffer garbage collect
+            if (!Material.getGCOptions().disabled) {
+                Material.garbageCollect(frameInfo.frameTimestamp);
+            }
+            for (const an of this._animationSet){
+                an.update();
+            }
+            // check environment lighting
+            if (this.env.light.type === 'ibl') {
+                if (!this.env.light.radianceMap) {
+                    if (this.env.sky.skyType !== 'none') {
+                        this.env.light.radianceMap = this.env.sky.radianceMap;
+                    }
+                } else if (this.env.light.radianceMap === this.env.sky.radianceMap) {
+                    if (this.env.sky.skyType === 'none') {
+                        this.env.light.radianceMap = null;
+                    }
+                }
+                if (!this.env.light.irradianceMap) {
+                    if (this.env.sky.skyType !== 'none') {
+                        this.env.light.irradianceMap = this.env.sky.irradianceMap;
+                    }
+                } else if (this.env.light.irradianceMap === this.env.sky.irradianceMap) {
+                    if (this.env.sky.skyType === 'none') {
+                        this.env.light.irradianceMap = null;
+                    }
+                }
+            }
+            // update scene objects first
+            this.dispatchEvent(this._updateEvent);
+            this.updateNodePlacement(this._octree, this._nodePlaceList);
+        }
+    }
+    /**
+   * Update node placement in the octree
+   */ updateNodePlacement(octree, list) {
+        function placeNode(node, attached) {
+            if (node.isGraphNode()) {
+                if (attached && !node.hidden) {
+                    octree.placeNode(node);
+                } else {
+                    octree.removeNode(node);
+                }
+            }
+            for (const child of node.children){
+                if (child.isGraphNode()) {
+                    placeNode(child, attached);
+                }
+            }
+            list.delete(node);
+        }
+        if (list.size > 0) {
+            while(list.size > 0){
+                const node = list.keys().next().value;
+                if (octree) {
+                    placeNode(node, node.attached);
+                } else {
+                    list.delete(node);
+                }
+            }
+            if (octree) {
+                const worldBox = octree.getRootNode().getBox();
+                if (worldBox) {
+                    const radius = Math.max(Math.abs(worldBox.minPoint.x), Math.abs(worldBox.minPoint.y), Math.abs(worldBox.minPoint.z), Math.abs(worldBox.maxPoint.x), Math.abs(worldBox.maxPoint.y), Math.abs(worldBox.maxPoint.z));
+                    const rootSize = nextPowerOf2(radius * 2);
+                    if (rootSize > octree.getRootSize()) {
+                        octree.initialize(rootSize, octree.getLeafSize());
+                        const v = new OctreeUpdateVisitor(octree);
+                        this._rootNode.traverse(v);
+                    }
+                }
+            }
+        }
+    }
+}
+
+export { Scene, SceneUpdateEvent };
+//# sourceMappingURL=scene.js.map

package/dist/scene/scene.js.map

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

package/dist/scene/scene_node.js

@@ -0,0 +1,299 @@
+import { XForm } from './xform.js';
+
+/**
+ * The base class for any kind of scene objects
+ *
+ * @remarks
+ * We use a data structure called SceneGraph to store scenes,
+ * which consists of a couple of scene objects forming a
+ * hierarchical structure. This is the base class for any kind
+ * of the scene object, which contains the basic properties such
+ * as position, rotation, and scale of the object.
+ *
+ * @public
+ */ class SceneNode extends XForm {
+    static CLIP_INHERITED = -1;
+    static CLIP_DISABLED = 0;
+    static CLIP_ENABLED = 1;
+    static SHOW_INHERITED = -1;
+    static SHOW_HIDE = 0;
+    static SHOW_DEFAULT = 1;
+    static PICK_INHERITED = -1;
+    static PICK_DISABLED = 0;
+    static PICK_ENABLED = 1;
+    static BBOXDRAW_INHERITED = -1;
+    static BBOXDRAW_DISABLED = 0;
+    static BBOXDRAW_LOCAL = 1;
+    static BBOXDRAW_WORLD = 2;
+    /** @internal */ _clipMode;
+    /** @internal */ _renderOrder;
+    /** @internal */ _boxDrawMode;
+    /** @internal */ _visible;
+    /** @internal */ _pickMode;
+    /** @internal */ _name;
+    /** @internal */ _scene;
+    /** @internal */ _bv;
+    /** @internal */ _bvDirty;
+    /** @internal */ _bvWorld;
+    /**
+   * Creates a new scene node
+   * @param scene - Which scene the node belongs to
+   */ constructor(scene){
+        super();
+        this._scene = scene;
+        this._name = '';
+        this._bv = null;
+        this._bvWorld = null;
+        this._bvDirty = true;
+        this._clipMode = SceneNode.CLIP_ENABLED;
+        this._boxDrawMode = SceneNode.BBOXDRAW_DISABLED;
+        this._visible = SceneNode.SHOW_DEFAULT;
+        this._pickMode = SceneNode.PICK_DISABLED;
+        if (scene && this !== scene.rootNode) {
+            this.reparent(scene.rootNode);
+        }
+    }
+    /**
+   * Name of the scene node
+   */ get name() {
+        return this._name;
+    }
+    set name(val) {
+        this._name = val || '';
+    }
+    /** The scene to which the node belongs */ get scene() {
+        return this._scene;
+    }
+    /** true if the node is attached to the scene node, false otherwise */ get attached() {
+        return !!this._scene?.rootNode?.isParentOf(this);
+    }
+    /**
+   * Check if given node is a direct child of the node
+   * @param child - The node to be checked
+   * @returns true if the given node is a direct child of this node, false otherwise
+   */ hasChild(child) {
+        return this._children.indexOf(child) >= 0;
+    }
+    /**
+   * Removes all children from this node
+   */ removeChildren() {
+        while(this._children.length){
+            this._children[0].remove();
+        }
+    }
+    /**
+   * Checks if this node is the direct parent or indirect parent of a given node
+   * @param child - The node to be checked
+   * @returns true if this node is the direct parent or indirect parent of the given node, false otherwise
+   */ isParentOf(child) {
+        while(child && child !== this){
+            child = child.parent;
+        }
+        return child === this;
+    }
+    /**
+   * Removes this node from it's parent
+   * @returns self
+   */ remove() {
+        this.parent = null;
+        return this;
+    }
+    /**
+   * Traverse the entire subtree of this node by a visitor
+   * @param v - The visitor that will travel the subtree of this node
+   * @param inverse - true if traversing from bottom to top, otherwise top to bottom
+   */ traverse(v, inverse) {
+        if (inverse) {
+            for(let i = this._children.length - 1; i >= 0; i--){
+                this._children[i].traverse(v, inverse);
+            }
+            v.visit(this);
+        } else {
+            v.visit(this);
+            for (const child of this._children){
+                child.traverse(v);
+            }
+        }
+    }
+    /**
+   * Iterate self and all of the children
+   * @param callback - callback function that will be called on each node
+   */ iterate(callback) {
+        callback(this);
+        for (const child of this._children){
+            child.iterate(callback);
+        }
+    }
+    /** true if this is a graph node, false otherwise */ isGraphNode() {
+        return false;
+    }
+    /** true if this is a light node, false otherwise */ isLight() {
+        return false;
+    }
+    /** true if this is a mesh node, false otherwise */ isMesh() {
+        return false;
+    }
+    /** true if this is a terrain node, false otherwise */ isTerrain() {
+        return false;
+    }
+    /** true if this is a camera node, false otherwise */ isCamera() {
+        return false;
+    }
+    /** true if this is a punctual light node, false otherwise */ isPunctualLight() {
+        return false;
+    }
+    /** Disposes the node */ dispose() {
+        this.remove();
+        this.removeChildren();
+    }
+    /**
+   * Computes the bounding volume of the node
+   * @param bv - The output bounding volume
+   * @returns The output bounding volume
+   */ computeBoundingVolume(bv) {
+        return bv;
+    }
+    /**
+   * Gets the bounding volume of the node
+   * @returns The bounding volume of the node
+   */ getBoundingVolume() {
+        if (this._bvDirty) {
+            this._bv = this.computeBoundingVolume(this._bv) || null;
+            this._bvDirty = false;
+        }
+        return this._bv;
+    }
+    /**
+   * Sets the bounding volume of the node
+   * @param bv - The bounding volume to set
+   */ setBoundingVolume(bv) {
+        if (bv !== this._bv) {
+            this._bv = bv;
+            this.invalidateBoundingVolume();
+        }
+    }
+    /**
+   * Gets the world space bounding volume of the node
+   * @returns The world space bounding volume of the node
+   */ getWorldBoundingVolume() {
+        if (!this._bvWorld) {
+            this._bvWorld = this.getBoundingVolume()?.transform(this.worldMatrix) ?? null;
+        }
+        return this._bvWorld;
+    }
+    /**
+   * Force the bounding volume to be recalculated
+   */ invalidateBoundingVolume() {
+        this._bvDirty = true;
+        this.invalidateWorldBoundingVolume();
+    }
+    /** Force the world space bounding volume to be recalculated */ invalidateWorldBoundingVolume() {
+        this._bvWorld = null;
+        this._scene?.invalidateNodePlacement(this);
+    }
+    /**
+   * Computed value of clip mode
+   */ get computedClipMode() {
+        if (this._clipMode === SceneNode.CLIP_INHERITED) {
+            let parent = this.parent;
+            while(parent && !parent.isGraphNode()){
+                parent = parent.parent;
+            }
+            return parent?.computedClipMode ?? SceneNode.CLIP_ENABLED;
+        }
+        return this._clipMode;
+    }
+    /** Clip mode */ get clipMode() {
+        return this._clipMode;
+    }
+    set clipMode(val) {
+        this._clipMode = val;
+    }
+    /** Computed value of show state */ get hidden() {
+        if (this._visible === SceneNode.SHOW_INHERITED) {
+            let parent = this.parent;
+            while(parent && !parent.isGraphNode()){
+                parent = parent.parent;
+            }
+            return parent?.hidden ?? false;
+        }
+        return this._visible === SceneNode.SHOW_HIDE;
+    }
+    /** Show state */ get showState() {
+        return this._visible;
+    }
+    set showState(val) {
+        if (val !== this._visible) {
+            const prevHidden = this.hidden;
+            this._visible = val;
+            if (prevHidden !== this.hidden) {
+                this.notifyHiddenChanged();
+            }
+        }
+    }
+    /** Computed value of pick mode */ get pickable() {
+        if (this._pickMode === SceneNode.PICK_INHERITED) {
+            let parent = this.parent;
+            while(parent && !parent.isGraphNode()){
+                parent = parent.parent;
+            }
+            return parent?.pickable ?? false;
+        }
+        return this._pickMode !== SceneNode.PICK_DISABLED;
+    }
+    /** Pick mode */ get pickMode() {
+        return this._pickMode;
+    }
+    set pickMode(val) {
+        this._pickMode = val;
+    }
+    /** Computed value for bounding box draw mode */ get computedBoundingBoxDrawMode() {
+        if (this._boxDrawMode === SceneNode.BBOXDRAW_INHERITED) {
+            let parent = this.parent;
+            while(parent && !parent.isGraphNode()){
+                parent = parent.parent;
+            }
+            return parent?.computedBoundingBoxDrawMode ?? SceneNode.BBOXDRAW_DISABLED;
+        }
+        return this._boxDrawMode;
+    }
+    /** Bounding box draw mode */ get boundingBoxDrawMode() {
+        return this._boxDrawMode;
+    }
+    set boundingBoxDrawMode(mode) {
+        this._boxDrawMode = mode;
+    }
+    /** @internal */ _setParent(p) {
+        if (p !== this._parent) {
+            const sceneLast = this.attached ? this.scene : null;
+            const sceneNew = p?.attached ? p.scene : null;
+            const willDetach = sceneLast && sceneLast !== sceneNew;
+            const willAttach = sceneNew && sceneLast !== sceneNew;
+            willDetach && this._willDetach();
+            willAttach && this._willAttach();
+            super._setParent(p);
+            willDetach && this._detached();
+            willAttach && this._attached();
+        }
+    }
+    /** @internal */ _onTransformChanged(invalidateLocal) {
+        super._onTransformChanged(invalidateLocal);
+        this.invalidateWorldBoundingVolume();
+    }
+    /** @internal */ _willAttach() {}
+    /** @internal */ _attached() {}
+    /** @internal */ _willDetach() {}
+    /** @internal */ _detached() {}
+    /** @internal */ notifyHiddenChanged() {
+        this._visibleChanged();
+        for (const child of this._children){
+            if (child.isGraphNode() && child.showState === SceneNode.SHOW_INHERITED) {
+                child.notifyHiddenChanged();
+            }
+        }
+    }
+    /** @internal */ _visibleChanged() {}
+}
+
+export { SceneNode };
+//# sourceMappingURL=scene_node.js.map

package/dist/scene/scene_node.js.map

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