itowns 2.45.1 → 2.45.2-next.1

package/lib/Core/PointCloudNode.js

@@ -1,4 +1,7 @@
 import * as THREE from 'three';
+const size = new THREE.Vector3();
+const position = new THREE.Vector3();
+const translation = new THREE.Vector3();
 class PointCloudNode extends THREE.EventDispatcher {
   constructor() {
     let numPoints = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
@@ -10,16 +13,43 @@ class PointCloudNode extends THREE.EventDispatcher {
     this.bbox = new THREE.Box3();
     this.sse = -1;
   }
+  get pointSpacing() {
+    return this.layer.spacing / 2 ** this.depth;
+  }
+  get id() {
+    throw new Error('In extended PointCloudNode, you have to implement the getter id!');
+  }
   add(node, indexChild) {
     this.children.push(node);
     node.parent = this;
     this.createChildAABB(node, indexChild);
   }
+  createChildAABB(node) {
+    // factor to apply, based on the depth difference (can be > 1)
+    const f = 2 ** (node.depth - this.depth);
+
+    // size of the child node bbox (Vector3), based on the size of the
+    // parent node, and divided by the factor
+    this.bbox.getSize(size).divideScalar(f);
+
+    // initialize the child node bbox at the location of the parent node bbox
+    node.bbox.min.copy(this.bbox.min);
+
+    // position of the parent node, if it was at the same depth than the
+    // child, found by multiplying the tree position by the factor
+    position.copy(this).multiplyScalar(f);
+
+    // difference in position between the two nodes, at child depth, and
+    // scale it using the size
+    translation.subVectors(node, position).multiply(size);
+
+    // apply the translation to the child node bbox
+    node.bbox.min.add(translation);
+
+    // use the size computed above to set the max
+    node.bbox.max.copy(node.bbox.min).add(size);
+  }
   load() {
-    // Query octree/HRC if we don't have children potreeNode yet.
-    if (!this.octreeIsLoaded) {
-      this.loadOctree();
-    }
     return this.layer.source.fetcher(this.url, this.layer.source.networkOptions).then(file => this.layer.source.parse(file, {
       out: this.layer,
       in: this.layer.source

package/lib/Core/Potree2Node.d.ts

@@ -0,0 +1,11 @@
+export default Potree2Node;
+declare class Potree2Node extends PotreeNode {
+    networkOptions(byteOffset: any, byteSize: any): any;
+    load(): Promise<any>;
+    loaded: boolean | undefined;
+    loading: boolean | undefined;
+    loadOctree(): Promise<void>;
+    loadHierarchy(): Promise<void>;
+    parseHierarchy(buffer: any): void;
+}
+import PotreeNode from '../Core/PotreeNode';

package/lib/Core/Potree2Node.js

@@ -33,72 +33,18 @@ of the authors and should not be interpreted as representing official policies,
     either expressed or implied, of the FreeBSD Project.
  */
 
-import * as THREE from 'three';
-import PointCloudNode from "./PointCloudNode.js";
-
-// Create an A(xis)A(ligned)B(ounding)B(ox) for the child `childIndex` of one aabb.
-// (PotreeConverter protocol builds implicit octree hierarchy by applying the same
-// subdivision algo recursively)
-const dHalfLength = new THREE.Vector3();
+import PotreeNode from "./PotreeNode.js";
 const NODE_TYPE = {
   NORMAL: 0,
   LEAF: 1,
   PROXY: 2
 };
-class Potree2Node extends PointCloudNode {
+class Potree2Node extends PotreeNode {
   constructor() {
     let numPoints = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     let childrenBitField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     let layer = arguments.length > 2 ? arguments[2] : undefined;
-    super(numPoints, layer);
-    this.childrenBitField = childrenBitField;
-    this.id = '';
-    this.depth = 0;
-    this.baseurl = layer.source.baseurl;
-  }
-  add(node, indexChild) {
-    super.add(node, indexChild);
-    node.id = this.id + indexChild;
-    node.depth = this.depth + 1;
-  }
-  createChildAABB(node, childIndex) {
-    // Code inspired from potree
-    node.bbox.copy(this.bbox);
-    this.bbox.getCenter(node.bbox.max);
-    dHalfLength.copy(node.bbox.max).sub(this.bbox.min);
-    if (childIndex === 1) {
-      node.bbox.min.z += dHalfLength.z;
-      node.bbox.max.z += dHalfLength.z;
-    } else if (childIndex === 3) {
-      node.bbox.min.z += dHalfLength.z;
-      node.bbox.max.z += dHalfLength.z;
-      node.bbox.min.y += dHalfLength.y;
-      node.bbox.max.y += dHalfLength.y;
-    } else if (childIndex === 0) {
-      //
-    } else if (childIndex === 2) {
-      node.bbox.min.y += dHalfLength.y;
-      node.bbox.max.y += dHalfLength.y;
-    } else if (childIndex === 5) {
-      node.bbox.min.z += dHalfLength.z;
-      node.bbox.max.z += dHalfLength.z;
-      node.bbox.min.x += dHalfLength.x;
-      node.bbox.max.x += dHalfLength.x;
-    } else if (childIndex === 7) {
-      node.bbox.min.add(dHalfLength);
-      node.bbox.max.add(dHalfLength);
-    } else if (childIndex === 4) {
-      node.bbox.min.x += dHalfLength.x;
-      node.bbox.max.x += dHalfLength.x;
-    } else if (childIndex === 6) {
-      node.bbox.min.y += dHalfLength.y;
-      node.bbox.max.y += dHalfLength.y;
-      node.bbox.min.x += dHalfLength.x;
-      node.bbox.max.x += dHalfLength.x;
-    }
-  }
-  get octreeIsLoaded() {
-    return !(this.childrenBitField && this.children.length === 0);
+    super(numPoints, childrenBitField, layer);
   }
   get url() {
     return `${this.baseurl}/octree.bin`;
@@ -146,8 +92,8 @@ class Potree2Node extends PointCloudNode {
     return this.nodeType === NODE_TYPE.PROXY ? this.loadHierarchy() : Promise.resolve();
   }
   async loadHierarchy() {
-    const hierarchyPath = `${this.baseurl}/hierarchy.bin`;
-    const buffer = await this.layer.source.fetcher(hierarchyPath, this.networkOptions(this.hierarchyByteOffset, this.hierarchyByteSize));
+    const hierarchyUrl = `${this.baseurl}/hierarchy.bin`;
+    const buffer = await this.layer.source.fetcher(hierarchyUrl, this.networkOptions(this.hierarchyByteOffset, this.hierarchyByteSize));
     this.parseHierarchy(buffer);
   }
   parseHierarchy(buffer) {
@@ -196,7 +142,6 @@ class Potree2Node extends PointCloudNode {
           continue;
         }
         const child = new Potree2Node(numPoints, childMask, this.layer);
-        child.spacing = current.spacing / 2;
         current.add(child, childIndex);
         stack.push(child);
       }

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

package/lib/Core/PotreeNode.js

@@ -12,19 +12,23 @@ class PotreeNode extends PointCloudNode {
     let layer = arguments.length > 2 ? arguments[2] : undefined;
     super(numPoints, layer);
     this.childrenBitField = childrenBitField;
-    this.id = '';
     this.depth = 0;
+    this.hierarchyKey = 'r';
     this.baseurl = layer.source.baseurl;
   }
-  add(node, indexChild, root) {
+  get octreeIsLoaded() {
+    return !(this.childrenBitField && this.children.length === 0);
+  }
+  get url() {
+    return `${this.baseurl}/${this.hierarchyKey}.${this.layer.source.extension}`;
+  }
+  get id() {
+    return this.hierarchyKey;
+  }
+  add(node, indexChild) {
+    node.hierarchyKey = this.hierarchyKey + indexChild;
+    node.depth = this.depth + 1;
     super.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;
-    }
   }
   createChildAABB(node, childIndex) {
     // Code inspired from potree
@@ -62,14 +66,15 @@ 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}`;
+  load() {
+    // Query octree/HRC if we don't have children potreeNode yet.
+    if (!this.octreeIsLoaded) {
+      this.loadOctree();
+    }
+    return super.load();
   }
   loadOctree() {
-    const octreeUrl = `${this.baseurl}/r${this.id}.${this.layer.source.extensionOctree}`;
+    const octreeUrl = `${this.baseurl}/${this.hierarchyKey}.${this.layer.source.extensionOctree}`;
     return this.layer.source.fetcher(octreeUrl, this.layer.source.networkOptions).then(blob => {
       const view = new DataView(blob);
       const stack = [];
@@ -89,9 +94,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() {