abstract-3d 0.4.21 → 0.5.0

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

@@ -1,3 +1,4 @@
+import { Euler, Matrix4, Vector3 } from "three";
 import {
   Plane,
   Material,
@@ -16,11 +17,16 @@ import {
   vec3NegY,
   vec3NegZ,
   vec3PosY,
+  vec3Normalize,
+  vec3Scale,
+  vec3Add,
 } from "../../../abstract-3d.js";
 import { parseRgb } from "../../shared.js";
 import {
   ADVANCED_BREP_SHAPE_REPRESENTATION,
   ADVANCED_FACE,
+  APPLICATION_CONTEXT,
+  APPLICATION_PROTOCOL_DEFINITION,
   AXIS2_PLACEMENT_3D,
   CARTESIAN_POINT,
   CIRCLE,
@@ -45,7 +51,14 @@ import {
   PCURVE,
   PLANE,
   PRESENTATION_STYLE_ASSIGNMENT,
+  PRODUCT,
+  PRODUCT_CONTEXT,
+  PRODUCT_DEFINITION,
+  PRODUCT_DEFINITION_CONTEXT,
+  PRODUCT_DEFINITION_FORMATION,
+  PRODUCT_DEFINITION_SHAPE,
   SEAM_CURVE,
+  SHAPE_DEFINITION_REPRESENTATION,
   SHELL_BASED_SURFACE_MODEL,
   STYLED_ITEM,
   SURFACE_CURVE,
@@ -57,129 +70,214 @@ import {
 } from "../step-encoding.js";
 
 export function stepCylinder(c: Cylinder, mat: Material, parentPos: Vec3, parentRot: Vec3, m: MutableStep): void {
+  const r = c.radius;
+  const h = c.length;
+  const rgb = parseRgb(mat.normal);
   const pos = vec3TransRot(c.pos, parentPos, parentRot);
-  const rot = vec3RotCombine(parentRot, c.rot ?? vec3Zero);
-  const cart3tr = (x: number, y: number): number => CARTESIAN_POINT(vec3TransRot(vec3(x, y, 0), pos, rot), m);
-  const v0 = VECTOR(DIRECTION(vec3Zero, m), m);
-  const c03 = CARTESIAN_POINT(vec3Zero, m);
-  const c02 = CARTESIAN_POINT(vec2Zero, m);
-  const [d1, d2] = [DIRECTION(vec3RotCombine(vec3PosX, rot), m), DIRECTION(vec3RotCombine(vec3PosY, rot), m)];
-  const [d3, d4] = [DIRECTION(vec3RotCombine(vec3PosZ, rot), m), DIRECTION(vec3RotCombine(vec3NegX, rot), m)];
-  const [d5, d6] = [DIRECTION(vec3RotCombine(vec3NegY, rot), m), DIRECTION(vec3RotCombine(vec3NegZ, rot), m)];
-  const [down, up] = [AXIS2_PLACEMENT_3D(c03, d5, d4, m), AXIS2_PLACEMENT_3D(c03, d2, d1, m)];
-  const [c1, c2] = [cart3tr(-c.radius, -c.length / 2), cart3tr(c.radius, -c.length / 2)];
-  const [c3, c4] = [cart3tr(c.radius, c.length / 2), cart3tr(-c.radius, c.length / 2)];
-  const [v1, v2, v3, v4] = [VERTEX_POINT(c1, m), VERTEX_POINT(c2, m), VERTEX_POINT(c3, m), VERTEX_POINT(c4, m)];
-  const [l1, l2, l3, l4] = [LINE(c1, v0, m), LINE(c2, v0, m), LINE(c3, v0, m), LINE(c4, v0, m)];
-
-  const [oe1, oe2, oe3, oe4] = [
-    ORIENTED_EDGE(
-      EDGE_CURVE(
-        v1,
-        v2,
-        SEAM_CURVE(
-          LINE(c2, v0, m),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
-          m
-        ),
+  const rotation = vec3RotCombine(parentRot, c.rot ?? vec3Zero);
+  
+  const rotationMatrix = new Matrix4();
+  const euler = new Euler();
+  euler.set(rotation.x, rotation.y, rotation.z);
+  rotationMatrix.makeRotationFromEuler(euler);
+
+  const upNormal = new Vector3();
+  const downNormal = new Vector3();
+  upNormal.set(0, 1, 0);
+  downNormal.set(0, -1, 0);
+
+  upNormal.applyMatrix4(rotationMatrix);
+  downNormal.applyMatrix4(rotationMatrix);
+
+  const circleTop = new Vector3();
+  circleTop.set(0,  h / 2, 0);
+  circleTop.applyMatrix4(rotationMatrix);
+
+  const circleBot = new Vector3();
+  circleBot.set(0,  -h / 2, 0);
+  circleBot.applyMatrix4(rotationMatrix);
+
+  const v1 = new Vector3();
+  const v2 = new Vector3();
+  v1.set(r, h / 2, 0);
+  v2.set(r, -h / 2, 0);
+  v1.applyMatrix4(rotationMatrix);
+  v2.applyMatrix4(rotationMatrix);
+
+  APPLICATION_PROTOCOL_DEFINITION(m);
+  const applicationContext = APPLICATION_CONTEXT(m);
+
+  const ecurve0 = EDGE_CURVE(
+    VERTEX_POINT(CARTESIAN_POINT(vec3Add(pos, v2), m), m),
+    VERTEX_POINT(CARTESIAN_POINT(vec3Add(pos, v1), m), m), 
+    LINE(CARTESIAN_POINT(vec3Add(pos, v2), m), VECTOR(DIRECTION(upNormal, m), m), m),
+    m,
+    "T"
+  );
+
+  const ecurve1 = EDGE_CURVE(
+    VERTEX_POINT(CARTESIAN_POINT(vec3Add(pos, v2), m), m),
+    VERTEX_POINT(CARTESIAN_POINT(vec3Add(pos, v2), m), m),
+    CIRCLE(
+      AXIS2_PLACEMENT_3D(
+        CARTESIAN_POINT(vec3Add(pos, circleBot), m),
+        DIRECTION(upNormal, m),
+        DIRECTION(vec3(0, 1, 0), m),
+        m
+      ),
+      r,
+      m
+    ),
+    m,
+    "T"
+  );
+
+  const ecurve2 = EDGE_CURVE(
+    VERTEX_POINT(CARTESIAN_POINT(vec3Add(pos, v1), m), m),
+    VERTEX_POINT(CARTESIAN_POINT(vec3Add(pos, v1), m), m),
+    CIRCLE(
+      AXIS2_PLACEMENT_3D(
+        CARTESIAN_POINT(vec3Add(pos, circleTop), m),
+        DIRECTION(upNormal, m),
+        DIRECTION(vec3(0, 1, 0), m),
         m
       ),
+      r,
       m
     ),
-    ORIENTED_EDGE(
-      EDGE_CURVE(
-        v1,
-        v2,
-        SEAM_CURVE(
-          LINE(c2, v0, m),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
+    m
+  );
+
+  const msb = MANIFOLD_SOLID_BREP(CLOSED_SHELL([
+
+    ADVANCED_FACE(
+      FACE_BOUND(
+        EDGE_LOOP(
+          [
+            ORIENTED_EDGE(
+              ecurve0,
+              m,
+              "T"
+            ),
+            ORIENTED_EDGE(
+              ecurve2,
+              m
+            ),
+            ORIENTED_EDGE(ecurve0, m, "F"),
+            ORIENTED_EDGE(
+              ecurve1,
+              m,
+              "F"
+            ),
+          ],
           m
         ),
+        "F",
+        m
+      ),
+      CYLINDRICAL_SURFACE(
+        AXIS2_PLACEMENT_3D(
+          CARTESIAN_POINT(vec3(pos.x + circleTop.x, pos.y + circleTop.y, pos.z + circleTop.z), m),
+          DIRECTION(downNormal, m),
+          DIRECTION(vec3(0, -1, 0), m),
+          m
+        ),
+        r,
         m
       ),
       m
     ),
-    ORIENTED_EDGE(
-      EDGE_CURVE(
-        v2,
-        v2,
-        SURFACE_CURVE(
-          CIRCLE(down, m),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
-          PCURVE(down, DEFINITIONAL_REPRESENTATION(CIRCLE(up, m), m), m),
+
+    ADVANCED_FACE(
+      FACE_BOUND(
+        EDGE_LOOP([
+          ORIENTED_EDGE(
+              ecurve1,
+              m,
+              "F"
+            ),
+          ],
           m
         ),
+        "T",
         m
       ),
-      m
-    ), // Bottom  circle edge curve
-    ORIENTED_EDGE(
-      EDGE_CURVE(
-        v3,
-        v3,
-        SURFACE_CURVE(
-          CIRCLE(down, m),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
-          PCURVE(down, DEFINITIONAL_REPRESENTATION(CIRCLE(up, m), m), m),
+      PLANE(
+        AXIS2_PLACEMENT_3D(
+          CARTESIAN_POINT(vec3Add(pos, circleBot), m),
+          DIRECTION(upNormal, m),
+          DIRECTION(vec3(0, 1, 0), m),
           m
         ),
         m
       ),
-      m
-    ), // Top circle edge curve
-  ];
+      m,
+      "F"
+    ),
 
-  const color = COLOUR_RGB(parseRgb(mat.normal), m);
-  const msb = MANIFOLD_SOLID_BREP(
-    CLOSED_SHELL(
-      [
-        ADVANCED_FACE(
-          FACE_BOUND(EDGE_LOOP([oe1, oe2, oe3, oe4], m), "F", m),
-          PCURVE(
-            CYLINDRICAL_SURFACE(down, m),
-            DEFINITIONAL_REPRESENTATION(LINE(c02, VECTOR(DIRECTION(vec2(-1, 0), m), m), m), m),
-            m
-          ),
+    ADVANCED_FACE(
+      FACE_BOUND(
+        EDGE_LOOP(
+          [
+            ORIENTED_EDGE(
+              ecurve2,
+              m,
+              "F"
+            ),
+          ],
           m
         ),
-        ADVANCED_FACE(FACE_BOUND(EDGE_LOOP([oe3], m), "T", m), PLANE(down, m), m), // Circle down
-        ADVANCED_FACE(FACE_BOUND(EDGE_LOOP([oe4], m), "F", m), PLANE(up, m), m), // Circle up
-      ],
+        "F",
+        m
+      ),
+      PLANE(
+        AXIS2_PLACEMENT_3D(
+          CARTESIAN_POINT(vec3Add(pos, circleTop), m),
+          DIRECTION(upNormal, m),
+          DIRECTION(vec3(0, 1, 0), m),
+          m
+        ),
+        m
+      ),
       m
     ),
+  ], m), m);
+
+  const absp = ADVANCED_BREP_SHAPE_REPRESENTATION(
+    AXIS2_PLACEMENT_3D(CARTESIAN_POINT(vec3Zero, m), DIRECTION(vec3(0, 0, 1), m), DIRECTION(vec3(1, 0, 0), m), m),
+    msb,
     m
   );
-  ADVANCED_BREP_SHAPE_REPRESENTATION(
-    AXIS2_PLACEMENT_3D(c03, DIRECTION(vec3PosZ, m), DIRECTION(vec3PosX, m), m),
-    msb,
+
+  const prod = PRODUCT(
+    PRODUCT_CONTEXT(
+      applicationContext,
+      m
+    ),
+    "Cylinder",
     m
   );
+
+  SHAPE_DEFINITION_REPRESENTATION(
+    PRODUCT_DEFINITION_SHAPE(
+      PRODUCT_DEFINITION(
+        PRODUCT_DEFINITION_FORMATION(
+          prod,
+          m
+        ),
+        PRODUCT_DEFINITION_CONTEXT(
+          applicationContext,
+          m
+        ),
+        m
+      ),
+      m
+    ),
+    absp,
+    m
+  );
+
+  const color = COLOUR_RGB(parseRgb(mat.normal), m);
   MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(
     STYLED_ITEM(
       PRESENTATION_STYLE_ASSIGNMENT(
@@ -192,4 +290,4 @@ export function stepCylinder(c: Cylinder, mat: Material, parentPos: Vec3, parent
     ),
     m
   );
-}
+}

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

@@ -9,10 +9,15 @@ import {
   vec3,
   vec3PosX,
   vec3PosZ,
+  vec3PosY,
+  vec3RotNormal,
+  vec3NegZ,
 } from "../../../abstract-3d.js";
 import { parseRgb } from "../../shared.js";
 import {
   ADVANCED_FACE,
+  APPLICATION_CONTEXT,
+  APPLICATION_PROTOCOL_DEFINITION,
   AXIS2_PLACEMENT_3D,
   CARTESIAN_POINT,
   COLOUR_RGB,
@@ -31,6 +36,13 @@ import {
   ORIENTED_EDGE,
   PLANE,
   PRESENTATION_STYLE_ASSIGNMENT,
+  PRODUCT,
+  PRODUCT_CONTEXT,
+  PRODUCT_DEFINITION,
+  PRODUCT_DEFINITION_CONTEXT,
+  PRODUCT_DEFINITION_FORMATION,
+  PRODUCT_DEFINITION_SHAPE,
+  SHAPE_DEFINITION_REPRESENTATION,
   SHELL_BASED_SURFACE_MODEL,
   STYLED_ITEM,
   SURFACE_SIDE_STYLE,
@@ -45,7 +57,7 @@ export function stepPlane(p: Plane, mat: Material, parentPos: Vec3, parentRot: V
   const pos = vec3TransRot(p.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, p.rot ?? vec3Zero);
   const cart3tr = (x: number, y: number): number => CARTESIAN_POINT(vec3TransRot(vec3(x, y, 0), pos, rot), m);
-  const v0 = VECTOR(DIRECTION(vec3Zero, m), m);
+  const v0 = VECTOR(DIRECTION(vec3PosX, m), m);
   const c0 = CARTESIAN_POINT(vec3Zero, m);
   const [c1, c2] = [cart3tr(-half.x, -half.y), cart3tr(half.x, -half.y)];
   const [c3, c4] = [cart3tr(half.x, half.y), cart3tr(-half.x, half.y)];
@@ -58,14 +70,18 @@ export function stepPlane(p: Plane, mat: Material, parentPos: Vec3, parentRot: V
     ORIENTED_EDGE(EDGE_CURVE(v4, v1, l4, m), m),
   ];
 
-  const [d1, d2] = [DIRECTION(vec3RotCombine(vec3PosX, rot), m), DIRECTION(vec3RotCombine(vec3PosZ, rot), m)];
+  APPLICATION_PROTOCOL_DEFINITION(m);
+  const applicationContext = APPLICATION_CONTEXT(m);
+
+  const normal = DIRECTION(vec3RotNormal(vec3PosZ, rot), m);
+  const up = DIRECTION(vec3PosZ, m);
 
   const color = COLOUR_RGB(parseRgb(mat.normal), m);
   const sbsm = SHELL_BASED_SURFACE_MODEL(
     OPEN_SHELL(
       ADVANCED_FACE(
         FACE_BOUND(EDGE_LOOP([oe1, oe2, oe3, oe4], m), "T", m),
-        PLANE(AXIS2_PLACEMENT_3D(c0, d2, d1, m), m),
+        PLANE(AXIS2_PLACEMENT_3D(c0, normal, up, m), m),
         m
       ),
       m
@@ -73,7 +89,7 @@ export function stepPlane(p: Plane, mat: Material, parentPos: Vec3, parentRot: V
     m
   );
 
-  MANIFOLD_SURFACE_SHAPE_REPRESENTATION(
+  const mssr = MANIFOLD_SURFACE_SHAPE_REPRESENTATION(
     AXIS2_PLACEMENT_3D(c0, DIRECTION(vec3PosZ, m), DIRECTION(vec3PosX, m), m),
     sbsm,
     m
@@ -91,4 +107,30 @@ export function stepPlane(p: Plane, mat: Material, parentPos: Vec3, parentRot: V
     ),
     m
   );
+
+  SHAPE_DEFINITION_REPRESENTATION(
+    PRODUCT_DEFINITION_SHAPE(
+      PRODUCT_DEFINITION(
+        PRODUCT_DEFINITION_FORMATION(
+          PRODUCT(
+            PRODUCT_CONTEXT(
+              applicationContext,
+              m
+            ),
+            "Plane",
+            m
+          ),
+          m
+        ),
+        PRODUCT_DEFINITION_CONTEXT(
+          applicationContext,
+          m
+        ),
+        m
+      ),
+      m
+    ),
+    mssr,
+    m
+  );
 }

package/src/renderers/step/step.ts

@@ -1,4 +1,4 @@
-import { Scene, vec3Zero, Group, Vec3, vec3TransRot, vec3RotCombine } from "../../abstract-3d.js";
+import { Scene, vec3Zero, Group, Vec3, vec3TransRot, vec3RotCombine, Cylinder, Material, Plane, Box } from "../../abstract-3d.js";
 import {
   MutableStep,
   GEOMETRIC_REPRESENTATION_CONTEXT_3D,
@@ -10,18 +10,11 @@ import {
   ENDSEC,
 } from "./step-encoding.js";
 import { stepBox } from "./step-geometries/step-box.js";
+import { stepCylinder } from "./step-geometries/step-cylinder.js";
 import { stepPlane } from "./step-geometries/step-plane.js";
 
-// export const toStep2 = (scene: A3D.Scene): string => {
-//   const start = performance.now();
-//   for (let i = 0; i < 100; i++) {
-//     toStep(scene);
-//   }
-//   console.log((performance.now() - start) / 100);
-//   return "";
-// };
-
 export const toStep = (scene: Scene): string => {
+
   const m: MutableStep = { refs: new Map<string, number>([]), step: "" };
   GEOMETRIC_REPRESENTATION_CONTEXT_3D(
     // 1
@@ -36,11 +29,12 @@ export const toStep = (scene: Scene): string => {
   for (const g of scene.groups) {
     stepGroup(g, scene.center_deprecated ?? vec3Zero, scene.rotation_deprecated ?? vec3Zero, m);
   }
-
+  
   return `${HEADER()}${m.step}${ENDSEC()}`;
 };
 
 function stepGroup(g: Group, parentPos: Vec3, parentRot: Vec3, m: MutableStep): void {
+
   const pos = vec3TransRot(g.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, g.rot ?? vec3Zero);
   for (const mesh of g.meshes ?? []) {
@@ -51,6 +45,9 @@ function stepGroup(g: Group, parentPos: Vec3, parentRot: Vec3, m: MutableStep):
       case "Plane":
         stepPlane(mesh.geometry, mesh.material, pos, rot, m);
         break;
+      case "Cylinder":
+        stepCylinder(mesh.geometry, mesh.material, pos, rot, m);
+        break;
       default:
         break;
     }