@zephyr3d/scene 0.4.0 → 0.6.0

package/dist/camera/camera.js

@@ -1,7 +1,8 @@
-import { Matrix4x4, Vector4, Frustum } from '@zephyr3d/base';
+import { Matrix4x4, Vector4, Vector3, Ray, Frustum } from '@zephyr3d/base';
 import { SceneNode } from '../scene/scene_node.js';
 import { Application } from '../app.js';
 import '../scene/octree.js';
+import '../values.js';
 import '@zephyr3d/device';
 import '../material/shader/helper.js';
 import '../material/lambert.js';
@@ -15,7 +16,6 @@ import '../material/pbrsg.js';
 import { SceneRenderer } from '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
-import '../render/watermesh.js';
 
 /**
  * The camera node class
@@ -40,8 +40,25 @@ import '../render/watermesh.js';
     /** @internal */ _oit;
     /** @internal */ _depthPrePass;
     /** @internal */ _commandBufferReuse;
+    /** @internal */ _HiZ;
+    /** @internal */ _SSR;
+    /** @internal */ _ssrParams;
+    /** @internal */ _ssrMaxRoughness;
+    /** @internal */ _ssrRoughnessFactor;
+    /** @internal */ _ssrStride;
+    /** @internal */ _ssrCalcThickness;
+    /** @internal */ _ssrBlurriness;
+    /** @internal */ _ssrBlurDepthCutoff;
+    /** @internal */ _ssrBlurKernelSize;
+    /** @internal */ _ssrBlurStdDev;
+    /** @internal */ _picking;
+    /** @internal */ _pickPosX;
+    /** @internal */ _pickPosY;
+    /** @internal */ _pickResultPromise;
+    /** @internal */ _pickResult;
     /**
    * Creates a new camera node
+   *
    * @param scene - The scene that the camera belongs to
    * @param projectionMatrix - Projection matrix for this camera
    */ constructor(scene, projectionMatrix){
@@ -63,6 +80,20 @@ import '../render/watermesh.js';
         this._frustumV = null;
         this._oit = null;
         this._depthPrePass = false;
+        this._pickPosX = 0;
+        this._pickPosY = 0;
+        this._HiZ = false;
+        this._SSR = false;
+        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._pickResult = null;
         this._commandBufferReuse = true;
     }
     /** Clip plane in camera space */ get clipPlane() {
@@ -72,6 +103,125 @@ import '../render/watermesh.js';
         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 Screen Space Reflections (SSR) is enabled.
+   */ get SSR() {
+        return this._SSR;
+    }
+    set SSR(val) {
+        this._SSR = !!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;
+    }
     /** Whether to perform a depth pass */ get depthPrePass() {
         return this._depthPrePass;
     }
@@ -84,6 +234,36 @@ import '../render/watermesh.js';
     set commandBufferReuse(val) {
         this._commandBufferReuse = !!val;
     }
+    /** Whether GPU picking is enabled for this camera */ get enablePicking() {
+        return this._picking;
+    }
+    set enablePicking(enable) {
+        this._picking = !!enable;
+    }
+    /** X coordinate for picking related to viewport  */ get pickPosX() {
+        return this._pickPosX;
+    }
+    set pickPosX(val) {
+        this._pickPosX = val;
+    }
+    /** Y coordinate for picking related to viewport  */ get pickPosY() {
+        return this._pickPosY;
+    }
+    set pickPosY(val) {
+        this._pickPosY = val;
+    }
+    /** Pick result */ get pickResult() {
+        return this._pickResult;
+    }
+    set pickResult(val) {
+        this._pickResult = val;
+    }
+    /** @internal */ get pickResultAsync() {
+        return this._pickResultPromise;
+    }
+    set pickResultAsync(val) {
+        this._pickResultPromise = val;
+    }
     /**
    * Sample count for MSAA
    *
@@ -172,6 +352,22 @@ import '../render/watermesh.js';
         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 vClip = new Vector4(2 * x / width - 1, 1 - 2 * y / height, 1, 1);
+        const vWorld = this.invViewProjectionMatrix.transform(vClip);
+        vWorld.scaleBy(1 / vWorld.w);
+        const vEye = this.getWorldPosition();
+        const vDir = Vector3.sub(vWorld.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
@@ -320,13 +516,13 @@ import '../render/watermesh.js';
    * 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) {
+   */ render(scene, compositor) {
         const device = Application.instance.device;
         device.pushDeviceStates();
         device.reverseVertexWindingOrder(false);
         device.setFramebuffer(this._framebuffer);
         SceneRenderer.setClearColor(this._clearColor);
-        SceneRenderer.renderScene(scene, this, compositor, logger);
+        SceneRenderer.renderScene(scene, this, compositor);
         device.popDeviceStates();
     }
     /**

package/dist/camera/camera.js.map

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