@zephyr3d/scene 0.1.0

package/dist/camera/orbit.js

@@ -0,0 +1,157 @@
+import { Vector3, Quaternion } from '@zephyr3d/base';
+import { BaseCameraController } from './base.js';
+
+/**
+ * Orbit camera controller
+ * @public
+ */ class OrbitCameraController extends BaseCameraController {
+    /** @internal */ options;
+    /** @internal */ mouseDown;
+    /** @internal */ lastMouseX;
+    /** @internal */ lastMouseY;
+    /** @internal */ rotateX;
+    /** @internal */ rotateY;
+    /** @internal */ eyePos;
+    /** @internal */ upVector;
+    /** @internal */ xVector;
+    /** @internal */ target;
+    /** @internal */ direction;
+    /** @internal */ quat;
+    /** @internal */ scale;
+    /**
+   * Creates an instance of OrbitCameraController
+   * @param options - The creation options
+   */ constructor(options){
+        super();
+        this.options = Object.assign({
+            distance: 1,
+            damping: 0.1,
+            moveSpeed: 0.2,
+            rotateSpeed: 0.01,
+            zoomSpeed: 1
+        }, options || {});
+        this.rotateX = 0;
+        this.rotateY = 0;
+        this.eyePos = new Vector3();
+        this.upVector = Vector3.axisPY();
+        this.xVector = new Vector3();
+        this.target = new Vector3();
+        this.direction = new Vector3();
+        this.quat = new Quaternion();
+        this.scale = 1;
+    }
+    /**
+   * {@inheritDoc BaseCameraController.reset}
+   * @override
+   */ reset() {
+        this.mouseDown = false;
+        this.lastMouseX = 0;
+        this.lastMouseY = 0;
+        this.rotateX = 0;
+        this.rotateY = 0;
+        this.scale = 1;
+        this._loadCameraParams();
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onMouseDown}
+   * @override
+   */ _onMouseDown(evt) {
+        if (evt.button === 0) {
+            this.mouseDown = true;
+            this.lastMouseX = evt.offsetX;
+            this.lastMouseY = evt.offsetY;
+            this.rotateX = 0;
+            this.rotateY = 0;
+            return true;
+        }
+        return false;
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onMouseUp}
+   * @override
+   */ _onMouseUp(evt) {
+        if (evt.button === 0 && this.mouseDown) {
+            this.mouseDown = false;
+            return true;
+        }
+        return false;
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onMouseWheel}
+   * @override
+   */ _onMouseWheel(evt) {
+        console.log(`wheel deltaX: ${evt.deltaX}`);
+        console.log(`wheel deltaY: ${evt.deltaY}`);
+        const factor = Math.pow(0.9, Math.abs(this.options.zoomSpeed));
+        if (evt.deltaY > 0) {
+            this.scale /= factor;
+        } else {
+            this.scale *= factor;
+        }
+        return true;
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onMouseMove}
+   * @override
+   */ _onMouseMove(evt) {
+        if (this.mouseDown) {
+            const dx = evt.offsetX - this.lastMouseX;
+            const dy = evt.offsetY - this.lastMouseY;
+            this.lastMouseX = evt.offsetX;
+            this.lastMouseY = evt.offsetY;
+            this.rotateX -= dy * this.options.rotateSpeed;
+            this.rotateY -= dx * this.options.rotateSpeed;
+            return true;
+        }
+        return false;
+    }
+    /** @internal */ _loadCameraParams() {
+        if (this._getCamera()) {
+            const mat = this._getCamera().worldMatrix;
+            mat.decomposeLookAt(this.eyePos, this.target);
+            Vector3.normalize(Vector3.sub(this.eyePos, this.target), this.direction);
+            Vector3.sub(this.eyePos, Vector3.scale(this.direction, this.options.distance), this.target);
+            this.xVector.setXYZ(mat[0], mat[1], mat[2]);
+        }
+    }
+    /**
+   * Set options
+   * @param opt - options
+   */ setOptions(opt) {
+        opt && Object.assign(this.options, opt);
+        this.reset();
+    }
+    /**
+   * {@inheritDoc BaseCameraController.update}
+   * @override
+   */ update() {
+        if (this._getCamera()) {
+            Quaternion.fromAxisAngle(this.xVector, this.rotateX, this.quat);
+            this.quat.transform(this.eyePos.subBy(this.target), this.eyePos);
+            Quaternion.fromEulerAngle(0, this.rotateY, 0, 'XYZ', this.quat);
+            this.quat.transform(this.eyePos, this.eyePos);
+            this.quat.transform(this.xVector, this.xVector).inplaceNormalize();
+            Vector3.normalize(this.eyePos, this.direction).inplaceNormalize();
+            Vector3.cross(this.direction, this.xVector, this.upVector).inplaceNormalize();
+            Vector3.add(this.target, Vector3.scale(this.direction, this.options.distance * this.scale), this.eyePos);
+            this._getCamera().lookAt(this.eyePos, this.target, this.upVector);
+            // this._loadCameraParams();
+            if (this.mouseDown) {
+                this.rotateX = 0;
+                this.rotateY = 0;
+            } else {
+                this.rotateX *= 1 - this.options.damping;
+                this.rotateY *= 1 - this.options.damping;
+                if (Math.abs(this.rotateX) < 0.0001) {
+                    this.rotateX = 0;
+                }
+                if (Math.abs(this.rotateY) < 0.0001) {
+                    this.rotateY = 0;
+                }
+            }
+        }
+    }
+}
+
+export { OrbitCameraController };
+//# sourceMappingURL=orbit.js.map

package/dist/camera/orbit.js.map

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

package/dist/camera/orthocamera.js

@@ -0,0 +1,126 @@
+import { Camera } from './camera.js';
+
+/**
+ * Orthogonal camera class
+ * @public
+ */ class OrthoCamera extends Camera {
+    /** @internal */ _left;
+    _right;
+    _top;
+    _bottom;
+    _near;
+    _far;
+    /**
+   * Creates an instance of PerspectiveCamera
+   * @param scene - The scene that the camera belongs to.
+   * @param fovY - A radian value indicates the field of view in Y axis
+   * @param aspect - Aspect ratio of the perspective transform
+   * @param nearPlane - The near clip plane
+   * @param farPlane - The far clip plane
+   */ constructor(scene, left, right, bottom, top, near, far){
+        super(scene);
+        this._left = left;
+        this._right = right;
+        this._bottom = bottom;
+        this._top = top;
+        this._near = near;
+        this._far = far;
+        this._invalidate(true);
+    }
+    /** The near clip plane */ get near() {
+        return this._near;
+    }
+    set near(val) {
+        if (val !== this._near) {
+            this._near = val;
+            this._invalidate(true);
+        }
+    }
+    /** The far clip plane */ get far() {
+        return this._far;
+    }
+    set far(val) {
+        if (val !== this._far) {
+            this._far = val;
+            this._invalidate(true);
+        }
+    }
+    /** The left clip plane */ get left() {
+        return this._left;
+    }
+    set left(val) {
+        if (val !== this._left) {
+            this._left = val;
+            this._invalidate(true);
+        }
+    }
+    /** The right clip plane */ get right() {
+        return this._right;
+    }
+    set right(val) {
+        if (val !== this._right) {
+            this._right = val;
+            this._invalidate(true);
+        }
+    }
+    /** The top clip plane */ get top() {
+        return this._top;
+    }
+    set top(val) {
+        if (val !== this._top) {
+            this._top = val;
+            this._invalidate(true);
+        }
+    }
+    /** The bottom clip plane */ get bottom() {
+        return this._bottom;
+    }
+    set bottom(val) {
+        if (val !== this._bottom) {
+            this._bottom = val;
+            this._invalidate(true);
+        }
+    }
+    /**
+   * Not valid for OrthoCamera
+   *
+   * @remarks
+   * This method is only valid for {@link Camera} class or {@link PerspectiveCamera} class.
+   */ setPerspective() {
+        throw new Error(`setPerspective() not allowed on OrthoCamera`);
+    }
+    /**
+   * {@inheritDoc Camera.setOrtho}
+   */ setOrtho(left, right, bottom, top, near, far) {
+        this._left = left;
+        this._right = right;
+        this._bottom = bottom;
+        this._top = top;
+        this._near = near;
+        this._far = far;
+        this._invalidate(true);
+        return this;
+    }
+    /**
+   * Setup a projection matrix for the camera
+   * @param matrix - The projection matrix
+   */ setProjectionMatrix(matrix) {
+        if (matrix && matrix !== this._projMatrix && matrix.isOrtho()) {
+            this._left = matrix.getLeftPlane();
+            this._right = matrix.getRightPlane();
+            this._near = matrix.getNearPlane();
+            this._far = matrix.getFarPlane();
+            this._top = matrix.getTopPlane();
+            this._bottom = matrix.getBottomPlane();
+            this._invalidate(true);
+        } else {
+            throw new Error(`OrthoCamera.setProjectionMatrix(): param is not an orthogonal projection matrix`);
+        }
+    }
+    /** @internal */ _computeProj() {
+        this._projMatrix.ortho(this._left, this._right, this._bottom, this._top, this._near, this._far);
+    }
+}
+
+export { OrthoCamera };
+//# sourceMappingURL=orthocamera.js.map

package/dist/camera/orthocamera.js.map

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

package/dist/camera/perspectivecamera.js

@@ -0,0 +1,133 @@
+import { Camera } from './camera.js';
+
+/**
+ * Perspective camera class
+ * @public
+ */ class PerspectiveCamera extends Camera {
+    /** @internal */ _near;
+    _far;
+    _fovY;
+    _aspect;
+    _window;
+    /**
+   * Creates an instance of PerspectiveCamera
+   * @param scene - The scene that the camera belongs to.
+   * @param fovY - A radian value indicates the field of view in Y axis
+   * @param aspect - Aspect ratio of the perspective transform
+   * @param near - The near clip plane
+   * @param far - The far clip plane
+   */ constructor(scene, fovY, aspect, near, far){
+        super(scene);
+        this._fovY = fovY;
+        this._aspect = aspect;
+        this._near = near;
+        this._far = far;
+        this._window = null;
+        this._invalidate(true);
+    }
+    /** Sub-window of the frustum */ get window() {
+        return this._window;
+    }
+    set window(val) {
+        this._window = val ?? null;
+        this._invalidate(true);
+    }
+    /** The near clip plane */ get near() {
+        return this._near;
+    }
+    set near(val) {
+        if (val !== this._near) {
+            this._near = val;
+            this._invalidate(true);
+        }
+    }
+    /** The far clip plane */ get far() {
+        return this._far;
+    }
+    set far(val) {
+        if (val !== this._far) {
+            this._far = val;
+            this._invalidate(true);
+        }
+    }
+    /** Radian value indicates the field of view in Y axis */ get fovY() {
+        return this._fovY;
+    }
+    set fovY(val) {
+        if (val === 0) {
+            debugger;
+        }
+        if (val !== this._fovY) {
+            this._fovY = val;
+            this._invalidate(true);
+        }
+    }
+    /** Aspect ratio of the perspective transform */ get aspect() {
+        return this._aspect;
+    }
+    set aspect(val) {
+        if (val !== this._aspect) {
+            this._aspect = val;
+            this._invalidate(true);
+        }
+    }
+    /**
+   * {@inheritDoc Camera.setPerspective}
+   */ setPerspective(fovY, aspect, zNear, zFar) {
+        if (fovY === 0) {
+            debugger;
+        }
+        this._aspect = aspect;
+        this._fovY = fovY;
+        this._near = zNear;
+        this._far = zFar;
+        this._invalidate(true);
+        return this;
+    }
+    /**
+   * Not valid for PerspectiveCamera
+   *
+   * @remarks
+   * This method is only valid for {@link Camera} class or {@link OrthoCamera} class.
+   */ setOrtho(left, right, bottom, top, near, far) {
+        throw new Error(`setOrtho() not allowed on PerspectiveCamera`);
+    }
+    /**
+   * Setup a projection matrix for the camera
+   * @param matrix - The projection matrix
+   */ setProjectionMatrix(matrix) {
+        if (matrix && matrix !== this._projMatrix && matrix.isPerspective()) {
+            if (matrix.getFov() === 0) {
+                debugger;
+            }
+            this._aspect = matrix.getAspect();
+            this._fovY = matrix.getFov();
+            this._near = matrix.getNearPlane();
+            this._far = matrix.getFarPlane();
+            this._invalidate(true);
+        } else {
+            throw new Error(`PerspectiveCamera.setProjectionMatrix(): param is not a perspective projection matrix`);
+        }
+    }
+    /** @internal */ _computeProj() {
+        const h = this._near * Math.tan(this._fovY * 0.5);
+        const w = h * this._aspect;
+        let left = -w;
+        let right = w;
+        let top = h;
+        let bottom = -h;
+        if (this._window) {
+            const width = right - left;
+            const height = top - bottom;
+            left += width * this._window[0];
+            bottom += height * this._window[1];
+            right = left + width * this._window[2];
+            top = bottom + height * this._window[3];
+        }
+        this._projMatrix.frustum(left, right, bottom, top, this._near, this._far);
+    //this._projMatrix.perspective(this._fovY, this._aspect, this._near, this._far);
+    }
+}
+
+export { PerspectiveCamera };
+//# sourceMappingURL=perspectivecamera.js.map

package/dist/camera/perspectivecamera.js.map

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