itowns 2.43.2-next.17 → 2.43.2-next.18

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 = {
@@ -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.18",
   "description": "A JS/WebGL framework for 3D geospatial data visualization",
   "type": "module",
   "main": "lib/Main.js",