abstract-3d 1.6.4 → 1.6.6

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

@@ -9,8 +9,7 @@ import {
   vec3Scale,
   equals,
 } from "../../../abstract-3d.js";
-import { color } from "../color.js";
-import { dxf3DFACE, Handle } from "../dxf-encoding.js";
+import { dxfQuad, dxfTriangle, Handle } from "../dxf-encoding.js";
 import { dxfPlane } from "./dxf-plane.js";
 
 export function dxfCylinder(
@@ -21,41 +20,39 @@ export function dxfCylinder(
   parentRot: Vec3,
   handleRef: Handle
 ): string {
-  const angleStart = c.angleStart ?? 0.0;
-  const angleLength = c.angleLength ?? Math.PI * 2;
-  const angleEnd = angleStart + angleLength;
-  let dxfString = "";
   const pos = vec3TransRot(c.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, c.rot ?? vec3Zero);
   const vec3tr = (x: number, y: number, z: number): Vec3 => vec3TransRot(vec3(x, y, z), pos, rot);
-  const mat = m.normal;
+
+  const angleStart = c.angleStart ?? 0.0;
+  const angleLength = c.angleLength ?? Math.PI * 2;
+  const angleEnd = angleStart + angleLength;
   const angleStep = angleLength / sides;
   let currentAngle = angleStart;
+  let dxfString = "";
 
   const half = c.length / 2;
   const topPos = vec3tr(0, half, 0);
   const botPos = vec3tr(0, -half, 0);
 
-  const botVec3Array = Array<Vec3>();
-  const topVec3Array = Array<Vec3>();
-
+  let prevBot = undefined;
+  let prevTop = undefined;
   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]!;
+    if (i !== 0 && prevBot && prevTop) {
       if (!c.open) {
         dxfString +=
-          dxf3DFACE(botPos, prevBot, currBot, currBot, mat, handleRef) +
-          dxf3DFACE(topPos, prevTop, currTop, currTop, mat, handleRef);
+          dxfTriangle(botPos, prevBot, currBot, m.normal, handleRef) +
+          dxfTriangle(topPos, prevTop, currTop, m.normal, handleRef);
       }
-      dxfString += dxf3DFACE(currBot, prevBot, prevTop, currTop, mat, handleRef);
+      dxfString += dxfQuad(currBot, prevBot, prevTop, currTop, m.normal, handleRef);
     }
+
+    prevBot = currBot;
+    prevTop = currTop;
     currentAngle += angleStep;
   }
 

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

@@ -9,22 +9,15 @@ import {
   vec3,
   vec3Rot,
   vec3Add,
-  vec3Sub,
-  vec3Normalize,
-  vec3Cross,
-  vec3Scale,
 } from "../../../abstract-3d.js";
-import { dxf3DFACE, dxfHandle, Handle } from "../dxf-encoding.js";
-import { dxfPlane } from "./dxf-plane.js";
+import { DEFAULT_CIRCLE_SIDE_COUNT, DxfDynamicColor, dxfLine, dxfPolyline, Handle } from "../dxf-encoding.js";
 
 export function dxfImage(i: Image, parentPos: Vec3, parentRot: Vec3, handleRef: Handle): string {
-
   const half = vec2Scale(i.size, 0.5);
   const offset = vec3Rot(vec3(-half.x, half.y, 0), vec3Zero, i.rot ?? vec3Zero);
   const pos = vec3TransRot(vec3Add(i.pos, offset), parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, i.rot ?? vec3Zero);
-
-  switch(i.image.type) {
+  switch (i.image.type) {
     case "AbstractImage": {
       const scale = {
         x: i.size.x / i.image.image.size.width,
@@ -33,72 +26,63 @@ export function dxfImage(i: Image, parentPos: Vec3, parentRot: Vec3, handleRef:
       };
       return abstractImageToDxf3D(i.image.image, pos, rot, scale, handleRef);
     }
-    default: 
+    default:
       return "";
   }
 }
 
 function abstractImageToDxf3D(image: AbstractImage, pos: Vec3, rot: Vec3, scale: Vec3, handleRef: Handle): string {
   const strokeScale = Math.max(scale.x, scale.y, scale.z);
-
-  let dxf = "";
-
-  //create the background and place it slightly below the stroke elements
-  // const normal = eulerToVector(rot);
-  // const bgSize = { x: image.size.width * scale.x, y: image.size.height * scale.y, z: 1 };
-  // const bgHalf = vec3Rot(vec3Scale(bgSize, 0.5), vec3Zero, rot);
-  // const bgPos = vec3Add(vec3Add(pos, bgHalf), vec3Scale(normal, -1));
-  // dxf += dxfPlane({
-  //   type: "Plane",
-  //   size: bgSize,
-  //   pos: bgPos,
-  //   rot,
-  // }, {normal: `normal(0, 0, 1)`}, vec3Zero, vec3Zero, handleRef);
-
-  for(const comp of image.components) {
-    dxf += abstractImageComponentToDxf3D(comp, pos, rot, scale, strokeScale, handleRef);    
-  }
-  return dxf;
+  return image.components.map(
+    (comp) =>
+      abstractImageComponentToDxf3D(comp, pos, rot, scale, strokeScale, handleRef)
+  ).join("");
 }
 
 function abstractImageComponentToDxf3D(comp: Component, pos: Vec3, rot: Vec3, scale: Vec3, strokeScale: number, handleRef: Handle): string {
   const vec3tr = (x: number, y: number): Vec3 => vec3TransRot(vec3(x * scale.x, y * scale.y, 0), pos, rot);
-  const strokeColor: Color = { a: 255.0, r: 0.0, g: 0.0, b: 0.0 };
+  const strokeColor: DxfDynamicColor = 7;
 
   let dxf = "";
-  switch(comp.type) {
+  switch (comp.type) {
     case "group": {
-      for(const child of comp.children) {
-        dxf += abstractImageComponentToDxf3D(child, pos, rot, scale, strokeScale, handleRef);
-      }
+      dxf += comp.children.map(
+        (child) =>
+          abstractImageComponentToDxf3D(child, pos, rot, scale, strokeScale, handleRef)
+      ).join("");
       break;
+
     }
     case "line": {
-      dxf += dxfLine(vec3tr(comp.start.x, comp.start.y), vec3tr(comp.end.x, comp.end.y), strokeColor, comp.strokeThickness * strokeScale, rot, handleRef);
+      dxf += dxfLine(
+        vec3tr(comp.start.x, comp.start.y),
+        vec3tr(comp.end.x, comp.end.y),
+        strokeColor,
+        handleRef
+      );
       break;
     }
     case "polyline": {
       const points = comp.points.map((p) => vec3tr(p.x, p.y));
-      dxf += dxfPolyline(points, strokeColor, false, comp.strokeThickness * strokeScale, rot, handleRef);
+      dxf += dxfPolyline(points, strokeColor, false, handleRef);
       break;
     }
     case "polygon": {
       const points = comp.points.map((p) => vec3tr(p.x, p.y));
-      dxf += dxfPolyline(points, strokeColor, true, comp.strokeThickness * strokeScale, rot, handleRef);
+      dxf += dxfPolyline(points, strokeColor, true, handleRef);
       break;
     }
     case "ellipse": {
       const points: Array<Vec3> = [];
       const r1 = Math.abs(comp.bottomRight.x - comp.topLeft.x) / 2.0;
       const r2 = Math.abs(comp.topLeft.y - comp.bottomRight.y) / 2.0;
-      const numPoints = 32;
-      for (let i = 0; i < numPoints; i++) {
-        const t = (2 * Math.PI * i) / numPoints;
+      for (let i = 0; i < DEFAULT_CIRCLE_SIDE_COUNT; i++) {
+        const t = (2 * Math.PI * i) / DEFAULT_CIRCLE_SIDE_COUNT;
         const x = comp.topLeft.x + r1 + r1 * Math.cos(t);
         const y = comp.topLeft.y + r2 + r2 * Math.sin(t);
         points.push(vec3tr(x, y));
       }
-      dxf += dxfPolyline(points, strokeColor, true, comp.strokeThickness * strokeScale, rot, handleRef);
+      dxf += dxfPolyline(points, strokeColor, true, handleRef);
       break;
     }
     case "rectangle": {
@@ -106,13 +90,13 @@ function abstractImageComponentToDxf3D(comp: Component, pos: Vec3, rot: Vec3, sc
         x: comp.bottomRight.x - comp.topLeft.x,
         y: comp.bottomRight.y - comp.topLeft.y
       };
-      const points = [
+      const points = [ //these points form a loop
         vec3tr(0, 0),
         vec3tr(size.x, 0),
         vec3tr(size.x, size.y),
         vec3tr(0, size.y),
       ];
-      dxf += dxfPolyline(points, strokeColor, true, comp.strokeThickness * strokeScale, rot, handleRef);
+      dxf += dxfPolyline(points, strokeColor, true, handleRef);
       break;
     }
     default:
@@ -120,58 +104,4 @@ function abstractImageComponentToDxf3D(comp: Component, pos: Vec3, rot: Vec3, sc
   }
 
   return dxf;
-}
-
-function dxfLine(vecStart: Vec3, vecEnd: Vec3, color: Color, strokeThickness: number, normal: Vec3, handleRef: Handle): string {
-  const norm = eulerToVector(normal);
-  strokeThickness = 0;
-
-  const dir = vec3Normalize(vec3Sub(vecEnd, vecStart));
-  const right = vec3Cross(dir, norm);
-  const s1 = vec3Add(vecStart, vec3Scale(right, strokeThickness / 2));
-  const s2 = vec3Add(vecStart, vec3Scale(right, -strokeThickness / 2));
-  const e1 = vec3Add(vecEnd, vec3Scale(right, strokeThickness / 2));
-  const e2 = vec3Add(vecEnd, vec3Scale(right, -strokeThickness / 2));
-  //return dxf3DFACE(s1, e1, e2, s2, abstractImageColorToHex(color), handleRef);
-  return dxf3DFACE(s1, e1, e2, s2, 7, handleRef);
-}
-
-function dxfPolyline(points: ReadonlyArray<Vec3>, color: Color, closed: boolean, strokeThickness: number, normal: Vec3, handleRef: Handle): string {
-  let dxf = "";
-  for(let i = 0; i < points.length - 1; i++) {
-    const p1 = points[i];
-    const p2 = points[i+1];
-    if(!p1 || !p2) {
-      continue;
-    }
-    dxf += dxfLine(p1, p2, color, strokeThickness, normal, handleRef);
-  }
-  if(closed) {
-    const start = points[0];
-    const end = points[points.length - 1];
-    if(start && end) {
-      dxf += dxfLine(start, end, color, strokeThickness, normal, handleRef);
-    }
-  }
-  return dxf;
-}
-
-function abstractImageColorToHex(color: Color): string {
-  const col = `rgb(${color.r}, ${color.g}, ${color.b})`;
-  return col;
-}
-
-function eulerToVector(euler: Vec3): Vec3 {
-  const cx = Math.cos(euler.x);
-  const sx = Math.sin(euler.x);
-  const cy = Math.cos(euler.y);
-  const sy = Math.sin(euler.y);
-  //const cz = Math.cos(euler.z); ?
-  //const sz = Math.sin(euler.z); ?
-  const norm = {
-    x: sy,
-    y: -sx * cy,
-    z: cx * cy
-  };
-  return norm;
 }

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

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

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

@@ -1,6 +1,5 @@
 import { Polygon, Material, Vec3, vec3TransRot, vec3RotCombine, vec3Zero } from "../../../abstract-3d.js";
-import { color } from "../color.js";
-import { dxf3DFACE, Handle } from "../dxf-encoding.js";
+import { dxfQuad, dxfTriangle, Handle } from "../dxf-encoding.js";
 
 const QUAD_STRIDE = 4;
 const TRIANGLE_STRIDE = 3;
@@ -18,7 +17,7 @@ export function dxfPolygon(p: Polygon, m: Material, parentPos: Vec3, parentRot:
     const vec3 = points[i + 2];
     const vec4 = points[i + 3];
     if(vec1 && vec2 && vec3 && vec4) {
-      polygonString += dxf3DFACE(
+      polygonString += dxfQuad(
         vec1,
         vec2,
         vec3,
@@ -38,7 +37,7 @@ export function dxfPolygon(p: Polygon, m: Material, parentPos: Vec3, parentRot:
         const vec2 = points[i - 1];
         const vec3 = points[i - 2];
         if(vec1 && vec2 && vec3) {
-          polygonString += dxf3DFACE(vec3, vec2, vec1, vec1, col, handleRef);
+          polygonString += dxfTriangle(vec3, vec2, vec1, col, handleRef);
         }
         break;
       }
@@ -47,11 +46,10 @@ export function dxfPolygon(p: Polygon, m: Material, parentPos: Vec3, parentRot:
         const vec2 = points[i - 1];
         const vec3 = points[i + 1];
         if(vec1 && vec2 && vec3) {
-          polygonString += dxf3DFACE(
+          polygonString += dxfTriangle(
             vec2,
             vec1,
             vec3,
-            vec3,
             col,
             handleRef
           );
@@ -63,11 +61,10 @@ export function dxfPolygon(p: Polygon, m: Material, parentPos: Vec3, parentRot:
         const vec2 = points[i + 1];
         const vec3 = points[i + 2];
         if(vec1 && vec2 && vec3) {
-          polygonString += dxf3DFACE(
+          polygonString += dxfTriangle(
             vec1,
             vec2,
             vec3,
-            vec3,
             col,
             handleRef
           );

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

@@ -1,34 +1,57 @@
 import { Shape, Material, Vec3, vec3TransRot, vec3RotCombine, vec3Zero, vec3 } from "../../../abstract-3d.js";
-import { color } from "../color.js";
-import { dxf3DFACE, Handle } from "../dxf-encoding.js";
+import { dxfQuad, dxfTriangle, Handle } from "../dxf-encoding.js";
 
-const chunkSize = 4;
+const QUAD_STRIDE = 4;
+const TRIANGLE_STRIDE = 3;
 
 export function dxfPolygon(s: Shape, m: Material, parentPos: Vec3, parentRot: Vec3, handleRef: Handle): string {
   let polygonString = "";
   const pos = vec3TransRot(s.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, s.rot ?? vec3Zero);
   const points = s.points.map((p) => vec3TransRot(vec3(p.x, p.y, 0), pos, rot));
-  const mat = m.normal;
   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]!, mat, handleRef);
+  if (points.length >= QUAD_STRIDE) {
+    for (i; i < points.length; i += QUAD_STRIDE) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const p3 = points[i + 2];
+      const p4 = points[i + 3];
+      if(p1 && p2 && p3 && p4) {
+        polygonString += dxfQuad(p1, p2, p3, p4, m.normal, handleRef);
+      }
     }
   }
 
-  if (i <= points.length && chunkSize - 1 <= points.length) {
+  if (i <= points.length && TRIANGLE_STRIDE <= points.length) {
     const lastArrayLength = points.length - i;
     switch (lastArrayLength) {
-      case 1:
-        polygonString += dxf3DFACE(points[i - 2]!, points[i - 1]!, points[i]!, points[i]!, mat, handleRef);
+      case 1: {
+        const p1 = points[i - 2];
+        const p2 = points[i - 1];
+        const p3 = points[i];
+        if(p1 && p2 && p3) {
+          polygonString += dxfTriangle(p1, p2, p3, m.normal, handleRef);
+        }
         break;
-      case 2:
-        polygonString += dxf3DFACE(points[i - 1]!, points[i]!, points[i + 1]!, points[i + 1]!, mat, handleRef);
+      }
+      case 2: {
+        const p1 = points[i - 1];
+        const p2 = points[i];
+        const p3 = points[i + 1];
+        if(p1 && p2 && p3) {
+          polygonString += dxfTriangle(p1, p2, p3, m.normal, handleRef);
+        }
         break;
-      case 3:
-        polygonString += dxf3DFACE(points[i]!, points[i + 1]!, points[i + 2]!, points[i + 2]!, mat, handleRef);
+      }
+      case 3: {
+        const p1 = points[i];
+        const p2 = points[i + 1];
+        const p3 = points[i + 2];
+        if(p1 && p2 && p3) {
+          polygonString += dxfTriangle(p1, p2, p3, m.normal, handleRef);
+        }
         break;
+      }
       default:
         break;
     }

package/src/renderers/dxf/dxf.ts

@@ -15,11 +15,12 @@ import {
   bounds3Merge,
   bounds3Center,
   vec3Add,
-  sizeCenterBoundsForCameraPos,
+  sizeBoundsForCameraPos,
   boundsScene,
   vec3Sub,
+  vec3Rot,
 } from "../../abstract-3d.js";
-import { dxf, dxfHandleCreate, DxfOrigin, Handle } from "./dxf-encoding.js";
+import { DEFAULT_CIRCLE_SIDE_COUNT, dxf, dxfHandleCreate, DxfOrigin, Handle } from "./dxf-encoding.js";
 import { dxfPlane } from "./dxf-geometries/dxf-plane.js";
 import { dxfBox } from "./dxf-geometries/dxf-box.js";
 import { dxfCylinder } from "./dxf-geometries/dxf-cylinder.js";
@@ -28,11 +29,17 @@ import { dxfPolygon } from "./dxf-geometries/dxf-polygon.js";
 import { Optional } from "../shared.js";
 import { dxfImage } from "./dxf-geometries/dxf-image.js";
 
-const DEFAULT_CYLINDER_SIDE_COUNT = 18;
-
-export type DxfOptions = { readonly view: View; readonly origin: DxfOrigin; readonly cylinderSideCount: number };
+export type DxfOptions = {
+  readonly view: View;
+  readonly origin: DxfOrigin;
+  readonly cylinderSideCount: number;
+};
 
-export type DxfScene = { readonly scene: Scene; readonly options?: Optional<DxfOptions>; readonly pos: Vec3 };
+export type DxfScene = {
+  readonly scene: Scene;
+  readonly options?: Optional<DxfOptions>;
+  readonly pos: Vec3;
+};
 
 export function renderScenes(scenes: ReadonlyArray<DxfScene>, baseOptions?: Optional<DxfOptions>): string {
   let allGroups = "";
@@ -67,14 +74,11 @@ const renderInternal = (
   handleRef: Handle
 ): { readonly groups: string; readonly size: Vec3; readonly center: Vec3 } => {
   const unitRot = vec3RotCombine(rotationForCameraPos(options.view), scene.rotation_deprecated ?? vec3Zero);
-  const [size, center] = sizeCenterBoundsForCameraPos(
-    scene.size_deprecated,
-    scene.center_deprecated ?? vec3Zero,
-    unitRot
-  );
-  const bounds = bounds3FromPosAndSize(center, size);
-  const dxfOriginOffset = originOffsetFromBounds(bounds, options.origin)
-  const pos = vec3NegateY(vec3Add(center, vec3Add(offset, dxfOriginOffset)));
+  const rotatedCenter = vec3Rot(scene.center_deprecated ?? vec3Zero, vec3Zero, scene.rotation_deprecated ?? vec3Zero);
+  const [size] = sizeBoundsForCameraPos(scene.size_deprecated, rotatedCenter, unitRot);
+  const bounds = bounds3FromPosAndSize(rotatedCenter, size);
+  const dxfOriginOffset = originOffsetFromBounds(bounds, options.origin);
+  const pos = vec3NegateY(vec3Add(rotatedCenter, vec3Add(offset, dxfOriginOffset)));
   return {
     groups: scene.groups.reduce((a, c) => a + dxfGroup(c, pos, unitRot, options, handleRef), ""),
     size,
@@ -86,13 +90,13 @@ function vec3NegateY(vec: Vec3): Vec3 {
   return {
     x: vec.x,
     y: -vec.y,
-    z: vec.z
+    z: vec.z,
   };
 }
 
 function originOffsetFromScenes(scenes: ReadonlyArray<DxfScene>, origin: DxfOrigin): Vec3 {
   const allBounds = Array<Bounds3>();
-  for(const scene of scenes) {
+  for (const scene of scenes) {
     const center = scene.scene.center_deprecated ?? vec3Zero;
     const size = scene.scene.size_deprecated;
     allBounds.push(bounds3FromPosAndSize(center, size));
@@ -101,7 +105,7 @@ function originOffsetFromScenes(scenes: ReadonlyArray<DxfScene>, origin: DxfOrig
 }
 
 function originOffsetFromBounds(bounds: Bounds3, origin: DxfOrigin): Vec3 {
-  switch(origin) {
+  switch (origin) {
     case "BottomLeftFront": {
       return vec3(Math.abs(bounds.min.x), -Math.abs(bounds.min.y), -Math.abs(bounds.min.z));
     }
@@ -158,7 +162,7 @@ function optionsDef(options: Optional<DxfOptions> | undefined): DxfOptions {
   return {
     view: options?.view ?? "front",
     origin: options?.origin ?? "BottomLeftFront",
-    cylinderSideCount: DEFAULT_CYLINDER_SIDE_COUNT,
+    cylinderSideCount: DEFAULT_CIRCLE_SIDE_COUNT,
   };
 }
 
@@ -168,9 +172,11 @@ export const renderOld = (scene: Scene, options?: Optional<DxfOptions>): string
   const center = scene.center_deprecated ?? vec3Zero;
   const unitRot = vec3RotCombine(rotationForCameraPos(opts.view), scene.rotation_deprecated ?? vec3Zero);
   const bounds = bounds3FromPosAndSize(center, scene.size_deprecated);
-  const offset =
-    vec3Sub(opts.origin === "Center" ? vec3Zero : vec3(Math.abs(bounds.min.x), Math.abs(bounds.min.y), -bounds.max.z), center);
-  
+  const offset = vec3Sub(
+    opts.origin === "Center" ? vec3Zero : vec3(Math.abs(bounds.min.x), Math.abs(bounds.min.y), -bounds.max.z),
+    center
+  );
+
   const newBounds: Bounds3 = {
     max: {
       x: bounds.max.x + offset.x,
@@ -181,7 +187,7 @@ export const renderOld = (scene: Scene, options?: Optional<DxfOptions>): string
       x: bounds.min.x + offset.x,
       y: bounds.min.y + offset.y,
       z: bounds.min.z + offset.z,
-    }
+    },
   };
 
   const bounds2 = bounds3FromPosAndSize(offset, scene.size_deprecated);

package/src/renderers/svg/svg.ts

@@ -15,7 +15,7 @@ import {
   vec3TransRot,
   Material,
   rotationForCameraPos,
-  sizeCenterBoundsForCameraPos,
+  sizeBoundsForCameraPos,
   Bounds2,
   bounds2FromPosAndSize,
   bounds2ToSize,
@@ -97,15 +97,13 @@ function renderInternal(
   };
   const baseRot = vec3RotCombine(rotationForCameraPos(opts.view), scene.rotation_deprecated ?? vec3Zero);
   const unitRot = opts.rotation ? vec3RotCombine(vec3(0, 0, (opts.rotation * Math.PI) / 180), baseRot) : baseRot;
-  const [unitSize, unitCenter] = sizeCenterBoundsForCameraPos(
-    scene.size_deprecated,
-    scene.center_deprecated ?? vec3Zero,
-    unitRot
-  );
+  const rotatedCenter = vec3Rot(scene.center_deprecated ?? vec3Zero, vec3Zero, scene.rotation_deprecated ?? vec3Zero);
+  const [unitSize] = sizeBoundsForCameraPos(scene.size_deprecated, rotatedCenter, 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 unitCenterFlipped = vec3Flip(rotatedCenter);
 
   const elements = Array<zOrderElement>();
   for (const g of scene.groups) {