Rendering a curve primitive in a ray tracing scene

At a glance

Project structure

Source bundle/
├── Renderer/
│   ├── Renderer.mm
│   ├── Shaders.metal
│   └── ShaderTypes.h
└── Application/
    ├── ViewController.mm
    ├── main.m
    ├── WindowSceneDelegate.m
    ├── AppDelegate.h
    ├── AppDelegate.m
    └── ViewController.h

Structure observations

• The entry/composition boundary and renderer or operation boundary are separate in the source; Renderer is the principal feature coordinator.
• GPU-specific logic stays in Metal shader files; shared headers bridge host/shader layouts where present.
• The tree above is intentionally pruned to composition, resource, and shader files.

Overall architecture

flowchart LR
    N1["ViewController"]
    N2["Renderer"]
    N3["curve geometry and acceleration-structure setup"]
    N4["curve intersection/ray-tracing shader"]
    N1 --> N2
    N2 --> N3
    N3 --> N4

Reference code

Renderer/Renderer.mm:339 — feature handoff or setup anchor

    CurveGeometry *catmullCurveGeometry = [[CurveGeometry alloc] initWithDevice:_device];
    MTLPrimitiveAccelerationStructureDescriptor *catmullCurveAccelDesc = [catmullCurveGeometry addCurveWithControlPoints:catmullControlPoints curveIndices:catmullIndices radii:radii];
    // Build the acceleration structure.
    id <MTLAccelerationStructure> catmullCurveAccelerationStructure = [self newAccelerationStructureWithDescriptor:catmullCurveAccelDesc];
    // Add the acceleration structure to the array of primitive acceleration structures.
    [_primitiveAccelerationStructures addObject:catmullCurveAccelerationStructure];
    
    _controlPointBuffer = catmullCurveGeometry.controlPointBuffer;

Interpretation

This is the dominant control/data path: platform code composes Renderer; that object controls curve geometry and acceleration-structure setup; GPU-visible work ends in curve intersection/ray-tracing shader. The arrows summarize responsibility transfer, not a claim that every node directly calls the next.

Ownership and state

classDiagram
    ViewController *-- Renderer : _renderer

Ownership evidence

Application/ViewController.mm:54 — ViewController creates and stores _renderer

@implementation ViewController
// ...
    _renderer = [[Renderer alloc] initWithDevice:_view.device];
// ...
@end

Class and protocol design

Framework delegate conformance is a callback seam; the source does not justify calling the whole app protocol-oriented.

Access control

This sample does not use Swift private, fileprivate, or public for its native boundary. Objective-C/Objective-C++ use header versus implementation placement, C++ uses access specifiers/linkage, Python uses module conventions, and Metal entry points cross a compiled-library boundary; these are not Swift access levels.

Logic ownership and placement

Shader boundary reference

Renderer/Shaders.metal:136 — custom Catmull–Rom curve intersection function

[[intersection (curve, triangle_data, curve_data, instancing)]]
bool catmullRomCurveIntersectionFunction(// Ray parameters passed to the ray intersector.
                                         float3 origin                    [[origin]],
                                         float3 direction                 [[direction]],
                                         float distance                   [[distance]],
                                         // Information about the primitive.
                                         uint segmentId                   [[primitive_id]],
                                         float t                          [[curve_parameter]],
                                         ray_data float3& normal          [[payload]],
                                         // Custom resources bound to the intersection function table.
                                         constant float3   *controlPoints [[buffer(0)]],
                                         constant uint16_t *indices       [[buffer(1)]]
                                         )
{
    // ...
}

Design patterns

Naming conventions

• Role suffixes make ownership visible: ViewController, Renderer, AppDelegate, WindowSceneDelegate.
• Method names describe setup or encoding actions: application, applicationShouldTerminateAfterLastWindowClosed, viewDidLoad, scene, sceneDidDisconnect, initWithDevice, loadMetal.
• Shader entry points use stage/operation names: raytracingKernel, copyVertex, copyFragment.
• Names favor concrete domain roles and target-local types; no broad public library namespace is introduced.

Architecture takeaways

• Keep ViewController focused on composition; Renderer is the owner of curve geometry and acceleration-structure setup.
• Treat curve intersection/ray-tracing shader as a separate execution/compilation boundary with explicit resource and data-layout contracts.
• The verified ownership edge is ViewController → _renderer; broader exclusive ownership is not inferred.
• Access-control rationale follows concrete language boundaries rather than translating every header or shader symbol into Swift terms.

Source map

• Official Apple documentation