itowns 2.43.2-next.9 → 2.44.1-next.0

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 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 = 1.0;\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            // 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        vColor.a *= opacity;\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)) {\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 = {
@@ -251,7 +250,7 @@ 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;
+    needTransparency = needTransparency || opacity < 1 || !visible;
   }
   texture.needsUpdate = true;
   return needTransparency;
@@ -262,12 +261,12 @@ class PointsMaterial extends THREE.ShaderMaterial {
    * @param      {object}  [options={}]  The options
    * @param      {number}  [options.size=0]  size point
    * @param      {number}  [options.mode=PNTS_MODE.COLOR]  display mode.
-   * @param      {number}  [options.mode=PNTS_SHAPE.CIRCLE]  rendered points shape.
+   * @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      {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      {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)
@@ -289,54 +288,49 @@ 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 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.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);
@@ -368,26 +362,99 @@ 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) {
+    // 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 {
-      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;
+    this.userData.needTransparency = needTransparency;
+    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() {
     const needTransparency = recomputeTexture(this.classificationScheme, this.classificationTexture, 256);
@@ -408,43 +475,10 @@ class PointsMaterial extends THREE.ShaderMaterial {
       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/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/OGC3DTilesGoogleSource.js

@@ -0,0 +1,32 @@
+import OGC3DTilesSource from "./OGC3DTilesSource.js";
+class OGC3DTilesGoogleSource extends OGC3DTilesSource {
+  /**
+   * @classdesc
+   * An object defining the source connection to a 3D Tiles asset from [Google Tiles API](https://tile.googleapis.com).
+   *
+   * @extends OGC3DTilesSource
+   *
+   * @property {boolean} isOGC3DTilesGoogleSource - Used to check if this source is an OGC3DTilesGoogleSource. Set to true.
+   * You should not change this, as it is used internally for optimisation.
+   * @property {string} url - The URL to the tileset json.
+   * @property {string} baseUrl - The base URL to access tiles.
+   *
+   * @constructor
+   *
+   * @property {boolean} isOGC3DTilesGoogleSource - Used to check if this source is an OGC3DTilesGoogleSource. Set to
+   * true. You should not change this, as it is used internally for optimisation.
+   * @param {Object} source An object that can contain all properties of an OGC3DTilesGoogleSource and {@link Source}.
+   * @param {String} source.key Your google tiles map API access key
+   */
+  constructor(source) {
+    if (!source.key) {
+      throw new Error('[OGC3DTilesGoogleSource]: A API key for the google map tiles API is required');
+    }
+    // URL to the root tileset
+    source.url = `https://tile.googleapis.com/v1/3dtiles/root.json?key=${source.key}`;
+    super(source);
+    this.isOGC3DTilesGoogleSource = true;
+    this.key = source.key;
+  }
+}
+export default OGC3DTilesGoogleSource;

package/lib/Source/OGC3DTilesIonSource.js

@@ -0,0 +1,37 @@
+import OGC3DTilesSource from "./OGC3DTilesSource.js";
+class OGC3DTilesIonSource extends OGC3DTilesSource {
+  /**
+   * @classdesc
+   * An object defining the source connection to a 3DTiles asset of a [Cesium ion server](https://cesium.com/learn/ion/).
+   *
+   * @extends Source
+   *
+   * @property {boolean} isOGC3DTilesIonSource - Used to check if this source is an OGC3DTilesIonSource. Set to true.
+   * You should not change this, as it is used internally for optimisation.
+   * @property {string} accessToken - The Cesium ion access token used to retrieve the resource.
+   * @property {string} assetId - The id of the asset on Cesium ion.
+   *
+   * @constructor
+   *
+   * @param {Object} source An object that can contain all properties of an OGC3DTilesIonSource and {@link Source}.
+   * Only `accessToken` and `assetId` are mandatory.
+   * @param {string} source.accessToken - The Cesium ion access token used to retrieve the resource.
+   * @param {string} source.assetId - The id of the asset on Cesium ion.
+   */
+  constructor(source) {
+    if (!source.accessToken) {
+      throw new Error('[OGC3DTilesIonSource]: accessToken is required');
+    }
+    if (!source.assetId) {
+      throw new Error('[OGC3DTilesIonSource]: assetId is required');
+    }
+
+    // Url to query cesium ion the first time to retrieve metadata of the asset with assetId
+    source.url = `https://api.cesium.com/v1/assets/${source.assetId}/endpoint?access_token=${source.accessToken}`;
+    super(source);
+    this.isOGC3DTilesIonSource = true;
+    this.accessToken = source.accessToken;
+    this.assetId = source.assetId;
+  }
+}
+export default OGC3DTilesIonSource;

package/lib/Source/OGC3DTilesSource.js

@@ -0,0 +1,24 @@
+import Source from "./Source.js";
+class OGC3DTilesSource extends Source {
+  /**
+   * @classdesc
+   * An object defining the source connection to a 3DTiles dataset from a web server.
+   *
+   * @extends Source
+   *
+   * @property {boolean} isOGC3DTilesSource - Used to check if this source is an isOGC3DTilesSource. Set to true.
+   * You should not change this, as it is used internally for optimisation.
+   * @property {string} url - The URL of the tileset json.
+   *
+   * @constructor
+   *
+   * @param {Object} source An object that can contain all properties of OGC3DTilesSource and of {@link Source}.
+   * Only `url` is mandatory.
+   * @param {string} source.url - The URL of the tileset json.
+   */
+  constructor(source) {
+    super(source);
+    this.isOGC3DTilesSource = true;
+  }
+}
+export default OGC3DTilesSource;

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/DRACOLoader.js

@@ -46,18 +46,20 @@ class DRACOLoader extends Loader {
       this.parse(buffer, onLoad, onError);
     }, onProgress, onError);
   }
-  parse(buffer, onLoad, onError) {
-    this.decodeDracoFile(buffer, onLoad, null, null, SRGBColorSpace).catch(onError);
+  parse(buffer, onLoad) {
+    let onError = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};
+    this.decodeDracoFile(buffer, onLoad, null, null, SRGBColorSpace, onError).catch(onError);
   }
   decodeDracoFile(buffer, callback, attributeIDs, attributeTypes) {
     let vertexColorSpace = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : LinearSRGBColorSpace;
+    let onError = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : () => {};
     const taskConfig = {
       attributeIDs: attributeIDs || this.defaultAttributeIDs,
       attributeTypes: attributeTypes || this.defaultAttributeTypes,
       useUniqueIDs: !!attributeIDs,
       vertexColorSpace: vertexColorSpace
     };
-    return this.decodeGeometry(buffer, taskConfig).then(callback);
+    return this.decodeGeometry(buffer, taskConfig).then(callback).catch(onError);
   }
   decodeGeometry(buffer, taskConfig) {
     const taskKey = JSON.stringify(taskConfig);