abstract-3d 4.1.6 → 4.2.1

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

@@ -1,4 +1,12 @@
-import { type Dimension, dimensionIsOfTypeMesh, type Vec3, vec3Length, vec3Sub, vec3TransRot } from "../../../abstract-3d.js";
+import {
+  type Dimension,
+  type DimensionPlacement,
+  dimensionIsOfTypeMesh,
+  type Vec3,
+  vec3Length,
+  vec3Sub,
+  vec3TransRot,
+} from "../../../abstract-3d.js";
 import type { Handle } from "../dxf-encoding/dxf-common.js";
 import { type DxfDimensionDefinition, dxfEncDimension } from "../dxf-encoding/dxf-dimension.js";
 
@@ -8,6 +16,8 @@ export function dxfDimension(
   parentRot: Vec3,
   sceneRotation: Vec3,
   viewRotation: Vec3,
+  textHeight: number | undefined,
+  placement: DimensionPlacement | undefined,
   handleRef: Handle
 ): DxfDimensionDefinition {
   if (dimensionIsOfTypeMesh(dimension)) {
@@ -21,5 +31,5 @@ export function dxfDimension(
   const me = vec3TransRot(dimension.measurementEnd, parentPos, parentRot);
   const lp = vec3TransRot(dimension.linePosition, parentPos, parentRot);
   const text = dimension.text ?? `${vec3Length(vec3Sub(me, ms))}`;
-  return dxfEncDimension(ms, me, lp, text, 7, sceneRotation, viewRotation, dimension.views ?? ["front"], handleRef);
+  return dxfEncDimension(ms, me, lp, text, 7, sceneRotation, viewRotation, dimension.views ?? ["front"], textHeight, placement, handleRef);
 }

package/src/renderers/dxf/dxf.ts

@@ -10,8 +10,11 @@ import {
   bounds3Merge,
   bounds3ToSize,
   boundsScene,
+  dimensionPlacements,
   group,
+  groupTextBackgrounds,
   rotationForCameraPos,
+  sceneTextHeight,
   sizeBoundsForCameraPos,
   vec3,
   vec3Add,
@@ -103,8 +106,9 @@ const renderInternal = (
   const dxfOriginOffset = originOffsetFromBounds(bounds, options.origin);
   const pos = options.origin === "SameAsScene" ? vec3Zero : vec3NegateY(vec3Add(unitCenter, vec3Add(offset, dxfOriginOffset)));
   const visibleViews = calculateVisibleViews(options.view, scene.rotation_deprecated);
+  const textHeight = sceneTextHeight(scene.groups);
   return {
-    groups: scene.groups.reduce((a, c) => a + dxfGroup(c, pos, unitRot, options, handleRef), ""),
+    groups: scene.groups.reduce((a, c) => a + dxfGroup(groupTextBackgrounds(c, textHeight), pos, unitRot, options, handleRef), ""),
     dimensions: dxfDimensions(
       scene.dimensions_deprecated,
       pos,
@@ -113,6 +117,7 @@ const renderInternal = (
       viewRotation,
       visibleViews,
       options,
+      textHeight,
       handleRef
     ),
     size,
@@ -200,6 +205,7 @@ function dxfDimensions(
   viewRotation: Vec3,
   visibleViews: Record<string, boolean>,
   options: DxfOptions,
+  textHeight: number,
   handleRef: Handle
 ): DxfDimensionDefinition {
   if (!d || !options.showDimensions) {
@@ -209,9 +215,13 @@ function dxfDimensions(
       blockRecord: "",
     };
   }
+  const placements = dimensionPlacements(d.dimensions, textHeight);
   return d.dimensions
-    .filter((d) => d.views?.[0] && visibleViews[d.views[0]] === true)
-    .map((d) => dxfDimension(d, parentPos, parentRot, sceneRotation, viewRotation, handleRef))
+    .flatMap((dim, i) =>
+      dim.views?.[0] && visibleViews[dim.views[0]] === true
+        ? [dxfDimension(dim, parentPos, parentRot, sceneRotation, viewRotation, textHeight, placements[i], handleRef)]
+        : []
+    )
     .reduce<DxfDimensionDefinition>(
       (prev, curr) => ({
         block: prev.block + curr.block,
@@ -243,7 +253,13 @@ export const renderOld = (scene: Scene, options?: Optional<DxfOptions>): string
   const visibleViews = calculateVisibleViews(opts.view, scene.rotation_deprecated);
 
   const bounds2 = bounds3FromPosAndSize(offset, scene.size_deprecated);
-  const groupRoot = group([], offset, vec3Zero, scene.groups);
+  const textHeight = sceneTextHeight(scene.groups);
+  const groupRoot = group(
+    [],
+    offset,
+    vec3Zero,
+    scene.groups.map((g) => groupTextBackgrounds(g, textHeight))
+  );
   const handleRef = dxfHandleInit();
   const dimensions = dxfDimensions(
     scene.dimensions_deprecated,
@@ -253,6 +269,7 @@ export const renderOld = (scene: Scene, options?: Optional<DxfOptions>): string
     viewRotation,
     visibleViews,
     opts,
+    textHeight,
     handleRef
   );
   return dxfBuild(dxfGroup(groupRoot, center, unitRot, opts, handleRef), dimensions, bounds2, scene.size_deprecated, center);

package/src/renderers/ifc/ifc.ts

@@ -1,6 +1,17 @@
 import { Color, SRGBColorSpace } from "three";
 import type { Scene, Group, Material, Relation, Vec3, GroupType, AirType } from "../../abstract-3d.js";
-import { vec3Zero, vec3PosX, vec3PosY, vec3Rot, vec3Sub, vec3TransRot, vec3RotCombine, vec3RotInverse } from "../../abstract-3d.js";
+import {
+  vec3Zero,
+  vec3PosX,
+  vec3PosY,
+  vec3Rot,
+  vec3Sub,
+  vec3TransRot,
+  vec3RotCombine,
+  vec3RotInverse,
+  groupTextBackgrounds,
+  sceneTextHeight,
+} from "../../abstract-3d.js";
 import type { MutableIfc } from "./ifc-encoding.js";
 import { add, guid, ifcFile, point, real, ref, refs, serialize, str } from "./ifc-encoding.js";
 import type { Polyline, Triangulation } from "./ifc-geometry.js";
@@ -259,11 +270,13 @@ export function render(scene: Scene, options: IfcOptions = {}): string {
 
   const center = scene.center_deprecated ?? vec3Zero;
   const sceneRot = scene.rotation_deprecated ?? vec3Zero;
+  const textHeight = sceneTextHeight(scene.groups);
+  const groups = scene.groups.map((g) => groupTextBackgrounds(g, textHeight));
   // A scene that is something as a whole is one element, with its groups as the parts of it
   const roots =
     scene.id !== undefined || scene.name !== undefined || scene.type !== undefined
-      ? [{ pos: vec3Zero, id: scene.id, name: scene.name, type: scene.type, groups: scene.groups }]
-      : scene.groups;
+      ? [{ pos: vec3Zero, id: scene.id, name: scene.name, type: scene.type, groups }]
+      : groups;
   const elements = mergeSameId(roots)
     .flatMap((g) => elementNode(g, vec3TransRot(g.pos, center, sceneRot), vec3RotCombine(sceneRot, g.rot ?? vec3Zero), g.layer) ?? [])
     .map((node, i) => element(m, node, `${i + 1}`, { element: storey, placement: storeyPlacement, pos: vec3Zero, rot: vec3Zero }, c));

package/src/renderers/step/step.ts

@@ -1,5 +1,5 @@
 import type { Scene, Group, Vec3 } from "../../abstract-3d.js";
-import { vec3Zero, vec3TransRot, vec3RotCombine } from "../../abstract-3d.js";
+import { vec3Zero, vec3TransRot, vec3RotCombine, groupTextBackgrounds, sceneTextHeight } from "../../abstract-3d.js";
 import type { MutableStep } from "./step-encoding.js";
 import {
   GEOMETRIC_REPRESENTATION_CONTEXT_3D,
@@ -39,8 +39,9 @@ export const render = (scene: Scene): string => {
     throw Error("Context 3d is not correct");
   }
 
+  const textHeight = sceneTextHeight(scene.groups);
   for (const g of scene.groups) {
-    stepGroup(g, scene.center_deprecated ?? vec3Zero, scene.rotation_deprecated ?? vec3Zero, m);
+    stepGroup(groupTextBackgrounds(g, textHeight), scene.center_deprecated ?? vec3Zero, scene.rotation_deprecated ?? vec3Zero, m);
   }
 
   return `${HEADER(date ?? DEFAULT_DATE_UNIX)}${m.step}${ENDSEC()}`;

package/src/renderers/stl/stl.ts

@@ -1,14 +1,22 @@
 import type { Scene, Group, Vec3 } from "../../abstract-3d.js";
-import { vec3Zero, vec3TransRot, vec3RotCombine } from "../../abstract-3d.js";
+import { vec3Zero, vec3TransRot, vec3RotCombine, groupTextBackgrounds, sceneTextHeight } from "../../abstract-3d.js";
 import { stlBox } from "./stl-geometries/stl-box.js";
 import { stlCone } from "./stl-geometries/stl-cone.js";
 import { stlCylinder } from "./stl-geometries/stl-cylinder.js";
 import { stlPlane } from "./stl-geometries/stl-plane.js";
 import { stlPolygon } from "./stl-geometries/stl-polygon.js";
 
-export const render = (scene: Scene): string =>
-  `solid
-` + scene.groups.reduce((a, c) => a + stlGroup(c, scene.center_deprecated ?? vec3Zero, scene.rotation_deprecated ?? vec3Zero), "");
+export const render = (scene: Scene): string => {
+  const textHeight = sceneTextHeight(scene.groups);
+  return (
+    `solid
+` +
+    scene.groups.reduce(
+      (a, c) => a + stlGroup(groupTextBackgrounds(c, textHeight), scene.center_deprecated ?? vec3Zero, scene.rotation_deprecated ?? vec3Zero),
+      ""
+    )
+  );
+};
 
 function stlGroup(g: Group, parentPos: Vec3, parentRot: Vec3): string {
   const pos = vec3TransRot(g.pos, parentPos, parentRot);

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

@@ -14,7 +14,8 @@ export function text(
   fill: string,
   opts: SvgOptions,
   parentPos: Vec3,
-  parentRot: Vec3
+  parentRot: Vec3,
+  textHeight: number
 ): ReadonlyArray<zOrderElement> {
   const pos = vec3TransRot(t.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, t.rot ?? vec3Zero);
@@ -27,7 +28,7 @@ export function text(
   }
 
   const texts = Array<zOrderElement>();
-  const fontSize = t.fontSize;
+  const fontSize = t.fontSize ?? textHeight;
   const strings = t.text.split("\n");
   let posY = strings.length === 1 ? 0 : (fontSize * strings.length - fontSize) / 2;
   for (const s of strings) {

package/src/renderers/svg/svg.ts

@@ -15,6 +15,9 @@ import {
   vec2Zero,
   vec3Flip,
   dimensionConvertToTypeMesh,
+  dimensionPlacements,
+  groupTextBackgrounds,
+  sceneTextHeight,
 } from "../../abstract-3d.js";
 import type { Optional } from "../../utils.js";
 import { calculateVisibleViews, isViewVisible } from "../../utils.js";
@@ -109,37 +112,53 @@ function renderInternal(
   const point = (x: number, y: number): Vec2 => vec2(svgCenter.x + x, svgCenter.y - y);
   const unitCenterFlipped = vec3Flip(unitCenter);
 
+  const textHeight = sceneTextHeight(scene.groups);
   const elements = Array<zOrderElement>();
   for (const g of scene.groups) {
-    elements.push(...svgGroup(g, unitCenterFlipped, unitRot, point, opts));
+    elements.push(...svgGroup(groupTextBackgrounds(g, textHeight), unitCenterFlipped, unitRot, point, opts, textHeight));
   }
   const dimOpts: SvgOptions = { ...opts, only_stroke: false, gray_scale: false };
   elements.sort((a, b) => a.zOrder - b.zOrder);
   const visibleViews = calculateVisibleViews(view, scene.rotation_deprecated);
 
   // Dimensions are drawn for the flat views
-  for (const dim of isometric ? [] : (scene.dimensions_deprecated?.dimensions ?? [])) {
-    const d = dimensionConvertToTypeMesh(dim, scene.rotation_deprecated ?? vec3Zero, scene.dimensions_deprecated?.material);
+  const dimensions = isometric ? [] : (scene.dimensions_deprecated?.dimensions ?? []);
+  const placements = dimensionPlacements(dimensions, textHeight);
+  for (const [i, dim] of dimensions.entries()) {
+    const d = dimensionConvertToTypeMesh(
+      dim,
+      scene.rotation_deprecated ?? vec3Zero,
+      scene.dimensions_deprecated?.material,
+      textHeight,
+      placements[i]
+    );
     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));
+        elements.push(...svgMesh(m, pos, rot, point, scene.dimensions_deprecated?.material ?? { normal: "" }, dimOpts, textHeight));
       }
     }
   }
   return { elements, size: svgSize, center: svgCenter };
 }
 
-function svgGroup(g: Group, parentPos: Vec3, parentRot: Vec3, point: (x: number, y: number) => Vec2, opts: SvgOptions): ReadonlyArray<zOrderElement> {
+function svgGroup(
+  g: Group,
+  parentPos: Vec3,
+  parentRot: Vec3,
+  point: (x: number, y: number) => Vec2,
+  opts: SvgOptions,
+  textHeight: number
+): 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));
+    elements.push(...svgMesh(m, pos, rot, point, m.material, opts, textHeight));
   }
   for (const sg of g.groups ?? []) {
-    elements.push(...svgGroup(sg, pos, rot, point, opts));
+    elements.push(...svgGroup(sg, pos, rot, point, opts, textHeight));
   }
   return elements;
 }
@@ -150,7 +169,8 @@ function svgMesh(
   parentRot: Vec3,
   point: (x: number, y: number) => Vec2,
   material: Material,
-  opts: SvgOptions
+  opts: SvgOptions,
+  textHeight: number
 ): ReadonlyArray<zOrderElement> {
   switch (mesh.geometry.type) {
     case "Box":
@@ -169,7 +189,7 @@ function svgMesh(
     case "Shape":
       return shape(mesh.geometry, point, material, opts, parentPos, parentRot);
     case "Text":
-      return text(mesh.geometry, point, material.normal, opts, parentPos, parentRot);
+      return text(mesh.geometry, point, material.normal, opts, parentPos, parentRot, textHeight);
     case "Image":
       return image(mesh.geometry, point, opts, parentPos, parentRot);
     case "Tube":

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

@@ -14,7 +14,8 @@ export function text(
   fill: string,
   opts: SvgOptions,
   parentPos: Vec3,
-  parentRot: Vec3
+  parentRot: Vec3,
+  textHeight: number
 ): ReadonlyArray<zOrderElement> {
   const pos = vec3TransRot(t.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, t.rot ?? vec3Zero);
@@ -27,7 +28,7 @@ export function text(
   }
 
   const texts = Array<zOrderElement>();
-  const fontSize = t.fontSize;
+  const fontSize = t.fontSize ?? textHeight;
   const strings = t.text.split("\n");
   let posY = strings.length === 1 ? 0 : (fontSize * strings.length - fontSize) / 2;
   for (const s of strings) {

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

@@ -15,6 +15,9 @@ import {
   vec2Zero,
   vec3Flip,
   dimensionConvertToTypeMesh,
+  dimensionPlacements,
+  groupTextBackgrounds,
+  sceneTextHeight,
 } from "../../abstract-3d.js";
 import type { Optional } from "../../utils.js";
 import { calculateVisibleViews, isViewVisible } from "../../utils.js";
@@ -110,9 +113,10 @@ function renderInternal(
   const point = (x: number, y: number): Vec2 => vec2(svgCenter.x + x, svgCenter.y - y);
   const unitCenterFlipped = vec3Flip(unitCenter);
 
+  const textHeight = sceneTextHeight(scene.groups);
   const elements = [
     ...orderElements(
-      scene.groups.flatMap((g) => svgGroup(g, unitCenterFlipped, unitRot, point, opts)),
+      scene.groups.flatMap((g) => svgGroup(groupTextBackgrounds(g, textHeight), unitCenterFlipped, unitRot, point, opts, textHeight)),
       point
     ),
   ];
@@ -120,28 +124,43 @@ function renderInternal(
   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);
+  const dimensions = angled ? [] : (scene.dimensions_deprecated?.dimensions ?? []);
+  const placements = dimensionPlacements(dimensions, textHeight);
+  for (const [i, dim] of dimensions.entries()) {
+    const d = dimensionConvertToTypeMesh(
+      dim,
+      scene.rotation_deprecated ?? vec3Zero,
+      scene.dimensions_deprecated?.material,
+      textHeight,
+      placements[i]
+    );
     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));
+        elements.push(...svgMesh(m, pos, rot, point, scene.dimensions_deprecated?.material ?? { normal: "" }, dimOpts, textHeight));
       }
     }
   }
   return { elements, size: svgSize, center: svgCenter };
 }
 
-function svgGroup(g: Group, parentPos: Vec3, parentRot: Vec3, point: (x: number, y: number) => Vec2, opts: SvgOptions): ReadonlyArray<zOrderElement> {
+function svgGroup(
+  g: Group,
+  parentPos: Vec3,
+  parentRot: Vec3,
+  point: (x: number, y: number) => Vec2,
+  opts: SvgOptions,
+  textHeight: number
+): 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));
+    elements.push(...svgMesh(m, pos, rot, point, m.material, opts, textHeight));
   }
   for (const sg of g.groups ?? []) {
-    elements.push(...svgGroup(sg, pos, rot, point, opts));
+    elements.push(...svgGroup(sg, pos, rot, point, opts, textHeight));
   }
   return elements;
 }
@@ -152,7 +171,8 @@ function svgMesh(
   parentRot: Vec3,
   point: (x: number, y: number) => Vec2,
   material: Material,
-  opts: SvgOptions
+  opts: SvgOptions,
+  textHeight: number
 ): ReadonlyArray<zOrderElement> {
   switch (mesh.geometry.type) {
     case "Box":
@@ -171,7 +191,7 @@ function svgMesh(
     case "Shape":
       return shape(mesh.geometry, point, material, opts, parentPos, parentRot);
     case "Text":
-      return text(mesh.geometry, point, material.normal, opts, parentPos, parentRot);
+      return text(mesh.geometry, point, material.normal, opts, parentPos, parentRot, textHeight);
     case "Image":
       return image(mesh.geometry, point, opts, parentPos, parentRot);
     case "Tube":

package/src/renderers/three/build/build.test.ts

@@ -96,8 +96,8 @@ describe("buildScene", () => {
   });
 
   it("keeps dimensions in their own group, and doesn't pick hidden ones", () => {
-    // Its text is centered half a text height of 44 above the line, here at the origin
-    const dimension = alignedDimension(vec3(-500, 78, 0), vec3(500, 78, 0), vec3(0, -22, 0), "1000", ["front"], undefined, "dim");
+    // Its text, the empty scene's 32 high, is centered a gap and half its height out from the line, over the origin
+    const dimension = alignedDimension(vec3(-500, 100, 0), vec3(500, 100, 0), vec3(0, 30, 0), "1000", ["front"], undefined, "dim");
     const built = build(scene([], { dimensions_deprecated: { dimensions: [dimension], material: red } }));
     expect(built.dimensions.children.length).toBeGreaterThan(0);
     expect(pickId(built, 0)).toBe("dim");

package/src/renderers/three/build/build.ts

@@ -216,7 +216,7 @@ function createPart(
     case "text":
       return createTextPart(
         items.flatMap(({ mesh: { geometry: g } }) =>
-          g.type === "Text" ? [{ text: g.text, fontSize: g.fontSize, local: transform(g.pos, g.rot) }] : []
+          g.type === "Text" ? [{ text: g.text, fontSize: g.fontSize ?? compiled.textHeight, local: transform(g.pos, g.rot) }] : []
         ),
         options.atlas
       );

package/src/renderers/three/compile/compile.ts

@@ -1,6 +1,14 @@
 import { Euler, Matrix4, Quaternion, Vector3 } from "three";
 import type { Group, Mesh, Relation, Scene, Vec3 } from "../../../abstract-3d.js";
-import { dimensionConvertToTypeMesh, vec3, vec3Scale, vec3Zero } from "../../../abstract-3d.js";
+import {
+  dimensionConvertToTypeMesh,
+  dimensionPlacements,
+  groupTextBackgrounds,
+  sceneTextHeight,
+  vec3,
+  vec3Scale,
+  vec3Zero,
+} from "../../../abstract-3d.js";
 
 /**
  * Scene → flat items with world matrices, with no GPU objects, so everything here is testable in Node; groups transform as the r3f renderer's
@@ -48,6 +56,8 @@ export type CompiledScene = {
   readonly matrix: Matrix4;
   /** World matrix of each top-level group */
   readonly roots: ReadonlyArray<Matrix4>;
+  /** The height of the scene's texts without a font size, see `sceneTextHeight` */
+  readonly textHeight: number;
 };
 
 type Output = { readonly items: Array<Item>; readonly animations: Array<Animation> };
@@ -67,16 +77,24 @@ export function compileScene(scene: Scene, createGroupId?: (g: Group) => string)
     ...dimensions.map((d): Target => ({ kind: "dimension", id: d.id })),
     ...relations.map((relation): Target => ({ kind: "relation", relation })),
   ];
-  scene.groups.forEach((g, i) => addGroup(out, g, matrix, undefined, "group", i));
+  const textHeight = sceneTextHeight(scene.groups);
+  scene.groups.forEach((g, i) => addGroup(out, groupTextBackgrounds(g, textHeight), matrix, undefined, "group", i));
+  const placements = dimensionPlacements(dimensions, textHeight);
   dimensions.forEach((dimension, i) => {
-    const mesh = dimensionConvertToTypeMesh(dimension, scene.rotation_deprecated ?? vec3Zero, scene.dimensions_deprecated?.material);
+    const mesh = dimensionConvertToTypeMesh(
+      dimension,
+      scene.rotation_deprecated ?? vec3Zero,
+      scene.dimensions_deprecated?.material,
+      textHeight,
+      placements[i]
+    );
     const base = { style: "dimension", target: scene.groups.length + i, data: undefined, animation: undefined } as const;
     addMeshes(out, mesh.meshes, matrix.clone().multiply(transform(mesh.pos, mesh.rot)), base);
   });
   relations.forEach((relation, i) =>
     relation.groups?.forEach((g) => addGroup(out, g, matrix, undefined, "relation", scene.groups.length + dimensions.length + i))
   );
-  return { ...out, targets, matrix, roots: scene.groups.map((g) => matrix.clone().multiply(transform(g.pos, g.rot))) };
+  return { ...out, targets, matrix, roots: scene.groups.map((g) => matrix.clone().multiply(transform(g.pos, g.rot))), textHeight };
 }
 
 function addGroup(out: Output, g: Group, parent: Matrix4, parentAnimation: number | undefined, style: "group" | "relation", target: number): void {