@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/timetracks/programpoint-line-strip.js

@@ -1,5 +1,7 @@
-import { createProgram, shaderfunctions } from "../util";
-import { CameraUniformBlockTotem, globeProgramCache } from "../programs";
+import { createProgram, shaderfunctions } from "../util";
+import { CameraUniformBlockTotem, globeProgramCache } from "../programs";
+
+
 const vertexShader = `#version 300 es
 
 layout(std140) uniform GlobeCamera {
@@ -26,7 +28,7 @@ in float end_time;
 in vec3 end_color;
 out vec4 v_color;
 
-` + shaderfunctions.pixelXYToCartesian3DPoint + shaderfunctions.pixelXYToCartesian2DPoint + `
+`+ shaderfunctions.pixelXYToCartesian3DPoint + shaderfunctions.pixelXYToCartesian2DPoint + `
 
 void main() {
     if (head_time < start_time || head_time > end_time) { return; }
@@ -42,7 +44,8 @@ void main() {
     }
     v_color = vec4(mix(start_color, end_color, t), final_opacity);
     gl_PointSize = point_size;
-}`;
+}`;
+
 const fragmentShader = `#version 300 es
 precision highp float;
 in vec4 v_color;
@@ -55,97 +58,118 @@ void main() {
     if (cc > 0.5) {
         outColor.a = 0.0;    
  }
-}`;
-export default class {
-    constructor(gl, globe, attrBuffer, options) {
-        this.gl = gl;
-        this._cameraBlockBindingPoint = 0;
-        this._globalsBlockBindingPoint = 1;
-        this.cameraUniformBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
-        this._vao = gl.createVertexArray();
-        this._attbuffer = attrBuffer;
-        this.program = this._createProgram();
-        this._drawCount = 0;
-        this._globalsbuffer = gl.createBuffer();
-        {
-            const { gl, _globalsbuffer } = this;
-            gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW);
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
-            gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
-            gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        }
-    }
-    _createProgram() {
-        const gl = this.gl;
-        const program = createProgram(gl, vertexShader, fragmentShader);
-        const ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
-        const cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
-        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
-        const globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
-        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
-        // numaralarda yanlışlık olabilir
-        const start_position = gl.getAttribLocation(program, "start_position");
-        const start_time = gl.getAttribLocation(program, "start_time");
-        const start_color = gl.getAttribLocation(program, "start_color");
-        const end_position = gl.getAttribLocation(program, "end_position");
-        const end_time = gl.getAttribLocation(program, "end_time");
-        const end_color = gl.getAttribLocation(program, "end_color");
-        gl.bindVertexArray(this._vao);
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
-        gl.enableVertexAttribArray(start_position);
-        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 36, 0);
-        gl.enableVertexAttribArray(start_time);
-        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 36, 12);
-        gl.enableVertexAttribArray(start_color);
-        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 36, 16);
-        gl.enableVertexAttribArray(end_position);
-        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 36, 36);
-        gl.enableVertexAttribArray(end_time);
-        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 36, 48);
-        gl.enableVertexAttribArray(end_color);
-        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 36, 52);
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return program;
-    }
-    setOpacity(opacity) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setDrawCount(count) {
-        this._drawCount = count;
-    }
-    setPointSize(size) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setHeadTime(time) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    draw() {
-        const { gl, program, _vao, _drawCount } = this;
-        gl.useProgram(program);
-        gl.bindVertexArray(_vao);
-        gl.disable(gl.DEPTH_TEST);
-        gl.drawArrays(gl.POINTS, 0, _drawCount);
-        gl.enable(gl.DEPTH_TEST);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        const { gl, _vao, _globalsbuffer, program } = this;
-        gl.deleteVertexArray(_vao);
-        // gl.deleteBuffer(_attbuffer);
-        gl.deleteBuffer(_globalsbuffer);
-        gl.deleteProgram(program);
-    }
-}
+}`;
+
+
+export default class {
+
+    constructor(gl, globe, attrBuffer, options) {
+
+        this.gl = gl;
+        this._cameraBlockBindingPoint = 0;
+        this._globalsBlockBindingPoint = 1;
+        this.cameraUniformBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+        this._vao = gl.createVertexArray();
+        this._attbuffer = attrBuffer;
+        this.program = this._createProgram();
+        this._drawCount = 0;
+
+        this._globalsbuffer = gl.createBuffer();
+        {
+            const { gl, _globalsbuffer } = this;
+            gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
+            gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
+            gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        }
+    }
+
+
+    _createProgram() {
+        const gl = this.gl
+
+        const program = createProgram(gl, vertexShader, fragmentShader);
+        const ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
+        const globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
+        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
+
+        // numaralarda yanlışlık olabilir
+        const start_position = gl.getAttribLocation(program, "start_position");
+        const start_time = gl.getAttribLocation(program, "start_time");
+        const start_color = gl.getAttribLocation(program, "start_color");
+        const end_position = gl.getAttribLocation(program, "end_position");
+        const end_time = gl.getAttribLocation(program, "end_time");
+        const end_color = gl.getAttribLocation(program, "end_color");
+
+        gl.bindVertexArray(this._vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
+        gl.enableVertexAttribArray(start_position);
+        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 36, 0);
+        gl.enableVertexAttribArray(start_time);
+        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 36, 12);
+        gl.enableVertexAttribArray(start_color);
+        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 36, 16);
+        gl.enableVertexAttribArray(end_position);
+        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 36, 36);
+        gl.enableVertexAttribArray(end_time);
+        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 36, 48);
+        gl.enableVertexAttribArray(end_color);
+        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 36, 52);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return program;
+    }
+
+
+    setOpacity(opacity) {
+        const { gl, _globalsbuffer } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+
+    setDrawCount(count) {
+        this._drawCount = count;
+    }
+
+
+    setPointSize(size) {
+        const { gl, _globalsbuffer } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+
+
+    setHeadTime(time) {
+        const { gl, _globalsbuffer } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+
+
+    draw() {
+        const { gl, program, _vao, _drawCount } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(_vao);
+        gl.disable(gl.DEPTH_TEST);
+        gl.drawArrays(gl.POINTS, 0, _drawCount);
+        gl.enable(gl.DEPTH_TEST);
+        gl.bindVertexArray(null);
+    }
+
+
+    free() {
+        const { gl, _vao, _globalsbuffer, program } = this;
+        gl.deleteVertexArray(_vao);
+        // gl.deleteBuffer(_attbuffer);
+        gl.deleteBuffer(_globalsbuffer);
+        gl.deleteProgram(program);
+    }
+}

package/timetracks/readme.md

@@ -0,0 +1 @@
+TODO: delete program, programpoint, maybe adaptors. which are related to the old version of this plugin.

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "target": "es2022",
+        "module": "es2015",
+        "outDir": "./dist",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "allowJs": true,
+        "declaration": false
+    },
+    "include": [
+        "**/*.ts", // Include all .ts files in the current directory and subdirectories
+        "**/*.js" // Include all .js files in the current directory and subdirectories
+    ],
+    "exclude": [
+        "node_modules",
+        "dist", // Exclude the output directory itself
+        "./tests/**/*" // Exclude tests directory
+    ]
+}

package/types.ts

@@ -0,0 +1,265 @@
+
+
+export type TypedArray =
+    Float32Array | Float64Array |
+    Int32Array | Int16Array | Int8Array |
+    Uint32Array | Uint16Array | Uint8Array | Uint8ClampedArray;
+
+
+export type Color = [number, number, number, number] | Float32Array; // RGBA color format 0-1 
+export type LongLat = [number, number]; // [longitude, latitude]
+export type CentigradeDegree = number;
+export type Meter = number;
+export type Radians = number;
+
+export type ColorRatio = {
+    color: Color;
+    ratio: CentigradeDegree;
+};
+
+export type BUFFER_TYPE = "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW";
+
+
+export type DRAW_MODE = 'LINE_STRIP' | 'TRIANGLE_FAN' | 'TRIANGLES' | 'POINTS' | 'LINES' | 'LINE_LOOP' | 'TRIANGLE_STRIP' | 'LINE_STRIP_ADJACENCY' | 'TRIANGLE_STRIP_ADJACENCY' | 'LINES_ADJACENCY' | 'PATCHES';
+
+
+export type GlobeLookInfo = {
+    CenterLong: CentigradeDegree;
+    CenterLat: CentigradeDegree;
+    Distance: Meter;
+    Tilt: CentigradeDegree;
+    NorthAng: CentigradeDegree;
+}
+
+
+
+interface GlobeMath {
+    FindPointByPolar(
+        centerLong: CentigradeDegree,
+        centerLat: CentigradeDegree,
+        distance: Meter,
+        azimuth: CentigradeDegree
+    ): { long: CentigradeDegree, lat: CentigradeDegree };
+    GetDist2D(
+        long1: CentigradeDegree,
+        lat1: CentigradeDegree,
+        long2: CentigradeDegree,
+        lat2: CentigradeDegree
+    ): Meter;
+    GetAzimuthAngle(
+        long1: CentigradeDegree,
+        lat1: CentigradeDegree,
+        long2: CentigradeDegree,
+        lat2: CentigradeDegree
+    ): CentigradeDegree;
+}
+
+
+
+
+
+
+export interface TextFont {
+    name: string;
+    textColor: string;
+    hollowColor: string;
+    size: number;
+    hollow: boolean;
+    bold: boolean;
+    italic: boolean;
+    position?: string;
+}
+
+
+export interface Globe {
+    DrawRender(): void;
+    api_ScrW(): number;
+    api_ScrH(): number;
+    api_GetCurrentGeometry(): 0 | 1;
+    api_GetCurrentLODWithDecimal(): number;
+    api_GetCurrentWorldWH(): { width: number; height: number };
+    api_GetCurrentLookInfo(): GlobeLookInfo;
+    api_GetCartesian3DPoint: (long: number, lat: number, height: number, msl: boolean) => [number, number, number];
+    api_GetMercator2DPoint: (long: number, lat: number) => [number, number];
+    api_IsScreenMoving(): boolean;
+    api_GetMouseDeg(): { long: number; lat: number } | null;
+    api_GetZScale(): number;
+    api_SetZScale(zScale: number): void; // Max 4 
+    api_DrawContextTextMultiLine(text: string, textFont: TextFont, opacity: number, position: 
+        { x: number; y: number }, angleIsOn: boolean, angle: number | null): void;
+    api_GetScreenPointFromGeo(coords: { long: number; lat: number; z: number }, isMSL: boolean): 
+        { x: number | null; y: number | null };
+    api_GetCurrentWorldLimit(): { ur: { x: number; y: number }; ll: { x: number; y: number } };
+    gl: WebGL2RenderingContext;
+    Fp: { x: number; y: number; z: number };
+    FUPos: { x: number; y: number; z: number };
+    Math: GlobeMath;
+    ObjectArray: ObjectArray;
+}
+
+
+
+export type GlobeChanges = {
+    geometry: boolean;
+    look: boolean;
+    lod: boolean;
+    lod2DWheel: boolean;
+    elevationScale: boolean;
+    screenMoved: boolean;
+}
+
+export type ChargerInput = {
+    totalTime: number;
+    ratio: number;
+    acceleration: number;
+}
+
+
+export type DrawRange = {
+    first: number;
+    count: number;
+};
+
+
+export type DrawRangeIndexParams = {
+    drawRange: DrawRange;
+    elementBuffer?: WebGLBuffer;
+    elementBufferIndexType?: number;
+    drawMode?: number;
+};
+
+
+export interface ProgramInterface {
+    draw(vao: WebGLVertexArrayObject, drawOptions: DrawRangeIndexParams, opacity: number, flexibleUBO: UBOHandler | null): void;
+    createUBO(bufferReadType?: "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW"): UBOHandler;
+    createVAO(...inputs: (BufferAndReadInfo | null)[]): WebGLVertexArrayObject;
+    free(): void;
+}
+
+
+export interface PluginInterface {
+    id: string;
+    init(globe: Globe, gl: WebGL2RenderingContext): void;
+    draw3D(projectionMatrix: Float32Array, modelViewMatrix: Float32Array, transPosition: { x: number, y: number, z: number }): void;
+    free(): void;
+}
+
+
+
+export type BufferAndReadInfo = {
+    buffer: WebGLBuffer;
+    stride: number;
+    offset: number;
+} | null;
+
+
+export type AttributeLoaderOptions = {
+    divisor?: number | null;
+    type?: number | null;
+    escapeValues?: Array<number> | null;
+    normalized?: boolean;
+}
+
+export type UBOHandler = {
+    ubo: WebGLBuffer;
+    update: (nameValueMap: Map<string, any>) => void;
+    updateSingle: (name: string, value: Float32Array | Int32Array | DataView | ArrayBuffer) => void;
+    bind: () => void;
+    unbind: () => void;
+    free: () => void;
+};
+
+
+export type PluginAttachmentParameters = {
+    plugin: PluginInterface;
+    freeOnUnregister?: boolean;
+}
+
+
+
+export interface ElevationMode {
+    setElevationMode(mode: "agl" | "msl"): void;
+}
+
+export interface UpdateColor {
+    updateColors(keyColorCouples: { key: string, color: Color }[], drawRender: boolean): void;
+}
+
+
+// OBJECT ARRAY START
+
+
+export interface ObjectArray {
+    Add(object: LayerObjectObjectArray): void;
+    Delete(id: string): void;
+    GetDefaultStyle(): StyleObjectArray;
+    StyleChanged(object: LayerObjectObjectArray): void;
+    UpdateData(object: LayerObjectObjectArray, mode: any, buckets: DataBucketObjectArray[], options: { attribs: boolean; icon: boolean; text: boolean }): void;
+    SetData(object: LayerObjectObjectArray, data: DataBucketObjectArray): void;
+}
+
+export interface StyleObjectArray {
+    fidKey: string;
+    opacity: number;
+    labels: LabelObjectArray[];
+}
+
+export interface LabelObjectArray {
+    offset: { x: number; y: number };
+    fontFamily: { hollowWidth: number };
+    vAlignment: number;
+    hAlignment: number;
+    size: number;
+    text: string;
+}
+
+export interface LayerObjectObjectArray {
+    displayName: string;
+    layerType: number;
+    wkbGeom: null;
+    wfsLayerName: null;
+    objectType: string;
+    bbox: null;
+    startLod: number;
+    endLod: number;
+    continuousLOD: boolean;
+    MVTXYZName: string;
+    rasterize: boolean;
+    style: StyleObjectArray;
+    id: string;
+}
+
+export interface DataBucketObjectArray {
+    coords: number[];
+    coordsZ: number[];
+    attribs: Record<string, any>[];
+}
+
+
+
+// OBJECT ARRAY FINISH
+
+
+//  GLOBE MANAGER
+
+interface GlobeManager {
+    /**
+     * When mesh service is not working call this method with (false, true) it fixes issues
+     * @param retry 
+     * @param divideMeshFurther 
+     */
+  api_ReTryAtMeshTimeout(retry: boolean, divideMeshFurther: boolean): void; 
+}
+
+export enum CSMeasureTextPositionTypes {
+    CENTER= 'center',
+    LEFT= 'left',
+    RIGHT= 'right',
+    TOP= 'bottom',
+    BOTTOM= 'top',
+    TOP_LEFT= 'bottom_left',
+    TOP_RIGHT= 'bottom_right',
+    BOTTOM_LEFT= 'top_left',
+    BOTTOM_RIGHT= 'top_right',
+};
+