itowns 2.43.2-next.17 → 2.43.2-next.19

package/lib/Core/Style.js

@@ -15,29 +15,30 @@ function baseAltitudeDefault(properties, ctx) {
   return ctx?.coordinates?.z || 0;
 }
 export function readExpression(property, ctx) {
-  if (property != undefined) {
-    if (property.expression) {
-      return property.expression.evaluate(ctx);
-    } else if (property.stops) {
-      for (let i = property.stops.length - 1; i >= 0; i--) {
-        const stop = property.stops[i];
-        if (ctx.zoom >= stop[0]) {
-          return stop[1];
-        }
+  if (property.expression) {
+    return property.expression.evaluate(ctx);
+  }
+  if (property.stops) {
+    const stops = property.stops;
+    property = property.stops[0][1];
+    for (let i = stops.length - 1; i >= 0; i--) {
+      const stop = stops[i];
+      if (ctx.zoom >= stop[0]) {
+        property = stop[1];
+        break;
       }
-      return property.stops[0][1];
-    }
-    if (typeof property === 'string' || property instanceof String) {
-      property = property.replace(/\{(.+?)\}/g, (a, b) => ctx.properties[b] || '').trim();
     }
-    if (property instanceof Function) {
-      // TOBREAK: Pass the current `context` as a unique parameter.
-      // In this proposal, metadata will be accessed in the callee by the
-      // `context.properties` property.
-      return property(ctx.properties, ctx);
-    }
-    return property;
   }
+  if (typeof property === 'string' || property instanceof String) {
+    return property.replace(/\{(.+?)\}/g, (a, b) => ctx.properties[b] || '').trim();
+  }
+  if (property instanceof Function) {
+    // TOBREAK: Pass the current `context` as a unique parameter.
+    // In this proposal, metadata will be accessed in the callee by the
+    // `context.properties` property.
+    return property(ctx.properties, ctx);
+  }
+  return property;
 }
 function rgba2rgb(orig) {
   if (!orig) {
@@ -48,7 +49,7 @@ function rgba2rgb(orig) {
     };
   } else if (typeof orig == 'string') {
     const result = orig.match(/(?:((hsl|rgb)a? *\(([\d.%]+(?:deg|g?rad|turn)?)[ ,]*([\d.%]+)[ ,]*([\d.%]+)[ ,/]*([\d.%]*)\))|(#((?:[\d\w]{3}){1,2})([\d\w]{1,2})?))/i);
-    if (!result) {
+    if (result === null) {
       return {
         color: orig,
         opacity: 1.0
@@ -62,10 +63,10 @@ function rgba2rgb(orig) {
         color: `#${result[8]}`,
         opacity
       };
-    } else if (result[0]) {
+    } else if (result[1]) {
       return {
         color: `${result[2]}(${result[3]},${result[4]},${result[5]})`,
-        opacity: Number(result[6]) || 1.0
+        opacity: result[6] ? Number(result[6]) : 1.0
       };
     }
   }
@@ -692,31 +693,6 @@ class Style {
     defineStyleProperty(this, 'icon', 'color', params.icon.color);
     defineStyleProperty(this, 'icon', 'opacity', params.icon.opacity, 1.0);
   }
-
-  /**
-   * Copies the content of the target style into this style.
-   * @param {Style} style - The style to copy.
-   *
-   * @return {Style} This style.
-   */
-  copy(style) {
-    Object.assign(this.fill, style.fill);
-    Object.assign(this.stroke, style.stroke);
-    Object.assign(this.point, style.point);
-    Object.assign(this.text, style.text);
-    Object.assign(this.icon, style.icon);
-    return this;
-  }
-
-  /**
-       * Clones this style.
-       *
-       * @return {Style} The new style, cloned from this one.
-       */
-  clone() {
-    const clone = new Style();
-    return clone.copy(this);
-  }
   setContext(ctx) {
     this.context = ctx;
   }
@@ -940,8 +916,35 @@ class Style {
       if (iconImg) {
         try {
           style.icon.id = iconImg;
+          if (iconImg.stops) {
+            const iconCropValue = {
+              ...(iconImg.base !== undefined && {
+                base: iconImg.base
+              }),
+              stops: iconImg.stops.map(stop => {
+                let cropValues = sprites[stop[1]];
+                if (stop[1].includes('{')) {
+                  cropValues = function (p) {
+                    const id = stop[1].replace(/\{(.+?)\}/g, (a, b) => p[b] || '').trim();
+                    cropValues = sprites[id];
+                    return sprites[id];
+                  };
+                }
+                return [stop[0], cropValues];
+              })
+            };
+            style.icon.cropValues = iconCropValue;
+          } else {
+            style.icon.cropValues = sprites[iconImg];
+            if (iconImg[0].includes('{')) {
+              style.icon.cropValues = function (p) {
+                const id = iconImg.replace(/\{(.+?)\}/g, (a, b) => p[b] || '').trim();
+                style.icon.cropValues = sprites[id];
+                return sprites[id];
+              };
+            }
+          }
           style.icon.source = sprites.source;
-          style.icon.cropValues = sprites[iconImg];
           style.icon.size = readVectorProperty(layer.layout['icon-size']) || 1;
           const {
             color,

package/lib/Provider/3dTilesProvider.js

@@ -38,7 +38,7 @@ function pntsParse(data, layer) {
       size: 1,
       mode: layer.pntsMode,
       shape: layer.pntsShape,
-      classification: layer.classification,
+      classificationScheme: layer.classification,
       sizeMode: layer.pntsSizeMode,
       minAttenuatedSize: layer.pntsMinAttenuatedSize,
       maxAttenuatedSize: layer.pntsMaxAttenuatedSize

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 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        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) || (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 = {
@@ -267,7 +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      {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,95 @@ 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() {
     const needTransparency = recomputeTexture(this.classificationScheme, this.classificationTexture, 256);
@@ -408,43 +471,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itowns",
-  "version": "2.43.2-next.17",
+  "version": "2.43.2-next.19",
   "description": "A JS/WebGL framework for 3D geospatial data visualization",
   "type": "module",
   "main": "lib/Main.js",