itowns 2.44.3-next.22 → 2.44.3-next.23

package/lib/Core/Prefab/computeBufferTileGeometry.js

@@ -3,14 +3,52 @@ export function getBufferIndexSize(segments, noSkirt) {
   const triangles = segments * segments * 2 + (noSkirt ? 0 : 4 * segments * 2);
   return triangles * 3;
 }
-export default function computeBuffers(params) {
-  // Create output buffers.
-  const outBuffers = {
-    index: null,
-    position: null,
-    normal: null,
-    // 2 UV set per tile: wgs84 (uv[0]) and pm (uv[1])
-    //    - wgs84: 1 texture per tile because tiles are using wgs84 projection
+function getUintArrayConstructor(highestValue) {
+  let picked = null;
+  if (highestValue < 2 ** 8) {
+    picked = Uint8Array;
+  } else if (highestValue < 2 ** 16) {
+    picked = Uint16Array;
+  } else if (highestValue < 2 ** 32) {
+    picked = Uint32Array;
+  } else {
+    throw new Error('Value is too high');
+  }
+  return picked;
+}
+function allocateIndexBuffer(nVertex, nSeg, params) {
+  if (!params.buildIndexAndUv_0) {
+    return undefined;
+  }
+  const indexBufferSize = getBufferIndexSize(nSeg, params.disableSkirt);
+  const indexConstructor = getUintArrayConstructor(nVertex);
+  const tileLen = indexBufferSize;
+  const skirtLen = 4 * nSeg;
+  const indexBuffer = new ArrayBuffer((
+  // Tile
+  tileLen
+  // Skirt
+  + (params.disableSkirt ? 0 : skirtLen)) * indexConstructor.BYTES_PER_ELEMENT);
+  const index = new indexConstructor(indexBuffer);
+  const skirt = !params.disableSkirt ? index.subarray(tileLen, tileLen + skirtLen) : undefined;
+  return {
+    index,
+    skirt
+  };
+}
+function allocateBuffers(nVertex, nSeg, builder, params) {
+  const {
+    index,
+    skirt
+  } = allocateIndexBuffer(nVertex, nSeg, params) ?? {};
+  return {
+    index,
+    skirt,
+    position: new Float32Array(nVertex * 3),
+    normal: new Float32Array(nVertex * 3),
+    // 2 UV set per tile: wgs84 (uv[0]) and pseudo-mercator (pm, uv[1])
+    //    - wgs84: 1 texture per tile because tiles are using wgs84
+    //          projection
     //    - pm: use multiple textures per tile.
     //      +-------------------------+
     //      |                         |
@@ -24,142 +62,157 @@ export default function computeBuffers(params) {
     //      +-------------------------+
     //        * u = wgs84.u
     //        * v = textureid + v in builder texture
-    uvs: []
+    uvs: [params.buildIndexAndUv_0 ? new Float32Array(nVertex * 2) : undefined, builder.computeExtraOffset !== undefined ? new Float32Array(nVertex) : undefined]
+  };
+}
+function computeUv0(uv, id, u, v) {
+  uv[id * 2 + 0] = u;
+  uv[id * 2 + 1] = v;
+}
+function initComputeUv1(value) {
+  return (uv, id) => {
+    uv[id] = value;
   };
-  const computeUvs = [];
-  const builder = params.builder;
-  const nSeg = params.segments;
-  // segments count :
-  // Tile : (nSeg + 1) * (nSeg + 1)
-  // Skirt : 8 * (nSeg - 1)
-  const nVertex = (nSeg + 1) * (nSeg + 1) + (params.disableSkirt ? 0 : 4 * nSeg);
-  if (nVertex > 2 ** 32) {
+}
+/** Compute buffers describing a tile according to a builder and its params. */
+// TODO: Split this even further into subfunctions
+export function computeBuffers(builder, params) {
+  //     n seg, n+1 vert    + <- skirt, n verts per side
+  //    <---------------> / |
+  //    +---+---+---+---+   |
+  //    | / | / | / | / |   |  Vertices:
+  //    +---+---+---+---+ - +     tile = (n + 1)^2
+  //    | / | / | / | / |   |    skirt = 4n
+  //    +---+---+---+---+ - +
+  //    | / | / | / | / |   |  Segments:
+  //    +---+---+---+---+ - +     tile = 2 * n * (n + 1) + n^2
+  //    | / | / | / | / |   |    skirt = 2n * 4
+  //    +---+---+---+---+   |
+  const nSeg = Math.max(2, params.segments);
+  const nVertex = nSeg + 1;
+  const nTileVertex = nVertex ** 2;
+  const nSkirtVertex = params.disableSkirt ? 0 : 4 * nSeg;
+  const nTotalVertex = nTileVertex + nSkirtVertex;
+
+  // Computer should combust before this happens
+  if (nTotalVertex > 2 ** 32) {
     throw new Error('Tile segments count is too big');
   }
-  outBuffers.position = new Float32Array(nVertex * 3);
-  outBuffers.normal = new Float32Array(nVertex * 3);
-  const uvCount = params.builder.uvCount;
-  if (uvCount > 1) {
-    outBuffers.uvs[1] = new Float32Array(nVertex);
-  }
-  computeUvs[0] = () => {};
-  const bufferIndexSize = getBufferIndexSize(nSeg, params.disableSkirt);
-  if (params.buildIndexAndUv_0) {
-    if (nVertex < 2 ** 8) {
-      outBuffers.index = new Uint8Array(bufferIndexSize);
-    } else if (nVertex < 2 ** 16) {
-      outBuffers.index = new Uint16Array(bufferIndexSize);
-    } else if (nVertex < 2 ** 32) {
-      outBuffers.index = new Uint32Array(bufferIndexSize);
+  const outBuffers = allocateBuffers(nTotalVertex, nSeg, builder, params);
+  const computeUvs = [params.buildIndexAndUv_0 ? computeUv0 : () => {}];
+  params = builder.prepare(params);
+  for (let y = 0; y <= nSeg; y++) {
+    const v = y / nSeg;
+    params.coordinates.y = builder.vProject(v, params.extent);
+    if (builder.computeExtraOffset !== undefined) {
+      computeUvs[1] = initComputeUv1(builder.computeExtraOffset(params));
     }
-    outBuffers.uvs[0] = new Float32Array(nVertex * 2);
-    computeUvs[0] = (id, u, v) => {
-      outBuffers.uvs[0][id * 2 + 0] = u;
-      outBuffers.uvs[0][id * 2 + 1] = v;
-    };
-  }
-  const widthSegments = Math.max(2, Math.floor(nSeg) || 2);
-  const heightSegments = Math.max(2, Math.floor(nSeg) || 2);
-  let idVertex = 0;
-  const vertices = [];
-  let skirt = [];
-  const skirtEnd = [];
-  builder.prepare(params);
-  for (let y = 0; y <= heightSegments; y++) {
-    const verticesRow = [];
-    const v = y / heightSegments;
-    builder.vProjecte(v, params);
-    if (uvCount > 1) {
-      const u = builder.computeUvs[1](params);
-      computeUvs[1] = id => {
-        outBuffers.uvs[1][id] = u;
-      };
-    }
-    for (let x = 0; x <= widthSegments; x++) {
-      const u = x / widthSegments;
-      const id_m3 = idVertex * 3;
-      builder.uProjecte(u, params);
-      const vertex = builder.vertexPosition(params, params.projected);
-      const normal = builder.vertexNormal(params);
+    for (let x = 0; x <= nSeg; x++) {
+      const u = x / nSeg;
+      const id_m3 = (y * nVertex + x) * 3;
+      params.coordinates.x = builder.uProject(u, params.extent);
+      const vertex = builder.vertexPosition(params.coordinates);
+      const normal = builder.vertexNormal();
 
       // move geometry to center world
       vertex.sub(params.center);
 
       // align normal to z axis
-      if (params.quatNormalToZ) {
-        vertex.applyQuaternion(params.quatNormalToZ);
-        normal.applyQuaternion(params.quatNormalToZ);
+      // HACK: this check style is not great
+      if ('quatNormalToZ' in params) {
+        const quat = params.quatNormalToZ;
+        vertex.applyQuaternion(quat);
+        normal.applyQuaternion(quat);
       }
       vertex.toArray(outBuffers.position, id_m3);
       normal.toArray(outBuffers.normal, id_m3);
-      for (const computeUv of computeUvs) {
-        computeUv(idVertex, u, v);
-      }
-      if (!params.disableSkirt) {
-        if (y !== 0 && y !== heightSegments) {
-          if (x === widthSegments) {
-            skirt.push(idVertex);
-          } else if (x === 0) {
-            skirtEnd.push(idVertex);
-          }
+      for (const [index, computeUv] of computeUvs.entries()) {
+        if (computeUv !== undefined) {
+          computeUv(outBuffers.uvs[index], y * nVertex + x, u, v);
         }
       }
-      verticesRow.push(idVertex);
-      idVertex++;
-    }
-    vertices.push(verticesRow);
-    if (y === 0) {
-      skirt = skirt.concat(verticesRow);
-    } else if (y === heightSegments) {
-      skirt = skirt.concat(verticesRow.slice().reverse());
     }
   }
-  if (!params.disableSkirt) {
-    skirt = skirt.concat(skirtEnd.reverse());
+
+  // Fill skirt index buffer
+  if (params.buildIndexAndUv_0 && !params.disableSkirt) {
+    for (let x = 0; x < nVertex; x++) {
+      //   -------->
+      //   0---1---2
+      //   | / | / |   [0-9] = assign order
+      //   +---+---+
+      //   | / | / |
+      //   +---+---+
+      outBuffers.skirt[x] = x;
+      //   +---+---+
+      //   | / | / |   [0-9] = assign order
+      //   +---+---x   x = skipped for now
+      //   | / | / |
+      //   0---1---2
+      //   <--------
+      outBuffers.skirt[2 * nVertex - 2 + x] = nVertex ** 2 - (x + 1);
+    }
+    for (let y = 1; y < nVertex - 1; y++) {
+      //   +---+---s |
+      //   | / | / | | o = stored vertices
+      //   +---+---o | s = already stored
+      //   | / | / | |
+      //   +---+---s v
+      outBuffers.skirt[nVertex - 1 + y] = y * nVertex + (nVertex - 1);
+      // ^ s---+---+
+      // | | / | / |   o = stored vertices
+      // | o---+---+   s = already stored
+      // | | / | / |
+      // | s---+---+
+      outBuffers.skirt[3 * nVertex - 3 + y] = nVertex * (nVertex - 1 - y);
+    }
   }
-  function bufferize(va, vb, vc, idVertex) {
-    outBuffers.index[idVertex + 0] = va;
-    outBuffers.index[idVertex + 1] = vb;
-    outBuffers.index[idVertex + 2] = vc;
-    return idVertex + 3;
+
+  /** Copy passed indices at the desired index of the output index buffer. */
+  function bufferizeTri(id, va, vb, vc) {
+    outBuffers.index[id + 0] = va;
+    outBuffers.index[id + 1] = vb;
+    outBuffers.index[id + 2] = vc;
   }
-  let idVertex2 = 0;
   if (params.buildIndexAndUv_0) {
-    for (let y = 0; y < heightSegments; y++) {
-      for (let x = 0; x < widthSegments; x++) {
-        const v1 = vertices[y][x + 1];
-        const v2 = vertices[y][x];
-        const v3 = vertices[y + 1][x];
-        const v4 = vertices[y + 1][x + 1];
-        idVertex2 = bufferize(v4, v2, v1, idVertex2);
-        idVertex2 = bufferize(v4, v3, v2, idVertex2);
+    for (let y = 0; y < nSeg; y++) {
+      for (let x = 0; x < nSeg; x++) {
+        const v1 = y * nVertex + (x + 1);
+        const v2 = y * nVertex + x;
+        const v3 = (y + 1) * nVertex + x;
+        const v4 = (y + 1) * nVertex + (x + 1);
+        const id = (y * nSeg + x) * 6;
+        bufferizeTri(id, /**/v4, v2, v1);
+        bufferizeTri(id + 3, v4, v3, v2);
       }
     }
   }
-  const iStart = idVertex;
 
-  // TODO: WARNING beware skirt's size influences performance
-  // The size of the skirt is now a ratio of the size of the tile.
-  // To be perfect it should depend on the real elevation delta but too heavy to compute
-  if (!params.disableSkirt) {
-    // We compute the actual size of tile segment to use later for the skirt.
+  // PERF: Beware skirt's size influences performance
+  // INFO: The size of the skirt is now a ratio of the size of the tile.
+  // To be perfect it should depend on the real elevation delta but too heavy
+  // to compute
+  if (params.buildIndexAndUv_0 && !params.disableSkirt) {
+    // We compute the actual size of tile segment to use later for
+    // the skirt.
     const segmentSize = new THREE.Vector3().fromArray(outBuffers.position).distanceTo(new THREE.Vector3().fromArray(outBuffers.position, 3));
-    let buildIndexSkirt = function () {};
-    let buildUVSkirt = function () {};
-    if (params.buildIndexAndUv_0) {
-      buildIndexSkirt = function (id, v1, v2, v3, v4) {
-        id = bufferize(v1, v2, v3, id);
-        id = bufferize(v1, v3, v4, id);
-        return id;
-      };
-      buildUVSkirt = function (id) {
-        outBuffers.uvs[0][idVertex * 2 + 0] = outBuffers.uvs[0][id * 2 + 0];
-        outBuffers.uvs[0][idVertex * 2 + 1] = outBuffers.uvs[0][id * 2 + 1];
-      };
-    }
-    for (let i = 0; i < skirt.length; i++) {
-      const id = skirt[i];
-      const id_m3 = idVertex * 3;
+    const buildSkirt = {
+      index: (id, v1, v2, v3, v4) => {
+        bufferizeTri(id, v1, v2, v3);
+        bufferizeTri(id + 3, v1, v3, v4);
+        return id + 6;
+      },
+      uv: (buf, idTo, idFrom) => {
+        buf[idTo * 2 + 0] = buf[idFrom * 2 + 0];
+        buf[idTo * 2 + 1] = buf[idFrom * 2 + 1];
+      }
+    };
+
+    // Alias for readability
+    const start = nTileVertex;
+    for (let i = 0; i < outBuffers.skirt.length; i++) {
+      const id = outBuffers.skirt[i];
+      const id_m3 = (start + i) * 3;
       const id2_m3 = id * 3;
       outBuffers.position[id_m3 + 0] = outBuffers.position[id2_m3 + 0] - outBuffers.normal[id2_m3 + 0] * segmentSize;
       outBuffers.position[id_m3 + 1] = outBuffers.position[id2_m3 + 1] - outBuffers.normal[id2_m3 + 1] * segmentSize;
@@ -167,17 +220,23 @@ export default function computeBuffers(params) {
       outBuffers.normal[id_m3 + 0] = outBuffers.normal[id2_m3 + 0];
       outBuffers.normal[id_m3 + 1] = outBuffers.normal[id2_m3 + 1];
       outBuffers.normal[id_m3 + 2] = outBuffers.normal[id2_m3 + 2];
-      buildUVSkirt(id);
-      if (uvCount > 1) {
-        outBuffers.uvs[1][idVertex] = outBuffers.uvs[1][id];
+      buildSkirt.uv(outBuffers.uvs[0], start + i, id);
+      if (outBuffers.uvs[1] !== undefined) {
+        outBuffers.uvs[1][start + i] = outBuffers.uvs[1][id];
       }
-      const idf = (i + 1) % skirt.length;
-      const v2 = idVertex;
-      const v3 = idf === 0 ? iStart : idVertex + 1;
-      const v4 = skirt[idf];
-      idVertex2 = buildIndexSkirt(idVertex2, id, v2, v3, v4);
-      idVertex++;
+      const idf = (i + 1) % outBuffers.skirt.length;
+      const v2 = start + i;
+      const v3 = idf === 0 ? start : start + i + 1;
+      const v4 = outBuffers.skirt[idf];
+      buildSkirt.index(6 * nSeg ** 2 + i * 6, id, v2, v3, v4);
     }
   }
-  return outBuffers;
+
+  // Dropping skirt view
+  return {
+    index: outBuffers.index,
+    position: outBuffers.position,
+    uvs: outBuffers.uvs,
+    normal: outBuffers.normal
+  };
 }

package/lib/Core/TileGeometry.js

@@ -1,40 +1,124 @@
 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;
+import { computeBuffers, getBufferIndexSize } from "./Prefab/computeBufferTileGeometry.js";
+import Coordinates from "./Geographic/Coordinates.js";
+function defaultBuffers(builder, params) {
+  const fullParams = {
+    disableSkirt: false,
+    hideSkirt: false,
+    buildIndexAndUv_0: true,
+    segments: 16,
+    coordinates: new Coordinates(builder.crs),
+    center: builder.center(params.extent).clone(),
+    ...params
+  };
+  const buffers = computeBuffers(builder, fullParams);
+  const bufferAttributes = {
+    index: buffers.index ? new THREE.BufferAttribute(buffers.index, 1) : null,
+    uvs: [...(buffers.uvs[0] ? [new THREE.BufferAttribute(buffers.uvs[0], 2)] : []), ...(buffers.uvs[1] ? [new THREE.BufferAttribute(buffers.uvs[1], 1)] : [])],
+    position: new THREE.BufferAttribute(buffers.position, 3),
+    normal: new THREE.BufferAttribute(buffers.normal, 3)
+  };
+  return bufferAttributes;
 }
-class TileGeometry extends THREE.BufferGeometry {
-  constructor(params) {
-    let buffers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultBuffers(params);
+export class TileGeometry extends THREE.BufferGeometry {
+  /** Oriented Bounding Box of the tile geometry. */
+
+  /** Ground area covered by this tile geometry. */
+
+  /** Resolution of the tile geometry in segments per side. */
+
+  /**
+   * [TileGeometry] instances are shared between tiles. Since a geometry
+   * handles its own GPU resource, it needs a reference counter to dispose of
+   * that resource only when it is discarded by every single owner of a
+   * reference to the geometry.
+   */
+  // https://github.com/iTowns/itowns/pull/2440#discussion_r1860743294
+  // TODO: Remove nullability by reworking OBB:setFromExtent
+
+  constructor(builder, params) {
+    let bufferAttributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultBuffers(builder, 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.setIndex(bufferAttributes.index);
+    this.setAttribute('position', bufferAttributes.position);
+    this.setAttribute('normal', bufferAttributes.normal);
+    this.setAttribute('uv', bufferAttributes.uvs[0]);
+    for (let i = 1; i < bufferAttributes.uvs.length; i++) {
+      this.setAttribute(`uv_${i}`, bufferAttributes.uvs[i]);
     }
     this.computeBoundingBox();
-    this.OBB = {};
+    this.OBB = null;
     if (params.hideSkirt) {
       this.hideSkirt = params.hideSkirt;
     }
+    this._refCount = null;
   }
-  set hideSkirt(value) {
-    this.setDrawRange(0, getBufferIndexSize(this.segments, value));
+
+  /**
+   * Enables or disables skirt rendering.
+   *
+   * @param toggle - Whether to hide the skirt; true hides, false shows.
+   */
+  set hideSkirt(toggle) {
+    this.setDrawRange(0, getBufferIndexSize(this.segments, toggle));
   }
-}
-export default TileGeometry;
+
+  /**
+   * Initialize reference count for this geometry if it is currently null.
+   *
+   * @param cacheTile - The [Cache] used to store this geometry.
+   * @param keys - The [south, level, epsg] key of this geometry.
+   */
+  initRefCount(cacheTile, keys) {
+    if (this._refCount !== null) {
+      return;
+    }
+    this._refCount = {
+      count: 0,
+      fn: () => {
+        this._refCount.count--;
+        if (this._refCount.count <= 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).
+          this.index = null;
+          delete this.attributes.uv;
+          cacheTile.delete(...keys);
+          super.dispose();
+          // THREE.BufferGeometry.prototype.dispose.call(this);
+        }
+      }
+    };
+  }
+
+  /**
+   * Increase reference count.
+   *
+   * @throws If reference count has not been initialized.
+   */
+  increaseRefCount() {
+    if (this._refCount === null) {
+      throw new Error('[TileGeometry::increaseRefCount] ' + 'Tried to increment an unitialized reference count.');
+    }
+    this._refCount.count++;
+  }
+
+  /**
+   * The current reference count of this [TileGeometry] if it has been
+   * initialized.
+   */
+  get refCount() {
+    return this._refCount?.count;
+  }
+  dispose() {
+    if (this._refCount == null) {
+      super.dispose();
+    } else {
+      this._refCount.fn();
+    }
+  }
+}

package/lib/Layer/C3DTilesLayer.js

@@ -51,11 +51,14 @@ function findTileID(object) {
 function object3DHasFeature(object3d) {
   return object3d.geometry && object3d.geometry.attributes._BATCHID;
 }
+
+/**
+ * @extends GeometryLayer
+ */
 class C3DTilesLayer extends GeometryLayer {
   #fillColorMaterialsBuffer;
   /**
    * @deprecated Deprecated 3D Tiles layer. Use {@link OGC3DTilesLayer} instead.
-   * @extends GeometryLayer
    *
    * @example
    * // Create a new 3d-tiles layer from a web server
@@ -83,7 +86,7 @@ class C3DTilesLayer extends GeometryLayer {
    * {@link View} that already has a layer going by that id.
    * @param      {object}  config   configuration, all elements in it
    * will be merged as is in the layer.
-   * @param {C3TilesSource} config.source The source of 3d Tiles.
+   * @param {C3DTilesSource} config.source The source of 3d Tiles.
    *
    * name.
    * @param {Number} [config.sseThreshold=16] The [Screen Space Error](https://github.com/CesiumGS/3d-tiles/blob/main/specification/README.md#geometric-error)
@@ -143,8 +146,8 @@ class C3DTilesLayer extends GeometryLayer {
       }
     }
 
-    /** @type {Style} */
-    this.style = config.style || null;
+    /** @type {Style | null} */
+    this._style = config.style || null;
 
     /** @type {Map<string, THREE.MeshStandardMaterial>} */
     this.#fillColorMaterialsBuffer = new Map();

package/lib/Layer/ColorLayer.js

@@ -44,6 +44,8 @@ import { deprecatedColorLayerOptions } from "../Core/Deprecated/Undeprecator.js"
  * * `1`: used to amplify the transparency effect.
  * * `2`: unused.
  * * `3`: could be used by your own glsl code.
+ *
+ * @extends RasterLayer
  */
 class ColorLayer extends RasterLayer {
   /**
@@ -51,8 +53,6 @@ class ColorLayer extends RasterLayer {
    * it can be an aerial view of the ground or a simple transparent layer with the
    * roads displayed.
    *
-   * @extends Layer
-   *
    * @param {string} id - The id of the layer, that should be unique. It is
    * not mandatory, but an error will be emitted if this layer is added a
    * {@link View} that already has a layer going by that id.
@@ -92,15 +92,41 @@ class ColorLayer extends RasterLayer {
   constructor(id) {
     let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     deprecatedColorLayerOptions(config);
-    super(id, config);
+    const {
+      effect_type = 0,
+      effect_parameter = 1.0,
+      transparent,
+      ...rasterConfig
+    } = config;
+    super(id, rasterConfig);
+
+    /**
+     * @type {boolean}
+     * @readonly
+     */
     this.isColorLayer = true;
-    this.defineLayerProperty('visible', true);
-    this.defineLayerProperty('opacity', 1.0);
-    this.defineLayerProperty('sequence', 0);
-    this.transparent = config.transparent || this.opacity < 1.0;
+
+    /**
+     * @type {boolean}
+     */
+    this.visible = true;
+    this.defineLayerProperty('visible', this.visible);
+
+    /**
+     * @type {number}
+     */
+    this.opacity = 1.0;
+    this.defineLayerProperty('opacity', this.opacity);
+
+    /**
+     * @type {number}
+     */
+    this.sequence = 0;
+    this.defineLayerProperty('sequence', this.sequence);
+    this.transparent = transparent || this.opacity < 1.0;
     this.noTextureParentOutsideLimit = config.source ? config.source.isFileSource : false;
-    this.effect_type = config.effect_type ?? 0;
-    this.effect_parameter = config.effect_parameter ?? 1.0;
+    this.effect_type = effect_type;
+    this.effect_parameter = effect_parameter;
 
     // Feature options
     this.buildExtent = true;

package/lib/Layer/CopcLayer.js

@@ -30,6 +30,11 @@ class CopcLayer extends PointCloudLayer {
    */
   constructor(id, config) {
     super(id, config);
+
+    /**
+     * @type {boolean}
+     * @readonly
+     */
     this.isCopcLayer = true;
     const resolve = () => this;
     this.whenReady = this.source.whenReady.then((/** @type {CopcSource} */source) => {