@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/semiplugins/shape-on-terrain/terrain-polygon/adapters.js

@@ -0,0 +1,55 @@
+function geoJSONToTerrainPolygon(geojson, keyAdapter, colorAdapter) {
+    if (geojson.type !== 'FeatureCollection') {
+        throw new Error('Invalid GeoJSON: Expected FeatureCollection');
+    }
+    const features = geojson.features;
+    const polygons = [];
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        const key = keyAdapter(feature);
+        const color = colorAdapter(feature);
+        const geometries = [];
+        if (geometry.type === 'Polygon') {
+            const coordinates = geometry.coordinates;
+            const vertices = [];
+            const holes = [];
+            let holeIndex = 0;
+            for (let i = 0; i < coordinates.length; i++) {
+                if (i > 0) {
+                    holeIndex += coordinates[i - 1].length;
+                    holes.push(holeIndex);
+                }
+                for (const coord of coordinates[i]) {
+                    vertices.push(coord[0], coord[1]);
+                }
+            }
+            geometries.push({ vertices, holes });
+        }
+        else if (geometry.type === 'MultiPolygon') {
+            const multiCoordinates = geometry.coordinates;
+            for (const coordinates of multiCoordinates) {
+                const vertices = [];
+                const holes = [];
+                let holeIndex = 0;
+                for (let i = 0; i < coordinates.length; i++) {
+                    if (i > 0) {
+                        holeIndex += coordinates[i - 1].length;
+                        holes.push(holeIndex);
+                    }
+                    for (const coord of coordinates[i]) {
+                        vertices.push(coord[0], coord[1]);
+                    }
+                }
+                geometries.push({ vertices, holes });
+            }
+        }
+        else {
+            continue; // Skip non-polygon geometries
+        }
+        if (geometries.length > 0) {
+            polygons.push({ key, color, geometry: geometries });
+        }
+    }
+    return polygons;
+}
+export { geoJSONToTerrainPolygon };

package/semiplugins/shape-on-terrain/terrain-polygon/data/cache.js

@@ -0,0 +1,102 @@
+import { createTriangleTessellationMeta } from "../../../../Math/tessellation/triangle-tessellation";
+import { triangulation } from "./polygon-to-triangles";
+import RBush from "rbush";
+import { RADIAN } from "../../../../Math/methods";
+// TODO: use type instead of any
+function _entry(polygon, kmThreshold) {
+    __polygonInputWGS84ToRadian(polygon);
+    const trianglesData = triangulation(polygon, kmThreshold);
+    const cacheTriangles = [];
+    for (let i = 0; i < trianglesData.indices.length; i += 3) {
+        const idx0 = trianglesData.indices[i] * 2;
+        const idx1 = trianglesData.indices[i + 1] * 2;
+        const idx2 = trianglesData.indices[i + 2] * 2;
+        const v0 = [trianglesData.vertices[idx0], trianglesData.vertices[idx0 + 1]];
+        const v1 = [trianglesData.vertices[idx1], trianglesData.vertices[idx1 + 1]];
+        const v2 = [trianglesData.vertices[idx2], trianglesData.vertices[idx2 + 1]];
+        const tessellationMeta = createTriangleTessellationMeta(v0, v1, v2);
+        cacheTriangles.push({
+            polygon: polygon,
+            offset: i / 3,
+            tessellationMeta: tessellationMeta,
+            minX: tessellationMeta.bbox.min[0],
+            minY: tessellationMeta.bbox.min[1],
+            maxX: tessellationMeta.bbox.max[0],
+            maxY: tessellationMeta.bbox.max[1],
+        });
+    }
+    return cacheTriangles;
+}
+function __polygonInputWGS84ToRadian(polygon) {
+    for (const geom of polygon.geometry) {
+        const vertices = geom.vertices;
+        for (let i = 0; i < vertices.length / 2; i++) {
+            vertices[i * 2] = vertices[i * 2] * RADIAN;
+            vertices[i * 2 + 1] = vertices[i * 2 + 1] * RADIAN;
+        }
+    }
+}
+export class Cache {
+    cache = new Map();
+    kmThreshold;
+    rbush = new RBush();
+    bboxes = [];
+    constructor(kmThreshold) {
+        this.kmThreshold = kmThreshold;
+    }
+    clear() {
+        this.cache.clear();
+        this.rbush.clear();
+    }
+    insert(key, polygon) {
+        if (this.cache.has(key)) {
+            this.remove(key);
+        }
+        const triangles = _entry(polygon, this.kmThreshold);
+        this.rbush.load(triangles);
+        this.cache.set(key, { polygon: polygon, triangles });
+    }
+    remove(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            for (const triangle of entry.triangles) {
+                this.rbush.remove(triangle);
+            }
+            this.cache.delete(key);
+        }
+    }
+    setBBOXes(BBOXES) {
+        this.bboxes = BBOXES;
+    }
+    search() {
+        const results = new Set();
+        for (const bbox of this.bboxes) {
+            const { minX, minY, maxX, maxY } = bbox;
+            if (minX <= maxX && minY <= maxY) {
+                // Normal case
+                const partialResults = this.rbush.search({ minX, minY, maxX, maxY });
+                for (const res of partialResults) {
+                    results.add(res);
+                }
+            }
+            else {
+                // Handle antimeridian crossing
+                // MinX > MaxX case is the signal.
+                const partialResults1 = this.rbush.search({ minX, minY, maxX: Math.PI, maxY });
+                const partialResults2 = this.rbush.search({ minX: -Math.PI, minY, maxX, maxY });
+                for (const res of partialResults1) {
+                    results.add(res);
+                }
+                for (const res of partialResults2) {
+                    results.add(res);
+                }
+            }
+        }
+        return results;
+    }
+    defragment() {
+        const allItems = this.rbush.all();
+        this.rbush.clear();
+        this.rbush.load(allItems);
+    }
+}

package/semiplugins/shape-on-terrain/terrain-polygon/data/index-polygon-map.js

@@ -0,0 +1,45 @@
+export class IndexPolygonMap {
+    _indexPolygonMap = new Map();
+    _polygonKeyMap = new Map();
+    _thumbstones = [];
+    _polygonIndex = 1; // 0 index is null
+    constructor() { }
+    newIndex() {
+        if (this._thumbstones.length > 0) {
+            return this._thumbstones.pop();
+        }
+        return this._polygonIndex++;
+    }
+    insertBulk(polygons) {
+        for (const poly of polygons) {
+            if (this._polygonKeyMap.has(poly.key)) {
+                this.deleteBulk([poly.key]);
+            }
+            const index = this.newIndex();
+            // @ts-ignore
+            poly.index = index; // Assign the new index to the polygon
+            this._indexPolygonMap.set(index, poly);
+            this._polygonKeyMap.set(poly.key, index);
+        }
+        return polygons;
+    }
+    deleteBulk(keys) {
+        for (const key of keys) {
+            const index = this._polygonKeyMap.get(key);
+            if (index === undefined)
+                continue;
+            this._polygonKeyMap.delete(key);
+            this._indexPolygonMap.delete(index);
+            this._thumbstones.push(index);
+        }
+    }
+    get(index) {
+        return this._indexPolygonMap.get(index) || null;
+    }
+    clear() {
+        this._indexPolygonMap.clear();
+        this._polygonKeyMap.clear();
+        this._thumbstones = [];
+        this._polygonIndex = 1;
+    }
+}

package/semiplugins/shape-on-terrain/terrain-polygon/data/manager.js

@@ -0,0 +1,4 @@
+"use strict";
+// this is the glue binds data to plugin
+// plugin inserts data to this.
+// plugin send bboxes and zoom levels and expects data ready to be looaded on polygon program

package/semiplugins/shape-on-terrain/terrain-polygon/data/master-worker.js

@@ -0,0 +1,177 @@
+/// <reference lib="webworker" />
+const _workers = [];
+const _workerMap = new Map();
+let _maxWorkers = 4; // Default, updated in init
+let _nextWorkerIndex = 0;
+// Configuration state to pass to new workers or re-broadcast
+let _pickableState;
+let _variativeColorsOn;
+// Initialize workers
+function initWorkers() {
+    _maxWorkers = Math.max(1, (navigator.hardwareConcurrency || 4) - 1);
+    for (let i = 0; i < _maxWorkers; i++) {
+        addWorker();
+    }
+}
+function addWorker() {
+    // @ts-ignore
+    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: 'module' });
+    const wrapper = {
+        worker,
+        inProgress: false,
+        insertDeleteQueue: [],
+        lastBBOXData: null,
+        itemCount: 0,
+        lastOutput: null
+    };
+    worker.onmessage = (event) => {
+        wrapper.inProgress = false;
+        wrapper.lastOutput = event.data;
+        mergeAndSendResults();
+        sendToSubWorker(wrapper);
+    };
+    // Initialize sub-worker with current global state
+    worker.postMessage({
+        pickableState: _pickableState,
+        variativeColorsOn: _variativeColorsOn,
+        insertDeleteQueue: [],
+        bboxes: null,
+    });
+    _workers.push(wrapper);
+}
+function mergeAndSendResults() {
+    let totalVec3s = 0;
+    let totalIndices = 0;
+    let totalLongLats = 0;
+    let totalPickIndices = 0;
+    let totalVariativeColors = 0;
+    const validOutputs = [];
+    for (const w of _workers) {
+        if (w.lastOutput) {
+            validOutputs.push(w.lastOutput);
+            totalVec3s += w.lastOutput.vec3s.length;
+            totalIndices += w.lastOutput.indices.length;
+            totalLongLats += w.lastOutput.longLats.length;
+            if (w.lastOutput.pickIndices)
+                totalPickIndices += w.lastOutput.pickIndices.length;
+            if (w.lastOutput.variativeColors)
+                totalVariativeColors += w.lastOutput.variativeColors.length;
+        }
+    }
+    if (validOutputs.length === 0)
+        return;
+    const merged = {
+        vec3s: new Float32Array(totalVec3s),
+        indices: new Uint32Array(totalIndices),
+        longLats: new Float32Array(totalLongLats),
+        pickIndices: totalPickIndices > 0 ? new Float32Array(totalPickIndices) : null,
+        variativeColors: totalVariativeColors > 0 ? new Float32Array(totalVariativeColors) : null
+    };
+    let offsetVec3s = 0;
+    let offsetIndices = 0;
+    let offsetLongLats = 0;
+    let offsetPickIndices = 0;
+    let offsetVariativeColors = 0;
+    let vertexOffset = 0;
+    for (const out of validOutputs) {
+        merged.vec3s.set(out.vec3s, offsetVec3s);
+        offsetVec3s += out.vec3s.length;
+        for (let i = 0; i < out.indices.length; i++) {
+            merged.indices[offsetIndices + i] = out.indices[i] + vertexOffset;
+        }
+        offsetIndices += out.indices.length;
+        vertexOffset += out.vec3s.length / 3;
+        merged.longLats.set(out.longLats, offsetLongLats);
+        offsetLongLats += out.longLats.length;
+        if (merged.pickIndices && out.pickIndices) {
+            merged.pickIndices.set(out.pickIndices, offsetPickIndices);
+            offsetPickIndices += out.pickIndices.length;
+        }
+        if (merged.variativeColors && out.variativeColors) {
+            merged.variativeColors.set(out.variativeColors, offsetVariativeColors);
+            offsetVariativeColors += out.variativeColors.length;
+        }
+    }
+    // Send merged result to Main Thread
+    self.postMessage(merged, [
+        merged.vec3s.buffer,
+        merged.indices.buffer,
+        merged.longLats.buffer,
+        ...(merged.pickIndices ? [merged.pickIndices.buffer] : []),
+        ...(merged.variativeColors ? [merged.variativeColors.buffer] : [])
+    ]);
+}
+function sendToSubWorker(wrapper) {
+    if (wrapper.inProgress)
+        return;
+    if (wrapper.insertDeleteQueue.length === 0 && wrapper.lastBBOXData === null)
+        return;
+    wrapper.inProgress = true;
+    wrapper.worker.postMessage({
+        pickableState: undefined, // State is set on init, only send updates if needed
+        variativeColorsOn: undefined,
+        bboxes: wrapper.lastBBOXData,
+        insertDeleteQueue: wrapper.insertDeleteQueue,
+    });
+    wrapper.lastBBOXData = null;
+    wrapper.insertDeleteQueue = [];
+}
+function triggerAllWorkers() {
+    for (const w of _workers) {
+        sendToSubWorker(w);
+    }
+}
+// Handle messages from Main Thread
+self.onmessage = (event) => {
+    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
+    // Initialize if not already done
+    if (_workers.length === 0) {
+        _pickableState = pickableState;
+        _variativeColorsOn = variativeColorsOn;
+        initWorkers();
+    }
+    // Handle BBOX updates
+    if (bboxes) {
+        for (const w of _workers) {
+            w.lastBBOXData = bboxes;
+        }
+    }
+    // Handle Insert/Delete
+    if (insertDeleteQueue && insertDeleteQueue.length > 0) {
+        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
+            _workerMap.clear();
+            for (const w of _workers) {
+                w.insertDeleteQueue = ["__CLEAR_ALL_ITEMS__"];
+                w.itemCount = 0;
+                w.lastOutput = null;
+            }
+        }
+        else {
+            for (const item of insertDeleteQueue) {
+                if (typeof item === 'string') {
+                    // Delete
+                    const workerIdx = _workerMap.get(item);
+                    if (workerIdx !== undefined) {
+                        _workers[workerIdx].insertDeleteQueue.push(item);
+                        _workers[workerIdx].itemCount--;
+                        _workerMap.delete(item);
+                    }
+                }
+                else {
+                    // Insert
+                    let workerIdx = _workerMap.get(item.key);
+                    if (workerIdx === undefined) {
+                        workerIdx = _nextWorkerIndex;
+                        _workerMap.set(item.key, workerIdx);
+                        _workers[workerIdx].itemCount++;
+                        _nextWorkerIndex = (_nextWorkerIndex + 1) % _workers.length;
+                    }
+                    _workers[workerIdx].insertDeleteQueue.push(item.key);
+                }
+            }
+        }
+    }
+    // Trigger all workers to process the new data
+    triggerAllWorkers();
+};
+export {};

package/semiplugins/shape-on-terrain/terrain-polygon/data/polygon-to-triangles.js

@@ -0,0 +1,100 @@
+/**
+ * # Purpose
+ * Divide long edges of polygons into smaller segments
+ *
+ * This algorithm should be called after earcutting / triangulation.
+ * Then earcut should run second time to further divide long edges.
+ *
+ * populate points on a arc between two given points on a sphere
+ *
+ */
+import { haversine } from "../../../../Math/haversine";
+import earcut from "earcut";
+/**
+ *
+ */
+function __pointsInBetweenGreateCircle(lat1, lon1, lat2, lon2, unitSphereDistance) {
+    const points = [];
+    const d1 = haversine(lat1, lon1, lat2, lon2);
+    if (d1 <= unitSphereDistance) {
+        return null;
+    }
+    const numSegments = Math.ceil(d1 / unitSphereDistance);
+    for (let i = 1; i < numSegments; i++) {
+        const f = i / numSegments;
+        const A = Math.sin((1 - f) * d1) / Math.sin(d1);
+        const B = Math.sin(f * d1) / Math.sin(d1);
+        const x = A * Math.cos(lat1) * Math.cos(lon1) + B * Math.cos(lat2) * Math.cos(lon2);
+        const y = A * Math.cos(lat1) * Math.sin(lon1) + B * Math.cos(lat2) * Math.sin(lon2);
+        const z = A * Math.sin(lat1) + B * Math.sin(lat2);
+        const latN = Math.atan2(z, Math.sqrt(x * x + y * y));
+        const lonN = Math.atan2(y, x);
+        points.push(latN, lonN);
+    }
+    return points;
+}
+function _dividePolygonEdgeSize(polygon, kmThreshold) {
+    const unitSphereDistance = kmThreshold / 6371; // Earth radius in km
+    const newGeometries = polygon.geometry.map(geom => {
+        const { vertices, holes } = geom;
+        const newVertices = [];
+        const newHoles = [];
+        const processRing = (start, end) => {
+            for (let i = start; i < end; i++) {
+                const long1 = vertices[2 * i];
+                const lat1 = vertices[2 * i + 1];
+                const next_i = (i + 1 < end) ? i + 1 : start;
+                const long2 = vertices[2 * next_i];
+                const lat2 = vertices[2 * next_i + 1];
+                newVertices.push(long1, lat1);
+                const extraPoints = __pointsInBetweenGreateCircle(lat1, long1, lat2, long2, unitSphereDistance);
+                if (extraPoints) {
+                    newVertices.push(...extraPoints);
+                }
+            }
+        };
+        const shellEnd = holes.length > 0 ? holes[0] : vertices.length / 2;
+        processRing(0, shellEnd);
+        for (let h = 0; h < holes.length; h++) {
+            newHoles.push(newVertices.length / 2);
+            const holeStart = holes[h];
+            const holeEnd = h + 1 < holes.length ? holes[h + 1] : vertices.length / 2;
+            processRing(holeStart, holeEnd);
+        }
+        return { vertices: newVertices, holes: newHoles };
+    });
+    return {
+        ...polygon,
+        geometry: newGeometries,
+    };
+}
+// TODO: 
+// divide TrianglesMiddleData edges longer than threshold
+// function _divideTriangleEdges(
+//     key: string,
+//     vertices: number[],
+//     indices: number[],
+//     kmThreshold: number // maybe
+// ): TrianglesMiddleData {
+//     return { key, vertices, indices };
+// }
+// TODO: NEED TEST
+function triangulation(polygon, kmThreshold) {
+    const finalVertices = [];
+    const finalIndices = [];
+    let vertexIndexOffset = 0;
+    for (const geom of polygon.geometry) {
+        const indices = earcut(geom.vertices, geom.holes, 2);
+        finalVertices.push(...geom.vertices);
+        for (const index of indices) {
+            finalIndices.push(index + vertexIndexOffset);
+        }
+        vertexIndexOffset += geom.vertices.length / 2;
+    }
+    return {
+        key: polygon.key,
+        vertices: finalVertices,
+        indices: finalIndices
+    };
+}
+export { triangulation };

package/semiplugins/shape-on-terrain/terrain-polygon/data/random.js

@@ -0,0 +1,121 @@
+/**
+ * Generates random polygon data for testing PolygonPluginInput
+ */
+/**
+ * Generates a random polygon with optional holes
+ * @param {Object} options - Configuration options
+ * @param {number} options.minVertices - Minimum number of vertices for the shell (default: 3)
+ * @param {number} options.maxVertices - Maximum number of vertices for the shell (default: 8)
+ * @param {number} options.holeCount - Number of holes to generate (default: 0)
+ * @param {number} options.minLat - Minimum latitude (default: -85)
+ * @param {number} options.maxLat - Maximum latitude (default: 85)
+ * @param {number} options.minLng - Minimum longitude (default: -180)
+ * @param {number} options.maxLng - Maximum longitude (default: 180)
+ * @param {number} options.dimensions - Number of dimensions per vertex (default: 2)
+ * @returns {Object} PolygonPluginInput object
+ */
+function generateRandomPolygon(options = {}) {
+    const { minVertices = 3, maxVertices = 8, holeCount = 0, minLat = -85, maxLat = 85, minLng = -180, maxLng = 180, dimensions = 2, radius = 4, } = options;
+    const key = `polygon_${Date.now()}_${Math.floor(Math.random() * 1000)}_${Math.random()}`;
+    const vertices = [];
+    const holes = [];
+    // Generate shell vertices
+    const shellVertexCount = Math.floor(Math.random() * (maxVertices - minVertices + 1)) + minVertices;
+    const centerLng = Math.random() * (maxLng - minLng) + minLng;
+    const centerLat = Math.random() * (maxLat - minLat) + minLat;
+    // Generate shell as a rough circle with random variations
+    for (let i = 0; i < shellVertexCount; i++) {
+        const angle = (i / shellVertexCount) * 2 * Math.PI;
+        const radiusVariation = radius * (0.7 + Math.random() * 0.6); // Add variation to radius
+        const lng = centerLng + Math.cos(angle) * radiusVariation;
+        const lat = centerLat + Math.sin(angle) * radiusVariation;
+        vertices.push(lng, lat);
+        if (dimensions > 2) {
+            for (let d = 2; d < dimensions; d++) {
+                vertices.push(Math.random() * 1000); // Random additional dimensions
+            }
+        }
+    }
+    // Generate holes
+    for (let h = 0; h < holeCount; h++) {
+        const holeStartIndex = vertices.length / dimensions;
+        holes.push(holeStartIndex);
+        const holeVertexCount = Math.floor(Math.random() * 4) + 3; // 3-6 vertices for holes
+        const holeRadius = radius * (0.2 + Math.random() * 0.3); // Smaller radius for holes
+        const holeCenterLng = centerLng + (Math.random() - 0.5) * radius * 0.8;
+        const holeCenterLat = centerLat + (Math.random() - 0.5) * radius * 0.8;
+        for (let i = 0; i < holeVertexCount; i++) {
+            const angle = (i / holeVertexCount) * 2 * Math.PI;
+            const lng = holeCenterLng + Math.cos(angle) * holeRadius;
+            const lat = holeCenterLat + Math.sin(angle) * holeRadius;
+            vertices.push(lng, lat);
+            if (dimensions > 2) {
+                for (let d = 2; d < dimensions; d++) {
+                    vertices.push(Math.random() * 1000);
+                }
+            }
+        }
+    }
+    return {
+        key,
+        geometry: [{ vertices, holes }],
+        color: [Math.random(), Math.random(), Math.random(), 1.0],
+    };
+}
+/**
+ * Generates multiple random polygons
+ * @param {number} count - Number of polygons to generate
+ * @param {Object} options - Options to pass to generateRandomPolygon
+ * @returns {Array} Array of PolygonPluginInput objects
+ */
+function generateRandomPolygons(count, options = {}) {
+    const polygons = [];
+    for (let i = 0; i < count; i++) {
+        polygons.push(generateRandomPolygon(options));
+    }
+    return polygons;
+}
+/**
+ * Generates a simple rectangular polygon for basic testing
+ * @param {number} lng - Center longitude
+ * @param {number} lat - Center latitude
+ * @param {number} width - Width in degrees
+ * @param {number} height - Height in degrees
+ * @returns {Object} PolygonPluginInput object
+ */
+function generateRectanglePolygon(lng = 0, lat = 0, width = 2, height = 1) {
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    return {
+        key: `rectangle_${Date.now()}`,
+        geometry: [{
+                vertices: [
+                    lng - halfWidth, lat - halfHeight, // Bottom-left
+                    lng + halfWidth, lat - halfHeight, // Bottom-right
+                    lng + halfWidth, lat + halfHeight, // Top-right
+                    lng - halfWidth, lat + halfHeight // Top-left
+                ],
+                holes: []
+            }]
+    };
+}
+function generateRectangleFromBBOX(bbox, key = null) {
+    const { ll, ur } = bbox;
+    return {
+        key: key || `rectangle_${Date.now()}`,
+        geometry: [{
+                vertices: [
+                    ll.x, ll.y, // Bottom-left
+                    ur.x, ll.y, // Bottom-right
+                    ur.x, ur.y, // Top-right
+                    ll.x, ur.y // Top-left
+                ],
+                holes: []
+            }]
+    };
+}
+// // Example usage:
+// console.log('Polygon with holes:', generateRandomPolygon({ holeCount: 2 }));
+// console.log('Multiple polygons:', generateRandomPolygons(3));
+// console.log('Rectangle polygon:', generateRectanglePolygon(-74, 40.7, 0.1, 0.05));
+export { generateRandomPolygon, generateRandomPolygons, generateRectanglePolygon, generateRectangleFromBBOX };

package/semiplugins/shape-on-terrain/terrain-polygon/data/types.js

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

package/semiplugins/shape-on-terrain/terrain-polygon/data/worker-contact.js

@@ -0,0 +1,63 @@
+import { DemTextureManagerCache } from "../../../../programs/totems/dem-textures-manager";
+import { RADIAN } from "../../../../Math/methods";
+export class WorkerContact {
+    _masterWorker;
+    _options;
+    onResult;
+    demTextureManager = null;
+    constructor(globe, options, onResult) {
+        this._options = options;
+        this.onResult = onResult;
+        // Initialize the Master Worker
+        // @ts-ignore
+        this._masterWorker = new Worker(new URL("./master-worker.js", import.meta.url), { type: 'module' });
+        this._masterWorker.onmessage = (event) => {
+            this.onResult(event.data);
+        };
+        // Initialize Master Worker state
+        this._masterWorker.postMessage({
+            pickableState: this._options.pickable,
+            variativeColorsOn: this._options.variativeColorsOn,
+            insertDeleteQueue: [],
+            bboxes: null,
+        });
+        this.demTextureManager = DemTextureManagerCache.get(globe);
+        this.demTextureManager.register(this);
+    }
+    setMergedTiles(mergedTilesInfo) {
+        const bboxesData = new Array(mergedTilesInfo.length);
+        for (let i = 0; i < mergedTilesInfo.length; i++) {
+            const { bbox, zoom } = mergedTilesInfo[i];
+            bboxesData[i] = {
+                zoom: zoom,
+                minX: bbox.ll.x * RADIAN,
+                minY: bbox.ll.y * RADIAN,
+                maxX: bbox.ur.x * RADIAN,
+                maxY: bbox.ur.y * RADIAN,
+            };
+        }
+        // Send BBOX updates to Master Worker
+        this._masterWorker.postMessage({
+            bboxes: bboxesData
+        });
+    }
+    free() {
+        this.demTextureManager.unregister(this);
+        this._masterWorker.terminate();
+    }
+    insertBulk(polygons) {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: polygons
+        });
+    }
+    deleteBulk(keys) {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: keys
+        });
+    }
+    clear() {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: ["__CLEAR_ALL_ITEMS__"]
+        });
+    }
+}