@tomorrowevening/hermes 0.1.39 → 0.1.40

package/dist/editor/components/icons/DragIcon.js

@@ -0,0 +1,12 @@
+import { jsx as r } from "react/jsx-runtime";
+const o = /* @__PURE__ */ r("svg", { className: "dragIcon", width: "14", height: "14", fill: "#666666", stroke: "none", children: /* @__PURE__ */ r(
+  "path",
+  {
+    d: `M10.43,4H3.57C3.26,4,3,4.22,3,4.5v1C3,5.78,3.26,6,3.57,6h6.86C10.74,6,11,5.78,11,5.5v-1\r
+C11,4.22,10.74,4,10.43,4z M10.43,8H3.57C3.26,8,3,8.22,3,8.5v1C3,9.78,3.26,10,3.57,10h6.86C10.74,10,11,9.78,11,9.5v-1\r
+C11,8.22,10.74,8,10.43,8z`
+  }
+) });
+export {
+  o as default
+};

package/dist/editor/multiView/CameraWindow.js

@@ -0,0 +1,64 @@
+import { jsxs as f, jsx as d } from "react/jsx-runtime";
+import { forwardRef as w, useState as l } from "react";
+const x = (e) => {
+  const [n, c] = l(e.options[e.index]), i = () => {
+    e.onToggle(!e.open);
+  }, a = (t) => {
+    t !== n && (e.onSelect(t), c(t)), e.onToggle(!1);
+  }, s = e.open ? `${e.options.length * 31 - 1}px` : "0px";
+  return /* @__PURE__ */ f("div", { className: `dropdown ${e.up === !0 ? "up" : ""}`, children: [
+    /* @__PURE__ */ d("div", { className: "dropdown-toggle", onClick: i, children: `${e.title}: ${n}` }),
+    /* @__PURE__ */ d("ul", { className: "dropdown-menu", style: { height: s }, children: e.options.map((t) => /* @__PURE__ */ d("li", { onClick: () => a(t), children: t }, t)) })
+  ] });
+}, R = w(function(n, c) {
+  const i = [
+    "Renderer",
+    "Depth",
+    "Normals",
+    "UVs",
+    "Wireframe"
+  ], [a, s] = l("Renderer"), [t, O] = l(!1), [u, g] = l(!1), [r, m] = l(!1);
+  return /* @__PURE__ */ f("div", { className: `CameraWindow ${n.name}`, children: [
+    /* @__PURE__ */ d("div", { ref: c, className: "clickable", onClick: () => {
+      r && m(!1);
+    } }),
+    /* @__PURE__ */ f("div", { className: "options", children: [
+      n.camera !== null && /* @__PURE__ */ d(
+        x,
+        {
+          title: "Camera",
+          index: n.options.indexOf(n.camera.name),
+          open: r,
+          options: n.options,
+          onSelect: n.onSelectCamera,
+          onToggle: (o) => {
+            o && u && g(!1), m(o);
+          },
+          up: !0
+        }
+      ),
+      /* @__PURE__ */ d(
+        x,
+        {
+          title: "Mode",
+          index: i.indexOf(a),
+          open: u,
+          options: i,
+          onSelect: (o) => {
+            if (o === a) return;
+            const h = o;
+            n.onSelectRenderMode(h), s(h);
+          },
+          onToggle: (o) => {
+            o && r && m(!1), t && O(!1), g(o);
+          },
+          up: !0
+        }
+      )
+    ] })
+  ] });
+});
+export {
+  x as Dropdown,
+  R as default
+};

package/dist/editor/multiView/DepthNodeMaterial.js

@@ -0,0 +1,12 @@
+import o from "three/src/materials/nodes/MeshBasicNodeMaterial.js";
+import { remapClamp as r, linearDepth as t, vec4 as a } from "three/src/nodes/TSL.js";
+class c extends o {
+  constructor() {
+    super();
+    const e = r(t(), 0.1, 0.5, 0, 1).oneMinus();
+    this.colorNode = a(e, e, e, 1);
+  }
+}
+export {
+  c as default
+};

package/dist/editor/multiView/InfiniteGridHelper.js

@@ -0,0 +1,31 @@
+import { Mesh as t, PlaneGeometry as e } from "three";
+import a from "./InfiniteGridMaterial.js";
+class g extends t {
+  gridMaterial;
+  constructor(i) {
+    const r = new a(i);
+    super(new e(), r), this.gridMaterial = r, this.frustumCulled = !1, this.name = "InfiniteGridHelper";
+  }
+  // Getters / Setters
+  get color() {
+    return this.gridMaterial.color;
+  }
+  set color(i) {
+    this.gridMaterial.color = i;
+  }
+  get gridOpacity() {
+    return this.gridMaterial.gridOpacity;
+  }
+  set gridOpacity(i) {
+    this.gridMaterial.gridOpacity = i;
+  }
+  get subgridOpacity() {
+    return this.gridMaterial.subgridOpacity;
+  }
+  set subgridOpacity(i) {
+    this.gridMaterial.subgridOpacity = i;
+  }
+}
+export {
+  g as default
+};

package/dist/editor/multiView/InfiniteGridHelperGPU.js

@@ -0,0 +1,31 @@
+import { Mesh as t, PlaneGeometry as e } from "three/webgpu";
+import a from "./InfiniteGridNodeMaterial.js";
+class g extends t {
+  gridMaterial;
+  constructor(i) {
+    const r = new a(i);
+    super(new e(), r), this.gridMaterial = r, this.frustumCulled = !1, this.name = "InfiniteGridHelper";
+  }
+  // Getters / Setters
+  get color() {
+    return this.gridMaterial.color;
+  }
+  set color(i) {
+    this.gridMaterial.color = i;
+  }
+  get gridOpacity() {
+    return this.gridMaterial.gridOpacity;
+  }
+  set gridOpacity(i) {
+    this.gridMaterial.gridOpacity = i;
+  }
+  get subgridOpacity() {
+    return this.gridMaterial.subgridOpacity;
+  }
+  set subgridOpacity(i) {
+    this.gridMaterial.subgridOpacity = i;
+  }
+}
+export {
+  g as default
+};

package/dist/editor/multiView/InfiniteGridMaterial.js

@@ -0,0 +1,137 @@
+import { ShaderMaterial as i, DoubleSide as t, GLSL3 as a, Color as o } from "three";
+const r = `out vec3 worldPosition;
+uniform float uDistance;
+
+void main() {
+  // Scale the plane by the drawing distance
+  worldPosition = position.xzy * uDistance;
+  worldPosition.xz += cameraPosition.xz;
+
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(worldPosition, 1.0);
+}`, n = `out vec4 fragColor;
+in vec3 worldPosition;
+uniform float uDivisions;
+uniform float uScale;
+uniform vec3 uColor;
+uniform float uDistance;
+uniform float uGridOpacity;
+uniform float uSubgridOpacity;
+
+#define minAlpha 0.00784313725490196
+
+float getGrid(float gapSize) {
+  vec2 worldPositionByDivision = worldPosition.xz / gapSize;
+
+  // Inverted, 0 where line, >1 where there's no line
+  // We use the worldPosition (which in this case we use similarly to UVs) differential to control the anti-aliasing
+  // We need to do the -0.5)-0.5 trick because the result fades out from 0 to 1, and we want both
+  // worldPositionByDivision == 0.3 and worldPositionByDivision == 0.7 to result in the same fade, i.e. 0.3,
+  // otherwise only one side of the line will be anti-aliased
+  vec2 grid = abs(fract(worldPositionByDivision-0.5)-0.5) / fwidth(worldPositionByDivision) / 2.0;
+  float gridLine = min(grid.x, grid.y);
+
+  // Uninvert and clamp
+  return 1.0 - min(gridLine, 1.0);
+}
+
+void main() {
+  float cameraDistanceToGridPlane = max(200.0, distance(cameraPosition.y, worldPosition.y));
+  float cameraDistanceToFragmentOnGridPlane = distance(cameraPosition.xyz, worldPosition.xyz);
+
+  // The size of the grid and subgrid are powers of each other and they are determined based on camera distance.
+  // The current grid will become the next subgrid when it becomes too small, and its next power becomes the new grid.
+  float subGridPower = pow(uDivisions, floor(log(cameraDistanceToGridPlane) / log(uDivisions)));
+  float gridPower = subGridPower * uDivisions;
+
+  // If we want to fade both the grid and its subgrid, we need to displays 3 different opacities, with the next grid being the third
+  float nextGridPower = gridPower * uDivisions;
+
+  // 1 where grid, 0 where no grid
+  float subgrid = getGrid(subGridPower * uScale);
+  float grid = getGrid(gridPower * uScale);
+  float nextGrid = getGrid(nextGridPower * uScale);
+
+  // Where we are between the introduction of the current grid power and when we switch to the next grid power
+  float stepPercentage = (cameraDistanceToGridPlane - subGridPower)/(gridPower - subGridPower);
+
+  // The last x percentage of the current step over which we want to fade
+  float fadeRange = 0.3;
+
+  // We calculate the fade percentage from the step percentage and the fade range
+  float fadePercentage = max(stepPercentage - 1.0 + fadeRange, 0.0) / fadeRange;
+
+  // Set base opacity based on how close we are to the drawing distance, with a cubic falloff
+  float baseOpacity = subgrid * pow(1.0 - min(cameraDistanceToFragmentOnGridPlane / uDistance, 1.0), 3.0);
+
+  // Shade the subgrid
+  fragColor = vec4(uColor.rgb, (baseOpacity - fadePercentage) * uSubgridOpacity);
+
+  // Somewhat arbitrary additional fade coefficient to counter anti-aliasing popping when switching between grid powers
+  float fadeCoefficient = 0.5;
+
+  // Shade the grid
+  fragColor.a = mix(fragColor.a, baseOpacity * uGridOpacity - fadePercentage * (uGridOpacity - uSubgridOpacity) * fadeCoefficient, grid);
+
+  // Shade the next grid
+  fragColor.a = mix(fragColor.a, baseOpacity * uGridOpacity, nextGrid);
+
+  if (fragColor.a <= minAlpha) discard;
+}`;
+class l extends i {
+  constructor(e) {
+    super({
+      extensions: {
+        // @ts-ignore
+        derivatives: !0
+      },
+      uniforms: {
+        uScale: {
+          value: e?.scale !== void 0 ? e?.scale : 0.1
+        },
+        uDivisions: {
+          value: e?.divisions !== void 0 ? e?.divisions : 10
+        },
+        uColor: {
+          value: e?.color !== void 0 ? e?.color : new o(16777215)
+        },
+        uDistance: {
+          value: e?.distance !== void 0 ? e?.distance : 1e4
+        },
+        uSubgridOpacity: {
+          value: e?.subgridOpacity !== void 0 ? e?.subgridOpacity : 0.15
+        },
+        uGridOpacity: {
+          value: e?.gridOpacity !== void 0 ? e?.gridOpacity : 0.25
+        }
+      },
+      glslVersion: a,
+      side: t,
+      transparent: !0,
+      name: "InfiniteGrid",
+      vertexShader: r,
+      fragmentShader: n
+    });
+  }
+  // Getters / Setters
+  get color() {
+    return this.uniforms.uColor.value;
+  }
+  set color(e) {
+    this.uniforms.uColor.value = e;
+  }
+  get gridOpacity() {
+    return this.uniforms.uGridOpacity.value;
+  }
+  set gridOpacity(e) {
+    this.uniforms.uGridOpacity.value = e;
+  }
+  get subgridOpacity() {
+    return this.uniforms.uSubgridOpacity.value;
+  }
+  set subgridOpacity(e) {
+    this.uniforms.uSubgridOpacity.value = e;
+  }
+}
+export {
+  l as default
+};

package/dist/editor/multiView/InfiniteGridNodeMaterial.js

@@ -0,0 +1,63 @@
+import { NodeMaterial as q, DoubleSide as E, Color as j } from "three/webgpu";
+import { uniform as u, varyingProperty as k, Fn as v, positionLocal as A, vec3 as B, cameraPosition as n, float as i, fwidth as H, abs as x, fract as J, min as h, max as D, distance as K, log as P, pow as S, floor as Q, mix as C, If as U, lessThanEqual as V, Discard as X, vec4 as Y } from "three/tsl";
+class ii extends q {
+  uScale;
+  uDivisions;
+  uColor;
+  uDistance;
+  uSubgridOpacity;
+  uGridOpacity;
+  constructor(t) {
+    super(), this.name = "InfiniteGrid", this.side = E, this.transparent = !0, this.uScale = u(t?.scale ?? 0.1), this.uDivisions = u(t?.divisions ?? 10), this.uColor = u(t?.color ?? new j(16777215)), this.uDistance = u(t?.distance ?? 1e4), this.uSubgridOpacity = u(t?.subgridOpacity ?? 0.15), this.uGridOpacity = u(t?.gridOpacity ?? 0.25);
+    const { uScale: c, uDivisions: a, uColor: N, uDistance: y, uSubgridOpacity: f, uGridOpacity: d } = this, l = k("vec3", "vWorldPosition");
+    this.positionNode = v(() => {
+      const s = A.xzy.mul(y).add(
+        B(n.x, i(0), n.z)
+      );
+      return l.assign(s), s;
+    })();
+    const g = v(([s]) => {
+      const e = l.xz.div(s), b = H(e), r = x(J(e.sub(0.5)).sub(0.5)).div(b).div(2), o = h(r.x, r.y);
+      return i(1).sub(h(o, i(1)));
+    });
+    this.outputNode = v(() => {
+      const s = l, e = D(i(200), x(n.y.sub(s.y))), b = i(K(n, s)), r = P(e).div(P(a)), o = S(a, Q(r)), m = o.mul(a), z = m.mul(a), F = g(o.mul(c)), I = g(m.mul(c)), T = g(z.mul(c)), L = e.sub(o).div(m.sub(o)), O = i(0.3), G = D(
+        L.sub(i(1)).add(O),
+        i(0)
+      ).div(O), p = F.mul(
+        S(i(1).sub(h(b.div(y), i(1))), i(3))
+      ), M = i(0.5), R = p.sub(G).mul(f), W = C(
+        R,
+        p.mul(d).sub(
+          G.mul(d.sub(f)).mul(M)
+        ),
+        I
+      ), w = i(C(W, p.mul(d), T));
+      return U(V(w, i(1 / 127)), () => {
+        X();
+      }), Y(N, w);
+    })();
+  }
+  // Getters / Setters
+  get color() {
+    return this.uColor.value;
+  }
+  set color(t) {
+    this.uColor.value = t;
+  }
+  get gridOpacity() {
+    return this.uGridOpacity.value;
+  }
+  set gridOpacity(t) {
+    this.uGridOpacity.value = t;
+  }
+  get subgridOpacity() {
+    return this.uSubgridOpacity.value;
+  }
+  set subgridOpacity(t) {
+    this.uSubgridOpacity.value = t;
+  }
+}
+export {
+  ii as default
+};