@webviz/subsurface-viewer 0.0.1-alpha.1

package/dist/layers/map/privateMapLayer.js

@@ -0,0 +1,190 @@
+import { COORDINATE_SYSTEM, Layer, picking, project, phongLighting, } from "@deck.gl/core/typed";
+import { createPropertyData, } from "../utils/layerTools";
+import { Model, Geometry } from "@luma.gl/engine";
+import vsShader from "./vertex.glsl";
+import fsShader from "./fragment.fs.glsl";
+import vsLineShader from "./vertex_lines.glsl";
+import fsLineShader from "./fragment_lines.glsl";
+import { rgbValues } from "@emerson-eps/color-tables/";
+import { createDefaultContinuousColorScale } from "@emerson-eps/color-tables/dist/component/Utils/legendCommonFunction";
+import { Texture2D } from "@luma.gl/webgl";
+import GL from "@luma.gl/constants";
+const DEFAULT_TEXTURE_PARAMETERS = {
+    [GL.TEXTURE_MIN_FILTER]: GL.LINEAR_MIPMAP_LINEAR,
+    [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
+    [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+    [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE,
+};
+function getImageData(colorMapName, colorTables, colorMapFunction) {
+    const isColorMapFunctionDefined = typeof colorMapFunction !== "undefined";
+    const isColorMapNameDefined = !!colorMapName;
+    const defaultColorMap = createDefaultContinuousColorScale;
+    let colorMap = defaultColorMap();
+    if (isColorMapFunctionDefined) {
+        colorMap =
+            typeof colorMapFunction === "function"
+                ? colorMapFunction
+                : (() => colorMapFunction);
+    }
+    else if (isColorMapNameDefined) {
+        colorMap = (value) => rgbValues(value, colorMapName, colorTables);
+    }
+    const data = new Uint8Array(256 * 3);
+    for (let i = 0; i < 256; i++) {
+        const value = i / 255.0;
+        const color = colorMap ? colorMap(value) : [0, 0, 0];
+        if (color) {
+            data[3 * i + 0] = color[0];
+            data[3 * i + 1] = color[1];
+            data[3 * i + 2] = color[2];
+        }
+    }
+    return data ? data : [0, 0, 0];
+}
+const defaultProps = {
+    data: ["dummy"],
+    contours: [-1, -1],
+    isContoursDepth: true,
+    gridLines: false,
+    colorMapName: "",
+    coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+    propertyValueRange: [0.0, 1.0],
+    meshValueRange: [0.0, 1.0],
+    depthTest: true,
+};
+// This is a private layer used only by the composite Map3DLayer
+export default class privateMapLayer extends Layer {
+    initializeState(context) {
+        const { gl } = context;
+        const [model_mesh, mesh_lines_model] = this._getModels(gl);
+        this.setState({ models: [model_mesh, mesh_lines_model] });
+    }
+    shouldUpdateState({ props, oldProps, context, changeFlags, }) {
+        return (super.shouldUpdateState({
+            props,
+            oldProps,
+            context,
+            changeFlags,
+        }) || changeFlags.propsOrDataChanged);
+    }
+    updateState({ context }) {
+        this.initializeState(context);
+    }
+    //eslint-disable-next-line
+    _getModels(gl) {
+        // MESH MODEL
+        const mesh_model = new Model(gl, {
+            id: `${this.props.id}-mesh`,
+            vs: vsShader,
+            fs: fsShader,
+            geometry: new Geometry({
+                drawMode: this.props.mesh.drawMode,
+                attributes: {
+                    positions: this.props.mesh.attributes.positions,
+                    normals: this.props.mesh.attributes.normals,
+                    properties: this.props.mesh.attributes.properties,
+                    vertex_indexs: this.props.mesh.attributes.vertex_indexs,
+                },
+                vertexCount: this.props.mesh.vertexCount,
+                indices: this.props.mesh.indices,
+            }),
+            modules: [project, picking, phongLighting],
+            isInstanced: false, // This only works when set to false.
+        });
+        // MESH LINES
+        const mesh_lines_model = new Model(gl, {
+            id: `${this.props.id}-lines`,
+            vs: vsLineShader,
+            fs: fsLineShader,
+            geometry: new Geometry(this.props.meshLines),
+            modules: [project, picking],
+            isInstanced: false,
+        });
+        return [mesh_model, mesh_lines_model];
+    }
+    // Signature from the base class, eslint doesn't like the any type.
+    // eslint-disable-next-line
+    draw(args) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!this.state["models"]) {
+            return;
+        }
+        const { uniforms, context } = args;
+        const { gl } = context;
+        const contourReferencePoint = (_a = this.props.contours[0]) !== null && _a !== void 0 ? _a : -1.0;
+        const contourInterval = (_b = this.props.contours[1]) !== null && _b !== void 0 ? _b : -1.0;
+        const isContoursDepth = this.props.isContoursDepth;
+        const [model_mesh, mesh_lines_model] = this.state["models"];
+        const valueRangeMin = (_c = this.props.propertyValueRange[0]) !== null && _c !== void 0 ? _c : 0.0;
+        const valueRangeMax = (_d = this.props.propertyValueRange[1]) !== null && _d !== void 0 ? _d : 1.0;
+        // If specified color map will extend from colorMapRangeMin to colorMapRangeMax.
+        // Otherwise it will extend from valueRangeMin to valueRangeMax.
+        const colorMapRangeMin = (_f = (_e = this.props.colorMapRange) === null || _e === void 0 ? void 0 : _e[0]) !== null && _f !== void 0 ? _f : valueRangeMin;
+        const colorMapRangeMax = (_h = (_g = this.props.colorMapRange) === null || _g === void 0 ? void 0 : _g[1]) !== null && _h !== void 0 ? _h : valueRangeMax;
+        const isClampColor = this.props.colorMapClampColor !== undefined &&
+            this.props.colorMapClampColor !== true &&
+            this.props.colorMapClampColor !== false;
+        let colorMapClampColor = isClampColor
+            ? this.props.colorMapClampColor
+            : [0, 0, 0];
+        // Normalize to [0,1] range.
+        colorMapClampColor = colorMapClampColor.map((x) => (x !== null && x !== void 0 ? x : 0) / 255);
+        const isColorMapClampColorTransparent = this.props.colorMapClampColor === false;
+        const smoothShading = this.props.smoothShading;
+        gl.enable(GL.POLYGON_OFFSET_FILL);
+        if (!this.props.depthTest) {
+            gl.disable(GL.DEPTH_TEST);
+        }
+        gl.polygonOffset(1, 1);
+        model_mesh
+            .setUniforms(Object.assign(Object.assign({}, uniforms), { contourReferencePoint,
+            contourInterval,
+            isContoursDepth, colormap: new Texture2D(context.gl, {
+                width: 256,
+                height: 1,
+                format: GL.RGB,
+                data: getImageData(this.props.colorMapName, this.context.userData
+                    .colorTables, this.props.colorMapFunction),
+                parameters: DEFAULT_TEXTURE_PARAMETERS,
+            }), valueRangeMin,
+            valueRangeMax,
+            colorMapRangeMin,
+            colorMapRangeMax,
+            colorMapClampColor,
+            isColorMapClampColorTransparent,
+            isClampColor,
+            smoothShading }))
+            .draw();
+        gl.disable(GL.POLYGON_OFFSET_FILL);
+        if (!this.props.depthTest) {
+            gl.enable(GL.DEPTH_TEST);
+        }
+        if (this.props.gridLines) {
+            mesh_lines_model.draw();
+        }
+    }
+    decodePickingColor() {
+        return 0;
+    }
+    getPickingInfo({ info }) {
+        if (!info.color) {
+            return info;
+        }
+        const layer_properties = [];
+        // Note these colors are in the  0-255 range.
+        const r = info.color[0];
+        const g = info.color[1];
+        const b = info.color[2];
+        const vertexIndex = 256 * 256 * r + 256 * g + b;
+        const vertexs = this.props.mesh.attributes.positions.value;
+        const depth = -vertexs[3 * vertexIndex + 2];
+        layer_properties.push(createPropertyData("Depth", depth));
+        const properties = this.props.mesh.attributes.properties.value;
+        const property = properties[vertexIndex];
+        layer_properties.push(createPropertyData("Property", property));
+        return Object.assign(Object.assign({}, info), { properties: layer_properties });
+    }
+}
+privateMapLayer.layerName = "privateMapLayer";
+privateMapLayer.defaultProps = defaultProps;
+//# sourceMappingURL=privateMapLayer.js.map

package/dist/layers/map/privateMapLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"privateMapLayer.js","sourceRoot":"","sources":["../../../src/layers/map/privateMapLayer.ts"],"names":[],"mappings":"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"}

package/dist/layers/map/vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const vsShader = "#version 300 es\n#define SHADER_NAME vertex-shader\n\nprecision highp float;\n\n// Primitive attributes\nin vec3 positions;\nin float properties;\nin vec3 normals;\nin vec3 colors;\n\nin int vertex_indexs;\nflat out int vertex_indexs_;\n\n\n// Outputs to fragment shader\nout vec2 vTexCoord;\nout vec3 cameraPosition;\nout vec3 normals_commonspace;\nout vec4 position_commonspace;\nout vec4 vColor;\nout vec3 worldPos;\nout float property;\n\n\nvoid main(void) {\n   cameraPosition = project_uCameraPosition;\n\n   worldPos = positions;\n\n   normals_commonspace = normals;\n\n   vertex_indexs_ = vertex_indexs;\n\n   vColor = vec4(colors.rgb, 1.0);\n\n   property = properties;\n\n   position_commonspace = vec4(project_position(positions), 0.0);\n   gl_Position = project_common_position_to_clipspace(position_commonspace);\n}\n";
+export default vsShader;

package/dist/layers/map/vertex.glsl.js

@@ -0,0 +1,45 @@
+const vsShader = `\
+#version 300 es
+#define SHADER_NAME vertex-shader
+
+precision highp float;
+
+// Primitive attributes
+in vec3 positions;
+in float properties;
+in vec3 normals;
+in vec3 colors;
+
+in int vertex_indexs;
+flat out int vertex_indexs_;
+
+
+// Outputs to fragment shader
+out vec2 vTexCoord;
+out vec3 cameraPosition;
+out vec3 normals_commonspace;
+out vec4 position_commonspace;
+out vec4 vColor;
+out vec3 worldPos;
+out float property;
+
+
+void main(void) {
+   cameraPosition = project_uCameraPosition;
+
+   worldPos = positions;
+
+   normals_commonspace = normals;
+
+   vertex_indexs_ = vertex_indexs;
+
+   vColor = vec4(colors.rgb, 1.0);
+
+   property = properties;
+
+   position_commonspace = vec4(project_position(positions), 0.0);
+   gl_Position = project_common_position_to_clipspace(position_commonspace);
+}
+`;
+export default vsShader;
+//# sourceMappingURL=vertex.glsl.js.map

package/dist/layers/map/vertex.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex.glsl.js","sourceRoot":"","sources":["../../../src/layers/map/vertex.glsl.ts"],"names":[],"mappings":"AAAA,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0ChB,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/dist/layers/map/vertex_lines.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "#version 300 es\n#define SHADER_NAME vertex-lines-shader\n\nprecision highp float;\n\nin vec3 positions;\n\nout vec4 position_commonspace;\n\nvoid main(void) {\n   vec3 position_commonspace = project_position(positions);\n   gl_Position = project_common_position_to_clipspace(vec4(position_commonspace, 0.0));\n}\n";
+export default _default;

package/dist/layers/map/vertex_lines.glsl.js

@@ -0,0 +1,16 @@
+export default `\
+#version 300 es
+#define SHADER_NAME vertex-lines-shader
+
+precision highp float;
+
+in vec3 positions;
+
+out vec4 position_commonspace;
+
+void main(void) {
+   vec3 position_commonspace = project_position(positions);
+   gl_Position = project_common_position_to_clipspace(vec4(position_commonspace, 0.0));
+}
+`;
+//# sourceMappingURL=vertex_lines.glsl.js.map

package/dist/layers/map/vertex_lines.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex_lines.glsl.js","sourceRoot":"","sources":["../../../src/layers/map/vertex_lines.glsl.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;CAcd,CAAC"}

package/dist/layers/map/webworker.d.ts

@@ -0,0 +1,4 @@
+import { Params } from "./mapLayer";
+export declare function makeFullMesh(e: {
+    data: Params;
+}): void;

package/dist/layers/map/webworker.js

@@ -0,0 +1,362 @@
+export function makeFullMesh(e) {
+    const params = e.data;
+    // Keep
+    //const t0 = performance.now();
+    const meshData = params.meshData;
+    const propertiesData = params.propertiesData;
+    const isMesh = params.isMesh;
+    const frame = params.frame;
+    const smoothShading = params.smoothShading;
+    function getFloat32ArrayMinMax(data) {
+        let max = -99999999;
+        let min = 99999999;
+        for (let i = 0; i < data.length; i++) {
+            max = data[i] > max ? data[i] : max;
+            min = data[i] < min ? data[i] : min;
+        }
+        return [min, max];
+    }
+    function crossProduct(a, b) {
+        const c = [
+            a[1] * b[2] - a[2] * b[1],
+            a[2] * b[0] - a[0] * b[2],
+            a[0] * b[1] - a[1] * b[0],
+        ];
+        return c;
+    }
+    function normalize(a) {
+        const L = Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+        a[0] /= L;
+        a[1] /= L;
+        a[2] /= L;
+    }
+    function calcNormal(w, h, nx, ny, isMesh, smoothShading, meshData, ox, oy) {
+        if (!smoothShading) {
+            return [1, 1, 1];
+        }
+        if (!isMesh) {
+            return [0, 0, 1];
+        }
+        const i0 = h * nx + w;
+        const i1 = h * nx + (w - 1);
+        const i2 = (h + 1) * nx + w;
+        const i3 = h * nx + (w + 1);
+        const i4 = (h - 1) * nx + w;
+        const i0_act = !isNaN(meshData[i0]); // eslint-disable-line
+        const i1_act = (w - 1) >= 0 && !isNaN(meshData[i1]); // eslint-disable-line
+        const i2_act = (h + 1) < ny && !isNaN(meshData[i2]); // eslint-disable-line
+        const i3_act = (w + 1) < nx && !isNaN(meshData[i3]); // eslint-disable-line
+        const i4_act = (h - 1) >= 0 && !isNaN(meshData[i4]); // eslint-disable-line
+        const noNormal = [0, 0, 1]; // signals a normal could not be calculated.
+        if (!i0_act) {
+            return noNormal;
+        }
+        const hh = ny - 1 - h; // Note use hh for h for getting y values.
+        const p0 = [ox + w * dx, oy + hh * dy, i0_act ? -meshData[i0] : 0]; // eslint-disable-line
+        const p1 = [ox + (w - 1) * dx, oy + hh * dy, i1_act ? -meshData[i1] : 0]; // eslint-disable-line
+        const p2 = [ox + w * dx, oy + (hh + 1) * dy, i2_act ? -meshData[i2] : 0]; // eslint-disable-line
+        const p3 = [ox + (w + 1) * dx, oy + hh * dy, i3_act ? -meshData[i3] : 0]; // eslint-disable-line
+        const p4 = [ox + w * dx, oy + (hh - 1) * dy, i4_act ? -meshData[i4] : 0]; // eslint-disable-line
+        const v1 = [p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]];
+        const v2 = [p2[0] - p0[0], p2[1] - p0[1], p2[2] - p0[2]];
+        const v3 = [p3[0] - p0[0], p3[1] - p0[1], p3[2] - p0[2]];
+        const v4 = [p4[0] - p0[0], p4[1] - p0[1], p4[2] - p0[2]];
+        // Estimating a normal vector at p0:
+        // Take cross product of vectors v1, v2,
+        // Do this for all 4 quadrants.
+        // The resulting normal will be the mean of these four normals.
+        //        p2
+        //         |
+        //   p1 - p0 - p3
+        //         |
+        //        p4
+        const normals = [];
+        if (i1_act && i2_act) {
+            const normal = crossProduct(v2, v1);
+            normals.push(normal);
+        }
+        if (i2_act && i3_act) {
+            const normal = crossProduct(v3, v2);
+            normals.push(normal);
+        }
+        if (i3_act && i4_act) {
+            const normal = crossProduct(v4, v3);
+            normals.push(normal);
+        }
+        if (i4_act && i1_act) {
+            const normal = crossProduct(v1, v4);
+            normals.push(normal);
+        }
+        if (normals.length === 0) {
+            return noNormal;
+        }
+        const mean = normals[0];
+        for (let i = 1; i < normals.length; i++) {
+            mean[0] += normals[i][0];
+            mean[1] += normals[i][1];
+            mean[2] += normals[i][2];
+        }
+        normalize(mean);
+        return mean;
+    }
+    const meshZValueRange = getFloat32ArrayMinMax(meshData);
+    const propertyValueRange = getFloat32ArrayMinMax(propertiesData);
+    // Dimensions.
+    const ox = frame.origin[0];
+    const oy = frame.origin[1];
+    const dx = frame.increment[0];
+    const dy = frame.increment[1];
+    const nx = frame.count[0];
+    const ny = frame.count[1];
+    const propLength = propertiesData.length;
+    const isCellCenteredProperties = propLength === (nx - 1) * (ny - 1);
+    if (propLength !== (nx - 1) * (ny - 1) && propLength !== nx * ny) {
+        console.error("There should be as many property values as nodes (nx*ny) OR as many as cells (nx - 1) * (ny - 1).");
+    }
+    const positions = [];
+    const normals = [];
+    const indices = [];
+    const vertexProperties = [];
+    const vertexIndexs = [];
+    const line_positions = [];
+    // Note: Assumed layout of the incomming 2D array of data:
+    // First coloumn corresponds to lowest x value. Last column highest x value.
+    // First row corresponds to max y value. Last row corresponds to lowest y value.
+    // This must be taken into account when calculating vertex x,y values and texture coordinates.
+    if (!isCellCenteredProperties) {
+        // PROPERTIES IS SET INTERPOLATED OVER A CELL.
+        let i = 0;
+        // Loop over nodes.
+        for (let h = 0; h < ny; h++) {
+            for (let w = 0; w < nx; w++) {
+                const i0 = h * nx + w;
+                const x0 = ox + w * dx;
+                const y0 = oy + (ny - 1 - h) * dy; // See note above.
+                const z = isMesh ? -meshData[i0] : 0;
+                const propertyValue = propertiesData[i0];
+                positions.push(x0, y0, z);
+                const normal = calcNormal(w, h, nx, ny, isMesh, smoothShading, meshData, ox, oy); // eslint-disable-line
+                normals.push(normal[0], normal[1], normal[2]);
+                vertexProperties.push(propertyValue);
+                vertexIndexs.push(i++);
+            }
+        }
+        for (let h = 0; h < ny - 1; h++) {
+            for (let w = 0; w < nx - 1; w++) {
+                const i0 = h * nx + w;
+                const i1 = h * nx + (w + 1);
+                const i2 = (h + 1) * nx + (w + 1);
+                const i3 = (h + 1) * nx + w;
+                const i0_act = !isMesh || (!isNaN(meshData[i0]) && !isNaN(propertiesData[i0])); // eslint-disable-line
+                const i1_act = !isMesh || (!isNaN(meshData[i1]) && !isNaN(propertiesData[i1])); // eslint-disable-line
+                const i2_act = !isMesh || (!isNaN(meshData[i2]) && !isNaN(propertiesData[i2])); // eslint-disable-line
+                const i3_act = !isMesh || (!isNaN(meshData[i3]) && !isNaN(propertiesData[i3])); // eslint-disable-line
+                const hh = ny - h - 1; // See note above.
+                const x0 = ox + w * dx;
+                const y0 = oy + hh * dy;
+                const z0 = isMesh ? -meshData[i0] : 0;
+                const x1 = ox + (w + 1) * dx;
+                const y1 = oy + hh * dy;
+                const z1 = isMesh ? -meshData[i1] : 0;
+                const x2 = ox + (w + 1) * dx;
+                const y2 = oy + (hh - 1) * dy;
+                const z2 = isMesh ? -meshData[i2] : 0;
+                const x3 = ox + w * dx;
+                const y3 = oy + (hh - 1) * dy;
+                const z3 = isMesh ? -meshData[i3] : 0;
+                if (i1_act && i3_act) {
+                    // diagonal i1, i3
+                    if (i0_act) {
+                        indices.push(i1, i3, i0); // t1 - i0 provoking index.
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x3, y3, z3);
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x1, y1, z1);
+                    }
+                    if (i2_act) {
+                        indices.push(i1, i3, i2); // t2 - i2 provoking index.
+                        line_positions.push(x2, y2, z2);
+                        line_positions.push(x3, y3, z3);
+                        line_positions.push(x2, y2, z2);
+                        line_positions.push(x1, y1, z1);
+                    }
+                    // diagonal
+                    if ((i0_act && !i2_act) || (!i0_act && i2_act)) {
+                        line_positions.push(x1, y1, z1);
+                        line_positions.push(x3, y3, z3);
+                    }
+                }
+                else if (i0_act && i2_act) {
+                    // diagonal i0, i2
+                    if (i1_act) {
+                        indices.push(i1, i2, i0); // t1 - i0 provoking index.
+                    }
+                    if (i3_act) {
+                        indices.push(i3, i0, i2); // t2 - i2 provoking index.
+                    }
+                    // diagonal
+                    if ((i3_act && !i1_act) || (!i3_act && i1_act)) {
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x2, y2, z2);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // PROPERTIES IS SET CONSTANT OVER A CELL.
+        let i_indices = 0;
+        let i_vertices = 0;
+        // Loop over cells.
+        for (let h = 0; h < ny - 1; h++) {
+            for (let w = 0; w < nx - 1; w++) {
+                const hh = ny - 1 - h; // See note above.
+                const i0 = h * nx + w;
+                const i1 = h * nx + (w + 1);
+                const i2 = (h + 1) * nx + (w + 1);
+                const i3 = (h + 1) * nx + w;
+                const normal0 = calcNormal(w, h, nx, ny, isMesh, smoothShading, meshData, ox, oy); // eslint-disable-line
+                const normal1 = calcNormal(w + 1, h, nx, ny, isMesh, smoothShading, meshData, ox, oy); // eslint-disable-line
+                const normal2 = calcNormal(w + 1, h + 1, nx, ny, isMesh, smoothShading, meshData, ox, oy); // eslint-disable-line
+                const normal3 = calcNormal(w, h + 1, nx, ny, isMesh, smoothShading, meshData, ox, oy); // eslint-disable-line
+                const i0_act = !isMesh || !isNaN(meshData[i0]); // eslint-disable-line
+                const i1_act = !isMesh || !isNaN(meshData[i1]); // eslint-disable-line
+                const i2_act = !isMesh || !isNaN(meshData[i2]); // eslint-disable-line
+                const i3_act = !isMesh || !isNaN(meshData[i3]); // eslint-disable-line
+                const x0 = ox + w * dx;
+                const y0 = oy + hh * dy;
+                const z0 = isMesh ? -meshData[i0] : 0;
+                const x1 = ox + (w + 1) * dx;
+                const y1 = oy + hh * dy;
+                const z1 = isMesh ? -meshData[i1] : 0;
+                const x2 = ox + (w + 1) * dx;
+                const y2 = oy + (hh - 1) * dy; // Note hh - 1 here.
+                const z2 = isMesh ? -meshData[i2] : 0;
+                const x3 = ox + w * dx;
+                const y3 = oy + (hh - 1) * dy; // Note hh - 1 here.
+                const z3 = isMesh ? -meshData[i3] : 0;
+                const propertyIndex = h * (nx - 1) + w; // (nx - 1) -> the width of the property 2D array is one less than for the nodes in this case.
+                const propertyValue = propertiesData[propertyIndex];
+                if (isNaN(propertyValue)) {
+                    // Inactive cell, dont draw.
+                    continue;
+                }
+                if (i1_act && i3_act) {
+                    // diagonal i1, i3
+                    if (i0_act) {
+                        // t1 - i0 provoking index.
+                        positions.push(x1, y1, z1);
+                        positions.push(x3, y3, z3);
+                        positions.push(x0, y0, z0);
+                        normals.push(normal1[0], normal1[1], normal1[2]);
+                        normals.push(normal3[0], normal3[1], normal3[2]);
+                        normals.push(normal0[0], normal0[1], normal0[2]);
+                        vertexIndexs.push(i_vertices++, i_vertices++, i_vertices++);
+                        indices.push(i_indices++, i_indices++, i_indices++);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x3, y3, z3);
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x1, y1, z1);
+                    }
+                    if (i2_act) {
+                        // t2 - i2 provoking index.
+                        positions.push(x1, y1, z1);
+                        positions.push(x3, y3, z3);
+                        positions.push(x2, y2, z2);
+                        normals.push(normal1[0], normal1[1], normal1[2]);
+                        normals.push(normal3[0], normal3[1], normal3[2]);
+                        normals.push(normal2[0], normal2[1], normal2[2]);
+                        vertexIndexs.push(i_vertices++, i_vertices++, i_vertices++);
+                        indices.push(i_indices++, i_indices++, i_indices++);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        line_positions.push(x2, y2, z2);
+                        line_positions.push(x3, y3, z3);
+                        line_positions.push(x2, y2, z2);
+                        line_positions.push(x1, y1, z1);
+                    }
+                    // diagonal
+                    if ((i0_act && !i2_act) || (!i0_act && i2_act)) {
+                        line_positions.push(x1, y1, z1);
+                        line_positions.push(x3, y3, z3);
+                    }
+                }
+                else if (i0_act && i2_act) {
+                    // diagonal i0, i2
+                    if (i1_act) {
+                        // t1 - i0 provoking index.
+                        positions.push(x1, y1, z1);
+                        positions.push(x2, y2, z2);
+                        positions.push(x0, y0, z0);
+                        normals.push(normal1[0], normal1[1], normal1[2]);
+                        normals.push(normal2[0], normal2[1], normal2[2]);
+                        normals.push(normal0[0], normal0[1], normal0[2]);
+                        vertexIndexs.push(i_vertices++, i_vertices++, i_vertices++);
+                        indices.push(i_indices++, i_indices++, i_indices++);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        line_positions.push(x1, y1, z1);
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x1, y1, z1);
+                        line_positions.push(x2, y2, z2);
+                    }
+                    if (i3_act) {
+                        // t2 - i2 provoking index.
+                        positions.push(x0, y0, z0);
+                        positions.push(x3, y3, z3);
+                        positions.push(x2, y2, z2);
+                        normals.push(normal0[0], normal0[1], normal0[2]);
+                        normals.push(normal3[0], normal3[1], normal3[2]);
+                        normals.push(normal2[0], normal2[1], normal2[2]);
+                        vertexIndexs.push(i_vertices++, i_vertices++, i_vertices++);
+                        indices.push(i_indices++, i_indices++, i_indices++);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        vertexProperties.push(propertyValue);
+                        line_positions.push(x3, y3, z3);
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x3, y3, z3);
+                        line_positions.push(x2, y2, z2);
+                    }
+                    // diagonal
+                    if ((i3_act && !i1_act) || (!i3_act && i1_act)) {
+                        line_positions.push(x0, y0, z0);
+                        line_positions.push(x2, y2, z2);
+                    }
+                }
+            }
+        }
+    }
+    const mesh = {
+        drawMode: 4,
+        attributes: {
+            positions: { value: new Float32Array(positions), size: 3 },
+            normals: { value: new Float32Array(normals), size: 3 },
+            properties: { value: new Float32Array(vertexProperties), size: 1 },
+            vertex_indexs: { value: new Int32Array(vertexIndexs), size: 1 },
+        },
+        vertexCount: indices.length,
+        indices: { value: new Uint32Array(indices), size: 1 },
+    };
+    const mesh_lines = {
+        drawMode: 1,
+        attributes: {
+            positions: { value: new Float32Array(line_positions), size: 3 },
+        },
+        vertexCount: line_positions.length / 3,
+    };
+    //const t1 = performance.now();
+    // Keep this.
+    //console.log(`Task makeMesh took ${(t1 - t0) * 0.001}  seconds.`);
+    // Note: typescript gives this error "error TS2554: Expected 2-3 arguments, but got 1."
+    // Disabling this for now as the second argument should be optional.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    postMessage([mesh, mesh_lines, meshZValueRange, propertyValueRange]);
+}
+//# sourceMappingURL=webworker.js.map