Annexe R · Raycasting

Raycasting GPU

Le raycasting est la technique la plus fondamentale du rendu 3D — avant le rasterizer, avant les GPUs modernes, c'est comme ça qu'on rendait des scènes. Aujourd'hui on l'utilise pour des effets impossibles avec le pipeline classique : ombres exactes, réflexions, intersection analytique avec des sphères parfaites. Et sur GPU, on peut lancer un rayon par pixel — en parallèle.

Objectif de ce chapitreWhat you’ll learn
Wat je leert
  • Construire un rayon par pixel depuis la caméra, avec le même champ de vision que le raster
  • Calculer l'intersection rayon — sphère sans approximation
  • Écrire le résultat d'un compute shader dans une texture
  • Afficher cette texture derrière la scène raster, dans la même passe
  • Une classe Raycaster complète, prête à garder
⏱ ~40 min
PrérequisPrerequisites
Vereisten

L'idée

Un rayon part de l'œil (la caméra) à travers chaque pixel de l'écran. Pour chaque rayon, on teste l'intersection avec les objets de la scène. Le premier objet touché détermine la couleur du pixel.

// Vision mentale :
//
//         Écran (plan image)
//        ┌─────────┐
//  œil ──┼──→ rayon│──────────────→  ● sphère  (hit)
//        │         │
//  œil ──┼──→ rayon│──────────────────────────→  (miss, fond)
//        └─────────┘
//
// Un thread GPU = un pixel = un rayon

Le chapitre construit une classe Raycaster en quatre fichiers : un header partagé avec le GPU, le shader, et la classe elle-même (.hpp et .cpp). Elle s'utilise en deux appels par image : compute() lance les rayons dans une texture, draw() affiche cette texture derrière la scène raster.

Les données partagées CPU ↔ GPU

Une sphère, c'est un centre, un rayon et une couleur. La caméra du raycast, c'est une position et trois directions. Les deux structures sont lues par le CPU et par le shader : elles vivent dans un seul header, inclus des deux côtés.

/// C++ — Raycaster_shared.h — update:19/10/26
#ifndef Raycaster_shared_h
#define Raycaster_shared_h

#include <simd/simd.h>

// Partagé CPU ↔ GPU : mêmes octets des deux côtés.
// simd::float3 occupe 16 octets (pas 12) et s'aligne sur 16, en C++ comme en MSL.
struct alignas(16) Sphere
{
    simd::float3 center; // offset  0
    float        radius; // offset 16
    simd::float3 color;  // offset 32  → sizeof = 48
};

struct alignas(16) RaycastCameraUniforms
{
    simd::float3 position; // offset  0
    simd::float3 forward;  // offset 16  — normalisé
    simd::float3 right;    // offset 32  — déjà multiplié par tan(fov / 2)
    simd::float3 up;       // offset 48  — × tan(fov / 2), inversé : la ligne 0 de la texture est en haut
};

#endif /* Raycaster_shared_h */
float3 fait 16 octets, pas 12

En MSL comme avec simd::float3 en C++, un float3 occupe 16 octets et commence sur un multiple de 16 : le 4e float existe, il n'est simplement pas utilisé. Dans Sphere, radius se place donc à l'offset 16 et color à 32, pour 48 octets au total — vérifié des deux côtés par le compilateur. Comme le CPU et le GPU utilisent les mêmes types, les octets correspondent sans _pad manuel.

Le piège arrive si un seul côté change de type : un packed_float3 (12 octets) dans le shader face à un simd::float3 côté C++, et chaque champ est lu au mauvais endroit. Les static_assert à la fin du shader arrêtent la compilation dans ce cas.

Construire le rayon depuis la caméra

C'est la partie la plus importante et la moins bien expliquée ailleurs. Il faut reconstruire la direction du rayon dans l'espace monde depuis les coordonnées pixel. Le kernel utilise directement les vecteurs forward, right, up de la caméra — c'est l'approche la plus propre.

/// MSL — Exemple — update:19/10/26
// 1. Pixel → coordonnées écran centrées dans [-1, 1]
float  aspectRatio = float(imageWidth) / float(imageHeight);
float2 screenPos   = (float2(pixelCoord) / float2(imageWidth, imageHeight)) * 2.0 - 1.0;

// 2. Corriger le ratio : sans ça, les sphères deviennent des ellipses
screenPos.x *= aspectRatio;

// 3. Direction dans l'espace monde
float3 rayDirection = normalize(cameraUniforms.forward
                              + screenPos.x * cameraUniforms.right
                              + screenPos.y * cameraUniforms.up);

Le pixel \( (0, 0) \) donne \( (-1, -1) \), le centre de l'écran \( (0, 0) \), le coin opposé \( (+1, +1) \). Sur un écran 1920 × 1080, le ratio vaut 1,78 : screenPos.x va de −1,78 à +1,78, et une sphère reste ronde.

Deux réglages se font côté CPU, avant d'envoyer la caméra au shader :

/// C++ — Exemple — update:19/10/26
const float tanHalfFov = tanf(fieldOfView * 0.5f);   // fieldOfView = 60° → tan(30°) = 0.577
cameraUniforms->position = camera.getPosition();
cameraUniforms->forward  = simd::normalize(camera.getForward());
cameraUniforms->right    = camera.getRight() * tanHalfFov;
cameraUniforms->up       = -camera.getUp()   * tanHalfFov; // la ligne 0 de la texture est en haut

Le champ de vision. Le rayon avance de 1 dans forward et se décale jusqu'à 1 vers le haut : sans réglage, l'angle vertical serait de \( 2 \arctan(1) = 90° \). La caméra raster, elle, a 60°. En multipliant right et up par \( \tan(60° / 2) \approx 0.577 \), le bord haut de l'écran tombe exactement sur l'angle de la caméra raster : les deux images se superposent.

Le sens vertical. La ligne 0 d'une texture est en haut de l'écran, alors que screenPos.y y vaut −1. Passer up inversé remet l'image à l'endroit, sans toucher au kernel.

Pourquoi normalize() est crucial
La combinaison linéaire forward + screenPos.x * right + screenPos.y * up n'a pas une longueur de 1. Sans normalize(), les rayons vers les coins de l'écran seraient plus longs que ceux vers le centre — ils parcourraient plus de distance par unité de t, et intersectSphere, qui suppose une direction de longueur 1, renverrait de mauvaises distances. Le normalize() garantit que chaque rayon avance à la même vitesse.

Intersection rayon — sphère

La sphère est l'objet de référence du raycasting parce que son intersection avec un rayon se calcule analytiquement — une équation du second degré, zéro approximation.

Un rayon est défini par son origine O et sa direction normalisée d : tout point sur le rayon est P = O + t*d pour t ≥ 0. Une sphère de centre C et de rayon r est l'ensemble des points tels que |P - C|² = r². Substituer P donne :

// |O + t*d - C|² = r²
// |oc + t*d|²   = r²      où oc = O - C            → centerToOrigin
// dot(oc,oc) + 2t*dot(oc,d) + t²*dot(d,d) = r²
//
// Comme d est normalisé : dot(d,d) = 1
// t² + 2t*dot(oc,d) + (dot(oc,oc) - r²) = 0
//
// b = dot(oc, d)          ← projection de oc sur la direction    → projectionOnRay
// c = dot(oc, oc) - r²    ← distance² du centre moins r²         → distanceSqMinusRadiusSq
// discriminant = b² - c   (le facteur 2 se simplifie : t = -b ± √(b² - c))
//
// discriminant < 0 → pas d'intersection (le rayon manque la sphère)
// discriminant = 0 → tangent (un seul point de contact)
// discriminant > 0 → deux intersections : -b - √ (la plus proche) et -b + √
Pourquoi kMinHitDistance = 0.001, et pas 0

Un point d'impact calculé en float tombe rarement pile sur la surface : souvent un peu à l'intérieur. Un rayon secondaire (ombre, réflexion) parti de ce point retoucherait aussitôt la sphère elle-même, à \( t \approx 0 \), et la surface se couvrirait de points noirs — l'acné. Ignorer les impacts plus proches que 0,001 règle le problème. Si la caméra est dans la sphère, l'impact proche est derrière elle : intersectSphere renvoie alors l'impact lointain.

Le shader complet

Le kernel raycastKernel tourne une fois par pixel : il construit le rayon, garde la sphère la plus proche, l'éclaire, et écrit la couleur dans la texture. Les deux fonctions du bas affichent ensuite cette texture.

/// MSL — Raycaster.metal — update:19/10/26
#include <metal_stdlib>
using namespace metal;

#include "../includes/SharedGPU/Raycaster_shared.h"

// Distance minimale d'impact : évite de toucher la surface d'où part le rayon (auto-intersection).
constant float kMinHitDistance = 0.001;

// Renvoie la distance t le long du rayon jusqu'à la sphère, ou -1 si le rayon la rate.
// Résout |origin + t * direction - center|² = radius² (direction normalisée), soit t² + 2bt + c = 0.
float intersectSphere(float3 rayOrigin, float3 rayDirection, Sphere sphere)
{
    float3 centerToOrigin          = rayOrigin - sphere.center;
    float  projectionOnRay         = dot(centerToOrigin, rayDirection);                                  // b
    float  distanceSqMinusRadiusSq = dot(centerToOrigin, centerToOrigin) - sphere.radius * sphere.radius; // c
    float  discriminant            = projectionOnRay * projectionOnRay - distanceSqMinusRadiusSq;

    if (discriminant < 0.0) return -1.0;

    float sqrtDiscriminant = sqrt(discriminant);
    float nearHitDistance  = -projectionOnRay - sqrtDiscriminant;   // intersection la plus proche
    float farHitDistance   = -projectionOnRay + sqrtDiscriminant;   // la plus lointaine

    // On veut t > 0 (devant la caméra)
    if (nearHitDistance > kMinHitDistance) return nearHitDistance;
    if (farHitDistance > kMinHitDistance)  return farHitDistance;   // on est à l'intérieur de la sphère

    return -1.0;
}

kernel void raycastKernel(device const Sphere*                 spheres         [[buffer(0)]],
                          device const RaycastCameraUniforms&  cameraUniforms  [[buffer(1)]],
                          device const uint32_t&               sphereCount     [[buffer(2)]],
                          texture2d<float, access::write>      outputTexture   [[texture(0)]],
                          uint2                                pixelCoord      [[thread_position_in_grid]])
{
    const uint imageWidth  = outputTexture.get_width();
    const uint imageHeight = outputTexture.get_height();
    if (pixelCoord.x >= imageWidth || pixelCoord.y >= imageHeight) return;

    // Coordonnées écran dans [-1, 1], corrigées du ratio pour que les sphères restent rondes
    float  aspectRatio = float(imageWidth) / float(imageHeight);
    float2 screenPos   = (float2(pixelCoord) / float2(imageWidth, imageHeight)) * 2.0 - 1.0;
    screenPos.x *= aspectRatio;

    // Rayon primaire depuis la caméra, à travers ce pixel
    float3 rayDirection       = normalize(cameraUniforms.forward + screenPos.x * cameraUniforms.right + screenPos.y * cameraUniforms.up);
    float  closestHitDistance = 1e9;
    int    closestSphereIndex = -1;
    float3 finalColor         = float3(0.0);

    for (uint sphereIndex = 0; sphereIndex < sphereCount; sphereIndex++)
    {
        float hitDistance = intersectSphere(cameraUniforms.position, rayDirection, spheres[sphereIndex]);

        if (hitDistance > 0.0 && hitDistance < closestHitDistance)
        {
            closestHitDistance = hitDistance;
            closestSphereIndex = int(sphereIndex);
        }
    }

    if (closestSphereIndex >= 0)
    {
        Sphere hitSphere = spheres[closestSphereIndex];

        float3 hitPoint      = cameraUniforms.position + rayDirection * closestHitDistance;
        float3 surfaceNormal = normalize(hitPoint - hitSphere.center);

        // Éclairage diffus simple (Lambertian) — direction lumière normalisée
        float3 lightDirection = normalize(float3(0.6, 1.0, 0.4));
        float  lambertFactor  = max(dot(surfaceNormal, lightDirection), 0.0);

        // Petite ambiance pour éviter le noir total dans les zones non éclairées
        float3 ambientColor = hitSphere.color * 0.15;
        float3 diffuseColor = hitSphere.color * lambertFactor;

        finalColor = ambientColor + diffuseColor;
    }

    outputTexture.write(float4(finalColor, 1.0), pixelCoord);
}

// ── Affichage : un triangle plein écran qui recopie la texture du raycast ─────────────────────────

struct RaycastDisplayOut
{
    float4 position [[position]];
};

vertex RaycastDisplayOut raycastDisplayVertex(uint vertexID [[vertex_id]])
{   // 3 sommets (-1,-1) (3,-1) (-1,3) : un triangle qui couvre tout l'écran
    float2 corner = float2((vertexID << 1) & 2, vertexID & 2) * 2.0 - 1.0;

    RaycastDisplayOut out;
    out.position = float4(corner, 1.0, 1.0); // z = 1 : plan lointain, derrière tout ce que le raster a dessiné
    return out;
}

fragment float4 raycastDisplayFragment(RaycastDisplayOut          in             [[stage_in]],
                                       texture2d<float, access::read> raycastTexture [[texture(0)]])
{
    uint2 pixel = uint2(in.position.xy); // une texture à la taille de la fenêtre : 1 pixel = 1 texel
    if (pixel.x >= raycastTexture.get_width() || pixel.y >= raycastTexture.get_height())
        discard_fragment();

    float4 color = raycastTexture.read(pixel);
    if (all(color.rgb == 0.0))
        discard_fragment(); // rayon raté (le kernel écrit 0) : on garde la couleur de fond du Renderer
    return color;
}

// Garde-fous : si quelqu'un modifie la struct d'un seul côté, la compilation s'arrête
static_assert(sizeof(Sphere) == 48, "Sphere : 48 octets attendus");
static_assert(sizeof(RaycastCameraUniforms) == 64, "RaycastCameraUniforms : 64 octets attendus");

La normale — pourquoi c'est si simple pour une sphère

La normale en un point de surface est le vecteur perpendiculaire à la surface en ce point. Pour une sphère, c'est le vecteur qui va du centre au point : une propriété géométrique de la sphère, qui évite tout calcul de dérivée.

/// MSL — Exemple — update:19/10/26
float3 hitPoint      = cameraUniforms.position + rayDirection * closestHitDistance;
float3 surfaceNormal = normalize(hitPoint - hitSphere.center);
//                               └──────────────────────────┘
//                               centre → surface : longueur = radius, normalize → longueur 1

// Pour voir les normales (debug) : [-1, 1] → [0, 1]
finalColor = surfaceNormal * 0.5 + 0.5;   // x → rouge, y → vert, z → bleu

Éclairage Lambertien — la physique du diffus

Le modèle de Lambert dit que l'intensité lumineuse reçue par une surface est proportionnelle au cosinus de l'angle entre la normale et la direction de la lumière. C'est une loi physique réelle — une surface tenue à 90° de la lumière reçoit zéro énergie.

/// MSL — Exemple — update:19/10/26
float3 lightDirection = normalize(float3(0.6, 1.0, 0.4)); // vers la lumière
float  lambertFactor  = max(dot(surfaceNormal, lightDirection), 0.0);
//                          └────────────────────────────────┘
//                          cosinus de l'angle normale / lumière, 0 pour les faces cachées

float3 ambientColor = hitSphere.color * 0.15; // évite le noir total
float3 diffuseColor = hitSphere.color * lambertFactor;
finalColor = ambientColor + diffuseColor;
// face à la lumière : 0.15 + 1.0 = 1.15 → au-dessus de 1, gardé tel quel par RGBA16Float
// à 90° ou à l'ombre : 0.15         → sombre mais pas noir (pas encore d'ombres portées)

Afficher la texture : un triangle derrière la scène

Le compute shader remplit une texture, mais rien ne la met à l'écran. On l'affiche dans la passe de rendu existante, avec un seul triangle assez grand pour couvrir tout l'écran : ses sommets \( (-1, -1) \), \( (3, -1) \) et \( (-1, 3) \) débordent, et le GPU découpe ce qui sort. Chaque fragment lit son texel avec read() : la texture a la taille de la fenêtre, pas besoin de sampler.

Le triangle est placé à \( z = 1 \), le plan le plus lointain, avec un test de profondeur LessEqual sans écriture. Dessiné après les objets raster, il ne passe que là où la profondeur vaut encore 1, c'est-à-dire là où rien n'a été dessiné : le raycast devient l'arrière-plan. Les rayons qui ne touchent rien sont écartés avec discard_fragment(), et la couleur de fond du Renderer reste visible.

La classe Raycaster

/// C++ — Raycaster.hpp — update:19/10/26
#ifndef Raycaster_hpp
#define Raycaster_hpp

#include <Metal/Metal.hpp>
#include <vector>

#include "../includes/SharedGPU/Raycaster_shared.h"

class Camera;

// Raycasting GPU : un compute shader lance un rayon par pixel dans une texture,
// puis un triangle plein écran l'affiche en arrière-plan de la passe de rendu.
class Raycaster
{
public:
  Raycaster(MTL::Device* device, MTL::Library* shaderLibrary,
            MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat);
  ~Raycaster();

  bool addSphere(simd::float3 center, float radius, simd::float3 color); // false si kMaxSpheres est atteint
  void clearSpheres();

  // Avant la passe de rendu, sur le même command buffer
  void compute(MTL::CommandBuffer* commandBuffer, const Camera& camera, simd::float2 windowSize);
  // Dans la passe de rendu, après les objets raster : ne remplit que les pixels encore vides
  void draw(MTL::RenderCommandEncoder* renderCommandEncoder);

  float fieldOfView = 1.0471976f; // 60° en radians, comme la caméra raster

  static constexpr uint32_t kMaxSpheres = 256;

private:
  void buildPipelines(MTL::Library* shaderLibrary, MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat);
  void buildBuffers();
  void resizeOutputTexture(NS::UInteger width, NS::UInteger height);

  MTL::Device*                             m_device;
  NS::SharedPtr<MTL::ComputePipelineState> m_raycastPipelineState;
  NS::SharedPtr<MTL::RenderPipelineState>  m_displayPipelineState;
  NS::SharedPtr<MTL::DepthStencilState>    m_displayDepthStencilState;
  NS::SharedPtr<MTL::Texture>              m_outputTexture;     // RGBA16Float, taille de la fenêtre
  NS::SharedPtr<MTL::Buffer>               m_sphereBuffer;      // kMaxSpheres × Sphere
  NS::SharedPtr<MTL::Buffer>               m_cameraBuffer;      // RaycastCameraUniforms
  NS::SharedPtr<MTL::Buffer>               m_sphereCountBuffer; // uint32_t

  std::vector<Sphere> m_spheres;
  bool                m_spheresChanged = true; // recopie vers le GPU seulement après un changement
};

#endif /* Raycaster_hpp */

Quelques choix qui la rendent solide :

/// C++ — Raycaster.cpp — update:19/10/26
#include "Raycaster.hpp"

#include <cassert>
#include <cmath>
#include <cstring>

#include "Camera.hpp"

Raycaster::Raycaster(MTL::Device* device, MTL::Library* shaderLibrary,
                     MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat)
: m_device(device->retain())
{
  buildPipelines(shaderLibrary, colorPixelFormat, depthPixelFormat);
  buildBuffers();

  // Une scène de départ, devant la caméra (en 0, 0, -3, qui regarde vers +z)
  addSphere({ 0.0f,    0.0f,  2.0f },   1.0f, { 1.00f, 0.37f, 0.12f }); // orange LearnMSL
  addSphere({-2.2f,   -0.2f,  3.0f },   0.8f, { 0.20f, 0.55f, 1.00f });
  addSphere({ 2.3f,    0.3f,  3.5f },   0.9f, { 0.30f, 0.90f, 0.45f });
  addSphere({ 0.0f, -101.0f,  3.0f }, 100.0f, { 0.55f, 0.55f, 0.60f }); // le sol : une très grosse sphère
}

Raycaster::~Raycaster()
{
  m_device->release();
}

void Raycaster::buildPipelines(MTL::Library* shaderLibrary,
                               MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat)
{
  NS::Error* error = nullptr;

  // Compute : un thread par pixel
  auto raycastFunction = NS::TransferPtr(shaderLibrary->newFunction(MTLSTR("raycastKernel")));
  assert(raycastFunction && "raycastKernel not found in library – check Raycaster.metal");
  m_raycastPipelineState = NS::TransferPtr(m_device->newComputePipelineState(raycastFunction.get(), &error));
  assert(!error && "Raycast compute pipeline creation failed");

  // Affichage : triangle plein écran
  auto vertexFunction   = NS::TransferPtr(shaderLibrary->newFunction(MTLSTR("raycastDisplayVertex")));
  auto fragmentFunction = NS::TransferPtr(shaderLibrary->newFunction(MTLSTR("raycastDisplayFragment")));
  assert(vertexFunction && fragmentFunction && "raycastDisplay functions not found in library");

  auto renderPipelineDescriptor = NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init());
  renderPipelineDescriptor->setVertexFunction(vertexFunction.get());
  renderPipelineDescriptor->setFragmentFunction(fragmentFunction.get());
  renderPipelineDescriptor->colorAttachments()->object(0)->setPixelFormat(colorPixelFormat);
  renderPipelineDescriptor->setDepthAttachmentPixelFormat(depthPixelFormat);
  m_displayPipelineState = NS::TransferPtr(m_device->newRenderPipelineState(renderPipelineDescriptor.get(), &error));
  assert(!error && "Raycast display pipeline creation failed");

  // z = 1 et LessEqual : ne passe que là où la profondeur vaut encore 1 (rien n'a été dessiné)
  auto depthStencilDescriptor = NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init());
  depthStencilDescriptor->setDepthCompareFunction(MTL::CompareFunctionLessEqual);
  depthStencilDescriptor->setDepthWriteEnabled(false);
  m_displayDepthStencilState = NS::TransferPtr(m_device->newDepthStencilState(depthStencilDescriptor.get()));
}

void Raycaster::buildBuffers()
{
  m_sphereBuffer      = NS::TransferPtr(m_device->newBuffer(sizeof(Sphere) * kMaxSpheres, MTL::ResourceStorageModeShared));
  m_cameraBuffer      = NS::TransferPtr(m_device->newBuffer(sizeof(RaycastCameraUniforms), MTL::ResourceStorageModeShared));
  m_sphereCountBuffer = NS::TransferPtr(m_device->newBuffer(sizeof(uint32_t), MTL::ResourceStorageModeShared));
  m_spheres.reserve(kMaxSpheres);
}

bool Raycaster::addSphere(simd::float3 center, float radius, simd::float3 color)
{
  if (m_spheres.size() >= kMaxSpheres)
    return false;
  m_spheres.push_back({ center, radius, color });
  m_spheresChanged = true;
  return true;
}

void Raycaster::clearSpheres()
{
  m_spheres.clear();
  m_spheresChanged = true;
}

void Raycaster::resizeOutputTexture(NS::UInteger width, NS::UInteger height)
{
  auto textureDescriptor = NS::TransferPtr(MTL::TextureDescriptor::alloc()->init());
  textureDescriptor->setTextureType(MTL::TextureType2D);
  textureDescriptor->setPixelFormat(MTL::PixelFormatRGBA16Float);
  textureDescriptor->setWidth(width);
  textureDescriptor->setHeight(height);
  textureDescriptor->setUsage(MTL::TextureUsageShaderWrite | MTL::TextureUsageShaderRead);
  textureDescriptor->setStorageMode(MTL::StorageModePrivate); // GPU seulement : le CPU n'y lit jamais
  m_outputTexture = NS::TransferPtr(m_device->newTexture(textureDescriptor.get()));
}

void Raycaster::compute(MTL::CommandBuffer* commandBuffer, const Camera& camera, simd::float2 windowSize)
{
  const NS::UInteger width  = (NS::UInteger)windowSize.x;
  const NS::UInteger height = (NS::UInteger)windowSize.y;
  if (width == 0 || height == 0)
    return;
  if (!m_outputTexture || m_outputTexture->width() != width || m_outputTexture->height() != height)
    resizeOutputTexture(width, height); // la fenêtre a changé de taille

  if (m_spheresChanged)
  {
    memcpy(m_sphereBuffer->contents(), m_spheres.data(), m_spheres.size() * sizeof(Sphere));
    *static_cast<uint32_t*>(m_sphereCountBuffer->contents()) = (uint32_t)m_spheres.size();
    m_spheresChanged = false;
  }

  // Le kernel avance de 1 dans forward et de [-1, 1] sur l'écran : multiplier right et up par
  // tan(fov / 2) donne le même champ de vision que la caméra raster. up est inversé parce que
  // la ligne 0 d'une texture est en haut, alors que screenPos.y = -1 sur cette ligne.
  const float tanHalfFov = tanf(fieldOfView * 0.5f);
  RaycastCameraUniforms* cameraUniforms = static_cast<RaycastCameraUniforms*>(m_cameraBuffer->contents());
  cameraUniforms->position = camera.getPosition();
  cameraUniforms->forward  = simd::normalize(camera.getForward());
  cameraUniforms->right    = camera.getRight() * tanHalfFov;
  cameraUniforms->up       = -camera.getUp()   * tanHalfFov;

  MTL::ComputeCommandEncoder* computeCommandEncoder = commandBuffer->computeCommandEncoder();
  computeCommandEncoder->setComputePipelineState(m_raycastPipelineState.get());
  computeCommandEncoder->setBuffer(m_sphereBuffer.get(),      0, 0);
  computeCommandEncoder->setBuffer(m_cameraBuffer.get(),      0, 1);
  computeCommandEncoder->setBuffer(m_sphereCountBuffer.get(), 0, 2);
  computeCommandEncoder->setTexture(m_outputTexture.get(), 0);

  // Taille de groupe donnée par le pipeline : une largeur de SIMD, puis autant de lignes que possible
  const NS::UInteger threadWidth  = m_raycastPipelineState->threadExecutionWidth();
  const NS::UInteger threadHeight = m_raycastPipelineState->maxTotalThreadsPerThreadgroup() / threadWidth;
  computeCommandEncoder->dispatchThreads(MTL::Size::Make(width, height, 1),
                                         MTL::Size::Make(threadWidth, threadHeight, 1));
  computeCommandEncoder->endEncoding();
}

void Raycaster::draw(MTL::RenderCommandEncoder* renderCommandEncoder)
{
  if (!m_outputTexture)
    return;
  renderCommandEncoder->setRenderPipelineState(m_displayPipelineState.get());
  renderCommandEncoder->setDepthStencilState(m_displayDepthStencilState.get());
  renderCommandEncoder->setFragmentTexture(m_outputTexture.get(), 0);
  renderCommandEncoder->drawPrimitives(MTL::PrimitiveTypeTriangle, NS::UInteger(0), NS::UInteger(3));
}

Brancher dans le Renderer

Quatre ajouts. Le membre, déclaré à la fin de la classe comme les autres : il est construit avec m_device et m_shaderLibrary, qui doivent exister avant lui.

/// C++ — Renderer.hpp — update:19/10/26
#include "Raycaster.hpp"

private:
  Raycaster m_raycaster;
/// C++ — Renderer.cpp — update:19/10/26 — initialisation = constructeur
m_raycaster(m_device, m_shaderLibrary, m_pixelFormat, m_depthPixelFormat),

La passe compute s'encode sur le même command buffer que le rendu, avant lui. Metal voit que la passe de rendu lit la texture que le compute vient d'écrire, et attend la fin du compute tout seul.

/// C++ — Renderer.cpp — update:19/10/26 — draw(), juste après la création du command buffer
MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
m_raycaster.compute(commandBuffer, m_camera, m_windowSize);

Et l'affichage, en dernier dans la passe de rendu. draw() change l'état de profondeur de l'encoder : tout ce qui se dessine après lui doit remettre le sien.

/// C++ — Renderer.cpp — update:19/10/26 — draw(), avant endEncoding()
m_raycaster.draw(renderCommandEncoder);
⬡CheckPoint Compilation

Avance avec Z Q S D et tourne à la souris : les sphères suivent la caméra exactement comme les objets raster, parce que les deux utilisent la même position, les mêmes axes et le même angle de vue.

Extensions — ce qu'on peut ajouter

Ombres portées

/// MSL — Exemple — update:19/10/26
// Depuis le point d'impact, un rayon vers la lumière : s'il touche une sphère, le point est à l'ombre
float3 shadowOrigin = hitPoint + surfaceNormal * kMinHitDistance; // décalé pour ne pas se toucher soi-même
bool   inShadow     = false;

for (uint sphereIndex = 0; sphereIndex < sphereCount; sphereIndex++)
{
    if (intersectSphere(shadowOrigin, lightDirection, spheres[sphereIndex]) > 0.0)
    {
        inShadow = true;
        break; // une seule sphère suffit
    }
}

finalColor = ambientColor + (inShadow ? float3(0.0) : diffuseColor);

Réflexions

/// MSL — Exemple — update:19/10/26
// Les shaders MSL ne sont pas récursifs : on déroule les rebonds dans une boucle
float3 throughput   = float3(1.0);              // atténuation cumulée
float3 rayOrigin    = cameraUniforms.position;
float3 currentRay   = rayDirection;

for (int bounce = 0; bounce < 4; bounce++)
{
    // … chercher closestSphereIndex depuis rayOrigin dans la direction currentRay …
    if (closestSphereIndex < 0) break;

    throughput *= hitSphere.color;              // chaque rebond teinte la lumière
    rayOrigin   = hitPoint + surfaceNormal * kMinHitDistance;
    currentRay  = reflect(currentRay, surfaceNormal); // miroir parfait, fonction native MSL
}

Anti-aliasing — supersampling

pcg() et hashToFloat() viennent du chapitre ↘ Fonctions de hachage. trace() reprend la boucle de recherche et l'éclairage du kernel dans une fonction, et frame est un compteur d'images à ajouter dans les uniforms.

/// MSL — Exemple — update:19/10/26
// N rayons par pixel, décalés à l'intérieur du pixel, puis moyenne
float3 accumulated = float3(0.0);
const int kSampleCount = 4;                     // 4× le coût pour des bords lisses

for (int sampleIndex = 0; sampleIndex < kSampleCount; sampleIndex++)
{
    uint   hash   = pcg(pixelCoord.x ^ (pixelCoord.y << 16) ^ (frame * 1337u + sampleIndex));
    float2 jitter = float2(hashToFloat(hash), hashToFloat(pcg(hash))) - 0.5;

    float2 jitteredPos = ((float2(pixelCoord) + jitter) / float2(imageWidth, imageHeight)) * 2.0 - 1.0;
    jitteredPos.x *= aspectRatio;
    float3 jitteredRay = normalize(cameraUniforms.forward + jitteredPos.x * cameraUniforms.right
                                                         + jitteredPos.y * cameraUniforms.up);
    accumulated += trace(cameraUniforms.position, jitteredRay, spheres, sphereCount);
}
finalColor = accumulated / float(kSampleCount);

Raycasting vs Rasterization

Rasterization Raycasting
Coût O(triangles) — très rapide O(pixels × objets) — coûteux
Ombres Shadow maps — approximation Exactes par construction
Réflexions Cubemaps — approximation Exactes, récursives
Formes Triangles seulement Analytique (sphères, plans, SDF…)
Utilisation Jeux temps réel Effets spéciaux, raytracing hybride
Sample Apple correspondant
↗ Performing Calculations on a GPU — la base du compute shader. Le raycasting complet avec BVH est couvert dans ↗ Metal 4 — Raytracing avec BVH.