@tomorrowevening/hermes 0.1.39 → 0.1.40

package/dist/utils/theatre.js

@@ -0,0 +1,316 @@
+import { types as n } from "@tomorrowevening/theatre-core";
+import { useState as d, useEffect as p } from "react";
+let m;
+function v() {
+  const [i, s] = d(m);
+  return p(() => {
+    m || import("@tomorrowevening/theatre-studio").then((e) => {
+      m = e.default, m.initialize(), m.ui.hide(), s(m);
+    });
+  }, []), i;
+}
+async function E() {
+  for (; !document.getElementById("theatrejs-studio-root"); )
+    await new Promise((r) => setTimeout(r, 100));
+  const i = document.getElementById("theatrejs-studio-root");
+  if (i === null || i.shadowRoot === null) return;
+  const s = i.shadowRoot.getElementById("pointer-root");
+  if (s === null) return;
+  const e = s.children[0];
+  if (e !== null) {
+    try {
+      const t = e.children[1].children[1];
+      t.parentElement?.removeChild(t);
+    } catch {
+    }
+    try {
+      const r = e.children[3];
+      r.style.top = "0", r.style.right = "300px";
+    } catch {
+    }
+  }
+}
+function O(i, s, e, r) {
+  r.sheetObject(i, s, {
+    transform: {
+      position: {
+        x: e.position.x,
+        y: e.position.y,
+        z: e.position.z
+      },
+      rotation: {
+        x: e.rotation.x,
+        y: e.rotation.y,
+        z: e.rotation.z
+      },
+      scale: {
+        x: e.scale.x,
+        y: e.scale.y,
+        z: e.scale.z
+      },
+      visible: e.visible
+    }
+  }, (t) => {
+    const o = t.transform;
+    e.position.copy(o.position), e.rotation.copy(o.rotation), e.scale.copy(o.scale), e.visible = o.visible;
+  });
+}
+const h = [
+  "allowOverride",
+  "alphaHash",
+  "alphaTest",
+  "alphaToCoverage",
+  "blendAlpha",
+  "blendColor",
+  "blendDst",
+  "blendDstAlpha",
+  "blendEquation",
+  "blendEquationAlpha",
+  "blendSrc",
+  "blendSrcAlpha",
+  "blending",
+  "clipIntersection",
+  "clipShadows",
+  "clipping",
+  "clippingPlanes",
+  "colorWrite",
+  "combine",
+  "defaultAttributeValues",
+  "defines",
+  "depthFunc",
+  "depthTest",
+  "depthWrite",
+  "dithering",
+  "extensions",
+  "fog",
+  "forceSinglePass",
+  "fragmentShader",
+  "glslVersion",
+  "id",
+  "index0AttributeName",
+  "index1AttributeName",
+  "index2AttributeName",
+  "index3AttributeName",
+  "index4AttributeName",
+  "isMaterial",
+  "lights",
+  "linewidth",
+  "name",
+  "needsUpdate",
+  "polygonOffset",
+  "polygonOffsetFactor",
+  "polygonOffsetUnits",
+  "precision",
+  "premultipliedAlpha",
+  "shadowSide",
+  "side",
+  "stencilFail",
+  "stencilFunc",
+  "stencilFuncMask",
+  "stencilRef",
+  "stencilWrite",
+  "stencilWriteMask",
+  "stencilZFail",
+  "stencilZPass",
+  "toneMapped",
+  "transparent",
+  "type",
+  "uniformsGroups",
+  "uniformsNeedUpdate",
+  "userData",
+  "uuid",
+  "version",
+  "vertexColors",
+  "vertexShader",
+  "visible",
+  "wireframe",
+  "wireframeLinewidth",
+  "wireframeLinecap",
+  "wireframeLinejoin"
+];
+function f(i) {
+  const s = typeof i;
+  if (i === null || i.isTexture)
+    return "texture";
+  if (s === "boolean")
+    return "boolean";
+  if (s === "number")
+    return "number";
+  if (s === "string")
+    return "string";
+  if (s === "object") {
+    if (i.isColor)
+      return "color";
+    if (i.isVector2)
+      return "vector2";
+    if (i.isVector3)
+      return "vector3";
+    if (i.isVector4)
+      return "vector4";
+    if (i.isMatrix2)
+      return "matrix2";
+    if (i.isMatrix3)
+      return "matrix3";
+    if (i.isMatrix4)
+      return "matrix4";
+    if (i.isEuler)
+      return "euler";
+    if (Array.isArray(i))
+      return "array";
+  }
+  return "object";
+}
+function y(i) {
+  const s = [];
+  for (const r in i) {
+    const t = h.find((a) => a === r), o = r.indexOf("_") === 0 || r.indexOf("is") === 0;
+    if (!(t || o))
+      if (r === "uniforms") {
+        const a = i.uniforms;
+        for (const c in a) {
+          const b = a[c].value, u = f(b);
+          u === "array" || u === "object" || s.push({
+            name: `uniforms.${c}.value`,
+            type: u,
+            value: b
+          });
+        }
+      } else {
+        const a = f(i[r]);
+        s.push({
+          name: r,
+          type: a,
+          value: i[r]
+        });
+      }
+  }
+  return s.filter(
+    (r) => r.type !== "array" && r.type !== "object" && r.type !== "texture"
+  );
+}
+function x(i) {
+  const s = {}, e = { nudgeMultiplier: 0.01 };
+  return i.forEach((r) => {
+    let t = r.value;
+    switch (r.type) {
+      case "color":
+        t = n.rgba({ r: t.r, g: t.g, b: t.b, a: 1 });
+        break;
+      case "number":
+        t = n.number(t, e);
+        break;
+      case "euler":
+      case "vector3":
+        t = {
+          x: n.number(t.x, e),
+          y: n.number(t.y, e),
+          z: n.number(t.z, e)
+        };
+        break;
+      case "vector2":
+        t = {
+          x: n.number(t.x, e),
+          y: n.number(t.y, e)
+        };
+        break;
+      case "vector4":
+        t = {
+          x: n.number(t.x, e),
+          y: n.number(t.y, e),
+          z: n.number(t.z, e),
+          w: n.number(t.w, e)
+        };
+        break;
+      case "matrix2":
+        t = {
+          0: n.number(t.elements[0], e),
+          1: n.number(t.elements[1], e),
+          2: n.number(t.elements[2], e),
+          3: n.number(t.elements[3], e)
+        };
+        break;
+      case "matrix3":
+        t = {
+          0: n.number(t.elements[0], e),
+          1: n.number(t.elements[1], e),
+          2: n.number(t.elements[2], e),
+          3: n.number(t.elements[3], e),
+          4: n.number(t.elements[4], e),
+          5: n.number(t.elements[5], e),
+          6: n.number(t.elements[6], e),
+          7: n.number(t.elements[7], e),
+          8: n.number(t.elements[8], e)
+        };
+        break;
+      case "matrix4":
+        t = {
+          0: n.number(t.elements[0], e),
+          1: n.number(t.elements[1], e),
+          2: n.number(t.elements[2], e),
+          3: n.number(t.elements[3], e),
+          4: n.number(t.elements[4], e),
+          5: n.number(t.elements[5], e),
+          6: n.number(t.elements[6], e),
+          7: n.number(t.elements[7], e),
+          8: n.number(t.elements[8], e),
+          9: n.number(t.elements[9], e),
+          10: n.number(t.elements[10], e),
+          11: n.number(t.elements[11], e),
+          12: n.number(t.elements[12], e),
+          13: n.number(t.elements[13], e),
+          14: n.number(t.elements[14], e),
+          15: n.number(t.elements[15], e)
+        };
+        break;
+    }
+    if (r.name.includes(".")) {
+      const o = r.name.split(".");
+      let l = s;
+      for (let a = 0; a < o.length - 1; a++) {
+        const c = o[a];
+        l[c] || (l[c] = {}), l = l[c];
+      }
+      l[o[o.length - 1]] = t;
+    } else
+      s[r.name] = t;
+  }), s;
+}
+function g(i, s, e) {
+  s.forEach((r) => {
+    if (i[r.name] !== void 0)
+      switch (r.type) {
+        case "boolean":
+        case "number":
+          i[r.name] = e.material[r.name];
+          break;
+        case "color":
+        case "euler":
+        case "matrix2":
+        case "matrix3":
+        case "matrix4":
+        case "vector2":
+        case "vector3":
+        case "vector4":
+          i[r.name].copy(e.material[r.name]);
+          break;
+      }
+  });
+}
+function M(i, s, e, r) {
+  if (!e.isMaterial) return;
+  const t = y(e), o = x(t);
+  r.sheetObject(i, s, {
+    material: o
+  }, (l) => {
+    g(e, t, l);
+  });
+}
+export {
+  M as animateObjectMaterial,
+  O as animateObjectTransform,
+  g as applyObjectMaterial,
+  E as customizeTheatreElements,
+  x as getObjectMaterialObject,
+  y as getObjectMaterialProps,
+  v as useStudio
+};

package/dist/utils/three.js

@@ -0,0 +1,199 @@
+import { BufferGeometry as M, OrthographicCamera as y, Texture as g, Scene as T, MeshBasicMaterial as O, Float32BufferAttribute as l, Mesh as B, LinearSRGBColorSpace as m, ObjectLoader as R, AnimationMixer as D, AnimationClip as W, Matrix4 as Z, AlwaysStencilFunc as v, ReplaceStencilOp as o, NotEqualStencilFunc as A, EqualStencilFunc as w, KeepStencilOp as c, NormalBlending as q, AddEquation as u, SrcAlphaFactor as F, OneMinusSrcAlphaFactor as b, CustomBlending as f, OneFactor as x, DstColorFactor as P, OneMinusDstColorFactor as U } from "three";
+const h = new M();
+h.setAttribute("position", new l([-0.5, -0.5, 0, 1.5, -0.5, 0, -0.5, 1.5, 0], 3));
+h.setAttribute("normal", new l([0, 0, 1, 0, 0, 1], 3));
+h.setAttribute("uv", new l([0, 0, 2, 0, 0, 2], 2));
+const I = new y(-0.5, 0.5, 0.5, -0.5, 0, 100), S = (e) => {
+  e?.dispose();
+}, C = (e) => {
+  if (e)
+    if (Array.isArray(e))
+      e.forEach((t) => C(t));
+    else {
+      for (const t in e) {
+        const n = e[t];
+        n !== null && n instanceof g && S(n);
+      }
+      if (e.isShaderMaterial === !0) {
+        const t = e;
+        for (const n in t.uniforms) {
+          const i = t.uniforms[n];
+          i.value !== null && i.value instanceof g && S(i.value);
+        }
+      }
+      e.dispose();
+    }
+}, L = (e) => {
+  if (e) {
+    for (; e.children.length > 0; ) {
+      const t = e.children[0];
+      t.type === "Audio" ? (t.pause(), t.parent && t.parent.remove(t)) : L(t);
+    }
+    if (e.parent && e.parent.remove(e), e.isMesh) {
+      const t = e;
+      t.geometry?.dispose(), C(t.material);
+    }
+    e.dispose !== void 0 && e.dispose();
+  }
+};
+let d = 0;
+const N = () => {
+  d = 0;
+}, $ = (e) => {
+  if (!e) return;
+  let t = e.name.replaceAll(" ", "").replaceAll("/", ".");
+  if (t.length === 0 && (t = `obj_${d}`, d++), e.parent !== null && e.parent.uuid.length > 0 && (t = `${e.parent.uuid}.${t}`), e.uuid = t, e.isMesh !== void 0) {
+    const n = e;
+    if (Array.isArray(n.material))
+      n.material.forEach((i, s) => {
+        i.uuid = `${t}.material.${s}`;
+      });
+    else {
+      const i = n.material;
+      i.uuid = `${t}.material`;
+    }
+  }
+  e.children.forEach((n) => $(n));
+};
+class V {
+  static renderer;
+  static canvas;
+  static context = null;
+  static scene = null;
+  static camera = null;
+  static material = null;
+  static inited = !1;
+  static width = 100;
+  static height = 100;
+  static init() {
+    this.inited || (this.canvas = document.createElement("canvas"), this.canvas.width = this.width, this.canvas.height = this.height, this.context = this.canvas.getContext("2d"), this.inited = !0);
+  }
+  static renderToBlob(t) {
+    this.init();
+    const n = t.repeat.clone(), i = t.offset.clone();
+    if (t.repeat.set(1, 1), t.offset.set(0, 0), this.context !== null) {
+      this.context.clearRect(0, 0, this.width, this.height);
+      const s = t.image;
+      if (s != null && s.width > 0) {
+        this.canvas.title = t.sourceFile;
+        const r = this.canvas.width / s.width, a = this.renderToCanvas(t);
+        this.context.drawImage(a, 0, 0, s.width * r, s.height * r);
+      }
+    }
+    return t.repeat.copy(n), t.offset.copy(i), this.canvas.toDataURL("image/png");
+  }
+  static renderToCanvas(t) {
+    if (this.material === null) {
+      this.camera = new y(-0.5, 0.5, 0.5, -0.5, 0, 100), this.scene = new T(), this.material = new O();
+      const n = new M();
+      n.setAttribute("position", new l([-0.5, -0.5, 0, 1.5, -0.5, 0, -0.5, 1.5, 0], 3)), n.setAttribute("normal", new l([0, 0, 1, 0, 0, 1], 3)), n.setAttribute("uv", new l([0, 0, 2, 0, 0, 2], 2));
+      const i = new B(n, this.material);
+      this.scene.add(i);
+    }
+    if (t.isRenderTargetTexture)
+      this.material.map = t, this.renderer.render(this.scene, this.camera);
+    else {
+      const n = this.renderer.outputColorSpace, i = t.colorSpace;
+      this.renderer.outputColorSpace = m, t.colorSpace = m, this.material.map = t, this.renderer.render(this.scene, this.camera), this.renderer.outputColorSpace = n, t.colorSpace = i;
+    }
+    return this.renderer.domElement;
+  }
+}
+function H(e) {
+  return new Promise((t) => {
+    const n = new R();
+    n.parseAsync(e.scene).then((i) => {
+      const s = new D(i);
+      if (e.animations.length > 0) {
+        const a = e.animations.map((E) => W.parse(E));
+        s.clipAction(a[0]).play(), s.getRoot().animations = e.animations, s.getRoot().mixer = s;
+      }
+      const r = [];
+      e.cameras && e.cameras.length > 0 && e.cameras.forEach((a) => {
+        const p = n.parse(a);
+        r.push(p);
+      }), t({
+        animations: e.animations,
+        model: i,
+        mixer: s,
+        cameras: r
+      });
+    });
+  });
+}
+const K = (e, t, n, i) => {
+  e.setRenderTarget(i), e.clear(), e.render(t, n);
+};
+function G(e, t, n, i) {
+  e.applyMatrix4(new Z().makeTranslation(t, -n, -i));
+}
+function _(e) {
+  e.computeBoundingBox();
+  const t = e.boundingBox, n = (t.max.x - t.min.x) / 2, i = (t.max.y - t.min.y) / 2;
+  G(e, n, i, 0);
+}
+function z(e, t, n) {
+  e.left = t / -2, e.right = t / 2, e.top = n / 2, e.bottom = n / -2, e.position.x = t / 2, e.position.y = n / -2, e.updateProjectionMatrix();
+}
+function J(e, t, n) {
+  const i = 1.7777777777777777, s = t / n;
+  let r = t, a = n;
+  s > i ? r = n * i : a = t / i, e.left = r / -2, e.right = r / 2, e.top = a / 2, e.bottom = a / -2, e.updateProjectionMatrix();
+}
+function Q() {
+  let t = "transferControlToOffscreen" in document.createElement("canvas");
+  if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+    const i = navigator.userAgent.match(/version\/(\d+)/i);
+    t = (i ? parseInt(i[1]) : 0) >= 17;
+  }
+  return t;
+}
+function X(e, t, n = !0, i = !1) {
+  e.renderOrder = -t;
+  const s = e.material;
+  Array.isArray(s) ? s.forEach((r) => {
+    r.colorWrite = n, r.depthWrite = i, r.stencilWrite = !0, r.stencilRef = t, r.stencilFunc = v, r.stencilFail = o, r.stencilZFail = o, r.stencilZPass = o;
+  }) : (s.colorWrite = n, s.depthWrite = i, s.stencilWrite = !0, s.stencilRef = t, s.stencilFunc = v, s.stencilFail = o, s.stencilZFail = o, s.stencilZPass = o);
+}
+function Y(e, t, n = !1) {
+  const i = e.material;
+  Array.isArray(i) ? i.forEach((s) => {
+    s.stencilWrite = !0, s.stencilRef = t, s.stencilFunc = n ? A : w, s.stencilFail = c, s.stencilZFail = c, s.stencilZPass = c;
+  }) : (i.stencilWrite = !0, i.stencilRef = t, i.stencilFunc = n ? A : w, i.stencilFail = c, i.stencilZFail = c, i.stencilZPass = c);
+}
+function j(e) {
+  e.blending = q, e.blendEquation = u, e.blendSrc = F, e.blendDst = b, e.needsUpdate = !0;
+}
+function ee(e) {
+  e.blending = f, e.blendEquation = u, e.blendSrc = F, e.blendDst = x, e.needsUpdate = !0;
+}
+function te(e) {
+  e.blending = f, e.blendEquation = u, e.blendSrc = P, e.blendDst = b, e.needsUpdate = !0;
+}
+function ne(e) {
+  e.blending = f, e.blendEquation = u, e.blendSrc = U, e.blendDst = x, e.needsUpdate = !0;
+}
+export {
+  V as ExportTexture,
+  G as anchorGeometry,
+  _ as anchorGeometryTL,
+  X as createMask,
+  L as dispose,
+  C as disposeMaterial,
+  S as disposeTexture,
+  $ as hierarchyUUID,
+  I as orthoCamera,
+  H as parseModelLite,
+  K as renderToTexture,
+  N as resetThreeObjects,
+  ee as setMaterialBlendAdd,
+  te as setMaterialBlendMultiply,
+  j as setMaterialBlendNormal,
+  ne as setMaterialBlendScreen,
+  Q as supportsOffscreenCanvas,
+  d as totalThreeObjects,
+  h as triangle,
+  z as updateCameraOrtho,
+  J as updateCameraOrtho16x9,
+  Y as useMask
+};

package/dist/webworkers/EventHandling.js

@@ -0,0 +1,115 @@
+const s = a([
+  "ctrlKey",
+  "metaKey",
+  "shiftKey",
+  "button",
+  "pointerId",
+  "pointerType",
+  "clientX",
+  "clientY",
+  "pageX",
+  "pageY"
+]), l = a([
+  "clientX",
+  "clientY",
+  "deltaX",
+  "deltaY",
+  "deltaMode"
+]), h = a([
+  "ctrlKey",
+  "metaKey",
+  "shiftKey",
+  "keyCode"
+]);
+function y(e, n) {
+  e.preventDefault(), l(e, n);
+}
+function f(e) {
+  e.preventDefault();
+}
+function m(e, n, t) {
+  for (const r of n)
+    t[r] = e[r];
+}
+function a(e) {
+  return function(t, r) {
+    const o = { type: t.type };
+    m(t, e, o), r(o);
+  };
+}
+function c(e, n) {
+  const t = [], r = { type: e.type, touches: t };
+  for (let o = 0; o < e.touches.length; ++o) {
+    const i = e.touches[o];
+    t.push({
+      pageX: i.pageX,
+      pageY: i.pageY
+    });
+  }
+  n(r);
+}
+const w = {
+  37: !0,
+  // left
+  38: !0,
+  // up
+  39: !0,
+  // right
+  40: !0
+  // down
+};
+function v(e, n) {
+  const { keyCode: t } = e;
+  w[t] && (e.preventDefault(), h(e, n));
+}
+const E = {
+  contextmenu: f,
+  mousedown: s,
+  mousemove: s,
+  mouseup: s,
+  pointerdown: s,
+  pointermove: s,
+  pointerup: s,
+  touchstart: c,
+  touchmove: c,
+  touchend: c,
+  wheel: y,
+  keydown: v
+};
+let g = 0;
+class H {
+  id;
+  worker;
+  constructor(n, t, r) {
+    this.id = g++, this.worker = t;
+    const o = (d) => {
+      this.worker.postMessage({
+        type: "event",
+        id: this.id,
+        data: d
+      });
+    };
+    t.postMessage({
+      type: "makeProxy",
+      id: this.id
+    });
+    for (const [d, p] of Object.entries(r))
+      n.addEventListener(d, (u) => {
+        p(u, o);
+      });
+    function i() {
+      o({
+        type: "resize",
+        left: 0,
+        top: 0,
+        width: innerWidth,
+        height: innerHeight
+      });
+    }
+    window.addEventListener("resize", i), i();
+  }
+}
+export {
+  H as ElementProxy,
+  E as WebworkerEventHandlers
+};

package/dist/webworkers/ProxyManager.js

@@ -0,0 +1,76 @@
+import { EventDispatcher as r } from "three";
+import { noop as e } from "../core/types.js";
+class n extends r {
+  style = {};
+  left = 0;
+  top = 0;
+  width = 0;
+  height = 0;
+  ownerDocument = void 0;
+  constructor() {
+    super(), this.ownerDocument = this;
+  }
+  get clientWidth() {
+    return this.width;
+  }
+  set clientWidth(t) {
+    this.width = t;
+  }
+  get clientHeight() {
+    return this.height;
+  }
+  set clientHeight(t) {
+    this.height = t;
+  }
+  // OrbitControls call these as of r132. Implementing as no-ops
+  setPointerCapture() {
+  }
+  releasePointerCapture() {
+  }
+  getBoundingClientRect() {
+    return {
+      x: this.left,
+      y: this.top,
+      left: this.left,
+      top: this.top,
+      width: this.width,
+      height: this.height,
+      right: this.left + this.width,
+      bottom: this.top + this.height,
+      toJSON: () => ({})
+      // Satisfies the DOMRect interface
+    };
+  }
+  handleEvent(t) {
+    if (t.type === "size") {
+      this.left = t.left, this.top = t.top, this.width = t.width, this.height = t.height;
+      return;
+    }
+    t.preventDefault = e, t.stopPropagation = e, this.dispatchEvent(t);
+  }
+  focus() {
+  }
+  getRootNode() {
+    return this;
+  }
+}
+class l {
+  targets = {};
+  constructor() {
+    this.handleEvent = this.handleEvent.bind(this);
+  }
+  makeProxy(t) {
+    const { id: h } = t, s = new n();
+    this.targets[h] = s;
+  }
+  getProxy(t) {
+    return this.targets[t];
+  }
+  handleEvent(t) {
+    this.targets[t.id]?.handleEvent(t.data);
+  }
+}
+export {
+  n as ElementProxyReceiver,
+  l as ProxyManager
+};