itowns 2.45.1 → 2.45.2-next.1

package/lib/Renderer/PointsMaterial.d.ts

@@ -0,0 +1,226 @@
+export namespace PNTS_MODE {
+    let COLOR: number;
+    let INTENSITY: number;
+    let CLASSIFICATION: number;
+    let ELEVATION: number;
+    let RETURN_NUMBER: number;
+    let RETURN_TYPE: number;
+    let RETURN_COUNT: number;
+    let POINT_SOURCE_ID: number;
+    let SCAN_ANGLE: number;
+    let NORMAL: number;
+}
+export namespace PNTS_SHAPE {
+    let CIRCLE: number;
+    let SQUARE: number;
+}
+export namespace PNTS_SIZE_MODE {
+    let VALUE: number;
+    let ATTENUATED: number;
+}
+export namespace ClassificationScheme {
+    let DEFAULT: {
+        0: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        1: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        2: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        3: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        4: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        5: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        6: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        7: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        8: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        9: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        10: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        11: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        12: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+        DEFAULT: {
+            visible: boolean;
+            name: string;
+            color: THREE.Color;
+            opacity: number;
+        };
+    };
+}
+export default PointsMaterial;
+/**
+ * Every lidar point can have a classification assigned to it that defines
+ * the type of object that has reflected the laser pulse. Lidar points can be
+ * classified into a number of categories including bare earth or ground,
+ * top of canopy, and water. The different classes are defined using numeric
+ * integer codes in the files.
+ */
+export type Classification = {
+    /**
+     * - category visibility,
+     */
+    visible: boolean;
+    /**
+     * - category name,
+     */
+    name: string;
+    /**
+     * - category color,
+     */
+    color: THREE.Color;
+    /**
+     * - category opacity,
+     */
+    opacity: number;
+};
+import * as THREE from 'three';
+declare class PointsMaterial extends THREE.ShaderMaterial {
+    /**
+     * @class      PointsMaterial
+     * @param      {object}  [options={}]  The options
+     * @param      {number}  [options.size=1] point size
+     * @param      {number}  [options.mode=PNTS_MODE.COLOR]  display mode.
+     * @param      {number}  [options.shape=PNTS_SHAPE.CIRCLE]  rendered points shape.
+     * @param      {THREE.Vector4}  [options.overlayColor=new THREE.Vector4(0, 0, 0, 0)]  overlay color.
+
+     * @param      {Scheme}  [options.classificationScheme]  LUT for point classification colorization.
+     * @param      {Scheme}  [options.discreteScheme]  LUT for other discret point values colorization.
+     * @param      {string}  [options.gradient]  Descrition of the gradient to use for continuous point values.
+     *                          (Default value will be the 'SPECTRAL' gradient from Utils/Gradients)
+     * @param      {number}  [options.sizeMode=PNTS_SIZE_MODE.VALUE]  point cloud size mode. Only 'VALUE' or 'ATTENUATED' are possible. VALUE use constant size, ATTENUATED compute size depending on distance from point to camera.
+     * @param      {number}  [options.minAttenuatedSize=3]  minimum scale used by 'ATTENUATED' size mode
+     * @param      {number}  [options.maxAttenuatedSize=10]  maximum scale used by 'ATTENUATED' size mode
+     *
+     * @property {THREE.Vector2}  [options.intensityRange=new THREE.Vector2(1, 65536)]  intensity range (default value will be [1, 65536] if not defined at Layer level).
+     * @property {THREE.Vector2}  [options.elevationRange=new THREE.Vector2(0, 1000)]  elevation range (default value will be [0, 1000] if not defined at Layer level).
+     * @property {THREE.Vector2}  [options.angleRange=new THREE.Vector2(-90, 90)]  scan angle range (default value will be [-90, 90] if not defined at Layer level).
+     * @property {Scheme}  classificationScheme - Color scheme for point classification values.
+     * @property {Scheme}  discreteScheme - Color scheme for all other discrete values.
+     * @property {object}  gradients - Descriptions of all available gradients.
+     * @property {object}  gradient - Description of the gradient to use for display.
+     * @property {THREE.CanvasTexture}  gradientTexture - The texture generate from the choosen gradient.
+     *
+     * @example
+     * // change color category classification
+     * const pointMaterial = new PointsMaterial();
+     * pointMaterial.classification[3].color.setStyle('red');
+     * pointMaterial.recomputeClassification();
+     */
+    constructor(options?: {
+        size?: number | undefined;
+        mode?: number | undefined;
+        shape?: number | undefined;
+        overlayColor?: THREE.Vector4 | undefined;
+        classificationScheme?: any;
+        discreteScheme?: any;
+        gradient?: string | undefined;
+        sizeMode?: number | undefined;
+        minAttenuatedSize?: number | undefined;
+        maxAttenuatedSize?: number | undefined;
+    });
+    gradients: any;
+    gradientTexture: THREE.CanvasTexture;
+    /** @param {number} size */
+    set size(size: number);
+    /** @returns {number} */
+    get size(): number;
+    classificationScheme: any;
+    discreteScheme: any;
+    set gradient(value: any);
+    /**
+     * Copy the parameters from the passed material into this material.
+     * @override
+     * @param {THREE.PointsMaterial} source
+     * @returns {this}
+     */
+    override copy(source: THREE.PointsMaterial): this;
+    /** @param {THREE.Texture | null} map */
+    set map(map: THREE.Texture | null);
+    /** @returns {THREE.Texture | null} */
+    get map(): THREE.Texture | null;
+    /** @param {THREE.Texture | null} map */
+    set alphaMap(map: THREE.Texture | null);
+    /** @returns {THREE.Texture | null} */
+    get alphaMap(): THREE.Texture | null;
+    /** @param {boolean} value */
+    set sizeAttenuation(value: boolean);
+    /** @returns {boolean} */
+    get sizeAttenuation(): boolean;
+    /** @param {THREE.Color} color */
+    set color(color: THREE.Color);
+    /** @returns {THREE.Color} */
+    get color(): THREE.Color;
+    sizeMode: number | undefined;
+    /** @param {number} gamma */
+    set gamma(gamma: number);
+    /** @returns {number} */
+    get gamma(): number;
+    /** @param {number} ambientBoost */
+    set ambientBoost(ambientBoost: number);
+    /** @returns {number} */
+    get ambientBoost(): number;
+    recomputeClassification(): void;
+    recomputeDiscreteTexture(): void;
+    recomputeVisibilityTexture(): void;
+    enablePicking(picking: any): void;
+    picking: any;
+}

package/lib/Renderer/PointsMaterial.js

@@ -1,8 +1,8 @@
 import * as THREE from 'three';
 /* babel-plugin-inline-import './Shader/PointsVS.glsl' */
-const PointsVS = "#include <common>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec4 vColor; // color_pars_vertex\n\n#ifdef USE_POINTS_UV\n    varying vec2 vUv;\n    uniform mat3 uvTransform;\n#endif\n\n#define NB_CLASS 8.\n\nuniform float size;\nuniform float scale;\n\nuniform bool picking;\nuniform int mode;\n\nuniform vec2 elevationRange;\nuniform vec2 intensityRange;\nuniform vec2 angleRange;\n\nuniform sampler2D classificationTexture;\nuniform sampler2D discreteTexture;\nuniform sampler2D gradientTexture;\nuniform int sizeMode;\nuniform float minAttenuatedSize;\nuniform float maxAttenuatedSize;\n\nattribute vec4 unique_id;\nattribute float intensity;\nattribute float classification;\nattribute float pointSourceID;\n\nattribute float returnNumber;\nattribute float numberOfReturns;\nattribute float scanAngle;\n\nvoid main() {\n    vColor = vec4(1.0);\n    if (picking) {\n        vColor = unique_id;\n    } else {\n        if (mode == PNTS_MODE_CLASSIFICATION) {\n            vec2 uv = vec2(classification/255., 0.5);\n            vColor = texture2D(classificationTexture, uv);\n        } else if (mode == PNTS_MODE_NORMAL) {\n            vColor.rgb = abs(normal);\n        } else if (mode == PNTS_MODE_COLOR) {\n#if defined(USE_COLOR)\n            vColor.rgb = color.rgb;\n#elif defined(USE_COLOR_ALPHA)\n            vColor = color;\n#endif\n        } else if (mode == PNTS_MODE_RETURN_NUMBER) {\n            vec2 uv = vec2(returnNumber/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_RETURN_TYPE) {\n            float returnType;\n            if (returnNumber > numberOfReturns) {\n                returnType = 4.;\n            } else if (returnNumber == 1.) {\n                if (numberOfReturns == 1.) {\n                    // single\n                    returnType = 0.;\n                } else {\n                    // first\n                    returnType = 1.;\n                }\n            } else {\n                if (returnNumber == numberOfReturns) {\n                    // last\n                    returnType = 3.;\n                } else {\n                    // intermediate\n                    returnType = 2.;\n                }\n            }\n            vec2 uv = vec2(returnType/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_RETURN_COUNT) {\n            vec2 uv = vec2(numberOfReturns/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_POINT_SOURCE_ID) {\n            vec2 uv = vec2(mod(pointSourceID, NB_CLASS)/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_SCAN_ANGLE) {\n            float i = (scanAngle - angleRange.x) / (angleRange.y - angleRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        } else if (mode == PNTS_MODE_INTENSITY) {\n            float i = (intensity - intensityRange.x) / (intensityRange.y - intensityRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        } else if (mode == PNTS_MODE_ELEVATION) {\n            float z = (modelMatrix * vec4(position, 1.0)).z;\n            float i = (z - elevationRange.x) / (elevationRange.y - elevationRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        }\n    }\n\n#define USE_COLOR_ALPHA\n#include <morphcolor_vertex>\n#include <begin_vertex>\n#include <morphtarget_vertex>\n#include <project_vertex>\n\n    gl_PointSize = size;\n\n    if (sizeMode == PNTS_SIZE_MODE_ATTENUATED) {\n        bool isPerspective = isPerspectiveMatrix(projectionMatrix);\n\n        if (isPerspective) {\n            gl_PointSize *= scale / -mvPosition.z;\n            gl_PointSize = clamp(gl_PointSize, minAttenuatedSize, maxAttenuatedSize);\n        }\n    }\n\n#include <logdepthbuf_vertex>\n#include <clipping_planes_vertex>\n#include <worldpos_vertex>\n#include <fog_vertex>\n}\n";
+const PointsVS = "#include <common>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec4 vColor; // color_pars_vertex\n\n#ifdef USE_POINTS_UV\n    varying vec2 vUv;\n    uniform mat3 uvTransform;\n#endif\n\n#define SOURCE_ID_GROUP 8.\n\nuniform float size;\nuniform float scale;\n\nuniform bool picking;\nuniform int mode;\n\nuniform vec2 elevationRange;\nuniform vec2 intensityRange;\nuniform vec2 angleRange;\n\nuniform sampler2D classificationTexture;\nuniform sampler2D discreteTexture;\nuniform sampler2D gradientTexture;\nuniform sampler2D visibilityTexture;\n\nuniform int sizeMode;\nuniform float minAttenuatedSize;\nuniform float maxAttenuatedSize;\n\nattribute vec4 unique_id;\nattribute float intensity;\nattribute float classification;\nattribute float pointSourceID;\n\nattribute float returnNumber;\nattribute float numberOfReturns;\nattribute float scanAngle;\n\nvoid main() {\n    vec2 uv = vec2(classification/255., 0.5);\n\n    vColor = vec4(1.0);\n    if (picking) {\n        vColor = unique_id;\n    } else {\n        if (mode == PNTS_MODE_CLASSIFICATION) {\n            vColor = texture2D(classificationTexture, uv);\n        } else if (mode == PNTS_MODE_NORMAL) {\n            vColor.rgb = abs(normal);\n        } else if (mode == PNTS_MODE_COLOR) {\n#if defined(USE_COLOR)\n            vColor.rgb = color.rgb;\n#elif defined(USE_COLOR_ALPHA)\n            vColor = color;\n#endif\n        } else if (mode == PNTS_MODE_RETURN_NUMBER) {\n            vec2 uv = vec2(returnNumber/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_RETURN_TYPE) {\n            float returnType;\n            if (returnNumber > numberOfReturns) {\n                returnType = 4.;\n            } else if (returnNumber == 1.) {\n                if (numberOfReturns == 1.) {\n                    // single\n                    returnType = 0.;\n                } else {\n                    // first\n                    returnType = 1.;\n                }\n            } else {\n                if (returnNumber == numberOfReturns) {\n                    // last\n                    returnType = 3.;\n                } else {\n                    // intermediate\n                    returnType = 2.;\n                }\n            }\n            vec2 uv = vec2(returnType/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_RETURN_COUNT) {\n            vec2 uv = vec2(numberOfReturns/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_POINT_SOURCE_ID) {\n            vec2 uv = vec2(mod(pointSourceID, SOURCE_ID_GROUP)/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_SCAN_ANGLE) {\n            float i = (scanAngle - angleRange.x) / (angleRange.y - angleRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        } else if (mode == PNTS_MODE_INTENSITY) {\n            float i = (intensity - intensityRange.x) / (intensityRange.y - intensityRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        } else if (mode == PNTS_MODE_ELEVATION) {\n            float z = (modelMatrix * vec4(position, 1.0)).z;\n            float i = (z - elevationRange.x) / (elevationRange.y - elevationRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        }\n    }\n\n    if (texture2D(visibilityTexture, uv).r == 0.) {\n        vColor.a = 0.;\n    }\n\n#define USE_COLOR_ALPHA\n#include <morphcolor_vertex>\n#include <begin_vertex>\n#include <morphtarget_vertex>\n#include <project_vertex>\n\n    gl_PointSize = size;\n\n    if (sizeMode == PNTS_SIZE_MODE_ATTENUATED) {\n        bool isPerspective = isPerspectiveMatrix(projectionMatrix);\n\n        if (isPerspective) {\n            gl_PointSize *= scale / -mvPosition.z;\n            gl_PointSize = clamp(gl_PointSize, minAttenuatedSize, maxAttenuatedSize);\n        }\n    }\n\n#include <logdepthbuf_vertex>\n#include <clipping_planes_vertex>\n#include <worldpos_vertex>\n#include <fog_vertex>\n}\n";
 /* babel-plugin-inline-import './Shader/PointsFS.glsl' */
-const PointsFS = "#define USE_COLOR_ALPHA\n\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\nuniform vec3 diffuse;\nuniform float opacity;\n\nuniform bool picking;\nuniform int shape;\n\nvoid main() {\n\n// Early discard (clipping planes and shape)\n#include <clipping_planes_fragment>\n    if (shape == PNTS_SHAPE_CIRCLE) {\n        //circular rendering in glsl\n        if ((length(gl_PointCoord - 0.5) > 0.5)) {\n            discard;\n        }\n    }\n\n#include <logdepthbuf_fragment>\n\n    vec4 diffuseColor = vec4(diffuse, opacity);\n#include <map_particle_fragment>\n#include <color_fragment>\n\n#include <alphatest_fragment>\n#include <alphahash_fragment>\n\n    vec3 outgoingLight = diffuseColor.rgb;\n#include <opaque_fragment> // gl_FragColor\n#include <tonemapping_fragment>\n#include <fog_fragment>\n#include <premultiplied_alpha_fragment>\n\n}\n";
+const PointsFS = "#define USE_COLOR_ALPHA\n\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\nuniform vec3 diffuse;\nuniform float opacity;\nuniform float gamma;\nuniform float ambientBoost;\n\nuniform bool picking;\nuniform int shape;\n\nvoid main() {\n\n// Early discard (clipping planes and shape)\n#include <clipping_planes_fragment>\n    if (shape == PNTS_SHAPE_CIRCLE) {\n        //circular rendering in glsl\n        if ((length(gl_PointCoord - 0.5) > 0.5)) {\n            discard;\n        }\n    }\n\n#include <logdepthbuf_fragment>\n\n    vec4 diffuseColor = vec4(diffuse, opacity);\n#include <map_particle_fragment>\n#include <color_fragment>\n\n#include <alphatest_fragment>\n#include <alphahash_fragment>\n\n    vec3 outgoingLight = diffuseColor.rgb;\n    \n    outgoingLight = max(outgoingLight, vec3(ambientBoost));\n    \n    outgoingLight = pow(outgoingLight, vec3(1.0 / gamma));\n    \n#include <opaque_fragment> // gl_FragColor\n#include <tonemapping_fragment>\n#include <fog_fragment>\n#include <premultiplied_alpha_fragment>\n\n}\n";
 import CommonMaterial from "./CommonMaterial.js";
 import Gradients from "../Utils/Gradients.js";
 export const PNTS_MODE = {
@@ -218,7 +218,6 @@ function generateGradientTexture(gradient) {
   return texture;
 }
 function recomputeTexture(scheme, texture, nbClass) {
-  let needTransparency;
   const data = texture.image.data;
   const width = texture.image.width;
   if (!nbClass) {
@@ -227,18 +226,14 @@ function recomputeTexture(scheme, texture, nbClass) {
   for (let i = 0; i < width; i++) {
     let color;
     let opacity;
-    let visible = true;
     if (scheme[i]) {
       color = scheme[i].color;
-      visible = scheme[i].visible;
       opacity = scheme[i].opacity;
     } else if (scheme[i % nbClass]) {
       color = scheme[i % nbClass].color;
-      visible = scheme[i % nbClass].visible;
       opacity = scheme[i % nbClass].opacity;
     } else if (scheme.DEFAULT) {
       color = scheme.DEFAULT.color;
-      visible = scheme.DEFAULT.visible;
       opacity = scheme.DEFAULT.opacity;
     } else {
       color = white;
@@ -248,11 +243,9 @@ function recomputeTexture(scheme, texture, nbClass) {
     data[j + 0] = parseInt(255 * color.r, 10);
     data[j + 1] = parseInt(255 * color.g, 10);
     data[j + 2] = parseInt(255 * color.b, 10);
-    data[j + 3] = visible ? parseInt(255 * opacity, 10) : 0;
-    needTransparency = needTransparency || opacity < 1 || !visible;
+    data[j + 3] = parseInt(255 * opacity, 10);
   }
   texture.needsUpdate = true;
-  return needTransparency;
 }
 class PointsMaterial extends THREE.ShaderMaterial {
   /**
@@ -305,12 +298,15 @@ class PointsMaterial extends THREE.ShaderMaterial {
       minAttenuatedSize = 3,
       maxAttenuatedSize = 10,
       gradient,
+      gamma = 1.0,
       scale = 0.05 * 0.5 / Math.tan(1.0 / 2.0),
+      ambientBoost = 0.0,
       ...materialOptions
     } = options;
     super({
       ...materialOptions,
       fog: true,
+      transparent: true,
       precision: 'highp',
       vertexColors: true
     });
@@ -319,7 +315,6 @@ class PointsMaterial extends THREE.ShaderMaterial {
     THREE.UniformsLib.points, THREE.UniformsLib.fog]);
     this.vertexShader = PointsVS;
     this.fragmentShader = PointsFS;
-    this.userData.needTransparency = {};
     this.gradients = gradients;
     this.gradientTexture = new THREE.CanvasTexture();
     CommonMaterial.setDefineMapping(this, 'PNTS_MODE', PNTS_MODE);
@@ -337,6 +332,8 @@ class PointsMaterial extends THREE.ShaderMaterial {
     CommonMaterial.setUniformProperty(this, 'scale', scale);
     CommonMaterial.setUniformProperty(this, 'minAttenuatedSize', minAttenuatedSize);
     CommonMaterial.setUniformProperty(this, 'maxAttenuatedSize', maxAttenuatedSize);
+    CommonMaterial.setUniformProperty(this, 'gamma', gamma);
+    CommonMaterial.setUniformProperty(this, 'ambientBoost', ambientBoost);
 
     // add classification texture to apply classification lut.
     const data = new Uint8Array(256 * 4);
@@ -352,6 +349,13 @@ class PointsMaterial extends THREE.ShaderMaterial {
     textureLUT.magFilter = THREE.NearestFilter;
     CommonMaterial.setUniformProperty(this, 'discreteTexture', textureLUT);
 
+    // add texture to apply visibility.
+    const dataVisi = new Uint8Array(256 * 1);
+    const textureVisi = new THREE.DataTexture(dataVisi, 256, 1, THREE.RedFormat);
+    textureVisi.needsUpdate = true;
+    textureVisi.magFilter = THREE.NearestFilter;
+    CommonMaterial.setUniformProperty(this, 'visibilityTexture', textureVisi);
+
     // Classification and other discrete values scheme
     this.classificationScheme = classificationScheme;
     this.discreteScheme = discreteScheme;
@@ -359,6 +363,7 @@ class PointsMaterial extends THREE.ShaderMaterial {
     // Update classification and discrete Texture
     this.recomputeClassification();
     this.recomputeDiscreteTexture();
+    this.recomputeVisibilityTexture();
 
     // Gradient texture for continuous values
     this.gradient = gradient;
@@ -372,9 +377,6 @@ class PointsMaterial extends THREE.ShaderMaterial {
    * @returns {this}
    */
   copy(source) {
-    // Manually copy this needTransparency if source doesn't have one. Prevents losing it when copying a three
-    // PointsMaterial into this PointsMaterial
-    const needTransparency = source.userData.needTransparency !== undefined ? source.userData.needTransparency : this.userData.needTransparency;
     if (source.isShaderMaterial) {
       super.copy(source);
     } else {
@@ -388,7 +390,6 @@ class PointsMaterial extends THREE.ShaderMaterial {
     this.size = source.size;
     this.sizeAttenuation = source.sizeAttenuation;
     this.fog = source.fog;
-    this.userData.needTransparency = needTransparency;
     return this;
   }
 
@@ -455,20 +456,57 @@ class PointsMaterial extends THREE.ShaderMaterial {
   set sizeAttenuation(value) {
     this.sizeMode = value ? PNTS_SIZE_MODE.ATTENUATED : PNTS_SIZE_MODE.VALUE;
   }
+
+  /** @returns {number} */
+  get gamma() {
+    return this.uniforms.gamma.value;
+  }
+
+  /** @param {number} gamma */
+  set gamma(gamma) {
+    this.uniforms.gamma.value = gamma;
+  }
+
+  /** @returns {number} */
+  get ambientBoost() {
+    return this.uniforms.ambientBoost.value;
+  }
+
+  /** @param {number} ambientBoost */
+  set ambientBoost(ambientBoost) {
+    this.uniforms.ambientBoost.value = ambientBoost;
+  }
   recomputeClassification() {
-    const needTransparency = recomputeTexture(this.classificationScheme, this.classificationTexture, 256);
-    this.userData.needTransparency[PNTS_MODE.CLASSIFICATION] = needTransparency;
+    recomputeTexture(this.classificationScheme, this.classificationTexture, 256);
     this.dispatchEvent({
       type: 'material_property_changed',
       target: this.uniforms
     });
   }
   recomputeDiscreteTexture() {
-    const needTransparency = recomputeTexture(this.discreteScheme, this.discreteTexture);
-    this.userData.needTransparency[PNTS_MODE.RETURN_NUMBER] = needTransparency;
-    this.userData.needTransparency[PNTS_MODE.RETURN_TYPE] = needTransparency;
-    this.userData.needTransparency[PNTS_MODE.RETURN_COUNT] = needTransparency;
-    this.userData.needTransparency[PNTS_MODE.POINT_SOURCE_ID] = needTransparency;
+    recomputeTexture(this.discreteScheme, this.discreteTexture);
+    this.dispatchEvent({
+      type: 'material_property_changed',
+      target: this.uniforms
+    });
+  }
+  recomputeVisibilityTexture() {
+    const texture = this.visibilityTexture;
+    const scheme = this.classificationScheme;
+    const data = texture.image.data;
+    const width = texture.image.width;
+    for (let i = 0; i < width; i++) {
+      let visible;
+      if (scheme[i]) {
+        visible = scheme[i].visible;
+      } else if (scheme.DEFAULT) {
+        visible = scheme.DEFAULT.visible;
+      } else {
+        visible = true;
+      }
+      data[i] = visible ? 255 : 0;
+    }
+    texture.needsUpdate = true;
     this.dispatchEvent({
       type: 'material_property_changed',
       target: this.uniforms

package/lib/Renderer/RasterTile.d.ts

@@ -0,0 +1,53 @@
+export const EMPTY_TEXTURE_ZOOM: -1;
+/**
+ * A `RasterTile` is part of raster {@link Layer} data.
+ * This part is a spatial subdivision of the extent of a layer.
+ * In the `RasterTile`, The data are converted on three.js textures.
+ * This `RasterTile` textures are assigned to a `LayeredMaterial`.
+ * This material is applied on terrain (TileMesh).
+ * The color textures are mapped to color the terrain.
+ * The elevation textures are used to displace vertex terrain.
+ *
+ * @class RasterTile
+ */
+export class RasterTile extends THREE.EventDispatcher<any> {
+    constructor(layer: any);
+    layer: any;
+    crs: any;
+    textures: any[];
+    offsetScales: any[];
+    level: number;
+    needsUpdate: boolean;
+    _handlerCBEvent: () => void;
+    get id(): any;
+    get opacity(): any;
+    get visible(): any;
+    initFromParent(parent: any, extents: any): void;
+    sortBestParentTextures(textures: any): any;
+    disposeRedrawnTextures(newTextures: any): void;
+    dispose(removeEvent?: boolean): void;
+    _listeners: {} | undefined;
+    disposeAtIndexes(indexes: any): void;
+    setTexture(index: any, texture: any, offsetScale: any): void;
+    setTextures(textures: any, pitchs: any): void;
+    shouldWriteTextureAtIndex(index: any, texture: any): any;
+}
+export class RasterColorTile extends RasterTile {
+    get effect_type(): any;
+    get effect_parameter(): any;
+    get transparent(): any;
+}
+export class RasterElevationTile extends RasterTile {
+    scaleFactor: number;
+    min: any;
+    max: any;
+    bias: any;
+    mode: any;
+    zmin: any;
+    zmax: any;
+    get scale(): number;
+    dispose(removeEvent: any): void;
+    updateMinMaxElevation(): void;
+    replaceNoDataValueFromTexture(texture: any): void;
+}
+import * as THREE from 'three';

package/lib/Renderer/RasterTile.js

@@ -24,8 +24,8 @@ function getIndiceWithPitch(i, pitch, w) {
  *
  * @class RasterTile
  */
-class RasterTile extends THREE.EventDispatcher {
-  constructor(material, layer) {
+export class RasterTile extends THREE.EventDispatcher {
+  constructor(layer) {
     super();
     this.layer = layer;
     this.crs = layer.parent.tileMatrixSets.indexOf(layer.crs);
@@ -35,9 +35,9 @@ class RasterTile extends THREE.EventDispatcher {
     this.textures = [];
     this.offsetScales = [];
     this.level = EMPTY_TEXTURE_ZOOM;
-    this.material = material;
+    this.needsUpdate = false;
     this._handlerCBEvent = () => {
-      this.material.layersNeedUpdate = true;
+      this.needsUpdate = true;
     };
     layer.addEventListener('visible-property-changed', this._handlerCBEvent);
     layer.addEventListener('opacity-property-changed', this._handlerCBEvent);
@@ -105,14 +105,14 @@ class RasterTile extends THREE.EventDispatcher {
         texture.dispose();
       }
     }
-    this.material.layersNeedUpdate = true;
+    this.needsUpdate = true;
   }
   setTexture(index, texture, offsetScale) {
     if (this.shouldWriteTextureAtIndex(index, texture)) {
       this.level = texture && texture.extent ? texture.extent.zoom : this.level;
       this.textures[index] = texture || null;
       this.offsetScales[index] = offsetScale;
-      this.material.layersNeedUpdate = true;
+      this.needsUpdate = true;
     }
   }
   setTextures(textures, pitchs) {
@@ -126,7 +126,6 @@ class RasterTile extends THREE.EventDispatcher {
     return !this.textures[index] || texture && texture.isTexture;
   }
 }
-export default RasterTile;
 export class RasterColorTile extends RasterTile {
   get effect_type() {
     return this.layer.effect_type;
@@ -139,8 +138,8 @@ export class RasterColorTile extends RasterTile {
   }
 }
 export class RasterElevationTile extends RasterTile {
-  constructor(material, layer) {
-    super(material, layer);
+  constructor(layer) {
+    super(layer);
     const defaultEle = {
       bias: 0,
       mode: ELEVATION_MODES.DATA,

package/lib/Renderer/RenderMode.d.ts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { MODES };
+    export { push };
+}
+export default _default;
+declare namespace MODES {
+    let FINAL: number;
+    let DEPTH: number;
+    let ID: number;
+}
+declare function push(object3d: any, mode: any): () => void;

package/lib/Renderer/RenderMode.js

@@ -14,6 +14,7 @@ function push(object3d, mode) {
     const material = node.material;
     if (material) {
       material.mode = m;
+      material.transparent = m === MODES.FINAL;
     }
   };
   object3d.traverse(setMode(mode));

package/lib/Renderer/Shader/ShaderChunk.d.ts

@@ -0,0 +1,78 @@
+export default ShaderChunk;
+declare const ShaderChunk: ShaderChunkManager;
+/**
+ * The ShaderChunkManager manages the itowns chunks shader.
+ * It adds chunks to THREE.ShaderChunk to compile shaders
+ *
+ * In itowns, if you want access to `ShaderChunkManager` instance :
+ *
+ * ```js
+ * import ShaderChunk from '../../Renderer/Shader/ShaderChunk';
+ * ```
+ * or
+ * ```js
+ * const ShaderChunk = itowns.ShaderChunk';
+ * ```
+ *
+ * @property {Object} target - The target to install the chunks into.
+ * @property {string} [path] - A path to add before a chunk name as a prefix.
+ *
+ */
+declare class ShaderChunkManager {
+    /**
+     * Constructs a new instance ShaderChunkManager.
+     *
+     * @constructor
+     *
+     * @param {Object} target - The target to install the chunks into.
+     * @param {string} [path] - A path to add before a chunk name as a prefix.
+     *
+     */
+    constructor(target: Object, path?: string);
+    path: string | undefined;
+    target: Object;
+    /**
+     * Set the header ColorLayer shader.
+     *
+     * @param  {string}  header  The glsl header
+     */
+    customHeaderColorLayer(header: string): void;
+    /**
+     * Set the body ColorLayer shader.
+     * You could define you color terrain shader, with a header and a body.
+     * the header defines yours fonctions and the body defines the process on ColorLayer.
+     * @example <caption>Custom shader chunk</caption>
+     *  itowns.ShaderChunk.customHeaderColorLayer(`
+     *  // define yours methods
+     *  vec4 myColor(vec4 color, float a) {
+     *      return color * a;
+     *  }
+     * `);
+     * itowns.ShaderChunk.customBodyColorLayer(`
+     *  // the body set final color layer.
+     *  // layer.amount_effect is variable, it could be change in Layer instance.
+     *  color = myColor(color, layer.amount_effect)
+     * `);
+     *
+     *  var colorLayer = new itowns.ColorLayer('OPENSM', {
+     *    source,
+     *    type_effect: itowns.colorLayerEffects.customEffect,
+     *    amount_effect: 0.5,
+     *  });
+     *
+     * @param  {string}  body  The glsl body
+     */
+    customBodyColorLayer(body: string): void;
+    /**
+     * Install chunks in a target, for example THREE.ShaderChunk, with adding an
+     * optional path.
+     *
+     * @param {Object} target - The target to install the chunks into.
+     * @param {Object} chunks - The chunks to install. The key of each chunk will be
+     * the name of installation of the chunk in the target (plus an optional path).
+     * @param {string} [path] - A path to add before a chunk name as a prefix.
+     *
+     * @return {Object} The target with installed chunks.
+     */
+    install(target?: Object, chunks?: Object, path?: string): Object;
+}

package/lib/Renderer/Shader/ShaderUtils.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    function patchMaterialForLogDepthSupport(material: any): void;
+    function unrollLoops(string: any, defines: any): any;
+}
+export default _default;

package/lib/Renderer/WebXR.d.ts

@@ -0,0 +1,33 @@
+export namespace VR_EVENTS {
+    let CONTROLS_INITIALIZED: string;
+}
+export default WebXR;
+/**
+ * @property {VRControls} vrControls - WebXR controllers handler
+ * */
+declare class WebXR extends THREE.EventDispatcher<any> {
+    /**
+     * Handler of a webXR session
+     *
+     *
+     * @param {GlobeView} view - The view where the webXR session will be started
+     * @param {Object} [options] - WebXR configuration - its presence alone
+     * enable WebXR to switch on VR visualization.
+     * @param {function} [options.callback] - WebXR rendering callback (optional).
+     * @param {boolean} [options.controllers] - Enable the webXR controllers handling (optional).
+     */
+    constructor(view: GlobeView, options?: {
+        callback?: Function | undefined;
+        controllers?: boolean | undefined;
+    });
+    view: GlobeView;
+    options: {
+        callback?: Function | undefined;
+        controllers?: boolean | undefined;
+    } | undefined;
+    renderCb: Function | undefined;
+    vrControls: VRControls | null;
+    initializeWebXR: () => void;
+}
+import * as THREE from 'three';
+import VRControls from '../Controls/VRControls';