@pirireis/webglobeplugins 0.6.49-a → 0.7.0

package/point-heat-map/point-to-heat-map-flow.js

@@ -0,0 +1,155 @@
+import { densityToLegendProgramCache } from "../programs/data2legend/density-to-legend";
+import { pointToDensityTextureCache } from "../programs/data2legend/point-to-density-texture";
+import { textureOnCanvasProgramCache } from "../util/programs/draw-texture-on-canvas";
+import { defaultblendfunction } from "../util/webglobe/gldefaultstates";
+class PointHeatmapFlow {
+
+    constructor(globe) {
+        this.globe = null;
+        this.gl = null;
+        this.program = null;
+        this.densityToLegendProgram = null;
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.pointToDensityProgram = pointToDensityTextureCache.get(globe);
+        this.densityToLegendProgram = densityToLegendProgramCache.get(globe);
+        this.testTextureProgram = textureOnCanvasProgramCache.get(globe);
+        this._lookInfo = globe.api_GetCurrentLookInfo();
+        const { gl } = this;
+        {
+            this.buffer = gl.createBuffer();
+            this.vao2D = this.pointToDensityProgram.createVAO(this.buffer, 2);
+            this.vao3D = this.pointToDensityProgram.createVAO(this.buffer, 3);
+        }
+        { // framebuffer and texture
+            this.framebuffer = gl.createFramebuffer();
+            this.densityTexture = this._createDensityTexture();
+            this._bindTextureToFramebuffer();
+
+        }
+    }
+
+    _bindTextureToFramebuffer() {
+        const { gl, densityTexture, framebuffer } = this;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, densityTexture, 0);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    }
+
+
+    draw(legendTexture, pointSize, opacity = 1.0) {
+        const { gl, globe, framebuffer } = this;
+        if (this._drawDensityRequired || this._isVisionChanged()) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+            gl.clearColor(0, 0, 0, 0);
+            gl.viewport(
+                0, 0,
+                Math.floor(globe.api_ScrW()), Math.floor(globe.api_ScrH())
+            );
+            gl.clear(gl.COLOR_BUFFER_BIT);
+            this._drawDensity(pointSize);
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        }
+        defaultblendfunction(gl);
+        gl.viewport(0, 0, 400, 400);
+        this.testTextureProgram.draw(legendTexture, 1.0);
+        gl.viewport(0, 400, 400, 400);
+        this.testTextureProgram.draw(this.densityTexture, 1.0);
+        gl.viewport(0, 0, globe.api_ScrW(), globe.api_ScrH());
+        this._drawLegend(legendTexture, opacity);
+    }
+
+
+    resize() {
+        const { gl, densityTexture } = this;
+        gl.deleteTexture(densityTexture);
+        this.densityTexture = this._createDensityTexture();
+        this._bindTextureToFramebuffer();
+        this._drawDensityRequired = true;
+    }
+
+
+    // USER API
+
+    /**
+     * @param {Float32Array} data 
+     * @format [x, y, z, height] x,y,z is normalized 3d cartesian coordinates. Height in kilometers. Set 6371.137 for ground level.
+     */
+    setData(data) {
+        const { gl, buffer } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+        // use program
+        this.dataLength = data.length;
+        this._drawDensityRequired = true;
+        this.globe.DrawRender();
+    }
+
+    // implicit Methods
+
+    _createDensityTexture() {
+        const { gl, globe } = this;
+        const width = Math.floor(globe.api_ScrW())
+        const height = Math.floor(globe.api_ScrH());
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        return texture;
+    }
+
+
+    _drawDensity(pointSize) {
+        const { gl, globe, pointToDensityProgram, vao2D, vao3D, dataLength } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const vao = is3D ? vao3D : vao2D;
+        const length = dataLength / (is3D ? 3 : 2);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE, gl.SRC_ALPHA, gl.ONE);
+        pointToDensityProgram.draw(vao, length, pointSize);
+
+        this._drawDensityRequired = false;
+    }
+
+
+    _drawLegend(legendTexture, opacity) {
+        const { densityToLegendProgram, densityTexture } = this;
+        densityToLegendProgram.draw(densityTexture, legendTexture, opacity);
+    }
+
+
+    _isVisionChanged() {
+        const currentLookInfo = this.globe.api_GetCurrentLookInfo();
+        const _lookInfo = this._lookInfo;
+        if (
+            currentLookInfo.CenterLong !== _lookInfo.CenterLong ||
+            currentLookInfo.CenterLat !== _lookInfo.CenterLat ||
+            currentLookInfo.Distance !== _lookInfo.Distance ||
+            currentLookInfo.Tilt !== _lookInfo.Tilt ||
+            currentLookInfo.NorthAng !== _lookInfo.NorthAng
+        ) {
+            this._lookInfo = currentLookInfo;
+            return true;
+        }
+        return false;
+    }
+
+
+    free() {
+        if (this._isFreed) return;
+        this._isFreed = true;
+        densityToLegendProgramCache.release(this.globe);
+        pointToDensityTextureCache.release(this.globe);
+        this.gl.deleteTexture(this.densityTexture);
+        this.gl.deleteFramebuffer(this.framebuffer);
+        this.gl.deleteBuffer(this.buffer);
+        this.gl.deleteVertexArray(this.vao2D);
+        this.gl.deleteVertexArray(this.vao3D);
+    }
+}
+
+
+export { PointHeatmapFlow };

package/point-heat-map/readme.md

@@ -0,0 +1,15 @@
+# Content
+
+point-heat-map/
+├── plugin.js              
+└── point-to-heat-flow.js
+
+## plugin.js
+
+Contains plugin plugin that calculates data on main thread.
+
+## point-to-heat-flow.js
+
+Contains a wrapper around point-to-density and density-to-color-ramp programs.
+
+The reason behind seperation of program flow and plugin is to explore web-worker version of interpolation and compare it with main thread version.

package/programs/data2legend/density-to-legend.js

@@ -0,0 +1,115 @@
+import { createProgram } from "../../util/";
+import { noRegisterGlobeProgramCache } from "../programcache";
+
+
+const vs = `#version 300 es
+precision highp float;
+
+uniform sampler2D u_density_texture;
+in vec2 a_position;
+
+out vec2 v_texcoord;
+
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texcoord = a_position * 0.5 + 0.5;
+}`;
+
+
+const fs = `#version 300 es
+precision highp float;
+
+uniform sampler2D u_legend_texture;
+uniform sampler2D u_density_texture;
+
+uniform float u_opacity;
+in vec2 v_texcoord;
+out vec4 fragColor;
+
+void main() {
+    float density = texture(u_density_texture, v_texcoord).r;
+    fragColor = texture(u_legend_texture, vec2(density, 0.5));
+    fragColor.a *= u_opacity * sqrt(density);
+}`;
+
+
+
+
+class DensityToLegendProgram {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(globe.gl, vs, fs);
+        const { gl, program } = this;
+        this.uniforms = {
+            densityTexture: gl.getUniformLocation(program, "u_density_texture"),
+            legendTexture: gl.getUniformLocation(program, "u_legend_texture"),
+            opacity: gl.getUniformLocation(program, "u_opacity"),
+        }
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, "a_position");
+        }
+        {
+            this.vao = gl.createVertexArray();
+            const a_positionLocation = gl.getAttribLocation(program, "a_position");
+            gl.bindVertexArray(this.vao);
+
+            const buffer = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+                -1, -1,
+                1, -1,
+                1, 1,
+                -1, 1,
+            ]), gl.STATIC_DRAW);
+            gl.enableVertexAttribArray(a_positionLocation);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+            gl.bindVertexArray(null);
+            // gl.bindBuffer(gl.ARRAY_BUFFER, null);
+            this._buffer = buffer;
+        }
+
+        {
+            this._lastOpacity = 1;
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this.uniforms.opacity, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+    }
+
+
+    draw(densityTexture, legendTexture, opacity) {
+        const { gl, program, uniforms } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(this.vao);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, legendTexture);
+        gl.uniform1i(uniforms.legendTexture, 1);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, densityTexture);
+        gl.uniform1i(uniforms.densityTexture, 0);
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+        gl.bindVertexArray(null);
+    }
+
+
+    free() {
+        const gl = this.gl;
+        gl.deleteVertexArray(this.vao);
+        gl.deleteBuffer(this._buffer);
+        gl.deleteProgram(this.program);
+    }
+}
+
+
+const densityToLegendProgramCache = {
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, DensityToLegendProgram),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, DensityToLegendProgram)
+}
+
+export { densityToLegendProgramCache };

package/programs/data2legend/point-to-density-texture.js

@@ -0,0 +1,114 @@
+import { createProgram } from "../../util/";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems/camerauniformblock";
+import { mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+
+
+const vs = `#version 300 es
+precision highp float;
+
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+
+in vec3 position;
+uniform float pointSize;
+
+void main() {
+    if (is3D) {
+        gl_Position = cartesian3DToGLPosition(position);
+    } else {
+        gl_Position = mercatorXYToGLPosition(position.xy);
+    }
+    gl_PointSize = pointSize;
+}
+`;
+
+
+const fs = `#version 300 es
+precision highp float;
+out vec4 fragColor;
+
+void main() {
+    float r = length(gl_PointCoord - 0.5) * 2.0;
+    if (r > 1.0) discard;
+    // float density = smoothstep(0.1, 1.0, 1.0 - r);
+    fragColor = vec4((15.0/16.0)*sqrt(1.0-sqrt(r)));
+}`;
+
+
+
+class PointHeatmapProgram {
+
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._isFreed = false;
+        this.program = createProgram(globe.gl, vs, fs);
+
+        const { gl, program } = this;
+        this.uniforms = {
+            pointSize: gl.getUniformLocation(this.program, "pointSize"),
+        }
+        { // assign attribute locations 
+            gl.bindAttribLocation(program, 0, "position");
+        }
+
+        { // arrange camera uniform block
+            this.cameraBlockBingingPoint = 0;
+            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBingingPoint);
+        }
+
+        { // last values
+            this._lastPointSize = 0;
+
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this.uniforms.pointSize, this._lastPointSize);
+            gl.useProgram(currentProgram);
+        }
+    }
+
+
+    createVAO(positionBuffer, vectorSize) {
+        const gl = this.gl;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, vectorSize, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return vao;
+    }
+
+    draw(vao, length, pointSize = 5.0) {
+        const gl = this.gl;
+        gl.useProgram(this.program);
+        if (pointSize !== this._lastPointSize) {
+            gl.uniform1f(this.uniforms.pointSize, pointSize);
+            this._lastPointSize = pointSize;
+        }
+        gl.bindVertexArray(vao);
+        this.cameraBlockTotem.bind(this.cameraBlockBingingPoint);
+        gl.drawArrays(gl.POINTS, 0, length);
+        this.cameraBlockTotem.unbind(this.cameraBlockBingingPoint);
+        gl.bindVertexArray(null);
+    }
+
+    free() {
+        if (this._isFreed) return;
+        const { gl, globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(this.program);
+        this._isFreed = true;
+    }
+}
+
+const pointToDensityTextureCache = {
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, PointHeatmapProgram),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, PointHeatmapProgram)
+}
+
+export { pointToDensityTextureCache }; 

package/programs/line-on-globe/degree-padding-around-circle-3d.js

@@ -19,7 +19,7 @@ import {
  * center_position is too small or doenst loaded as expected.
  */
 
-const INITIAL_EDGE_COUNT = 360;
+const INITIAL_EDGE_COUNT = 720;
 
 const vertexShaderSource = `#version 300 es
 precision highp float;
@@ -86,7 +86,7 @@ class Logic {
         this.gl = globe.gl;
         this._lastOpacity = 1.0;
         this._lastEdgeCount = INITIAL_EDGE_COUNT;
-        this._lastStepAngle = 360 / INITIAL_EDGE_COUNT;
+        this._lastStepAngle = 720 / INITIAL_EDGE_COUNT;
         this._lastZAlphaMode = Z_ALPHA_MODE.ON;
         this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
 
@@ -103,7 +103,7 @@ class Logic {
             gl.useProgram(program);
             gl.uniform1f(program.uniforms.opacity, 1.0);
             gl.uniform1f(program.uniforms.edgeCount, INITIAL_EDGE_COUNT * 2);
-            gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 180);
+            gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 360);
             gl.uniform1i(program.uniforms.zAlphaMode, Z_ALPHA_MODE.ON);
             gl.useProgram(currentProgram);
         }
@@ -162,7 +162,7 @@ class Logic {
             this._lastEdgeCount = edgeCount;
         }
         if (this._lastStepAngle !== stepAngle) {
-            gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 180);
+            gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 360);
             this._lastStepAngle = stepAngle;
         }
         if (this._lastZAlphaMode !== zAlphaMode) {

package/timetracks/adaptors-line-strip.js

@@ -69,7 +69,7 @@ function fillSliceOfFloat32ArrayLineStrip(floatArray, offset, coordinates, times
 }
 
 function addCuttingPointLineStrip(floatArray, offset) {
-    floatArray.set([0, 0, 0, 0, -1.0, -1.0, -1.0, 0, 0], offset);
+    floatArray.set(new Float32Array(9).fill(NaN), offset);
     return offset + 9;
 }
 

package/timetracks/program-line-strip.js

@@ -628,7 +628,7 @@ void main() {
             gl.uniform3fv(_lineProgram.uTranslate, uTranslate);
 
             gl.bindVertexArray(_lineProgram.vao);
-            gl.drawArrays(gl.LINE_STRIP, 0, this._totalLength); // TODO: line_strip with thombstone to reduce buffer size in half
+            gl.drawArrays(gl.LINE_STRIP, 0, this._totalLength);
             gl.drawBuffers([
                 gl.COLOR_ATTACHMENT0,
                 gl.NONE

package/timetracks/program.js

@@ -786,7 +786,7 @@ void main() {
             gl.uniform3fv(_lineProgram.uTranslate, uTranslate);
 
             gl.bindVertexArray(_lineProgram.vao);
-            gl.drawArrays(gl.LINES, 0, this._totalLength); // TODO: line_strip with thombstone to reduce buffer size in half
+            gl.drawArrays(gl.LINES, 0, this._totalLength);
             gl.drawBuffers([
                 gl.COLOR_ATTACHMENT0,
                 gl.NONE

package/timetracks/programpoint-line-strip.js

@@ -78,7 +78,7 @@ export default class {
         {
             const { gl, _globalsbuffer } = this;
             gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW); // TODO: sperate head time to make it dynamic maybe?
+            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);

package/timetracks/programpoint.js

@@ -71,7 +71,7 @@ export default class {
         {
             const { gl, _globalsbuffer } = this;
             gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW); // TODO: sperate head time to make it dynamic maybe?
+            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);

package/timetracks/readme.md

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

package/util/algorithms/search-binary.js

@@ -0,0 +1,26 @@
+/**
+ * @typedef {Array<number>} ListLike
+ * @typedef {number || null} Index
+ */
+
+/**
+ * @param {ListLike} container
+ * @param {number} value
+ * @returns {Index}
+ */
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1]) return mid;
+        if (container[mid] < value) start = mid + 1;
+        else end = mid - 1;
+    }
+    return null;
+}
+
+
+export { findFirstIndexInRange };
+

package/util/interpolation/timetrack/timetrack-interpolator.js

@@ -0,0 +1,89 @@
+import { findFirstIndexInRange } from '../../algorithms/search-binary';
+import {
+    sphericalLinearInterpolation_Cartesian3d,
+    sphericalLinearInterpolation_Mercator,
+} from '../../../Math/methods';
+
+
+/**
+ * @typedef {Array<number>} vec3 [x, y, z]
+ * @typedef {Array<number>} vec2 [x, y]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+
+const GEOMETRY = Object.freeze({
+    CARTESIAN3D: 0,
+    MERCATOR: 1,
+});
+
+class TimeTrackInterpolator {
+    /**
+     * @typedef Timetrack
+     * @property {Array<vec4>}} coordinates [x,y,z, length]
+     * @property {Array<Number>} times  
+     * @param {Array<Timetrack>} timeTracks 
+     */
+    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
+        this.timeTracks = null;
+        this.timeTracksStartTimes = null;
+        this.geometry = geometry;
+        if (timeTracks) this.setTimetracks(timeTracks);
+        if (bbox) this.setBbox(bbox);
+    }
+
+
+    setGeometry(geometry) {
+        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
+            throw new Error('Invalid geometry');
+        }
+        this.geometry = geometry;
+    }
+
+    setTimetracks(timeTracks) {
+        console.log("timetracks:", timeTracks);
+        this.timeTracks = timeTracks;
+    }
+
+
+    interpolate(time) {
+        const { timeTracks, geometry } = this;
+        if (!timeTracks) { return null; }
+        const resultArray = [];
+        const info = {
+            outOfRange: 0,
+            processed: 0,
+        }
+        for (let i = 0; i < timeTracks.length; i++) {
+            const { times, coordinates } = timeTracks[i];
+
+            if (times[times.length - 1] < time) continue;
+            info.processed++;
+            const timeIndex = findFirstIndexInRange(times, time);
+            if (timeIndex === null) { info.outOfRange++; continue; }
+            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
+                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            resultArray.push(...interpolated);
+        }
+        return new Float32Array(resultArray);
+    }
+
+
+    // implicit methods
+
+    _orderTimeTracks() {
+        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
+    }
+
+    _setStartTimes() {
+        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
+    }
+
+
+}
+
+
+export { TimeTrackInterpolator, GEOMETRY };

package/util/interpolation/timetrack/web-worker.js

@@ -0,0 +1,46 @@
+import { TimeTrackInterpolator, GEOMETRY } from './timetrack-interpolator';
+
+
+const interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });
+
+/* eslint-disable-next-line no-restricted-globals */
+self.onmessage = function (e) {
+
+    const { geometry = null, timeTracks = null, time = null } = e.data;
+
+    if (geometry !== null) {
+        try {
+            interpolator.setGeometry(geometry);
+        } catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+
+    if (timeTracks !== null) {
+        try {
+            interpolator.setTimetracks(timeTracks);
+        } catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+
+    if (time !== null) {
+        try {
+            const result = interpolator.interpolate(time);
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage(result, [result.buffer]);
+            return;
+        } catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+    /* eslint-disable-next-line no-restricted-globals */
+    self.postMessage(true);
+}
+