itowns 2.43.2-next.2 → 2.43.2-next.20

package/lib/Renderer/PointsMaterial.js

@@ -1,9 +1,8 @@
 import * as THREE from 'three';
 /* babel-plugin-inline-import './Shader/PointsVS.glsl' */
-const PointsVS = "#include <itowns/precision_qualifier>\n#if defined(USE_TEXTURES_PROJECTIVE)\n#include <itowns/projective_texturing_pars_vertex>\n#endif\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\n#define NB_CLASS 8.\n\nuniform float size;\nuniform float scale;\n\nuniform bool picking;\nuniform int mode;\nuniform float opacity;\nuniform vec4 overlayColor;\n\nuniform vec2 elevationRange;\nuniform vec2 intensityRange;\nuniform vec2 angleRange;\n\nuniform bool applyOpacityClassication;\n\nuniform sampler2D classificationTexture;\nuniform sampler2D discreteTexture;\nuniform sampler2D gradientTexture;\nuniform int sizeMode;\nuniform float minAttenuatedSize;\nuniform float maxAttenuatedSize;\n\nattribute vec3 color;\nattribute vec2 range;\nattribute vec4 unique_id;\nattribute float intensity;\nattribute float classification;\nattribute float pointSourceID;\n\nattribute float returnNumber;\nattribute float numberOfReturns;\nattribute float scanAngle;\n\n#if defined(NORMAL_OCT16)\nattribute vec2 oct16Normal;\n#elif defined(NORMAL_SPHEREMAPPED)\nattribute vec2 sphereMappedNormal;\n#endif\n\nvarying vec4 vColor;\n\n// see https://web.archive.org/web/20150303053317/http://lgdv.cs.fau.de/get/1602\n// and implementation in PotreeConverter (BINPointReader.cpp) and potree (BinaryDecoderWorker.js)\n#if defined(NORMAL_OCT16)\nvec3 decodeOct16Normal(vec2 encodedNormal) {\n    vec2 nNorm = 2. * (encodedNormal / 255.) - 1.;\n    vec3 n;\n    n.z = 1. - abs(nNorm.x) - abs(nNorm.y);\n    if (n.z >= 0.) {\n        n.x = nNorm.x;\n        n.y = nNorm.y;\n    } else {\n        n.x = sign(nNorm.x) - sign(nNorm.x) * sign(nNorm.y) * nNorm.y;\n        n.y = sign(nNorm.y) - sign(nNorm.y) * sign(nNorm.x) * nNorm.x;\n    }\n    return normalize(n);\n}\n#elif defined(NORMAL_SPHEREMAPPED)\n// see http://aras-p.info/texts/CompactNormalStorage.html method #4\n// or see potree's implementation in BINPointReader.cpp\nvec3 decodeSphereMappedNormal(vec2 encodedNormal) {\n    vec2 fenc = 2. * encodedNormal / 255. - 1.;\n    float f = dot(fenc,fenc);\n    float g = 2. * sqrt(1. - f);\n    vec3 n;\n    n.xy = fenc * g;\n    n.z = 1. - 2. * f;\n    return n;\n}\n#endif\n\nvoid main() {\n\n#if defined(NORMAL_OCT16)\n    vec3  normal = decodeOct16Normal(oct16Normal);\n#elif defined(NORMAL_SPHEREMAPPED)\n    vec3 normal = decodeSphereMappedNormal(sphereMappedNormal);\n#elif defined(NORMAL)\n    // nothing to do\n#else\n    // default to color\n    vec3 normal = color;\n#endif\n\n    if (picking) {\n        vColor = unique_id;\n    } else {\n        vColor.a = opacity;\n        if (applyOpacityClassication || mode == PNTS_MODE_CLASSIFICATION) {\n            vec2 uv = vec2(classification/255., 0.5);\n            vColor = texture2D(classificationTexture, uv);\n            vColor.a *= opacity;\n        }\n\n        if (mode == PNTS_MODE_NORMAL) {\n            vColor.rgb = abs(normal);\n        } else if (mode == PNTS_MODE_COLOR) {\n            // default to color mode\n            vColor.rgb = mix(color, overlayColor.rgb, overlayColor.a);\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 i = (position.z - elevationRange.x) / (elevationRange.y - elevationRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        }\n    }\n\n    #include <begin_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#if defined(USE_TEXTURES_PROJECTIVE)\n    #include <itowns/projective_texturing_vertex>\n#endif\n    #include <logdepthbuf_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 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";
 /* babel-plugin-inline-import './Shader/PointsFS.glsl' */
-const PointsFS = "#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#if defined(USE_TEXTURES_PROJECTIVE)\n#include <itowns/projective_texturing_pars_fragment>\n#endif\n\nvarying vec4 vColor;\nuniform bool picking;\nuniform int shape;\n\nvoid main() {\n    #include <logdepthbuf_fragment>\n    //square shape does not require any change.\n    if (shape == PNTS_SHAPE_CIRCLE) {\n        //circular rendering in glsl\n        if ((length(gl_PointCoord - 0.5) > 0.5) || (vColor.a == 0.0)) {\n            discard;\n        }\n    }\n\n#if defined(USE_TEXTURES_PROJECTIVE)\n    vec4 color = vColor;\n    if (!picking) {\n        #pragma unroll_loop\n        for (int i = 0; i < ORIENTED_IMAGES_COUNT; i++) {\n            color = projectiveTextureColor(projectiveTextureCoords[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTextureDistortion[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTexture[ ORIENTED_IMAGES_COUNT - 1 - i ], mask[ORIENTED_IMAGES_COUNT - 1 - i], color);\n        }\n        gl_FragColor = vec4(color.rgb, color.a * opacity);\n    } else {\n        gl_FragColor = color;\n    }\n#else\n    gl_FragColor = vColor;\n#endif\n}\n";
-import ShaderUtils from "./Shader/ShaderUtils.js";
+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_pars_fragment>\n    if (shape == PNTS_SHAPE_CIRCLE) {\n        //circular rendering in glsl\n        if ((length(gl_PointCoord - 0.5) > 0.5) || (vColor.a == 0.0)) {\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";
 import CommonMaterial from "./CommonMaterial.js";
 import Gradients from "../Utils/Gradients.js";
 export const PNTS_MODE = {
@@ -127,7 +126,7 @@ export const ClassificationScheme = {
       visible: true,
       name: 'default',
       color: new THREE.Color(0.3, 0.6, 0.6),
-      opacity: 0.5
+      opacity: 1.0
     }
   }
 };
@@ -185,7 +184,7 @@ const DiscreteScheme = {
       visible: true,
       name: 'default',
       color: white,
-      opacity: 0.5
+      opacity: 1.0
     }
   }
 };
@@ -220,6 +219,7 @@ function generateGradientTexture(gradient) {
   return texture;
 }
 function recomputeTexture(scheme, texture, nbClass) {
+  let needTransparency;
   const data = texture.image.data;
   const width = texture.image.width;
   if (!nbClass) {
@@ -250,8 +250,10 @@ function recomputeTexture(scheme, texture, nbClass) {
     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;
   }
   texture.needsUpdate = true;
+  return needTransparency;
 }
 class PointsMaterial extends THREE.ShaderMaterial {
   /**
@@ -264,8 +266,7 @@ class PointsMaterial extends THREE.ShaderMaterial {
    * @param      {THREE.Vector2}  [options.intensityRange=new THREE.Vector2(1, 65536)]  intensity range.
    * @param      {THREE.Vector2}  [options.elevationRange=new THREE.Vector2(0, 1000)]  elevation range.
    * @param      {THREE.Vector2}  [options.angleRange=new THREE.Vector2(-90, 90)]  scan angle range.
-   * @param      {boolean}  [options.applyOpacityClassication=false]  apply opacity classification on all display mode.
-   * @param      {Scheme}  [options.classification]  LUT for point classification colorization.
+   * @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)
@@ -287,59 +288,52 @@ class PointsMaterial extends THREE.ShaderMaterial {
    */
   constructor() {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const intensityRange = options.intensityRange || new THREE.Vector2(1, 65536);
-    const elevationRange = options.elevationRange || new THREE.Vector2(0, 1000);
-    const angleRange = options.angleRange || new THREE.Vector2(-90, 90);
-    const oiMaterial = options.orientedImageMaterial;
-    const classificationScheme = options.classification || ClassificationScheme.DEFAULT;
-    const discreteScheme = options.discreteScheme || DiscreteScheme.DEFAULT;
-    const applyOpacityClassication = options.applyOpacityClassication == undefined ? false : options.applyOpacityClassication;
-    const size = options.size || 0;
-    const mode = options.mode || PNTS_MODE.COLOR;
-    const shape = options.shape || PNTS_SHAPE.CIRCLE;
-    const sizeMode = size === 0 ? PNTS_SIZE_MODE.ATTENUATED : options.sizeMode || PNTS_SIZE_MODE.VALUE;
-    const minAttenuatedSize = options.minAttenuatedSize || 3;
-    const maxAttenuatedSize = options.maxAttenuatedSize || 10;
-    let gradients = Gradients;
-    if (options.gradient) {
-      gradients = {
-        ...options.gradient,
-        ...Gradients
-      };
-    }
-    delete options.intensityRange;
-    delete options.elevationRange;
-    delete options.angleRange;
-    delete options.orientedImageMaterial;
-    delete options.classification;
-    delete options.discreteScheme;
-    delete options.applyOpacityClassication;
-    delete options.size;
-    delete options.mode;
-    delete options.shape;
-    delete options.sizeMode;
-    delete options.minAttenuatedSize;
-    delete options.maxAttenuatedSize;
-    delete options.gradient;
-    super(options);
+    const gradients = {
+      ...options.gradient,
+      ...Gradients
+    };
+    options.gradient = Object.values(gradients)[0];
+    const {
+      intensityRange = new THREE.Vector2(1, 65536),
+      elevationRange = new THREE.Vector2(0, 1000),
+      angleRange = new THREE.Vector2(-90, 90),
+      classificationScheme = ClassificationScheme.DEFAULT,
+      discreteScheme = DiscreteScheme.DEFAULT,
+      size = 1,
+      mode = PNTS_MODE.COLOR,
+      shape = PNTS_SHAPE.CIRCLE,
+      sizeMode = PNTS_SIZE_MODE.ATTENUATED,
+      minAttenuatedSize = 3,
+      maxAttenuatedSize = 10,
+      gradient,
+      scale = 0.05 * 0.5 / Math.tan(1.0 / 2.0),
+      ...materialOptions
+    } = options;
+    super({
+      ...materialOptions,
+      fog: true,
+      precision: 'highp',
+      vertexColors: true
+    });
+    this.uniforms = THREE.UniformsUtils.merge([
+    // THREE.PointsMaterial uniforms
+    THREE.UniformsLib.points, THREE.UniformsLib.fog]);
+    this.vertexShader = PointsVS;
+    this.fragmentShader = PointsFS;
+    this.userData.needTransparency = {};
     this.gradients = gradients;
     this.gradientTexture = new THREE.CanvasTexture();
-    this.vertexShader = PointsVS;
-    const scale = options.scale || 0.05 * 0.5 / Math.tan(1.0 / 2.0); // autosizing scale
-
     CommonMaterial.setDefineMapping(this, 'PNTS_MODE', PNTS_MODE);
     CommonMaterial.setDefineMapping(this, 'PNTS_SHAPE', PNTS_SHAPE);
     CommonMaterial.setDefineMapping(this, 'PNTS_SIZE_MODE', PNTS_SIZE_MODE);
-    CommonMaterial.setUniformProperty(this, 'size', size);
+    this.size = size;
     CommonMaterial.setUniformProperty(this, 'mode', mode);
     CommonMaterial.setUniformProperty(this, 'shape', shape);
     CommonMaterial.setUniformProperty(this, 'picking', false);
     CommonMaterial.setUniformProperty(this, 'opacity', this.opacity);
-    CommonMaterial.setUniformProperty(this, 'overlayColor', options.overlayColor || new THREE.Vector4(0, 0, 0, 0));
     CommonMaterial.setUniformProperty(this, 'intensityRange', intensityRange);
     CommonMaterial.setUniformProperty(this, 'elevationRange', elevationRange);
     CommonMaterial.setUniformProperty(this, 'angleRange', angleRange);
-    CommonMaterial.setUniformProperty(this, 'applyOpacityClassication', applyOpacityClassication);
     CommonMaterial.setUniformProperty(this, 'sizeMode', sizeMode);
     CommonMaterial.setUniformProperty(this, 'scale', scale);
     CommonMaterial.setUniformProperty(this, 'minAttenuatedSize', minAttenuatedSize);
@@ -368,78 +362,119 @@ class PointsMaterial extends THREE.ShaderMaterial {
     this.recomputeDiscreteTexture();
 
     // Gradient texture for continuous values
-    this.gradient = Object.values(gradients)[0];
+    this.gradient = gradient;
     CommonMaterial.setUniformProperty(this, 'gradientTexture', this.gradientTexture);
-    if (oiMaterial) {
-      this.uniforms.projectiveTextureAlphaBorder = oiMaterial.uniforms.projectiveTextureAlphaBorder;
-      this.uniforms.projectiveTextureDistortion = oiMaterial.uniforms.projectiveTextureDistortion;
-      this.uniforms.projectiveTextureMatrix = oiMaterial.uniforms.projectiveTextureMatrix;
-      this.uniforms.projectiveTexture = oiMaterial.uniforms.projectiveTexture;
-      this.uniforms.mask = oiMaterial.uniforms.mask;
-      this.uniforms.boostLight = oiMaterial.uniforms.boostLight;
-      this.defines.ORIENTED_IMAGES_COUNT = oiMaterial.defines.ORIENTED_IMAGES_COUNT;
-      this.defines.USE_DISTORTION = oiMaterial.defines.USE_DISTORTION;
-      this.defines.DEBUG_ALPHA_BORDER = oiMaterial.defines.DEBUG_ALPHA_BORDER;
-      this.defines.USE_TEXTURES_PROJECTIVE = true;
-      this.defines.USE_BASE_MATERIAL = true;
-      // three loop unrolling of ShaderMaterial only supports integer
-      // bounds, see https://github.com/mrdoob/three.js/issues/28020
-      this.fragmentShader = ShaderUtils.unrollLoops(PointsFS, this.defines);
+  }
+
+  /**
+   * Copy the parameters from the passed material into this material.
+   * @override
+   * @param {THREE.PointsMaterial} source
+   * @returns {this}
+   */
+  copy(source) {
+    if (source.isShaderMaterial) {
+      super.copy(source);
     } else {
-      this.fragmentShader = PointsFS;
+      THREE.Material.prototype.copy.call(this, source);
+    }
+
+    // Parameters of THREE.PointsMaterial
+    this.color.copy(source.color);
+    this.map = source.map;
+    this.alphaMap = source.alphaMap;
+    this.size = source.size;
+    this.sizeAttenuation = source.sizeAttenuation;
+    this.fog = source.fog;
+    return this;
+  }
+
+  /** @returns {THREE.Color} */
+  get color() {
+    return this.uniforms.diffuse.value;
+  }
+
+  /** @param {THREE.Color} color */
+  set color(color) {
+    this.uniforms.diffuse.value.copy(color);
+  }
+
+  /** @returns {THREE.Texture | null} */
+  get map() {
+    return this.uniforms.map.value;
+  }
+
+  /** @param {THREE.Texture | null} map */
+  set map(map) {
+    this.uniforms.map.value = map;
+    if (!map) {
+      return;
+    }
+    if (map.matrixAutoUpdate) {
+      map.updateMatrix();
+    }
+    this.uniforms.uvTransform.value.copy(map.matrix);
+  }
+
+  /** @returns {THREE.Texture | null} */
+  get alphaMap() {
+    return this.uniforms.alphaMap.value;
+  }
+
+  /** @param {THREE.Texture | null} map */
+  set alphaMap(map) {
+    this.uniforms.alphaMap.value = map;
+    if (!map) {
+      return;
+    }
+    if (map.matrixAutoUpdate) {
+      map.updateMatrix();
     }
+    this.uniforms.alphaMapTransform.value.copy(map.matrix);
+  }
+
+  /** @returns {number} */
+  get size() {
+    return this.uniforms.size.value;
+  }
+
+  /** @param {number} size */
+  set size(size) {
+    this.uniforms.size.value = size;
+  }
+
+  /** @returns {boolean} */
+  get sizeAttenuation() {
+    return this.sizeMode !== PNTS_SIZE_MODE.VALUE;
+  }
+
+  /** @param {boolean} value */
+  set sizeAttenuation(value) {
+    this.sizeMode = value ? PNTS_SIZE_MODE.ATTENUATED : PNTS_SIZE_MODE.VALUE;
   }
   recomputeClassification() {
-    recomputeTexture(this.classificationScheme, this.classificationTexture, 32);
+    const needTransparency = recomputeTexture(this.classificationScheme, this.classificationTexture, 256);
+    this.userData.needTransparency[PNTS_MODE.CLASSIFICATION] = needTransparency;
     this.dispatchEvent({
       type: 'material_property_changed',
       target: this.uniforms
     });
   }
   recomputeDiscreteTexture() {
-    recomputeTexture(this.discreteScheme, this.discreteTexture);
+    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;
     this.dispatchEvent({
       type: 'material_property_changed',
       target: this.uniforms
     });
   }
-  copy(source) {
-    super.copy(source);
-    if (source.uniforms.projectiveTextureAlphaBorder) {
-      // Don't copy oriented image because, it's a link to oriented image material.
-      // It needs a reference to oriented image material.
-      this.uniforms.projectiveTextureAlphaBorder = source.uniforms.projectiveTextureAlphaBorder;
-      this.uniforms.projectiveTextureDistortion = source.uniforms.projectiveTextureDistortion;
-      this.uniforms.projectiveTextureMatrix = source.uniforms.projectiveTextureMatrix;
-      this.uniforms.projectiveTexture = source.uniforms.projectiveTexture;
-      this.uniforms.mask = source.uniforms.mask;
-      this.uniforms.boostLight = source.uniforms.boostLight;
-    }
-    return this;
-  }
   enablePicking(picking) {
     this.picking = picking;
     this.blending = picking ? THREE.NoBlending : THREE.NormalBlending;
   }
-  update(source) {
-    this.visible = source.visible;
-    this.opacity = source.opacity;
-    this.transparent = source.transparent;
-    this.size = source.size;
-    this.mode = source.mode;
-    this.shape = source.shape;
-    this.sizeMode = source.sizeMode;
-    this.minAttenuatedSize = source.minAttenuatedSize;
-    this.maxAttenuatedSize = source.maxAttenuatedSize;
-    this.picking = source.picking;
-    this.scale = source.scale;
-    this.overlayColor.copy(source.overlayColor);
-    this.intensityRange.copy(source.intensityRange);
-    this.elevationRange.copy(source.elevationRange);
-    this.angleRange.copy(source.angleRange);
-    Object.assign(this.defines, source.defines);
-    return this;
-  }
   set gradient(value) {
     this.gradientTexture = generateGradientTexture(value);
   }

package/lib/Renderer/RenderMode.js

@@ -5,7 +5,6 @@ const MODES = {
   // depth buffer
   ID: 2 // id object
 };
-
 function push(object3d, mode) {
   const _mode = object3d.mode ?? MODES.FINAL;
   if (_mode == mode) {

package/lib/Source/FileSource.js

@@ -130,7 +130,7 @@ class FileSource extends Source {
     }
 
     // the fake url is for when we use the fetchedData or features mode
-    source.url = source.url || 'fake-file-url';
+    source.url = source.url || 'none';
     super(source);
     this.isFileSource = true;
     this.fetchedData = source.fetchedData;

package/lib/Source/Potree2Source.js

@@ -0,0 +1,172 @@
+import Source from "./Source.js";
+import Fetcher from "../Provider/Fetcher.js";
+import Potree2BinParser from "../Parser/Potree2BinParser.js";
+
+/**
+ * @classdesc
+ * Potree2Source are object containing informations on how to fetch potree 2.0 points cloud resources.
+ *
+ *
+ */
+
+class Potree2Source extends Source {
+  /**
+   * @param {Object} source - An object that can contain all properties of a
+   * Potree2Source
+   * @param {string} source.url - folder url.
+   * @param {string} source.file - metadata file name.
+   *
+   * This `metadata` file stores information about the potree cloud 2.0 in JSON format. the structure is :
+   *
+   * * __`version`__ - The metadata.json format may change over time. The version number is
+   * necessary so that parsers know how to interpret the data.
+   * * __`name`__ - Point cloud name.
+   * * __`description`__ - Point cloud description.
+   * * __`points`__ - Total number of points.
+   * * __`projection`__ - Point cloud geographic projection system.
+   * * __`hierarchy`__ - Information about point cloud hierarchy (first chunk size, step size, octree depth).
+   * * __`offset`__ - Position offset used to determine the global point position.
+   * * __`scale`__ - Point cloud scale.
+   * * __`spacing`__ - The minimum distance between points at root level.
+   * * __`boundingBox`__ - Contains the minimum and maximum of the axis aligned bounding box. This bounding box is cubic and aligned to fit to the octree root.
+   * * __`encoding`__ - Encoding type: BROTLI or DEFAULT (uncompressed).
+   * * __`attributes`__ - Array of attributes (position,  intensity, return number, number of returns, classification, scan angle rank, user data, point source id, gps-time, rgb).
+   * ```
+   * {
+   *     version: '2.0',
+   *     name: "sample",
+   *     description: "",
+   *     points: 534909153,
+   *     projection: "",
+   *     hierarchy: {
+   *         firstChunkSize: 1276,
+   *         stepSize: 4,
+   *         depth: 16
+   *     },
+   *     offset: [1339072.07, 7238866.339, 85.281],
+   *     scale: [0.001, 0.001, 0.002],
+   *     spacing: 24.476062500005355,
+   *     boundingBox: {
+   *         min: [1339072.07, 7238866.339, 85.281],
+   *         max: [1342205.0060000008, 7241999.275, 3218.2170000006854]
+   *     },
+   *     encoding: "BROTLI",
+   *     attributes: [
+   *          {
+   *              name: "position",
+   *              description: "",
+   *              size: 12,
+   *              numElements: 3,
+   *              elementSize: 4,
+   *              type: "int32",
+   *              min: [-0.74821299314498901, -2.7804059982299805, 2.5478212833404541],
+   *              max: [2.4514148223438199, 1.4893437627414672, 7.1957106576508663]
+   *          },
+   *          {
+   *              name: "intensity",
+   *              description: "",
+   *              size: 2,
+   *              numElements: 1,
+   *              elementSize: 2,
+   *              type: "uint16",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "return number",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "number of returns",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "classification",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "scan angle rank",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "user data",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "point source id",
+   *              description: "",
+   *              size: 2,
+   *              numElements: 1,
+   *              elementSize: 2,
+   *              type: "uint16",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "gps-time",
+   *              description: "",
+   *              size: 8,
+   *              numElements: 1,
+   *              elementSize: 8,
+   *              type: "double",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "rgb",
+   *              description: "",
+   *              size: 6,
+   *              numElements: 3,
+   *              elementSize: 2,
+   *              type: "uint16",
+   *              min: [5632, 5376, 4864],
+   *              max: [65280, 65280, 65280]
+   *          }
+   *     ]
+   * }
+   * ```
+   *
+   * @extends Source
+   *
+   * @constructor
+   */
+  constructor(source) {
+    if (!source.file) {
+      throw new Error('New Potree2Source: file is required');
+    }
+    super(source);
+    this.file = source.file;
+    this.fetcher = Fetcher.arrayBuffer;
+    this.whenReady = (source.metadata ? Promise.resolve(source.metadata) : Fetcher.json(`${this.url}/${this.file}`, this.networkOptions)).then(metadata => {
+      this.metadata = metadata;
+      this.pointAttributes = metadata.attributes;
+      this.baseurl = `${this.url}`;
+      this.extension = 'bin';
+      this.parser = Potree2BinParser.parse;
+      return metadata;
+    });
+  }
+}
+export default Potree2Source;

package/lib/ThreeExtended/loaders/DDSLoader.js

@@ -17,23 +17,29 @@ class DDSLoader extends CompressedTextureLoader {
 
     // All values and structures referenced from:
     // http://msdn.microsoft.com/en-us/library/bb943991.aspx/
+
     // const DDSD_CAPS = 0x1;
     // const DDSD_HEIGHT = 0x2;
     // const DDSD_WIDTH = 0x4;
     // const DDSD_PITCH = 0x8;
     // const DDSD_PIXELFORMAT = 0x1000;
+
     // const DDSD_LINEARSIZE = 0x80000;
     // const DDSD_DEPTH = 0x800000;
+
     // const DDSCAPS_COMPLEX = 0x8;
     // const DDSCAPS_MIPMAP = 0x400000;
     // const DDSCAPS_TEXTURE = 0x1000;
+
     // const DDSCAPS2_VOLUME = 0x200000;
+
     // const DDPF_ALPHAPIXELS = 0x1;
     // const DDPF_ALPHA = 0x2;
     // const DDPF_FOURCC = 0x4;
     // const DDPF_RGB = 0x40;
     // const DDPF_YUV = 0x200;
     // const DDPF_LUMINANCE = 0x20000;
+
     function fourCCToInt32(value) {
       return value.charCodeAt(0) + (value.charCodeAt(1) << 8) + (value.charCodeAt(2) << 16) + (value.charCodeAt(3) << 24);
     }
@@ -66,7 +72,6 @@ class DDSLoader extends CompressedTextureLoader {
           dst++; //a
         }
       }
-
       return byteArray;
     }
     const FOURCC_DXT1 = fourCCToInt32('DXT1');
@@ -78,11 +83,16 @@ class DDSLoader extends CompressedTextureLoader {
     const extendedHeaderLengthInt = 5; // The extended header length in 32 bit ints
 
     // Offsets into the header array
+
     // const off_pfFlags = 20;
+
     // const off_caps = 27;
+
     // const off_caps3 = 29;
     // const off_caps4 = 30;
+
     // If fourCC = DX10, the extended header starts after 32
+
     // Parse header
 
     const header = new Int32Array(buffer, 0, headerLengthInt);

package/lib/ThreeExtended/loaders/DRACOLoader.js

@@ -261,7 +261,6 @@ function DRACOWorker() {
           };
           DracoDecoderModule(decoderConfig); // eslint-disable-line no-undef
         });
-
         break;
       case 'decode':
         const buffer = message.buffer;

package/lib/ThreeExtended/loaders/GLTFLoader.js

@@ -2627,6 +2627,7 @@ class GLTFParser {
 
       // Removes dangling associations, associations that reference a node that
       // didn't make it into the scene.
+
       parser.associations = (node => {
         const reducedAssociations = new Map();
         for (const [key, value] of parser.associations) {

package/lib/Utils/DEMUtils.js

@@ -255,6 +255,7 @@ function _readZCorrect(layer, texture, uv, tileDimensions, tileOwnerDimensions)
 
   // Determine if we're going to read the vertices from the top-left or lower-right triangle
   // (low-right = on the line 21-22 or under the diagonal lu = 1 - lv)
+
   const tri = new THREE.Triangle(new THREE.Vector3(u1, v2), new THREE.Vector3(u2, v1), lv == 1 || lu / (1 - lv) >= 1 ? new THREE.Vector3(u2, v2) : new THREE.Vector3(u1, v1));
 
   // bary holds the respective weight of each vertices of the triangles
@@ -287,11 +288,10 @@ function offsetInExtent(point, extent) {
   return target.set(originX, originY);
 }
 function _readZ(layer, method, coord, nodes, cache) {
-  var _cache$tile;
   const pt = coord.as(layer.extent.crs, temp.coord1);
   let tileWithValidElevationTexture = null;
   // first check in cache
-  if (cache !== null && cache !== void 0 && (_cache$tile = cache.tile) !== null && _cache$tile !== void 0 && _cache$tile.material) {
+  if (cache?.tile?.material) {
     tileWithValidElevationTexture = tileAt(pt, cache.tile);
   }
   for (let i = 0; !tileWithValidElevationTexture && i < nodes.length; i++) {

package/lib/Utils/OrientationUtils.js

@@ -71,7 +71,6 @@ export default {
     // return this.setFromEuler(euler.set(pitch, roll, heading , 'ZXY')).conjugate();
     return target.setFromEuler(euler.set(-pitch, -roll, -heading, 'YXZ')); // optimized version of above
   },
-
   /**
    * From
    * [DocMicMac](https://github.com/micmacIGN/Documentation/raw/master/DocMicMac.pdf),

package/lib/Utils/gui/Searchbar.js

@@ -9,7 +9,6 @@ const DEFAULT_OPTIONS = {
   placeholder: 'Search location'
 };
 function addActive(htmlElements, index) {
-  var _htmlElements$index;
   if (!htmlElements) {
     return index;
   }
@@ -19,7 +18,7 @@ function addActive(htmlElements, index) {
   } else if (index < 0) {
     index = htmlElements.length - 1;
   }
-  (_htmlElements$index = htmlElements[index]) === null || _htmlElements$index === void 0 ? void 0 : _htmlElements$index.classList.add('active');
+  htmlElements[index]?.classList.add('active');
   return index;
 }
 function removeAllActives(htmlElements) {