A 3D CAD application usually contains several layers that solve very different problems. The user interface manages commands and interaction, the document model stores engineering intent, visualization turns model data into something that can be displayed, and import or export components communicate with external formats. Between these systems sits the geometry layer: the part responsible for representing precise shape and performing the calculations that actually modify a model.
What Belongs in the Geometry Layer?
At its lowest level, the geometry layer works with mathematical entities.
Points and vectors define positions and directions. Curves can represent lines, circles, ellipses, or spline-based shapes. Surfaces describe planes, cylinders, cones, tori, and freeform geometry.
These entities support calculations such as evaluation, projection, transformation, distance measurement, and intersection.
A geometric kernel provides this mathematical foundation. For a full CAD system, however, geometry alone is insufficient. The software also needs to understand how individual geometric elements are connected.
From Mathematical Geometry to B-Rep
B-Rep provides the structural representation required for many solid modeling workflows.
A surface describes a mathematical shape, but a face identifies a bounded region of that surface. Similarly, an edge typically represents a bounded portion of a curve.
Vertices, edges, loops, faces, shells, and bodies establish the topology of the model.
A geometric modeling kernel operates on both geometry and topology. When a modeling command changes a solid, it may have to construct new surfaces, calculate intersections, split existing faces, create new edges, remove obsolete topology, and assemble the result into a valid body.
This distinction is important for application developers because model entities exposed through an API are not interchangeable. A surface and a face may be related, but they represent different concepts.
Feature Logic Sits Above the Kernel
Users do not normally work directly with B-Rep entities. They create engineering features.
Consider a hole defined by a position, diameter, and depth. The application layer can store these parameters as design intent. The geometry layer converts that intent into the necessary modeling operations.
One possible implementation constructs a cylindrical tool body and subtracts it from the target using a Boolean operation.
The resulting B-Rep contains the actual faces and edges of the modified solid, while the higher application layer retains the semantic meaning that those geometric changes represent a hole.
This separation makes parametric reconstruction possible. When the diameter changes, the application updates the feature parameters and asks the geometry layer to regenerate the affected model.
Modeling Operations Change Topology
One architectural complication is that topology is not necessarily persistent.
Suppose an application stores a reference to a face created by an extrusion. A later Boolean operation may split that face. A fillet can replace neighboring edges and introduce additional faces. Editing an earlier feature can reconstruct a large part of the body.
Applications that attach dimensions, annotations, manufacturing information, or simulation conditions to individual entities therefore need a strategy for maintaining references across topology changes.
The geometry API or SDK may provide information about generated, modified, and deleted entities, but the application still needs to incorporate that information into its own document model.
Visualization Should Remain Separate
The geometry layer should also be distinguished from the graphics layer.
Precise CAD surfaces are usually tessellated for display. A cylindrical face, for example, can be converted into triangles that approximate its visible shape.
Those triangles are suitable for rendering but should not automatically become the authoritative engineering representation.
When the model changes, the affected geometry can be tessellated again. This allows visualization quality to vary independently of the exact model.
The same principle applies to wireframe display, edge highlighting, section views, and other graphical representations derived from model geometry.
Tolerances and Validation Are Architectural Concerns
Geometric calculations use floating-point arithmetic, which means numerical tolerances influence many modeling decisions.
The system may need to determine whether two points coincide, whether an edge lies on a surface, or whether neighboring faces form a closed shell. Imported geometry can make these questions more difficult because its precision assumptions may differ from those used internally.
Model validation therefore belongs close to the geometry layer. Invalid face boundaries, inconsistent topology, or open shells should be detected before corrupted geometry propagates into downstream features.
For CAD application development, the geometry layer is best treated as a specialized computational subsystem with a clearly defined interface. It owns precise geometry and topology, while the rest of the engineering application adds design intent, interaction, visualization, and domain-specific behavior around that model.
