Part
Everything in Flux revolves around a single central concept: the Part. A Part is the digital twin of a physical sheet-metal component — it holds the 3D geometry, the 2D flat drawing, and all the manufacturing instructions needed to produce that component on real machines.
Every other major object either belongs to a Part or organises Parts for production.
Part ← one sheet-metal component
├── Model3 ← its 3D folded shape
├── Drawing2 ← its unfolded flat shape
├── BendTech ← instructions for a press-brake
├── FoldTech ← instructions for a panel-bending machine
├── FlatTech (CutTech) ← instructions for laser / punch cutting
├── Layout ← single-part arrangement on one sheet
└── TrimJob / TrimTech ← instructions for 5-axis trimmingAt a higher level, many Parts can be grouped together for production:
NestJob ← one production batch
├── NestPart[] ← which parts, how many
├── NestSheet[] ← which raw-material sheets are available
└── NestPattern[] ← calculated sheet arrangements (results)The Part
Namespace: Flux.Core — File: Core/Part/Part.cs
Part is the root domain object.
It is a container that links together every representation of the same physical component.
| Property | Type | Meaning |
|---|---|---|
|
|
Name, material, thickness, and other metadata |
|
|
The 3D folded shape of the part |
|
|
The 2D unfolded (flat) drawing |
|
|
Press-brake processing data |
|
|
Panel-bender processing data |
|
|
Laser / punch cutting data |
|
|
Quick single-part sheet arrangement |
|
|
5-axis trim / pipe-cutting job |
|
|
5-axis CAM processing data |
|
|
Bitfield of part-state switches |
Active Part
Part.Current is the static property that holds whichever Part the user is currently working on.
This is the application’s global selection state — think of it as "the open document".
Part active = Part.Current; // the part currently open in the editor3D Geometry — Model3
File: Core/Model/Model3.cs
Model3 represents the part in its folded, three-dimensional state — what you would hold in your hands.
It stores a tree of connected planar faces and bends:
| Property | Type | Meaning |
|---|---|---|
|
|
All geometric elements (faces, bends, meshes) |
|
|
The reference face — root of the geometry tree |
|
|
All bend lines in the model |
|
|
Triangle mesh in the fully flat state |
|
|
Triangle mesh in the folded state |
|
|
Classification (sheet metal, laser, assembly …) |
|
|
Centre of gravity, volume, weight |
Entity Hierarchy
Entity3 is the base class for all geometric elements inside a model:
Entity3 ← abstract base (has a name, transform)
├── E3Thick ← has a material thickness
│ ├── E3Plane ← a flat face (most common element)
│ └── E3Flex ← a bend connecting two faces
├── E3Surface ← imported freeform surface
├── E3Insert ← assembly sub-component
└── E3Mesh ← arbitrary triangle meshE3Plane objects are the faces of the part.
E3Flex objects are the bends that connect those faces.
Together they form a directed acyclic graph (DAG) rooted at Baseplane:
Baseplane (E3Plane)
└── [via E3Flex "bend A"]
└── Side face (E3Plane)
└── [via E3Flex "bend B"]
└── Flange (E3Plane)Every E3Thick has Windward (parent) and Leeward (child) pointers to navigate this tree.
2D Flat Drawing — Drawing2
File: Core/Model/Drawing2.cs
Drawing2 is the unfolded, two-dimensional representation — the flat blank that will be cut from a sheet.
| Property | Type | Meaning |
|---|---|---|
|
|
All 2D elements |
|
|
Contours (outer edge, holes, internal features) |
|
|
Lines where the part will be bent |
The most important element is E2Pline — a 2D polyline that describes a contour.
The outer boundary of the flat part is one E2Pline; every hole or cutout is another.
Geometry Primitives
These types live in Flux.Base and are used throughout the entire codebase.
Points and Vectors
| Type | Description |
|---|---|
|
2D position (x, y) as |
|
3D position (x, y, z) as |
|
2D position as |
|
3D position as |
|
2D direction with length |
|
3D direction; supports dot product, cross product, normalisation |
Transforms
| Type | Description |
|---|---|
|
2D affine transform — rotation, translation, scaling |
|
3D affine transform |
|
An oriented coordinate frame: one origin point and three perpendicular axes |
Polylines — Pline
File: Base/Pline/Pline.cs
Pline is one of the most frequently used types in the codebase.
It represents a 2D contour made of straight lines and arcs.
| Property | Type | Meaning |
|---|---|---|
|
|
The individual line or arc segments |
|
|
Whether the contour is closed (a loop) |
|
|
Whether this is an outer boundary (vs. a hole) |
|
|
Axis-aligned bounding box |
|
|
Enclosed area |
Think of Pline as the 2D equivalent of a shape — it can be the outline of the whole part, a rectangular hole, or an arc slot.
Press-Brake Data — BendTech
File: Core/Bend/BendTech.cs
BendTech stores everything needed to produce the part’s bends on a press-brake machine.
| Property | Type | Meaning |
|---|---|---|
|
|
The target machine |
|
|
Ordered list of bend operations |
|
|
Robotic cell configuration (optional) |
|
|
Whether a robot handles the part |
Bend Operations — BendOp
Each BendOp is one individual bend, in sequence:
| Property | Type | Meaning |
|---|---|---|
|
|
The model element being bent |
|
|
What kind of bend (air bend, hem, coin …) |
|
|
Target bend angle in degrees |
|
|
How the operator re-orients the part after this step |
|
|
Punch and die selected for this step |
EBendKind — Bend Types
enum EBendKind {
AirBend, // most common: punch doesn't reach die bottom
Coining, // high-pressure: punch presses all the way
ClosedHem, // folds flat onto itself
OpenHem, // folds back but leaves a gap
BumpBend, // multiple small hits to form a curve
FormBend, // uses a special forming tool
// … and several pre-bend variants
}EHandlingFlip — Part Re-orientation
After each bend the operator (or robot) may need to turn the part:
enum EHandlingFlip {
None, // keep orientation
Bump, // push forward along the machine
RotateL, // rotate left 90°
RotateR, // rotate right 90°
Rotate180, // rotate 180°
Flip, // flip over (turn upside down)
}Panel-Bender Data — FoldTech
File: Core/Fold/FoldTech.cs
FoldTech covers panel-bending and bump-bending machines — different from press-brakes in that the sheet stays mostly still and the machine’s bending beam moves.
| Property | Type | Meaning |
|---|---|---|
|
|
Target machine |
|
|
Segments of the part processed together |
|
|
Resolved material (may differ from the request) |
|
|
Whether bend order can be reordered freely |
FoldSection → FoldStep
FoldTech
└── FoldSection[] ← one group of bends processed without re-gripping
└── FoldStep[] ← each individual machine movementCutting Data — FlatTech (CutTech)
File: Core/Cut/FlatTech.cs
FlatTech holds everything for cutting the flat blank from a raw sheet, either by laser or by punch.
| Property | Type | Meaning |
|---|---|---|
|
|
The flat drawing being cut |
|
|
Machine, material, thickness, film/treatment settings |
|
|
Ordered cutting operations |
|
|
Contours being processed |
|
|
Warning: some contours have no tooling yet |
CutStep subtypes include LaserCut, PunchStep, CommonLineCut, and ScrapCut.
Sheet Layout — Layout
File: Core/Layout/Layout.cs
A Layout arranges one or more part instances on a single physical sheet, ready for cutting.
| Property | Type | Meaning |
|---|---|---|
|
|
Physical sheet dimensions (width × height) |
|
|
Unusable margins at the sheet edges |
|
|
Rolling direction of the material |
|
|
Each positioned part instance |
|
|
Machine and material settings |
|
|
Calculated machining time |
Placement
Each Placement is one instance of a part on the sheet:
| Property | Type | Meaning |
|---|---|---|
|
|
Cutting data for this part |
|
|
Position of the part on the sheet |
|
|
Rotation in radians |
|
|
Whether the part is flipped on the X axis |
|
|
Validation: overlaps with another placement |
|
|
Validation: rolling direction is wrong |
A single Part can appear as many Placement objects on the same sheet.
Nesting — NestJob
File: Core/Nest/NestJob.cs
When multiple different part types must be cut from a batch of sheets, a NestJob manages the optimisation.
NestJob
├── NestPart[] ← which parts are required and how many
├── NestSheet[] ← raw sheets available (size, grain, quantity)
└── NestPattern[] ← one result sheet per used sheet
└── NestElement[] ← each part instance with its positionNestPart
| Property | Type | Meaning |
|---|---|---|
|
|
The part to nest |
|
|
Minimum quantity required |
|
|
Maximum allowed |
|
|
How many have been placed so far |
NestSheet
| Property | Type | Meaning |
|---|---|---|
|
|
Sheet dimensions |
|
|
Unusable edge margins |
|
|
Number of sheets available |
|
|
Rolling direction |
NestPattern
A NestPattern is one filled sheet — the output for a single raw sheet after nesting:
| Property | Type | Meaning |
|---|---|---|
|
|
Parent job |
|
|
Which sheet type was used |
|
|
All placed part instances |
Robotic Bend Cell — BCellTech
File: Core/BCell/
When a press-brake is combined with a robot for automated material handling, the robotic cell configuration is stored in BCellTech.
The cell is composed of typed equipment items:
BCellItem ← abstract: has a name, size, and position
├── BStorage ← pallet, basket, conveyor (where parts wait)
├── BGripper ← end-of-arm tool (vacuum cups or jaw gripper)
├── BLightBox ← vision reference target
├── BFurniture ← passive collision geometry (tables, fences)
└── BEquipment ← active conveyorsKey planning objects:
| Type | Meaning |
|---|---|
|
A robot TCP (tool-centre-point) position and orientation |
|
How and from where the robot picks up a part |
|
Where and how the robot places a finished part |
|
A robot manoeuvre to re-orient the part mid-sequence |
5-Axis Trimming — TrimJob / TrimTech
Files: Core/Trim/
For parts that need 5-axis cutting (e.g. pipes or complex 3D profiles), TrimJob and TrimTech fill the same role as NestJob and FlatTech do for flat cutting.
| Type | Meaning |
|---|---|
|
The production job: which machine, which parts, quantities |
|
CAM data for a single part: tool paths, lead-ins, sequences |
Global State — FX
File: Core/FX.cs
FX is a large static class that acts as the application’s global state and service locator.
A few key properties beginners will encounter frequently:
| Property | Meaning |
|---|---|
|
The Part currently open in the editor |
|
Application-wide user settings |
|
Whether the app uses millimetres or inches |
|
Path to the installation data directory |
|
Whether admin-only features are enabled |
|
Note
|
FX extends BA (the Base utility module), which means all low-level helpers (logging, geometry, colours) are also accessible through FX.
|
Change Notifications
The data model uses a lightweight property-watching system instead of (or alongside) standard .NET INotifyPropertyChanged.
Classes that participate implement ISheafSite and expose PWatch / PUnwatch methods.
Change events are identified by the EProp enum:
// Subscribe to changes on a part:
part.PWatch(EProp.DwgChanged, OnDwgChanged);
// Unsubscribe:
part.PUnwatch(EProp.DwgChanged, OnDwgChanged);Common EProp values: DwgChanged, Bendlines, Visual, SheetSize, SheetGrain.
Complete Relationship Diagram
NestJob
/ | \
NestPart[] NestSheet[] NestPattern[]
| |
Part* NestElement[]
/|\\ \\ / \
/ | \\ \\ NestPart Point2
/ | \\ \\
Model3 Dwg BendTech FoldTech FlatTech(CutTech) TrimJob
| | | | |
E3Plane E2Pline BendOp[] FoldSection[] CutStep[]
E3Flex E2Bendline FoldStep[]
E3Mesh
Layout
└── Placement[]
├── FlatTech (ref to Part's CutTech)
├── Point2 (position on sheet)
└── double (rotation angle)
* A Layout also belongs to a Part (Part.Layout = quick single-part layout)Key Enumerations Summary
| Enum | Values (selection) |
|---|---|
|
|
|
|
|
|
|
Describes the rolling direction of sheet material |
|
|
|
|