@zephyr3d/scene 0.6.1 → 0.7.0

package/dist/src/camera/camera.js

@@ -0,0 +1,1005 @@
+import { halton23, Matrix4x4, DRef, Vector4, Vector2, Plane, Vector3, Ray, Frustum } from '@zephyr3d/base';
+import { SceneNode } from '../scene/scene_node.js';
+import { Application } from '../app/app.js';
+import { Compositor } from '../posteffect/compositor.js';
+import { TAA } from '../posteffect/taa.js';
+import { SSR } from '../posteffect/ssr.js';
+import { Tonemap } from '../posteffect/tonemap.js';
+import { FXAA } from '../posteffect/fxaa.js';
+import { Bloom } from '../posteffect/bloom.js';
+import { SAO } from '../posteffect/sao.js';
+import { MotionBlur } from '../posteffect/motionblur.js';
+
+/**
+ * The camera node class
+ * @public
+ */ class Camera extends SceneNode {
+    /** @internal */ static _halton23 = halton23(16);
+    /** @internal */ static _historyData = new WeakMap();
+    /** @internal */ _projMatrix;
+    /** @internal */ _invProjMatrix;
+    /** @internal */ _viewMatrix;
+    /** @internal */ _viewProjMatrix;
+    /** @internal */ _rotationMatrix;
+    /** @internal */ _invViewProjMatrix;
+    /** @internal */ _clipPlane;
+    /** @internal */ _controller;
+    /** @internal */ _frustum;
+    /** @internal */ _frustumV;
+    /** @internal */ _dirty;
+    /** @internal */ _viewport;
+    /** @internal */ _scissor;
+    /** @internal */ _clipMask;
+    /** @internal */ _oit;
+    /** @internal */ _depthPrePass;
+    /** @internal */ _commandBufferReuse;
+    /** @internal */ _HiZ;
+    /** @internal */ _toneMap;
+    /** @internal */ _postEffectTonemap;
+    /** @internal */ _tonemapExposure;
+    /** @internal */ _motionBlur;
+    /** @internal */ _postEffectMotionBlur;
+    /** @internal */ _motionBlurStrength;
+    /** @internal */ _bloom;
+    /** @internal */ _postEffectBloom;
+    /** @internal */ _bloomMaxDownsampleLevels;
+    /** @internal */ _bloomDownsampleLimit;
+    /** @internal */ _bloomThreshold;
+    /** @internal */ _bloomThresholdKnee;
+    /** @internal */ _bloomIntensity;
+    /** @internal */ _FXAA;
+    /** @internal */ _postEffectFXAA;
+    /** @internal */ _TAA;
+    /** @internal */ _postEffectTAA;
+    /** @internal */ _TAADebug;
+    /** @internal */ _SSR;
+    /** @internal */ _postEffectSSR;
+    /** @internal */ _ssrParams;
+    /** @internal */ _ssrMaxRoughness;
+    /** @internal */ _ssrRoughnessFactor;
+    /** @internal */ _ssrStride;
+    /** @internal */ _ssrCalcThickness;
+    /** @internal */ _ssrBlurriness;
+    /** @internal */ _ssrBlurDepthCutoff;
+    /** @internal */ _ssrBlurKernelSize;
+    /** @internal */ _ssrBlurStdDev;
+    /** @internal */ _SSAO;
+    /** @internal */ _postEffectSSAO;
+    /** @internal */ _SSAOScale;
+    /** @internal */ _SSAOBias;
+    /** @internal */ _SSAORadius;
+    /** @internal */ _SSAOIntensity;
+    /** @internal */ _SSAOBlurDepthCutoff;
+    /** @internal */ _pickResultPromise;
+    /** @internal */ _pickResultResolve;
+    /** @internal */ _pickPosX;
+    /** @internal */ _pickPosY;
+    /** @internal */ _pickResult;
+    /** @internal */ _jitterValue;
+    /** @internal */ _prevJitterValue;
+    /** @internal */ _jitteredVPMatrix;
+    /** @internal */ _jitteredInvVPMatrix;
+    /** @internal */ _prevVPMatrix;
+    /** @internal */ _prevPosition;
+    /** @internal */ _prevJitteredVPMatrix;
+    /** @internal */ _compositor;
+    /**
+   * 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._invProjMatrix = Matrix4x4.invert(this._projMatrix);
+        this._viewMatrix = Matrix4x4.identity();
+        this._viewProjMatrix = Matrix4x4.identity();
+        this._invViewProjMatrix = Matrix4x4.identity();
+        this._clipPlane = null;
+        this._dirty = true;
+        this._controller = null;
+        this._viewport = null;
+        this._scissor = null;
+        this._clipMask = 0;
+        this._frustum = null;
+        this._frustumV = null;
+        this._oit = new DRef();
+        this._depthPrePass = false;
+        this._HiZ = false;
+        this._toneMap = true;
+        this._postEffectTonemap = new DRef();
+        this._tonemapExposure = 1;
+        this._motionBlur = false;
+        this._postEffectMotionBlur = new DRef();
+        this._motionBlurStrength = 1;
+        this._bloom = false;
+        this._postEffectBloom = new DRef();
+        this._bloomMaxDownsampleLevels = 4;
+        this._bloomDownsampleLimit = 32;
+        this._bloomThreshold = 0.8;
+        this._bloomThresholdKnee = 0;
+        this._bloomIntensity = 1;
+        this._FXAA = false;
+        this._postEffectFXAA = new DRef();
+        this._TAA = false;
+        this._postEffectTAA = new DRef();
+        this._TAADebug = 0;
+        this._SSR = false;
+        this._postEffectSSR = new DRef();
+        this._ssrParams = new Vector4(100, 120, 0.5, 0);
+        this._ssrMaxRoughness = 0.8;
+        this._ssrRoughnessFactor = 1;
+        this._ssrStride = 2;
+        this._ssrCalcThickness = false;
+        this._ssrBlurriness = 0.05;
+        this._ssrBlurDepthCutoff = 2;
+        this._ssrBlurKernelSize = 17;
+        this._ssrBlurStdDev = 10;
+        this._SSAO = false;
+        this._postEffectSSAO = new DRef();
+        this._SSAOScale = 10;
+        this._SSAOBias = 1;
+        this._SSAOIntensity = 0.025;
+        this._SSAORadius = 100;
+        this._SSAOBlurDepthCutoff = 2;
+        this._pickResult = null;
+        this._commandBufferReuse = true;
+        this._jitteredVPMatrix = new Matrix4x4();
+        this._jitteredInvVPMatrix = new Matrix4x4();
+        this._jitterValue = new Vector2(0, 0);
+        this._prevVPMatrix = null;
+        this._prevPosition = null;
+        this._prevJitteredVPMatrix = null;
+        this._prevJitterValue = null;
+        this._pickResultPromise = null;
+        this._pickResultResolve = null;
+        this._pickPosX = 0;
+        this._pickPosY = 0;
+        this._compositor = new Compositor();
+        this.updatePostProcessing();
+    }
+    clone(method, recursive) {
+        const other = new Camera(this.scene);
+        other.copyFrom(this, method, recursive);
+        other.parent = this.parent;
+        return other;
+    }
+    copyFrom(other, method, recursive) {
+        super.copyFrom(other, method, recursive);
+        this.clipPlane = other.clipPlane ? new Plane(other.clipPlane) : null;
+        this.HiZ = other.HiZ;
+        this.toneMap = other.toneMap;
+        this.toneMapExposure = other.toneMapExposure;
+        this.bloom = other.bloom;
+        this.FXAA = other.FXAA;
+        this.TAA = other.TAA;
+        this.TAADebug = other.TAADebug;
+        this.SSR = other.SSR;
+        this.ssrMaxRoughness = other.ssrMaxRoughness;
+        this.ssrRoughnessFactor = other.ssrRoughnessFactor;
+        this.ssrStride = other.ssrStride;
+        this.ssrMaxDistance = other.ssrMaxDistance;
+        this.ssrIterations = other.ssrIterations;
+        this.ssrThickness = other.ssrThickness;
+        this.ssrCalcThickness = other.ssrCalcThickness;
+        this.ssrBlurScale = other.ssrBlurScale;
+        this.ssrBlurDepthCutoff = other.ssrBlurDepthCutoff;
+        this.ssrBlurKernelSize = other.ssrBlurKernelSize;
+        this.depthPrePass = other.depthPrePass;
+        this.commandBufferReuse = other.commandBufferReuse;
+        this.oit = other.oit;
+        this.clipMask = other.clipMask;
+        this.viewport = other.viewport?.slice() ?? null;
+        this.scissor = other.scissor?.slice() ?? null;
+        this.setProjectionMatrix(other.getProjectionMatrix());
+    }
+    /** Compositor */ get compositor() {
+        return this._compositor;
+    }
+    /** Clip plane in camera space */ get clipPlane() {
+        return this._clipPlane;
+    }
+    set clipPlane(plane) {
+        this._clipPlane = plane;
+        this._invalidate(false);
+    }
+    /**
+   * Gets whether Hi-Z acceleration is enabled.
+   * When enabled, it can significantly improve SSR performance with minimal quality impact.
+   */ get HiZ() {
+        return this._HiZ;
+    }
+    set HiZ(val) {
+        this._HiZ = !!val;
+    }
+    /**
+   * Gets whether Tonemap is enabled.
+   */ get toneMap() {
+        return this._postEffectTonemap.get().enabled;
+    }
+    set toneMap(val) {
+        this._postEffectTonemap.get().enabled = !!val;
+    }
+    /**
+   * Gets whether motion blur is enabled
+   */ get motionBlur() {
+        return this._postEffectMotionBlur.get().enabled;
+    }
+    set motionBlur(val) {
+        this._postEffectMotionBlur.get().enabled = !!val;
+    }
+    /** Motion blur strength */ get motionBlurStrength() {
+        return this._motionBlurStrength;
+    }
+    set motionBlurStrength(val) {
+        this._motionBlurStrength = val;
+        if (this._postEffectMotionBlur.get()) {
+            this._postEffectMotionBlur.get().strength = this._motionBlurStrength;
+        }
+    }
+    /**
+   * Gets whether Bloom is enabled.
+   */ get bloom() {
+        return this._postEffectBloom.get().enabled;
+    }
+    set bloom(val) {
+        this._postEffectBloom.get().enabled = !!val;
+    }
+    /**
+   * Maximum bloom downsample levels
+   */ get bloomMaxDownsampleLevels() {
+        return this._bloomMaxDownsampleLevels;
+    }
+    set bloomMaxDownsampleLevels(val) {
+        this._bloomMaxDownsampleLevels = val;
+        if (this._postEffectBloom.get()) {
+            this._postEffectBloom.get().maxDownsampleLevel = val;
+        }
+    }
+    /**
+   * Bloom downsample limit
+   */ get bloomDownsampleLimit() {
+        return this._bloomDownsampleLimit;
+    }
+    set bloomDownsampleLimit(val) {
+        this._bloomDownsampleLimit = val;
+        if (this._postEffectBloom.get()) {
+            this._postEffectBloom.get().downsampleLimit = val;
+        }
+    }
+    /**
+   * Bloom threshold
+   */ get bloomThreshold() {
+        return this._bloomThreshold;
+    }
+    set bloomThreshold(val) {
+        this._bloomThreshold = val;
+        if (this._postEffectBloom.get()) {
+            this._postEffectBloom.get().threshold = val;
+        }
+    }
+    /**
+   * Bloom threshold knee
+   */ get bloomThresholdKnee() {
+        return this._bloomThresholdKnee;
+    }
+    set bloomThresholdKnee(val) {
+        this._bloomThresholdKnee = val;
+        if (this._postEffectBloom.get()) {
+            this._postEffectBloom.get().thresholdKnee = val;
+        }
+    }
+    /**
+   * Bloom intensity
+   */ get bloomIntensity() {
+        return this._bloomIntensity;
+    }
+    set bloomIntensity(val) {
+        this._bloomIntensity = val;
+        if (this._postEffectBloom.get()) {
+            this._postEffectBloom.get().intensity = val;
+        }
+    }
+    /**
+   * Gets whether FXAA is enabled.
+   */ get FXAA() {
+        return this._postEffectFXAA.get().enabled;
+    }
+    set FXAA(val) {
+        this._postEffectFXAA.get().enabled = !!val;
+    }
+    /**
+   * Tonemap exposure
+   */ get toneMapExposure() {
+        return this._tonemapExposure;
+    }
+    set toneMapExposure(val) {
+        this._tonemapExposure = val;
+        if (this._postEffectTonemap.get()) {
+            this._postEffectTonemap.get().exposure = val;
+        }
+    }
+    /**
+   * Gets whether TAA is enabled.
+   */ get TAA() {
+        return this._postEffectTAA.get().enabled;
+    }
+    set TAA(val) {
+        this._postEffectTAA.get().enabled = !!val;
+    }
+    /**
+   * Gets the debug flag for TAA
+   */ get TAADebug() {
+        return this._TAADebug;
+    }
+    set TAADebug(val) {
+        this._TAADebug = val;
+    }
+    /**
+   * Gets whether Screen Space Reflections (SSR) is enabled.
+   */ get SSR() {
+        return this._postEffectSSR.get().enabled;
+    }
+    set SSR(val) {
+        this._postEffectSSR.get().enabled = !!val;
+    }
+    /**
+   * Gets the maximum roughness value for screen space reflections.
+   * Controls the cutoff point where surfaces are considered too rough for SSR.
+   */ get ssrMaxRoughness() {
+        return this._ssrMaxRoughness;
+    }
+    set ssrMaxRoughness(val) {
+        this._ssrMaxRoughness = val;
+    }
+    /**
+   * Gets the roughness factor for SSR calculations.
+   * Affects how surface roughness influences reflection clarity.
+   */ get ssrRoughnessFactor() {
+        return this._ssrRoughnessFactor;
+    }
+    set ssrRoughnessFactor(val) {
+        this._ssrRoughnessFactor = val;
+    }
+    /**
+   * Gets the stride value for SSR ray marching.
+   * Controls the step size during ray marching. Larger values improve performance but may miss details.
+   */ get ssrStride() {
+        return this._ssrStride;
+    }
+    set ssrStride(val) {
+        this._ssrStride = val;
+    }
+    /**
+   * Gets the maximum distance for SSR ray marching.
+   * Defines how far rays will travel when searching for reflection intersections.
+   */ get ssrMaxDistance() {
+        return this._ssrParams.x;
+    }
+    set ssrMaxDistance(val) {
+        this._ssrParams.x = val;
+    }
+    /**
+   * Gets the number of iterations for SSR ray marching.
+   * Higher values provide more accurate reflections but impact performance.
+   */ get ssrIterations() {
+        return this._ssrParams.y;
+    }
+    set ssrIterations(val) {
+        this._ssrParams.y = val;
+    }
+    /**
+   * Gets the thickness value for SSR calculations.
+   * Determines the thickness threshold for surfaces when calculating reflections.
+   */ get ssrThickness() {
+        return this._ssrParams.z;
+    }
+    set ssrThickness(val) {
+        this._ssrParams.z = val;
+    }
+    /**
+   * Gets whether SSR should calculate thickness automatically.
+   * When enabled, the system will dynamically compute surface thickness for reflections.
+   */ get ssrCalcThickness() {
+        return this._ssrCalcThickness;
+    }
+    set ssrCalcThickness(val) {
+        this._ssrCalcThickness = !!val;
+    }
+    /**
+   * Gets the blur scale factor for SSR.
+   * Controls the overall intensity of the blur effect applied to reflections.
+   */ get ssrBlurScale() {
+        return this._ssrBlurriness;
+    }
+    set ssrBlurScale(val) {
+        this._ssrBlurriness = val;
+    }
+    /**
+   * Gets the depth cutoff value for SSR blur.
+   * Determines at what depth difference the blur effect should be reduced or eliminated.
+   */ get ssrBlurDepthCutoff() {
+        return this._ssrBlurDepthCutoff;
+    }
+    set ssrBlurDepthCutoff(val) {
+        this._ssrBlurDepthCutoff = val;
+    }
+    /**
+   * Gets the kernel size for the SSR blur effect.
+   * Defines the size of the blur kernel. Larger values create softer, more spread-out blur.
+   */ get ssrBlurKernelSize() {
+        return this._ssrBlurKernelSize;
+    }
+    set ssrBlurKernelSize(val) {
+        this._ssrBlurKernelSize = val;
+    }
+    /**
+   * Gets the standard deviation for the SSR Gaussian blur.
+   * Controls the distribution of the blur effect. Higher values create more pronounced blur.
+   */ get ssrBlurStdDev() {
+        return this._ssrBlurStdDev;
+    }
+    set ssrBlurStdDev(val) {
+        this._ssrBlurStdDev = val;
+    }
+    /** @internal */ get ssrParams() {
+        return this._ssrParams;
+    }
+    /**
+   * Gets whether SSAO is enabled.
+   */ get SSAO() {
+        return this._postEffectSSAO.get().enabled;
+    }
+    set SSAO(val) {
+        this._postEffectSSAO.get().enabled = !!val;
+    }
+    /** SSAO scale */ get SSAOScale() {
+        return this._SSAOScale;
+    }
+    set SSAOScale(val) {
+        this._SSAOScale = val;
+        if (this._postEffectSSAO.get()) {
+            this._postEffectSSAO.get().scale = val;
+        }
+    }
+    /** SSAO bias */ get SSAOBias() {
+        return this._SSAOBias;
+    }
+    set SSAOBias(val) {
+        this._SSAOBias = val;
+        if (this._postEffectSSAO.get()) {
+            this._postEffectSSAO.get().bias = val;
+        }
+    }
+    /** SSAO radius */ get SSAORadius() {
+        return this._SSAORadius;
+    }
+    set SSAORadius(val) {
+        this._SSAORadius = val;
+        if (this._postEffectSSAO.get()) {
+            this._postEffectSSAO.get().radius = val;
+        }
+    }
+    /** SSAO intensity */ get SSAOIntensity() {
+        return this._SSAOIntensity;
+    }
+    set SSAOIntensity(val) {
+        this._SSAOIntensity = val;
+        if (this._postEffectSSAO.get()) {
+            this._postEffectSSAO.get().intensity = val;
+        }
+    }
+    /** SSAO depth cutoff */ get SSAOBlurDepthCutoff() {
+        return this._SSAOBlurDepthCutoff;
+    }
+    set SSAOBlurDepthCutoff(val) {
+        this._SSAOBlurDepthCutoff = val;
+        if (this._postEffectSSAO.get()) {
+            this._postEffectSSAO.get().blurDepthCutoff = val;
+        }
+    }
+    /** Whether to perform a depth pass */ get depthPrePass() {
+        return this._depthPrePass;
+    }
+    set depthPrePass(val) {
+        this._depthPrePass = !!val;
+    }
+    /** Whether to allow command buffer reuse optimization */ get commandBufferReuse() {
+        return this._commandBufferReuse;
+    }
+    set commandBufferReuse(val) {
+        this._commandBufferReuse = !!val;
+    }
+    /** OIT */ get oit() {
+        return this._oit.get();
+    }
+    set oit(val) {
+        this._oit.set(val);
+    }
+    /** Clip plane mask */ get clipMask() {
+        return this._clipMask;
+    }
+    set clipMask(val) {
+        this._clipMask = val;
+    }
+    /** 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;
+    }
+    /**
+   * 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;
+    }
+    /**
+   * Constructs a ray based on the given screen coordinates.
+   *
+   * @param x - The x-component of the screen coordinates, relative to the top-left corner of the viewport.
+   * @param y - The y-component of the screen coordinates, relative to the top-left corner of the viewport.
+   * @returns The ray originating from the camera position and passing through the given screen coordinates.
+   */ constructRay(x, y) {
+        const width = this.viewport ? this.viewport[2] : Application.instance.device.getViewport().width;
+        const height = this.viewport ? this.viewport[3] : Application.instance.device.getViewport().height;
+        const ndcX = 2 * x / width - 1;
+        const ndcY = 1 - 2 * y / height;
+        const nearClip = new Vector4(ndcX, ndcY, 0, 1);
+        const farClip = new Vector4(ndcX, ndcY, 1, 1);
+        const nearWorld = this.invViewProjectionMatrix.transform(nearClip);
+        const farWorld = this.invViewProjectionMatrix.transform(farClip);
+        if (this.isPerspective()) {
+            nearWorld.scaleBy(1 / nearWorld.w);
+            farWorld.scaleBy(1 / farWorld.w);
+        }
+        const vEye = this.isPerspective() ? this.getWorldPosition() : nearWorld.xyz();
+        const vDir = Vector3.sub(farWorld.xyz(), vEye).inplaceNormalize();
+        return new Ray(vEye, vDir);
+    }
+    /**
+   * 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);
+        Matrix4x4.invert(this._projMatrix, this._invProjMatrix);
+        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);
+        Matrix4x4.invert(this._projMatrix, this._invProjMatrix);
+        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 = matrix;
+            Matrix4x4.invert(this._projMatrix, this._invProjMatrix);
+            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;
+    }
+    /**
+   * Gets the inverse projection matrix of the camera
+   * @returns The projection matrix
+   */ getInvProjectionMatrix() {
+        if (this._dirty) {
+            this._dirty = false;
+            this._compute();
+        }
+        return this._invProjMatrix;
+    }
+    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.getProjectionMatrix().getNearPlane();
+    }
+    /** Gets the far clip plane of the camera */ getFarPlane() {
+        return this.getProjectionMatrix().getFarPlane();
+    }
+    /** Gets the vertical field of view of the camera */ getFOV() {
+        return this.getProjectionMatrix().getFov();
+    }
+    /** Gets the tangent of half of the vertical field of view */ getTanHalfFovy() {
+        return this.getProjectionMatrix().getTanHalfFov();
+    }
+    /** Gets the aspect ratio */ getAspect() {
+        return this.getProjectionMatrix().getAspect();
+    }
+    /** Returns true if the camera is perspective */ isPerspective() {
+        return this.getProjectionMatrix().isPerspective();
+    }
+    /** Returns true if the camera is orthographic */ isOrtho() {
+        return this.getProjectionMatrix().isOrtho();
+    }
+    /**
+   * Gets the camera history data which is used in temporal reprojection
+   * @returns Camera history data
+   */ getHistoryData() {
+        let data = Camera._historyData.get(this);
+        if (!data) {
+            data = {
+                prevColorTex: null,
+                prevMotionVectorTex: null
+            };
+            Camera._historyData.set(this, data);
+        }
+        return data;
+    }
+    /**
+   * Clears the camera history data which is used in temporal reprojection
+   */ clearHistoryData() {
+        const data = Camera._historyData.get(this);
+        if (data) {
+            if (data.prevColorTex) {
+                Application.instance.device.pool.releaseTexture(data.prevColorTex);
+            }
+            if (data.prevMotionVectorTex) {
+                Application.instance.device.pool.releaseTexture(data.prevMotionVectorTex);
+            }
+            Camera._historyData.delete(this);
+        }
+        this._prevVPMatrix = null;
+        this._prevPosition = null;
+        this._prevJitteredVPMatrix = null;
+        this._prevJitterValue = null;
+    }
+    /** @internal */ updatePostProcessing() {
+        this._compositor.clear();
+        if (!this._postEffectSSR.get()) {
+            const ssr = new SSR();
+            ssr.enabled = false;
+            this._postEffectSSR.set(ssr);
+            this._compositor.appendPostEffect(ssr);
+        }
+        if (!this._postEffectSSAO.get()) {
+            const ssao = new SAO();
+            ssao.enabled = false;
+            ssao.scale = this._SSAOScale;
+            ssao.bias = this._SSAOBias;
+            ssao.radius = this._SSAORadius;
+            ssao.intensity = this._SSAOIntensity;
+            ssao.blurDepthCutoff = this._SSAOBlurDepthCutoff;
+            this._postEffectSSAO.set(ssao);
+            this._compositor.appendPostEffect(ssao);
+        }
+        if (!this._postEffectTAA.get()) {
+            const taa = new TAA();
+            taa.enabled = false;
+            this._postEffectTAA.set(taa);
+            this._compositor.appendPostEffect(taa);
+        }
+        if (!this._postEffectMotionBlur.get()) {
+            const motionBlur = new MotionBlur();
+            motionBlur.enabled = false;
+            motionBlur.strength = this._motionBlurStrength;
+            this._postEffectMotionBlur.set(motionBlur);
+            this._compositor.appendPostEffect(motionBlur);
+        }
+        if (!this._postEffectTonemap.get()) {
+            const tonemap = new Tonemap();
+            tonemap.enabled = true;
+            tonemap.exposure = this._tonemapExposure;
+            this._postEffectTonemap.set(tonemap);
+            this._compositor.appendPostEffect(tonemap);
+        }
+        if (!this._postEffectFXAA.get()) {
+            const fxaa = new FXAA();
+            fxaa.enabled = false;
+            this._postEffectFXAA.set(fxaa);
+            this._compositor.appendPostEffect(fxaa);
+        }
+        if (!this._postEffectBloom.get()) {
+            const bloom = new Bloom();
+            bloom.enabled = false;
+            bloom.maxDownsampleLevel = this._bloomMaxDownsampleLevels;
+            bloom.downsampleLimit = this._bloomDownsampleLimit;
+            bloom.threshold = this._bloomThreshold;
+            bloom.thresholdKnee = this._bloomThresholdKnee;
+            bloom.intensity = this._bloomIntensity;
+            this._postEffectBloom.set(bloom);
+            this._compositor.appendPostEffect(bloom);
+        }
+    }
+    /**
+   * Renders a scene
+   * @param scene - The scene to be rendered
+   * @param compositor - Compositor instance that will be used to apply postprocess effects
+   */ render(scene) {
+        const device = Application.instance.device;
+        //this.updatePostProcessing(device);
+        const useMotionVector = (this.TAA || this.motionBlur) && device.type !== 'webgl';
+        const useTAA = useMotionVector && this.TAA;
+        scene.dispatchEvent('startrender', scene, this, this._compositor);
+        if (useMotionVector) {
+            const width = device.getDrawingBufferWidth();
+            const height = device.getDrawingBufferHeight();
+            if (useTAA) {
+                const halton = Camera._halton23[device.frameInfo.frameCounter % Camera._halton23.length];
+                this._jitterValue.setXY(halton[0] * 2 / width, halton[1] * 2 / height);
+            } else {
+                this._jitterValue.setXY(0, 0);
+            }
+            this._jitteredVPMatrix.set(this.getProjectionMatrix());
+            this._jitteredVPMatrix[8] += this._jitterValue.x;
+            this._jitteredVPMatrix[9] += this._jitterValue.y;
+            this._jitteredVPMatrix.multiplyRight(this.viewMatrix);
+            Matrix4x4.invert(this._jitteredVPMatrix, this._jitteredInvVPMatrix);
+            if (!this._prevJitteredVPMatrix) {
+                this._prevJitteredVPMatrix = new Matrix4x4();
+                this._prevJitteredVPMatrix.set(this._jitteredVPMatrix);
+                this._prevJitterValue = new Vector2(this._jitterValue);
+            }
+            if (!this._prevVPMatrix) {
+                this._prevVPMatrix = new Matrix4x4();
+                this._prevVPMatrix.set(this.viewProjectionMatrix);
+                this._prevPosition = this.getWorldPosition();
+            }
+        } else {
+            this._jitterValue.setXY(0, 0);
+            this._prevVPMatrix = null;
+            this._prevPosition = null;
+            this._prevJitteredVPMatrix = null;
+            this._prevJitterValue = null;
+            this._jitteredInvVPMatrix.set(this.invViewProjectionMatrix);
+        }
+        device.pushDeviceStates();
+        device.reverseVertexWindingOrder(false);
+        scene.getRenderer().renderScene(scene, this);
+        device.popDeviceStates();
+        if (useMotionVector) {
+            this._prevJitteredVPMatrix.set(this._jitteredVPMatrix);
+            this._prevJitterValue.set(this._jitterValue);
+            this._prevVPMatrix.set(this.viewProjectionMatrix);
+            this._prevPosition = this.getWorldPosition();
+        }
+        scene.dispatchEvent('endrender', scene, this, this._compositor);
+    }
+    async pickAsync(posX, posY) {
+        this._pickPosX = posX;
+        this._pickPosY = posY;
+        if (!this._pickResultPromise) {
+            this._pickResultPromise = new Promise((resolve)=>{
+                this._pickResultResolve = (result)=>{
+                    resolve(result);
+                    this._pickResultPromise = null;
+                    this._pickResultResolve = null;
+                };
+            });
+        }
+        return this._pickResultPromise;
+    }
+    /** @internal */ getPickResultResolveFunc() {
+        return this._pickResultResolve;
+    }
+    /** @internal */ getPickPosX() {
+        return this._pickPosX;
+    }
+    /** @internal */ getPickPosY() {
+        return this._pickPosY;
+    }
+    /**
+   * Updates the controller state
+   */ updateController() {
+        this._controller?.update();
+    }
+    /**
+   * Reset the controller
+   */ resetController() {
+        this._controller?.reset();
+    }
+    /** @internal */ get jitteredVPMatrix() {
+        return this._jitteredVPMatrix;
+    }
+    /** @internal */ get jitteredInvVPMatrix() {
+        return this._jitteredInvVPMatrix;
+    }
+    /** @internal */ get jitterValue() {
+        return this._jitterValue;
+    }
+    /** @internal */ get prevJitteredVPMatrix() {
+        return this._prevJitteredVPMatrix;
+    }
+    /** @internal */ get prevJitterValue() {
+        return this._prevJitterValue;
+    }
+    /** @internal */ get prevVPMatrix() {
+        return this._prevVPMatrix;
+    }
+    /** @internal */ get prevPosition() {
+        return this._prevPosition;
+    }
+    /** @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.clearHistoryData();
+        this._projMatrix = null;
+        this._viewMatrix = null;
+        this._viewProjMatrix = null;
+        this._postEffectBloom.dispose();
+        this._postEffectFXAA.dispose();
+        this._postEffectMotionBlur.dispose();
+        this._postEffectSSAO.dispose();
+        this._postEffectSSR.dispose();
+        this._postEffectTAA.dispose();
+        this._postEffectTonemap.dispose();
+        this._oit.dispose();
+        super.dispose();
+    }
+}
+
+export { Camera };
+//# sourceMappingURL=camera.js.map