Accelerating ray tracing using Metal

At a glance

Project structure

Source bundle/
├── Renderer/
│   ├── Renderer.mm
│   ├── Shaders.metal
│   ├── Scene.mm
│   ├── ShaderTypes.h
│   └── Scene.h
└── Application/
    ├── ViewController.mm
    ├── main.m
    ├── AppDelegate.m
    └── AppDelegate.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["acceleration-structure construction"]
    N4["ray-tracing shader work"]
    N1 --> N2
    N2 --> N3
    N3 --> N4

Reference code

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

@implementation Renderer
// ...
- (id <MTLAccelerationStructure>)newAccelerationStructureWithDescriptor:(MTLAccelerationStructureDescriptor *)descriptor
// ...
@end

Interpretation

This is the dominant control/data path: platform code composes Renderer; that object controls acceleration-structure construction; GPU-visible work ends in ray-tracing shader work. 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:57 — ViewController creates and stores _renderer

@implementation ViewController
// ...
    _renderer = [[Renderer alloc] initWithDevice:_view.device
                                           scene:scene];
// ...
@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:264 — ray-tracing compute entry point and resource contract

kernel void raytracingKernel(
     uint2                                                  tid                       [[thread_position_in_grid]],
     constant Uniforms &                                    uniforms                  [[buffer(0)]],
     texture2d<unsigned int>                                randomTex                 [[texture(0)]],
     texture2d<float>                                       prevTex                   [[texture(1)]],
     texture2d<float, access::write>                        dstTex                    [[texture(2)]],
     device void                                           *resources                 [[buffer(1), function_constant(useResourcesBuffer)]],
     constant MTLAccelerationStructureInstanceDescriptor   *instances                 [[buffer(2)]],
     constant AreaLight                                    *areaLights                [[buffer(3)]],
     instance_acceleration_structure                        accelerationStructure     [[buffer(4)]],
     intersection_function_table<triangle_data, instancing> intersectionFunctionTable [[buffer(5)]]
)
{
    // ...
}

Design patterns

Naming conventions

• Role suffixes make ownership visible: ViewController, Renderer, Scene, AAPLAppDelegate, AAPLWindowSceneDelegate, WindowSceneDelegate.
• Method names describe setup or encoding actions: initWithDevice, clear, uploadToBuffers, geometryDescriptor, resources, addCubeWithFaces, addSphereWithOrigin.
• Shader entry points use stage/operation names: raytracingKernel, copyVertex, copyFragment.
• AAPL is a sample namespace prefix, not a recommendation for production module naming; retain semantic suffixes such as Renderer, Manager, Scene, or Adapter.

Architecture takeaways

• Keep ViewController focused on composition; Renderer is the owner of acceleration-structure construction.
• Treat ray-tracing shader work 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