potree-core 2.0.12 → 2.0.14

package/dist/materials/clipping.d.ts

@@ -1,4 +1,16 @@
 import { Box3, Matrix4, Vector3 } from 'three';
+export interface IClipSphere {
+    center: Vector3;
+    radius: number;
+}
+/**
+ * Creates an IClipSphere from a center position and radius.
+ *
+ * @param center - The center position of the clip sphere in world space. Defaults to the origin.
+ * @param radius - The radius of the clip sphere.
+ * @returns An IClipSphere object ready to be passed to PointCloudMaterial.setClipSpheres().
+ */
+export declare function createClipSphere(center: Vector3, radius: number): IClipSphere;
 export declare enum ClipMode {
     DISABLED = 0,
     CLIP_OUTSIDE = 1,
@@ -11,3 +23,15 @@ export interface IClipBox {
     matrix: Matrix4;
     position: Vector3;
 }
+/**
+ * Creates an IClipBox from a given size and position.
+ *
+ * The base shape is a unit cube centered at the origin (-0.5 to 0.5 on each axis).
+ * The transformation matrix is built by applying scale (size) followed by translation (position).
+ * The inverse matrix is computed from the transformation matrix and is used by the shader for clipping.
+ *
+ * @param size - The dimensions of the clip box.
+ * @param position - The center position of the clip box in world space. Defaults to the origin.
+ * @returns An IClipBox object ready to be passed to PointCloudMaterial.setClipBoxes().
+ */
+export declare function createClipBox(size: Vector3, position?: Vector3): IClipBox;

package/dist/materials/eye-dome-lighting-material.d.ts

@@ -10,6 +10,9 @@ export interface IEyeDomeLightingMaterialUniforms {
     neighbours: IUniform<Float32Array>;
     uProj: IUniform<Float32Array>;
     colorMap: IUniform<Texture | null>;
+    far: IUniform<number>;
+    useLogDepth: IUniform<boolean>;
+    useOrthographicCamera: IUniform<boolean>;
 }
 export declare class EyeDomeLightingMaterial extends RawShaderMaterial {
     uniforms: IEyeDomeLightingMaterialUniforms;

package/dist/materials/point-cloud-material.d.ts

@@ -1,7 +1,7 @@
 import { BufferGeometry, Camera, Color, Material, RawShaderMaterial, Scene, Texture, Vector3, Vector4, WebGLRenderer } from 'three';
 import { PointCloudOctree } from '../point-cloud-octree';
 import { PointCloudOctreeNode } from '../point-cloud-octree-node';
-import { ClipMode, IClipBox } from './clipping';
+import { ClipMode, IClipBox, IClipSphere } from './clipping';
 import { PointColorType, PointOpacityType, PointShape, PointSizeType, TreeType } from './enums';
 import { IClassification, IGradient, IUniform } from './types';
 import { ColorEncoding } from './color-encoding';
@@ -52,6 +52,14 @@ export interface IPointCloudMaterialUniforms {
     clipBoxCount: IUniform<number>;
     /** Array containing clipping box parameters */
     clipBoxes: IUniform<Float32Array>;
+    /** Number of active clipping spheres */
+    clipSphereCount: IUniform<number>;
+    /** Array containing clipping sphere parameters (vec4: xyz=center, w=radius) */
+    clipSpheres: IUniform<Float32Array>;
+    /** Number of active clipping planes */
+    clipPlaneCount: IUniform<number>;
+    /** Array containing clipping plane parameters (vec4: xyz=normal, w=constant) */
+    clipPlanes: IUniform<Float32Array>;
     /** Depth map texture for depth-based effects, null if not used */
     depthMap: IUniform<Texture | null>;
     /** Diffuse color as RGB values [r, g, b] */
@@ -149,6 +157,9 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     fog: boolean;
     numClipBoxes: number;
     clipBoxes: IClipBox[];
+    numClipSpheres: number;
+    clipSpheres: IClipSphere[];
+    private numClipPlanes;
     visibleNodesTexture: Texture | undefined;
     private visibleNodeTextureOffsets;
     private _gradient;
@@ -196,6 +207,7 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     highlightedPointScale: number;
     viewScale: number;
     useClipBox: boolean;
+    useClipSphere: boolean;
     weighted: boolean;
     pointColorType: PointColorType;
     pointSizeType: PointSizeType;
@@ -254,6 +266,12 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     updateShaderSource(): void;
     applyDefines(shaderSrc: string): string;
     setClipBoxes(clipBoxes: IClipBox[]): void;
+    setClipSpheres(clipSpheres: IClipSphere[]): void;
+    /**
+     * Syncs the inherited `clippingPlanes` property to internal shader uniforms.
+     * Called automatically each frame from `updateMaterial()`.
+     */
+    private syncClippingPlanes;
     get gradient(): IGradient;
     set gradient(value: IGradient);
     get classification(): IClassification;

package/dist/point-cloud-octree-picker.d.ts

@@ -19,6 +19,9 @@ export interface PickParams {
      */
     onBeforePickRender: (material: PointCloudMaterial, renterTarget: WebGLRenderTarget) => void;
 }
+/**
+ * Handle picking for points in octree.
+ */
 export declare class PointCloudOctreePicker {
     private static readonly helperVec3;
     private static readonly helperSphere;

package/dist/point-cloud-octree.d.ts

@@ -1,4 +1,4 @@
-import { Box3, Camera, Object3D, Ray, Sphere, WebGLRenderer } from 'three';
+import { Box3, Camera, Intersection, Object3D, Ray, Raycaster, Sphere, WebGLRenderer } from 'three';
 import { PointCloudMaterial, PointSizeType } from './materials';
 import { PointCloudOctreeGeometryNode } from './point-cloud-octree-geometry-node';
 import { PointCloudOctreeNode } from './point-cloud-octree-node';
@@ -111,5 +111,20 @@ export declare class PointCloudOctree extends PointCloudTree {
     getBoundingBoxWorld(): Box3;
     getVisibleExtent(): Box3;
     pick(renderer: WebGLRenderer, camera: Camera, ray: Ray, params?: Partial<PickParams>): PickPoint | null;
+    /**
+     * Implements THREE.js raycaster support for point cloud picking.
+     *
+     * When EDL is active, point cloud child nodes are moved to a dedicated rendering layer
+     * (e.g. layer 1) so they are excluded from the normal scene render pass. This means
+     * the default THREE.js layer test inside `Raycaster.intersectObject()` will fail for
+     * those nodes, making `raycaster.intersectObject()` return no hits.
+     *
+     * This override handles that case by directly calling `raycast()` on each visible node's
+     * scene node whenever the node's layer is NOT visible to the raycaster (i.e. EDL mode).
+     * When nodes ARE on a raycaster-visible layer (non-EDL mode), this method does nothing
+     * and lets the normal recursive traversal call `Points.raycast()` instead, avoiding
+     * double-counting of intersections.
+     */
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
     get progress(): number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "potree-core",
-	"version": "2.0.12",
+	"version": "2.0.14",
 	"description": "Potree wrapper for three.js applications",
 	"repository": {
 		"type": "git",