potree-core 2.0.11 → 2.0.12

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

@@ -0,0 +1,25 @@
+import { Matrix4, RawShaderMaterial, Texture } from 'three';
+import { IUniform } from './types';
+export interface IEyeDomeLightingMaterialUniforms {
+    [name: string]: IUniform<any>;
+    screenWidth: IUniform<number>;
+    screenHeight: IUniform<number>;
+    edlStrength: IUniform<number>;
+    radius: IUniform<number>;
+    opacity: IUniform<number>;
+    neighbours: IUniform<Float32Array>;
+    uProj: IUniform<Float32Array>;
+    colorMap: IUniform<Texture | null>;
+}
+export declare class EyeDomeLightingMaterial extends RawShaderMaterial {
+    uniforms: IEyeDomeLightingMaterialUniforms;
+    private _neighbourCount;
+    private neighboursArray;
+    constructor();
+    get neighbourCount(): number;
+    set neighbourCount(value: number);
+    private initializeNeighboursArray;
+    private getDefines;
+    updateShaderSource(): void;
+    setProjectionMatrix(projectionMatrix: Matrix4): void;
+}

package/dist/materials/index.d.ts

@@ -1,6 +1,7 @@
 export * from './blur-material';
 export * from './clipping';
 export * from './enums';
+export * from './eye-dome-lighting-material';
 export * from './point-cloud-material';
 export * from './texture-generation';
 export * from './types';

package/dist/rendering/edl-pass.d.ts

@@ -0,0 +1,25 @@
+import { Camera, Object3D, WebGLRenderer } from 'three';
+import { PointCloudOctree } from '../point-cloud-octree';
+export type EDLPassParams = {
+    renderer: WebGLRenderer;
+    scene: Object3D;
+    camera: Camera;
+    pointClouds?: PointCloudOctree[];
+    pointCloudLayer?: number;
+};
+export declare class EDLPass {
+    edlStrength: number;
+    radius: number;
+    opacity: number;
+    neighbourCount: number;
+    private rtEDL;
+    private rtTypeChecked;
+    private edlMaterial;
+    private screenPass;
+    private size;
+    constructor();
+    private ensureRenderTargetType;
+    dispose(): void;
+    private resizeToRenderer;
+    render(params: EDLPassParams): void;
+}

package/dist/rendering/potree-renderer.d.ts

@@ -0,0 +1,83 @@
+import { Camera, Object3D, WebGLRenderer } from 'three';
+import { PointCloudOctree } from '../point-cloud-octree';
+import { Potree } from '../potree';
+import { IVisibilityUpdateResult } from '../types';
+/**
+ * Configuration for Eye-Dome Lighting (EDL) rendering.
+ *
+ * Note: EDL is a multi-pass / post-process effect (render default layer 0 (non-pointcloud), render point clouds to an offscreen target,
+ * then composite). Therefore it cannot be expressed as a single `renderer.render(scene, camera)` call.
+ */
+export type PotreeRendererEDLOptions = {
+    enabled: boolean;
+    /** Defaults to 1 so layer 0 can remain reserved for non-pointcloud content in the first pass. */
+    pointCloudLayer?: number;
+    strength?: number;
+    radius?: number;
+    opacity?: number;
+    neighbourCount?: number;
+};
+/**
+ * Options for {@link PotreeRenderer}.
+ *
+ * This is intentionally additive and does not change existing Potree APIs.
+ */
+export type PotreeRendererOptions = {
+    edl?: PotreeRendererEDLOptions;
+};
+/**
+ * Parameters required to render a frame.
+ */
+export type PotreeRendererRenderParams = {
+    renderer: WebGLRenderer;
+    scene: Object3D;
+    camera: Camera;
+    pointClouds?: PointCloudOctree[];
+};
+/**
+ * Thin helper that renders Potree point clouds.
+ *
+ * Why this exists:
+ * - Without EDL, users typically do: `potree.updatePointClouds(...)` then `renderer.render(scene, camera)`.
+ * - With EDL enabled, users previously had to manually:
+ *   1) keep point-cloud objects on a dedicated layer, and
+ *   2) run `EDLPass.render(...)` instead of `renderer.render(...)`.
+ *
+ * `PotreeRenderer` keeps that wiring in one place while preserving backward compatibility.
+ */
+export declare class PotreeRenderer {
+    private edlPass;
+    private edlOptions;
+    private lastPointClouds;
+    private overriddenMaterials;
+    private overriddenLayerMasks;
+    constructor(options?: PotreeRendererOptions);
+    /** Releases internally owned GPU resources (render targets). */
+    dispose(): void;
+    /**
+     * Enables/disables EDL and updates EDL parameters.
+     *
+     * This method is safe to call at runtime (e.g. toggling EDL on/off).
+     */
+    setEDL(options: PotreeRendererEDLOptions): void;
+    private setLayerMaskRecursive;
+    /**
+     * Ensures all point-cloud objects (including newly created child nodes) are on the provided layer.
+      * Side effect: overwrites `Object3D.layers` for the point cloud subtree.
+     *
+     * When EDL is enabled, layer separation is required so we can render:
+     * - non-pointcloud content first (layer 0), then
+     * - point clouds on a dedicated layer into an offscreen target.
+     */
+    syncPointCloudLayers(pointClouds: PointCloudOctree[], layer: number): void;
+    private applyEDLState;
+    /**
+     * Renders a frame.
+     *
+     * - EDL disabled: calls `renderer.render(scene, camera)`.
+     * - EDL enabled: runs the EDL multi-pass pipeline via {@link EDLPass}.
+     */
+    render(params: PotreeRendererRenderParams): void;
+    /** Convenience helper: `updatePointClouds()` followed by {@link render}. */
+    updateAndRender(potree: Potree, pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer, scene: Object3D): IVisibilityUpdateResult;
+}

package/dist/rendering/screen-pass.d.ts

@@ -0,0 +1,11 @@
+import { RawShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare class ScreenPass {
+    private scene;
+    private camera;
+    private quad;
+    private geometry;
+    private placeholderMaterial;
+    constructor();
+    dispose(): void;
+    render(renderer: WebGLRenderer, material: RawShaderMaterial, target?: WebGLRenderTarget | null): void;
+}

package/dist/utils/binary-heap.d.ts

@@ -0,0 +1,16 @@
+export class BinaryHeap<T> 
+{
+	constructor(scoreFunction: (node: T)=> number);
+
+	push(node: T): void;
+
+	pop(): T | undefined;
+
+	remove(node: T): void;
+
+	size(): number;
+
+	bubbleUp(n: number): void;
+
+	sinkDown(n: number): void;
+}

package/package.json

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