abstract-3d 4.1.1 → 4.1.2

package/src/renderers/svg-bsp/svg-geometries/svg-shape.ts

@@ -0,0 +1,34 @@
+import type { Vec3, Vec2, Shape, Material } from "../../../abstract-3d.js";
+import { vec3ZMean, vec3TransRot, vec3RotCombine, vec3, vec3Zero } from "../../../abstract-3d.js";
+import { rgbGrayScale } from "../../../utils.js";
+import { svgPolygon } from "../svg-encoding.js";
+import type { zOrderElement, SvgOptions } from "./shared.js";
+import { gray, isOpaque, zElem, transparent } from "./shared.js";
+
+export function shape(
+  s: Shape,
+  point: (x: number, y: number) => Vec2,
+  material: Material,
+  opts: SvgOptions,
+  parentPos: Vec3,
+  parentRot: Vec3
+): ReadonlyArray<zOrderElement> {
+  const pos = vec3TransRot(s.pos, parentPos, parentRot);
+  const rot = vec3RotCombine(parentRot, s.rot ?? vec3Zero);
+  const rotatedPoints = s.points.map((p) => vec3TransRot(vec3(p.x, p.y, 0), pos, rot));
+  const points = rotatedPoints.map(({ x, y }) => point(x, y));
+  const color = material.normal;
+  const [strokeColor, fill] = opts.only_stroke
+    ? [opts.gray_scale ? gray : color, opts.background]
+    : [transparent, opts.gray_scale ? rgbGrayScale(color) : color];
+  const opacity = material.opacity ?? 1.0;
+  return [
+    zElem(
+      svgPolygon(rot, points, fill, opacity, strokeColor, 0),
+      vec3ZMean(...rotatedPoints),
+      rotatedPoints,
+      isOpaque(fill, opacity) && !s.holes?.length,
+      { fill, opacity, stroke: strokeColor, strokeWidth: 0 }
+    ),
+  ];
+}

package/src/renderers/svg-bsp/svg-geometries/svg-text.ts

@@ -0,0 +1,40 @@
+import type { Text, Vec2, Vec3 } from "../../../abstract-3d.js";
+import { vec3TransRot, vec3RotCombine, vec3Zero, vec3, vec3Dot, vec3Rot } from "../../../abstract-3d.js";
+import { svgText } from "../svg-encoding.js";
+import type { SvgOptions, zOrderElement } from "./shared.js";
+import { svgTrsMatrix, zElem } from "./shared.js";
+
+const SVG_FORWARD: Vec3 = vec3(0.0, 0.0, 1.0);
+const SVG_DOT_OPPOSITE_THRESHOLD: number = -0.9;
+
+// dummy
+export function text(
+  t: Text,
+  point: (x: number, y: number) => Vec2,
+  fill: string,
+  opts: SvgOptions,
+  parentPos: Vec3,
+  parentRot: Vec3
+): ReadonlyArray<zOrderElement> {
+  const pos = vec3TransRot(t.pos, parentPos, parentRot);
+  const rot = vec3RotCombine(parentRot, t.rot ?? vec3Zero);
+
+  const textForward = vec3Rot({ x: 0, y: 0, z: 1 }, vec3Zero, rot);
+
+  //discard texts that are pointing away
+  if (vec3Dot(textForward, SVG_FORWARD) <= SVG_DOT_OPPOSITE_THRESHOLD) {
+    return [];
+  }
+
+  const texts = Array<zOrderElement>();
+  const fontSize = t.fontSize;
+  const strings = t.text.split("\n");
+  let posY = strings.length === 1 ? 0 : (fontSize * strings.length - fontSize) / 2;
+  for (const s of strings) {
+    const matrix = svgTrsMatrix(point(pos.x, pos.y + posY), rot);
+    texts.push(zElem(svgText(s, matrix, fill, opts.font, fontSize), pos.z, [pos]));
+    posY -= fontSize * 1.2;
+  }
+
+  return texts;
+}

package/src/renderers/svg-bsp/svg.ts

@@ -0,0 +1,183 @@
+import { exhaustiveCheck } from "ts-exhaustive-check";
+import type { Scene, Vec3, Mesh, Vec2, Group, Material, Bounds2 } from "../../abstract-3d.js";
+import {
+  vec2,
+  vec3Rot,
+  vec3Zero,
+  vec3RotCombine,
+  vec3,
+  vec3TransRot,
+  rotationForCameraPos,
+  sizeBoundsForCameraPos,
+  bounds2FromPosAndSize,
+  bounds2ToSize,
+  bounds2Merge,
+  vec2Zero,
+  vec3Flip,
+  dimensionConvertToTypeMesh,
+} from "../../abstract-3d.js";
+import type { Optional } from "../../utils.js";
+import { calculateVisibleViews, isViewVisible } from "../../utils.js";
+import { svg } from "./svg-encoding.js";
+import type { SvgOptions, zOrderElement } from "./svg-geometries/shared.js";
+import { box } from "./svg-geometries/svg-box.js";
+import { cone } from "./svg-geometries/svg-cone.js";
+import { cylinder } from "./svg-geometries/svg-cylinder.js";
+import { image } from "./svg-geometries/svg-image.js";
+import { line } from "./svg-geometries/svg-line.js";
+import { plane } from "./svg-geometries/svg-plane.js";
+import { polygon } from "./svg-geometries/svg-polygon.js";
+import { shape } from "./svg-geometries/svg-shape.js";
+import { text } from "./svg-geometries/svg-text.js";
+import { orderElements } from "./svg-order.js";
+
+export type SvgScene = {
+  readonly scene: Scene;
+  readonly options?: Optional<SvgOptions>;
+  readonly pos: Vec2;
+};
+
+export type SvgWithSize = { readonly image: string; readonly width: number; readonly height: number };
+
+export function renderScenes(scenes: ReadonlyArray<SvgScene>, baseOptions?: Optional<SvgOptions>): SvgWithSize {
+  const allElements = Array<zOrderElement>();
+  const bounds = Array<Bounds2>();
+
+  for (const view of scenes) {
+    const { elements, size, center } = renderInternal(view.scene, { ...baseOptions, ...view.options }, view.pos);
+    allElements.push(...elements);
+    const newBounds = bounds2FromPosAndSize(center, size);
+    bounds.push(newBounds);
+  }
+  const mergedBounds = bounds2Merge(...bounds);
+  const size = bounds2ToSize(mergedBounds);
+  const image = svg(
+    mergedBounds.min,
+    size,
+    allElements.reduce((a, { element }) => `${a} ${element}`, ""),
+    baseOptions?.className ?? ""
+  );
+  return { image, width: size.x, height: size.y };
+}
+
+export function render(scene: Scene, options?: Optional<SvgOptions>): SvgWithSize {
+  const { elements, size, center } = renderInternal(scene, options, vec2Zero);
+
+  const image = svg(
+    vec2(center.x - size.x / 2, center.y - size.y / 2),
+    size,
+    elements.reduce((a, { element }) => `${a} ${element}`, ""),
+    options?.className ?? ""
+  );
+  return { image, width: size.x, height: size.y };
+}
+
+function renderInternal(
+  scene: Scene,
+  options: Optional<SvgOptions> | undefined,
+  offset: Vec2
+): {
+  readonly elements: ReadonlyArray<zOrderElement>;
+  readonly size: Vec2;
+  readonly center: Vec2;
+} {
+  const opts: SvgOptions = {
+    view: options?.view ?? "front",
+    stroke_thickness: options?.stroke_thickness ?? 2,
+    only_stroke: options?.only_stroke ?? false,
+    gray_scale: options?.gray_scale ?? false,
+    background: options?.background ?? "rgba(255,255,255,0)",
+    font: options?.font ?? "",
+    imageDataByUrl: options?.imageDataByUrl ?? {},
+    rotation: options?.rotation ?? 0,
+    imageBg: options?.imageBg ?? false,
+    className: options?.className ?? "",
+  };
+  // A three-quarter view: the front turned 30° to show the side, and tilted 20° to show the top, the front foremost
+  const angled = opts.view === "TopLeft" || opts.view === "TopRight";
+  const view = angled ? "front" : opts.view;
+  const angledRot = angled
+    ? vec3RotCombine(vec3((20 * Math.PI) / 180, 0, 0), vec3(0, ((opts.view === "TopRight" ? -1 : 1) * 30 * Math.PI) / 180, 0))
+    : vec3Zero;
+  const cameraRot = vec3RotCombine(angledRot, rotationForCameraPos(view));
+  const viewRot = opts.rotation ? vec3RotCombine(vec3(0, 0, (opts.rotation * Math.PI) / 180), cameraRot) : cameraRot;
+  const unitRot = vec3RotCombine(viewRot, scene.rotation_deprecated ?? vec3Zero);
+
+  const unitCenter = vec3Rot(scene.center_deprecated ?? vec3Zero, vec3Zero, cameraRot);
+  const [unitSize] = sizeBoundsForCameraPos(scene.size_deprecated, unitCenter, unitRot);
+  const svgSize = vec2(unitSize.x + 1.5 * opts.stroke_thickness, unitSize.y + 1.5 * opts.stroke_thickness);
+  const svgCenter = vec2(offset.x + opts.stroke_thickness * 0.75, offset.y + opts.stroke_thickness * 0.75);
+  const point = (x: number, y: number): Vec2 => vec2(svgCenter.x + x, svgCenter.y - y);
+  const unitCenterFlipped = vec3Flip(unitCenter);
+
+  const elements = [
+    ...orderElements(
+      scene.groups.flatMap((g) => svgGroup(g, unitCenterFlipped, unitRot, point, opts)),
+      point
+    ),
+  ];
+  const dimOpts: SvgOptions = { ...opts, only_stroke: false, gray_scale: false };
+  const visibleViews = calculateVisibleViews(view, scene.rotation_deprecated);
+
+  // Dimensions are drawn for the flat views
+  for (const dim of angled ? [] : (scene.dimensions_deprecated?.dimensions ?? [])) {
+    const d = dimensionConvertToTypeMesh(dim, scene.rotation_deprecated ?? vec3Zero, scene.dimensions_deprecated?.material);
+    if (isViewVisible(d.views[0], visibleViews)) {
+      const pos = vec3TransRot(d.pos, unitCenterFlipped, unitRot);
+      const rot = vec3RotCombine(unitRot, d.rot);
+      for (const m of d.meshes) {
+        elements.push(...svgMesh(m, pos, rot, point, scene.dimensions_deprecated?.material ?? { normal: "" }, dimOpts));
+      }
+    }
+  }
+  return { elements, size: svgSize, center: svgCenter };
+}
+
+function svgGroup(g: Group, parentPos: Vec3, parentRot: Vec3, point: (x: number, y: number) => Vec2, opts: SvgOptions): ReadonlyArray<zOrderElement> {
+  const pos = vec3TransRot(g.pos, parentPos, parentRot);
+  const rot = vec3RotCombine(parentRot, g.rot ?? vec3Zero);
+  const elements = Array<zOrderElement>();
+  for (const m of g.meshes ?? []) {
+    elements.push(...svgMesh(m, pos, rot, point, m.material, opts));
+  }
+  for (const sg of g.groups ?? []) {
+    elements.push(...svgGroup(sg, pos, rot, point, opts));
+  }
+  return elements;
+}
+
+function svgMesh(
+  mesh: Mesh,
+  parentPos: Vec3,
+  parentRot: Vec3,
+  point: (x: number, y: number) => Vec2,
+  material: Material,
+  opts: SvgOptions
+): ReadonlyArray<zOrderElement> {
+  switch (mesh.geometry.type) {
+    case "Box":
+      return box(mesh.geometry, point, material, opts, parentPos, parentRot);
+    case "Plane":
+      return plane(mesh.geometry, point, material, opts, parentPos, parentRot);
+    case "Cylinder":
+      return cylinder(mesh.geometry, point, material, opts, parentPos, parentRot);
+    case "Cone":
+      return cone(mesh.geometry, point, material, opts, parentPos, parentRot);
+    case "CulledLine":
+    case "Line":
+      return line(mesh.geometry, point, material.normal, opts, parentPos, parentRot);
+    case "Polygon":
+      return polygon(mesh.geometry, point, material, opts, parentPos, parentRot);
+    case "Shape":
+      return shape(mesh.geometry, point, material, opts, parentPos, parentRot);
+    case "Text":
+      return text(mesh.geometry, point, material.normal, opts, parentPos, parentRot);
+    case "Image":
+      return image(mesh.geometry, point, opts, parentPos, parentRot);
+    case "Tube":
+    case "Sphere":
+      return [];
+    default:
+      return exhaustiveCheck(mesh.geometry);
+  }
+}