@pirireis/webglobeplugins 0.12.0-alpha → 0.14.0-alpha

package/semiplugins/shape-on-terrain/derived/padding-plugin.js

@@ -0,0 +1,96 @@
+import { ArcOnTerrainPlugin } from "../arc-plugin";
+const EDGE_COUNT = 5;
+const paddingKeys = (padding) => {
+    const stepCount = padding.coverAngle / padding.stepAngle;
+    const keys = new Array(Math.ceil(stepCount));
+    for (let i = 0; i < stepCount; i++) {
+        keys[i] = padding.key + i;
+    }
+    if (keys.length > stepCount) {
+        keys[keys.length - 1] = padding.key + stepCount;
+    }
+    return keys;
+};
+const adapterPadding2Arc = (globe, padding) => {
+    const stepCount = padding.coverAngle / padding.stepAngle;
+    const result = new Array(Math.ceil(stepCount));
+    const fill = (i, angle) => {
+        const startPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.outerRadius, angle);
+        const endPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.innerRadius, angle);
+        result[i] = {
+            key: padding.key + i,
+            start: [startPoint.long, startPoint.lat],
+            end: [endPoint.long, endPoint.lat],
+            color: padding.color,
+            height: padding.height,
+        };
+    };
+    for (let i = 0; i < stepCount; i++) {
+        const angle = padding.startAngle + i * padding.stepAngle;
+        fill(i, angle);
+    }
+    if (result.length > stepCount) {
+        const i = result.length - 1;
+        const angle = padding.startAngle + padding.coverAngle;
+        fill(i, angle);
+    }
+    return result;
+};
+export const chargerAdaptor = (chargerInput, plugin, padding) => {
+};
+export class PaddingPlugin {
+    id;
+    arcPlugin;
+    _memory = new Map();
+    isFreed = false;
+    constructor(id) {
+        this.id = id;
+        this.arcPlugin = new ArcOnTerrainPlugin(id, {
+            cameraAttractionIsOn: false,
+            vertexCount: EDGE_COUNT,
+        });
+    }
+    insertBulk(items, globe) {
+        for (const padding of items) {
+            this.__delete(padding.key);
+            this._memory.set(padding.key, padding);
+        }
+        const arcInputs = items.flatMap(padding => adapterPadding2Arc(globe, padding));
+        this.arcPlugin.insertBulk(arcInputs);
+    }
+    deleteBulk(keys) {
+        const arcKeys = keys.flatMap(key => paddingKeys({ key, center: [0, 0], outerRadius: 0, innerRadius: 0, startAngle: 0, coverAngle: 0, stepAngle: 0, color: [0, 0, 0, 1] }));
+        this.arcPlugin.deleteBulk(arcKeys);
+    }
+    updateColor(key, color) {
+        // TODO: get all padding keys and update all of them
+        if (!this._memory.has(key)) {
+            console.warn(`Padding with key ${key} does not exist.`);
+            return;
+        }
+        const keys = paddingKeys(this._memory.get(key));
+        for (let i = 0; i < keys.length; i++) {
+            this.arcPlugin.updateColor(keys[i], color);
+        }
+    }
+    __delete(key) {
+        const padding = this._memory.get(key);
+        if (padding) {
+            const keys = paddingKeys(padding);
+            this.arcPlugin.deleteBulk(keys);
+            this._memory.delete(key);
+        }
+    }
+    init(globe, gl) {
+        this.arcPlugin.init(globe, gl);
+    }
+    draw3D() {
+        this.arcPlugin.draw3D();
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        this.isFreed = true;
+        this.arcPlugin.free();
+    }
+}

package/semiplugins/type.js

@@ -0,0 +1 @@
+export {};

package/types.js

@@ -1,12 +1 @@
-/**
- * @typedef DrawRange
- * @type {Object}
- * @property {int} first
- * @property {int} count
- *
- * @typedef DrawRangeIndexParamsClient
- * @type {Object}
- * @property {null|DrawRange} drawRange
- * @property {null|Int32List} indexes
- */
 export {};

package/util/account/create-buffermap-orchastration.js

@@ -0,0 +1,39 @@
+// IN construction
+import { BufferManager } from "./single-attribute-buffer-management/buffer-manager";
+import { BufferOrchestrator } from "./single-attribute-buffer-management/buffer-orchestrator";
+export class BufferMapOrchestrator {
+    gl;
+    bufferManagersMap;
+    bufferOrchestrator;
+    constructor(gl, bufferDetailsMap, initialCapacity = 10) {
+        this.gl = gl;
+        this.bufferManagersMap = new Map();
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
+        for (const [key, details] of bufferDetailsMap) {
+            const { itemSize, bufferType, adaptor } = details;
+            const bufferManager = new BufferManager(gl, itemSize, { bufferType, initialCapacity });
+            this.bufferManagersMap.set(key, { bufferManager, adaptor });
+        }
+    }
+    insertBulk(items) {
+        // @ts-ignore
+        this.bufferOrchestrator.insertBulk(items, this.bufferManagersMap);
+    }
+    updateBulk(items, bufferKeys = []) {
+        // @ts-ignore
+        this.bufferOrchestrator.updateBulk(items, this.bufferManagersMap, bufferKeys);
+    }
+    deleteBulk(keys) {
+        // @ts-ignore
+        this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersMap);
+    }
+    resetWithCapacity(capacity) {
+        this.bufferOrchestrator.resetWithCapacity(this.bufferManagersMap, capacity);
+    }
+    free() {
+        for (const [key, { bufferManager }] of this.bufferManagersMap) {
+            bufferManager.free();
+        }
+        this.bufferManagersMap.clear();
+    }
+}

package/util/account/index.js

@@ -1,3 +1,3 @@
-import BufferOffsetManager from './bufferoffsetmanager';
-export { BufferOffsetManager };
+// import BufferOffsetManager from './bufferoffsetmanager';
+// export { BufferOffsetManager };
 export * from './single-attribute-buffer-management/index';

package/util/account/single-attribute-buffer-management/buffer-manager.js

@@ -22,13 +22,12 @@ export class BufferManager {
     itemSize;
     bufferType;
     isFreed = false;
-    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
+    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = 10 } = {}) {
         this.gl = gl;
         this.itemSize = itemSize;
         this.bufferType = bufferType;
         this.buffer = buffer === null ? gl.createBuffer() : buffer;
-        if (initialCapacity !== null)
-            this.resetWithCapacity(initialCapacity);
+        this.resetWithCapacity(initialCapacity);
     }
     resetWithCapacity(capacity) {
         const { gl, buffer, bufferType, itemSize } = this;

package/util/account/single-attribute-buffer-management/buffer-orchestrator.js

@@ -19,7 +19,7 @@ export class BufferOrchestrator {
         this.tombstoneOffsets = [];
         this._length = 0;
     }
-    insertBulk(items, bufferManagersMap) {
+    insertBulk(items, bufferManagersMap, bufferKeys = null) {
         this.ensureSpace(items.length, bufferManagersMap);
         const { offsetMap } = this;
         const offsets = [];
@@ -29,8 +29,19 @@ export class BufferOrchestrator {
             offsetMap.set(item.key, offset);
             offsets.push(offset);
         }
-        for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-            bufferManager.insertBulk(items.map(adaptor), offsets);
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined)
+                    throw new Error("insertBulk bufferKey does not exist");
+                const { bufferManager, adaptor } = bufferManagerComp;
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+        else {
+            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
         }
     }
     // does not assign offset to the new items.

package/util/build-strategy/static-dynamic.js

@@ -17,7 +17,7 @@ export class StaticDynamicStrategy {
     updateState() {
         const currentLOD = this.globe.api_GetCurrentLODWithDecimal();
         const state = currentLOD < this._transitionLevel ? StaticDynamicState.STATIC : StaticDynamicState.DYNAMIC;
-        if (this._lastStaticDynamicState === StaticDynamicState.STATIC && state === StaticDynamicState.DYNAMIC) {
+        if (this._lastStaticDynamicState === StaticDynamicState.DYNAMIC && state === StaticDynamicState.STATIC) {
             this._staticDynamicState = StaticDynamicState.TO_STATIC;
         }
         else {

package/util/check/typecheck.js

@@ -2,7 +2,7 @@
 const doesOwnProperties = (properties, errorMessage) => {
     return (object) => {
         properties.forEach(element => {
-            if (!Object.hasOwn(object, element))
+            if (!object.hasOwnProperty(element))
                 throw new TypeError(errorMessage + ':' + element);
         });
     };
@@ -38,3 +38,17 @@ export const isBoolean = (x) => {
     if (typeof x !== "boolean")
         throw new TypeError("type must be boolean");
 };
+export const mapGetOrThrow = (errorNote) => {
+    return (mapInstance, ids) => {
+        if (!ids)
+            throw new Error("There is no map keys to get");
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const e = mapInstance.get(ids[i]);
+            if (e === undefined)
+                throw new Error(errorNote + " " + ids[i]);
+            result.push(e);
+        }
+        return result;
+    };
+};

package/util/geometry/index.js

@@ -24,8 +24,9 @@ function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
 }
 /**
  *
- * @param {Float32List} array
- * @returns {Float32Array}
+ * @param array - The array to normalize
+ * @param newLength - The target length for the normalized array
+ * @returns Normalized Float32Array
  */
 function normalize(array, newLength = 1) {
     let total = 0;

package/util/gl-util/buffer/attribute-loader.js

@@ -1,4 +1,3 @@
-import './types';
 /**
  * @typedef BufferAndReadInfo Buffers can be intertwined or interleaved.
  * This object forces user to adapt generic convention of buffer and read information.
@@ -20,10 +19,8 @@ import './types';
  * @returns
  */
 const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, type = null, escapeValues = null, normalized = false } = {}) => {
-    if (size < 1 || size > 4)
-        throw new Error("Size must be between 1 and 4");
-    if (bufferAndReadInfo == null) {
-        if (escapeValues !== null)
+    if (bufferAndReadInfo == null || bufferAndReadInfo.buffer == null) {
+        if (escapeValues)
             constantFunction(gl, index, size, escapeValues);
         return;
     }

package/util/gl-util/draw-options/methods.js

@@ -1,17 +1,16 @@
-import './types';
 /**
  * Draws instanced geometry using WebGL2.
  */
 const drawInstanced = (gl, mode, drawOptions, vertexCount) => {
     const { drawRange, elementBufferIndexType = gl.UNSIGNED_INT } = drawOptions;
-    const { first = 0, count: instanceCount = 1 } = drawRange;
-    if (first > 0 || drawOptions.elementBuffer) {
+    const { first = 0, count } = drawRange;
+    if (drawOptions.elementBuffer) {
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, drawOptions.elementBuffer ?? null);
-        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, instanceCount);
+        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, count);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
     }
     else {
-        gl.drawArraysInstanced(mode, first, vertexCount, instanceCount);
+        gl.drawArraysInstanced(mode, first, vertexCount, count);
     }
 };
 /**

package/util/webglobjectbuilders.js

@@ -34,8 +34,7 @@ export function createShader(gl, type, source) {
 export function createProgram(gl, vertexSource, fragmentSource) {
     const program = gl.createProgram();
     if (!program) {
-        console.error("Failed to create WebGLProgram.");
-        return undefined;
+        throw new Error("Failed to create WebGLProgram.");
     }
     let vertexShader;
     let fragmentShader;
@@ -45,18 +44,14 @@ export function createProgram(gl, vertexSource, fragmentSource) {
     }
     catch (e) { // Catching errors from createShader
         console.error(e.message);
-        gl.deleteProgram(program); // Clean up the program if shaders failed
-        return undefined;
+        throw new Error(`Shader creation failed: ${e.message}`);
     }
     gl.attachShader(program, vertexShader);
     gl.attachShader(program, fragmentShader);
     gl.linkProgram(program);
     if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-        console.error("Failed to link WebGL program:", gl.getProgramInfoLog(program));
-        gl.deleteProgram(program);
-        gl.deleteShader(vertexShader);
-        gl.deleteShader(fragmentShader);
-        return undefined;
+        // console.error("Failed to link WebGL program:", gl.getProgramInfoLog(program));
+        throw new Error(`Error linking program:\n${gl.getProgramInfoLog(program)}`);
     }
     // Detach and delete shaders after linking to free up resources
     gl.detachShader(program, vertexShader);

package/write-text/context-text3.js

@@ -1,3 +1,4 @@
+// @ts-ignore
 import { CSZMode } from "@pirireis/webglobe";
 import { isTextFont, opacityCheck } from "../util/check/typecheck";
 /**
@@ -9,6 +10,22 @@ import { isTextFont, opacityCheck } from "../util/check/typecheck";
  * TODO: key check and raise error if doesnt exist
  */
 export class ContextTextWriter3 {
+    globe;
+    itemMap;
+    // @ts-ignore
+    style;
+    doDraw;
+    textAdaptor;
+    coordinatesAdaptor;
+    keyAdaptor;
+    zoomLevelAdaptor;
+    positionAdaptor;
+    opacityAdaptor;
+    angleOnSphere;
+    angleAdaptor;
+    angleAdaptorIsOn;
+    xOffset;
+    yOffset;
     constructor(globe, { style = {
         textFont: {
             name: 'Arial',

package/write-text/context-text3old.js

@@ -0,0 +1,152 @@
+"use strict";
+// import { CSZMode } from "@pirireis/webglobe";
+// import { isTextFont, opacityCheck } from "../util/check/typecheck";
+// /**
+//  * TODOs:
+//  * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+//  * 2) expose a mechanic to update text on zoom change
+//  * 3) extend the mechanic on 2 to other events
+//  *
+//  * TODO: key check and raise error if doesnt exist
+//  */
+// export class ContextTextWriter3 {
+//     constructor(globe, {
+//         style = {
+//             textFont: {
+//                 name: 'Arial',
+//                 textColor: '#FFFFFF', // beyaz
+//                 hollowColor: '#000000', // siyah
+//                 size: 12, // piksel
+//                 hollow: true,
+//                 bold: true,
+//                 italic: false,
+//             },
+//             opacity: 1.0,
+//             zMode: CSZMode.Z_GROUND_PERVERTEX,
+//         },
+//         xOffset = 0,
+//         yOffset = 0,
+//         doDraw = true,
+//         textAdaptor = null,
+//         coordinatesAdaptor = null,
+//         keyAdaptor = null,
+//         opacityAdaptor = null,
+//         angleAdaptor = null,
+//         angleOnSphere = false,
+//         positionAdaptor = (item, i, container, properties) => "left",
+//         zoomLevelAdaptor = (zoomLevel) => (item) => {
+//             return {
+//                 opacityMultiplier: 1,
+//                 sizeMultiplier: 1
+//             }
+//         }
+//     } = {}) {
+//         this.globe = globe;
+//         this.itemMap = new Map();
+//         this.setStyle(style);
+//         this.doDraw = doDraw;
+//         this._checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset);
+//         this.textAdaptor = textAdaptor;
+//         this.coordinatesAdaptor = coordinatesAdaptor;
+//         this.keyAdaptor = keyAdaptor;
+//         this.zoomLevelAdaptor = zoomLevelAdaptor;
+//         this.positionAdaptor = positionAdaptor;
+//         this.opacityAdaptor = opacityAdaptor ? opacityAdaptor : () => 1;
+//         this.angleOnSphere = angleOnSphere;
+//         if (angleAdaptor) {
+//             this.angleAdaptor = angleAdaptor
+//             this.angleAdaptorIsOn = true;
+//         } else {
+//             this.angleAdaptor = () => null
+//             this.angleAdaptorIsOn = false
+//         }
+//         this.xOffset = xOffset;
+//         this.yOffset = yOffset;
+//     }
+//     _checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset) {
+//         if (textAdaptor !== null) if (!(textAdaptor instanceof Function)) throw new Error("textAdaptor is not an instance of a Function");
+//         if (coordinatesAdaptor !== null) if (!(coordinatesAdaptor instanceof Function)) throw new Error("coordinatesAdaptor is not an instance of a Function");
+//         if (keyAdaptor !== null) if (!(keyAdaptor instanceof Function)) throw new Error("keyAdaptor is not an instance of a Function");
+//         if (opacityAdaptor !== null) if (!(opacityAdaptor instanceof Function)) throw new Error("opacityAdaptor is not an instance of a Function");
+//         if (angleAdaptor !== null) if (!(angleAdaptor instanceof Function)) throw new Error("angleAdaptor is not an instance of a Function");
+//         if (typeof xOffset !== "number") throw new Error("xOffset type is not a number");
+//         if (typeof yOffset !== "number") throw new Error("yOffset type is not a number");
+//     }
+//     setKeyAdaptor(adaptor) {
+//         this.keyAdaptor = adaptor;
+//     }
+//     setDoDraw(bool) {
+//         this.doDraw = bool;
+//         this.globe.DrawRender();
+//     }
+//     setStyle(style) {
+//         isTextFont(style.textFont);
+//         opacityCheck(style.opacity); //TODO: use shallow copy
+//         this.style = style;
+//         this.globe.DrawRender();
+//     }
+//     setOpacity(opacity) {
+//         this.style.opacity = opacity;
+//         this.globe.DrawRender();
+//     }
+//     draw() {
+//         if (!this.doDraw) return;
+//         const { globe, style, itemMap, xOffset, yOffset } = this;
+//         const { textFont, opacity: opacity_ } = style;
+//         const textSize = textFont.size;
+//         const is3D = globe.api_GetCurrentGeometry() === 0;
+//         const angleIsOn = is3D ? (this.angleAdaptorIsOn && this.angleOnSphere) : (this.angleAdaptorIsOn)
+//         const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+//         const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+//         for (const item of itemMap.values()) {
+//             const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+//             const { x, y } = globe.api_GetScreenPointFromGeo(
+//                 {
+//                     long: long,
+//                     lat: lat,
+//                     z: 0,
+//                 },
+//                 style.zMode === CSZMode.Z_MSL,
+//             );
+//             const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
+//             const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+//             textFont.size = sizeMultiplier * textSize;
+//             textFont.position = position;
+//             if (x !== null && y !== null) globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+//         }
+//         textFont.size = textSize;
+//     }
+//     insertTextBulk(container, properties) {
+//         container.forEach((v, i, c) => {
+//             this.insertText(v, i, c, properties);
+//         });
+//     }
+//     deleteTextBulk(keys) {
+//         for (const key of keys) {
+//             this.itemMap.delete(key);
+//         }
+//     }
+//     insertText(item, id, container, properties) {
+//         const key = this.keyAdaptor(item, id, container, properties)
+//         const coords = this.coordinatesAdaptor(item, id, container, properties)
+//         if (coords == null) {
+//             this.itemMap.delete(key);
+//             return;
+//         }
+//         const text = this.textAdaptor(item, id, container, properties)
+//         if (text == null) {
+//             this.itemMap.delete(key);
+//             return
+//         };
+//         const opacity = this.opacityAdaptor(item, id, container, properties);
+//         const angle = this.angleAdaptor(item, id, container, properties);
+//         const position = this.positionAdaptor(item, id, container, properties);
+//         this.itemMap.set(key, { long: coords.long, lat: coords.lat, text, opacity, angle, zPayload: item, position });
+//     }
+//     clear() {
+//         this.itemMap.clear();
+//     }
+//     free() {
+//         this.itemMap = null;
+//     }
+// }