itowns 2.42.1-next.20 → 2.42.1-next.21

package/lib/Core/Deprecated/Undeprecator.js

@@ -69,7 +69,7 @@ export const deprecatedFeature2MeshOptions = options => {
 };
 export const deprecatedC3DEngineWebGLOptions = options => {
   if (options.isWebGL2 === false) {
-    console.warn('WebGL1 support (isWebGL2=false) is deprecated and will be removed in iTowns 2.43. This follows its deprecation by three.js. If you are impacted by this change, please discuss in the following issue: https://github.com/iTowns/itowns/issues/2152.');
+    console.error('WebGL1 support ended in 2.43.0. Falling-back to the WebGL2 renderer.');
   }
 };
 export default {};

package/lib/Core/Prefab/GlobeView.js

@@ -74,14 +74,6 @@ class GlobeView extends View {
    * }
    * var view = new itowns.GlobeView(viewerDiv, placement);
    *
-   * @example <caption><b>Enable WebGl 1.0 instead of WebGl 2.0.</b></caption>
-   * var viewerDiv = document.getElementById('viewerDiv');
-   * const placement = {
-   *     coord: new itowns.Coordinates('EPSG:4326', 2.351323, 48.856712),
-   *     range: 25000000,
-   * }
-   * var view = new itowns.GlobeView(viewerDiv, placement, {  renderer: { isWebGL2: false } });
-   *
    * @param {HTMLDivElement} viewerDiv - Where to attach the view and display it
    * in the DOM.
    * @param {CameraTransformOptions|Extent} placement - An object to place view

package/lib/Core/Prefab/PlanarView.js

@@ -8,11 +8,6 @@ class PlanarView extends View {
    * @constructor
    * @extends View
    *
-   * @example <caption><b>Enable WebGl 1.0 instead of WebGl 2.0.</b></caption>
-   * var viewerDiv = document.getElementById('viewerDiv');
-   * const extent = new Extent('EPSG:3946', 1837816.94334, 1847692.32501, 5170036.4587, 5178412.82698);
-   * var view = new itowns.PlanarView(viewerDiv, extent, {  renderer: { isWebGL2: false } });
-   *
    * @example <caption><b>Instance with placement on the ground.</b></caption>
    * var viewerDiv = document.getElementById('viewerDiv');
    * const extent = new Extent('EPSG:3946', 1837816.94334, 1847692.32501, 5170036.4587, 5178412.82698);

package/lib/Core/Prefab/TileBuilder.js

@@ -55,12 +55,12 @@ export default function newTileGeometry(builder, params) {
     geometry.dispose = () => {
       geometry._count--;
       if (geometry._count <= 0) {
-        // To avoid remove index buffer and attribute buffer uv_0
+        // To avoid remove index buffer and attribute buffer uv
         //  error un-bound buffer in webgl with VAO rendering.
         // Could be removed if the attribute buffer deleting is
         //  taken into account in the buffer binding state (in THREE.WebGLBindingStates code).
         geometry.index = null;
-        delete geometry.attributes.uv_0;
+        delete geometry.attributes.uv;
         THREE.BufferGeometry.prototype.dispose.call(geometry);
         cacheTile.delete(south, params.level, bufferKey);
       }

package/lib/Core/Prefab/computeBufferTileGeometry.js

@@ -9,7 +9,7 @@ export default function computeBuffers(params) {
     index: null,
     position: null,
     normal: null,
-    // 2 UV set per tile: wgs84 (uv_0) and pm (uv_1)
+    // 2 UV set per tile: wgs84 (uv[0]) and pm (uv[1])
     //    - wgs84: 1 texture per tile because tiles are using wgs84 projection
     //    - pm: use multiple textures per tile.
     //      +-------------------------+

package/lib/Core/System/Capabilities.js

@@ -20,10 +20,6 @@ export default {
     return logDepthBufferSupported;
   },
   isFirefox,
-  isInternetExplorer() {
-    const internetExplorer = false || !!document.documentMode;
-    return internetExplorer;
-  },
   getMaxTextureUnitsCount() {
     return maxTexturesUnits;
   },

package/lib/Core/TileGeometry.js

@@ -23,7 +23,8 @@ class TileGeometry extends THREE.BufferGeometry {
     this.setIndex(buffers.index);
     this.setAttribute('position', buffers.position);
     this.setAttribute('normal', buffers.normal);
-    for (let i = 0; i < buffers.uvs.length; i++) {
+    this.setAttribute('uv', buffers.uvs[0]);
+    for (let i = 1; i < buffers.uvs.length; i++) {
       this.setAttribute(`uv_${i}`, buffers.uvs[i]);
     }
     this.computeBoundingBox();

package/lib/Core/View.js

@@ -142,7 +142,6 @@ class View extends THREE.EventDispatcher {
    * a default one will be constructed. In this case, if options.renderer is an object, it will be used to
    * configure the renderer (see {@link c3DEngine}.  If not present, a new <canvas> will be created and
    * added to viewerDiv (mutually exclusive with mainLoop)
-   * @param {boolean} [options.renderer.isWebGL2=true] - enable webgl 2.0 for THREE.js.
    * @param {boolean|Object} [options.webXR=false] - enable webxr button to switch on VR visualization.
    * @param {number} [options.webXR.scale=1.0] - apply webxr scale tranformation.
    * @param {?Scene} [options.scene3D] - [THREE.Scene](https://threejs.org/docs/#api/en/scenes/Scene) instance to use, otherwise a default one will be constructed
@@ -325,10 +324,6 @@ class View extends THREE.EventDispatcher {
         } else {
           return layer._reject(new Error(`Cant add color layer ${layer.id}: the maximum layer is reached`));
         }
-      } else if (layer.isElevationLayer && layer.source.format == 'image/x-bil;bits=32') {
-        var _this$renderer, _this$renderer$capabi;
-        layer.source.networkOptions.isWebGL2 = (_this$renderer = this.renderer) === null || _this$renderer === void 0 ? void 0 : (_this$renderer$capabi = _this$renderer.capabilities) === null || _this$renderer$capabi === void 0 ? void 0 : _this$renderer$capabi.isWebGL2;
-        parentLayer.attach(layer);
       } else {
         parentLayer.attach(layer);
       }

package/lib/Provider/Fetcher.js

@@ -1,4 +1,4 @@
-import { TextureLoader, DataTexture, RedFormat, FloatType, AlphaFormat } from 'three';
+import { TextureLoader, DataTexture, RedFormat, FloatType } from 'three';
 const textureLoader = new TextureLoader();
 const SIZE_TEXTURE_TILE = 256;
 function checkResponse(response) {
@@ -16,16 +16,10 @@ const arrayBuffer = function (url) {
   });
 };
 function getTextureFloat(buffer) {
-  let isWebGL2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  if (isWebGL2) {
-    const texture = new DataTexture(buffer, SIZE_TEXTURE_TILE, SIZE_TEXTURE_TILE, RedFormat, FloatType);
-    texture.internalFormat = 'R32F';
-    texture.needsUpdate = true;
-    return texture;
-  } else {
-    const texture = new DataTexture(buffer, SIZE_TEXTURE_TILE, SIZE_TEXTURE_TILE, AlphaFormat, FloatType);
-    return texture;
-  }
+  const texture = new DataTexture(buffer, SIZE_TEXTURE_TILE, SIZE_TEXTURE_TILE, RedFormat, FloatType);
+  texture.internalFormat = 'R32F';
+  texture.needsUpdate = true;
+  return texture;
 }
 
 /**
@@ -136,7 +130,7 @@ export default {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return arrayBuffer(url, options).then(buffer => {
       const floatArray = new Float32Array(buffer);
-      const texture = getTextureFloat(floatArray, options.isWebGL2);
+      const texture = getTextureFloat(floatArray);
       return texture;
     });
   },

package/lib/Renderer/LayeredMaterial.js

@@ -1,8 +1,8 @@
 import * as THREE from 'three';
 /* babel-plugin-inline-import './Shader/TileVS.glsl' */
-const TileVS = "#include <itowns/WebGL2_pars_vertex>\n#include <itowns/precision_qualifier>\n#include <common>\n#include <itowns/project_pars_vertex>\n#include <itowns/elevation_pars_vertex>\n#include <logdepthbuf_pars_vertex>\nattribute vec2      uv_0;\n#if NUM_CRS > 1\nattribute float     uv_1;\n#endif\nattribute vec3      normal;\n\nuniform mat4 modelMatrix;\nuniform bool lightingEnabled;\nvarying vec2 vHighPrecisionZW;\n\n#if MODE == MODE_FINAL\n#include <fog_pars_vertex>\nvarying vec3        vUv;\nvarying vec3        vNormal;\n#endif\nvoid main() {\n        vec2 uv = vec2(uv_0.x, 1.0 - uv_0.y);\n\n        #include <begin_vertex>\n        #include <itowns/elevation_vertex>\n        #include <itowns/geoid_vertex>\n        #include <project_vertex>\n        #include <logdepthbuf_vertex>\n        vHighPrecisionZW = gl_Position.zw;\n#if MODE == MODE_FINAL\n        #include <fog_vertex>\n        #if NUM_CRS > 1\n        vUv = vec3(uv_0, (uv_1 > 0.) ? uv_1 : uv_0.y); // set uv_1 = uv_0 if uv_1 is undefined\n        #else\n        vUv = vec3(uv_0, 0.0);\n        #endif\n        vNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );\n#endif\n}\n";
+const TileVS = "#include <itowns/precision_qualifier>\n#include <common>\n#include <itowns/elevation_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#if NUM_CRS > 1\nattribute float     uv_1;\n#endif\n\nuniform bool lightingEnabled;\nvarying vec2 vHighPrecisionZW;\n\n#if MODE == MODE_FINAL\n#include <fog_pars_vertex>\nvarying vec3        vUv;\nvarying vec3        vNormal;\n#endif\nvoid main() {\n        #include <begin_vertex>\n        #include <itowns/elevation_vertex>\n        #include <itowns/geoid_vertex>\n        #include <project_vertex>\n        #include <logdepthbuf_vertex>\n        vHighPrecisionZW = gl_Position.zw;\n#if MODE == MODE_FINAL\n        #include <fog_vertex>\n        #if NUM_CRS > 1\n        vUv = vec3(uv, (uv_1 > 0.) ? uv_1 : uv.y); // set uv_1 = uv if uv_1 is undefined\n        #else\n        vUv = vec3(uv, 0.0);\n        #endif\n        vNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );\n#endif\n}\n";
 /* babel-plugin-inline-import './Shader/TileFS.glsl' */
-const TileFS = "#include <itowns/WebGL2_pars_fragment>\n#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/pitUV>\n#include <itowns/color_layers_pars_fragment>\n#if MODE == MODE_FINAL\n#include <itowns/fog_pars_fragment>\n#include <itowns/overlay_pars_fragment>\n#include <itowns/lighting_pars_fragment>\n#endif\n#include <itowns/mode_pars_fragment>\n\nuniform vec3        diffuse;\nuniform float       opacity;\nvarying vec3        vUv; // uv_0.x/uv_1.x, uv_0.y, uv_1.y\nvarying vec2        vHighPrecisionZW;\n\nvoid main() {\n    #include <logdepthbuf_fragment>\n\n#if MODE == MODE_ID\n\n    #include <itowns/mode_id_fragment>\n\n#elif MODE == MODE_DEPTH\n\n    #include <itowns/mode_depth_fragment>\n\n#else\n\n    gl_FragColor = vec4(diffuse, opacity);\n\n    uvs[0] = vec3(vUv.xy, 0.);\n\n#if NUM_CRS > 1\n    uvs[1] = vec3(vUv.x, fract(vUv.z), floor(vUv.z));\n#endif\n\n    vec4 color;\n    #pragma unroll_loop\n    for ( int i = 0; i < NUM_FS_TEXTURES; i ++ ) {\n        color = getLayerColor( i , colorTextures[ i ], colorOffsetScales[ i ], colorLayers[ i ]);\n        gl_FragColor.rgb = mix(gl_FragColor.rgb, color.rgb, color.a);\n    }\n\n  #if defined(DEBUG)\n    if (showOutline) {\n        #pragma unroll_loop\n        for ( int i = 0; i < NUM_CRS; i ++) {\n            color = getOutlineColor( outlineColors[ i ], uvs[ i ].xy);\n            gl_FragColor.rgb = mix(gl_FragColor.rgb, color.rgb, color.a);\n        }\n    }\n  #endif\n\n    #include <itowns/fog_fragment>\n    #include <itowns/lighting_fragment>\n    #include <itowns/overlay_fragment>\n\n#endif\n}\n";
+const TileFS = "#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/pitUV>\n#include <itowns/color_layers_pars_fragment>\n#if MODE == MODE_FINAL\n#include <itowns/fog_pars_fragment>\n#include <itowns/overlay_pars_fragment>\n#include <itowns/lighting_pars_fragment>\n#endif\n#include <itowns/mode_pars_fragment>\n\nuniform vec3        diffuse;\nuniform float       opacity;\nvarying vec3        vUv; // uv.x/uv_1.x, uv.y, uv_1.y\nvarying vec2        vHighPrecisionZW;\n\nvoid main() {\n    #include <logdepthbuf_fragment>\n\n#if MODE == MODE_ID\n\n    #include <itowns/mode_id_fragment>\n\n#elif MODE == MODE_DEPTH\n\n    #include <itowns/mode_depth_fragment>\n\n#else\n\n    gl_FragColor = vec4(diffuse, opacity);\n\n    uvs[0] = vec3(vUv.xy, 0.);\n\n#if NUM_CRS > 1\n    uvs[1] = vec3(vUv.x, fract(vUv.z), floor(vUv.z));\n#endif\n\n    vec4 color;\n    #pragma unroll_loop\n    for ( int i = 0; i < NUM_FS_TEXTURES; i ++ ) {\n        color = getLayerColor( i , colorTextures[ i ], colorOffsetScales[ i ], colorLayers[ i ]);\n        gl_FragColor.rgb = mix(gl_FragColor.rgb, color.rgb, color.a);\n    }\n\n  #if defined(DEBUG)\n    if (showOutline) {\n        #pragma unroll_loop\n        for ( int i = 0; i < NUM_CRS; i ++) {\n            color = getOutlineColor( outlineColors[ i ], uvs[ i ].xy);\n            gl_FragColor.rgb = mix(gl_FragColor.rgb, color.rgb, color.a);\n        }\n    }\n  #endif\n\n    #include <itowns/fog_fragment>\n    #include <itowns/lighting_fragment>\n    #include <itowns/overlay_fragment>\n\n#endif\n}\n";
 import ShaderUtils from "./Shader/ShaderUtils.js";
 import Capabilities from "../Core/System/Capabilities.js";
 import RenderMode from "./RenderMode.js";
@@ -85,7 +85,7 @@ export const ELEVATION_MODES = {
 };
 let nbSamplers;
 const fragmentShader = [];
-class LayeredMaterial extends THREE.RawShaderMaterial {
+class LayeredMaterial extends THREE.ShaderMaterial {
   #_visible = true;
   constructor() {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -94,16 +94,16 @@ class LayeredMaterial extends THREE.RawShaderMaterial {
     nbSamplers = nbSamplers || [samplersElevationCount, getMaxColorSamplerUnitsCount()];
     this.defines.NUM_VS_TEXTURES = nbSamplers[0];
     this.defines.NUM_FS_TEXTURES = nbSamplers[1];
+    // TODO: We do not use the fog from the scene, is this a desired
+    // behavior?
     this.defines.USE_FOG = 1;
     this.defines.NUM_CRS = crsCount;
     CommonMaterial.setDefineMapping(this, 'ELEVATION', ELEVATION_MODES);
     CommonMaterial.setDefineMapping(this, 'MODE', RenderMode.MODES);
     CommonMaterial.setDefineProperty(this, 'mode', 'MODE', RenderMode.MODES.FINAL);
-    if (Capabilities.isLogDepthBufferSupported()) {
-      this.defines.USE_LOGDEPTHBUF = 1;
-      this.defines.USE_LOGDEPTHBUF_EXT = 1;
-    }
     this.vertexShader = TileVS;
+    // three loop unrolling of ShaderMaterial only supports integer bounds,
+    // see https://github.com/mrdoob/three.js/issues/28020
     fragmentShader[crsCount] = fragmentShader[crsCount] || ShaderUtils.unrollLoops(TileFS, this.defines);
     this.fragmentShader = fragmentShader[crsCount];
 
@@ -170,12 +170,6 @@ class LayeredMaterial extends THREE.RawShaderMaterial {
       }
     });
   }
-  onBeforeCompile(shader, renderer) {
-    if (renderer.capabilities.isWebGL2) {
-      this.defines.WEBGL2 = true;
-      shader.glslVersion = '300 es';
-    }
-  }
   getUniformByType(type) {
     return {
       layers: this.uniforms[`${type}Layers`],

package/lib/Renderer/OrientedImageMaterial.js

@@ -1,15 +1,15 @@
 import * as THREE from 'three';
 import Capabilities from "../Core/System/Capabilities.js";
 /* babel-plugin-inline-import './Shader/ProjectiveTextureVS.glsl' */
-const textureVS = "#include <itowns/WebGL2_pars_vertex>\n#include <itowns/precision_qualifier>\n#include <itowns/project_pars_vertex>\n#include <itowns/projective_texturing_pars_vertex>\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\nvarying vec3 vNormal;\nattribute vec3 normal;\n\nvoid main() {\n    #include <begin_vertex>\n    #include <project_vertex>\n    vNormal = normal;\n    #include <itowns/projective_texturing_vertex>\n    #include <logdepthbuf_vertex>\n}\n";
+const textureVS = "#include <itowns/precision_qualifier>\n#include <itowns/projective_texturing_pars_vertex>\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\nvarying vec3 vNormal;\n\nvoid main() {\n    #include <begin_vertex>\n    #include <project_vertex>\n    vNormal = normal;\n    #include <itowns/projective_texturing_vertex>\n    #include <logdepthbuf_vertex>\n}\n";
 /* babel-plugin-inline-import './Shader/ProjectiveTextureFS.glsl' */
-const textureFS = "#include <itowns/WebGL2_pars_fragment>\n#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/projective_texturing_pars_fragment>\nvarying vec3 vNormal;\n\n#ifdef USE_BASE_MATERIAL\nstruct noPT {\n    vec3 lightDirection;\n    vec3 ambient;\n    float opacity;\n};\n\nuniform noPT noProjectiveMaterial;\n#endif\n\nvoid main(void)\n{\n    #include <logdepthbuf_fragment>\n    #ifdef USE_BASE_MATERIAL\n    float nDotVP = (max(0.1, dot(vNormal, normalize(noProjectiveMaterial.lightDirection))));\n    vec4 color = vec4(noProjectiveMaterial.ambient + nDotVP, 0.0);\n    #else\n    vec4 color = vec4(0.0);\n    #endif\n\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\n    #ifdef USE_BASE_MATERIAL\n    color.a = color.a < 1.0 ? max(noProjectiveMaterial.opacity, color.a) : 1.0 ;\n    gl_FragColor = vec4(color.rgb, color.a * opacity);\n    #else\n    gl_FragColor = vec4(color.rgb / color.a, opacity);\n    #endif\n\n}\n";
+const textureFS = "#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/projective_texturing_pars_fragment>\nvarying vec3 vNormal;\n\n#ifdef USE_BASE_MATERIAL\nstruct noPT {\n    vec3 lightDirection;\n    vec3 ambient;\n    float opacity;\n};\n\nuniform noPT noProjectiveMaterial;\n#endif\n\nvoid main(void)\n{\n    #include <logdepthbuf_fragment>\n    #ifdef USE_BASE_MATERIAL\n    float nDotVP = (max(0.1, dot(vNormal, normalize(noProjectiveMaterial.lightDirection))));\n    vec4 color = vec4(noProjectiveMaterial.ambient + nDotVP, 0.0);\n    #else\n    vec4 color = vec4(0.0);\n    #endif\n\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\n    #ifdef USE_BASE_MATERIAL\n    color.a = color.a < 1.0 ? max(noProjectiveMaterial.opacity, color.a) : 1.0 ;\n    gl_FragColor = vec4(color.rgb, color.a * opacity);\n    #else\n    gl_FragColor = vec4(color.rgb / color.a, opacity);\n    #endif\n\n}\n";
 import ShaderUtils from "./Shader/ShaderUtils.js";
 const ndcToTextureMatrix = new THREE.Matrix4(1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0, 0, 2);
 const noMask = new THREE.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, THREE.RGBAFormat, THREE.UnsignedByteType);
 noMask.needsUpdate = true;
 const noTexture = new THREE.Texture();
-const rawShaderMaterial = new THREE.RawShaderMaterial();
+const shaderMaterial = new THREE.ShaderMaterial();
 /**
  * @classdesc OrientedImageMaterial is a custom shader material used to do projective texture mapping.<br/>
  *
@@ -28,7 +28,7 @@ const rawShaderMaterial = new THREE.RawShaderMaterial();
  * <br/>
  * To get a more comprehensive support of camera Micmac models, you can consider using [three-photogrammetric-camera]{@link https://github.com/mbredif/three-photogrammetric-camera} instead.
  */
-class OrientedImageMaterial extends THREE.RawShaderMaterial {
+class OrientedImageMaterial extends THREE.ShaderMaterial {
   /**
    * @constructor
    * @param { OrientedImageCamera[]} cameras - Array of {@link OrientedImageCamera}. Each camera will project a texture.
@@ -53,17 +53,17 @@ class OrientedImageMaterial extends THREE.RawShaderMaterial {
     options.transparent = options.transparent ?? true;
     options.opacity = options.opacity ?? 1;
 
-    // Filter the rawShaderMaterial options
-    const rawShaderMaterialOptions = {};
+    // Filter out non-ShaderMaterial options
+    const shaderMaterialOptions = {};
     for (const key in options) {
       if (Object.prototype.hasOwnProperty.call(options, key)) {
-        const currentValue = rawShaderMaterial[key];
+        const currentValue = shaderMaterial[key];
         if (currentValue !== undefined) {
-          rawShaderMaterialOptions[key] = options[key];
+          shaderMaterialOptions[key] = options[key];
         }
       }
     }
-    super(rawShaderMaterialOptions);
+    super(shaderMaterialOptions);
     this.defines.ORIENTED_IMAGES_COUNT = options.OrientedImagesCount ?? cameras.length;
 
     // verify that number of textures doesn't exceed GPU capabilities
@@ -107,19 +107,11 @@ class OrientedImageMaterial extends THREE.RawShaderMaterial {
       ambient: new THREE.Color(0.1, 0.1, 0.1),
       opacity: 0.75
     });
-    if (Capabilities.isLogDepthBufferSupported()) {
-      this.defines.USE_LOGDEPTHBUF = 1;
-      this.defines.USE_LOGDEPTHBUF_EXT = 1;
-    }
     this.vertexShader = textureVS;
+    // three loop unrolling of ShaderMaterial only supports integer bounds,
+    // see https://github.com/mrdoob/three.js/issues/28020
     this.fragmentShader = ShaderUtils.unrollLoops(textureFS, this.defines);
   }
-  onBeforeCompile(shader, renderer) {
-    if (renderer.capabilities.isWebGL2) {
-      this.defines.WEBGL2 = true;
-      shader.glslVersion = '300 es';
-    }
-  }
 
   /**
    * Set new textures and new position/orientation of the camera set.

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/WebGL2_pars_vertex>\n#include <itowns/precision_qualifier>\n#include <itowns/project_pars_vertex>\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#else\nattribute vec3 normal;\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 <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";
 /* babel-plugin-inline-import './Shader/PointsFS.glsl' */
-const PointsFS = "#include <itowns/WebGL2_pars_fragment>\n#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 Capabilities from "../Core/System/Capabilities.js";
+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";
 import CommonMaterial from "./CommonMaterial.js";
 import Gradients from "../Utils/Gradients.js";
@@ -254,7 +253,7 @@ function recomputeTexture(scheme, texture, nbClass) {
   }
   texture.needsUpdate = true;
 }
-class PointsMaterial extends THREE.RawShaderMaterial {
+class PointsMaterial extends THREE.ShaderMaterial {
   /**
    * @class      PointsMaterial
    * @param      {object}  [options={}]  The options
@@ -383,14 +382,12 @@ class PointsMaterial extends THREE.RawShaderMaterial {
       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);
     } else {
       this.fragmentShader = PointsFS;
     }
-    if (Capabilities.isLogDepthBufferSupported()) {
-      this.defines.USE_LOGDEPTHBUF = 1;
-      this.defines.USE_LOGDEPTHBUF_EXT = 1;
-    }
   }
   recomputeClassification() {
     recomputeTexture(this.classificationScheme, this.classificationTexture, 32);
@@ -406,12 +403,6 @@ class PointsMaterial extends THREE.RawShaderMaterial {
       target: this.uniforms
     });
   }
-  onBeforeCompile(shader, renderer) {
-    if (renderer.capabilities.isWebGL2) {
-      this.defines.WEBGL2 = true;
-      shader.glslVersion = '300 es';
-    }
-  }
   copy(source) {
     super.copy(source);
     if (source.uniforms.projectiveTextureAlphaBorder) {

package/lib/Renderer/Shader/ShaderChunk.js

@@ -2,7 +2,7 @@ import * as THREE from 'three';
 /* babel-plugin-inline-import './Chunk/color_layers_pars_fragment.glsl' */
 const color_layers_pars_fragment = "struct Layer {\n    int textureOffset;\n    int crs;\n    int effect_type;\n    float effect_parameter;\n    float opacity;\n    bool transparent;\n};\n\n#include <itowns/custom_header_colorLayer>\n\nuniform sampler2D   colorTextures[NUM_FS_TEXTURES];\nuniform vec4        colorOffsetScales[NUM_FS_TEXTURES];\nuniform Layer       colorLayers[NUM_FS_TEXTURES];\nuniform int         colorTextureCount;\n\nvec3 uvs[NUM_CRS];\n\nfloat getBorderDistance(vec2 uv) {\n    vec2 p2 = min(uv, 1. -uv);\n    return min(p2.x, p2.y);\n}\n\nfloat tolerance = 0.99;\n\nvec4 applyWhiteToInvisibleEffect(vec4 color) {\n    float a = dot(color.rgb, vec3(0.333333333));\n    if (a >= tolerance) {\n        color.a = 0.0;\n    }\n    return color;\n}\n\nvec4 applyLightColorToInvisibleEffect(vec4 color, float intensity) {\n    float a = max(0.05,1. - length(color.xyz - 1.));\n    color.a *= 1.0 - pow(abs(a), intensity);\n    color.rgb *= color.rgb * color.rgb;\n    return color;\n}\n\n#if defined(DEBUG)\nuniform bool showOutline;\nuniform vec3 outlineColors[NUM_CRS];\nuniform float outlineWidth;\n\nvec4 getOutlineColor(vec3 outlineColor, vec2 uv) {\n    float alpha = 1. - clamp(getBorderDistance(uv) / outlineWidth, 0., 1.);\n    return vec4(outlineColor, alpha);\n}\n#endif\n\nuniform float minBorderDistance;\nvec4 getLayerColor(int textureOffset, sampler2D tex, vec4 offsetScale, Layer layer) {\n    if ( textureOffset >= colorTextureCount ) return vec4(0);\n\n    vec3 uv;\n    // #pragma unroll_loop\n    for ( int i = 0; i < NUM_CRS; i ++ ) {\n        if ( i == layer.crs ) uv = uvs[ i ];\n    }\n\n    float borderDistance = getBorderDistance(uv.xy);\n    if (textureOffset != layer.textureOffset + int(uv.z) || borderDistance < minBorderDistance ) return vec4(0);\n    vec4 color = texture2D(tex, pitUV(uv.xy, offsetScale));\n    if (layer.effect_type == 3) {\n        #include <itowns/custom_body_colorLayer>\n    } else {\n        if (layer.transparent && color.a != 0.0) {\n            color.rgb /= color.a;\n        }\n\n        if (layer.effect_type == 1) {\n            color = applyLightColorToInvisibleEffect(color, layer.effect_parameter);\n        } else if (layer.effect_type == 2) {\n            color = applyWhiteToInvisibleEffect(color);\n        }\n    }\n    color.a *= layer.opacity;\n    return color;\n}\n";
 /* babel-plugin-inline-import './Chunk/elevation_pars_vertex.glsl' */
-const elevation_pars_vertex = "#if NUM_VS_TEXTURES > 0\n    struct Layer {\n        float scale;\n        float bias;\n        int mode;\n        float zmin;\n        float zmax;\n    };\n\n    uniform Layer       elevationLayers[NUM_VS_TEXTURES];\n    uniform sampler2D   elevationTextures[NUM_VS_TEXTURES];\n    uniform vec4        elevationOffsetScales[NUM_VS_TEXTURES];\n    uniform int         elevationTextureCount;\n    uniform float       geoidHeight;\n\n    highp float decode32(highp vec4 rgba) {\n        highp float Sign = 1.0 - step(128.0,rgba[0])*2.0;\n        highp float Exponent = 2.0 * mod(rgba[0],128.0) + step(128.0,rgba[1]) - 127.0;\n        highp float Mantissa = mod(rgba[1],128.0)*65536.0 + rgba[2]*256.0 +rgba[3] + float(0x800000);\n        highp float Result =  Sign * exp2(Exponent) * (Mantissa * exp2(-23.0 ));\n        return Result;\n    }\n\n    float getElevationMode(vec2 uv, sampler2D tex, int mode) {\n        if (mode == ELEVATION_RGBA)\n            return decode32(texture2D( tex, uv ).abgr * 255.0);\n        if (mode == ELEVATION_DATA || mode == ELEVATION_COLOR)\n        #if defined(WEBGL2)\n            return texture2D( tex, uv ).r;\n        #else\n            return texture2D( tex, uv ).w;\n        #endif\n        return 0.;\n    }\n\n    float getElevation(vec2 uv, sampler2D tex, vec4 offsetScale, Layer layer) {\n        uv = uv * offsetScale.zw + offsetScale.xy;\n        float d = clamp(getElevationMode(uv, tex, layer.mode), layer.zmin, layer.zmax);\n        return d * layer.scale + layer.bias;\n    }\n#endif\n";
+const elevation_pars_vertex = "#if NUM_VS_TEXTURES > 0\n    struct Layer {\n        float scale;\n        float bias;\n        int mode;\n        float zmin;\n        float zmax;\n    };\n\n    uniform Layer       elevationLayers[NUM_VS_TEXTURES];\n    uniform sampler2D   elevationTextures[NUM_VS_TEXTURES];\n    uniform vec4        elevationOffsetScales[NUM_VS_TEXTURES];\n    uniform int         elevationTextureCount;\n    uniform float       geoidHeight;\n\n    highp float decode32(highp vec4 rgba) {\n        highp float Sign = 1.0 - step(128.0,rgba[0])*2.0;\n        highp float Exponent = 2.0 * mod(rgba[0],128.0) + step(128.0,rgba[1]) - 127.0;\n        highp float Mantissa = mod(rgba[1],128.0)*65536.0 + rgba[2]*256.0 +rgba[3] + float(0x800000);\n        highp float Result =  Sign * exp2(Exponent) * (Mantissa * exp2(-23.0 ));\n        return Result;\n    }\n\n    float getElevationMode(vec2 uv, sampler2D tex, int mode) {\n        if (mode == ELEVATION_RGBA)\n            return decode32(texture2D( tex, uv ).abgr * 255.0);\n        if (mode == ELEVATION_DATA || mode == ELEVATION_COLOR)\n            return texture2D( tex, uv ).r;\n        return 0.;\n    }\n\n    float getElevation(vec2 uv, sampler2D tex, vec4 offsetScale, Layer layer) {\n        // Elevation textures are inverted along the y-axis\n        uv = vec2(uv.x, 1.0 - uv.y);\n        uv = uv * offsetScale.zw + offsetScale.xy;\n        float d = clamp(getElevationMode(uv, tex, layer.mode), layer.zmin, layer.zmax);\n        return d * layer.scale + layer.bias;\n    }\n#endif\n";
 /* babel-plugin-inline-import './Chunk/elevation_vertex.glsl' */
 const elevation_vertex = "#if NUM_VS_TEXTURES > 0\n    if(elevationTextureCount > 0) {\n        float elevation = getElevation(uv, elevationTextures[0], elevationOffsetScales[0], elevationLayers[0]);\n        transformed += elevation * normal;\n    }\n#endif\n";
 /* babel-plugin-inline-import './Chunk/geoid_vertex.glsl' */
@@ -18,7 +18,7 @@ const lighting_pars_fragment = "uniform bool lightingEnabled;\nuniform vec3 ligh
 /* babel-plugin-inline-import './Chunk/mode_pars_fragment.glsl' */
 const mode_pars_fragment = "#if MODE == MODE_ID || MODE == MODE_DEPTH\n#include <packing>\n#endif\n\n#if MODE == MODE_ID\nuniform int objectId;\n#endif\n";
 /* babel-plugin-inline-import './Chunk/mode_depth_fragment.glsl' */
-const mode_depth_fragment = "#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)\ngl_FragColor = packDepthToRGBA(gl_FragDepthEXT);\n#else\nfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\ngl_FragColor = packDepthToRGBA(fragCoordZ);\n#endif";
+const mode_depth_fragment = "#if defined(USE_LOGDEPTHBUF)\ngl_FragColor = packDepthToRGBA(gl_FragDepthEXT);\n#else\nfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\ngl_FragColor = packDepthToRGBA(fragCoordZ);\n#endif\n";
 /* babel-plugin-inline-import './Chunk/mode_id_fragment.glsl' */
 const mode_id_fragment = "// 16777216.0 == 256.0 * 256.0 * 256.0\ngl_FragColor = packDepthToRGBA(float(objectId) / 16777216.0);\n";
 /* babel-plugin-inline-import './Chunk/overlay_fragment.glsl' */
@@ -29,18 +29,12 @@ const overlay_pars_fragment = "uniform vec3  overlayColor;\nuniform float overla
 const pitUV = "vec2 pitUV(vec2 uv, vec4 pit)\n{\n    return uv * pit.zw + vec2(pit.x, 1.0 - pit.w - pit.y);\n}\n\n";
 /* babel-plugin-inline-import './Chunk/precision_qualifier.glsl' */
 const precision_qualifier = "precision highp float;\nprecision highp int;\n";
-/* babel-plugin-inline-import './Chunk/project_pars_vertex.glsl' */
-const project_pars_vertex = "attribute vec3 position;\nuniform mat4 projectionMatrix;\nuniform mat4 modelViewMatrix;\n";
 /* babel-plugin-inline-import './Chunk/projective_texturing_vertex.glsl' */
 const projective_texturing_vertex = "for(int i = 0; i < ORIENTED_IMAGES_COUNT; ++i)\n    projectiveTextureCoords[i] = projectiveTextureMatrix[i] * mvPosition;\n";
 /* babel-plugin-inline-import './Chunk/projective_texturing_pars_vertex.glsl' */
 const projective_texturing_pars_vertex = "uniform mat4 projectiveTextureMatrix[ORIENTED_IMAGES_COUNT];\nvarying vec4 projectiveTextureCoords[ORIENTED_IMAGES_COUNT];\n";
 /* babel-plugin-inline-import './Chunk/projective_texturing_pars_fragment.glsl' */
 const projective_texturing_pars_fragment = "uniform sampler2D projectiveTexture[ORIENTED_IMAGES_COUNT];\nuniform sampler2D mask[ORIENTED_IMAGES_COUNT];\nvarying vec4      projectiveTextureCoords[ORIENTED_IMAGES_COUNT];\nuniform float     projectiveTextureAlphaBorder;\nuniform float     opacity;\nuniform bool      boostLight;\n\nstruct Distortion {\n    vec2 size;\n#if USE_DISTORTION\n    vec2 pps;\n    vec4 polynom;\n    vec3 l1l2;\n#endif\n};\n\nuniform Distortion projectiveTextureDistortion[ORIENTED_IMAGES_COUNT];\n\nfloat getAlphaBorder(vec2 p)\n{\n    vec2 d = clamp(projectiveTextureAlphaBorder * min(p, 1. - p), 0., 1.);\n    return min(d.x, d.y);\n}\n\n#if USE_DISTORTION\nvoid distort(inout vec2 p, vec4 polynom, vec2 pps)\n{\n    vec2 v = p - pps;\n    float v2 = dot(v, v);\n    if (v2 > polynom.w) {\n        p = vec2(-1.);\n    }\n    else {\n        p += (v2 * (polynom.x + v2 * (polynom.y + v2 * polynom.z) ) ) * v;\n    }\n}\n\nvoid distort(inout vec2 p, vec4 polynom, vec3 l1l2, vec2 pps)\n{\n    if ((l1l2.x == 0.) && (l1l2.y == 0.)) {\n        distort(p, polynom, pps);\n    } else {\n        vec2 AB = (p - pps) / l1l2.z;\n        float R = length(AB);\n        float lambda = atan(R) / R;\n        vec2 ab = lambda * AB;\n        float rho2 = dot(ab, ab);\n        float r357 = 1. + rho2* (polynom.x + rho2* (polynom.y + rho2 * polynom.z));\n        p = pps + l1l2.z * (r357 * ab + vec2(dot(l1l2.xy, ab), l1l2.y * ab.x));\n    }\n}\n#endif\n\nvec4 mixBaseColor(vec4 aColor, vec4 baseColor) {\n    #ifdef USE_BASE_MATERIAL\n        baseColor.rgb = aColor.a == 1.0 ? aColor.rgb : mix(baseColor, aColor, aColor.a).rgb;\n        baseColor.a = min(1.0, aColor.a + baseColor.a);\n    #else\n        baseColor.rgb += aColor.rgb * aColor.a;\n        baseColor.a += aColor.a;\n    #endif\n    return baseColor;\n}\n\nvec4 projectiveTextureColor(vec4 coords, Distortion distortion, sampler2D tex, sampler2D mask, vec4 baseColor) {\n    vec3 p = coords.xyz / coords.w;\n    if(p.z * p.z < 1.) {\n#if USE_DISTORTION\n        p.xy *= distortion.size;\n        distort(p.xy, distortion.polynom, distortion.l1l2, distortion.pps);\n        p.xy /= distortion.size;\n#endif\n\n        float d = getAlphaBorder(p.xy) * texture2D(mask, p.xy).r;\n\n        if(d > 0.) {\n\n#if DEBUG_ALPHA_BORDER\n        vec3 r = texture2D(tex, p.xy).rgb;\n        return mixBaseColor(vec4( r.r * d, r.g, r.b, 1.0), baseColor);\n#else\n        vec4 color = texture2D(tex, p.xy);\n        color.a *= d;\n        if (boostLight) {\n            return mixBaseColor(vec4(sqrt(color.rgb), color.a), baseColor);\n        } else {\n            return mixBaseColor(color, baseColor);\n        }\n#endif\n\n        }\n    }\n    return mixBaseColor(vec4(0.), baseColor);\n}\n";
-/* babel-plugin-inline-import './Chunk/WebGL2_pars_vertex.glsl' */
-const WebGL2_pars_vertex = "// Copy from GLSL 3.0 conversion for built-in materials and ShaderMaterial in THREE.WebGLProgram\n// https://github.com/mrdoob/three.js/blob/696d7836d1fc56c4702a475e6991c4adef7357f4/src/renderers/webgl/WebGLProgram.js#L682\n#if defined(WEBGL2)\n#define attribute in\n#define varying out\n#define texture2D texture\n#endif\n";
-/* babel-plugin-inline-import './Chunk/WebGL2_pars_fragment.glsl' */
-const WebGL2_pars_fragment = "// Copy from GLSL 3.0 conversion for built-in materials and ShaderMaterial in THREE.WebGLProgram\n// https://github.com/mrdoob/three.js/blob/696d7836d1fc56c4702a475e6991c4adef7357f4/src/renderers/webgl/WebGLProgram.js#L682\n#if defined(WEBGL2)\n#define varying in\nout highp vec4 pc_fragColor;\n#define gl_FragColor pc_fragColor\n#define gl_FragDepthEXT gl_FragDepth\n#define texture2D texture\n#define textureCube texture\n#define texture2DProj textureProj\n#define texture2DLodEXT textureLod\n#define texture2DProjLodEXT textureProjLod\n#define textureCubeLodEXT textureLod\n#define texture2DGradEXT textureGrad\n#define texture2DProjGradEXT textureProjGrad\n#define textureCubeGradEXT textureGrad\n#endif\n";
 const custom_header_colorLayer = '// no custom header';
 const custom_body_colorLayer = '// no custom body';
 const itownsShaderChunk = {
@@ -63,10 +57,7 @@ const itownsShaderChunk = {
   precision_qualifier,
   projective_texturing_vertex,
   projective_texturing_pars_vertex,
-  projective_texturing_pars_fragment,
-  project_pars_vertex,
-  WebGL2_pars_vertex,
-  WebGL2_pars_fragment
+  projective_texturing_pars_fragment
 };
 
 /**

package/lib/Renderer/c3DEngine.js

@@ -15,7 +15,7 @@ class c3DEngine {
   constructor(rendererOrDiv) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     deprecatedC3DEngineWebGLOptions(options);
-    const NOIE = !Capabilities.isInternetExplorer();
+
     // pick sensible default options
     if (options.antialias === undefined) {
       options.antialias = true;
@@ -24,10 +24,7 @@ class c3DEngine {
       options.alpha = true;
     }
     if (options.logarithmicDepthBuffer === undefined) {
-      options.logarithmicDepthBuffer = this.gLDebug || NOIE;
-    }
-    if (options.isWebGL2 === undefined) {
-      options.isWebGL2 = true;
+      options.logarithmicDepthBuffer = true;
     }
 
     // If rendererOrDiv parameter is a domElement, we use it as support to display data.
@@ -78,7 +75,7 @@ class c3DEngine {
       this.label2dRenderer = new Label2DRenderer();
       this.label2dRenderer.setSize(this.width, this.height);
       viewerDiv.appendChild(this.label2dRenderer.domElement);
-      this.renderer = renderer || new (options.isWebGL2 ? THREE.WebGLRenderer : THREE.WebGL1Renderer)({
+      this.renderer = renderer || new THREE.WebGLRenderer({
         canvas: document.createElement('canvas'),
         antialias: options.antialias,
         alpha: options.alpha,
@@ -88,30 +85,10 @@ class c3DEngine {
       this.renderer.domElement.style.zIndex = 0;
       this.renderer.domElement.style.top = 0;
     } catch (ex) {
-      const versionWebGL = options.isWebGL2 ? '2' : '1';
-      console.error(`Failed to create WebGLRenderer webGL ${versionWebGL}.`);
-      this.renderer = null;
-    }
-    if (!this.renderer) {
-      if (!WEBGL.isWebGLAvailable()) {
-        viewerDiv.appendChild(WEBGL.getErrorMessage(1));
-      } else if (!WEBGL.isWebGL2Available()) {
+      if (!WEBGL.isWebGL2Available()) {
         viewerDiv.appendChild(WEBGL.getErrorMessage(2));
       }
-      throw new Error('WebGL unsupported');
-    }
-    if (!renderer && options.logarithmicDepthBuffer) {
-      // We don't support logarithmicDepthBuffer when EXT_frag_depth is missing.
-      // So recreated a renderer if needed.
-      if (!this.renderer.capabilities.isWebGL2 && !this.renderer.extensions.get('EXT_frag_depth')) {
-        this.renderer.dispose();
-        this.renderer = new (options.isWebGL2 ? THREE.WebGLRenderer : THREE.WebGL1Renderer)({
-          canvas: document.createElement('canvas'),
-          antialias: options.antialias,
-          alpha: options.alpha,
-          logarithmicDepthBuffer: false
-        });
-      }
+      throw ex;
     }
 
     // Let's allow our canvas to take focus
@@ -139,7 +116,7 @@ class c3DEngine {
 
   /**
    * return renderer THREE.js
-   * @returns {undefined|THREE.WebGLRenderer}
+   * @returns {THREE.WebGLRenderer}
    */
   getRenderer() {
     return this.renderer;

package/package.json

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