@code3d/core 0.0.1-alpha.0 → 0.0.1-alpha.3

package/src/library/sketch-solver.ts

@@ -1,4 +1,6 @@
-import type {GcsSystem, ModuleStatic} from '@salusoft89/planegcs';
+import type {GcsSystem} from '@salusoft89/planegcs/dist/planegcs_dist/gcs_system.js';
+// Upstream ships this declaration alongside sources, but omits it from dist.
+import type {ModuleStatic} from '@salusoft89/planegcs/planegcs_dist/planegcs.js';
 import type {SketchArcDirection, SketchPosition} from './sketch.js';
 import {sketchArcGeometry} from './sketch-curves.js';
 import {pointLineDistance} from './sketch-incidence.js';

package/src/library/sketch.ts

@@ -6,9 +6,11 @@ import {
 import {solveSketchDrag} from './sketch-drag-rules.js';
 import {sketchRegions} from './sketch-regions.js';
 import {
-  sketchFaceModel,
+  SketchFrame,
   disposeModelObjects,
   isModelObject,
+  type Constraint,
+  type FaceAnchor,
   type FaceModel,
 } from './runtime.js';
 import {
@@ -85,6 +87,10 @@ export type SketchOptions = Readonly<{
 
 /** An immutable sketch definition, independent of B-Rep construction. */
 export interface Sketch {
+  /** The unbounded local XZ plane (+Y normal), independent of closed regions. */
+  readonly plane: FaceAnchor;
+  /** Relates this immutable sketch's frame without changing its two-dimensional data. */
+  relate(build: (self: Sketch) => Constraint | readonly Constraint[]): Sketch;
   /** References a point defined in this layer. */
   point(id: number): SketchPoint;
   /** Adds a local layer while retaining the upstream sketch as read-only input. */
@@ -112,11 +118,26 @@ const definitions = new WeakMap<Sketch, Definition>();
 const references = new WeakSet<SketchPoint>();
 
 class SketchValue implements Sketch {
+  readonly frame: SketchFrame;
+  readonly source?: Sketch;
+
   constructor(
-    entries?: readonly SketchEntry[],
-    options?: SketchOptions,
-    base?: Sketch,
+    input:
+      | {
+          entries?: readonly SketchEntry[];
+          options?: SketchOptions;
+          base?: Sketch;
+        }
+      | {source: Sketch; frame: SketchFrame},
   ) {
+    if ('source' in input) {
+      this.frame = input.frame;
+      this.source = input.source;
+      definitions.set(this, definitions.get(input.source)!);
+      return;
+    }
+    const {entries, options, base} = input;
+    this.frame = new SketchFrame(base && (base as SketchValue).frame);
     const ids = new Set<number>();
     const points = new Map<number, SketchPosition>();
     const copied = (entries ?? []).map<SketchEntry>(entry => {
@@ -164,6 +185,10 @@ class SketchValue implements Sketch {
       ancestor = definitions.get(ancestor)?.base
     )
       ancestors.add(ancestor);
+    const ancestorFor = (value: Sketch) =>
+      [...ancestors].find(
+        ancestor => definitions.get(ancestor) === definitions.get(value),
+      );
     for (const [kind, id, data] of copied) {
       if (kind === 'point' && Array.isArray(data)) continue;
       const refs =
@@ -180,7 +205,7 @@ class SketchValue implements Sketch {
             throw new Error(
               `Sketch ${kind} ${id} references missing local point ${ref}.`,
             );
-        } else if (!references.has(ref) || !ancestors.has(ref.sketch)) {
+        } else if (!references.has(ref) || !ancestorFor(ref.sketch)) {
           throw new Error(
             `Sketch ${kind} ${id} must reference a local or upstream point.`,
           );
@@ -209,7 +234,7 @@ class SketchValue implements Sketch {
       if (
         typeof ref === 'number'
           ? !points.has(ref)
-          : !references.has(ref) || !ancestors.has(ref.sketch)
+          : !references.has(ref) || !ancestorFor(ref.sketch)
       )
         throw new Error(
           'Sketch constraints must reference a local or upstream point.',
@@ -304,6 +329,7 @@ class SketchValue implements Sketch {
     const local = 'local';
     const layers = new Map<Sketch, string>();
     const identity = (value: Sketch) => {
+      value = ancestorFor(value) ?? value;
       let id = layers.get(value);
       if (!id) layers.set(value, (id = `upstream:${layers.size}`));
       return id;
@@ -345,8 +371,21 @@ class SketchValue implements Sketch {
     return ref;
   }
 
+  get plane(): FaceAnchor {
+    return this.frame.plane;
+  }
+
+  relate(build: (self: Sketch) => Constraint | readonly Constraint[]): Sketch {
+    let related!: SketchValue;
+    this.frame.relate(frame => {
+      related = new SketchValue({source: this, frame});
+      return build(related);
+    });
+    return related;
+  }
+
   derive(entries?: readonly SketchEntry[], options?: SketchOptions): Sketch {
-    return new SketchValue(entries, options, this);
+    return new SketchValue({entries, options, base: this});
   }
 
   face(): FaceModel {
@@ -355,14 +394,14 @@ class SketchValue implements Sketch {
       throw new Error(
         `sketch.face() requires exactly one closed region; found ${regions.length}. Use faces() for multiple regions.`,
       );
-    return sketchFaceModel(regions[0]);
+    return this.frame.face(regions[0]);
   }
 
   faces(): readonly FaceModel[] {
     const faces: FaceModel[] = [];
     try {
       for (const region of sketchRegions(this.layers()))
-        faces.push(sketchFaceModel(region));
+        faces.push(this.frame.face(region));
       return faces;
     } catch (error) {
       disposeModelObjects(
@@ -381,7 +420,13 @@ class SketchValue implements Sketch {
     )
       values.unshift(value);
     return values.map(value =>
-      snapshotSketch(value, s => String(values.indexOf(s))),
+      snapshotSketch(value, s =>
+        String(
+          values.findIndex(
+            value => definitions.get(value) === definitions.get(s),
+          ),
+        ),
+      ),
     );
   }
 }
@@ -391,7 +436,7 @@ export function sketch(
   entries?: readonly SketchEntry[],
   options?: SketchOptions,
 ): Sketch {
-  return new SketchValue(entries, options);
+  return new SketchValue({entries, options});
 }
 
 export function isSketch(value: unknown): value is Sketch {
@@ -402,6 +447,16 @@ export function sketchDefinition(value: Sketch): Definition {
   return definitions.get(value)!;
 }
 
+/** The preceding spatial value; it shares a geometry definition, not a derived layer. */
+export function sketchSource(value: Sketch): Sketch | undefined {
+  return (value as SketchValue).source;
+}
+
+/** The relation frame used by this sketch and inherited by its generated faces. */
+export function sketchFrame(value: Sketch): SketchFrame {
+  return (value as SketchValue).frame;
+}
+
 export type SketchPointSnapshot = Readonly<{
   kind: 'point';
   id: number;
@@ -497,17 +552,30 @@ export function snapshotSketch(
     redundant,
   } = sketchDefinition(value);
   const id = identity(value);
+  const ancestors: Sketch[] = [];
+  for (
+    let ancestor = base;
+    ancestor;
+    ancestor = sketchDefinition(ancestor).base
+  )
+    ancestors.push(ancestor);
+  const pointIdentity = (reference: Sketch) =>
+    identity(
+      ancestors.find(
+        ancestor => definitions.get(ancestor) === definitions.get(reference),
+      ) ?? reference,
+    );
   return {
     id,
     base: base && identity(base),
-    entities: snapshotEntries(entries, id, identity, points).map(e =>
+    entities: snapshotEntries(entries, id, pointIdentity, points).map(e =>
       e.kind === 'point'
         ? {...e, position: points.get(e.id)!}
         : e.kind === 'circle' || e.kind === 'arc'
           ? {...e, radius: radii.get(e.id)!}
           : e,
     ),
-    constraints: snapshotConstraints(constraints, id, identity),
+    constraints: snapshotConstraints(constraints, id, pointIdentity),
     degreesOfFreedom,
     redundant,
   };

package/src/library/text.ts

@@ -0,0 +1,477 @@
+import {
+  BlueprintSketcher,
+  getOC,
+  type Blueprint,
+  type Face,
+  type Wire,
+  type Point2D,
+} from 'replicad';
+import {castOwnedShape} from './kernel-shapes.js';
+import type * as hb from 'harfbuzzjs';
+import {boolean as combinePaths} from 'flo-boolean';
+import {fontParts, shapeFontText, type Font, type FontPart} from './font.js';
+import {cachedArtifact} from './cached.js';
+import {kernelOperationKey, type KernelArtifact} from './kernel-cache.js';
+
+export type TextOptions = Readonly<{
+  /** Extra model-unit spacing between glyphs, including spaces. Defaults to 0; may be negative. */
+  letterSpacing?: number;
+  /** Apply the font's kerning pairs. Defaults to true. */
+  kerning?: boolean;
+}>;
+
+export type PathCommand =
+  | {type: 'M'; x: number; y: number}
+  | {type: 'L'; x: number; y: number}
+  | {type: 'Q'; x1: number; y1: number; x: number; y: number}
+  | {
+      type: 'C';
+      x1: number;
+      y1: number;
+      x2: number;
+      y2: number;
+      x: number;
+      y: number;
+    }
+  | {type: 'Z'};
+type Contour = readonly PathCommand[];
+type Region = readonly Contour[];
+type Glyph = Readonly<{
+  regions: KernelArtifact<readonly Region[]>;
+  x: number;
+  y: number;
+}>;
+
+/** Layout shares a baseline at (0, 0, 0); spaces advance without creating faces. */
+export function textGlyphs(
+  content: string,
+  font: Font,
+  size: number,
+  options: TextOptions = {},
+): readonly Glyph[] {
+  if (!Number.isFinite(size) || size <= 0)
+    throw new Error('Text size must be finite and greater than zero.');
+  if (typeof content !== 'string')
+    throw new Error('Text content must be a string.');
+  const letterSpacing = options.letterSpacing ?? 0;
+  if (!Number.isFinite(letterSpacing))
+    throw new Error('Text letter spacing must be finite.');
+  if (/[\r\n\t]/u.test(content))
+    throw new Error(
+      'text() supports one line; position separate text() calls for multiple lines.',
+    );
+  const parts = fontParts(font);
+  const runs: {part: FontPart; content: string}[] = [];
+  for (const character of content) {
+    const code = character.codePointAt(0)!;
+    const part = parts.find(
+      ({artifact, ranges}) =>
+        (!ranges.length ||
+          ranges.some(([start, end]) => code >= start && code <= end)) &&
+        artifact.value.font.nominalGlyph(code),
+    );
+    if (!part) {
+      throw new Error(
+        `Font ${font.family} has no glyph for ${JSON.stringify(character)} (U+${code.toString(16).toUpperCase()}).`,
+      );
+    }
+    const previous = runs.at(-1);
+    if (previous?.part === part) previous.content += character;
+    else runs.push({part, content: character});
+  }
+  const glyphs: Glyph[] = [];
+  let advanceX = 0;
+  let advanceY = 0;
+  for (const {part, content: run} of runs) {
+    const resource = part.artifact;
+    const parsed = resource.value;
+    const scale = size / parsed.face.upem;
+    const {infos, positions} = shapeFontText(
+      parsed.font,
+      run,
+      options.kerning ?? true,
+    );
+    infos.forEach((info, index) => {
+      const position = positions[index];
+      const regions = textGlyph(resource, info.codepoint, size);
+      glyphs.push({
+        regions,
+        x: advanceX + position.xOffset * scale + glyphs.length * letterSpacing,
+        y: -advanceY - position.yOffset * scale,
+      });
+      advanceX += position.xAdvance * scale;
+      advanceY += position.yAdvance * scale;
+    });
+  }
+  return glyphs;
+}
+
+const textGlyph = cachedArtifact(
+  (
+    resource: FontPart['artifact'],
+    codepoint: number,
+    size: number,
+  ): readonly Region[] =>
+    groupTextContours(
+      splitContours(
+        resource.value.font
+          .glyphToJson(codepoint)
+          .map(command =>
+            scaledCommand(command, size / resource.value.face.upem),
+          ),
+      ),
+    ),
+  {
+    key: (resource, codepoint, size) =>
+      kernelOperationKey('textGlyph', [codepoint, size], [resource]),
+  },
+);
+
+function scaledCommand(
+  {type, values}: hb.SvgPathCommand,
+  scale: number,
+): PathCommand {
+  const [x1, y1, x2, y2, x, y] = values.map(
+    (value, index) => value * scale * (index % 2 ? -1 : 1),
+  );
+  switch (type) {
+    case 'M':
+    case 'L':
+      return {type, x: x1, y: y1};
+    case 'Q':
+      return {type, x1, y1, x: x2, y: y2};
+    case 'C':
+      return {type, x1, y1, x2, y2, x, y};
+    case 'Z':
+      return {type};
+    default:
+      throw new Error(`Unsupported glyph path command: ${type}`);
+  }
+}
+
+function splitContours(commands: readonly PathCommand[]): readonly Contour[] {
+  const contours: PathCommand[][] = [];
+  let contour: PathCommand[] | undefined;
+  for (const command of commands) {
+    if (command.type === 'M') {
+      contour = [];
+      contours.push(contour);
+    }
+    if (!contour)
+      throw new Error('A font contour must start with a move command.');
+    contour.push(command);
+    if (command.type === 'Z') contour = undefined;
+  }
+  if (contour) throw new Error('A font contour must be closed.');
+  return contours.filter(contour => contour.length > 2);
+}
+
+function blueprint(contour: Contour, x = 0, y = 0): Blueprint {
+  const start = contour[0];
+  if (start?.type !== 'M')
+    throw new Error('A font contour must start with a move command.');
+  const sketcher = new BlueprintSketcher([start.x + x, -start.y - y]);
+  try {
+    let previous = start;
+    for (const command of contour.slice(1)) {
+      if (command.type === 'Z') return sketcher.close();
+      if (command.type === 'M')
+        throw new Error('Unexpected move inside a font contour.');
+      const end: [number, number] = [command.x + x, -command.y - y];
+      if (command.type === 'L') {
+        if (command.x !== previous.x || command.y !== previous.y)
+          sketcher.lineTo(end);
+      } else if (command.type === 'Q') {
+        sketcher.quadraticBezierCurveTo(end, [command.x1 + x, -command.y1 - y]);
+      } else {
+        sketcher.cubicBezierCurveTo(
+          end,
+          [command.x1 + x, -command.y1 - y],
+          [command.x2 + x, -command.y2 - y],
+        );
+      }
+      previous = {type: 'M', x: command.x, y: command.y};
+    }
+    throw new Error('A font contour must be closed.');
+  } catch (error) {
+    deleteBlueprint(sketcher.done());
+    throw error;
+  }
+}
+
+/**
+ * Work around Replicad #278 without relying on contour order. Every boundary
+ * belongs to its nearest containing boundary; even depths are filled islands.
+ * Overlapping outlines are first combined with the font non-zero fill rule.
+ */
+export function groupTextContours(
+  contours: readonly Contour[],
+): readonly Region[] {
+  const blueprints: Blueprint[] = [];
+  try {
+    for (const contour of contours) blueprints.push(blueprint(contour));
+    if (
+      blueprints.some((a, i) =>
+        blueprints.slice(i + 1).some(b => contoursIntersect(a, b)),
+      )
+    ) {
+      blueprints.splice(0).forEach(deleteBlueprint);
+      contours = combineContours(contours);
+      for (const contour of contours) blueprints.push(blueprint(contour));
+    }
+    const contains = blueprints.map(() => new Set<number>());
+    for (let i = 0; i < blueprints.length; i++) {
+      for (let j = i + 1; j < blueprints.length; j++) {
+        const a = blueprints[i],
+          b = blueprints[j];
+        if (containsPoint(a, b.firstPoint)) contains[j].add(i);
+        if (containsPoint(b, a.firstPoint)) contains[i].add(j);
+      }
+    }
+    const parents = contains.map(
+      containers =>
+        [...containers].sort((a, b) => contains[b].size - contains[a].size)[0],
+    );
+    return contours.flatMap((outer, index) =>
+      contains[index].size % 2
+        ? []
+        : [[outer, ...contours.filter((_, hole) => parents[hole] === index)]],
+    );
+  } finally {
+    blueprints.forEach(deleteBlueprint);
+  }
+}
+
+/** Keep quadratic/cubic Beziers; no polygon flattening or SVG rounding. */
+function combineContours(contours: readonly Contour[]): readonly Contour[] {
+  const paths = contours.map(contour => {
+    const curves: number[][][] = [];
+    let start: number[] = [];
+    let previous: number[] = [];
+    for (const command of contour) {
+      if (command.type === 'M') {
+        start = previous = [command.x, command.y];
+        continue;
+      }
+      if (command.type === 'Z') {
+        if (previous[0] !== start[0] || previous[1] !== start[1])
+          curves.push([previous, start]);
+        continue;
+      }
+      const end = [command.x, command.y];
+      if (command.type === 'L') curves.push([previous, end]);
+      else if (command.type === 'Q')
+        curves.push([previous, [command.x1, command.y1], end]);
+      else
+        curves.push([
+          previous,
+          [command.x1, command.y1],
+          [command.x2, command.y2],
+          end,
+        ]);
+      previous = end;
+    }
+    return curves;
+  });
+  return combinePaths('OR', paths, {minLoopArea: 0})
+    .filter(loop => loop.length)
+    .map(loop => {
+      const [x, y] = loop[0][0];
+      const commands: PathCommand[] = [{type: 'M', x, y}];
+      for (const curve of loop) {
+        const [x, y] = curve.at(-1)!;
+        if (curve.length === 2) commands.push({type: 'L', x, y});
+        else if (curve.length === 3)
+          commands.push({type: 'Q', x1: curve[1][0], y1: curve[1][1], x, y});
+        else
+          commands.push({
+            type: 'C',
+            x1: curve[1][0],
+            y1: curve[1][1],
+            x2: curve[2][0],
+            y2: curve[2][1],
+            x,
+            y,
+          });
+      }
+      commands.push({type: 'Z'});
+      return commands;
+    });
+}
+
+/** Blueprint.delete() does not release cached per-curve bounds. */
+function deleteBlueprint(value: Blueprint): void {
+  for (const curve of value.curves) {
+    curve._boundingBox?.delete();
+    curve._boundingBox = null;
+  }
+  value.delete();
+}
+
+function contoursIntersect(a: Blueprint, b: Blueprint): boolean {
+  if (a.boundingBox.isOut(b.boundingBox)) return false;
+  const intersector = new (getOC().Geom2dAPI_InterCurveCurve)();
+  try {
+    for (const first of a.curves)
+      for (const second of b.curves) {
+        if (first.boundingBox.isOut(second.boundingBox)) continue;
+        intersector.Init(first.wrapped, second.wrapped, 1e-9);
+        if (intersector.NbPoints() || intersector.NbSegments()) return true;
+      }
+    return false;
+  } finally {
+    intersector.delete();
+  }
+}
+
+function containsPoint(contour: Blueprint, point: Point2D): boolean {
+  const [min, max] = contour.boundingBox.bounds;
+  if (
+    point[0] < min[0] ||
+    point[0] > max[0] ||
+    point[1] < min[1] ||
+    point[1] > max[1]
+  )
+    return false;
+  const span = Math.max(max[0] - min[0], max[1] - min[1]);
+  const intersector = new (getOC().Geom2dAPI_InterCurveCurve)();
+  try {
+    // A ray through a vertex or tangent cannot be counted by intersection parity.
+    // Retry a different direction in those cases, retaining exact native curves.
+    for (let attempt = 0; attempt < 16; attempt++) {
+      const end: Point2D = [
+        max[0] + span,
+        point[1] + span * Math.sin(attempt * 2.399963229728653),
+      ];
+      const ray = new BlueprintSketcher(point).lineTo(end).done();
+      try {
+        let crossings = 0,
+          ambiguous = false;
+        for (const curve of contour.curves) {
+          intersector.Init(ray.curves[0].wrapped, curve.wrapped, 1e-9);
+          if (intersector.NbSegments()) {
+            ambiguous = true;
+            break;
+          }
+          const endpoints = [curve.firstPoint, curve.lastPoint];
+          for (let index = 1; index <= intersector.NbPoints(); index++) {
+            const hit = intersector.Point(index);
+            try {
+              if (
+                endpoints.some(
+                  p => Math.hypot(p[0] - hit.X(), p[1] - hit.Y()) < 1e-8,
+                )
+              )
+                ambiguous = true;
+            } finally {
+              hit.delete();
+            }
+          }
+          if (ambiguous) break;
+          crossings += intersector.NbPoints();
+        }
+        if (!ambiguous) return crossings % 2 === 1;
+      } finally {
+        deleteBlueprint(ray);
+      }
+    }
+    throw new Error('Could not determine containment of the font contours.');
+  } finally {
+    intersector.delete();
+  }
+}
+
+/** Own every native handle; Replicad's sketchOnPlane leaves edge builders alive. */
+export function textRegionFace(region: Region, x: number, y: number): Face {
+  const oc = getOC();
+  const blueprints: Blueprint[] = [];
+  const wires: Wire[] = [];
+  const origin = new oc.gp_Pnt(0, 0, 0);
+  const normal = new oc.gp_Dir(0, 1, 0);
+  const xDirection = new oc.gp_Dir(1, 0, 0);
+  const axis = new oc.gp_Ax2(origin, normal, xDirection);
+  const plane = new oc.gp_Pln(origin, normal);
+  try {
+    for (const contour of region) {
+      const profile = blueprint(contour, x, y);
+      blueprints.push(profile);
+      const wireBuilder = new oc.BRepBuilderAPI_MakeWire();
+      try {
+        for (const curve of profile.curves) {
+          const nativeCurve = oc.GeomLib.To3d(axis, curve.wrapped);
+          try {
+            const edgeBuilder = new oc.BRepBuilderAPI_MakeEdge(nativeCurve);
+            try {
+              const edge = edgeBuilder.Edge();
+              try {
+                wireBuilder.Add(edge);
+              } finally {
+                edge.delete();
+              }
+            } finally {
+              edgeBuilder.delete();
+            }
+          } finally {
+            nativeCurve.delete();
+          }
+        }
+        if (!wireBuilder.IsDone())
+          throw new Error('Could not connect the font contour into a wire.');
+        wires.push(castOwnedShape(wireBuilder.Wire()) as Wire);
+      } finally {
+        wireBuilder.delete();
+      }
+    }
+    const faceBuilder = new oc.BRepBuilderAPI_MakeFace(
+      plane,
+      wires[0].wrapped,
+      true,
+    );
+    try {
+      for (const hole of wires.slice(1)) faceBuilder.Add(hole.wrapped);
+      if (!faceBuilder.IsDone())
+        throw new Error('Could not create a text face.');
+      const raw = faceBuilder.Face();
+      try {
+        const fixer = new oc.ShapeFix_Face(raw);
+        try {
+          fixer.FixOrientation();
+          const face = castOwnedShape(fixer.Face()) as Face;
+          try {
+            const analyzer = new oc.BRepCheck_Analyzer(
+              face.wrapped,
+              true,
+              false,
+            );
+            try {
+              if (!analyzer.IsValid())
+                throw new Error(
+                  'The font contours do not form a valid planar face.',
+                );
+            } finally {
+              analyzer.delete();
+            }
+            return face;
+          } catch (error) {
+            face.delete();
+            throw error;
+          }
+        } finally {
+          fixer.delete();
+        }
+      } finally {
+        raw.delete();
+      }
+    } finally {
+      faceBuilder.delete();
+    }
+  } finally {
+    wires.forEach(wire => wire.delete());
+    blueprints.forEach(deleteBlueprint);
+    plane.delete();
+    axis.delete();
+    xDirection.delete();
+    normal.delete();
+    origin.delete();
+  }
+}