Chapter 11: Cutting Facets & Tiers — The Three Design Styles

Every time ProFacet executes a tier command, it performs a clean two-step geometric operation:

1. Aim One Reference Plane: At the tier's starting index (IDX), ProFacet constructs a single 3D cutting plane with an outward unit normal vector $\mathbf{n}$ and a perpendicular signed distance $d$ from the origin:
   $$\mathbf{n}\cdot \mathbf{p}\le d$$
2. Replicate & Slice Around the Dop: ProFacet rotates that reference plane around the Z-axis according to your symmetry and mirror rules (xN m M), slicing away all crystal volume outside those planes.

How do you tell ProFacet where that reference plane should sit? There are three distinct design styles—and knowing when to use each one is the secret to writing flexible, optimization-ready gemstone scripts.

1. Tier Naming Prefixes (PF, G, P, C, T)

Before looking at the three styles, notice how the first letter of a tier's name automatically determines which side of the stone it cuts:

2. The Three Ways to Aim a Tier

Style 1: Angle + Explicit Depth (@ angle : depth / TierAD)

You specify both the mast angle (°) and the raw perpendicular distance (depth) from the stone's origin (0, 0, 0) to the cutting plane:

• In FSL: P1 0 @ 42.0 : 0.65 x8
• In Lua: TierAD("P1", 0, 42.0, 0.65, "x8")

When to use Style 1:

• Cutting a 90° girdle cylinder at a fixed radius (G1 0 @ 90.0 : 1.0 x16).
• Cutting a flat 0° table at a fixed height when no star meetpoint is desired (T 0 @ 0.0 : 0.30 x1).
• Importing legacy GemCAD .asc files that store raw plane distances instead of symbolic meetpoints.

[!WARNING] Why Raw Depths Struggle During Optimization If you write raw numeric depths (: 0.65) on your Pavilion and Crown tiers and then ask the GPU Optimizer to vary their angles (@ 42.0 +/- 2.0), tilting a plane while holding its distance from (0, 0, 0) constant causes facets to overcut or undercut their neighbors, destroying your meetpoints! That is why Styles 2 and 3 are preferred for parametric design.

Style 2: Angle + Meetpoint (@ angle : point / TierAP) — The Cutter's Standard

You choose the mast angle (°), and pass a 3D landmark point (cp(), gp(), mp(...), ep(...)) after the colon :. ProFacet automatically calculates the exact plane depth $d=\mathbf{n}\cdot {\mathbf{P}}_{\text{target}}$ so the facet plane passes right through that landmark point!

• In FSL: C3 6 @ 22.0 +/- 1.5 : mp(C1) x8
• In Lua: TierAP("C3", 6, val(22.0, 1.5), mp("C1"), "x8")

When to use Style 2:

• 90% of all gemstone tiers! Just like cutting at a physical machine, you set your mast angle and grind until the facet meets an existing corner (cp(), gp(), mp(C1)).
• Because the depth is computed dynamically from the landmark point, you can freely optimize the angle (+/- 1.5 in FSL, val(22.0, 1.5) in Lua) and the meetpoint will never break!

Style 3: Point-Pair (: point1 : point2 / TierPP) — Angle-Free Proportion Locking!

What if you don't know (or don't care to hardcode) the exact mast angle of a tier, because what really matters is that the facet connects two specific 3D landmarks—for example, starting at the girdle corner (gp() + girdle) and ending at a specific fractional width on the crown (surface(0.55, 0.55))?

In Style 3 (Point-Pair), you omit @ angle completely in FSL (or call TierPP in Lua) and provide two 3D points:

• In FSL: C1 0 : gp() + girdle : surface(0.65, 0.0) x4
• In Lua: TierPP("C1", 0, gp():add(girdle), surface(0.65, 0.0), "x4")

How Point-Pair works mathematically: Given your tooth index IDX (which fixes the horizontal azimuth direction of the facet) and two 3D points ${\mathbf{P}}_1$ and ${\mathbf{P}}_2$ that the plane must pass through, there is one and only one mast angle and depth that passes through both ${\mathbf{P}}_1$ and ${\mathbf{P}}_2$! ProFacet solves for that exact angle and depth automatically—and prints the resulting angle in your cutting table!

3. Interactive Comparison: All Three Styles in One Stone

Run the live playground below to see all three styles working together in a single gemstone—and click the FSL / Lua toggle to compare the syntax in both languages:

name   = "Three Design Styles Demo"
ri     = 1.76
gear   = 96
color  = "#10b981"
size   = 1.0
girdle = Vector(0, 0, 0.04)

// STYLE 2 (Angle + Meetpoint): P1 meets centerpoint cp() at 42.5°
P1 0  @ 42.5 : cp() x4
P2 12 @ 41.8 : cp() x4

// STYLE 1 (Angle + Raw Depth): G1 cuts at 90° at explicit radius 1.0
G1 0  @ 90.0 : size x4
G2 12 @ 90.0 : (size * 0.92) x4

// STYLE 2 (Angle + Meetpoint): C1 meets the P1/G1 girdle corner + girdle
C1 0  @ 40.0 : mp(P1, G1) + girdle x4
C2 12 @ 39.0 : mp(P2, G2) + girdle x4

// STYLE 3 (Point-Pair — No @ Angle Needed!):
// Connects the C1/C2 ridge midpoint directly to a 32% height point!
C3 0  : ep(edge(C1:0, C2:12), 0.5) : Point(0, 0.55, 0.22) x4

// Flat table meeting the inner corner of C2 and C3
T  0  @ 0.0  : mp(C2, C3) x1

-- lua script
name("Three Design Styles Demo")
ri(1.76)
gear(96)
color("#10b981")
local size   = 1.0
local girdle = Point(0, 0, 0.04)

-- STYLE 2 (Angle + Meetpoint: TierAP)
TierAP("P1", 0,  42.5, cp(), "x4")
TierAP("P2", 12, 41.8, cp(), "x4")

-- STYLE 1 (Angle + Raw Depth: TierAD)
TierAD("G1", 0,  90.0, size, "x4")
TierAD("G2", 12, 90.0, size * 0.92, "x4")

-- STYLE 2 (Angle + Meetpoint: TierAP)
TierAP("C1", 0,  40.0, mp("P1", "G1"):add(girdle), "x4")
TierAP("C2", 12, 39.0, mp("P2", "G2"):add(girdle), "x4")

-- STYLE 3 (Point-Pair: TierPP — 2 points instead of angle + depth!)
TierPP("C3", 0, ep(edge("C1:0", "C2:12"), 0.5), Point(0, 0.55, 0.22), "x4")

-- Flat table meeting C2 and C3
TierAP("T",  0,  0.0,  mp("C2", "C3"), "x1")

4. Optional Tier Settings ({ frosted, notes })

You can also mark individual tiers as frosted (unpolished matte finish, which scatters light diffusely in renders and is noted on printable diagrams) or attach custom cutting instructions via an options object/table at the end of the tier command:

• In FSL:

  G1 0 @ 90.0 : size x16 { frosted: true, notes: "Pre-polish girdle cylinder" }
  

• In Lua:

  TierAD("G1", 0, 90.0, size, "x16", { frosted = true, notes = "Pre-polish girdle cylinder" })
  

Next, let’s master every single Point Helper (cp(), gp(), mp(), edge(), ep(), prz(), fred(), grid(), and surface()) in Chapter 12: Mastering Point Helpers — cp(), gp(), mp(), ep() & More.