@openglobus/og 0.20.3 → 0.21.0

package/lib/js/entity/GeometryHandler.js

@@ -682,6 +682,62 @@ class GeometryHandler {
         h.gl.deleteBuffer(this._lineStrokeColorsBuffer);
         this._lineStrokeColorsBuffer = h.createArrayBuffer(new Float32Array(this._lineStrokeColors), 4, this._lineStrokeColors.length / 4);
     }
+    clear() {
+        this._geometries = [];
+        this._polyVerticesHighMerc = [];
+        this._polyVerticesLowMerc = [];
+        this._polyIndexes = [];
+        this._polyColors = [];
+        this._polyPickingColors = [];
+        this._lineVerticesHighMerc = [];
+        this._lineVerticesLowMerc = [];
+        this._lineOrders = [];
+        this._lineIndexes = [];
+        this._lineColors = [];
+        this._linePickingColors = [];
+        this._lineThickness = [];
+        this._lineStrokeColors = [];
+        this._lineStrokes = [];
+        this._deleteBuffers();
+        this._polyVerticesHighBufferMerc = null;
+        this._polyVerticesLowBufferMerc = null;
+        this._polyIndexesBuffer = null;
+        this._polyColorsBuffer = null;
+        this._polyPickingColorsBuffer = null;
+        this._lineVerticesHighBufferMerc = null;
+        this._lineVerticesLowBufferMerc = null;
+        this._lineIndexesBuffer = null;
+        this._lineOrdersBuffer = null;
+        this._lineColorsBuffer = null;
+        this._linePickingColorsBuffer = null;
+        this._lineThicknessBuffer = null;
+        this._lineStrokeColorsBuffer = null;
+        this._lineStrokesBuffer = null;
+        this._updatedGeometryArr = [];
+        this._updatedGeometry = {};
+        this._removeGeometryExtentArr = [];
+        this._removeGeometryExtents = {};
+        this.refresh();
+    }
+    _deleteBuffers() {
+        if (this._layer._planet && this._layer._planet.renderer) {
+            let h = this._layer._planet.renderer.handler, gl = h.gl;
+            gl.deleteBuffer(this._polyVerticesHighBufferMerc);
+            gl.deleteBuffer(this._polyVerticesLowBufferMerc);
+            gl.deleteBuffer(this._polyIndexesBuffer);
+            gl.deleteBuffer(this._polyColorsBuffer);
+            gl.deleteBuffer(this._polyPickingColorsBuffer);
+            gl.deleteBuffer(this._lineVerticesHighBufferMerc);
+            gl.deleteBuffer(this._lineVerticesLowBufferMerc);
+            gl.deleteBuffer(this._lineIndexesBuffer);
+            gl.deleteBuffer(this._lineOrdersBuffer);
+            gl.deleteBuffer(this._lineColorsBuffer);
+            gl.deleteBuffer(this._linePickingColorsBuffer);
+            gl.deleteBuffer(this._lineThicknessBuffer);
+            gl.deleteBuffer(this._lineStrokeColorsBuffer);
+            gl.deleteBuffer(this._lineStrokesBuffer);
+        }
+    }
 }
 GeometryHandler.__counter__ = 0;
 export { GeometryHandler };

package/lib/js/layer/Bing.js

@@ -20,6 +20,7 @@ export class Bing extends XYZ {
             subdomains: ['t0', 't1', 't2', 't3'],
             url: "https://ecn.{s}.tiles.virtualearth.net/tiles/a{quad}.jpeg?n=z&g=7146",
             isBaseLayer: true,
+            textureFilter: "LINEAR",
             maxNativeZoom: 17,
             defaultTextures: [{ color: "#001522" }, { color: "#E4E6F3" }],
             attribution: `<div style="transform: scale(0.8); margin-top:-2px;"><a href="https://www.bing.com" target="_blank"><img style="position: relative; top: 2px;" title="Bing Imagery" src="https://sandcastle.cesium.com/CesiumUnminified/Assets/Images/bing_maps_credit.png"></a> © 2021 Microsoft Corporation</div>`,

package/lib/js/layer/Vector.d.ts

@@ -19,6 +19,7 @@ export interface IVectorParams extends ILayerParams {
     pickingScale?: number;
     scaleByDistance?: NumberArray3;
     labelMaxLetters?: number;
+    useLighting?: boolean;
 }
 type VectorEventsList = [
     "draw",
@@ -44,6 +45,7 @@ export type VectorEventsType = EventsHandler<VectorEventsList> & EventsHandler<L
  *      First index - near distance to the entity, after entity becomes full scale.
  *      Second index - far distance to the entity, when entity becomes zero scale.
  *      Third index - far distance to the entity, when entity becomes invisible.
+ *      Use [1.0, 1.0, 1.0] for real sized objects
  * @param {number} [options.nodeCapacity=30] - Maximum entities quantity in the tree node. Rendering optimization parameter. 30 is default.
  * @param {boolean} [options.async=true] - Asynchronous vector data handling before rendering. True for optimization huge data.
  * @param {boolean} [options.clampToGround = false] - Clamp vector data to the ground.
@@ -121,7 +123,10 @@ declare class Vector extends Layer {
     polygonOffsetUnits: number;
     _secondPASS: EntityCollectionNode[];
     protected _labelMaxLetters: number;
+    protected _useLighting: boolean;
     constructor(name?: string | null, options?: IVectorParams);
+    get useLighting(): boolean;
+    set useLighting(f: boolean);
     get labelMaxLetters(): number;
     get instanceName(): string;
     protected _bindPicking(): void;

package/lib/js/layer/Vector.js

@@ -45,6 +45,7 @@ function _entitiesConstructor(entities) {
  *      First index - near distance to the entity, after entity becomes full scale.
  *      Second index - far distance to the entity, when entity becomes zero scale.
  *      Third index - far distance to the entity, when entity becomes invisible.
+ *      Use [1.0, 1.0, 1.0] for real sized objects
  * @param {number} [options.nodeCapacity=30] - Maximum entities quantity in the tree node. Rendering optimization parameter. 30 is default.
  * @param {boolean} [options.async=true] - Asynchronous vector data handling before rendering. True for optimization huge data.
  * @param {boolean} [options.clampToGround = false] - Clamp vector data to the ground.
@@ -67,6 +68,7 @@ class Vector extends Layer {
         this.isVector = true;
         this._hasImageryTiles = false;
         this.scaleByDistance = options.scaleByDistance || [math.MAX32, math.MAX32, math.MAX32];
+        this._useLighting = options.useLighting !== undefined ? options.useLighting : true;
         this.pickingScale = options.pickingScale || 1;
         this.async = options.async !== undefined ? options.async : true;
         this.clampToGround = options.clampToGround || false;
@@ -83,7 +85,8 @@ class Vector extends Layer {
         });
         this._bindEventsDefault(this._polylineEntityCollection);
         this._geoObjectEntityCollection = new EntityCollection({
-            pickingEnabled: this.pickingEnabled
+            pickingEnabled: this.pickingEnabled,
+            useLighting: this._useLighting
         });
         this._bindEventsDefault(this._geoObjectEntityCollection);
         this._geometryHandler = new GeometryHandler(this);
@@ -101,6 +104,15 @@ class Vector extends Layer {
         this.pickingEnabled = this._pickingEnabled;
         this._secondPASS = [];
     }
+    get useLighting() {
+        return this._useLighting;
+    }
+    set useLighting(f) {
+        if (f !== this._useLighting) {
+            this._geoObjectEntityCollection.useLighting = f;
+            this._useLighting = f;
+        }
+    }
     get labelMaxLetters() {
         return this._labelMaxLetters;
     }
@@ -329,6 +341,9 @@ class Vector extends Layer {
         this._stripEntityCollection.setPickingEnabled(picking);
         this._polylineEntityCollection.setPickingEnabled(picking);
         this._geoObjectEntityCollection.setPickingEnabled(picking);
+        /**
+         * todo: it must be in the quadtree strategy
+         */
         this._entityCollectionsTree && this._entityCollectionsTree.traverseTree((node) => {
             node.entityCollection.setPickingEnabled(picking);
         });
@@ -373,6 +388,7 @@ class Vector extends Layer {
      * @public
      */
     clear() {
+        super.clear();
         let temp = new Array(this._entities.length);
         for (let i = 0; i < temp.length; i++) {
             temp[i] = this._entities[i];
@@ -389,6 +405,7 @@ class Vector extends Layer {
         this._entityCollectionsTree = null;
         this._entityCollectionsTreeNorth = null;
         this._entityCollectionsTreeSouth = null;
+        this._geometryHandler.clear();
     }
     /**
      * Safety entities loop.
@@ -708,7 +725,7 @@ class Vector extends Layer {
     }
     _execDeferredNode(node) {
         this._counter++;
-        setTimeout(() => {
+        requestAnimationFrame(() => {
             node.applyCollection();
             this._counter--;
             if (this._deferredEntitiesPendingQueue.length && this._counter < 1) {
@@ -721,7 +738,7 @@ class Vector extends Layer {
                     }
                 }
             }
-        }, 0);
+        });
     }
     /**
      * Start to load tile material.

package/lib/js/math/Quat.d.ts

@@ -118,6 +118,7 @@ export declare class Quat {
      * @returns {Quat} -
      */
     static getRotationBetweenVectorsUp(source: Vec3, dest: Vec3, up: Vec3): Quat;
+    static setFromEulerAngles(pitch: number, yaw: number, roll: number): Quat;
     /**
      * Returns true if the components are zero.
      * @public

package/lib/js/math/Quat.js

@@ -166,6 +166,10 @@ export class Quat {
         let rotAxis = source.cross(dest).normalize();
         return Quat.axisAngleToQuat(rotAxis, rotAngle);
     }
+    static setFromEulerAngles(pitch, yaw, roll) {
+        let res = new Quat();
+        return res.setFromEulerAngles(pitch, yaw, roll);
+    }
     /**
      * Returns true if the components are zero.
      * @public

package/lib/js/renderer/RendererEvents.js

@@ -663,9 +663,7 @@ class RendererEvents extends Events {
         }
         if (ts.touchStart) {
             let r = this.renderer;
-            r.pickingFramebuffer.activate();
-            r.pickingFramebuffer.readPixels(_currPickingColor, ts.nx, 1.0 - ts.ny, 1);
-            r.pickingFramebuffer.deactivate();
+            r.readPickingColor(ts.nx, 1 - ts.ny, _currPickingColor);
             let co = r.getPickingObjectArr(_currPickingColor);
             tpo = ts.pickingObject = co;
             if (tpo) {

package/lib/js/scene/Planet.js

@@ -1075,7 +1075,7 @@ export class Planet extends RenderNode {
         let transparentSegments = [];
         let isEq = this.terrain.equalizeVertices;
         let i = renderedNodes.length;
-        if (cam.slope > 0.8 /*|| cam.getAltitude() > 10000*/) {
+        if (cam.slope > 0.8 || !this.terrain || this.terrain.isEmpty /*|| cam.getAltitude() > 10000*/) {
             while (i--) {
                 let ri = renderedNodes[i];
                 let s = ri.segment;

package/lib/js/shaders/geoObject.js

@@ -1,4 +1,7 @@
 import { Program } from "../webgl/Program";
+const QROT = `vec3 qRotate(vec4 q, vec3 v){
+    return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);
+}`;
 export const geo_object = () => new Program("geo_object", {
     uniforms: {
         viewMatrix: "mat4",
@@ -10,7 +13,8 @@ export const geo_object = () => new Program("geo_object", {
         lightsParamsv: "vec3",
         lightsParamsf: "float",
         uTexture: "sampler2d",
-        uUseTexture: "float"
+        uUseTexture: "float",
+        useLighting: "float"
     },
     attributes: {
         aVertexPosition: "vec3",
@@ -18,11 +22,10 @@ export const geo_object = () => new Program("geo_object", {
         aTexCoord: "vec2",
         aPositionHigh: { type: "vec3", divisor: 1 },
         aPositionLow: { type: "vec3", divisor: 1 },
-        aDirection: { type: "vec3", divisor: 1 },
-        aPitchRoll: { type: "vec2", divisor: 1 },
         aColor: { type: "vec4", divisor: 1 },
         aScale: { type: "vec3", divisor: 1 },
-        aDispose: { type: "float", divisor: 1 }
+        aDispose: { type: "float", divisor: 1 },
+        qRot: { type: "vec4", divisor: 1 }
     },
     vertexShader: `precision highp float;
             
@@ -30,13 +33,12 @@ export const geo_object = () => new Program("geo_object", {
             attribute vec3 aVertexNormal; 
             attribute vec3 aPositionHigh;
             attribute vec3 aPositionLow;    
-            attribute vec3 aDirection;
-            attribute vec2 aPitchRoll;
             attribute vec4 aColor;
             attribute vec3 aScale;
             attribute float aDispose;
             attribute float aUseTexture;
             attribute vec2 aTexCoord;
+            attribute vec4 qRot;
             
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
@@ -51,11 +53,8 @@ export const geo_object = () => new Program("geo_object", {
             varying vec4 vColor;
             varying float vDispose;
             varying vec2 vTexCoords;
-            //varying float useLighting;
             
-            const float PI = 3.141592653589793;
-            
-            const float RADIANS = PI / 180.0;
+            ${QROT}
            
             void main(void) {
                         
@@ -69,43 +68,16 @@ export const geo_object = () => new Program("geo_object", {
                 vec3 look = cameraPosition - position;
                 float lookLength = length(look);
 
-                // useLighting = 1.0;                
-                // if(lookLength > 2000000.0){
-                //      useLighting = 0.0;
-                // }
-
-            
                 vColor = aColor;
                 vTexCoords = aTexCoord;
               
-                float cos_roll = cos(aPitchRoll.y);
-                float sin_roll = sin(aPitchRoll.y);
-                
-                mat3 rotZ = mat3(
-                     vec3(cos_roll, sin_roll, 0.0),
-                     vec3(-sin_roll, cos_roll, 0.0), 
-                     vec3(0.0, 0.0, 1.0) 
-                );
-
-                float cos_pitch = cos(aPitchRoll.x);
-                float sin_pitch = sin(aPitchRoll.x);
-
-                mat3 rotX = mat3(
-                    vec3(1.0, 0.0, 0.0),
-                    vec3(0.0, cos_pitch, sin_pitch), 
-                    vec3(0.0, -sin_pitch, cos_pitch) 
-               );
-
-                vec3 r = cross(normalize(-position), aDirection);
-                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
-
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 vec3 highDiff = aPositionHigh - eyePositionHigh;
                 vec3 lowDiff = aPositionLow - eyePositionLow;
              
-                vNormal = modelMatrix * aVertexNormal;
+                vNormal = qRotate(qRot, aVertexNormal);
                                
                 // if(lookLength > uScaleByDistance[1])
                 // {
@@ -116,9 +88,10 @@ export const geo_object = () => new Program("geo_object", {
                 //     scd = lookLength / uScaleByDistance[0];
                 // }
                 // ... is the same math
+                // use scaleByDistance: [1.0, 1.0, 1.0] for real sized objects 
                 float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
                 
-                vec3 vert = modelMatrix * (aVertexPosition * aScale) * scd;
+                vec3 vert = qRotate(qRot, (aVertexPosition * aScale)) * scd;
                 
                 vert += lowDiff;
                                
@@ -135,19 +108,19 @@ export const geo_object = () => new Program("geo_object", {
                 uniform float lightsParamsf[MAX_POINT_LIGHTS];
                 uniform sampler2D uTexture;
                 uniform float uUseTexture;
+                uniform float useLighting;                
                             
                 varying vec3 cameraPosition;
                 varying vec3 v_vertex;                
                 varying vec4 vColor;
                 varying vec3 vNormal;
                 varying vec2 vTexCoords;
-                //varying float useLighting;
                 
                 void main(void) {        
                                         
                     vec3 lightWeighting = vec3(1.0);
                 
-                    //if(useLighting != 0.0){
+                    if(useLighting != 0.0){
                         vec3 normal = normalize(vNormal);
                         vec3 lightDir = normalize(lightsPositions[0]);
                         vec3 viewDir = normalize(cameraPosition - v_vertex);                
@@ -156,7 +129,7 @@ export const geo_object = () => new Program("geo_object", {
                         float specularLightWeighting = pow( reflection, lightsParamsf[0]);                                        
                         float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);
                         lightWeighting = lightsParamsv[0] + lightsParamsv[1] * diffuseLightWeighting + lightsParamsv[2] * specularLightWeighting;
-                    //}
+                    }
                                        
                     if(uUseTexture > 0.0) {
                         vec4 tColor = texture2D(uTexture, vTexCoords);
@@ -179,22 +152,20 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
         aVertexPosition: "vec3",
         aPositionHigh: { type: "vec3", divisor: 1 },
         aPositionLow: { type: "vec3", divisor: 1 },
-        aDirection: { type: "vec3", divisor: 1 },
-        aPitchRoll: { type: "vec2", divisor: 1 },
         aPickingColor: { type: "vec3", divisor: 1 },
         aScale: { type: "vec3", divisor: 1 },
-        aDispose: { type: "float", divisor: 1 }
+        aDispose: { type: "float", divisor: 1 },
+        qRot: { type: "vec4", divisor: 1 }
     },
     vertexShader: `precision highp float;
 
             attribute vec3 aVertexPosition;
             attribute vec3 aPositionHigh;
-            attribute vec3 aPositionLow;    
-            attribute vec3 aDirection;
-            attribute vec3 aPickingColor;
-            attribute vec2 aPitchRoll;
+            attribute vec3 aPositionLow;
+            attribute vec3 aPickingColor;    
             attribute vec3 aScale;
             attribute float aDispose;
+            attribute vec4 qRot;
             
             uniform vec3 eyePositionHigh;
             uniform vec3 eyePositionLow;
@@ -205,7 +176,7 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
 
             varying vec3 vColor;
             
-            const float RADIANS = 3.141592653589793 / 180.0;
+            ${QROT}
 
             void main(void) {
 
@@ -214,29 +185,9 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
                  }
             
                  vColor = aPickingColor;
-               
-                float cos_roll = cos(aPitchRoll.y);
-                float sin_roll = sin(aPitchRoll.y);
                 
-                mat3 rotZ = mat3(
-                     vec3(cos_roll, sin_roll, 0.0),
-                     vec3(-sin_roll, cos_roll, 0.0), 
-                     vec3(0.0, 0.0, 1.0) 
-                );
-
-                float cos_pitch = cos(aPitchRoll.x);
-                float sin_pitch = sin(aPitchRoll.x);
-
-                mat3 rotX = mat3(
-                    vec3(1.0, 0.0, 0.0),
-                    vec3(0.0, cos_pitch, sin_pitch), 
-                    vec3(0.0, -sin_pitch, cos_pitch) 
-               );
- 
                  vec3 position = aPositionHigh + aPositionLow;
                  vec3 cameraPosition = eyePositionHigh + eyePositionLow;
-                 vec3 r = cross(normalize(-position), aDirection);
-                 mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
  
                  mat4 viewMatrixRTE = viewMatrix;
                  viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
@@ -261,7 +212,7 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
                  // tays in the vert above it affects on Mac Safari jitter
                  float scd = pickingScale * uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
 
-                 vec3 vert = modelMatrix * (aVertexPosition * aScale) * scd;
+                 vec3 vert = qRotate(qRot, (aVertexPosition * aScale)) * scd;
                  
                  vert += lowDiff;
                                 

package/lib/js/terrain/GlobusRgbTerrain.js

@@ -7,14 +7,14 @@ const urlPref = {
 const urlRewriteFunc = (tileX, tileY, tileZoom, tileGroup) => {
     let g = urlPref[tileGroup];
     if (g)
-        return `https://terrain.openglobus.org/public/poles/${g}/${tileZoom}/${tileX}/${tileY}.png`;
+        return `https://terrain.openglobus.org/poles/${g}/${tileZoom}/${tileX}/${tileY}.png`;
 };
 export class GlobusRgbTerrain extends RgbTerrain {
     constructor(name, options) {
         super(name || "GlobusEarthRgb", {
             maxNativeZoom: 6,
             maxZoom: 17,
-            url: "https://{s}.terrain.openglobus.org/public/all/{z}/{x}/{y}.png",
+            url: "https://{s}.terrain.openglobus.org/all/{z}/{x}/{y}.png",
             urlRewrite: urlRewriteFunc,
             ...options
         });

package/lib/js/terrain/GlobusTerrain.d.ts

@@ -19,6 +19,8 @@ type TileData = {
     extent: Extent | null;
 };
 /**
+ * @deprecated
+ * Use GlobusRgbTerrain
  * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
  * @class
  * @extends {GlobusTerrain}

package/lib/js/terrain/GlobusTerrain.js

@@ -12,6 +12,8 @@ import { TILEGROUP_COMMON } from "../segment/Segment";
 import { Ray } from "../math/Ray";
 import { Vec3 } from "../math/Vec3";
 /**
+ * @deprecated
+ * Use GlobusRgbTerrain
  * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
  * @class
  * @extends {GlobusTerrain}

package/lib/js/terrain/RgbTerrain.d.ts

@@ -7,16 +7,25 @@ export interface IRgbTerrainParams extends IGlobusTerrainParams {
     equalizeNormals?: boolean;
     key?: string;
     imageSize?: number;
+    minHeight?: number;
+    resolution?: number;
 }
 declare class RgbTerrain extends GlobusTerrain {
     protected _imageSize: number;
     protected _ctx: CanvasRenderingContext2D;
     protected _imageDataCache: Record<string, Uint8ClampedArray>;
+    protected _minHeight: number;
+    protected _resolution: number;
     constructor(name: string | null, options?: IRgbTerrainParams);
     static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
+    rgb2Height(r: number, g: number, b: number): number;
     isBlur(segment: Segment): boolean;
     protected _createTemporalCanvas(size: number): CanvasRenderingContext2D;
     protected _createHeights(data: HTMLImageElement | ImageBitmap, segment: Segment | null, tileGroup: number, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
     getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number): boolean;
+    extractElevationSimple(rgbaData: number[] | TypedArray, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentOffsetX: number, availableParentOffsetY: number, availableZoomDiff: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray, heightFactor: number | undefined, imageSize: number): void;
+    extractElevationTilesRgbNonPowerOfTwo(rgbaData: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, heightFactor?: number): void;
+    extractElevationTilesRgb(rgbaData: number[] | TypedArray, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentTileX: number, availableParentTileY: number, availableParentTileZoom: number, currentTileX: number, currentTileY: number, currentTileZoom: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]): void;
+    extractElevationTilesRgbNoChildren(rgbaData: number[] | TypedArray, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentTileX: number, availableParentTileY: number, availableParentTileZoom: number, currentTileX: number, currentTileY: number, currentTileZoom: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray): void;
 }
 export { RgbTerrain };