itowns 2.45.1 → 2.45.2-next.0

package/lib/Layer/OrientedImageLayer.d.ts

@@ -0,0 +1,53 @@
+export default OrientedImageLayer;
+/**
+ * OrientedImageLayer loads oriented images, and project these textures on the scene.
+ * It is design to create an immersive view. </br>
+ * It loads a set of panoramic position and orientation,
+ * a set of camera calibration file (it's the same set of camera for each panoramic),
+ * and a set of texture (each image for each camera for each panoramic), all organised in an {@link OrientedImageSource}. </br>
+ * It creates an {@link OrientedImageMaterial} used to do projective texture mapping on the scene.
+ * @extends GeometryLayer
+ */
+declare class OrientedImageLayer extends GeometryLayer {
+    /**
+     * @param { string } id - The id of the layer, a unique name.
+     * @param { Object } config - configuration of the layer
+     * @param { number } config.backgroundDistance - Radius in meter of the sphere used as a background
+     * @param { function } config.onPanoChanged - callback fired when current panoramic changes
+     * @param { string } config.crs - crs projection of the view
+     * @param { string } config.orientation - Json object, using GeoJSon format to represent points,
+     * it's a set of panoramic position and orientation.
+     * @param { string } config.calibrations - Json object, representing a set of camera.
+     * see {@link CameraCalibrationParser}
+     * @param { OrientedImageSource } config.source - Source used to build url of texture for each oriented image,
+     * a tecture is need for each camera, for each panoramic.
+     */
+    constructor(id: string, config?: {
+        backgroundDistance: number;
+        onPanoChanged: Function;
+        crs: string;
+        orientation: string;
+        calibrations: string;
+        source: OrientedImageSource;
+    });
+    isOrientedImageLayer: boolean;
+    background: any;
+    currentPano: any;
+    onPanoChanged: Function;
+    getCamerasNameFromFeature: any;
+    mergeFeatures: boolean;
+    accurate: boolean;
+    panos: any;
+    cameras: any;
+    material: OrientedImageMaterial;
+    update(): void;
+    set boostLight(value: any);
+    get boostLight(): any;
+    preUpdate(context: any): void;
+    getNextPano(): any;
+    getCurrentPano(): any;
+    getPreviousPano(): any;
+    mostNearPano(position: any): any;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+import OrientedImageMaterial from '../Renderer/OrientedImageMaterial';

package/lib/Layer/PointCloudLayer.d.ts

@@ -0,0 +1,103 @@
+export default PointCloudLayer;
+/**
+ * The basis for all point clouds related layers.
+ *
+ * @property {boolean} isPointCloudLayer - Used to checkout whether this layer
+ * is a PointCloudLayer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ * @property {THREE.Group|THREE.Object3D} group - Contains the created
+ * `THREE.Points` meshes, usually with an instance of a `THREE.Points` per node.
+ * @property {THREE.Group|THREE.Object3D} bboxes - Contains the bounding boxes
+ * (`THREE.Box3`) of the tree, usually one per node.
+ * @property {number} octreeDepthLimit - The depth limit at which to stop
+ * browsing the octree. Can be used to limit the browsing, without having to
+ * edit manually the source of the point cloud. No limit by default (`-1`).
+ * @property {number} [pointBudget=2000000] - Maximum number of points to
+ * display at the same time. This influences the performance of rendering.
+ * Default to two millions points.
+ * @property {number} [sseThreshold=2] - Threshold of the **S**creen **S**pace
+ * **E**rror. Default to `2`.
+ * @property {number} [pointSize=4] - The size (in pixels) of the points.
+ * Default to `4`.
+ * @property {THREE.Material|PointsMaterial} [material=new PointsMaterial] - The
+ * material to use to display the points of the cloud. Be default it is a new
+ * `PointsMaterial`.
+ * @property {number} [mode=PNTS_MODE.COLOR] - The displaying mode of the points.
+ * Values are specified in `PointsMaterial`.
+ * @property {number} [minIntensityRange=0] - The minimal intensity of the
+ * layer. Changing this value will affect the material, if it has the
+ * corresponding uniform. The value is normalized between 0 and 1.
+ * @property {number} [maxIntensityRange=1] - The maximal intensity of the
+ * layer. Changing this value will affect the material, if it has the
+ * corresponding uniform. The value is normalized between 0 and 1.
+ *
+ * @extends GeometryLayer
+ */
+declare class PointCloudLayer extends GeometryLayer {
+    /**
+     * Constructs a new instance of point cloud layer.
+     * Constructs a new instance of a Point Cloud Layer. This should not be used
+     * directly, but rather implemented using `extends`.
+     *
+     * @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.
+     * @param {Object} [config] - Optional configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name. See the list of properties to know which one can be specified.
+     * @param {Source} config.source - Description and options of the source See @Layer.
+     * @param {number}  [options.minElevationRange] - Min value for the elevation range (default value will be taken from the source.metadata).
+     * @param {number}  [options.maxElevationRange] - Max value for the elevation range (default value will be taken from the source.metadata).
+     */
+    constructor(id: string, config?: {
+        source: Source;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isPointCloudLayer: boolean;
+    protocol: string;
+    group: any;
+    bboxes: any;
+    /**
+     * @type {number}
+     */
+    octreeDepthLimit: number;
+    /**
+     * @type {number}
+     */
+    pointBudget: number;
+    /**
+     * @type {number}
+     */
+    pointSize: number;
+    /**
+     * @type {number}
+     */
+    sseThreshold: number;
+    /**
+     * @type {THREE.Material}
+     */
+    material: THREE.Material;
+    mode: any;
+    /**
+     * @type {PointCloudNode | undefined}
+     */
+    root: PointCloudNode | undefined;
+    preUpdate(context: any, changeSources: any): any[];
+    update(context: any, layer: any, elt: any): any;
+    displayedCount: number | undefined;
+    pickObjectsAt(view: any, mouse: any, radius: any, target?: any[]): any[] | undefined;
+    getObjectToUpdateForAttachedLayers(meta: any): {
+        element: any;
+        parent: any;
+    } | {
+        element: any;
+        parent?: undefined;
+    } | undefined;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+import * as THREE from 'three';

package/lib/Layer/PointCloudLayer.js

@@ -220,7 +220,7 @@ class PointCloudLayer extends GeometryLayer {
     if (this.material) {
       this.material.visible = this.visible;
       this.material.opacity = this.opacity;
-      this.material.transparent = this.opacity < 1 || this.material.userData.needTransparency[this.material.mode];
+      this.material.depthWrite = false;
       this.material.size = this.pointSize;
       this.material.scale = context.camera.preSSE;
       if (this.material.updateUniforms) {

package/lib/Layer/Potree2Layer.d.ts

@@ -0,0 +1,56 @@
+export default Potree2Layer;
+/**
+ * @property {boolean} isPotreeLayer - Used to checkout whether this layer
+ * is a Potree2Layer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ *
+ * @extends PointCloudLayer
+ */
+declare class Potree2Layer extends PointCloudLayer {
+    /**
+     * Constructs a new instance of Potree2 layer.
+     *
+     * @example
+     * // Create a new point cloud layer
+     * const points = new Potree2Layer('points',
+     *  {
+     *      source: new Potree2Source({
+     *          url: 'https://pointsClouds/',
+     *          file: 'metadata.json',
+     *      }
+     *  });
+     *
+     * View.prototype.addLayer.call(view, points);
+     *
+     * @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.
+     * @param {Object} config - Configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name. See the list of properties to know which one can be specified.
+     * @param {string} [config.crs=ESPG:4326] - The CRS of the {@link View} this
+     * layer will be attached to. This is used to determine the extent of this
+     * layer.  Default to `EPSG:4326`.
+     */
+    constructor(id: string, config: {
+        crs?: string | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isPotreeLayer: boolean;
+    scale: THREE.Vector3;
+    metadata: any;
+    pointAttributes: Potree2PointAttributes;
+    spacing: any;
+    minElevationRange: any;
+    maxElevationRange: any;
+    extent: Extent;
+}
+import PointCloudLayer from '../Layer/PointCloudLayer';
+import * as THREE from 'three';
+import { Potree2PointAttributes } from '../Core/Potree2PointAttributes';
+import { Extent } from '@itowns/geographic';

package/lib/Layer/PotreeLayer.d.ts

@@ -0,0 +1,55 @@
+export default PotreeLayer;
+/**
+ * @property {boolean} isPotreeLayer - Used to checkout whether this layer
+ * is a PotreeLayer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ *
+ * @extends PointCloudLayer
+ */
+declare class PotreeLayer extends PointCloudLayer {
+    /**
+     * Constructs a new instance of Potree layer.
+     *
+     * @example
+     * // Create a new point cloud layer
+     * const points = new PotreeLayer('points',
+     *  {
+     *      source: new PotreeLayer({
+     *          url: 'https://pointsClouds/',
+     *          file: 'points.js',
+     *      }
+     *  });
+     *
+     * View.prototype.addLayer.call(view, points);
+     *
+     * @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.
+     * @param {Object} config - Configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name. See the list of properties to know which one can be specified.
+     * @param {string} [config.crs='ESPG:4326'] - The CRS of the {@link View} this
+     * layer will be attached to. This is used to determine the extent of this
+     * layer.  Default to `EPSG:4326`.
+     */
+    constructor(id: string, config: {
+        crs?: string | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isPotreeLayer: boolean;
+    scale: THREE.Vector3;
+    spacing: any;
+    hierarchyStepSize: any;
+    supportsProgressiveDisplay: boolean;
+    minElevationRange: any;
+    maxElevationRange: any;
+    extent: Extent;
+}
+import PointCloudLayer from '../Layer/PointCloudLayer';
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';

package/lib/Layer/RasterLayer.d.ts

@@ -0,0 +1,8 @@
+export default RasterLayer;
+declare class RasterLayer extends Layer {
+    constructor(id: any, config: any);
+    minFilter: any;
+    magFilter: any;
+    convert(data: any, extentDestination: any): any;
+}
+import Layer from '../Layer/Layer';

package/lib/Layer/RasterLayer.js

@@ -1,5 +1,5 @@
 import Layer from "./Layer.js";
-import { removeLayeredMaterialNodeLayer } from "../Process/LayeredMaterialNodeProcessing.js";
+import { removeLayeredMaterialNodeTile } from "../Process/LayeredMaterialNodeProcessing.js";
 import textureConverter from "../Converter/textureConverter.js";
 import { CACHE_POLICIES } from "../Core/Scheduler/Cache.js";
 class RasterLayer extends Layer {
@@ -30,7 +30,7 @@ class RasterLayer extends Layer {
       this.cache.clear();
     }
     for (const root of this.parent.level0Nodes) {
-      root.traverse(removeLayeredMaterialNodeLayer(this.id));
+      root.traverse(removeLayeredMaterialNodeTile(this.id));
     }
   }
 }

package/lib/Layer/ReferencingLayerProperties.d.ts

@@ -0,0 +1,2 @@
+export default ReferLayerProperties;
+declare function ReferLayerProperties(material: any, layer: any): any;

package/lib/Layer/ReferencingLayerProperties.js

@@ -1,8 +1,6 @@
 // next step is move these properties to Style class
-// and hide transparent mechanism
 function ReferLayerProperties(material, layer) {
   if (layer && layer.isGeometryLayer) {
-    let transparent = material.transparent;
     material.layer = layer;
     if (material.uniforms && material.uniforms.opacity != undefined) {
       Object.defineProperty(material.uniforms.opacity, 'value', {
@@ -46,16 +44,6 @@ function ReferLayerProperties(material, layer) {
     Object.defineProperty(material, 'wireframe', {
       get: () => material.layer.wireframe
     });
-    Object.defineProperty(material, 'transparent', {
-      get: () => {
-        const needTransparency = material.userData.needTransparency?.[material.mode] || material.layer.opacity < 1.0;
-        if (transparent != needTransparency) {
-          material.needsUpdate = true;
-          transparent = needTransparency;
-        }
-        return transparent;
-      }
-    });
   }
   return material;
 }

package/lib/Layer/TiledGeometryLayer.d.ts

@@ -0,0 +1,192 @@
+export default TiledGeometryLayer;
+/**
+ * @property {InfoTiledGeometryLayer} info - Status information of layer
+ * @property {boolean} isTiledGeometryLayer - Used to checkout whether this
+ * layer is a TiledGeometryLayer. Default is true. You should not change this,
+ * as it is used internally for optimisation.
+ * @property {boolean} hideSkirt (default false) - Used to hide the skirt (tile borders).
+ * Useful when the layer opacity < 1
+ *
+ * @extends GeometryLayer
+ */
+declare class TiledGeometryLayer extends GeometryLayer {
+    /**
+     * Tell if a node has enough elevation or color textures to subdivide.
+     * Subdivision is prevented if:
+     * <ul>
+     *  <li>the node is covered by at least one elevation layer and if the node
+     *  doesn't have an elevation texture yet</li>
+     *  <li>a color texture is missing</li>
+     * </ul>
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {TileMesh} node - The node to subdivide.
+     *
+     * @returns {boolean} False if the node can not be subdivided, true
+     * otherwise.
+     */
+    static hasEnoughTexturesToSubdivide(context: Object, node: TileMesh): boolean;
+    /**
+     * A layer extending the {@link GeometryLayer}, but with a tiling notion.
+     *
+     * `TiledGeometryLayer` is the ground where `ColorLayer` and `ElevationLayer` are attached.
+     * `TiledGeometryLayer` is a quadtree data structure. At zoom 0,
+     * there is a single tile for the whole earth. At zoom level 1,
+     * the single tile splits into 4 tiles (2x2 tile square).
+     * Each zoom level quadtree divides the geometry tiles of the one before it.
+     * The camera distance determines how the tiles are subdivided for optimal data display.
+     *
+     * Some `GeometryLayer` can also be attached to the `TiledGeometryLayer` if they want to take advantage of the quadtree.
+     *
+     * ![tiled geometry](/docs/static/images/tiledGeometry.jpeg)
+     * _In `GlobeView`, **red lines** represents the **WGS84 grid** and **orange lines** the **Pseudo-mercator grid**._
+     * _In this picture, there are tiles with 3 different zoom/levels._
+     *
+     * The zoom/level is based on [tiled web map](https://en.wikipedia.org/wiki/Tiled_web_map).
+     * It corresponds at meters by pixel. If the projection tile exceeds a certain pixel size (on screen)
+     * then it is subdivided into 4 tiles with a zoom greater than 1.
+     *
+     * @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.
+     * @param {THREE.Object3D} object3d - The object3d used to contain the
+     * geometry of the TiledGeometryLayer. It is usually a `THREE.Group`, but it
+     * can be anything inheriting from a `THREE.Object3d`.
+     * @param {Array} schemeTile - extents Array of root tiles
+     * @param {Object} builder - builder geometry object
+     * @param {Object} [config] - Optional configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name.
+     * @param {Source} [config.source] - Description and options of the source.
+     *
+     * @throws {Error} `object3d` must be a valid `THREE.Object3d`.
+     */
+    constructor(id: string, object3d: THREE.Object3D, schemeTile: any[], builder: Object, config?: {
+        source?: any;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isTiledGeometryLayer: boolean;
+    protocol: string;
+    /**
+     * @type {boolean}
+     */
+    disableSkirt: boolean;
+    _hideSkirt: boolean;
+    /**
+     * @type {number}
+     */
+    sseSubdivisionThreshold: number;
+    /**
+     * @type {number}
+     */
+    minSubdivisionLevel: number;
+    /**
+     * @type {number}
+     */
+    maxSubdivisionLevel: number;
+    /**
+     * @type {number}
+     * @deprecated
+     */
+    maxDeltaElevationLevel: number;
+    segments: any;
+    schemeTile: any[];
+    builder: Object;
+    info: InfoTiledGeometryLayer;
+    maxScreenSizeNode: number;
+    tileMatrixSets: any;
+    materialOptions: any;
+    showOutline: any;
+    /**
+     * @type {THREE.Vector3 | undefined}
+     */
+    diffuse: THREE.Vector3 | undefined;
+    level0Nodes: any[];
+    set hideSkirt(value: boolean);
+    get hideSkirt(): boolean;
+    /**
+     * Does pre-update work on the context:
+     * <ul>
+     *  <li>update the `colorLayers` and `elevationLayers`</li>
+     *  <li>update the `maxElevationLevel`</li>
+     * </ul>
+     *
+     * Once this work is done, it returns a list of nodes to update. Depending
+     * on the origin of `sources`, it can return a few things:
+     * <ul>
+     *  <li>if `sources` is empty, it returns the first node of the layer
+     *  (stored as `level0Nodes`), which will trigger the update of the whole
+     *  tree</li>
+     *  <li>if the update is triggered by a camera move, the whole tree is
+     *  returned too</li>
+     *  <li>if `source.layer` is this layer, it means that `source` is a node; a
+     *  common ancestor will be found if there are multiple sources, with the
+     *  default common ancestor being the first source itself</li>
+     *  <li>else it returns the whole tree</li>
+     * </ul>
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {Set<GeometryLayer|TileMesh>} sources - A list of sources to
+     * generate a list of nodes to update.
+     *
+     * @return {TileMesh[]} The array of nodes to update.
+     */
+    preUpdate(context: Object, sources: Set<GeometryLayer | TileMesh>): TileMesh[];
+    _latestUpdateStartingLevel: any;
+    colorLayersOrder: any[] | undefined;
+    /**
+     * Update a node of this layer. The node will not be updated if:
+     * <ul>
+     *  <li>it does not have a parent, then it is removed</li>
+     *  <li>its parent is being subdivided</li>
+     *  <li>is not visible in the camera</li>
+     * </ul>
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {Layer} layer - Parameter to be removed once all update methods
+     * have been aligned.
+     * @param {TileMesh} node - The node to update.
+     *
+     * @returns {Object}
+     */
+    update(context: Object, layer: Layer, node: TileMesh): Object;
+    convert(requester: any, extent: any): Promise<import("../Core/TileMesh").default>;
+    countColorLayersTextures(...layers: any[]): number;
+    culling(node: any, camera: any): boolean;
+    /**
+     * Subdivides a node of this layer. If the node is currently in the process
+     * of subdivision, it will not do anything here. The subdivision of a node
+     * will occur in four part, to create a quadtree. The extent of the node
+     * will be divided in four parts: north-west, north-east, south-west and
+     * south-east. Once all four nodes are created, they will be added to the
+     * current node and the view of the context will be notified of this change.
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {TileMesh} node - The node to subdivide.
+     * @return {Promise}  { description_of_the_return_value }
+     */
+    subdivideNode(context: Object, node: TileMesh): Promise<any>;
+    /**
+     * Test the subdvision of a node, compared to this layer.
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {PlanarLayer} layer - This layer, parameter to be removed.
+     * @param {TileMesh} node - The node to test.
+     *
+     * @return {boolean} - True if the node is subdivisable, otherwise false.
+     */
+    subdivision(context: Object, layer: PlanarLayer, node: TileMesh): boolean;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+import { InfoTiledGeometryLayer } from '../Layer/InfoLayer';
+import * as THREE from 'three';

package/lib/Layer/TiledGeometryLayer.js

@@ -68,7 +68,7 @@ class TiledGeometryLayer extends GeometryLayer {
       showOutline = false,
       segments,
       disableSkirt = false,
-      materialOptions,
+      materialOptions = {},
       ...configGeometryLayer
     } = config;
     super(id, object3d, {
@@ -126,6 +126,7 @@ class TiledGeometryLayer extends GeometryLayer {
     }
     this.maxScreenSizeNode = this.sseSubdivisionThreshold * (this.sizeDiagonalTexture * 2);
     this.tileMatrixSets = tileMatrixSets;
+    materialOptions.transparent = materialOptions.transparent ?? true;
     this.materialOptions = materialOptions;
 
     /*
@@ -340,7 +341,7 @@ class TiledGeometryLayer extends GeometryLayer {
    */
   static hasEnoughTexturesToSubdivide(context, node) {
     const layerUpdateState = node.layerUpdateState || {};
-    let nodeLayer = node.material.getElevationLayer();
+    let nodeLayer = node.material.getElevationTile();
     for (const e of context.elevationLayers) {
       const extents = node.getExtentsByProjection(e.crs);
       const zoom = extents[0].zoom;
@@ -368,7 +369,7 @@ class TiledGeometryLayer extends GeometryLayer {
       if (layerUpdateState[c.id] && layerUpdateState[c.id].inError()) {
         continue;
       }
-      nodeLayer = node.material.getLayer(c.id);
+      nodeLayer = node.material.getColorTile(c.id);
       if (c.source.extentInsideLimit(node.extent, zoom) && (!nodeLayer || nodeLayer.level < 0)) {
         return false;
       }

package/lib/Main.d.ts

@@ -0,0 +1,89 @@
+export const REVISION: string;
+export { default as GeoidGrid } from "./Core/Geographic/GeoidGrid";
+export { default as PlanarView } from "./Core/Prefab/PlanarView";
+export { default as Fetcher } from "./Provider/Fetcher";
+export { MAIN_LOOP_EVENTS } from "./Core/MainLoop";
+export { default as FeatureProcessing } from "./Process/FeatureProcessing";
+export { default as ObjectRemovalHelper } from "./Process/ObjectRemovalHelper";
+export { default as OrientedImageCamera } from "./Renderer/OrientedImageCamera";
+export { default as FlyControls } from "./Controls/FlyControls";
+export { default as FirstPersonControls } from "./Controls/FirstPersonControls";
+export { default as StreetControls } from "./Controls/StreetControls";
+export { default as VRControls } from "./Controls/VRControls";
+export { VR_EVENTS } from "./Renderer/WebXR";
+export { default as Feature2Mesh } from "./Converter/Feature2Mesh";
+export { default as FeaturesUtils } from "./Utils/FeaturesUtils";
+export { default as DEMUtils } from "./Utils/DEMUtils";
+export { default as CameraUtils } from "./Utils/CameraUtils";
+export { default as ShaderChunk } from "./Renderer/Shader/ShaderChunk";
+export { default as Capabilities } from "./Core/System/Capabilities";
+export { CAMERA_TYPE } from "./Renderer/Camera";
+export { default as OBB } from "./Renderer/OBB";
+export { default as Style } from "./Core/Style";
+export { default as Label } from "./Core/Label";
+export { default as ColorLayer } from "./Layer/ColorLayer";
+export { default as ElevationLayer } from "./Layer/ElevationLayer";
+export { default as GeometryLayer } from "./Layer/GeometryLayer";
+export { default as FeatureGeometryLayer } from "./Layer/FeatureGeometryLayer";
+export { default as PointCloudLayer } from "./Layer/PointCloudLayer";
+export { default as PotreeLayer } from "./Layer/PotreeLayer";
+export { default as Potree2Layer } from "./Layer/Potree2Layer";
+export { default as TiledGeometryLayer } from "./Layer/TiledGeometryLayer";
+export { default as OrientedImageLayer } from "./Layer/OrientedImageLayer";
+export { default as ColorLayersOrdering } from "./Renderer/ColorLayersOrdering";
+export { default as GlobeLayer } from "./Core/Prefab/Globe/GlobeLayer";
+export { default as PlanarLayer } from "./Core/Prefab/Planar/PlanarLayer";
+export { default as LabelLayer } from "./Layer/LabelLayer";
+export { default as EntwinePointTileLayer } from "./Layer/EntwinePointTileLayer";
+export { default as CopcLayer } from "./Layer/CopcLayer";
+export { default as GeoidLayer } from "./Layer/GeoidLayer";
+export { default as Source } from "./Source/Source";
+export { default as FileSource } from "./Source/FileSource";
+export { default as TMSSource } from "./Source/TMSSource";
+export { default as WFSSource } from "./Source/WFSSource";
+export { default as WMSSource } from "./Source/WMSSource";
+export { default as WMTSSource } from "./Source/WMTSSource";
+export { default as VectorTilesSource } from "./Source/VectorTilesSource";
+export { default as OrientedImageSource } from "./Source/OrientedImageSource";
+export { default as PotreeSource } from "./Source/PotreeSource";
+export { default as Potree2Source } from "./Source/Potree2Source";
+export { default as C3DTilesSource } from "./Source/C3DTilesSource";
+export { default as C3DTilesIonSource } from "./Source/C3DTilesIonSource";
+export { default as C3DTilesGoogleSource } from "./Source/C3DTilesGoogleSource";
+export { default as OGC3DTilesSource } from "./Source/OGC3DTilesSource";
+export { default as OGC3DTilesIonSource } from "./Source/OGC3DTilesIonSource";
+export { default as OGC3DTilesGoogleSource } from "./Source/OGC3DTilesGoogleSource";
+export { default as EntwinePointTileSource } from "./Source/EntwinePointTileSource";
+export { default as CopcSource } from "./Source/CopcSource";
+export { default as GpxParser } from "./Parser/GpxParser";
+export { default as GeoJsonParser } from "./Parser/GeoJsonParser";
+export { default as KMLParser } from "./Parser/KMLParser";
+export { default as CameraCalibrationParser } from "./Parser/CameraCalibrationParser";
+export { default as ShapefileParser } from "./Parser/ShapefileParser";
+export { default as LASParser } from "./Parser/LASParser";
+export { default as ISGParser } from "./Parser/ISGParser";
+export { default as GDFParser } from "./Parser/GDFParser";
+export { default as GTXParser } from "./Parser/GTXParser";
+export { default as B3dmParser } from "./Parser/B3dmParser";
+export { default as iGLTFLoader } from "./Parser/iGLTFLoader";
+export { default as C3DTFeature } from "./Core/3DTiles/C3DTFeature";
+export { default as C3DTileset } from "./Core/3DTiles/C3DTileset";
+export { default as C3DTBoundingVolume } from "./Core/3DTiles/C3DTBoundingVolume";
+export { default as C3DTBatchTable } from "./Core/3DTiles/C3DTBatchTable";
+export { default as C3DTExtensions } from "./Core/3DTiles/C3DTExtensions";
+export { default as C3DTBatchTableHierarchyExtension } from "./Core/3DTiles/C3DTBatchTableHierarchyExtension";
+export { Coordinates, Extent, CRS, Ellipsoid, ellipsoidSizes, OrientationUtils } from "@itowns/geographic";
+export { default as GlobeView, GLOBE_VIEW_EVENTS } from "./Core/Prefab/GlobeView";
+export { default as View, VIEW_EVENTS } from "./Core/View";
+export { updateLayeredMaterialNodeImagery, updateLayeredMaterialNodeElevation } from "./Process/LayeredMaterialNodeProcessing";
+export { default as PointsMaterial, PNTS_MODE, PNTS_SHAPE, PNTS_SIZE_MODE, ClassificationScheme } from "./Renderer/PointsMaterial";
+export { default as GlobeControls, CONTROL_EVENTS } from "./Controls/GlobeControls";
+export { default as PlanarControls, PLANAR_CONTROL_EVENT } from "./Controls/PlanarControls";
+export { getMaxColorSamplerUnitsCount, colorLayerEffects } from "./Renderer/LayeredMaterial";
+export { default as Feature, FeatureCollection, FeatureGeometry, FEATURE_TYPES } from "./Core/Feature";
+export { default as Layer, ImageryLayers } from "./Layer/Layer";
+export { default as C3DTilesLayer, C3DTILES_LAYER_EVENTS } from "./Layer/C3DTilesLayer";
+export { default as OGC3DTilesLayer, OGC3DTILES_LAYER_EVENTS, enableDracoLoader, enableKtx2Loader, enableMeshoptDecoder } from "./Layer/OGC3DTilesLayer";
+export { STRATEGY_MIN_NETWORK_TRAFFIC, STRATEGY_GROUP, STRATEGY_PROGRESSIVE, STRATEGY_DICHOTOMY } from "./Layer/LayerUpdateStrategy";
+export { C3DTilesTypes, C3DTilesBoundingVolumeTypes } from "./Core/3DTiles/C3DTilesEnums";
+export { process3dTilesNode, $3dTilesCulling, $3dTilesSubdivisionControl } from "./Process/3dTilesProcessing";

package/lib/Main.js

@@ -1,5 +1,5 @@
 const conf = {
-  version: '2.45.1'
+  version: '2.45.2-next.0'
 };
 export const REVISION = conf.version;
 
@@ -22,6 +22,8 @@ export { default as FlyControls } from "./Controls/FlyControls.js";
 export { default as FirstPersonControls } from "./Controls/FirstPersonControls.js";
 export { default as StreetControls } from "./Controls/StreetControls.js";
 export { default as PlanarControls } from "./Controls/PlanarControls.js";
+export { default as VRControls } from "./Controls/VRControls.js";
+export { VR_EVENTS } from "./Renderer/WebXR.js";
 export { CONTROL_EVENTS } from "./Controls/GlobeControls.js";
 export { PLANAR_CONTROL_EVENT } from "./Controls/PlanarControls.js";
 export { default as Feature2Mesh } from "./Converter/Feature2Mesh.js";