@realsee/dnalogel 3.54.1 → 3.54.2

package/libs/shared-utils/three/core/Five_LineMaterial2.js

@@ -0,0 +1,307 @@
+var o = Object.defineProperty;
+var c = (n, t, i) => t in n ? o(n, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : n[t] = i;
+var a = (n, t, i) => (c(n, typeof t != "symbol" ? t + "" : t, i), i);
+import * as r from "three";
+const s = {
+  uniforms: r.UniformsUtils.merge([
+    r.UniformsLib.common,
+    r.UniformsLib.fog,
+    {
+      linewidth: { value: 1 },
+      resolution: { value: new r.Vector2(1, 1) },
+      dashScale: { value: 1 },
+      dashSize: { value: 1 },
+      gapSize: { value: 1 },
+      // todo FIX - maybe change to totalSize
+      opacity: { value: 1 }
+    }
+  ]),
+  vertexShader: `
+		#include <common>
+		#include <color_pars_vertex>
+		#include <fog_pars_vertex>
+		#include <logdepthbuf_pars_vertex>
+		#include <clipping_planes_pars_vertex>
+
+		uniform float linewidth;
+		uniform vec2 resolution;
+
+		attribute vec3 instanceStart;
+		attribute vec3 instanceEnd;
+
+		attribute vec3 instanceColorStart;
+		attribute vec3 instanceColorEnd;
+
+		varying vec2 vUv;
+
+		#ifdef USE_DASH
+
+			uniform float dashScale;
+			attribute float instanceDistanceStart;
+			attribute float instanceDistanceEnd;
+			varying float vLineDistance;
+
+		#endif
+
+		void trimSegment( const in vec4 start, inout vec4 end ) {
+
+			// trim end segment so it terminates between the camera plane and the near plane
+
+			// conservative estimate of the near plane
+			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
+			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
+			float nearEstimate = - 0.5 * b / a;
+
+			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
+
+			end.xyz = mix( start.xyz, end.xyz, alpha );
+
+		}
+
+		void main() {
+
+			#ifdef USE_COLOR
+
+				vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd;
+
+			#endif
+
+			#ifdef USE_DASH
+
+				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
+
+			#endif
+
+			float aspect = resolution.x / resolution.y;
+
+			vUv = uv;
+
+			// camera space
+			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
+			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
+
+			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
+			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
+			// but we need to perform ndc-space calculations in the shader, so we must address this issue directly
+			// perhaps there is a more elegant solution -- WestLangley
+
+			bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column
+
+			if ( perspective ) {
+
+				if ( start.z < 0.0 && end.z >= 0.0 ) {
+
+					trimSegment( start, end );
+
+				} else if ( end.z < 0.0 && start.z >= 0.0 ) {
+
+					trimSegment( end, start );
+
+				}
+
+			}
+
+			// clip space
+			vec4 clipStart = projectionMatrix * start;
+			vec4 clipEnd = projectionMatrix * end;
+
+			// ndc space
+			vec2 ndcStart = clipStart.xy / clipStart.w;
+			vec2 ndcEnd = clipEnd.xy / clipEnd.w;
+
+			// direction
+			vec2 dir = ndcEnd - ndcStart;
+
+			// account for clip-space aspect ratio
+			dir.x *= aspect;
+			dir = normalize( dir );
+
+			// perpendicular to dir
+			vec2 offset = vec2( dir.y, - dir.x );
+
+			// undo aspect ratio adjustment
+			dir.x /= aspect;
+			offset.x /= aspect;
+
+			// sign flip
+			if ( position.x < 0.0 ) offset *= - 1.0;
+
+			// endcaps
+			if ( position.y < 0.0 ) {
+
+				offset += - dir;
+
+			} else if ( position.y > 1.0 ) {
+
+				offset += dir;
+
+			}
+
+			// adjust for linewidth
+			offset *= linewidth;
+
+			// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
+			offset /= resolution.y;
+
+			// select end
+			vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
+
+			// back to clip space
+			offset *= clip.w;
+
+			clip.xy += offset;
+
+			gl_Position = clip;
+
+			vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation
+
+			#include <logdepthbuf_vertex>
+			#include <clipping_planes_vertex>
+			#include <fog_vertex>
+
+		}
+		`,
+  fragmentShader: `
+		uniform vec3 diffuse;
+		uniform float opacity;
+
+		#ifdef USE_DASH
+
+			uniform float dashSize;
+			uniform float gapSize;
+
+		#endif
+
+		varying float vLineDistance;
+
+		#include <common>
+		#include <color_pars_fragment>
+		#include <fog_pars_fragment>
+		#include <logdepthbuf_pars_fragment>
+		#include <clipping_planes_pars_fragment>
+
+		varying vec2 vUv;
+
+		void main() {
+
+			#include <clipping_planes_fragment>
+
+			#ifdef USE_DASH
+
+				if ( vUv.y < - 1.0 || vUv.y > 1.0 ) discard; // discard endcaps
+
+				if ( mod( vLineDistance, dashSize + gapSize ) < dashSize ) discard; // todo - FIX
+
+			#endif
+
+			if ( abs( vUv.y ) > 1.0 ) {
+
+				float a = vUv.x;
+				float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+				float len2 = a * a + b * b;
+
+				if ( len2 > 1.0 ) discard;
+
+			}
+
+			vec4 diffuseColor = vec4( diffuse, opacity );
+
+			#include <logdepthbuf_fragment>
+			#include <color_fragment>
+
+			gl_FragColor = vec4( diffuseColor.rgb, diffuseColor.a );
+
+			#include <tonemapping_fragment>
+			#include <fog_fragment>
+			#include <premultiplied_alpha_fragment>
+
+		}
+		`
+};
+class l extends r.ShaderMaterial {
+  // to be set by renderer
+  constructor(i) {
+    super({
+      uniforms: r.UniformsUtils.clone(s.uniforms),
+      vertexShader: s.vertexShader,
+      fragmentShader: s.fragmentShader,
+      clipping: !0
+      // required for clipping support
+    });
+    a(this, "color");
+    a(this, "dashed");
+    a(this, "dashScale");
+    a(this, "dashSize");
+    a(this, "gapSize");
+    a(this, "resolution");
+    this.type = "LineMaterial", this.dashed = !1, Object.defineProperties(this, {
+      color: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.diffuse.value;
+        },
+        set(e) {
+          this.uniforms.diffuse.value = e;
+        }
+      },
+      linewidth: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.linewidth.value;
+        },
+        set(e) {
+          this.uniforms.linewidth.value = e;
+        }
+      },
+      dashScale: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.dashScale.value;
+        },
+        set(e) {
+          this.uniforms.dashScale.value = e;
+        }
+      },
+      dashSize: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.dashSize.value;
+        },
+        set(e) {
+          this.uniforms.dashSize.value = e;
+        }
+      },
+      gapSize: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.gapSize.value;
+        },
+        set(e) {
+          this.uniforms.gapSize.value = e;
+        }
+      },
+      opacity: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.opacity.value;
+        },
+        set(e) {
+          this.uniforms.opacity.value = e;
+        }
+      },
+      resolution: {
+        enumerable: !0,
+        get() {
+          return this.uniforms.resolution.value;
+        },
+        set(e) {
+          this.uniforms.resolution.value.copy(e);
+        }
+      }
+    }), this.setValues(i);
+  }
+}
+Object.assign(l.prototype, { isLineMaterial: !0 });
+export {
+  l as Five_LineMaterial2
+};

package/libs/shared-utils/three/core/Line2.d.ts

@@ -0,0 +1,13 @@
+import { THREE_Line2 as Five_THREE_Line2 } from '@realsee/five/line';
+import type { LineMaterial } from './LineMaterial';
+import type { LineGeometry } from './LineGeometry';
+export declare class THREE_Line2 extends Five_THREE_Line2 {
+    material: LineMaterial;
+    constructor(geometry: LineGeometry, material: LineMaterial);
+    toJSON(): {
+        type: string;
+        geometryAttributes: {
+            [name: string]: import("three").BufferAttribute | import("three").InterleavedBufferAttribute;
+        };
+    };
+}

package/libs/shared-utils/three/core/Line2.js

@@ -0,0 +1,15 @@
+import { THREE_Line2 as r } from "@realsee/five/line";
+class o extends r {
+  constructor(e, t) {
+    super(e, t);
+  }
+  toJSON() {
+    return {
+      type: "Five_THREE_Line2",
+      geometryAttributes: this.geometry.attributes
+    };
+  }
+}
+export {
+  o as THREE_Line2
+};

package/libs/shared-utils/three/core/LineMaterial.d.ts

@@ -0,0 +1,19 @@
+import { LineMaterial as Five_LineMaterial } from '@realsee/five/line';
+import * as THREE from 'three';
+import type { Merge } from 'type-fest';
+import type { Color } from '../../..';
+export declare class LineMaterial extends Five_LineMaterial {
+    get three_color(): Color;
+    set three_color(value: Color);
+    /**
+     * @deprecated Use `setDashed` to set
+     */
+    dashed: boolean;
+    private _three_color;
+    constructor(params?: Merge<ConstructorParameters<typeof Five_LineMaterial>[0], THREE.MeshBasicMaterialParameters>);
+    setDashed(dashed: boolean): void;
+    toJSON(): {
+        type: string;
+        color: number | THREE.Vector3;
+    };
+}

package/libs/shared-utils/three/core/LineMaterial.js

@@ -0,0 +1,33 @@
+var c = Object.defineProperty;
+var s = (o, t, e) => t in o ? c(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var r = (o, t, e) => (s(o, typeof t != "symbol" ? t + "" : t, e), e);
+import { LineMaterial as n } from "@realsee/five/line";
+import { notNil as d } from "../../isNil.js";
+class u extends n {
+  constructor(e) {
+    var h, l;
+    super(e);
+    r(this, "_three_color");
+    d(e == null ? void 0 : e.color) && (this.three_color = (h = e == null ? void 0 : e.color) != null ? h : 16777215), Object.keys(e).forEach((i) => {
+      ["color", "dashed", "dashScale", "dashSize", "gapSize", "resolution"].includes(i) || i in this && (this[i] = e[i]);
+    }), this.setDashed((l = e == null ? void 0 : e.dashed) != null ? l : !1);
+  }
+  get three_color() {
+    return this._three_color;
+  }
+  set three_color(e) {
+    this._three_color = e, this.color = e;
+  }
+  setDashed(e) {
+    this.dashed = e, e ? this.defines.USE_DASH = "" : delete this.defines.USE_DASH, this.needsUpdate = !0;
+  }
+  toJSON() {
+    return {
+      type: "FiveLineMaterial",
+      color: this.color
+    };
+  }
+}
+export {
+  u as LineMaterial
+};

package/libs/shared-utils/three/core/LineMaterial2.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+import type { Merge } from 'type-fest';
+import type { Color } from '../../..';
+import { Five_LineMaterial2 } from './Five_LineMaterial2';
+export declare class LineMaterial2 extends Five_LineMaterial2 {
+    get three_color(): Color;
+    set three_color(value: Color);
+    /**
+     * @deprecated Use `setDashed` to set
+     */
+    dashed: boolean;
+    private _three_color;
+    constructor(params?: Merge<ConstructorParameters<typeof Five_LineMaterial2>[0], THREE.MeshBasicMaterialParameters>);
+    setDashed(dashed: boolean): void;
+    toJSON(): {
+        type: string;
+        color: number | THREE.Vector3;
+    };
+}

package/libs/shared-utils/three/core/LineMaterial2.js

@@ -0,0 +1,33 @@
+var c = Object.defineProperty;
+var s = (o, t, e) => t in o ? c(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var r = (o, t, e) => (s(o, typeof t != "symbol" ? t + "" : t, e), e);
+import { notNil as d } from "../../isNil.js";
+import { Five_LineMaterial2 as n } from "./Five_LineMaterial2.js";
+class u extends n {
+  constructor(e) {
+    var h, l;
+    super(e);
+    r(this, "_three_color");
+    d(e == null ? void 0 : e.color) && (this.three_color = (h = e == null ? void 0 : e.color) != null ? h : 16777215), Object.keys(e).forEach((i) => {
+      ["color", "dashed", "dashScale", "dashSize", "gapSize", "resolution"].includes(i) || i in this && (this[i] = e[i]);
+    }), this.setDashed((l = e == null ? void 0 : e.dashed) != null ? l : !1);
+  }
+  get three_color() {
+    return this._three_color;
+  }
+  set three_color(e) {
+    this._three_color = e, this.color = e;
+  }
+  setDashed(e) {
+    this.dashed = e, e ? this.defines.USE_DASH = "" : delete this.defines.USE_DASH, this.needsUpdate = !0;
+  }
+  toJSON() {
+    return {
+      type: "FiveLineMaterial",
+      color: this.color
+    };
+  }
+}
+export {
+  u as LineMaterial2
+};

package/libs/shared-utils/three/index.js

@@ -4,6 +4,7 @@ import "./PointSelector/index.js";
 import "three/examples/jsm/renderers/CSS3DRenderer";
 import "../tag.js";
 import "@realsee/five/line";
+import "./core/Five_LineMaterial2.js";
 import "./core/Sphere.js";
 import "animejs";
 import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realsee/dnalogel",
-  "version": "3.54.1",
+  "version": "3.54.2",
   "main": "./dist/index.js",
   "module": "./libs/index.js",
   "types": "./libs/index.d.ts",