itowns 2.45.1 → 2.45.2-next.0

package/lib/Core/Potree2PointAttributes.d.ts

@@ -0,0 +1,97 @@
+export class Potree2PointAttributes {
+    attributes: any[];
+    byteSize: number;
+    size: number;
+    vectors: any[];
+    add(pointAttribute: any): void;
+    addVector(vector: any): void;
+    hasNormals(): boolean;
+}
+export namespace PointAttributeTypes {
+    namespace DATA_TYPE_DOUBLE {
+        let name: string;
+        let size: number;
+    }
+    namespace DATA_TYPE_FLOAT {
+        let name_1: string;
+        export { name_1 as name };
+        let size_1: number;
+        export { size_1 as size };
+    }
+    namespace DATA_TYPE_INT8 {
+        let name_2: string;
+        export { name_2 as name };
+        let size_2: number;
+        export { size_2 as size };
+    }
+    namespace DATA_TYPE_UINT8 {
+        let name_3: string;
+        export { name_3 as name };
+        let size_3: number;
+        export { size_3 as size };
+    }
+    namespace DATA_TYPE_INT16 {
+        let name_4: string;
+        export { name_4 as name };
+        let size_4: number;
+        export { size_4 as size };
+    }
+    namespace DATA_TYPE_UINT16 {
+        let name_5: string;
+        export { name_5 as name };
+        let size_5: number;
+        export { size_5 as size };
+    }
+    namespace DATA_TYPE_INT32 {
+        let name_6: string;
+        export { name_6 as name };
+        let size_6: number;
+        export { size_6 as size };
+    }
+    namespace DATA_TYPE_UINT32 {
+        let name_7: string;
+        export { name_7 as name };
+        let size_7: number;
+        export { size_7 as size };
+    }
+    namespace DATA_TYPE_INT64 {
+        let name_8: string;
+        export { name_8 as name };
+        let size_8: number;
+        export { size_8 as size };
+    }
+    namespace DATA_TYPE_UINT64 {
+        let name_9: string;
+        export { name_9 as name };
+        let size_9: number;
+        export { size_9 as size };
+    }
+}
+export class PointAttribute {
+    constructor(name: any, type: any, numElements: any);
+    name: any;
+    type: any;
+    numElements: any;
+    byteSize: number;
+    description: string;
+    range: number[];
+}
+export namespace PointAttribute {
+    export let POSITION_CARTESIAN: PointAttribute;
+    export let RGBA_PACKED: PointAttribute;
+    import COLOR_PACKED = RGBA_PACKED;
+    export { COLOR_PACKED };
+    export let RGB_PACKED: PointAttribute;
+    export let NORMAL_FLOATS: PointAttribute;
+    export let INTENSITY: PointAttribute;
+    export let CLASSIFICATION: PointAttribute;
+    export let NORMAL_SPHEREMAPPED: PointAttribute;
+    export let NORMAL_OCT16: PointAttribute;
+    export let NORMAL: PointAttribute;
+    export let RETURN_NUMBER: PointAttribute;
+    export let NUMBER_OF_RETURNS: PointAttribute;
+    export let SOURCE_ID: PointAttribute;
+    export let INDICES: PointAttribute;
+    export let SPACING: PointAttribute;
+    export let GPS_TIME: PointAttribute;
+}

package/lib/Core/PotreeNode.d.ts

@@ -0,0 +1,13 @@
+export default PotreeNode;
+declare class PotreeNode extends PointCloudNode {
+    constructor(numPoints: number | undefined, childrenBitField: number | undefined, layer: any);
+    childrenBitField: number;
+    id: string;
+    depth: number;
+    baseurl: any;
+    get octreeIsLoaded(): boolean;
+    get url(): string;
+    createChildAABB(node: any, childIndex: any): void;
+    loadOctree(): any;
+}
+import PointCloudNode from '../Core/PointCloudNode';

package/lib/Core/PotreeNode.js

@@ -16,15 +16,16 @@ class PotreeNode extends PointCloudNode {
     this.depth = 0;
     this.baseurl = layer.source.baseurl;
   }
-  add(node, indexChild, root) {
-    super.add(node, indexChild);
+  get octreeIsLoaded() {
+    return !(this.childrenBitField && this.children.length === 0);
+  }
+  get url() {
+    return `${this.baseurl}/r${this.id}.${this.layer.source.extension}`;
+  }
+  add(node, indexChild) {
     node.id = this.id + indexChild;
-    node.depth = node.id.length;
-    if (node.id.length % this.layer.hierarchyStepSize == 0) {
-      node.baseurl = `${root.baseurl}/${node.id.substr(root.id.length)}`;
-    } else {
-      node.baseurl = root.baseurl;
-    }
+    node.depth = this.depth + 1;
+    super.add(node, indexChild);
   }
   createChildAABB(node, childIndex) {
     // Code inspired from potree
@@ -62,12 +63,6 @@ class PotreeNode extends PointCloudNode {
       node.bbox.max.x += dHalfLength.x;
     }
   }
-  get octreeIsLoaded() {
-    return !(this.childrenBitField && this.children.length === 0);
-  }
-  get url() {
-    return `${this.baseurl}/r${this.id}.${this.layer.source.extension}`;
-  }
   loadOctree() {
     const octreeUrl = `${this.baseurl}/r${this.id}.${this.layer.source.extensionOctree}`;
     return this.layer.source.fetcher(octreeUrl, this.layer.source.networkOptions).then(blob => {
@@ -89,9 +84,14 @@ class PotreeNode extends PointCloudNode {
             offset += 1;
             const numPoints = view.getUint32(offset, true) || this.numPoints;
             offset += 4;
-            const item = new PotreeNode(numPoints, childrenBitField, this.layer);
-            snode.add(item, indexChild, this);
-            stack.push(item);
+            const child = new PotreeNode(numPoints, childrenBitField, this.layer);
+            snode.add(child, indexChild);
+            if (child.id.length % this.layer.hierarchyStepSize == 0) {
+              child.baseurl = `${this.baseurl}/${child.id}`;
+            } else {
+              child.baseurl = this.baseurl;
+            }
+            stack.push(child);
           }
         }
       }

package/lib/Core/Prefab/Globe/Atmosphere.d.ts

@@ -0,0 +1,66 @@
+export default Atmosphere;
+/**
+ * @extends GeometryLayer
+ */
+declare class Atmosphere extends GeometryLayer {
+    /**
+    * It's layer to simulate Globe atmosphere.
+    * There's 2 modes : simple and realistic (atmospheric-scattering).
+     *
+    * The atmospheric-scattering it is taken from :
+    * * [Atmosphere Shader From Space (Atmospheric scattering)](http://stainlessbeer.weebly.com/planets-9-atmospheric-scattering.html)
+    * * [Accurate Atmospheric Scattering (NVIDIA GPU Gems 2)](https://developer.nvidia.com/gpugems/gpugems2/part-ii-shading-lighting-and-shadows/chapter-16-accurate-atmospheric-scattering).
+    *
+    * @param {string} id - The id of the layer Atmosphere.
+    * @param {Object} [options] - options layer.
+    * @param {number} [options.Kr] - `Kr` is the rayleigh scattering constant.
+    * @param {number} [options.Km] - `Km` is the Mie scattering constant.
+    * @param {number} [options.ESun] - `ESun` is the brightness of the sun.
+    * @param {number} [options.g] - constant `g` that affects the symmetry of the scattering.
+    * @param {number} [options.innerRadius] - The inner (planetary) radius
+    * @param {number} [options.outerRadius] - The outer (Atmosphere) radius
+    * @param {number[]} [options.wavelength] - The constant is the `wavelength` (or color) of light.
+    * @param {number} [options.scaleDepth] - The `scale depth` (i.e. the altitude at which the atmosphere's average density is found).
+    * @param {number} [options.mieScaleDepth] - not used.
+    */
+    constructor(id?: string, options?: {
+        Kr?: number | undefined;
+        Km?: number | undefined;
+        ESun?: number | undefined;
+        g?: number | undefined;
+        innerRadius?: number | undefined;
+        outerRadius?: number | undefined;
+        wavelength?: number[] | undefined;
+        scaleDepth?: number | undefined;
+        mieScaleDepth?: number | undefined;
+    });
+    isAtmosphere: boolean;
+    basicAtmosphere: THREE.Object3D<THREE.Object3DEventMap>;
+    realisticAtmosphere: THREE.Object3D<THREE.Object3DEventMap>;
+    realisticLightingPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    fog: {
+        enable: boolean;
+        distance: number;
+    };
+    realisticAtmosphereInitParams: {
+        Kr?: number | undefined;
+        Km?: number | undefined;
+        ESun?: number | undefined;
+        g?: number | undefined;
+        innerRadius?: number | undefined;
+        outerRadius?: number | undefined;
+        wavelength?: number[] | undefined;
+        scaleDepth?: number | undefined;
+        mieScaleDepth?: number | undefined;
+    };
+    update(context: any, layer: any, node: any): void;
+    preUpdate(context: any, srcs: any): void;
+    _initRealisticLighning(): void;
+    setRealisticOn(bool: any): void;
+}
+import GeometryLayer from '../../../Layer/GeometryLayer';
+import * as THREE from 'three';

package/lib/Core/Prefab/Globe/Atmosphere.js

@@ -75,6 +75,7 @@ class Atmosphere extends GeometryLayer {
     const sphereGeometry = new THREE.SphereGeometry(1, 64, 64);
     const basicAtmosphereOut = new THREE.Mesh(sphereGeometry, material);
     basicAtmosphereOut.scale.copy(ellipsoidSizes).multiplyScalar(1.14);
+    basicAtmosphereOut.renderOrder = 1;
     this.basicAtmosphere = new THREE.Object3D();
     this.realisticAtmosphere = new THREE.Object3D();
     this.realisticAtmosphere.visible = false;
@@ -101,6 +102,7 @@ class Atmosphere extends GeometryLayer {
     });
     const basicAtmosphereIn = new THREE.Mesh(sphereGeometry, materialAtmoIn);
     basicAtmosphereIn.scale.copy(ellipsoidSizes).multiplyScalar(1.002);
+    basicAtmosphereIn.renderOrder = 2;
     this.basicAtmosphere.add(basicAtmosphereIn);
     this.realisticLightingPosition = {
       x: -0.5,
@@ -130,9 +132,9 @@ class Atmosphere extends GeometryLayer {
   }
   update(context, layer, node) {
     // update uniforms
-    node.material.fogDistance = this.fog.distance;
-    node.material.lightingEnabled = this.realisticAtmosphere.visible;
-    node.material.lightPosition = this.realisticLightingPosition;
+    node.material.setUniform('fogDistance', this.fog.distance);
+    node.material.setUniform('lightingEnabled', this.realisticAtmosphere.visible);
+    node.material.setUniform('lightPosition', this.realisticLightingPosition);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -245,6 +247,7 @@ class Atmosphere extends GeometryLayer {
       depthWrite: false
     });
     const ground = new THREE.Mesh(geometryAtmosphereIn, materialAtmosphereIn);
+    ground.renderOrder = 2;
     const geometryAtmosphereOut = new THREE.SphereGeometry(atmosphere.outerRadius, 196, 196);
     const materialAtmosphereOut = new THREE.ShaderMaterial({
       uniforms: uniformsAtmosphere,
@@ -254,7 +257,9 @@ class Atmosphere extends GeometryLayer {
       side: THREE.BackSide
     });
     const sky = new THREE.Mesh(geometryAtmosphereOut, materialAtmosphereOut);
+    sky.renderOrder = 1;
     const skyDome = new Sky();
+    skyDome.renderOrder = 1;
     skyDome.frustumCulled = false;
     this.realisticAtmosphere.add(ground);
     this.realisticAtmosphere.add(sky);
@@ -264,7 +269,7 @@ class Atmosphere extends GeometryLayer {
       reileigh: 2,
       mieCoefficient: 0.005,
       mieDirectionalG: 0.8,
-      luminance: 1,
+      luminanceAtmosphere: 1,
       inclination: 0.49,
       // elevation / inclination
       azimuth: 0.25,
@@ -273,7 +278,7 @@ class Atmosphere extends GeometryLayer {
     };
     skyDome.material.uniforms.turbidity.value = effectController.turbidity;
     skyDome.material.uniforms.reileigh.value = effectController.reileigh;
-    skyDome.material.uniforms.luminance.value = effectController.luminance;
+    skyDome.material.uniforms.luminanceAtmosphere.value = effectController.luminanceAtmosphere;
     skyDome.material.uniforms.mieCoefficient.value = effectController.mieCoefficient;
     skyDome.material.uniforms.mieDirectionalG.value = effectController.mieDirectionalG;
     skyDome.material.uniforms.up.value = new THREE.Vector3(); // no more necessary, estimate normal from cam..

package/lib/Core/Prefab/Globe/GlobeLayer.d.ts

@@ -0,0 +1,48 @@
+export default GlobeLayer;
+/**
+ * @property {boolean} isGlobeLayer - Used to checkout whether this layer is a
+ * GlobeLayer. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ *
+ * @extends TiledGeometryLayer
+ */
+declare class GlobeLayer extends TiledGeometryLayer {
+    static horizonCulling(point: any): boolean;
+    /**
+     * A {@link TiledGeometryLayer} to use with a {@link GlobeView}. It has
+     * specific method for updating and subdivising its grid.
+     *
+     * @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=THREE.Group] - 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 {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 {number} [config.minSubdivisionLevel=2] - Minimum subdivision
+     * level for this tiled layer.
+     * @param {number} [config.maxSubdivisionLevel=18] - Maximum subdivision
+     * level for this tiled layer.
+     * @param {number} [config.sseSubdivisionThreshold=1] - Threshold level for
+     * the SSE.
+     *
+     * @throws {Error} `object3d` must be a valid `THREE.Object3d`.
+     */
+    constructor(id: string, object3d?: THREE.Object3D, config?: {
+        minSubdivisionLevel?: number | undefined;
+        maxSubdivisionLevel?: number | undefined;
+        sseSubdivisionThreshold?: number | undefined;
+    });
+    isGlobeLayer: boolean;
+    extent: any;
+    preUpdate(context: any, changeSources: any): TileMesh[];
+    subdivision(context: any, layer: any, node: any): boolean;
+    computeTileZoomFromDistanceCamera(distance: any, camera: any): number;
+    computeDistanceCameraFromTileZoom(zoom: any, camera: any): number;
+}
+import TiledGeometryLayer from '../../../Layer/TiledGeometryLayer';
+import * as THREE from 'three';

package/lib/Core/Prefab/Globe/GlobeTileBuilder.d.ts

@@ -0,0 +1,38 @@
+import * as THREE from 'three';
+import { Coordinates, Extent } from '@itowns/geographic';
+import { ShareableExtent, TileBuilder, TileBuilderParams } from '../TileBuilder';
+/** Specialized parameters for the [GlobeTileBuilder]. */
+export interface GlobeTileBuilderParams extends TileBuilderParams {
+    /** Number of rows of tiles, essentially the resolution of the globe. */
+    nbRow: number;
+    /** Offset of the second texture set. */
+    deltaUV1: number;
+    /** Transformation to align a tile's normal to the Z axis. */
+    quatNormalToZ: THREE.Quaternion;
+}
+/**
+ * TileBuilder implementation for the purpose of generating globe (or more
+ * precisely ellipsoidal) tile arrangements.
+ */
+export declare class GlobeTileBuilder implements TileBuilder<GlobeTileBuilderParams> {
+    private static _crs;
+    private static _computeExtraOffset;
+    /**
+     * Buffer holding information about the tile/vertex currently being
+     * processed.
+     */
+    private _transform;
+    computeExtraOffset?: (params: GlobeTileBuilderParams) => number;
+    get crs(): string;
+    constructor(options: {
+        /** Number of unaligned texture sets. */
+        uvCount: number;
+    });
+    prepare(params: TileBuilderParams): GlobeTileBuilderParams;
+    center(extent: Extent): THREE.Vector3;
+    vertexPosition(coordinates: Coordinates): THREE.Vector3;
+    vertexNormal(): THREE.Vector3;
+    uProject(u: number, extent: Extent): number;
+    vProject(v: number, extent: Extent): number;
+    computeShareableExtent(extent: Extent): ShareableExtent;
+}

package/lib/Core/Prefab/Globe/SkyShader.d.ts

@@ -0,0 +1,5 @@
+export default Sky;
+declare class Sky extends THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> {
+    constructor();
+}
+import * as THREE from 'three';

package/lib/Core/Prefab/Globe/SkyShader.js

@@ -17,7 +17,7 @@
 import * as THREE from 'three';
 const skyShader = {
   uniforms: {
-    luminance: {
+    luminanceAtmosphere: {
       type: 'f',
       value: 1
     },
@@ -49,7 +49,7 @@ const skyShader = {
   vertexShader: ['varying vec3 vWorldPosition;', 'void main() {', 'vec4 worldPosition = modelMatrix *  vec4( cameraPosition + position, 1.0 );', 'vWorldPosition = worldPosition.xyz;', 'gl_Position = projectionMatrix * modelViewMatrix * vec4( cameraPosition + position, 1.0 );', '}'].join('\n'),
   fragmentShader: ['uniform sampler2D skySampler;', 'uniform vec3 v3LightPosition;', 'uniform vec3 up;', 'varying vec3 vWorldPosition;',
   // "vec3 cameraPos = cameraPosition; //vec3(0., 0., 0.);",
-  '// uniform sampler2D sDiffuse;', '// const float turbidity = 10.0; //', '// const float reileigh = 2.; //', '// const float luminance = 1.0; //', '// const float mieCoefficient = 0.005;', '// const float mieDirectionalG = 0.8;', 'uniform float luminance;', 'uniform float turbidity;', 'uniform float reileigh;', 'uniform float mieCoefficient;', 'uniform float mieDirectionalG;', '// constants for atmospheric scattering', 'const float e = 2.71828182845904523536028747135266249775724709369995957;', 'const float pi = 3.141592653589793238462643383279502884197169;', 'const float n = 1.0003; // refractive index of air', 'const float N = 2.545E25; // number of molecules per unit volume for air at', '// 288.15K and 1013mb (sea level -45 celsius)', 'const float pn = 0.035; // depolatization factor for standard air', '// wavelength of used primaries, according to preetham', 'const vec3 lambda = vec3(680E-9, 550E-9, 450E-9);', '// mie stuff', '// K coefficient for the primaries', 'const vec3 K = vec3(0.686, 0.678, 0.666);', 'const float v = 4.0;', '// optical length at zenith for molecules', 'const float rayleighZenithLength = 8.4E3;', 'const float mieZenithLength = 1.25E3;',
+  '// uniform sampler2D sDiffuse;', '// const float turbidity = 10.0; //', '// const float reileigh = 2.; //', '// const float luminanceAtmosphere = 1.0; //', '// const float mieCoefficient = 0.005;', '// const float mieDirectionalG = 0.8;', 'uniform float luminanceAtmosphere;', 'uniform float turbidity;', 'uniform float reileigh;', 'uniform float mieCoefficient;', 'uniform float mieDirectionalG;', '// constants for atmospheric scattering', 'const float e = 2.71828182845904523536028747135266249775724709369995957;', 'const float pi = 3.141592653589793238462643383279502884197169;', 'const float n = 1.0003; // refractive index of air', 'const float N = 2.545E25; // number of molecules per unit volume for air at', '// 288.15K and 1013mb (sea level -45 celsius)', 'const float pn = 0.035; // depolatization factor for standard air', '// wavelength of used primaries, according to preetham', 'const vec3 lambda = vec3(680E-9, 550E-9, 450E-9);', '// mie stuff', '// K coefficient for the primaries', 'const vec3 K = vec3(0.686, 0.678, 0.666);', 'const float v = 4.0;', '// optical length at zenith for molecules', 'const float rayleighZenithLength = 8.4E3;', 'const float mieZenithLength = 1.25E3;',
   // "const vec3 up = vec3(0.0, 1.0, 0.0);",
 
   'const float EE = 1000.0;', 'const float sunAngularDiameterCos = 0.999956676946448443553574619906976478926848692873900859324;', '// 66 arc seconds -> degrees, and the cosine of that', '// earth shadow hack', 'const float cutoffAngle = pi/1.95;', 'const float steepness = 1.5;', 'vec3 totalRayleigh(vec3 lambda)', '{', 'return (8.0 * pow(pi, 3.0) * pow(pow(n, 2.0) - 1.0, 2.0) * (6.0 + 3.0 * pn)) / (3.0 * N * pow(lambda, vec3(4.0)) * (6.0 - 7.0 * pn));', '}',
@@ -58,7 +58,7 @@ const skyShader = {
   // return 0.00054532832366 / (3.0 * 2.545E25 * pow(vec3(680E-9, 550E-9, 450E-9), vec3(4.0)) * 6.245);
   '}', 'float rayleighPhase(float cosTheta)', '{ ', 'return (3.0 / (16.0*pi)) * (1.0 + pow(cosTheta, 2.0));', '// return (1.0 / (3.0*pi)) * (1.0 + pow(cosTheta, 2.0));', '// return (3.0 / 4.0) * (1.0 + pow(cosTheta, 2.0));', '}', 'vec3 totalMie(vec3 lambda, vec3 K, float T)', '{', 'float c = (0.2 * T ) * 10E-18;', 'return 0.434 * c * pi * pow((2.0 * pi) / lambda, vec3(v - 2.0)) * K;', '}', 'float hgPhase(float cosTheta, float g)', '{', 'return (1.0 / (4.0*pi)) * ((1.0 - pow(g, 2.0)) / pow(1.0 - 2.0*g*cosTheta + pow(g, 2.0), 1.5));', '}', 'float sunIntensity(float zenithAngleCos)', '{', 'return EE * max(0.0, 1.0 - exp(-((cutoffAngle - acos(zenithAngleCos))/steepness)));', '}', '// float logLuminance(vec3 c)', '// {', '//     return log(c.r * 0.2126 + c.g * 0.7152 + c.b * 0.0722);', '// }', '// Filmic ToneMapping http://filmicgames.com/archives/75', 'float A = 0.15;', 'float B = 0.50;', 'float C = 0.10;', 'float D = 0.20;', 'float E = 0.02;', 'float F = 0.30;', 'float W = 1000.0;', 'vec3 Uncharted2Tonemap(vec3 x)', '{', 'return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;', '}', 'void main() ', '{', 'vec3 up2 = normalize(cameraPosition.xyz);', 'float sunfade = 1.0-clamp(1.0-exp((v3LightPosition.y/450000.0)),0.0,1.0);', 'float reileighCoefficient = reileigh - (1.0* (1.0-sunfade));', 'vec3 sunDirection = normalize(v3LightPosition);', 'float sunE = sunIntensity(dot(sunDirection, up2));', '// extinction (absorbtion + out scattering) ', '// rayleigh coefficients',
   // "vec3 betaR = totalRayleigh(lambda) * reileighCoefficient;",
-  'vec3 betaR = simplifiedRayleigh() * reileighCoefficient;', '// mie coefficients', 'vec3 betaM = totalMie(lambda, K, turbidity) * mieCoefficient;', '// optical length', '// cutoff angle at 90 to avoid singularity in next formula.', 'float zenithAngle = acos(max(0.0, dot(up2, normalize(vWorldPosition - cameraPosition))));', 'float sR = rayleighZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));', 'float sM = mieZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));', '// combined extinction factor', 'vec3 Fex = exp(-(betaR * sR + betaM * sM));', '// in scattering', 'float cosTheta = dot(normalize(vWorldPosition - cameraPosition), sunDirection);', 'float rPhase = rayleighPhase(cosTheta*0.5+0.5);', 'vec3 betaRTheta = betaR * rPhase;', 'float mPhase = hgPhase(cosTheta, mieDirectionalG);', 'vec3 betaMTheta = betaM * mPhase;', 'vec3 Lin = pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * (1.0 - Fex),vec3(1.5));', 'Lin *= mix(vec3(1.0),pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * Fex,vec3(1.0/2.0)),clamp(pow(1.0-dot(up2, sunDirection),5.0),0.0,1.0));', '//nightsky', 'vec3 direction = normalize(vWorldPosition - cameraPosition);', 'float theta = acos(direction.y); // elevation --> y-axis, [-pi/2, pi/2]', 'float phi = atan(direction.z, direction.x); // azimuth --> x-axis [-pi/2, pi/2]', 'vec2 uv = vec2(phi, theta) / vec2(2.0*pi, pi) + vec2(0.5, 0.0);', '// vec3 L0 = texture2D(skySampler, uv).rgb+0.1 * Fex;', 'vec3 L0 = vec3(0.1) * Fex;', '// composition + solar disc', '//if (cosTheta > sunAngularDiameterCos)', 'float sundisk = smoothstep(sunAngularDiameterCos,sunAngularDiameterCos+0.00002,cosTheta);', '// if (normalize(vWorldPosition - cameraPosition).y>0.0)', 'L0 += (sunE * 19000.0 * Fex)*sundisk;', 'vec3 whiteScale = 1.0/Uncharted2Tonemap(vec3(W));', 'vec3 texColor = (Lin+L0);   ', 'texColor *= 0.04 ;', 'texColor += vec3(0.0,0.001,0.0025)*0.3;', 'float g_fMaxLuminance = 1.0;', 'float fLumScaled = 0.1 / luminance;     ', 'float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (g_fMaxLuminance * g_fMaxLuminance)))) / (1.0 + fLumScaled); ', 'float ExposureBias = fLumCompressed;', 'vec3 curr = Uncharted2Tonemap((log2(2.0/pow(luminance,4.0)))*texColor);', 'vec3 color = curr*whiteScale;', 'vec3 retColor = pow(color,vec3(1.0/(1.2+(1.2*sunfade))));', 'gl_FragColor.rgb = retColor;', 'gl_FragColor.a = 1. - ( (length(cameraPosition) - 6400000.) / 1000.);', '}'].join('\n')
+  'vec3 betaR = simplifiedRayleigh() * reileighCoefficient;', '// mie coefficients', 'vec3 betaM = totalMie(lambda, K, turbidity) * mieCoefficient;', '// optical length', '// cutoff angle at 90 to avoid singularity in next formula.', 'float zenithAngle = acos(max(0.0, dot(up2, normalize(vWorldPosition - cameraPosition))));', 'float sR = rayleighZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));', 'float sM = mieZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));', '// combined extinction factor', 'vec3 Fex = exp(-(betaR * sR + betaM * sM));', '// in scattering', 'float cosTheta = dot(normalize(vWorldPosition - cameraPosition), sunDirection);', 'float rPhase = rayleighPhase(cosTheta*0.5+0.5);', 'vec3 betaRTheta = betaR * rPhase;', 'float mPhase = hgPhase(cosTheta, mieDirectionalG);', 'vec3 betaMTheta = betaM * mPhase;', 'vec3 Lin = pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * (1.0 - Fex),vec3(1.5));', 'Lin *= mix(vec3(1.0),pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * Fex,vec3(1.0/2.0)),clamp(pow(1.0-dot(up2, sunDirection),5.0),0.0,1.0));', '//nightsky', 'vec3 direction = normalize(vWorldPosition - cameraPosition);', 'float theta = acos(direction.y); // elevation --> y-axis, [-pi/2, pi/2]', 'float phi = atan(direction.z, direction.x); // azimuth --> x-axis [-pi/2, pi/2]', 'vec2 uv = vec2(phi, theta) / vec2(2.0*pi, pi) + vec2(0.5, 0.0);', '// vec3 L0 = texture2D(skySampler, uv).rgb+0.1 * Fex;', 'vec3 L0 = vec3(0.1) * Fex;', '// composition + solar disc', '//if (cosTheta > sunAngularDiameterCos)', 'float sundisk = smoothstep(sunAngularDiameterCos,sunAngularDiameterCos+0.00002,cosTheta);', '// if (normalize(vWorldPosition - cameraPosition).y>0.0)', 'L0 += (sunE * 19000.0 * Fex)*sundisk;', 'vec3 whiteScale = 1.0/Uncharted2Tonemap(vec3(W));', 'vec3 texColor = (Lin+L0);   ', 'texColor *= 0.04 ;', 'texColor += vec3(0.0,0.001,0.0025)*0.3;', 'float g_fMaxLuminance = 1.0;', 'float fLumScaled = 0.1 / luminanceAtmosphere;     ', 'float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (g_fMaxLuminance * g_fMaxLuminance)))) / (1.0 + fLumScaled); ', 'float ExposureBias = fLumCompressed;', 'vec3 curr = Uncharted2Tonemap((log2(2.0/pow(luminanceAtmosphere,4.0)))*texColor);', 'vec3 color = curr*whiteScale;', 'vec3 retColor = pow(color,vec3(1.0/(1.2+(1.2*sunfade))));', 'gl_FragColor.rgb = retColor;', 'gl_FragColor.a = 1. - ( (length(cameraPosition) - 6400000.) / 1000.);', '}'].join('\n')
 };
 class Sky extends THREE.Mesh {
   constructor() {

package/lib/Core/Prefab/GlobeView.d.ts

@@ -0,0 +1,65 @@
+export namespace GLOBE_VIEW_EVENTS {
+    let GLOBE_INITIALIZED: string;
+    let LAYER_ADDED: string;
+    let LAYER_REMOVED: string;
+    let COLOR_LAYERS_ORDER_CHANGED: string;
+}
+export default GlobeView;
+declare class GlobeView extends View {
+    /**
+     * Creates a view of a globe.
+     *
+     * @extends View
+     *
+     * @example <caption><b>Instance GlobeView.</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);
+     *
+     * @param {HTMLDivElement} viewerDiv - Where to attach the view and display it
+     * in the DOM.
+     * @param {CameraTransformOptions|Extent} placement - An object to place view
+     * @param {object} [options] - See options of {@link View}.
+     * @param {Object} [options.controls] - See options of {@link GlobeControls}
+     * @param {Object} [options.webXR] - WebXR configuration - its presence alone
+     * enable WebXR to switch on VR visualization. (optional).
+     * @param {function} [options.webXR.callback] - WebXR rendering callback (optional).
+     * @param {boolean} [options.webXR.controllers] - Enable the webXR controllers handling (optional).
+     */
+    constructor(viewerDiv: HTMLDivElement, placement?: CameraTransformOptions | Extent, options?: {
+        controls?: Object | undefined;
+        webXR?: {
+            callback?: Function | undefined;
+            controllers?: boolean | undefined;
+        } | undefined;
+    });
+    isGlobeView: boolean;
+    tileLayer: GlobeLayer;
+    controls: GlobeControls | undefined;
+    webXR: WebXR | undefined;
+    /**
+     * Add layer in viewer.
+     * The layer id must be unique.
+     *
+     * The `layer.whenReady` is a promise that resolves when
+     * the layer is done. This promise is also returned by
+     * `addLayer` allowing to chain call.
+     *
+     * The layer added is attached, by default to `GlobeLayer` (`GlobeView.tileLayer`).
+     * If you want add a unattached layer use `View#addLayer` parent method.
+     *
+     * @param {LayerOptions|Layer|GeometryLayer} layer The layer to add in view.
+     * @return {Promise} a promise resolved with the new layer object when it is fully initialized or rejected if any error occurred.
+     */
+    addLayer(layer: LayerOptions | Layer | GeometryLayer): Promise<any>;
+    getPixelsToDegrees(pixels: number | undefined, screenCoord: any): number;
+    getPixelsToDegreesFromDistance(pixels?: number, distance?: number): number;
+    getMetersToDegrees(meters?: number): number;
+}
+import View from '../../Core/View';
+import GlobeLayer from '../../Core/Prefab/Globe/GlobeLayer';
+import GlobeControls from '../../Controls/GlobeControls';
+import WebXR from '../../Renderer/WebXR';

package/lib/Core/Prefab/GlobeView.js

@@ -5,6 +5,7 @@ import { Coordinates, ellipsoidSizes } from '@itowns/geographic';
 import GlobeLayer from "./Globe/GlobeLayer.js";
 import Atmosphere from "./Globe/Atmosphere.js";
 import CameraUtils from "../../Utils/CameraUtils.js";
+import WebXR from "../../Renderer/WebXR.js";
 
 /**
  * Fires when the view is completely loaded. Controls and view's functions can be called then.
@@ -76,6 +77,10 @@ class GlobeView extends View {
    * @param {CameraTransformOptions|Extent} placement - An object to place view
    * @param {object} [options] - See options of {@link View}.
    * @param {Object} [options.controls] - See options of {@link GlobeControls}
+   * @param {Object} [options.webXR] - WebXR configuration - its presence alone
+   * enable WebXR to switch on VR visualization. (optional).
+   * @param {function} [options.webXR.callback] - WebXR rendering callback (optional).
+   * @param {boolean} [options.webXR.controllers] - Enable the webXR controllers handling (optional).
    */
   constructor(viewerDiv) {
     let placement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -106,6 +111,10 @@ class GlobeView extends View {
 
     // GlobeView needs this.camera.resize to set perpsective matrix camera
     this.camera.resize(viewerDiv.clientWidth, viewerDiv.clientHeight);
+    if (options.webXR) {
+      this.webXR = new WebXR(this, typeof options.webXR === 'boolean' ? {} : options.webXR);
+      this.webXR.initializeWebXR();
+    }
   }
 
   /**

package/lib/Core/Prefab/Planar/PlanarLayer.d.ts

@@ -0,0 +1,38 @@
+export default PlanarLayer;
+/**
+ * @property {boolean} isPlanarLayer - Used to checkout whether this layer is a
+ * PlanarLayer. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ * @extends TiledGeometryLayer
+ */
+declare class PlanarLayer extends TiledGeometryLayer {
+    /**
+     * A {@link TiledGeometryLayer} to use with a {@link PlanarView}. It has
+     * specific method for updating and subdivising its grid.
+     *
+     * @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 {Extent} extent - The extent to define the layer within.
+     * @param {THREE.Object3d} [object3d=THREE.Group] - 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 {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 {number} [config.maxSubdivisionLevel=5] - Maximum subdivision
+     * level for this tiled layer.
+     *
+     * @throws {Error} `object3d` must be a valid `THREE.Object3d`.
+     */
+    constructor(id: string, extent: Extent, object3d?: THREE.Object3d, config?: {
+        maxSubdivisionLevel?: number | undefined;
+    });
+    isPlanarLayer: boolean;
+    extent: Extent;
+    minSubdivisionLevel: any;
+}
+import TiledGeometryLayer from '../../../Layer/TiledGeometryLayer';
+import * as THREE from 'three';

package/lib/Core/Prefab/Planar/PlanarTileBuilder.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from 'three';
+import { Coordinates, Extent } from '@itowns/geographic';
+import { ShareableExtent, TileBuilder, TileBuilderParams } from '../TileBuilder';
+/** Specialized parameters for the [PlanarTileBuilder]. */
+export interface PlanarTileBuilderParams extends TileBuilderParams {
+    crs: string;
+    uvCount?: number;
+    nbRow: number;
+}
+/**
+ * TileBuilder implementation for the purpose of generating planar
+ * tile arrangements.
+ */
+export declare class PlanarTileBuilder implements TileBuilder<PlanarTileBuilderParams> {
+    private _uvCount;
+    private _transform;
+    private _crs;
+    constructor(options: {
+        projection?: string;
+        crs: string;
+        uvCount?: number;
+    });
+    get uvCount(): number;
+    get crs(): string;
+    prepare(params: TileBuilderParams): PlanarTileBuilderParams;
+    center(extent: Extent): THREE.Vector3;
+    vertexPosition(coordinates: Coordinates): THREE.Vector3;
+    vertexNormal(): THREE.Vector3;
+    uProject(u: number, extent: Extent): number;
+    vProject(v: number, extent: Extent): number;
+    computeShareableExtent(extent: Extent): ShareableExtent;
+}

package/lib/Core/Prefab/PlanarView.d.ts

@@ -0,0 +1,33 @@
+export default PlanarView;
+declare class PlanarView extends View {
+    /**
+     * @extends View
+     *
+     * @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);
+     * var view = new itowns.PlanarView(viewerDiv, extent, { placement: { heading: -49.6, range: 6200, tilt: 17 } });
+     *
+     * @param {HTMLDivElement} viewerDiv - Where to attach the view and display it
+     * in the DOM.
+     * @param {Extent} extent - The ground extent.
+     * @param {Object} [options] - See options of {@link View}.
+     * @param {boolean} [options.noControls=false] - If true, no controls are associated to the view.
+     * @param {Object} [options.controls] - options for the {@link PlanarControls} associated to the view, if
+     * `options.noControls` is false.
+     * @param {CameraUtils~CameraTransformOptions|Extent} [options.placement] - The
+     * {@link CameraUtils~CameraTransformOptions} to apply to view's camera or the extent it must display at
+     * initialization. By default, camera will display the view's extent (given in `extent` parameter).
+     */
+    constructor(viewerDiv: HTMLDivElement, extent: Extent, options?: {
+        noControls?: boolean | undefined;
+        controls?: Object | undefined;
+    });
+    isPlanarView: boolean;
+    controls: PlanarControls | undefined;
+    tileLayer: PlanarLayer;
+    addLayer(layer: any): Promise<any>;
+}
+import View from '../../Core/View';
+import PlanarControls from '../../Controls/PlanarControls';
+import PlanarLayer from './Planar/PlanarLayer';