@openglobus/og 0.17.2 → 0.18.0

package/src/{og/segment/SegmentLonLat.js → segment/SegmentLonLat.ts}

@@ -1,13 +1,16 @@
-"use strict";
-
-import { Extent } from "../Extent.js";
-import { Layer } from "../layer/Layer.js";
-import { LonLat } from "../LonLat.js";
-import { Vec3 } from "../math/Vec3.js";
-import * as mercator from "../mercator.js";
-import { EPSG4326 } from "../proj/EPSG4326.js";
-import * as quadTree from "../quadTree/quadTree.js";
-import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "./Segment.js";
+import * as mercator from "../mercator";
+import * as quadTree from "../quadTree/quadTree";
+import {EPSG4326} from "../proj/EPSG4326";
+import {Extent} from "../Extent";
+import {Layer} from "../layer/Layer";
+import {Node} from "../quadTree/Node";
+import {Planet} from "../scene/Planet";
+import {Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH} from "./Segment";
+import {LonLat} from "../LonLat";
+import {Vec3} from "../math/Vec3";
+import {Entity} from "../entity/Entity";
+import {PlanetCamera} from "../camera/PlanetCamera";
+import {WebGLTextureExt} from "../webgl/Handler";
 
 const MAX_POLE_ZOOM = 7;
 export const POLE_PIECE_SIZE = (90.0 - mercator.MAX_LAT) / Math.pow(2, MAX_POLE_ZOOM);
@@ -19,50 +22,38 @@ let _tempHigh = new Vec3(),
  * Planet segment Web Mercator tile class that stored and rendered with quad tree.
  * @class
  * @extends {Segment}
- * @param {quadNode.Node} node - Quad tree segment node.
- * @param {Planet} planet - Scene planet.
- * @param {Number} tileZoom - Segment tile zoom index.
- * @param {Extent} extent - Segment WGS84 extent.
  */
 class SegmentLonLat extends Segment {
-    /**
-     * @param {quadTree.Node} node - Segment node.
-     * @param {Planet} planet - Current planet scene.
-     * @param {number} tileZoom - Zoom index.
-     * @param {Extent} extent - Segment extent.
-     */
-    constructor(node, planet, tileZoom, extent) {
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent) {
         super(node, planet, tileZoom, extent);
 
         this._projection = EPSG4326;
 
+        this._extentLonLat = this._extent;
+
         this._extentMerc = new Extent(
             extent.southWest.forwardMercatorEPS01(),
             extent.northEast.forwardMercatorEPS01()
         );
 
-        if (this._extent.northEast.lat > 0) {
-            this._isNorth = true;
-        } else {
-            this._isNorth = false;
-        }
+        this._isNorth = this._extent.northEast.lat > 0;
 
         this.isPole = true;
     }
 
-    _setExtentLonLat() {
+    public override _setExtentLonLat() {
         this._extentLonLat = this._extent;
     }
 
-    projectNative(coords) {
+    public override projectNative(coords: LonLat): LonLat {
         return coords;
     }
 
-    getInsideLonLat(obj) {
+    public override getInsideLonLat(obj: Entity | PlanetCamera): LonLat {
         return obj._lonLat;
     }
 
-    _getMaxZoom() {
+    protected _getMaxZoom() {
         let maxPoleZoom = 0;
         if (this._isNorth) {
             //north pole limits
@@ -76,17 +67,17 @@ class SegmentLonLat extends Segment {
         return maxPoleZoom;
     }
 
-    checkZoom() {
+    public override checkZoom() {
         return super.checkZoom() && this.tileZoom <= this._getMaxZoom();
     }
 
-    _assignTileIndexes() {
+    protected override _assignTileIndexes() {
         this._assignTileXIndexes(this._extent);
         this._assignTileYIndexes(this._extent);
         this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, this.tileZoom);
     }
 
-    _assignTileXIndexes(extent) {
+    protected _assignTileXIndexes(extent: Extent) {
         this.tileX = Math.round(
             Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
         );
@@ -96,8 +87,8 @@ class SegmentLonLat extends Segment {
         this.tileXW = (p2 + this.tileX - 1) % p2;
     }
 
-    _assignTileYIndexes(extent) {
-        var lat = extent.northEast.lat;
+    protected _assignTileYIndexes(extent: Extent) {
+        const lat = extent.northEast.lat;
         if (lat > 0) {
             this._tileGroup = TILEGROUP_NORTH;
             this.tileY = Math.round((90.0 - lat) / (extent.northEast.lat - extent.southWest.lat));
@@ -112,25 +103,27 @@ class SegmentLonLat extends Segment {
     }
 
 
-    _createPlainVertices() {
-        var gridSize = this.planet.terrain.gridSizeByZoom[this.tileZoom];
-
-        var e = this._extent,
-            fgs = this.planet.terrain.plainGridSize;
-        var lonSize = e.getWidth();
-        var latSize = e.getHeight();
-        var llStep = lonSize / Math.max(fgs, gridSize);
-        var ltStep = latSize / gridSize;
-        var esw_lon = e.southWest.lon,
-            ene_lat = e.northEast.lat;
-        var dg = Math.max(fgs / gridSize, 1),
-            gs = Math.max(fgs, gridSize) + 1;
-        var r2 = this.planet.ellipsoid._invRadii2;
-        var ind = 0,
+    protected override _createPlainVertices() {
+        const gridSize = this.planet.terrain!.gridSizeByZoom[this.tileZoom];
+
+        const e = this._extent;
+        const fgs = this.planet.terrain!.plainGridSize;
+        const lonSize = e.getWidth();
+        const latSize = e.getHeight();
+        const llStep = lonSize / Math.max(fgs, gridSize);
+        const ltStep = latSize / gridSize;
+        const esw_lon = e.southWest.lon;
+        const ene_lat = e.northEast.lat;
+        const dg = Math.max(fgs / gridSize, 1);
+        const gs = Math.max(fgs, gridSize) + 1;
+        const r2 = this.planet.ellipsoid._invRadii2;
+
+        let ind = 0,
             nmInd = 0;
+
         const gsgs = gs * gs;
 
-        var gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;
+        const gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;
 
         this.plainNormals = new Float32Array(gridSize3);
         this.plainVertices = new Float64Array(gridSize3);
@@ -149,7 +142,7 @@ class SegmentLonLat extends Segment {
             zmin = 549755748352.0,
             zmax = -549755748352.0;
 
-        var verts = this.plainVertices,
+        let verts = this.plainVertices,
             vertsHigh = this.plainVerticesHigh,
             vertsLow = this.plainVerticesLow,
             norms = this.plainNormals,
@@ -159,17 +152,17 @@ class SegmentLonLat extends Segment {
             nmNorms = this.normalMapNormals;
 
         for (let k = 0; k < gsgs; k++) {
-            var j = k % gs,
+            let j = k % gs,
                 i = ~~(k / gs);
 
-            var v = this.planet.ellipsoid.lonLatToCartesian(
+            const v = this.planet.ellipsoid.lonLatToCartesian(
                 new LonLat(esw_lon + j * llStep, ene_lat - i * ltStep)
             );
-            var nx = v.x * r2.x,
+            let nx = v.x * r2.x,
                 ny = v.y * r2.y,
                 nz = v.z * r2.z;
-            var l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);
-            var nxl = nx * l,
+            let l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);
+            let nxl = nx * l,
                 nyl = ny * l,
                 nzl = nz * l;
 
@@ -219,10 +212,6 @@ class SegmentLonLat extends Segment {
         this.terrainVerticesHigh = vertsHigh;
         this.terrainVerticesLow = vertsLow;
 
-        //store raw normals
-        this.normalMapNormalsRaw = new Float32Array(nmNorms.length);
-        this.normalMapNormalsRaw.set(nmNorms);
-
         let x = (xmax - xmin) * 0.5,
             y = (ymax - ymin) * 0.5,
             z = (zmax - zmin) * 0.5;
@@ -232,15 +221,18 @@ class SegmentLonLat extends Segment {
         this.plainReady = true;
     }
 
-    _assignGlobalTextureCoordinates() {
-        var e = this._extent;
+    protected override _assignGlobalTextureCoordinates() {
+        const e = this._extent;
         this._globalTextureCoordinates[0] = (e.southWest.lon + 180.0) / 360.0;
         this._globalTextureCoordinates[1] = (90 - e.northEast.lat) / 180.0;
         this._globalTextureCoordinates[2] = (e.northEast.lon + 180.0) / 360.0;
         this._globalTextureCoordinates[3] = (90 - e.southWest.lat) / 180.0;
     }
 
-    _collectVisibleNodes() {
+    /**
+     * @todo: replace to the strategy
+     */
+    public override _collectVisibleNodes() {
         if (this._isNorth) {
             this.planet._visibleNodesNorth[this.node.nodeId] = this.node;
         } else {
@@ -248,36 +240,42 @@ class SegmentLonLat extends Segment {
         }
     }
 
-    _getLayerExtentOffset(layer) {
-        var v0s = layer._extent;
-        var v0t = this._extent;
-        var sSize_x = v0s.northEast.lon - v0s.southWest.lon;
-        var sSize_y = v0s.northEast.lat - v0s.southWest.lat;
-        var dV0s_x = (v0t.southWest.lon - v0s.southWest.lon) / sSize_x;
-        var dV0s_y = (v0s.northEast.lat - v0t.northEast.lat) / sSize_y;
-        var dSize_x = (v0t.northEast.lon - v0t.southWest.lon) / sSize_x;
-        var dSize_y = (v0t.northEast.lat - v0t.southWest.lat) / sSize_y;
+    /**
+     * @param layer
+     * @protected
+     *
+     * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
+     *
+     */
+    protected override _getLayerExtentOffset(layer: Layer): [number, number, number, number] {
+        const v0s = layer._extent;
+        const v0t = this._extent;
+        const sSize_x = v0s.northEast.lon - v0s.southWest.lon;
+        const sSize_y = v0s.northEast.lat - v0s.southWest.lat;
+        const dV0s_x = (v0t.southWest.lon - v0s.southWest.lon) / sSize_x;
+        const dV0s_y = (v0s.northEast.lat - v0t.northEast.lat) / sSize_y;
+        const dSize_x = (v0t.northEast.lon - v0t.southWest.lon) / sSize_x;
+        const dSize_y = (v0t.northEast.lat - v0t.southWest.lat) / sSize_y;
         return [dV0s_x, dV0s_y, dSize_x, dSize_y];
     }
 
-    layerOverlap(layer) {
+    public override layerOverlap(layer: Layer): boolean {
         return this._extent.overlaps(layer._extent);
     }
 
-    getDefaultTexture() {
+    public override getDefaultTexture(): WebGLTextureExt | null {
         return this._isNorth ? this.planet.solidTextureOne : this.planet.solidTextureTwo;
     }
 
-    getExtentLonLat() {
+    public override getExtentLonLat(): Extent {
         return this._extent;
     }
 
-    getExtentMerc() {
-        return this._extentMerc;
-    }
-
-    getNodeState() {
-        var vn;
+    /**
+     * @todo: replace to the strategy
+     */
+    public override getNodeState(): number {
+        let vn;
         if (this._isNorth) {
             vn = this.planet._visibleNodesNorth[this.node.nodeId];
         } else {
@@ -285,10 +283,6 @@ class SegmentLonLat extends Segment {
         }
         return (vn && vn.state) || quadTree.NOTRENDERING;
     }
-
-    _freeCache() {
-        //empty for a time
-    }
 }
 
-export { SegmentLonLat };
+export {SegmentLonLat};

package/src/{og/segment/SegmentLonLatWgs84.js → segment/SegmentLonLatWgs84.ts}

@@ -1,34 +1,27 @@
-"use strict";
-
-import { TILEGROUP_COMMON } from "./Segment.js";
-import { SegmentLonLat } from "./SegmentLonLat.js";
+import {Extent} from "../Extent";
+import {Node} from "../quadTree/Node";
+import {Planet} from "../scene/Planet";
+import {SegmentLonLat} from "./SegmentLonLat";
+import {TILEGROUP_COMMON} from "./Segment";
 
 export class SegmentLonLatWgs84 extends SegmentLonLat {
-    constructor(node, planet, tileZoom, extent) {
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent) {
         super(node, planet, tileZoom, extent);
         this.isPole = false;
         this._tileGroup = TILEGROUP_COMMON;
     }
 
-    _getMaxZoom() {
+    protected override _getMaxZoom(): number {
         return 150;
-        // let lat = 0;
-        // if (this._isNorth) {
-        //     lat = this._extent.northEast.lat;
-        // } else {
-        //     lat = Math.abs(this._extent.southWest.lat);
-        // }
-        // let Yz = Math.floor((90 - lat) / POLE_PIECE_SIZE);
-        // return Math.floor(Yz / 16) + 7;
     }
 
-    _assignTileYIndexes(extent) {
+    protected override _assignTileYIndexes(extent: Extent) {
         this.tileY = Math.round((90.0 - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
         this.tileYN = this.tileY - 1;
         this.tileYS = this.tileY + 1;
     }
 
-    _assignTileXIndexes(extent) {
+    protected override _assignTileXIndexes(extent: Extent) {
         this.tileX = Math.round(
             Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
         );

package/src/{og/segment/Slice.js → segment/Slice.ts}

@@ -1,24 +1,30 @@
-'use strict';
+import {Layer} from "../layer/Layer";
+import {Segment} from "./Segment";
+import {Material} from "../layer/Material";
 
 class Slice {
-    constructor(segment) {
+    public segment: Segment;
+    public layers: Layer[];
+    public tileOffsetArr: Float32Array;
+    public layerOpacityArr: Float32Array;
+
+    constructor(segment: Segment) {
         this.segment = segment;
         this.layers = [];
         this.tileOffsetArr = new Float32Array(segment.planet.SLICE_SIZE_4);
         this.layerOpacityArr = new Float32Array(segment.planet.SLICE_SIZE);
-        this.init();
     }
 
-    init() {}
-
-    clear() {
+    public clear() {
+        // @ts-ignore
         this.layers = null;
+        // @ts-ignore
         this.tileOffsetArr = null;
+        // @ts-ignore
         this.layerOpacityArr = null;
-        //this.visibleExtentOffsetArr = null;
     }
 
-    append(layer, material) {
+    public append(layer: Layer, material: Material) {
         let n = this.layers.length;
 
         this.layers.push(layer);
@@ -42,4 +48,4 @@ class Slice {
     }
 }
 
-export { Slice }
+export {Slice}

package/src/{og/segment/segmentHelper.js → segment/segmentHelper.ts}

@@ -2,25 +2,31 @@
  * @module og/segment/SegmentHelper
  */
 
-'use strict';
+import {N, W, S, E} from '../quadTree/quadTree';
 
-import { N, W, S, E } from '../quadTree/quadTree.js';
+type IndexTypeArray = Uint32Array;
+type IndexesTable = [IndexTypeArray[][], IndexTypeArray[][], IndexTypeArray[][], IndexTypeArray[][]];
 
-function NewIndexesTypedArray(arr) {
+
+function NewIndexesTypedArray(arr: number[]): IndexTypeArray {
     return new Uint32Array(arr);
 }
 
-function createCenterBodyIndexes(size) {
+function NewIndexesTypedArrayEmpty(size: number): IndexTypeArray {
+    return new Uint32Array(size);
+}
+
+function createCenterBodyIndexes(size: number): IndexTypeArray {
 
     let indexes = [];
 
-    var i0 = 1,
+    let i0 = 1,
         j0 = 1;
 
-    var i1 = 1,
+    let i1 = 1,
         j1 = 1;
 
-    var ind1, ind2, nr;
+    let ind1 = 0, ind2 = 0, nr = 0;
     for (let i = i0; i < size - 1 - i1; i++) {
         for (let j = j0; j < size - j1; j++) {
             ind1 = i * size + j;
@@ -35,16 +41,16 @@ function createCenterBodyIndexes(size) {
     return NewIndexesTypedArray(indexes);
 }
 
-function createWestNeighborSkirt(size, deltaGr) {
+function createWestNeighborSkirt(size: number, deltaGr: number): IndexTypeArray {
     let indexes = [];
-    var grCount = (size - 1) / deltaGr;
-    var b = size * size - size;
-    var k = 0;
+    const grCount = (size - 1) / deltaGr;
+    const b = size * size - size;
+    let k = 0;
     for (let i = 0; i < size - 2; i++) {
         if (i % grCount === 0) {
             k = i;
         }
-        var rind = b - size * i - size + 1,
+        let rind = b - size * i - size + 1,
             lind = b - size * k;
         indexes.push(lind, rind);
     }
@@ -57,15 +63,15 @@ function createWestNeighborSkirt(size, deltaGr) {
     return NewIndexesTypedArray(indexes);
 }
 
-function createNorthNeighborSkirt(size, deltaGr) {
+function createNorthNeighborSkirt(size: number, deltaGr: number): IndexTypeArray {
     let indexes = [];
-    var grCount = (size - 1) / deltaGr;
-    var k = 0;
+    const grCount = (size - 1) / deltaGr;
+    let k = 0;
     for (let i = 0; i < size - 2; i++) {
         if (i % grCount === 0) {
             k = i;
         }
-        var rind = size + i + 1,
+        let rind = size + i + 1,
             lind = k;
         indexes.push(lind, rind);
     }
@@ -78,15 +84,15 @@ function createNorthNeighborSkirt(size, deltaGr) {
     return NewIndexesTypedArray(indexes);
 }
 
-function createEastNeighborSkirt(size, deltaGr) {
+function createEastNeighborSkirt(size: number, deltaGr: number): IndexTypeArray {
     let indexes = [];
-    var grCount = (size - 1) / deltaGr;
-    var k = 0;
+    const grCount = (size - 1) / deltaGr;
+    let k = 0;
     for (let i = 0; i < size - 2; i++) {
         if (i % grCount === 0) {
             k = i;
         }
-        var rind = size * (i + 1) + size - 2,
+        let rind = size * (i + 1) + size - 2,
             lind = size + size * k - 1;
         indexes.push(lind, rind);
     }
@@ -99,17 +105,17 @@ function createEastNeighborSkirt(size, deltaGr) {
     return NewIndexesTypedArray(indexes);
 }
 
-function createSouthNeighborSkirt(size, deltaGr) {
+function createSouthNeighborSkirt(size: number, deltaGr: number): IndexTypeArray {
     let indexes = [];
-    var grCount = (size - 1) / deltaGr;
-    var k = 0;
-    var rb = size * (size - 1) - 2;
-    var lb = size * size - 1;
+    const grCount = (size - 1) / deltaGr;
+    let k = 0;
+    const rb = size * (size - 1) - 2;
+    const lb = size * size - 1;
     for (let i = 0; i < size - 2; i++) {
         if (i % grCount === 0) {
             k = i;
         }
-        var rind = rb - i,
+        let rind = rb - i,
             lind = lb - k;
         indexes.push(lind, rind);
     }
@@ -122,16 +128,11 @@ function createSouthNeighborSkirt(size, deltaGr) {
     return NewIndexesTypedArray(indexes);
 }
 
-function initIndexesBodySkirts(pow) {
-    var table = [];
-
-    table[N] = [];
-    table[W] = [];
-    table[S] = [];
-    table[E] = [];
+function initIndexesBodySkirts(pow: number): IndexesTable {
+    let table: IndexesTable = [[], [], [], []];
 
     for (let i = 0; i <= pow; i++) {
-        var d = Math.pow(2, i),
+        let d = Math.pow(2, i),
             d1 = d + 1;
 
         table[N][i] = [];
@@ -140,7 +141,7 @@ function initIndexesBodySkirts(pow) {
         table[E][i] = [];
 
         for (let j = 0; j <= pow; j++) {
-            var dd = Math.pow(2, j);
+            let dd = Math.pow(2, j);
             table[W][i][j] = createWestNeighborSkirt(d1, dd);
             table[N][i][j] = createNorthNeighborSkirt(d1, dd);
             table[E][i][j] = createEastNeighborSkirt(d1, dd);
@@ -151,17 +152,17 @@ function initIndexesBodySkirts(pow) {
     return table;
 }
 
-function initIndexBodiesTable(pow) {
-    var table = [];
+function initIndexBodiesTable(pow: number): IndexTypeArray[] {
+    let table = [];
     for (let i = 0; i <= pow; i++) {
-        var d = Math.pow(2, i);
+        const d = Math.pow(2, i);
         table[i] = createCenterBodyIndexes(d + 1);
     }
     return table;
 }
 
-function createTextureCoords(size) {
-    var texCoords = new Uint16Array((size + 1) * (size + 1) * 2);
+function createTextureCoords(size: number): Uint16Array {
+    let texCoords = new Uint16Array((size + 1) * (size + 1) * 2);
     let k = 0;
     for (let i = 0; i <= size; i++) {
         for (let j = 0; j <= size; j++) {
@@ -173,25 +174,32 @@ function createTextureCoords(size) {
 }
 
 class SegmentHelper {
-    constructor(maxGridSize = 0) {
+
+    protected _maxGridSize: number;
+    public centerIndexesTable: IndexTypeArray[];
+    public skirtsIndexesTable: IndexesTable;
+
+    constructor(maxGridSize: number = 0) {
         this._maxGridSize = maxGridSize;
+        this.centerIndexesTable = initIndexBodiesTable(this._maxGridSize)
+        this.skirtsIndexesTable = initIndexesBodySkirts(this._maxGridSize);
     }
 
-    get maxGridSize() {
+    public get maxGridSize(): number {
         return this._maxGridSize;
     }
 
-    init() {
+    public init() {
         this.centerIndexesTable = initIndexBodiesTable(this._maxGridSize);
         this.skirtsIndexesTable = initIndexesBodySkirts(this._maxGridSize);
     }
 
-    setMaxGridSize(gridSize) {
+    public setMaxGridSize(gridSize: number) {
         this._maxGridSize = gridSize;
         this.init();
     }
 
-    createSegmentIndexes(size, sidesSizes) {
+    public createSegmentIndexes(size: number, sidesSizes: [number, number, number, number]) {
         if (size) {
             let c = this.centerIndexesTable[size],
                 w = this.skirtsIndexesTable[W][size][sidesSizes[W]],
@@ -199,7 +207,7 @@ class SegmentHelper {
                 e = this.skirtsIndexesTable[E][size][sidesSizes[E]],
                 s = this.skirtsIndexesTable[S][size][sidesSizes[S]];
 
-            let indexes = NewIndexesTypedArray(c.length + w.length + n.length + e.length + s.length);
+            let indexes = NewIndexesTypedArrayEmpty(c.length + w.length + n.length + e.length + s.length);
 
             indexes.set(c, 0);
             indexes.set(w, c.length);
@@ -213,10 +221,10 @@ class SegmentHelper {
         }
     }
 
-    initTextureCoordsTable(pow) {
-        var table = [];
+    public initTextureCoordsTable(pow: number): Uint16Array[] {
+        let table = [];
         for (let i = 0; i <= pow; i++) {
-            var d = Math.pow(2, i);
+            const d = Math.pow(2, i);
             table[i] = createTextureCoords(d);
         }
         return table;

package/src/{og/shaders/atmos.js → shaders/atmos.ts}

@@ -1,7 +1,5 @@
-'use strict';
-
-import { Program } from '../webgl/Program.js';
-import { UTILS } from './utils.js';
+import { Program } from '../webgl/Program';
+import { UTILS } from './utils';
 
 export const COMMON =
     `
@@ -93,7 +91,7 @@ export const COMMON =
         return exp(-(rayleighScatteringCoefficient * opticalDepth.x + mieExtinctionCoefficient * opticalDepth.y + ozoneAbsorptionCoefficient * opticalDepth.z));
     }`;
 
-export function transmittance() {
+export function transmittance(): Program {
     return new Program("transmittance", {
         uniforms: {
             iResolution: "vec2"
@@ -129,7 +127,7 @@ export function transmittance() {
     });
 }
 
-export function scattering() {
+export function scattering(): Program {
     return new Program("scattering", {
         uniforms: {
             iResolution: "vec2",

package/src/{og/shaders/billboard.js → shaders/billboard.ts}

@@ -1,6 +1,4 @@
-'use strict';
-
-import { Program } from '../webgl/Program.js';
+import {Program} from '../webgl/Program';
 
 const PROJECT = `vec2 project(vec4 p) {
                     return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
@@ -12,7 +10,7 @@ const ROTATE2D =
            sin(angle), cos(angle));
      }`;
 
-export function billboardPicking() {
+export function billboardPicking(): Program {
     return new Program("billboardPicking", {
         uniforms: {
             viewport: "vec2",
@@ -113,7 +111,7 @@ export function billboardPicking() {
     });
 }
 
-export function billboard_screen() {
+export function billboard_screen(): Program {
     return new Program("billboard", {
         uniforms: {
             viewport: "vec2",