@zephyr3d/scene 0.1.0

package/dist/camera/camera.js

@@ -0,0 +1,358 @@
+import { Matrix4x4, Vector4, Frustum } from '@zephyr3d/base';
+import { SceneNode } from '../scene/scene_node.js';
+import { Application } from '../app.js';
+import '../scene/octree.js';
+import '../material/material.js';
+import '@zephyr3d/device';
+import '../shaders/framework.js';
+import '../render/scatteringlut.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/lightmodel.js';
+import { ForwardRenderScheme } from '../render/forward.js';
+import '../render/sky.js';
+import '../render/clipmap.js';
+import '../render/watermesh.js';
+
+/**
+ * The camera node class
+ * @public
+ */ class Camera extends SceneNode {
+    /** @internal */ _projMatrix;
+    /** @internal */ _viewMatrix;
+    /** @internal */ _viewProjMatrix;
+    /** @internal */ _rotationMatrix;
+    /** @internal */ _invViewProjMatrix;
+    /** @internal */ _clipPlane;
+    /** @internal */ _controller;
+    /** @internal */ _frustum;
+    /** @internal */ _frustumV;
+    /** @internal */ _dirty;
+    /** @internal */ _sampleCount;
+    /** @internal */ _framebuffer;
+    /** @internal */ _viewport;
+    /** @internal */ _scissor;
+    /** @internal */ _clearColor;
+    /** @internal */ _clipMask;
+    /**
+   * Creates a new camera node
+   * @param scene - The scene that the camera belongs to
+   * @param projectionMatrix - Projection matrix for this camera
+   */ constructor(scene, projectionMatrix){
+        super(scene);
+        this._projMatrix = projectionMatrix || Matrix4x4.identity();
+        this._viewMatrix = Matrix4x4.identity();
+        this._viewProjMatrix = Matrix4x4.identity();
+        this._invViewProjMatrix = Matrix4x4.identity();
+        this._clipPlane = null;
+        this._dirty = true;
+        this._controller = null;
+        this._framebuffer = null;
+        this._viewport = null;
+        this._scissor = null;
+        this._clearColor = new Vector4(0, 0, 0, 1);
+        this._clipMask = 0;
+        this._sampleCount = 1;
+        this._frustum = null;
+        this._frustumV = null;
+    }
+    /** Clip plane in camera space */ get clipPlane() {
+        return this._clipPlane;
+    }
+    set clipPlane(plane) {
+        this._clipPlane = plane;
+        this._invalidate(false);
+    }
+    /**
+   * Sample count for MSAA
+   *
+   * @remarks
+   * If greater than one, force the scene to be rendered using multisampled framebuffer
+   */ get sampleCount() {
+        return this._sampleCount;
+    }
+    set sampleCount(val) {
+        if (val !== 1 && val !== 4) {
+            console.error(`Invalid sample count: ${val}`);
+        } else {
+            this._sampleCount = val;
+        }
+    }
+    /** Clip plane mask */ get clipMask() {
+        return this._clipMask;
+    }
+    set clipMask(val) {
+        this._clipMask = val;
+    }
+    /** Framebuffer object into which the scene will be rendered */ get framebuffer() {
+        return this._framebuffer;
+    }
+    set framebuffer(fb) {
+        this._framebuffer = fb ?? null;
+    }
+    /** Viewport used for rendering, if null, use full framebuffer size */ get viewport() {
+        return this._viewport ? [
+            ...this._viewport
+        ] : null;
+    }
+    set viewport(rect) {
+        this._viewport = rect?.slice() ?? null;
+    }
+    /** Scissor rectangle used for rendering, if null, use viewport value */ get scissor() {
+        return this._scissor ? [
+            ...this._scissor
+        ] : null;
+    }
+    set scissor(rect) {
+        this._scissor = rect?.slice() ?? null;
+    }
+    /** Color value used to clear color buffer before rendering, if null, color buffer will not be cleared */ get clearColor() {
+        return this._clearColor;
+    }
+    set clearColor(val) {
+        if (!val) {
+            this._clearColor = null;
+        } else {
+            this._clearColor.set(val);
+        }
+    }
+    /**
+   * Handle input events
+   * @param ev - input event object
+   * @param type - event type, default to ev.type
+   * @returns Boolean value indicates whether the event was handled.
+   */ handleEvent(ev, type) {
+        let handled = false;
+        if (this._controller) {
+            type = type ?? ev.type;
+            if (type === 'pointerdown') {
+                handled = this._controller.onMouseDown(ev);
+            } else if (type === 'pointerup') {
+                handled = this._controller.onMouseUp(ev);
+            } else if (type === 'pointermove') {
+                handled = this._controller.onMouseMove(ev);
+            } else if (type === 'wheel') {
+                handled = this._controller.onMouseWheel(ev);
+            } else if (type === 'keydown') {
+                handled = this._controller.onKeyDown(ev);
+            } else if (type === 'keyup') {
+                handled = this._controller.onKeyUp(ev);
+            }
+            if (handled) {
+                ev.preventDefault();
+            }
+        }
+        return handled;
+    }
+    /**
+   * Place the camera by specifying the camera position and the target point
+   * @param eye - The camera position
+   * @param target - The target point to look at
+   * @param up - The up vector
+   * @returns self
+   */ lookAt(eye, target, up) {
+        return this.setLocalTransform(Matrix4x4.lookAt(eye, target, up));
+    }
+    /**
+   * Place the camera to look at a given cube face at a given camera position
+   * @param face - The cube face to look at
+   * @param position - The camera position
+   * @returns self
+   */ lookAtCubeFace(face, position) {
+        return this.setLocalTransform(Matrix4x4.lookAtCubeFace(face, position ?? this.position));
+    }
+    /**
+   * Setup a perspective projection matrix for the camera
+   * @param fovY - The vertical field of view in radians.
+   * @param aspect - The aspect ratio
+   * @param zNear - The near clip plane
+   * @param zFar - The far clip plane
+   * @returns self
+   */ setPerspective(fovY, aspect, zNear, zFar) {
+        this._projMatrix.perspective(fovY, aspect, zNear, zFar);
+        this._invalidate(true);
+        return this;
+    }
+    /**
+   * Setup a orthogonal projection matrix for the camera
+   * @param left - Left bound of the frustum
+   * @param right - Right bound of the frustum
+   * @param bottom - Bottom bound of the frustum
+   * @param top - Top bound of the frustum
+   * @param near - Near bound of the frustum.
+   * @param far - Far bound of the frustum.
+   * @returns self
+   */ setOrtho(left, right, bottom, top, near, far) {
+        this._projMatrix.ortho(left, right, bottom, top, near, 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) {
+            this._projMatrix.set(matrix);
+            this._invalidate(true);
+        }
+    }
+    /**
+   * Gets the projection matrix of the camera
+   * @returns The projection matrix
+   */ getProjectionMatrix() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        return this._projMatrix;
+    }
+    getRotationMatrix() {
+        const rotationMatrix = new Matrix4x4();
+        this.worldMatrix.decompose(null, rotationMatrix, null);
+        const xAxis = rotationMatrix.getRow(0).xyz().scaleBy(-1);
+        const yAxis = rotationMatrix.getRow(1).xyz();
+        const zAxis = rotationMatrix.getRow(2).xyz().scaleBy(-1);
+        rotationMatrix.setRow(0, new Vector4(xAxis.x, xAxis.y, xAxis.z, 0));
+        rotationMatrix.setRow(1, new Vector4(yAxis.x, yAxis.y, yAxis.z, 0));
+        rotationMatrix.setRow(2, new Vector4(zAxis.x, zAxis.y, zAxis.z, 0));
+        return rotationMatrix;
+    }
+    /**
+   * View matrix of the camera
+   *
+   * @remarks
+   * Camera's view matrix will transform a point from the world space to the camera space
+   */ get viewMatrix() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        return this._viewMatrix;
+    }
+    get viewProjectionMatrix() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        return this._viewProjMatrix;
+    }
+    /**
+   * The inverse-view-projection matrix of the camera
+   *
+   * @remarks
+   * The inverse-view-projection matrix transforms a point from the clip space to the camera space
+   */ get invViewProjectionMatrix() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        return this._invViewProjMatrix;
+    }
+    /** Gets the frustum of the camera */ get frustum() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        return this._frustum;
+    }
+    get frustumViewSpace() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        if (!this._frustumV) {
+            this._frustumV = new Frustum(this._projMatrix);
+        }
+        return this._frustumV;
+    }
+    /** The camera controller  */ get controller() {
+        return this._controller || null;
+    }
+    set controller(controller) {
+        this.setController(controller);
+    }
+    /** {@inheritDoc SceneNode.isCamera} */ isCamera() {
+        return true;
+    }
+    /** Gets the near clip plane of the camera */ getNearPlane() {
+        return this._projMatrix.getNearPlane();
+    }
+    /** Gets the far clip plane of the camera */ getFarPlane() {
+        return this._projMatrix.getFarPlane();
+    }
+    /** Gets the vertical field of view of the camera */ getFOV() {
+        return this._projMatrix.getFov();
+    }
+    /** Gets the tangent of half of the vertical field of view */ getTanHalfFovy() {
+        return this._projMatrix.getTanHalfFov();
+    }
+    /** Gets the aspect ratio */ getAspect() {
+        return this._projMatrix.getAspect();
+    }
+    /**
+   * Renders a scene
+   * @param scene - The scene to be rendered
+   * @param compositor - Compositor instance that will be used to apply postprocess effects
+   */ render(scene, compositor, logger) {
+        const device = Application.instance.device;
+        device.pushDeviceStates();
+        device.reverseVertexWindingOrder(false);
+        device.setFramebuffer(this._framebuffer);
+        ForwardRenderScheme.setClearColor(this._clearColor);
+        ForwardRenderScheme.renderScene(scene, this, compositor, logger);
+        device.popDeviceStates();
+    }
+    /**
+   * Updates the controller state
+   */ updateController() {
+        this._controller?.update();
+    }
+    /**
+   * Reset the controller
+   */ resetController() {
+        this._controller?.reset();
+    }
+    /** @internal */ setController(controller) {
+        if (this._controller !== controller) {
+            if (controller && controller._getCamera() && controller._getCamera() !== this) {
+                throw new Error('Camera.setController failed: one camera controller object cannot be assigned to multiple camera');
+            }
+            this._controller?._setCamera(null);
+            this._controller = controller;
+            this._controller?._setCamera(this);
+        }
+        return this;
+    }
+    /** @internal */ _invalidate(projectMatrixChanged) {
+        this._dirty = true;
+        if (projectMatrixChanged) {
+            this._frustumV = null;
+        }
+    }
+    /** @internal */ _compute() {
+        this._computeProj();
+        Matrix4x4.invertAffine(this.worldMatrix, this._viewMatrix);
+        Matrix4x4.multiply(this._projMatrix, this._viewMatrix, this._viewProjMatrix);
+        Matrix4x4.invert(this._viewProjMatrix, this._invViewProjMatrix);
+        if (!this._frustum) {
+            this._frustum = new Frustum(this._viewProjMatrix);
+        } else {
+            this._frustum.initWithMatrix(this._viewProjMatrix);
+        }
+    }
+    /** @internal */ _computeProj() {}
+    /** @internal */ _onTransformChanged(invalidateLocal) {
+        super._onTransformChanged(invalidateLocal);
+        this._invalidate(false);
+    }
+    /** {@inheritdoc SceneNode.dispose} */ dispose() {
+        this.setController(null);
+        this._projMatrix = null;
+        this._viewMatrix = null;
+        this._viewProjMatrix = null;
+    }
+}
+
+export { Camera };
+//# sourceMappingURL=camera.js.map

package/dist/camera/camera.js.map

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

package/dist/camera/fps.js

@@ -0,0 +1,246 @@
+import { Vector3, Quaternion, Matrix3x3, Matrix4x4 } from '@zephyr3d/base';
+import { BaseCameraController } from './base.js';
+
+/**
+ * FPS camera controller
+ * @public
+ */ class FPSCameraController extends BaseCameraController {
+    /** @internal */ options;
+    /** @internal */ mouseDown;
+    /** @internal */ lastMouseX;
+    /** @internal */ lastMouseY;
+    /** @internal */ keyUp;
+    /** @internal */ keyDown;
+    /** @internal */ keyLeft;
+    /** @internal */ keyRight;
+    /** @internal */ keyForward;
+    /** @internal */ keyBackward;
+    /**
+   * Creates an instance of FPSCameraController
+   * @param options - The creation options
+   */ constructor(options){
+        super();
+        this.options = Object.assign({
+            controlKeys: {
+                up: 'KeyQ',
+                down: 'KeyE',
+                forward: 'KeyW',
+                backward: 'KeyS',
+                left: 'KeyA',
+                right: 'KeyD'
+            },
+            moveSpeed: 0.2,
+            rotateSpeed: 0.01
+        }, options || {});
+    }
+    /**
+   * {@inheritDoc BaseCameraController.reset}
+   * @override
+   */ reset() {
+        this.mouseDown = false;
+        this.lastMouseX = 0;
+        this.lastMouseY = 0;
+        this.keyUp = false;
+        this.keyDown = false;
+        this.keyLeft = false;
+        this.keyRight = false;
+        this.keyForward = false;
+        this.keyBackward = false;
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onMouseDown}
+   * @override
+   */ _onMouseDown(evt) {
+        if (evt.button === 0) {
+            this.mouseDown = true;
+            this.lastMouseX = evt.offsetX;
+            this.lastMouseY = evt.offsetY;
+            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._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;
+            const zAxis = this._getCamera().worldMatrix.getRow(2).xyz();
+            const alpha = Math.atan2(zAxis.z, zAxis.x) + dx * this.options.rotateSpeed;
+            const beta = Math.min(Math.PI / 2.1, Math.max(-Math.PI / 2.1, Math.asin(zAxis.y) + dy * this.options.rotateSpeed));
+            const newY = Math.sin(beta);
+            const r = Math.sqrt(Math.max(0, 1 - newY * newY));
+            const newZ = Math.sin(alpha) * r;
+            const newX = Math.cos(alpha) * r;
+            zAxis.setXYZ(newX, newY, newZ).inplaceNormalize();
+            const XAxis = Vector3.cross(Vector3.axisPY(), zAxis).inplaceNormalize();
+            const YAxis = Vector3.cross(zAxis, XAxis).inplaceNormalize();
+            const rotation = Quaternion.fromRotationMatrix(new Matrix3x3([
+                XAxis.x,
+                XAxis.y,
+                XAxis.z,
+                YAxis.x,
+                YAxis.y,
+                YAxis.z,
+                zAxis.x,
+                zAxis.y,
+                zAxis.z
+            ]));
+            if (!this._getCamera().parent) {
+                this._getCamera().rotation.set(rotation);
+            } else {
+                const pos = new Vector3();
+                const scale = new Vector3();
+                this._getCamera().worldMatrix.decompose(scale, null, pos);
+                const newWorldMatrix = Matrix4x4.scaling(scale).rotateLeft(rotation).translateLeft(pos);
+                const newLocalMatrix = this._getCamera().parent ? newWorldMatrix.multiplyLeftAffine(Matrix4x4.invertAffine(this._getCamera().parent.worldMatrix)) : newWorldMatrix;
+                newLocalMatrix.decompose(scale, rotation, pos);
+                this._getCamera().position.set(pos);
+                this._getCamera().scale.set(scale);
+                this._getCamera().rotation.set(rotation);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onKeyDown}
+   * @override
+   */ _onKeyDown(evt) {
+        switch(evt.code){
+            case this.options.controlKeys.up:
+                this.keyUp = true;
+                break;
+            case this.options.controlKeys.down:
+                this.keyDown = true;
+                break;
+            case this.options.controlKeys.left:
+                this.keyLeft = true;
+                break;
+            case this.options.controlKeys.right:
+                this.keyRight = true;
+                break;
+            case this.options.controlKeys.forward:
+                this.keyForward = true;
+                break;
+            case this.options.controlKeys.backward:
+                this.keyBackward = true;
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+    /**
+   * {@inheritDoc BaseCameraController._onKeyUp}
+   * @override
+   */ _onKeyUp(evt) {
+        switch(evt.code){
+            case this.options.controlKeys.up:
+                this.keyUp = false;
+                break;
+            case this.options.controlKeys.down:
+                this.keyDown = false;
+                break;
+            case this.options.controlKeys.left:
+                this.keyLeft = false;
+                break;
+            case this.options.controlKeys.right:
+                this.keyRight = false;
+                break;
+            case this.options.controlKeys.forward:
+                this.keyForward = false;
+                break;
+            case this.options.controlKeys.backward:
+                this.keyBackward = false;
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+    /**
+   * Set options
+   * @param opt - options
+   */ setOptions(opt) {
+        opt && Object.assign(this.options, opt);
+        this.reset();
+    }
+    /**
+   * {@inheritDoc BaseCameraController.update}
+   * @override
+   */ update() {
+        const x = this._getCamera().worldMatrix.getRow(0).xyz();
+        x.y = 0;
+        x.inplaceNormalize();
+        if (x.isNaN()) {
+            console.log(`Camera error 1: ${x.toString()}`);
+        }
+        const z = this._getCamera().worldMatrix.getRow(2).xyz().inplaceNormalize();
+        if (z.isNaN()) {
+            console.log(`Camera error 2: ${z.toString()}`);
+        }
+        const move = new Vector3(0, 0, 0);
+        let changed = false;
+        if (this.keyForward) {
+            changed = true;
+            move.subBy(Vector3.scale(z, this.options.moveSpeed));
+        }
+        if (this.keyBackward) {
+            changed = true;
+            move.addBy(Vector3.scale(z, this.options.moveSpeed));
+        }
+        if (this.keyUp) {
+            changed = true;
+            move.y += this.options.moveSpeed;
+        }
+        if (this.keyDown) {
+            changed = true;
+            move.y -= this.options.moveSpeed;
+        }
+        if (this.keyLeft) {
+            changed = true;
+            move.subBy(Vector3.scale(x, this.options.moveSpeed));
+        }
+        if (this.keyRight) {
+            changed = true;
+            move.addBy(Vector3.scale(x, this.options.moveSpeed));
+        }
+        if (changed) {
+            if (this._getCamera().parent) {
+                const pos = new Vector3();
+                const scale = new Vector3();
+                const rotation = new Quaternion();
+                this._getCamera().worldMatrix.decompose(scale, rotation, pos);
+                pos.addBy(move);
+                const newWorldMatrix = Matrix4x4.scaling(scale).rotateLeft(rotation).translateLeft(pos);
+                const newLocalMatrix = newWorldMatrix.multiplyLeftAffine(Matrix4x4.invertAffine(this._getCamera().parent.worldMatrix));
+                newLocalMatrix.decompose(scale, rotation, pos);
+                if (scale.isNaN() || rotation.isNaN() || pos.isNaN()) {
+                    console.log(`Camera error 3: ${scale.toString()} ${rotation.toString()} ${pos.toString()}`);
+                }
+                this._getCamera().position.set(pos);
+                this._getCamera().scale.set(scale);
+                this._getCamera().rotation.set(rotation);
+            } else {
+                this._getCamera().moveBy(move);
+            }
+        }
+    }
+}
+
+export { FPSCameraController };
+//# sourceMappingURL=fps.js.map

package/dist/camera/fps.js.map

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