itowns 2.44.3-next.4 → 2.44.3-next.41

package/lib/Core/System/Capabilities.js

@@ -1,63 +0,0 @@
-/* babel-plugin-inline-import '../../Renderer/Shader/SampleTestFS.glsl' */
-const SampleTestFS = "uniform sampler2D uni[SAMPLE];\nvoid main() {\n    gl_FragColor += texture2D(uni[SAMPLE-1], vec2(0));\n}";
-/* babel-plugin-inline-import '../../Renderer/Shader/SampleTestVS.glsl' */
-const SampleTestVS = "void main() {\n    gl_Position = vec4( 0.0, 0.0, 0.0, 1.0 );\n}"; // default values
-let logDepthBufferSupported = false;
-let maxTexturesUnits = 8;
-let maxTextureSize = 4096;
-function _WebGLShader(renderer, type, string) {
-  const gl = renderer.getContext();
-  const shader = gl.createShader(type);
-  gl.shaderSource(shader, string);
-  gl.compileShader(shader);
-  return shader;
-}
-function isFirefox() {
-  return navigator && navigator.userAgent && navigator.userAgent.toLowerCase().includes('firefox');
-}
-export default {
-  isLogDepthBufferSupported() {
-    return logDepthBufferSupported;
-  },
-  isFirefox,
-  getMaxTextureUnitsCount() {
-    return maxTexturesUnits;
-  },
-  getMaxTextureSize() {
-    return maxTextureSize;
-  },
-  updateCapabilities(renderer) {
-    const gl = renderer.getContext();
-    maxTexturesUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
-    maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-    const program = gl.createProgram();
-    const glVertexShader = _WebGLShader(renderer, gl.VERTEX_SHADER, SampleTestVS);
-    let fragmentShader = `#define SAMPLE ${maxTexturesUnits}\n`;
-    fragmentShader += SampleTestFS;
-    const glFragmentShader = _WebGLShader(renderer, gl.FRAGMENT_SHADER, fragmentShader);
-    gl.attachShader(program, glVertexShader);
-    gl.attachShader(program, glFragmentShader);
-    gl.linkProgram(program);
-    if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {
-      if (maxTexturesUnits > 16) {
-        const info = gl.getProgramInfoLog(program);
-        // eslint-disable-next-line no-console
-        console.warn(`${info}: using a maximum of 16 texture units instead of the reported value (${maxTexturesUnits})`);
-        if (isFirefox()) {
-          // eslint-disable-next-line no-console
-          console.warn(`It can come from a Mesa/Firefox bug;
-                        the shader compiles to an error when using more than 16 sampler uniforms,
-                        see https://bugzilla.mozilla.org/show_bug.cgi?id=777028`);
-        }
-        maxTexturesUnits = 16;
-      } else {
-        throw new Error(`The GPU capabilities could not be determined accurately.
-                    Impossible to link a shader with the Maximum texture units ${maxTexturesUnits}`);
-      }
-    }
-    gl.deleteProgram(program);
-    gl.deleteShader(glVertexShader);
-    gl.deleteShader(glFragmentShader);
-    logDepthBufferSupported = renderer.capabilities.logarithmicDepthBuffer;
-  }
-};

package/lib/Core/TileGeometry.js

@@ -1,40 +0,0 @@
-import * as THREE from 'three';
-import computeBuffers, { getBufferIndexSize } from "./Prefab/computeBufferTileGeometry.js";
-function defaultBuffers(params) {
-  params.buildIndexAndUv_0 = true;
-  params.center = params.builder.center(params.extent).clone();
-  const buffers = computeBuffers(params);
-  buffers.index = new THREE.BufferAttribute(buffers.index, 1);
-  buffers.uvs[0] = new THREE.BufferAttribute(buffers.uvs[0], 2);
-  buffers.position = new THREE.BufferAttribute(buffers.position, 3);
-  buffers.normal = new THREE.BufferAttribute(buffers.normal, 3);
-  for (let i = 1; i < params.builder.uvCount; i++) {
-    buffers.uvs[1] = new THREE.BufferAttribute(buffers.uvs[1], 1);
-  }
-  return buffers;
-}
-class TileGeometry extends THREE.BufferGeometry {
-  constructor(params) {
-    let buffers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultBuffers(params);
-    super();
-    this.center = params.center;
-    this.extent = params.extent;
-    this.segments = params.segments;
-    this.setIndex(buffers.index);
-    this.setAttribute('position', buffers.position);
-    this.setAttribute('normal', buffers.normal);
-    this.setAttribute('uv', buffers.uvs[0]);
-    for (let i = 1; i < buffers.uvs.length; i++) {
-      this.setAttribute(`uv_${i}`, buffers.uvs[i]);
-    }
-    this.computeBoundingBox();
-    this.OBB = {};
-    if (params.hideSkirt) {
-      this.hideSkirt = params.hideSkirt;
-    }
-  }
-  set hideSkirt(value) {
-    this.setDrawRange(0, getBufferIndexSize(this.segments, value));
-  }
-}
-export default TileGeometry;

package/lib/Core/TileMesh.js

@@ -1,108 +0,0 @@
-import * as THREE from 'three';
-import CRS from "./Geographic/Crs.js";
-import { geoidLayerIsVisible } from "../Layer/GeoidLayer.js";
-
-/**
- * A TileMesh is a THREE.Mesh with a geometricError and an OBB
- * The objectId property of the material is the with the id of the TileMesh
- * @param {TileGeometry} geometry - the tile geometry
- * @param {THREE.Material} material - a THREE.Material compatible with THREE.Mesh
- * @param {Layer} layer - the layer the tile is added to
- * @param {Extent} extent - the tile extent
- * @param {?number} level - the tile level (default = 0)
- */
-class TileMesh extends THREE.Mesh {
-  #_tms = (() => new Map())();
-  #visible = true;
-  constructor(geometry, material, layer, extent) {
-    let level = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-    super(geometry, material);
-    if (!extent) {
-      throw new Error('extent is mandatory to build a TileMesh');
-    }
-    this.layer = layer;
-    this.extent = extent;
-    this.extent.zoom = level;
-    this.level = level;
-    this.material.objectId = this.id;
-    this.obb = this.geometry.OBB.clone();
-    this.boundingSphere = new THREE.Sphere();
-    this.obb.box3D.getBoundingSphere(this.boundingSphere);
-    for (const tms of layer.tileMatrixSets) {
-      this.#_tms.set(tms, this.extent.tiledCovering(tms));
-    }
-    this.frustumCulled = false;
-    this.matrixAutoUpdate = false;
-    this.rotationAutoUpdate = false;
-    this.layerUpdateState = {};
-    this.isTileMesh = true;
-    this.geoidHeight = 0;
-    this.link = {};
-    Object.defineProperty(this, 'visible', {
-      get() {
-        return this.#visible;
-      },
-      set(v) {
-        if (this.#visible != v) {
-          this.#visible = v;
-          this.dispatchEvent({
-            type: v ? 'shown' : 'hidden'
-          });
-        }
-      }
-    });
-  }
-  /**
-   * If specified, update the min and max elevation of the OBB
-   * and updates accordingly the bounding sphere and the geometric error
-   *
-   * @param {Object}  elevation
-   * @param {number}  [elevation.min]
-   * @param {number}  [elevation.max]
-   * @param {number}  [elevation.scale]
-   */
-  setBBoxZ(elevation) {
-    elevation.geoidHeight = geoidLayerIsVisible(this.layer) ? this.geoidHeight : 0;
-    this.obb.updateZ(elevation);
-    if (this.horizonCullingPointElevationScaled) {
-      this.horizonCullingPointElevationScaled.setLength(this.obb.z.delta + this.horizonCullingPoint.length());
-    }
-    this.obb.box3D.getBoundingSphere(this.boundingSphere);
-  }
-  getExtentsByProjection(crs) {
-    return this.#_tms.get(CRS.formatToTms(crs));
-  }
-
-  /**
-   * Search for a common ancestor between this tile and another one. It goes
-   * through parents on each side until one is found.
-   *
-   * @param {TileMesh} tile
-   *
-   * @return {TileMesh} the resulting common ancestor
-   */
-  findCommonAncestor(tile) {
-    if (!tile) {
-      return undefined;
-    }
-    if (tile.level == this.level) {
-      if (tile.id == this.id) {
-        return tile;
-      } else if (tile.level != 0) {
-        return this.parent.findCommonAncestor(tile.parent);
-      } else {
-        return undefined;
-      }
-    } else if (tile.level < this.level) {
-      return this.parent.findCommonAncestor(tile);
-    } else {
-      return this.findCommonAncestor(tile.parent);
-    }
-  }
-  onBeforeRender() {
-    if (this.material.layersNeedUpdate) {
-      this.material.updateLayersUniforms();
-    }
-  }
-}
-export default TileMesh;