Rendering reflections in real time using ray tracing

At a glance

Project structure

Source bundle/
├── Renderer/
│   ├── AAPLRenderer.m
│   ├── AAPLShaders.metal
│   ├── AAPLShaderTypes.h
│   └── AAPLArgumentBufferTypes.h
└── Application/
    ├── iOS/
    │   └── AAPLViewController.m
    ├── main.m
    ├── WindowSceneDelegate.m
    ├── AAPLAppDelegate.h
    └── AAPLAppDelegate.m

Structure observations

• The entry/composition boundary and renderer or operation boundary are separate in the source; AAPLRenderer 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["AAPLViewController"]
    N2["AAPLRenderer"]
    N3["hybrid raster/ray-tracing renderer"]
    N4["ray-traced reflections plus raster composition"]
    N1 --> N2
    N2 --> N3
    N3 --> N4

Reference code

Renderer/AAPLRenderer.m:1251 — ray-traced reflection pass setup

            [commandBuffer pushDebugGroup:@"Raytrace Compute"];
            [commandBuffer encodeWaitForEvent:_accelerationStructureBuildEvent value:kInstanceAccelerationStructureBuild];
            id<MTLComputeCommandEncoder> compEnc = [commandBuffer computeCommandEncoder];
            compEnc.label = @"RaytracedReflectionsComputeEncoder";
            [compEnc setTexture:_rtReflectionMap atIndex:OutImageIndex];
            [compEnc setTexture:_thinGBuffer.positionTexture atIndex:ThinGBufferPositionIndex];
            [compEnc setTexture:_thinGBuffer.directionTexture atIndex:ThinGBufferDirectionIndex];
            [compEnc setTexture:_skyMap atIndex:AAPLSkyDomeTexture];

Interpretation

This is the dominant control/data path: platform code composes AAPLRenderer; that object controls hybrid raster/ray-tracing renderer; GPU-visible work ends in ray-traced reflections plus raster composition. The arrows summarize responsibility transfer, not a claim that every node directly calls the next.

Ownership and state

classDiagram
    AAPLViewController *-- AAPLRenderer : _renderer

Ownership evidence

Application/iOS/AAPLViewController.m:40 — AAPLViewController creates and stores _renderer

@implementation AAPLViewController
// ...
            strongSelf->_renderer = [[AAPLRenderer alloc] initWithMetalKitView:strongSelf->_view size:size];
// ...
@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/AAPLShaders.metal:337 — ray-traced reflection kernel and binding contract

kernel void rtReflection(
             texture2d< float, access::write >      outImage                [[texture(OutImageIndex)]],
             texture2d< float >                     positions               [[texture(ThinGBufferPositionIndex)]],
             texture2d< float >                     directions              [[texture(ThinGBufferDirectionIndex)]],
             texture2d< float >                     skydomeMap              [[texture(AAPLSkyDomeTexture)]],
             constant AAPLInstanceTransform*        instanceTransforms      [[buffer(BufferIndexInstanceTransforms)]],
             constant AAPLCameraData&               cameraData              [[buffer(BufferIndexCameraData)]],
             constant AAPLLightData&                lightData               [[buffer(BufferIndexLightData)]],
             constant Scene*                        pScene                  [[buffer(SceneIndex)]],
             instance_acceleration_structure        accelerationStructure   [[buffer(AccelerationStructureIndex)]],
             uint2 tid [[thread_position_in_grid]])

Design patterns

Naming conventions

• Role suffixes make ownership visible: AAPLViewController, AAPLRenderer, Scene, AAPLAppDelegate, WindowSceneDelegate.
• Method names describe setup or encoding actions: initWithMetalKitView, resizeRTReflectionMapTo, loadMetalWithView, loadAssets, argumentDescriptorWithIndex, buildSceneArgumentBufferFromReflectionFunction, newResidencySetWithLabel.
• Shader entry points use stage/operation names: skyboxVertex, skyboxFragment, vertexShader, fragmentShader, reflectionShader, gBufferFragmentShader.
• 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 AAPLViewController focused on composition; AAPLRenderer is the owner of hybrid raster/ray-tracing renderer.
• Treat ray-traced reflections plus raster composition as a separate execution/compilation boundary with explicit resource and data-layout contracts.
• The verified ownership edge is AAPLViewController → _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