abstract-3d 0.1.2

package/src/renderers/dxf/dxf-encoding.ts

@@ -0,0 +1,348 @@
+import { Vec3 } from "../../abstract-3d";
+
+export const dxf3DFACE = (vec1: Vec3, vec2: Vec3, vec3: Vec3, vec4: Vec3, color: string | undefined): string =>
+  `  0
+3DFACE
+  8
+A3D
+  6
+CONTINUOUS
+  62
+${color ?? "1"}
+  10
+${vec1.x}
+  20
+${vec1.y}
+  30
+${vec1.z}
+  11
+${vec2.x}
+  21
+${vec2.y}
+  31
+${vec2.z}
+  12
+${vec3.x}
+  22
+${vec3.y}
+  32
+${vec3.z}
+  13
+${vec4.x}
+  23
+${vec4.y}
+  33
+${vec4.z}
+`;
+
+export const dxfPOLYLINE = (vertices: ReadonlyArray<Vec3>, color: string): string =>
+  `  0
+POLYLINE
+  8
+A3D
+  62
+${color}
+  66
+1${vertices.map(
+    (v) =>
+      `
+  0
+VERTEX
+  8
+A3D
+  10
+${v.x}
+  20
+${v.y}
+  30
+${v.z}`
+  )}
+  0
+SEQEND
+`;
+
+export const dxfText = (pos: Vec3, fontSize: number, text: string, color: string): string =>
+  `  0
+Text
+  8
+A3D
+  62
+${color}
+  10
+${pos.x}
+  20
+${pos.y}
+  30
+${pos.z}
+  11
+${pos.x}
+  21
+${pos.y}
+  31
+${pos.z}
+  40
+${fontSize}
+  1
+${text}
+`;
+
+export const dxfHeader = (size: Vec3, center: Vec3): string =>
+  `  999
+Divid A3D
+  0
+SECTION
+  2
+HEADER
+  9
+$ACADVER
+  1
+AC1006
+  9
+$INSBASE
+  10
+0.0
+  20
+0.0
+  30
+0.0
+ 9
+$EXTMIN
+ 10
+${0}
+ 20
+${0}
+ 30
+${0}
+  9
+$EXTMAX
+ 10
+${size.x}
+ 20
+ ${size.y}
+ 30
+ ${size.z}
+ 0
+ENDSEC
+  0
+SECTION
+  2
+TABLES
+  0
+TABLE
+  2
+APPID
+ 70
+2
+  0
+APPID
+  2
+ACAD
+ 70
+1
+  0
+APPID
+  2
+A3D
+ 70
+1
+  0
+ENDTAB
+  0
+TABLE
+  2
+LTYPE
+ 70
+1
+  0
+LTYPE
+  2
+CONTINUOUS
+ 70
+0
+  3
+Solid line
+ 72
+65
+ 73
+0
+ 40
+0.0
+  0
+ENDTAB
+  0
+TABLE
+  2
+LAYER
+ 70
+3
+  0
+LAYER
+  2
+0
+ 70
+0
+ 62
+7
+  6
+CONTINUOUS
+  0
+LAYER
+  2
+A3D
+ 70
+0
+ 62
+230
+  6
+CONTINUOUS
+  0
+LAYER
+  2
+A3D
+ 70
+0
+ 62
+7
+  6
+CONTINUOUS
+  0
+ENDTAB
+  0
+TABLE
+  2
+STYLE
+ 70
+0
+  0
+ENDTAB
+ 0
+TABLE
+  2
+VPORT
+  70
+1
+ 0
+VPORT
+ 2
+*ACTIVE
+ 70
+0
+ 10
+0.0
+ 20
+0.0
+ 11
+1.0
+ 21
+1.0
+ 12
+${-size.x / 2}
+ 22     
+${0}
+ 13
+0.0
+ 23
+0.0
+ 14
+1.0
+ 24
+1.0
+ 15
+0.0
+ 25
+0.0
+ 16
+0
+ 26
+0
+ 36
+1
+ 17     
+${center.x}
+ 27     
+${center.y}
+ 37    
+0
+ 40
+${size.y}
+ 41
+${size.x / size.y}
+ 42
+50.0
+ 43
+0.0
+ 44
+0.0
+ 50
+0.0
+ 51
+0.0
+ 71
+0
+ 72
+0
+ 73
+0
+ 74
+0
+ 75
+0
+ 76
+0
+ 77
+0
+ 78
+0
+  0
+ENDTAB
+  0
+ENDSEC
+  0
+SECTION
+  2
+BLOCKS
+  0
+BLOCK
+  8
+A3D
+  2
+A3D_Group
+  70
+64
+  10
+0.0
+  20
+0.0
+  30
+0.0
+  3
+A3D_Group
+`;
+
+export const dxfFooter = `  0
+ENDBLK
+  0
+ENDSEC
+  0
+SECTION
+  2
+ENTITIES
+  0
+INSERT
+  8
+A3D
+  6
+CONTINUOUS
+ 10
+0.0
+ 20
+0.0
+ 30
+0.0
+  2
+A3D_Group
+  0
+ENDSEC
+  0
+EOF
+`;

package/src/renderers/dxf/dxf-geometries/dxf-box.ts

@@ -0,0 +1,27 @@
+import * as A3D from "../../../abstract-3d";
+import { dxf3DFACE } from "../dxf-encoding";
+
+export function dxfBox(b: A3D.Box, m: A3D.Material, parentPos: A3D.Vec3, parentRot: A3D.Vec3): string {
+  const pos = A3D.vec3TransRot(b.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, b.rot ?? A3D.vec3Zero);
+  const half = A3D.vec3Scale(b.size, 0.5);
+  const vec3tr3 = (x: number, y: number, z: number): A3D.Vec3 => A3D.vec3TransRot(A3D.vec3(x, y, z), pos, rot);
+
+  const v1 = vec3tr3(-half.x, -half.y, half.z);
+  const v2 = vec3tr3(half.x, -half.y, half.z);
+  const v3 = vec3tr3(half.x, half.y, half.z);
+  const v4 = vec3tr3(-half.x, half.y, half.z);
+  const v5 = vec3tr3(-half.x, -half.y, -half.z);
+  const v6 = vec3tr3(half.x, -half.y, -half.z);
+  const v7 = vec3tr3(half.x, half.y, -half.z);
+  const v8 = vec3tr3(-half.x, half.y, -half.z);
+
+  return (
+    dxf3DFACE(v1, v2, v3, v4, m.dxf) + // front
+    dxf3DFACE(v5, v6, v7, v8, m.dxf) + // Back
+    dxf3DFACE(v5, v1, v4, v8, m.dxf) + // Left
+    dxf3DFACE(v6, v2, v3, v7, m.dxf) + // Right
+    dxf3DFACE(v8, v7, v3, v4, m.dxf) + // Top
+    dxf3DFACE(v5, v6, v2, v1, m.dxf) // Bottom
+  );
+}

package/src/renderers/dxf/dxf-geometries/dxf-cone.ts

@@ -0,0 +1,31 @@
+import * as A3D from "../../../abstract-3d";
+import { dxf3DFACE } from "../dxf-encoding";
+
+export function dxfCone(c: A3D.Cone, m: A3D.Material, sides: number, parentPos: A3D.Vec3, parentRot: A3D.Vec3): string {
+  let dxfString = "";
+  const pos = A3D.vec3TransRot(c.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, c.rot ?? A3D.vec3Zero);
+  const vec3tr2 = (x: number, y: number, z: number): A3D.Vec3 => A3D.vec3TransRot(A3D.vec3(x, y, z), pos, rot);
+
+  const angleStep = (2 * Math.PI) / sides;
+  let currentAngle = 0;
+
+  const half = c.length / 2;
+  const botPos = vec3tr2(0, -half, 0);
+  const topPos = vec3tr2(0, half, 0);
+
+  const botVec3Array = Array<A3D.Vec3>();
+  for (let i = 0; i <= sides; i++) {
+    const currBot = vec3tr2(Math.sin(currentAngle) * c.radius, -half, Math.cos(currentAngle) * c.radius);
+    botVec3Array.push(currBot);
+
+    if (i !== 0) {
+      const prevBot = botVec3Array[i - 1]!;
+      dxfString +=
+        dxf3DFACE(botPos, prevBot, currBot, currBot, m.dxf) + dxf3DFACE(currBot, prevBot, topPos, topPos, m.dxf);
+    }
+    currentAngle += angleStep;
+  }
+
+  return dxfString;
+}

package/src/renderers/dxf/dxf-geometries/dxf-cylinder.ts

@@ -0,0 +1,45 @@
+import * as A3D from "../../../abstract-3d";
+import { dxf3DFACE } from "../dxf-encoding";
+
+export function dxfCylinder(
+  c: A3D.Cylinder,
+  m: A3D.Material,
+  sides: number,
+  parentPos: A3D.Vec3,
+  parentRot: A3D.Vec3
+): string {
+  let dxfString = "";
+  const pos = A3D.vec3TransRot(c.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, c.rot ?? A3D.vec3Zero);
+  const vec3tr = (x: number, y: number, z: number): A3D.Vec3 => A3D.vec3TransRot(A3D.vec3(x, y, z), pos, rot);
+
+  const angleStep = (2 * Math.PI) / sides;
+  let currentAngle = 0;
+
+  const half = c.length / 2;
+  const topPos = vec3tr(0, half, 0);
+  const botPos = vec3tr(0, -half, 0);
+
+  const botVec3Array = Array<A3D.Vec3>();
+  const topVec3Array = Array<A3D.Vec3>();
+
+  for (let i = 0; i <= sides; i++) {
+    const x = Math.sin(currentAngle) * c.radius;
+    const z = Math.cos(currentAngle) * c.radius;
+    const currBot = vec3tr(x, -half, z);
+    const currTop = vec3tr(x, half, z);
+    botVec3Array.push(currBot);
+    topVec3Array.push(currTop);
+    if (i !== 0) {
+      const prevBot = botVec3Array[i - 1]!;
+      const prevTop = topVec3Array[i - 1]!;
+      dxfString +=
+        dxf3DFACE(botPos, prevBot, currBot, currBot, m.dxf) +
+        dxf3DFACE(topPos, prevTop, currTop, currTop, m.dxf) +
+        dxf3DFACE(currBot, prevBot, prevTop, currTop, m.dxf);
+    }
+    currentAngle += angleStep;
+  }
+
+  return dxfString;
+}

package/src/renderers/dxf/dxf-geometries/dxf-plane.ts

@@ -0,0 +1,16 @@
+import * as A3D from "../../../abstract-3d";
+import { dxf3DFACE } from "../dxf-encoding";
+
+export function dxfPlane(p: A3D.Plane, m: A3D.Material, parentPos: A3D.Vec3, parentRot: A3D.Vec3): string {
+  const half = A3D.vec2Scale(p.size, 0.5);
+  const pos = A3D.vec3TransRot(p.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, p.rot ?? A3D.vec3Zero);
+  const vec3tr = (x: number, y: number): A3D.Vec3 => A3D.vec3TransRot(A3D.vec3(x, y, 0), pos, rot);
+  return dxf3DFACE(
+    vec3tr(-half.x, -half.y),
+    vec3tr(half.x, -half.y),
+    vec3tr(half.x, half.y),
+    vec3tr(-half.x, half.y),
+    m.dxf
+  );
+}

package/src/renderers/dxf/dxf-geometries/dxf-polygon.ts

@@ -0,0 +1,36 @@
+import * as A3D from "../../../abstract-3d";
+import { dxf3DFACE } from "../dxf-encoding";
+
+const chunkSize = 4;
+
+export function dxfPolygon(p: A3D.Polygon, m: A3D.Material, parentPos: A3D.Vec3, parentRot: A3D.Vec3): string {
+  let polygonString = "";
+  const pos = A3D.vec3TransRot(p.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, p.rot ?? A3D.vec3Zero);
+  const points = p.points.map((p) => A3D.vec3TransRot(p, pos, rot));
+  let i = 0;
+  if (points.length >= chunkSize) {
+    for (i; i < points.length; i += chunkSize) {
+      polygonString += dxf3DFACE(points[i]!, points[i + 1]!, points[i + 2]!, points[i + 3]!, m.dxf);
+    }
+  }
+
+  if (i <= points.length && chunkSize - 1 <= points.length) {
+    const lastArrayLength = points.length - i;
+    switch (lastArrayLength) {
+      case 1:
+        polygonString += dxf3DFACE(points[i - 2]!, points[i - 1]!, points[i]!, points[i]!, m.dxf);
+        break;
+      case 2:
+        polygonString += dxf3DFACE(points[i - 1]!, points[i]!, points[i + 1]!, points[i + 1]!, m.dxf);
+        break;
+      case 3:
+        polygonString += dxf3DFACE(points[i]!, points[i + 1]!, points[i + 2]!, points[i + 2]!, m.dxf);
+        break;
+      default:
+        break;
+    }
+  }
+
+  return polygonString;
+}

package/src/renderers/dxf/dxf-geometries/dxf-shape.ts

@@ -0,0 +1,36 @@
+import * as A3D from "../../../abstract-3d";
+import { dxf3DFACE } from "../dxf-encoding";
+
+const chunkSize = 4;
+
+export function dxfPolygon(s: A3D.Shape, m: A3D.Material, parentPos: A3D.Vec3, parentRot: A3D.Vec3): string {
+  let polygonString = "";
+  const pos = A3D.vec3TransRot(s.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, s.rot ?? A3D.vec3Zero);
+  const points = s.points.map((p) => A3D.vec3TransRot(A3D.vec3(p.x, p.y, 0), pos, rot));
+  let i = 0;
+  if (points.length >= chunkSize) {
+    for (i; i < points.length; i += chunkSize) {
+      polygonString += dxf3DFACE(points[i]!, points[i + 1]!, points[i + 2]!, points[i + 3]!, m.dxf);
+    }
+  }
+
+  if (i <= points.length && chunkSize - 1 <= points.length) {
+    const lastArrayLength = points.length - i;
+    switch (lastArrayLength) {
+      case 1:
+        polygonString += dxf3DFACE(points[i - 2]!, points[i - 1]!, points[i]!, points[i]!, m.dxf);
+        break;
+      case 2:
+        polygonString += dxf3DFACE(points[i - 1]!, points[i]!, points[i + 1]!, points[i + 1]!, m.dxf);
+        break;
+      case 3:
+        polygonString += dxf3DFACE(points[i]!, points[i + 1]!, points[i + 2]!, points[i + 2]!, m.dxf);
+        break;
+      default:
+        break;
+    }
+  }
+
+  return polygonString;
+}

package/src/renderers/dxf/dxf.ts

@@ -0,0 +1,38 @@
+import * as A3D from "../../abstract-3d";
+import { dxfFooter, dxfHeader } from "./dxf-encoding";
+import { dxfPlane } from "./dxf-geometries/dxf-plane";
+import { dxfBox } from "./dxf-geometries/dxf-box";
+import { dxfCylinder } from "./dxf-geometries/dxf-cylinder";
+import { dxfCone } from "./dxf-geometries/dxf-cone";
+import { dxfPolygon } from "./dxf-geometries/dxf-polygon";
+import { dimBoundZero, rotationForCameraPos, sizeCenterForCameraPos } from "../shared";
+
+export const toDxf = (scene: A3D.Scene, view: A3D.View): string => {
+  const unitRot = A3D.vec3RotCombine(rotationForCameraPos(view), scene.rotation ?? A3D.vec3Zero);
+  const rotatedCenter = A3D.vec3Rot(scene.center, A3D.vec3Zero, scene.rotation ?? A3D.vec3Zero);
+  const [size, center] = sizeCenterForCameraPos(scene.size, rotatedCenter, dimBoundZero, A3D.vec3Zero, view, 1);
+  return dxfHeader(size, center) + scene.groups.reduce((a, c) => a + dxfGroup(c, center, unitRot), "") + dxfFooter;
+};
+
+function dxfGroup(g: A3D.Group, parentPos: A3D.Vec3, parentRot: A3D.Vec3): string {
+  const pos = A3D.vec3TransRot(g.pos, parentPos, parentRot);
+  const rot = A3D.vec3RotCombine(parentRot, g.rot ?? A3D.vec3Zero);
+  return (
+    (g.meshes?.reduce((a, c) => {
+      switch (c.geometry.type) {
+        case "Plane":
+          return a + dxfPlane(c.geometry, c.material, pos, rot);
+        case "Box":
+          return a + dxfBox(c.geometry, c.material, pos, rot);
+        case "Cylinder":
+          return a + dxfCylinder(c.geometry, c.material, 18, pos, rot);
+        case "Cone":
+          return a + dxfCone(c.geometry, c.material, 18, pos, rot);
+        case "Polygon":
+          return a + dxfPolygon(c.geometry, c.material, pos, rot);
+        default:
+          return a;
+      }
+    }, "") ?? "") + g.groups?.reduce((a, c) => a + dxfGroup(c, pos, rot), "") ?? ""
+  );
+}

package/src/renderers/dxf/index.ts

@@ -0,0 +1 @@
+export * from "./dxf";

package/src/renderers/index.ts

@@ -0,0 +1,4 @@
+export * from "./dxf";
+export * from "./svg";
+export * from "./stl";
+export * from "./react";

package/src/renderers/react/index.ts

@@ -0,0 +1,5 @@
+export * from "./react";
+export type { HotSpotInfo } from "./react-hotspot";
+export type { CameraType, Camera, ControlsHelper } from "./react-camera";
+export type { MaterialState } from "./react-material";
+export { ERROR_IMG_KEY } from "./react-material";