@zephyr3d/scene 0.1.0 → 0.1.1

package/dist/camera/camera.js

@@ -15,9 +15,9 @@ import '../render/sky.js';
 import '../render/clipmap.js';
 import '../render/watermesh.js';
 
-/**
- * The camera node class
- * @public
+/**
+ * The camera node class
+ * @public
  */ class Camera extends SceneNode {
     /** @internal */ _projMatrix;
     /** @internal */ _viewMatrix;
@@ -35,10 +35,10 @@ import '../render/watermesh.js';
     /** @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
+    /**
+   * 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();
@@ -64,11 +64,11 @@ import '../render/watermesh.js';
         this._clipPlane = plane;
         this._invalidate(false);
     }
-    /**
-   * Sample count for MSAA
-   *
-   * @remarks
-   * If greater than one, force the scene to be rendered using multisampled framebuffer
+    /**
+   * Sample count for MSAA
+   *
+   * @remarks
+   * If greater than one, force the scene to be rendered using multisampled framebuffer
    */ get sampleCount() {
         return this._sampleCount;
     }
@@ -117,11 +117,11 @@ import '../render/watermesh.js';
             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.
+    /**
+   * 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) {
@@ -145,61 +145,61 @@ import '../render/watermesh.js';
         }
         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
+    /**
+   * 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
+    /**
+   * 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
+    /**
+   * 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
+    /**
+   * 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
+    /**
+   * 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
+    /**
+   * Gets the projection matrix of the camera
+   * @returns The projection matrix
    */ getProjectionMatrix() {
         if (this._dirty) {
             this._dirty = false;
@@ -218,11 +218,11 @@ import '../render/watermesh.js';
         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
+    /**
+   * 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;
@@ -237,11 +237,11 @@ import '../render/watermesh.js';
         }
         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
+    /**
+   * 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;
@@ -290,10 +290,10 @@ import '../render/watermesh.js';
     /** 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
+    /**
+   * 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();
@@ -303,13 +303,13 @@ import '../render/watermesh.js';
         ForwardRenderScheme.renderScene(scene, this, compositor, logger);
         device.popDeviceStates();
     }
-    /**
-   * Updates the controller state
+    /**
+   * Updates the controller state
    */ updateController() {
         this._controller?.update();
     }
-    /**
-   * Reset the controller
+    /**
+   * Reset the controller
    */ resetController() {
         this._controller?.reset();
     }

package/dist/index.d.ts

@@ -160,6 +160,8 @@ declare class BoundingBox extends AABB implements BoundingVolume {
      * @param maxPoint - Max point of the box
      */
     constructor(minPoint: Vector3, maxPoint: Vector3);
+    /** {@inheritDoc BoundingVolume.behindPlane} */
+    behindPlane(plane: Plane): boolean;
     /** {@inheritDoc BoundingVolume.clone} */
     clone(): BoundingVolume;
     /** {@inheritDoc BoundingVolume.transform} */

package/dist/material/grassmaterial.js

@@ -11,17 +11,17 @@ import './unlit.js';
 import { PBRLightModelMR } from './lightmodel.js';
 import { Vector4, Vector2 } from '@zephyr3d/base';
 
-/**
- * The terrain material
- * @public
+/**
+ * The terrain material
+ * @public
  */ class GrassMaterial extends Material {
     /** @internal */ _lightModel;
     /** @internal */ _terrainSize;
     /** @internal */ _normalMap;
     /** @internal */ _textureSize;
     /** @internal */ _useAlphaToCoverage;
-    /**
-   * Creates an instance of TerrainMaterial
+    /**
+   * Creates an instance of TerrainMaterial
    */ constructor(terrainSize, normalMap, grassTexture){
         super();
         this._lightModel = new PBRLightModelMR();
@@ -67,28 +67,28 @@ import { Vector4, Vector2 } from '@zephyr3d/base';
     set color(val) {
         this._lightModel.albedo = val;
     }
-    /**
-   * {@inheritDoc Material.isTransparent}
-   * @override
+    /**
+   * {@inheritDoc Material.isTransparent}
+   * @override
    */ isTransparent() {
         return false;
     }
-    /**
-   * {@inheritDoc Material.supportLighting}
-   * @override
+    /**
+   * {@inheritDoc Material.supportLighting}
+   * @override
    */ supportLighting() {
         return this._lightModel.supportLighting();
     }
-    /**
-   * {@inheritDoc Material.applyUniforms}
-   * @override
+    /**
+   * {@inheritDoc Material.applyUniforms}
+   * @override
    */ applyUniforms(bindGroup, ctx, needUpdate) {
         super.applyUniforms(bindGroup, ctx, needUpdate);
         this._lightModel.applyUniformsIfOutdated(bindGroup, ctx);
     }
-    /**
-   * {@inheritDoc Material._applyUniforms}
-   * @override
+    /**
+   * {@inheritDoc Material._applyUniforms}
+   * @override
    */ _applyUniforms(bindGroup, ctx) {
         bindGroup.setValue('terrainSize', this._terrainSize);
         bindGroup.setTexture('terrainNormalMap', this._normalMap);

package/dist/material/lambert.js

@@ -3,9 +3,9 @@ import { mixinAlbedoColor } from './mixins/albedocolor.js';
 import { mixinVertexColor } from './mixins/vertexcolor.js';
 import { applyMaterialMixins } from './meshmaterial.js';
 
-/**
- * Lambert material
- * @public
+/**
+ * Lambert material
+ * @public
  */ class LambertMaterial extends applyMaterialMixins(LitMaterial, mixinVertexColor, mixinAlbedoColor) {
     constructor(){
         super();