@webviz/subsurface-viewer 0.0.1-alpha.1

package/dist/layers/terrain/terrainmap.fs.glsl.js

@@ -0,0 +1,134 @@
+const fsShader = `#version 300 es
+#define SHADER_NAME terrainmap-shader
+
+precision highp float;
+
+uniform bool hasTexture;
+uniform sampler2D sampler;
+uniform bool flatShading;
+uniform float opacity;
+
+uniform bool isContoursDepth;
+
+uniform float contourReferencePoint;
+uniform float contourInterval;
+
+in vec2 vTexCoord;
+in vec3 cameraPosition;
+in vec3 normals_commonspace;
+in vec4 position_commonspace;
+in vec4 vColor;
+in vec4 positions;
+
+out vec4 fragColor;
+
+in vec3 worldPos; // we export this from vertex shader (by injecting into it).
+
+uniform sampler2D colormap;
+
+uniform float valueRangeMin;
+uniform float valueRangeMax;
+uniform float colorMapRangeMin;
+uniform float colorMapRangeMax;
+
+uniform vec3 colorMapClampColor;
+uniform bool isClampColor;
+uniform bool isColorMapClampColorTransparent;
+
+
+void main(void) {
+   geometry.uv = vTexCoord;
+
+   vec3 normal;
+   if (flatShading) {
+#ifdef DERIVATIVES_AVAILABLE
+      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
+#else
+      normal = vec3(0.0, 0.0, 1.0);
+#endif
+   } else {
+      normal = normals_commonspace;
+   }
+
+   vec4 color = hasTexture ? texture(sampler, vTexCoord) : vColor;
+
+   float texture_alpha = color.a;
+
+   // Discard transparent pixels.
+   if (!picking_uActive && color.w < 0.99) {
+         discard;
+         return;
+   }
+
+   // Picking pass.
+   if (picking_uActive) {
+      // Send texture coordinates.
+      float s = vTexCoord.x;
+      float t = vTexCoord.y;
+      float b = texture_alpha > 0.95 ? 255.0 : 0.0;
+
+      fragColor = vec4(s, t, b, 1.0);
+      return;
+   }
+
+   float propertyValue = 0.0;
+   if (hasTexture) {
+      float opcacity = color.w;
+      float floatScaler =  1.0 / (256.0 * 256.0 * 256.0 - 1.0);
+      vec3 rgb = color.rgb;
+      rgb *= vec3(16711680.0, 65280.0, 255.0); //255*256*256, 255*256, 255
+      float propertyValue_norm = (rgb.r + rgb.g + rgb.b) * floatScaler; // propertyValue_norm will be in range [0-1]
+
+      // If colorMapRangeMin/Max specified, color map will span this interval.
+      propertyValue  = propertyValue_norm * (valueRangeMax - valueRangeMin) + valueRangeMin;
+      float x = (propertyValue - colorMapRangeMin) / (colorMapRangeMax - colorMapRangeMin);
+;
+      if (x < 0.0 || x > 1.0) {
+         // Out of range. Use clampcolor.
+         if (isClampColor) {
+            color = vec4(colorMapClampColor.rgb, 1.0);
+
+         }
+         else if (isColorMapClampColorTransparent) {
+            discard;
+            return;
+         }
+         else {
+            // Use min/max color to clamp.
+            x = max(0.0, x);
+            x = min(1.0, x);
+
+            color = texture2D(colormap, vec2(x, 0.5));
+            color.a = opcacity;
+         }
+      }
+      else {
+         color = texture2D(colormap, vec2(x, 0.5));
+         color.a = opcacity;
+      }
+   }
+
+   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;
+   if (is_contours) {
+      // Contours are made of either depths or properties.
+      float val =  (hasTexture && !isContoursDepth) ? (propertyValue - contourReferencePoint) / contourInterval
+                                                    : (abs(worldPos.z) - contourReferencePoint) / contourInterval;
+
+      float f  = fract(val);
+      float df = fwidth(val);
+
+      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.
+      float c = smoothstep(0.0, df * 2.0, f);
+
+      color = color * vec4(c, c, c, 1.0);
+   }
+
+   // Use normal lighting.
+   vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
+   fragColor = vec4(lightColor, color.a * opacity);
+
+   DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+export default fsShader;
+//# sourceMappingURL=terrainmap.fs.glsl.js.map

package/dist/layers/terrain/terrainmap.fs.glsl.js.map

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

package/dist/layers/triangle/fragment.fs.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const fsShader = "#version 300 es\n#define SHADER_NAME terrainmap-shader\n\nprecision highp float;\n\nuniform bool isContoursDepth;\nuniform float contourReferencePoint;\nuniform float contourInterval;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec3 worldPos;\nin float property;\n\nout vec4 fragColor;\n\nuniform sampler2D colormap;\nuniform vec4 uColor;\nuniform bool smoothShading;\n\n\nvec3 getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n    \n   vec3 halfway_direction = normalize(light_direction + view_direction);   \n   float lambertian = abs(dot(light_direction, normal_worldspace));\n\n   float specular_angle = abs(dot(normal_worldspace, halfway_direction));\n\n   float specular = pow(specular_angle, lighting_uShininess);       \n   return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;    \n}\n\nvec3 getLightColor(vec3 surfaceColor,vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n\n  vec3 lightColor = surfaceColor;\n\n  if (lighting_uEnabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uPointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_uPointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uDirectionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n      lightColor += getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n\nvoid main(void) {\n   //geometry.uv = vTexCoord;\n\n   vec3 normal = normals_commonspace;\n\n   if (!smoothShading) {\n      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n   } \n   \n   //Picking pass.\n   if (picking_uActive) {\n      // Readout is surface height (z value).\n      float range = 10000.0;  // May represent depths in range 0 - 10000 meter.\n\n      // Express in 255 system.\n      float depth = abs(worldPos.z);\n      float depthScaled = (256.0 * 256.0 * 256.0) * (depth / range); // scaled to within max range in 256 system.\n\n      float r = 0.0;\n      float g = 0.0;\n      float b = 0.0;\n\n      if (depthScaled >= (256.0 * 256.0) - 1.0) {\n         r = floor(depthScaled / (256.0 * 256.0));\n         depthScaled -= r * (256.0 * 256.0);\n      }\n\n      if (depthScaled >= 256.0 - 1.0) {\n         g = floor(depthScaled / 256.0);\n         depthScaled -= g * 256.0;\n      }\n\n      b = floor(depthScaled);\n\n      fragColor = vec4(r / 255.0, g / 255.0, b / 255.0,  1.0);\n      return;\n   }\n\n   vec4 color = uColor;\n\n   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;\n   if (is_contours) {\n      // Contours are made of either depths or properties.\n      float val = (abs(worldPos.z) - contourReferencePoint) / contourInterval;\n\n      float f  = fract(val);\n      float df = fwidth(val);\n\n      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.\n      float c = smoothstep(0.0, df * 2.0, f);\n\n      color = color * vec4(c, c, c, 1.0);\n   }\n\n   // Use normal lighting. This has no effect if \"material\" property is not set.\n   vec3 lightColor = getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n   fragColor = vec4(lightColor, 1.0);\n\n   DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
+export default fsShader;

package/dist/layers/triangle/fragment.fs.glsl.js

@@ -0,0 +1,126 @@
+const fsShader = `#version 300 es
+#define SHADER_NAME terrainmap-shader
+
+precision highp float;
+
+uniform bool isContoursDepth;
+uniform float contourReferencePoint;
+uniform float contourInterval;
+
+in vec2 vTexCoord;
+in vec3 cameraPosition;
+in vec3 normals_commonspace;
+in vec4 position_commonspace;
+in vec3 worldPos;
+in float property;
+
+out vec4 fragColor;
+
+uniform sampler2D colormap;
+uniform vec4 uColor;
+uniform bool smoothShading;
+
+
+vec3 getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
+    
+   vec3 halfway_direction = normalize(light_direction + view_direction);   
+   float lambertian = abs(dot(light_direction, normal_worldspace));
+
+   float specular_angle = abs(dot(normal_worldspace, halfway_direction));
+
+   float specular = pow(specular_angle, lighting_uShininess);       
+   return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;    
+}
+
+vec3 getLightColor(vec3 surfaceColor,vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+
+  vec3 lightColor = surfaceColor;
+
+  if (lighting_uEnabled) {
+    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting_uPointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_uPointLight[i];
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting_uDirectionalLightCount) {
+        break;
+      }
+      DirectionalLight directionalLight = lighting_uDirectionalLight[i];
+      lightColor += getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  return lightColor;
+}
+
+void main(void) {
+   //geometry.uv = vTexCoord;
+
+   vec3 normal = normals_commonspace;
+
+   if (!smoothShading) {
+      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
+   } 
+   
+   //Picking pass.
+   if (picking_uActive) {
+      // Readout is surface height (z value).
+      float range = 10000.0;  // May represent depths in range 0 - 10000 meter.
+
+      // Express in 255 system.
+      float depth = abs(worldPos.z);
+      float depthScaled = (256.0 * 256.0 * 256.0) * (depth / range); // scaled to within max range in 256 system.
+
+      float r = 0.0;
+      float g = 0.0;
+      float b = 0.0;
+
+      if (depthScaled >= (256.0 * 256.0) - 1.0) {
+         r = floor(depthScaled / (256.0 * 256.0));
+         depthScaled -= r * (256.0 * 256.0);
+      }
+
+      if (depthScaled >= 256.0 - 1.0) {
+         g = floor(depthScaled / 256.0);
+         depthScaled -= g * 256.0;
+      }
+
+      b = floor(depthScaled);
+
+      fragColor = vec4(r / 255.0, g / 255.0, b / 255.0,  1.0);
+      return;
+   }
+
+   vec4 color = uColor;
+
+   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;
+   if (is_contours) {
+      // Contours are made of either depths or properties.
+      float val = (abs(worldPos.z) - contourReferencePoint) / contourInterval;
+
+      float f  = fract(val);
+      float df = fwidth(val);
+
+      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.
+      float c = smoothstep(0.0, df * 2.0, f);
+
+      color = color * vec4(c, c, c, 1.0);
+   }
+
+   // Use normal lighting. This has no effect if "material" property is not set.
+   vec3 lightColor = getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
+   fragColor = vec4(lightColor, 1.0);
+
+   DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+export default fsShader;
+//# sourceMappingURL=fragment.fs.glsl.js.map

package/dist/layers/triangle/fragment.fs.glsl.js.map

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

package/dist/layers/triangle/fragment_lines.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const fragmentShader = "#version 300 es\n#define SHADER_NAME graph-layer-fragment-shader\n\nprecision highp float;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  \n  // Picking pass.\n  if (picking_uActive) {\n    discard;\n    return;\n  }\n\n  fragColor = vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
+export default fragmentShader;

package/dist/layers/triangle/fragment_lines.glsl.js

@@ -0,0 +1,21 @@
+const fragmentShader = `\
+#version 300 es
+#define SHADER_NAME graph-layer-fragment-shader
+
+precision highp float;
+
+out vec4 fragColor;
+
+void main(void) {
+  
+  // Picking pass.
+  if (picking_uActive) {
+    discard;
+    return;
+  }
+
+  fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+}
+`;
+export default fragmentShader;
+//# sourceMappingURL=fragment_lines.glsl.js.map

package/dist/layers/triangle/fragment_lines.glsl.js.map

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

package/dist/layers/triangle/privateTriangleLayer.d.ts

@@ -0,0 +1,70 @@
+import { Layer, PickingInfo, UpdateParameters, LayerContext } from "@deck.gl/core/typed";
+import { LayerPickInfo } from "../utils/layerTools";
+import { DeckGLLayerContext } from "../../components/Map";
+import { ExtendedLayerProps } from "../utils/layerTools";
+export type GeometryTriangles = {
+    drawMode: number;
+    attributes: {
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        TEXCOORD_0?: {
+            value: Float32Array;
+            size: number;
+        };
+        normals: {
+            value: Float32Array;
+            size: number;
+        };
+        vertex_indexs: {
+            value: Int32Array;
+            size: number;
+        };
+    };
+    vertexCount: number;
+    indices: {
+        value: Uint32Array;
+        size: number;
+    };
+};
+export type GeometryLines = {
+    drawMode: number;
+    attributes: {
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+    };
+    vertexCount: number;
+};
+export type Material = {
+    ambient: number;
+    diffuse: number;
+    shininess: number;
+    specularColor: [number, number, number];
+} | boolean;
+export interface PrivateTriangleLayerProps<D> extends ExtendedLayerProps<D> {
+    geometryTriangles: GeometryTriangles;
+    geometryLines: GeometryLines;
+    contours: [number, number];
+    gridLines: boolean;
+    color: [number, number, number];
+    smoothShading: boolean;
+    depthTest: boolean;
+}
+export default class PrivateTriangleLayer extends Layer<PrivateTriangleLayerProps<unknown>> {
+    initializeState(context: DeckGLLayerContext): void;
+    shouldUpdateState({ props, oldProps, context, changeFlags, }: UpdateParameters<this>): boolean;
+    updateState({ context }: UpdateParameters<this>): void;
+    _getModels(gl: WebGLRenderingContext): [unknown, unknown];
+    draw(args: {
+        moduleParameters?: unknown;
+        uniforms: number[];
+        context: LayerContext;
+    }): void;
+    decodePickingColor(): number;
+    getPickingInfo({ info }: {
+        info: PickingInfo;
+    }): LayerPickInfo;
+}

package/dist/layers/triangle/privateTriangleLayer.js

@@ -0,0 +1,108 @@
+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 GL from "@luma.gl/constants";
+const defaultProps = {
+    data: ["dummy"],
+    contours: [-1, -1],
+    isContoursDepth: true,
+    gridLines: false,
+    color: [100, 100, 255],
+    coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+    depthTest: true,
+};
+// This is a private layer used only by the composite TriangleLayer
+export default class PrivateTriangleLayer extends Layer {
+    initializeState(context) {
+        const { gl } = context;
+        const [triangleModel, lineMode] = this._getModels(gl);
+        this.setState({ models: [triangleModel, lineMode] });
+    }
+    shouldUpdateState({ props, oldProps, context, changeFlags, }) {
+        return (super.shouldUpdateState({
+            props,
+            oldProps,
+            context,
+            changeFlags,
+        }) || changeFlags.propsOrDataChanged);
+    }
+    updateState({ context }) {
+        this.initializeState(context);
+    }
+    _getModels(gl) {
+        const triangleModel = new Model(gl, {
+            id: `${this.props.id}-mesh`,
+            vs: vsShader,
+            fs: fsShader,
+            geometry: new Geometry(this.props.geometryTriangles),
+            modules: [project, picking, phongLighting],
+            isInstanced: false, // This only works when set to false.
+        });
+        const lineModel = new Model(gl, {
+            id: `${this.props.id}-lines`,
+            vs: vsLineShader,
+            fs: fsLineShader,
+            geometry: new Geometry(this.props.geometryLines),
+            modules: [project, picking],
+            isInstanced: false,
+        });
+        return [triangleModel, lineModel];
+    }
+    draw(args) {
+        var _a, _b;
+        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 [triangleModel, lineModel] = this.state["models"];
+        const smoothShading = this.props.smoothShading;
+        // Normalize to [0,1] range.
+        const uColor = this.props.color.map((x) => (x !== null && x !== void 0 ? x : 0) / 255);
+        uColor.push(1); // alpha channel.
+        if (!this.props.depthTest) {
+            gl.disable(GL.DEPTH_TEST);
+        }
+        gl.enable(GL.POLYGON_OFFSET_FILL);
+        gl.polygonOffset(1, 1);
+        triangleModel
+            .setUniforms(Object.assign(Object.assign({}, uniforms), { contourReferencePoint,
+            contourInterval,
+            smoothShading,
+            uColor }))
+            .draw();
+        gl.disable(GL.POLYGON_OFFSET_FILL);
+        if (this.props.gridLines) {
+            lineModel.draw();
+        }
+        if (!this.props.depthTest) {
+            gl.enable(GL.DEPTH_TEST);
+        }
+    }
+    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] * 256 * 256;
+        const g = info.color[1] * 256;
+        const b = info.color[2] * 1;
+        const depthRange = 10000;
+        const depth = depthRange * ((r + g + b) / (256 * 256 * 256));
+        layer_properties.push(createPropertyData("Depth", depth));
+        return Object.assign(Object.assign({}, info), { properties: layer_properties });
+    }
+}
+PrivateTriangleLayer.layerName = "privateTriangleLayer";
+PrivateTriangleLayer.defaultProps = defaultProps;
+//# sourceMappingURL=privateTriangleLayer.js.map

package/dist/layers/triangle/privateTriangleLayer.js.map

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

package/dist/layers/triangle/test_data/surfacePoints.d.ts

@@ -0,0 +1,2 @@
+declare const _default: number[];
+export default _default;