abstract-3d 2.11.1 → 2.12.0

package/src/renderers/ifc/ifc.ts

@@ -15,17 +15,42 @@ export type IfcElementClass = {
   readonly predefinedType?: string;
 };
 
+export type IfcApplicationInfo = {
+  readonly name: string;
+  readonly version?: string;
+  /** Organization that develops the application, defaults to "Divid AB" */
+  readonly developer?: string;
+};
+
 export type IfcOptions = {
   /** Name of the IFC project, defaults to "Abstract 3D" */
   readonly name?: string;
+  /** Person exporting the file, written in the header and as the owner of every object, defaults to " " */
+  readonly author?: string;
+  /** Organization of the author, defaults to "UNKNOWN" */
+  readonly organization?: string;
+  /** Application that produced the scene, e.g. `{ name: "airCalc ACOM", version: "10.1" }`, defaults to Abstract 3D by Divid AB */
+  readonly application?: IfcApplicationInfo;
   /**
    * Wraps the whole scene in one element, e.g. `{ entity: "IfcUnitaryEquipment", predefinedType: "AIRHANDLER", name: "AHU" }`, otherwise the
    * top-level groups are placed directly in the storey
    */
   readonly root?: IfcElementClass & { readonly name: string };
+  /**
+   * Layer of a group's shapes, from the `data` of every group from the root down to this group, this group last; groups without `data` are skipped
+   * and the root element of `root` comes first. Undefined or "" keeps the layer of the group above
+   */
+  readonly layer?: (path: ReadonlyArray<Record<string, string>>) => string | undefined;
 };
 
-type NodeMesh = { readonly material: Material; readonly triangulation: Triangulation };
+type NodeMesh = { readonly material: Material; readonly triangulation: Triangulation; readonly layer: string | undefined };
+
+/** The `data` of the groups from the root down to a group and the layer its meshes are on */
+type Layering = {
+  readonly layerOf: IfcOptions["layer"];
+  readonly path: ReadonlyArray<Record<string, string>>;
+  readonly layer: string | undefined;
+};
 
 /** A group that becomes an element, groups without any triangulated geometry in them are left out */
 type ElementNode = {
@@ -39,78 +64,126 @@ type ElementNode = {
 
 const proxyClass: IfcElementClass = { entity: "IfcBuildingElementProxy" };
 
-type IfcContext = { readonly body: number; readonly styles: Map<string, number> };
+/**
+ * `owner` is the encoded GlobalId and OwnerHistory every IfcRoot entity starts with, call it once per entity since the GlobalId must be unique.
+ * `layers` are the face sets on each layer
+ */
+type IfcContext = {
+  readonly body: number;
+  readonly owner: (id?: string) => string;
+  readonly styles: Map<string, number>;
+  readonly layers: Map<string, Array<number>>;
+};
 
 /**
- * IFC4 (Reference View) with every mesh as an IfcTriangulatedFaceSet, in millimetres. Every top-level group and every group with `data` becomes an
- * IfcBuildingElementProxy placed relative to its parent element and aggregated into it. Groups without `data` are only transforms, so their meshes
- * are merged into the parent element
+ * IFC4 (Reference View) with every mesh as an IfcTriangulatedFaceSet, in millimetres. Every top-level group and every group with a `data.id` or
+ * `data.name` becomes an IfcBuildingElementProxy placed relative to its parent element and aggregated into it. Other groups are only transforms or
+ * metadata, so their meshes are merged into the parent element. With `layer`, the face sets are assigned to an IfcPresentationLayerAssignment per
+ * layer, the presentation layer of the Reference View
  */
 export function render(scene: Scene, options: IfcOptions = {}): string {
   const name = options.name ?? "Abstract 3D";
+  const author = options.author ?? " ";
+  const organization = options.organization ?? "UNKNOWN";
+  const application = options.application ?? { name: "Abstract 3D" };
+  const now = new Date();
   const m = ifcFile();
 
+  const ownerHistory = ownerHistoryEntity(m, author, organization, application, now);
   const world = axisPlacement(m, vec3Zero, vec3Zero);
   const context = add(m, `IFCGEOMETRICREPRESENTATIONCONTEXT($,'Model',3,1.E-05,${ref(world)},$)`);
   const body = add(m, `IFCGEOMETRICREPRESENTATIONSUBCONTEXT('Body','Model',*,*,*,*,${ref(context)},$,.MODEL_VIEW.,$)`);
+  const c: IfcContext = { body, owner: (id) => `${str(guid(m, id))},${ref(ownerHistory)}`, styles: new Map(), layers: new Map() };
   const units = [
     add(m, "IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.)"),
     add(m, "IFCSIUNIT(*,.AREAUNIT.,$,.SQUARE_METRE.)"),
     add(m, "IFCSIUNIT(*,.VOLUMEUNIT.,$,.CUBIC_METRE.)"),
     add(m, "IFCSIUNIT(*,.PLANEANGLEUNIT.,$,.RADIAN.)"),
   ];
-  const project = add(m, `IFCPROJECT(${str(guid(m))},$,${str(name)},$,$,$,$,(${ref(context)}),${ref(add(m, `IFCUNITASSIGNMENT(${refs(units)})`))})`);
+  const project = add(m, `IFCPROJECT(${c.owner()},${str(name)},$,$,$,$,(${ref(context)}),${ref(add(m, `IFCUNITASSIGNMENT(${refs(units)})`))})`);
 
   const sitePlacement = add(m, `IFCLOCALPLACEMENT($,${ref(world)})`);
-  const site = add(m, `IFCSITE(${str(guid(m))},$,'Site',$,$,${ref(sitePlacement)},$,$,.ELEMENT.,$,$,$,$,$)`);
+  const site = add(m, `IFCSITE(${c.owner()},'Site',$,$,${ref(sitePlacement)},$,$,.ELEMENT.,$,$,$,$,$)`);
   const buildingPlacement = add(m, `IFCLOCALPLACEMENT(${ref(sitePlacement)},${ref(world)})`);
-  const building = add(m, `IFCBUILDING(${str(guid(m))},$,'Building',$,$,${ref(buildingPlacement)},$,$,.ELEMENT.,$,$,$)`);
+  const building = add(m, `IFCBUILDING(${c.owner()},'Building',$,$,${ref(buildingPlacement)},$,$,.ELEMENT.,$,$,$)`);
   const storeyPlacement = add(m, `IFCLOCALPLACEMENT(${ref(buildingPlacement)},${ref(world)})`);
-  const storey = add(m, `IFCBUILDINGSTOREY(${str(guid(m))},$,'Storey',$,$,${ref(storeyPlacement)},$,$,.ELEMENT.,0.)`);
-  aggregate(m, project, [site]);
-  aggregate(m, site, [building]);
-  aggregate(m, building, [storey]);
+  const storey = add(m, `IFCBUILDINGSTOREY(${c.owner()},'Storey',$,$,${ref(storeyPlacement)},$,$,.ELEMENT.,0.)`);
+  aggregate(m, c, project, [site]);
+  aggregate(m, c, site, [building]);
+  aggregate(m, c, building, [storey]);
 
   const center = scene.center_deprecated ?? vec3Zero;
   const sceneRot = scene.rotation_deprecated ?? vec3Zero;
-  const c: IfcContext = { body, styles: new Map() };
-  const nodes = options.root
-    ? [elementNode({ pos: center, rot: sceneRot, groups: scene.groups, data: { name: options.root.name } }, center, sceneRot, options.root)]
-    : scene.groups.map((g) => elementNode(g, vec3TransRot(g.pos, center, sceneRot), vec3RotCombine(sceneRot, g.rot ?? vec3Zero)));
+  const top: Layering = { layerOf: options.layer, path: [], layer: undefined };
+  const rootGroup: Group | undefined = options.root && { pos: center, rot: sceneRot, groups: scene.groups, data: { name: options.root.name } };
+  const nodes = rootGroup
+    ? [elementNode(rootGroup, center, sceneRot, groupLayering(rootGroup, top), options.root)]
+    : scene.groups.map((g) =>
+        elementNode(g, vec3TransRot(g.pos, center, sceneRot), vec3RotCombine(sceneRot, g.rot ?? vec3Zero), groupLayering(g, top))
+      );
   const elements = nodes.flatMap((node) => node ?? []).map((node, i) => element(m, node, `${i + 1}`, storeyPlacement, c));
   if (elements.length > 0) {
-    add(m, `IFCRELCONTAINEDINSPATIALSTRUCTURE(${str(guid(m))},$,$,$,${refs(elements)},${ref(storey)})`);
+    add(m, `IFCRELCONTAINEDINSPATIALSTRUCTURE(${c.owner()},$,$,${refs(elements)},${ref(storey)})`);
   }
+  c.layers.forEach((items, layer) => add(m, `IFCPRESENTATIONLAYERASSIGNMENT(${str(layer)},$,${refs(items)},$)`));
 
-  const date = new Date().toISOString().split(".")[0] ?? "1970-01-01T00:00:00";
-  return serialize(m, `${name}.ifc`, date);
+  const date = now.toISOString().split(".")[0] ?? "1970-01-01T00:00:00";
+  return serialize(m, { fileName: `${name}.ifc`, date, author, organization, originatingSystem: application.name });
 }
 
-function elementNode(group: Group, pos: Vec3, rot: Vec3, elementClass = proxyClass): ElementNode | undefined {
-  const { meshes, children } = elementContent(group, vec3Zero, vec3Zero);
+/** The author as the owning user and the application, ADDED requires LastModifiedDate in IFC4 so it's set to the creation date */
+function ownerHistoryEntity(m: MutableIfc, author: string, organization: string, application: IfcApplicationInfo, now: Date): number {
+  const person = add(m, `IFCPERSON(${str(author)},$,$,$,$,$,$,$)`);
+  const owningOrganization = add(m, `IFCORGANIZATION($,${str(organization)},$,$,$)`);
+  const { name, version = "", developer = "Divid AB" } = application;
+  const developerOrganization = developer === organization ? owningOrganization : add(m, `IFCORGANIZATION($,${str(developer)},$,$,$)`);
+  const user = add(m, `IFCPERSONANDORGANIZATION(${ref(person)},${ref(owningOrganization)},$)`);
+  const app = add(m, `IFCAPPLICATION(${ref(developerOrganization)},${str(version)},${str(name)},${str(name)})`);
+  const timestamp = Math.floor(now.getTime() / 1000);
+  return add(m, `IFCOWNERHISTORY(${ref(user)},${ref(app)},$,.ADDED.,${timestamp},$,$,${timestamp})`);
+}
+
+/** `layering` is the group's own, see `groupLayering` */
+function elementNode(group: Group, pos: Vec3, rot: Vec3, layering: Layering, elementClass = proxyClass): ElementNode | undefined {
+  const { meshes, children } = elementContent(group, vec3Zero, vec3Zero, layering);
   return meshes.length > 0 || children.length > 0 ? { group, elementClass, pos, rot, meshes, children } : undefined;
 }
 
-/** Meshes of the group and its descendants without data, relative to the element the group is at pos/rot in, and the descendants with data as elements */
-function elementContent(group: Group, pos: Vec3, rot: Vec3): Pick<ElementNode, "meshes" | "children"> {
+/**
+ * Meshes of the group and its descendants that aren't elements, relative to the element the group is at pos/rot in, and the descendants with a
+ * `data.id` or `data.name` as elements
+ */
+function elementContent(group: Group, pos: Vec3, rot: Vec3, layering: Layering): Pick<ElementNode, "meshes" | "children"> {
   const meshes = (group.meshes ?? []).flatMap((mesh) => {
     const triangulation = triangulate(mesh.geometry, pos, rot);
-    return triangulation ? [{ material: mesh.material, triangulation }] : [];
+    return triangulation ? [{ material: mesh.material, triangulation, layer: layering.layer }] : [];
   });
   const nested = (group.groups ?? []).map((child) => {
     const childPos = vec3TransRot(child.pos, pos, rot);
     const childRot = vec3RotCombine(rot, child.rot ?? vec3Zero);
-    return Object.keys(child.data ?? {}).length > 0
-      ? { meshes: [], children: [elementNode(child, childPos, childRot)].flatMap((node) => node ?? []) }
-      : elementContent(child, childPos, childRot);
+    const childLayering = groupLayering(child, layering);
+    return child.data?.["id"] !== undefined || child.data?.["name"] !== undefined
+      ? { meshes: [], children: [elementNode(child, childPos, childRot, childLayering)].flatMap((node) => node ?? []) }
+      : elementContent(child, childPos, childRot, childLayering);
   });
   return { meshes: [...meshes, ...nested.flatMap((n) => n.meshes)], children: nested.flatMap((n) => n.children) };
 }
 
+/** Groups with `data` are added to the path and get the layer `layerOf` returns for it, if any, otherwise the layer of the parent */
+function groupLayering(group: Group, parent: Layering): Layering {
+  const data = group.data;
+  if (data === undefined || Object.keys(data).length === 0) {
+    return parent;
+  }
+  const path = [...parent.path, data];
+  const layer = parent.layerOf?.(path);
+  return { ...parent, path, layer: layer === undefined || layer === "" ? parent.layer : layer };
+}
+
 /** `path` is the element's position in the tree (e.g. "2.1"), named after it when the group has no `data.name` or `data.id` since IFC requires a name */
 function element(m: MutableIfc, node: ElementNode, path: string, parentPlacement: number, c: IfcContext): number {
   const placement = add(m, `IFCLOCALPLACEMENT(${ref(parentPlacement)},${ref(axisPlacement(m, node.pos, node.rot))})`);
-  const items = node.meshes.map(({ material, triangulation }) => faceSet(m, triangulation, material, c));
+  const items = node.meshes.map((mesh) => faceSet(m, mesh, c));
   const shape =
     items.length > 0
       ? ref(add(m, `IFCPRODUCTDEFINITIONSHAPE($,$,(${ref(add(m, `IFCSHAPEREPRESENTATION(${ref(c.body)},'Body','Tessellation',${refs(items)})`))}))`))
@@ -118,22 +191,29 @@ function element(m: MutableIfc, node: ElementNode, path: string, parentPlacement
   const id = node.group.data?.["id"];
   const name = node.group.data?.["name"] ?? id ?? `Element ${path}`;
   const { entity, predefinedType = "NOTDEFINED" } = node.elementClass;
-  const ifcElement = add(
-    m,
-    `${entity.toUpperCase()}(${str(guid(m, id))},$,${str(name)},$,$,${ref(placement)},${shape},${str(id)},.${predefinedType}.)`
-  );
+  const ifcElement = add(m, `${entity.toUpperCase()}(${c.owner(id)},${str(name)},$,$,${ref(placement)},${shape},${str(id)},.${predefinedType}.)`);
   aggregate(
     m,
+    c,
     ifcElement,
     node.children.map((child, i) => element(m, child, `${path}.${i + 1}`, placement, c))
   );
   return ifcElement;
 }
 
-function faceSet(m: MutableIfc, { points, triangles }: Triangulation, material: Material, c: IfcContext): number {
+/** One face set per mesh, so meshes on different layers are never in the same item */
+function faceSet(m: MutableIfc, { material, triangulation: { points, triangles }, layer }: NodeMesh, c: IfcContext): number {
   const pointList = add(m, `IFCCARTESIANPOINTLIST3D((${points.join(",")}))`);
   const faces = add(m, `IFCTRIANGULATEDFACESET(${ref(pointList)},$,.F.,(${triangles.map((t) => `(${t.join(",")})`).join(",")}),$)`);
   add(m, `IFCSTYLEDITEM(${ref(faces)},(${ref(surfaceStyle(m, material, c))}),$)`);
+  if (layer !== undefined) {
+    const items = c.layers.get(layer);
+    if (items) {
+      items.push(faces);
+    } else {
+      c.layers.set(layer, [faces]);
+    }
+  }
   return faces;
 }
 
@@ -160,8 +240,8 @@ function axisPlacement(m: MutableIfc, pos: Vec3, rot: Vec3): number {
   return add(m, `IFCAXIS2PLACEMENT3D(${ref(location)},${ref(axis)},${ref(refDirection)})`);
 }
 
-function aggregate(m: MutableIfc, parent: number, children: ReadonlyArray<number>): void {
+function aggregate(m: MutableIfc, c: IfcContext, parent: number, children: ReadonlyArray<number>): void {
   if (children.length > 0) {
-    add(m, `IFCRELAGGREGATES(${str(guid(m))},$,$,$,${ref(parent)},${refs(children)})`);
+    add(m, `IFCRELAGGREGATES(${c.owner()},$,$,${ref(parent)},${refs(children)})`);
   }
 }

package/src/renderers/react/react-image-material.tsx

@@ -1,7 +1,7 @@
 import { createSVG } from "abstract-image";
 import React from "react";
 import { suspend } from "suspend-react";
-import { CanvasTexture, DoubleSide, PlaneGeometry, SRGBColorSpace, type Texture, TextureLoader } from "three";
+import { CanvasTexture, DoubleSide, FrontSide, PlaneGeometry, SRGBColorSpace, type Texture, TextureLoader } from "three";
 import type { Material, Image as A3dImage } from "../../abstract-3d.js";
 import type { MaterialState } from "./react-material.js";
 import { ERROR_IMG_KEY, getColor, materialDefaults, selectMat } from "./react-material.js";
@@ -59,7 +59,7 @@ export function ImageMaterial({
   return (
     <meshBasicMaterial
       color={getColor(selected, hovered, material, selectMat)}
-      side={DoubleSide}
+      side={material.backfaceCulling ? FrontSide : DoubleSide}
       alphaTest={(useAlphaTest ?? true) ? 0.8 : undefined}
       map={texture}
       {...(material.opacity !== undefined && material.opacity < 1 ? { opacity: material.opacity } : materialDefaults)}

package/src/renderers/react/react-material.tsx

@@ -56,11 +56,11 @@ export function ReactMaterial({
   }
   return (
     <meshStandardMaterial
-      key={`mesh_material_standard_${mat.normal}_${mat.metalness}_${mat.opacity}_${mat.roughness}`}
+      key={`mesh_material_standard_${mat.normal}_${mat.metalness}_${mat.opacity}_${mat.roughness}_${material.backfaceCulling}`}
       color={getColor(selected, hovered, mat, selectMat)}
       roughness={mat.roughness}
       metalness={mat.metalness}
-      side={DoubleSide}
+      side={material.backfaceCulling ? FrontSide : DoubleSide}
       {...(opacity < 1 || disabled
         ? {
             transparent: true,