Link Search Menu Expand Document
OCCTSwift

Display & Presentation

These five types provide the rendering infrastructure for OCCTSwift: camera control, clipping planes, render-layer configuration, tessellated mesh extraction for Metal vertex buffers, and system font enumeration. They wrap OCCT’s Graphic3d_Camera, Graphic3d_ClipPlane, Graphic3d_ZLayerSettings, BRepMesh_IncrementalMesh / Poly_Triangulation, and Font_FontMgr respectively.

Topics

ZLayerSettings

ZLayerSettings configures a named rendering Z-layer — controlling depth testing, depth writing, polygon offset (depth bias), ray-tracing participation, culling thresholds, and the layer coordinate origin. Wraps OCCT’s Graphic3d_ZLayerSettings.

In a Metal renderer these properties map to: MTLDepthStencilDescriptor (depth test/write), depth attachment loadAction (clear depth), setDepthBias() on MTLRenderCommandEncoder (polygon offset), and render-pass ordering.

Predefined Layer IDs

Five static let constants identify the built-in layer slots. Pass these to a renderer or selector when associating objects with a layer.

public static let bottomOSD: Int32   // -5 — 2D underlay, drawn behind everything
public static let `default`: Int32   // 0  — main 3D scene layer
public static let top: Int32         // -2 — 3D overlay, inherits depth from default
public static let topmost: Int32     // -3 — 3D overlay, independent depth buffer
public static let topOSD: Int32      // -4 — 2D overlay for annotations and UI
  • OCCT: Graphic3d_ZLayerId enumeration values (Graphic3d_ZLayerId_BotOSD, Graphic3d_ZLayerId_Default, Graphic3d_ZLayerId_Top, Graphic3d_ZLayerId_Topmost, Graphic3d_ZLayerId_TopOSD).
  • Example: 
    // Place a transparent overlay object in the top OSD layer
let overlayLayerId = ZLayerSettings.topOSD

ZLayerSettings.bottomOSD

Id -5, the 2D underlay layer drawn behind everything.

ZLayerSettings.topOSD

Id -4, the 2D overlay layer for annotations and UI.

ZLayerSettings.topmost

Id -3, a 3D overlay layer with its own independent depth buffer.

PolygonOffsetMode

Controls which primitive types receive the polygon-offset (depth bias).

public enum PolygonOffsetMode: Int32, Sendable {
    case off = 0
    case fill = 1     // shaded faces
    case line = 2     // line primitives
    case point = 4    // point primitives
    case all = 7      // all types
}
  • OCCT: Aspect_PolygonOffsetMode.

PolygonOffsetMode.off

No polygon offset is applied to any primitive type.

PolygonOffsetMode.all

The polygon offset applies to fill, line and point primitives together (the bitwise union of the other three cases).

  • OCCT: Aspect_PolygonOffsetMode.

PolygonOffset

Groups the three polygon-offset parameters into a single value type.

public struct PolygonOffset: Sendable {
    public var mode: PolygonOffsetMode
    public var factor: Float
    public var units: Float
    public init(mode: PolygonOffsetMode = .off, factor: Float = 0, units: Float = 0)
}

Maps to Metal’s setDepthBias(depthBias:slopeScale:clamp:): factor → slopeScale, units → depthBias.

Field Meaning
mode Which primitive types receive the offset (PolygonOffsetMode).
factor Slope-scale term, maps to Metal’s slopeScale.
units Constant depth-bias term, maps to Metal’s depthBias.

PolygonOffset.units

ZLayerSettings.init()

Creates a new ZLayerSettings with default values.

public init()
  • OCCT: Graphic3d_ZLayerSettings default constructor.
  • Example: 
    let layer = ZLayerSettings()
layer.depthTestEnabled = true
layer.clearDepth = false

Depth

depthTestEnabled

Whether depth testing is enabled for objects in this layer.

public var depthTestEnabled: Bool { get set }
  • OCCT: Graphic3d_ZLayerSettings::SetEnableDepthTest / ToEnableDepthTest.
  • Example: 
    let layer = ZLayerSettings()
layer.depthTestEnabled = false  // always-on-top overlay

depthWriteEnabled

Whether objects in this layer write to the depth buffer.

public var depthWriteEnabled: Bool { get set }

Disable to allow subsequent layers to correctly depth-test against geometry underneath a transparent layer.

  • OCCT: Graphic3d_ZLayerSettings::SetEnableDepthWrite / ToEnableDepthWrite.
  • Example: 
    layer.depthWriteEnabled = false  // transparent layer

clearDepth

Whether the depth buffer is cleared before rendering this layer.

public var clearDepth: Bool { get set }

In Metal, maps to loadAction = .clear on the depth attachment for the layer’s render pass. Use for layers that must not test against depth accumulated by previous layers.

  • OCCT: Graphic3d_ZLayerSettings::SetClearDepth / ToClearDepth.
  • Example: 
    let topLayer = ZLayerSettings()
topLayer.clearDepth = true   // start fresh depth for this pass

Polygon Offset

polygonOffset

The polygon-offset (depth bias) parameters for this layer.

public var polygonOffset: PolygonOffset { get set }
  • OCCT: Graphic3d_ZLayerSettings::SetPolygonOffset / PolygonOffset → Graphic3d_PolygonOffset struct.
  • Example: 
    var layer = ZLayerSettings()
layer.polygonOffset = PolygonOffset(mode: .fill, factor: 1, units: 1)

setDepthOffsetPositive()

Sets a minimal positive depth offset (factor=1, units=1, mode=fill).

public func setDepthOffsetPositive()

Pushes coplanar geometry slightly away from the camera to avoid z-fighting.

  • OCCT: Graphic3d_ZLayerSettings::SetDepthOffsetPositive.
  • Example: 
    let layer = ZLayerSettings()
layer.setDepthOffsetPositive()

setDepthOffsetNegative()

Sets a minimal negative depth offset (factor=1, units=-1, mode=fill).

public func setDepthOffsetNegative()

Pulls geometry slightly toward the camera — typical use is a wireframe overlay that should render on top of a co-planar shaded surface.

  • OCCT: Graphic3d_ZLayerSettings::SetDepthOffsetNegative.
  • Example: 
    let wireLayer = ZLayerSettings()
wireLayer.setDepthOffsetNegative()

Rendering Options

isImmediate

Whether this layer is drawn after all normal layers (immediate mode).

public var isImmediate: Bool { get set }
  • OCCT: Graphic3d_ZLayerSettings::SetImmediate / IsImmediate.
  • Example: 
    layer.isImmediate = true  // draw this layer last

isRaytracable

Whether objects in this layer participate in ray tracing.

public var isRaytracable: Bool { get set }
  • OCCT: Graphic3d_ZLayerSettings::SetRaytracable / IsRaytracable.
  • Example: 
    layer.isRaytracable = false  // exclude UI overlays from ray-trace pass

useEnvironmentTexture

Whether environment texture is applied to objects in this layer.

public var useEnvironmentTexture: Bool { get set }
  • OCCT: Graphic3d_ZLayerSettings::SetEnvironmentTexture / UseEnvironmentTexture.
  • Example: 
    layer.useEnvironmentTexture = false  // flat-shaded annotation layer

renderInDepthPrepass

Whether objects in this layer are rendered in the depth pre-pass.

public var renderInDepthPrepass: Bool { get set }
  • OCCT: Graphic3d_ZLayerSettings::SetRenderInDepthPrepass / ToRenderInDepthPrepass.
  • Example: 
    layer.renderInDepthPrepass = false  // transparent objects skip depth pre-pass

Culling

cullingDistance

Distance-based culling threshold in model units.

public var cullingDistance: Double { get set }

Objects farther than this distance from the camera origin are culled from rendering. The default is a very large value (effectively disabled).

  • OCCT: Graphic3d_ZLayerSettings::SetCullingDistance / CullingDistance.
  • Example: 
    layer.cullingDistance = 5000.0  // discard objects beyond 5 km

cullingSize

Screen-space size culling threshold in pixels.

public var cullingSize: Double { get set }

Objects whose projected screen-space size falls below this threshold are culled. The default is a very large value (effectively disabled).

  • OCCT: Graphic3d_ZLayerSettings::SetCullingSize / CullingSize.
  • Example: 
    layer.cullingSize = 2.0  // discard tiny details under 2 px

Origin

origin

Layer coordinate origin for floating-point precision in large scenes.

public var origin: SIMD3<Double> { get set }

When working with very large world coordinates (e.g. geospatial), set the layer origin near the camera position. Vertex shader positions are computed relative to this origin, keeping values in a numerically safe range.

  • OCCT: Graphic3d_ZLayerSettings::SetOrigin / Origin → gp_XYZ.
  • Example: 
    layer.origin = SIMD3(500_000, 200_000, 0)  // geospatial tile offset

ClipPlane

ClipPlane defines a half-space clipping plane using the equation Ax + By + Cz + D = 0. Points satisfying Ax + By + Cz + D > 0 are considered visible. Planes can be chained for compound (AND) clipping regions. Wraps OCCT’s Graphic3d_ClipPlane.

On Apple Silicon, the equation maps directly to [[clip_distance]] in a Metal vertex shader; up to 8 hardware-accelerated clip distances are supported.

ClipState

Result of probing a point or bounding box against a clip plane (or chain).

public enum ClipState: Int32, Sendable {
    case out = 0   // fully outside — should be discarded
    case `in` = 1  // fully inside — not clipped
    case on  = 2   // on the boundary or partially clipped
}
  • OCCT: Graphic3d_ClipState (Graphic3d_ClipState_Out, Graphic3d_ClipState_In, Graphic3d_ClipState_On).
Case Meaning
out Fully outside the clipping region, should be discarded.
in Fully inside the clipping region, not clipped.
on On the boundary, or partially clipped.

(Per-case anchors below, for cross-reference; the table above has the actual meaning of each.)

ClipPlane.ClipState.out

HatchStyle

Standard cross-section hatch pattern for the capping surface.

public enum HatchStyle: Int32, Sendable {
    case solid = 0, gridDiagonal = 1, gridDiagonalWide = 2
    case grid = 3, gridWide = 4
    case diagonal45 = 5, diagonal135 = 6
    case horizontal = 7, vertical = 8
    case diagonal45Wide = 9, diagonal135Wide = 10
    case horizontalWide = 11, verticalWide = 12
}

Case meanings, from Aspect_HatchStyle (Wide corresponds to OCCT’s _SPARSE suffix: more widely spaced lines, not thicker ones):

HatchStyle.gridDiagonal

A crossed diagonal grid: lines at +45 and -45 degrees crossing each other (Aspect_HS_GRID_DIAGONAL, OCCT’s TEL_HS_CROSS).

HatchStyle.gridDiagonalWide

gridDiagonal with more widely spaced lines.

HatchStyle.grid

An orthogonal grid: horizontal and vertical lines crossing each other (Aspect_HS_GRID).

HatchStyle.gridWide

grid with more widely spaced lines.

HatchStyle.diagonal45

Parallel lines at +45 degrees.

HatchStyle.diagonal135

Parallel lines at +135 degrees (perpendicular to diagonal45).

HatchStyle.horizontal

Parallel horizontal lines.

HatchStyle.vertical

Parallel vertical lines.

HatchStyle.diagonal45Wide

diagonal45 with more widely spaced lines.

HatchStyle.diagonal135Wide

diagonal135 with more widely spaced lines.

HatchStyle.horizontalWide

horizontal with more widely spaced lines.

HatchStyle.verticalWide

vertical with more widely spaced lines.

  • OCCT: Aspect_HatchStyle.

ClipPlane.init(equation:)

Creates a clip plane from the four equation coefficients.

public init(equation: SIMD4<Double>)
  • Parameters: equation — (A, B, C, D) such that Ax + By + Cz + D = 0.
  • OCCT: Graphic3d_ClipPlane(Graphic3d_Vec4d(A, B, C, D)).
  • Example: 
    // Clip everything below z = 5
let plane = ClipPlane(equation: SIMD4(0, 0, 1, -5))

ClipPlane.init(normal:distance:)

Creates a clip plane from a normal vector and signed distance from origin.

public init(normal: SIMD3<Double>, distance: Double)

The stored equation is normal.x·x + normal.y·y + normal.z·z + distance = 0.

  • Parameters: normal — plane normal (used as-is, should be normalized); distance — signed distance from origin along the normal.
  • OCCT: Graphic3d_ClipPlane(Graphic3d_Vec4d(nx, ny, nz, distance)).
  • Example: 
    let plane = ClipPlane(normal: SIMD3(0, 0, 1), distance: -5)
// Clips everything below z = 5

Equation

equation

The plane equation coefficients (A, B, C, D).

public var equation: SIMD4<Double> { get set }
  • OCCT: Graphic3d_ClipPlane::SetEquation / GetEquation.
  • Example: 
    var plane = ClipPlane(equation: SIMD4(0, 0, 1, -10))
plane.equation = SIMD4(0, 0, 1, -20)  // move cut to z = 20

reversedEquation

The negated plane equation, useful for back-face clipping.

public var reversedEquation: SIMD4<Double> { get }
  • OCCT: Graphic3d_ClipPlane::ReversedEquation.
  • Example: 
    let rev = plane.reversedEquation  // (-A, -B, -C, -D)

Enable/Disable

isOn

Whether this clip plane is active.

public var isOn: Bool { get set }
  • OCCT: Graphic3d_ClipPlane::SetOn / IsOn.
  • Example: 
    plane.isOn = false  // temporarily disable without destroying

Capping

isCapping

Whether a filled cross-section surface (cap) is rendered at the cut.

public var isCapping: Bool { get set }

In Metal, implemented via the stencil-buffer technique: back faces increment, front faces decrement, fill where stencil ≠ 0.

  • OCCT: Graphic3d_ClipPlane::SetCapping / IsCapping.
  • Example: 
    plane.isCapping = true
plane.cappingColor = SIMD3(0.8, 0.8, 0.9)

cappingColor

The RGB fill color of the capping surface (components in 0…1).

public var cappingColor: SIMD3<Double> { get set }
  • OCCT: Graphic3d_ClipPlane::SetCappingColor(Quantity_Color) / CappingAspect()->InteriorColor().
  • Example: 
    plane.cappingColor = SIMD3(0.9, 0.9, 0.6)

hatchStyle

The hatch pattern drawn on the capping surface.

public var hatchStyle: HatchStyle { get set }
  • OCCT: Graphic3d_ClipPlane::SetCappingHatch(Aspect_HatchStyle) / CappingHatch.
  • Example: 
    plane.hatchStyle = .diagonal45
plane.isHatchOn = true

isHatchOn

Whether the hatch pattern is rendered on the capping surface.

public var isHatchOn: Bool { get set }
  • OCCT: Graphic3d_ClipPlane::SetCappingHatchOn / SetCappingHatchOff / IsHatchOn.
  • Example: 
    plane.isHatchOn = true

Probing

probe(point:)

Tests a world-space point against the clip plane (or chain of planes).

public func probe(point: SIMD3<Double>) -> ClipState

Iterates the full chain; returns .out immediately if any plane discards the point, .on if at least one plane is on the boundary, .in if all planes accept it.

  • Parameters: point — 3D world-space point to test.
  • Returns: The aggregate ClipState across the chain.
  • OCCT: Graphic3d_ClipPlane::ProbePointHalfspace per plane in the chain.
  • Example: 
    let state = plane.probe(point: SIMD3(0, 0, 3))
if state == .out { /* point is clipped */ }

probe(box:)

Tests an axis-aligned bounding box against the clip plane (or chain of planes).

public func probe(box: (min: SIMD3<Double>, max: SIMD3<Double>)) -> ClipState
  • Parameters: box — AABB defined by (min, max) corners.
  • Returns: .out if fully clipped, .in if fully inside, .on if partially intersected.
  • OCCT: Graphic3d_ClipPlane::ProbeBoxHalfspace (using Graphic3d_BndBox3d) per plane in the chain.
  • Example: 
    let box = shape.bounds
let state = plane.probe(box: box)
if state == .in { /* entire bounding box is visible */ }

Chaining

chainNext(_:)

Chains another clip plane for logical AND clipping.

public func chainNext(_ plane: ClipPlane?)

When planes are chained, a point or box must satisfy all planes in the chain to be considered visible. Pass nil to clear the chain.

  • Parameters: plane — the next ClipPlane in the chain, or nil to detach.
  • OCCT: Graphic3d_ClipPlane::SetChainNextPlane.
  • Example: 
    let planeA = ClipPlane(normal: SIMD3(0, 0, 1), distance: -5)
let planeB = ClipPlane(normal: SIMD3(0, 0, -1), distance: 10)
planeA.chainNext(planeB)  // visible only between z=5 and z=10

chainLength

The number of planes in the forward chain, including this one.

public var chainLength: Int { get }
  • OCCT: Graphic3d_ClipPlane::NbChainNextPlanes (returns the count of subsequent planes; OCCTSwift adds 1 to include the head).
  • Example: 
    #expect(planeA.chainLength == 2)  // head + one chained plane

Camera

Camera is a 3D camera backed by Graphic3d_Camera. It exposes standard perspective/orthographic projection controls and produces Metal-compatible matrices (column-major, zero-to-one depth range via SetZeroToOneDepth). Obtain a Camera with Camera() and set its position/target before reading the matrices.

ProjectionType

The camera projection mode.

public enum ProjectionType: Int32, Sendable {
    case perspective  = 0
    case orthographic = 1
}
  • OCCT: Graphic3d_Camera::Projection_Perspective / Projection_Orthographic.

Camera.ProjectionType.perspective

Objects farther from the camera appear smaller (standard vanishing-point projection).

Camera.ProjectionType.orthographic

No perspective foreshortening; parallel lines in world space stay parallel in the projection.

  • OCCT: Graphic3d_Camera::Projection_Perspective / Projection_Orthographic.

Camera.init()

Creates a camera with default settings and zero-to-one depth range.

public init()

The underlying Graphic3d_Camera is created with SetZeroToOneDepth(true) so its projection matrix is directly usable in Metal shaders without remapping.

  • OCCT: new Graphic3d_Camera() + SetZeroToOneDepth(Standard_True).
  • Example: 
    let cam = Camera()
cam.eye = SIMD3(0, -100, 50)
cam.center = SIMD3(0, 0, 0)
cam.up = SIMD3(0, 0, 1)

Position

eye

Camera eye (observer) position in world coordinates.

public var eye: SIMD3<Double> { get set }
  • OCCT: Graphic3d_Camera::SetEye(gp_Pnt) / Eye().
  • Example: 
    cam.eye = SIMD3(0, -200, 100)

center

Camera look-at target in world coordinates.

public var center: SIMD3<Double> { get set }
  • OCCT: Graphic3d_Camera::SetCenter(gp_Pnt) / Center().
  • Example: 
    cam.center = SIMD3(0, 0, 0)

up

Camera up direction vector.

public var up: SIMD3<Double> { get set }
  • OCCT: Graphic3d_Camera::SetUp(gp_Dir) / Up().
  • Example: 
    cam.up = SIMD3(0, 0, 1)  // Z-up

Projection Parameters

projectionType

The projection mode (perspective or orthographic).

public var projectionType: ProjectionType { get set }
  • OCCT: Graphic3d_Camera::SetProjectionType / ProjectionType.
  • Example: 
    cam.projectionType = .orthographic

fieldOfView

Vertical field of view in degrees (perspective mode only).

public var fieldOfView: Double { get set }
  • OCCT: Graphic3d_Camera::SetFOVy(degrees) / FOVy().
  • Example: 
    cam.fieldOfView = 60.0

scale

Camera scale factor (orthographic mode only).

public var scale: Double { get set }

Controls the orthographic view volume size. Larger values zoom out.

  • OCCT: Graphic3d_Camera::SetScale / Scale.
  • Example: 
    cam.projectionType = .orthographic
cam.scale = 200.0  // view 200 model units tall

zRange

Near and far clipping plane distances.

public var zRange: (near: Double, far: Double) { get set }
  • OCCT: Graphic3d_Camera::SetZRange(near, far) / ZNear() + ZFar().
  • Example: 
    cam.zRange = (near: 0.1, far: 10_000)

aspect

Viewport aspect ratio (width / height).

public var aspect: Double { get set }

Update whenever the drawable size changes.

  • OCCT: Graphic3d_Camera::SetAspect / Aspect.
  • Example: 
    cam.aspect = Double(viewportWidth) / Double(viewportHeight)

Matrices (Metal-compatible, column-major, [0,1] depth)

projectionMatrix

Projection matrix as a column-major simd_float4x4 with Metal [0,1] depth range.

public var projectionMatrix: simd_float4x4 { get }

Uses Graphic3d_Camera::ProjectionMatrixF(). The zero-to-one depth range is set at construction; no further remapping is needed in the vertex shader.

  • OCCT: Graphic3d_Camera::ProjectionMatrixF() → Graphic3d_Mat4.
  • Example: 
    var uniforms = MyUniforms()
uniforms.projectionMatrix = cam.projectionMatrix

viewMatrix

View (camera/orientation) matrix as a column-major simd_float4x4.

public var viewMatrix: simd_float4x4 { get }
  • OCCT: Graphic3d_Camera::OrientationMatrixF() → Graphic3d_Mat4.
  • Example: 
    uniforms.viewMatrix = cam.viewMatrix

Coordinate Conversion

project(_:)

Projects a world-space point to normalized screen coordinates.

public func project(_ point: SIMD3<Double>) -> SIMD3<Double>

Returns zero on error (null camera or projection exception).

  • Parameters: point — world-space 3D point.
  • Returns: Normalized device coordinates (x, y, z).
  • OCCT: Graphic3d_Camera::Project(gp_Pnt).
  • Example: 
    let ndc = cam.project(SIMD3(10, 0, 0))

unproject(_:)

Unprojects a screen-space point to world coordinates.

public func unproject(_ point: SIMD3<Double>) -> SIMD3<Double>

Inverse of project(_:). Returns zero on error.

  • Parameters: point — normalized device coordinates.
  • Returns: World-space 3D point.
  • OCCT: Graphic3d_Camera::UnProject(gp_Pnt).
  • Example: 
    let worldPt = cam.unproject(SIMD3(0, 0, 0.5))

Fitting

fit(boundingBox:)

Adjusts the camera to fit the given axis-aligned bounding box in view.

public func fit(boundingBox: (min: SIMD3<Double>, max: SIMD3<Double>))

Calls FitMinMax with a 1% margin (0.01). After calling this, eye, center, and the z-range are updated.

  • Parameters: boundingBox — AABB to fit, as (min, max) corners.
  • OCCT: Graphic3d_Camera::FitMinMax(Bnd_Box, margin, adjustZPlanes).
  • Example: 
    let box = myShape.bounds
cam.fit(boundingBox: box)
let proj = cam.projectionMatrix
let view = cam.viewMatrix

PresentationMesh (Shape extension)

Four methods on Shape extract GPU-ready mesh data by tessellating the shape’s B-Rep geometry. Triangulation is performed on demand using BRepMesh_IncrementalMesh; the output structs (ShadedMeshData, EdgeMeshData) are directly usable as Metal vertex/index buffer sources.

ShadedMeshData

Interleaved triangle mesh suitable for Metal vertex buffers.

public struct ShadedMeshData: Sendable {
    public let vertices: [SIMD3<Float>]       // per-vertex positions
    public let normals: [SIMD3<Float>]         // per-vertex normals (same count)
    public let indices: [UInt32]               // 3 indices per triangle
    public var triangleCount: Int { get }      // indices.count / 3
}

Positions and normals are stored in parallel arrays (not interleaved). Normals are derived from Poly_Triangulation::Normal(i) when available, or computed from triangle cross-products and normalized by accumulation.

EdgeMeshData

Wireframe edge polyline data suitable for Metal line rendering.

public struct EdgeMeshData: Sendable {
    public let vertices: [SIMD3<Float>]     // all polyline vertices
    public let segmentStarts: [Int]          // start index of each edge polyline
    public var segmentCount: Int { get }     // segmentStarts.count
}

Segment i spans vertices[segmentStarts[i] ..< segmentStarts[i+1]] (the array has a sentinel appended internally). Edges are de-duplicated via TopTools_IndexedMapOfShape.

EdgeMeshData.segmentStarts

Start index, into vertices, of each edge’s polyline; one entry per edge plus a trailing sentinel equal to vertices.count.

Shape.shadedMesh(deflection:)

Extracts a triangulated shaded mesh from the shape.

func shadedMesh(deflection: Double = 0.1) -> ShadedMeshData?
  • Parameters: deflection — chord deviation tolerance. Smaller values produce finer meshes (default 0.1).
  • Returns: ShadedMeshData, or nil if tessellation fails or produces no triangles.
  • OCCT: BRepMesh_IncrementalMesh::Perform + TopExp_Explorer(TopAbs_FACE) + BRep_Tool::Triangulation + Poly_Triangulation.
  • Example: 
    let box = Shape.box(width: 10, height: 10, depth: 10)!
if let mesh = box.shadedMesh(deflection: 0.05) {
    print(mesh.triangleCount)   // fine mesh
    // upload mesh.vertices / mesh.normals / mesh.indices to MTLBuffer
}

Shape.edgeMesh(deflection:)

Extracts wireframe edge polylines from the shape.

func edgeMesh(deflection: Double = 0.1) -> EdgeMeshData?
  • Parameters: deflection — chord deviation tolerance (default 0.1).
  • Returns: EdgeMeshData, or nil if extraction fails or produces no vertices.
  • OCCT: BRepMesh_IncrementalMesh::Perform + TopTools_IndexedMapOfShape + BRep_Tool::PolygonOnTriangulation / Polygon3D / GCPnts_TangentialDeflection (fallback).
  • Example: 
    if let wf = box.edgeMesh(deflection: 0.1) {
    print(wf.segmentCount)  // one segment per unique edge
}

Shape.shadedMesh(drawer:)

Extracts a triangulated shaded mesh using a DisplayDrawer for tessellation control.

func shadedMesh(drawer: DisplayDrawer) -> ShadedMeshData?

Uses the drawer’s deflection type (relative or absolute), deviation coefficient/angle, giving fine-grained tessellation quality per-object rather than a fixed global deflection.

  • Parameters: drawer — a configured DisplayDrawer whose properties drive BRepMesh_IncrementalMesh.
  • Returns: ShadedMeshData, or nil on failure.
  • OCCT: BRepMesh_IncrementalMesh(shape, deflection, Standard_False, angle) with deflection/angle read from Prs3d_Drawer.
  • Example: 
    let drawer = DisplayDrawer()
drawer.deviationCoefficient = 0.0002
if let mesh = shape.shadedMesh(drawer: drawer) {
    // high-quality tessellation
}

Shape.edgeMesh(drawer:)

Extracts wireframe edge polylines using a DisplayDrawer for tessellation control.

func edgeMesh(drawer: DisplayDrawer) -> EdgeMeshData?
  • Parameters: drawer — a configured DisplayDrawer.
  • Returns: EdgeMeshData, or nil on failure.
  • OCCT: BRepMesh_IncrementalMesh(shape, deflection, Standard_False, angle) + BRep_Tool::PolygonOnTriangulation.
  • Example: 
    if let wf = shape.edgeMesh(drawer: drawer) {
    print(wf.segmentCount)
}

FontManager

FontManager is a namespace (enum with no cases) wrapping Font_FontMgr, OCCT’s system font registry. Call initDatabase() once before querying; subsequent calls refresh the list.

FontAspect

Font style/weight variant.

public enum FontAspect: Int32, Sendable {
    case regular    = 0
    case bold       = 1
    case italic     = 2
    case boldItalic = 3
    public var name: String { get }   // human-readable string via OCCT
}
  • OCCT: Font_FontAspect.

FontAspect.regular

Regular weight, no italic.

FontAspect.bold

Bold weight, no italic.

FontAspect.italic

Regular weight, italic.

FontAspect.boldItalic

Bold weight and italic together.

  • OCCT: Font_FontAspect.

FontAspect.name

String representation of the font aspect.

public var name: String { get }
  • OCCT: Font_FontMgr::FontAspectToString(Font_FontAspect).
  • Example: 
    print(FontManager.FontAspect.bold.name)   // "Bold"

FontManager.initDatabase()

Initialises the system font database. Call before querying any font properties.

public static func initDatabase()

Triggers Font_FontMgr::InitFontDataBase() and caches the available font list. Subsequent calls refresh the cache.

  • OCCT: Font_FontMgr::GetInstance()->InitFontDataBase() + GetAvailableFonts().
  • Example: 
    FontManager.initDatabase()
print(FontManager.fontCount)

FontManager.fontCount

The number of system fonts available after initDatabase().

public static var fontCount: Int { get }
  • OCCT: NCollection_List<Handle(Font_SystemFont)>::Size() on the cached font list.
  • Example: 
    let n = FontManager.fontCount
for i in 0..<n { ... }

FontManager.fontName(at:)

Returns the font family name at the given 0-based index.

public static func fontName(at index: Int) -> String?
  • Parameters: index — 0-based position in the font list (must be less than fontCount).
  • Returns: Font family name string, or nil if index is out of range.
  • OCCT: Font_SystemFont::FontName() → TCollection_AsciiString.
  • Example: 
    FontManager.initDatabase()
for i in 0..<FontManager.fontCount {
    if let name = FontManager.fontName(at: i) {
        print(name)
    }
}

FontManager.fontPath(at:aspect:)

Returns the file system path to the font file for the given index and style.

public static func fontPath(at index: Int, aspect: FontAspect = .regular) -> String?
  • Parameters: index — 0-based font index; aspect — the desired style (default .regular).
  • Returns: Absolute file path string, or nil if the font has no file for that aspect or the index is out of range.
  • OCCT: Font_SystemFont::FontPath(Font_FontAspect) → TCollection_AsciiString.
  • Example: 
    if let path = FontManager.fontPath(at: 0, aspect: .bold) {
    print(path)  // e.g. "/System/Library/Fonts/Helvetica-Bold.ttc"
}

FontManager.fontHasAspect(at:aspect:)

Tests whether the font at the given index has a specific style variant available.

public static func fontHasAspect(at index: Int, aspect: FontAspect) -> Bool
  • Parameters: index — 0-based font index; aspect — the style to check.
  • Returns: true if a file exists for that aspect.
  • OCCT: Font_SystemFont::HasFontAspect(Font_FontAspect).
  • Example: 
    if FontManager.fontHasAspect(at: 0, aspect: .boldItalic) {
    let path = FontManager.fontPath(at: 0, aspect: .boldItalic)
}

FontManager.allFontNames

All available system font family names as a [String].

public static var allFontNames: [String] { get }

Pure-Swift: iterates 0..<fontCount collecting fontName(at:) results. Fonts whose name cannot be decoded are silently skipped.

  • Example: 
    FontManager.initDatabase()
let names = FontManager.allFontNames
let hasHelvetica = names.contains("Helvetica")