Chapitre - · 4D

Représenter de la 4D

Un tesseract est au cube ce que le cube est au carré. Personne ne peut le voir directement : nos yeux et notre écran n'ont que deux dimensions. On peut en revanche voir son ombre. L'ombre d'un cube en fil de fer, éclairé de près, est un petit carré dans un grand carré. L'ombre d'un tesseract dans notre espace 3D est un petit cube dans un grand cube.

Le programme fait exactement ça, deux fois de suite, dans le vertex shader : il projette les 16 sommets de \( \mathbb{R}^4 \) vers \( \mathbb{R}^3 \), puis de \( \mathbb{R}^3 \) vers l'écran. Et il fait tourner le tout dans des plans qui n'existent pas chez nous, ce qui retourne le cube comme un gant.

Objectif de ce chapitreWhat you’ll learn
Wat je leert
  • Construire les 16 sommets et les 32 arêtes d'un tesseract avec des bits
  • Faire tourner un point dans les 6 plans de rotation de la 4D
  • Enchaîner deux divisions perspectives : 4D → 3D → 2D
  • Colorer selon la 4e coordonnée pour la rendre lisible
  • Dessiner des lignes indexées et brancher la classe dans le Renderer
⏱ ~30 min
PrérequisPrerequisites
Vereisten

16 sommets, 32 arêtes : tout est dans les bits

Chaque dimension se construit à partir de la précédente : on copie la figure, on décale la copie dans la nouvelle direction, et on relie chaque sommet à sa copie. Un segment donne un carré, un carré donne un cube, un cube donne un tesseract. En orange, les arêtes ajoutées à chaque étape :

1D 2 sommets · 1 arête 2D 4 sommets · 4 arêtes → 3D 8 sommets · 12 arêtes → 4D 16 sommets · 32 arêtes →

Le nombre de sommets double à chaque fois : \( 2^n \), soit 16 en 4D. Chaque sommet est relié à un voisin par dimension, donc \( n \cdot 2^{n-1} \) arêtes : \( 4 \cdot 8 = 32 \).

Un sommet du tesseract a 4 coordonnées, chacune vaut \( -1 \) ou \( +1 \). Deux valeurs possibles, quatre fois : c'est un nombre binaire de 4 bits. Le sommet \( i \) lit ses coordonnées dans ses propres bits — bit à 1 → \( +1 \), bit à 0 → \( -1 \) :

\( i = 5 = 0101_2 \;→\; \begin{pmatrix} x \\ y \\ z \\ w \end{pmatrix} = \begin{pmatrix} \text{bit 0} = 1 \\ \text{bit 1} = 0 \\ \text{bit 2} = 1 \\ \text{bit 3} = 0 \end{pmatrix} = \begin{pmatrix} +1 \\ -1 \\ +1 \\ -1 \end{pmatrix} \)

Les arêtes tombent toutes seules : deux sommets sont reliés quand ils ne diffèrent que d'une coordonnée, donc d'un seul bit. Inverser un bit, c'est un XOR (^) avec 1 << bit. Les 4 voisins de 5 sont \( 5 \oplus 1 = 4 \), \( 5 \oplus 2 = 7 \), \( 5 \oplus 4 = 1 \) et \( 5 \oplus 8 = 13 \).

/// C++ — Tesseract.cpp — update:20/10/26
//         w z y x (bit 3 … bit 0)
//     5 =   1 0 1
//     8 = 1 0 0 0 ← 8 = 1 << 3 : seul le bit 3 (w) est à 1
//     ───────────
// 5 ⊕ 8 = 1 1 0 1 = 8 + 4 + 1 = 13 = 5 XOR 8 = 5 ^ 8
void Renderer4D::buildTesseract(MTL::Device* device)
{
  std::vector<Vertex4D> verts;
  verts.reserve(16);

  for (int i = 0; i < 16; ++i)
  {
    simd::float4 position;
    position.x = (i & 1) ? 1.f : -1.f;
    position.y = (i & 2) ? 1.f : -1.f;
    position.z = (i & 4) ? 1.f : -1.f;
    position.w = (i & 8) ? 1.f : -1.f;
    verts.push_back({ position });
  }

  // 2 indices per segment
  std::vector<uint16_t> indices;
  indices.reserve(64); // 32 edges * 2

  for (int i = 0; i < 16; ++i)
  {
    for (int bit = 0; bit < 4; ++bit)
    {
      int j = i ^ (1 << bit);
      if (j > i) // avoid duplicates
      {
        indices.push_back(static_cast<uint16_t>(i));
        indices.push_back(static_cast<uint16_t>(j));
      }
    }
  }
  assert(indices.size() == 64); // sanity

  m_indexCount = static_cast<uint32_t>(indices.size());

  m_vbo = NS::TransferPtr(device->newBuffer(verts.data(),
                          verts.size() * sizeof(Vertex4D),
                          MTL::ResourceStorageModeShared));

  m_ibo = NS::TransferPtr(device->newBuffer(indices.data(),
                          indices.size() * sizeof(uint16_t),
                          MTL::ResourceStorageModeShared));
}

La double boucle visite chaque arête deux fois : depuis 5 on trouve 7, depuis 7 on retrouve 5. Le test j > ine garde que le premier passage : 16 sommets × 4 voisins ÷ 2 = 32 arêtes, soit 64 indices de 2 octets. L'assert du constructeur vérifie justement ce 64.

Les données partagées CPU ↔ GPU

Un sommet n'est qu'un simd::float4 : \( (x, y, z, w) \). Tout le reste — angles, distances de caméra, taille de la fenêtre — passe par Uniforms4D, un seul petit buffer de 48 octets : un float2 (8 octets) puis 10 float (40 octets). Les offsets en commentaire ne sont pas décoratifs : la struct C++ et celle du shader doivent avoir exactement les mêmes champs, dans le même ordre. Un champ déplacé d'un côté seulement, et le shader lit l'angle XW à la place de la distance de caméra.

Les vitesses (speedXY, …), fov4D, fov3D et scalesont publiques : tu peux les modifier depuis le Renderer, au clavier par exemple, sans toucher à la classe.

/// C++ — Tesseract.hpp — update:20/10/26
#ifndef tesseract_hpp
#define tesseract_hpp

#include <Metal/Metal.hpp>

#include <simd/simd.h>
#include <vector>
#include <cstdint>

// Tesseract (hypercube 4D) renderer via double
// perspective projection: R^4 → R^3 → R^2
struct Vertex4D
{
  simd::float4 position; // x, y, z, w in 4D unit space
};

struct Uniforms4D
{
  simd::float2 windowSize; // viewport in pixels           offset  0
  float        time;       // elapsed seconds              offset  8
  float        angleXY;    // rotation plane XY            offset 12
  float        angleXZ;    // rotation plane XZ            offset 16
  float        angleXW;    // rotation plane XW            offset 20
  float        angleYZ;    // rotation plane YZ            offset 24
  float        angleYW;    // rotation plane YW            offset 28
  float        angleZW;    //rotation plane ZW             offset 32
  float        fov4D;      // 4D → 3D perspective distance offset 36
  float        fov3D;      // 3D → 2D perspective distance offset 40
  float        scale;      // global screen scale          offset 44
};

class Renderer4D
{
public:
  Renderer4D(MTL::Device*, MTL::Library*, MTL::PixelFormat, MTL::PixelFormat);
  ~Renderer4D();

  void buildTesseract(MTL::Device*);

  void update(float delta);
  void draw(MTL::RenderCommandEncoder*, simd::float2 windowSize);

  // tweakable from outside
  float speedXY  = 0.31f;
  float speedXZ  = 0.17f;
  float speedXW  = 0.53f; // main "into 4D" spin
  float speedYZ  = 0.11f;
  float speedYW  = 0.43f;
  float speedZW  = 0.23f;

  float fov4D    = 2.5f;  // 4D → 3D camera distance (>1)
  float fov3D    = 4.0f;  // 3D → 2D camera distance (>1)
  float scale    = 0.65f; // [0..1] fills screen

private:
  NS::SharedPtr<MTL::RenderPipelineState> m_pso = nullptr;
  NS::SharedPtr<MTL::Buffer> m_vbo = nullptr; // 16 Vertex4D
  NS::SharedPtr<MTL::Buffer> m_ibo = nullptr; // 64 uint16 (32 edges)
  NS::SharedPtr<MTL::Buffer> m_ubo = nullptr; // Uniforms4D

  uint32_t m_indexCount = 0;

  // per-plane accumulated angles
  float m_aXY = 0.f, m_aXZ = 0.f, m_aXW = 0.f;
  float m_aYZ = 0.f, m_aYW = 0.f, m_aZW = 0.f;
  float m_time = 0.f;
};


#endif /* tesseract_hpp */

Faire avancer les angles

/// C++ — Tesseract.cpp — update:20/10/26
void Renderer4D::update(float delta)
{
  m_time += delta;
  m_aXY  += speedXY * delta;
  m_aXZ  += speedXZ * delta;
  m_aXW  += speedXW * delta;
  m_aYZ  += speedYZ * delta;
  m_aYW  += speedYW * delta;
  m_aZW  += speedZW * delta;
}

Multiplier par delta transforme les vitesses en radians par seconde : la rotation va aussi vite à 60 qu'à 120 images par seconde. Avec speedXW = 0.53, un tour complet dans le plan XW prend \( 2\pi / 0.53 \approx 11.9 \) secondes. Les six vitesses sont toutes différentes : les plans ne se resynchronisent pratiquement jamais, et la figure ne repasse pas par la même pose avant longtemps. m_time est envoyé au shader sans y être utilisé : il est là pour tes propres effets, une pulsation par exemple.

Deux divisions perspectives : 4D → 3D → 2D

La perspective, c'est diviser par la distance : plus un point est loin, plus il paraît petit (chapitre ↘ Perspective). On place une caméra sur l'axe \( w \), à la distance fov4D, et on divise \( x, y, z \) par la distance qui sépare chaque sommet de cette caméra. On recommence ensuite en 3D avec \( z \) et fov3D :

\[ \vec{p}_3 = \frac{(x,\ y,\ z)}{fov_{4D} - w} \qquad \vec{p}_2 = \frac{(p_{3x},\ p_{3y})}{fov_{3D} - p_{3z}} \]

Au repos, le cube extérieur (\( w = +1 \)) est multiplié par \( 1 / 1.5 \approx 0.67 \), le cube intérieur (\( w = -1 \)) par \( 1 / 3.5 \approx 0.29 \) : 2,3 fois plus petit. Voilà d'où vient le « cube dans un cube ».

/// MSL — Exemple — update:20/10/26
// 4D → 3D  (perspective divide by fov4D - w) ───────────────────────────
//    fov4D is the camera distance along the 4th axis.
//    Result: p3 ∈ R^3
float inv4D = 1.0 / (uniforms.fov4D - vertice.w);
float3 p3   = vertice.xyz * inv4D;

// 3D → 2D  (perspective divide by fov3D - z) ────────────────────────────
//    fov3D is the camera distance along the Z axis.
//    Result: p2 ∈ R^2  (approx. in [-1, 1] for reasonable fovs)
float inv3D = 1.0 / (uniforms.fov3D - p3.z);
float2 p2   = p3.xy * inv3D;

// NDC aspoect ratio
float aspect = uniforms.windowSize.x / uniforms.windowSize.y;
p2 *= uniforms.scale;
p2.x /= aspect;
Pourquoi fov4D = 2.5, et pas 1.5

Le commentaire du header demande fov4D > 1, mais la vraie limite est 2. Un sommet est à la distance \( \sqrt{1 + 1 + 1 + 1} = 2 \) du centre, et une rotation ne change pas les longueurs : après rotation, \( w \) peut aller de \( -2 \) à \( +2 \). Avec fov4D = 2.5, le dénominateur reste au moins égal à 0,5. À 2 pile, un sommet aligné sur l'axe W provoquerait une division par zéro ; en dessous, le sommet passerait derrière la caméra et la figure s'inverserait. Même raisonnement en 3D : \( p_{3z} \) ne dépasse jamais \( 4/3 \), donc fov3D = 4 garde une bonne marge.

Le rapport d'aspect divise \( x \) pour que le tesseract ne s'écrase pas dans une fenêtre large, et scale règle la taille à l'écran. Le shader renvoie enfin float4(p2, 0.0, 1.0) : la perspective est déjà faite à la main, et le \( w = 1 \) rend inoffensive la division que le GPU applique ensuite à toutes les positions.

Le résultat, calculé avec ces mêmes formules et les valeurs par défaut :

au repos : seulement penché en 3D XW, YW, ZW ont tourné : le cube se retourne ■ w = −1 : cube « intérieur » ■ w = +1 : cube « extérieur » dégradé : les 8 arêtes qui traversent w

La couleur garde la trace de la 4e dimension

Sur l'écran, rien ne dit si un sommet vient du cube \( w = -1 \) ou du cube \( w = +1 \). Le shader mémorise donc \( w \) avant les rotations, puis le convertit en couleur : \( t = (w + 1) / 2 \) vaut 0 pour le cube intérieur (bleu) et 1 pour l'extérieur (orange). Comme wOrig est pris avant rotation, chaque sommet garde sa couleur pendant que la figure se retourne : tu vois les sommets bleus passer à l'extérieur.

/// MSL — Exemple — update:20/10/26
// remember original w for coloring (before any rotation)
//    w ∈ {-1, +1} → distinguishes inner / outer cube shells of the tesseract
float wOrig = vertice.w;   // -1 = "inner" cube, +1 = "outer" cube

// inner shell (wOrig == -1) → cold cyan-blue
// outer shell (wOrig == +1) → warm orange
// additional luminance modulation by 4D depth (inv4D) → near faces glow
float t      = (wOrig + 1.0) * 0.5;
float4 colA  = float4(0.15, 0.55, 1.00, 1.0); // inner: blue
float4 colB  = float4(1.00, 0.45, 0.10, 1.0); // outer: orange
float4 color = mix(colA, colB, t);

// brightness boost for vertices closest along the 4th axis
float brightness = mix(0.55, 1.0, saturate(inv4D * uniforms.fov4D * 0.5));
color.rgb *= brightness;

La luminosité, elle, utilise le \( w \) après rotation : \( fov_{4D} / (fov_{4D} - w) \) vaut 1 quand \( w = 0 \) et grandit quand le sommet s'approche de la caméra 4D. Au final, un sommet à \( w = -2 \) est éclairé à 67 %, un sommet à \( w = +2 \) à 100 %. Le rasterizer interpole la couleur le long de chaque ligne : les 8 arêtes qui relient les deux cubes passent du bleu à l'orange.

Le shader

/// MSL — Tesseract.metal — update:20/10/26
#include <metal_stdlib>
using namespace metal;
// 6 rotation planes (XY, XZ, XW, YZ, YW, ZW)
// Coloring by original w-depth of vertex.

struct Vertex4D
{
  float4 position; // x y z w in 4D
};

struct Uniforms4D
{
  float2 windowSize;
  float  time;
  float  angleXY;
  float  angleXZ;
  float  angleXW;
  float  angleYZ;
  float  angleYW;
  float  angleZW;
  float  fov4D;
  float  fov3D;
  float  scale;
};

struct VertexOut
{
  float4 position [[position]];
  float4 color;
};

inline float4 rotXY(float4 v, float a)
{
  float c = cos(a), s = sin(a);
  return float4(c * v.x - s * v.y, s * v.x + c * v.y, v.z, v.w);
}

inline float4 rotXZ(float4 v, float a)
{
  float c = cos(a), s = sin(a);
  return float4(c * v.x - s * v.z, v.y, s * v.x + c * v.z, v.w);
}

inline float4 rotXW(float4 v, float a)
{
  float c = cos(a), s = sin(a);
  return float4(c * v.x - s * v.w, v.y, v.z, s * v.x + c * v.w);
}

inline float4 rotYZ(float4 v, float a)
{
  float c = cos(a), s = sin(a);
  return float4(v.x, c * v.y - s * v.z, s * v.y + c * v.z, v.w);
}

inline float4 rotYW(float4 v, float a)
{
  float c = cos(a), s = sin(a);
  return float4(v.x, c * v.y - s * v.w, v.z, s * v.y + c * v.w);
}

Tourner en 4D : des plans, pas des axes

En 3D on dit « tourner autour de l'axe Z ». Ce qui bouge vraiment, ce sont \( x \) et \( y \) : la rotation se fait dans le plan XY, et l'axe Z est simplement ce qui reste immobile. En 4D, une rotation dans un plan laisse deux coordonnées immobiles : il n'y a plus d'axe unique, il n'y a que des plans. On en compte un par paire de coordonnées :

\[ \binom{4}{2} = 6 \text{ plans : } XY,\ XZ,\ XW,\ YZ,\ YW,\ ZW \]

Chaque rotation est une rotation 2D ordinaire, appliquée à deux coordonnées. Pour le plan ZW :

\[ R_{ZW}(a) = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & \cos a & -\sin a \\ 0 & 0 & \sin a & \cos a \end{pmatrix} \]

Plutôt qu'une matrice 4×4 complète, le shader écrit directement les deux lignes qui changent :

/// MSL — Tesseract.metal — update:20/10/26
inline float4 rotZW(float4 vector, float angle)
{
  float cosinus = cos(angle), sinus = sin(angle);
  return float4(vector.x, vector.y,
                cosinus * vector.z - sinus   * vector.w,
                sinus   * vector.z + cosinus * vector.w);
}

XY, XZ et YZ sont les rotations 3D que tu connais : le cube tourne sur lui-même. XW, YW et ZW mélangent une coordonnée visible avec \( w \) : un sommet du cube intérieur glisse vers l'extérieur et inversement. C'est là que le tesseract se retourne. L'ordre des six appels compte : en 4D comme en 3D, deux rotations ne commutent pas en général. Seuls les plans sans coordonnée commune, comme XY et ZW, peuvent s'échanger.

/// MSL — Tesseract.metal — update:20/10/26
vertex VertexOut vertex4D(uint                 vid      [[vertex_id]],
                          constant Vertex4D*   vertices [[buffer(0)]],
                          constant Uniforms4D& uniforms [[buffer(1)]])
{
  float4 vertice = vertices[vid].position;

  // remember original w for coloring (before any rotation)
  //    w ∈ {-1, +1} → distinguishes inner / outer cube shells of the tesseract
  float wOrig = vertice.w;   // -1 = "inner" cube, +1 = "outer" cube

  vertice = rotXY(vertice, uniforms.angleXY);
  vertice = rotXZ(vertice, uniforms.angleXZ);
  vertice = rotXW(vertice, uniforms.angleXW);
  vertice = rotYZ(vertice, uniforms.angleYZ);
  vertice = rotYW(vertice, uniforms.angleYW);
  vertice = rotZW(vertice, uniforms.angleZW);

  // 4D → 3D  (perspective divide by fov4D - w) ───────────────────────────
  //    fov4D is the camera distance along the 4th axis.
  //    Result: p3 ∈ R^3
  float inv4D = 1.0 / (uniforms.fov4D - vertice.w);
  float3 p3   = vertice.xyz * inv4D;

  // 3D → 2D  (perspective divide by fov3D - z) ────────────────────────────
  //    fov3D is the camera distance along the Z axis.
  //    Result: p2 ∈ R^2  (approx. in [-1, 1] for reasonable fovs)
  float inv3D = 1.0 / (uniforms.fov3D - p3.z);
  float2 p2   = p3.xy * inv3D;

  // NDC aspoect ratio
  float aspect = uniforms.windowSize.x / uniforms.windowSize.y;
  p2 *= uniforms.scale;
  p2.x /= aspect;

  // inner shell (wOrig == -1) → cold cyan-blue
  // outer shell (wOrig == +1) → warm orange
  // additional luminance modulation by 4D depth (inv4D) → near faces glow
  float t      = (wOrig + 1.0) * 0.5;
  float4 colA  = float4(0.15, 0.55, 1.00, 1.0); // inner: blue
  float4 colB  = float4(1.00, 0.45, 0.10, 1.0); // outer: orange
  float4 color = mix(colA, colB, t);

  // brightness boost for vertices closest along the 4th axis
  float brightness = mix(0.55, 1.0, saturate(inv4D * uniforms.fov4D * 0.5));
  color.rgb *= brightness;

  VertexOut out;
  out.position = float4(p2, 0.0, 1.0);
  out.color    = color;
  return out;
}

fragment float4 fragment4D(VertexOut in [[stage_in]])
{
  return in.color;
}

La classe Renderer4D

Le constructeur fait tout le travail lourd une seule fois : les 16 sommets et les 64 indices partent dans deux buffers MTL::ResourceStorageModeShared, les deux fonctions du shader sont récupérées par leur nom, et le pipeline est compilé. À chaque image, update() avance les angles et draw() recopie les valeurs dans le buffer d'uniforms, puis lance un seul draw call.

drawIndexedPrimitives() avec MTL::PrimitiveTypeLine lit les indices deux par deux : 64 indices, 32 segments. Chaque sommet n'est stocké qu'une fois alors qu'il appartient à 4 arêtes, et le GPU peut réutiliser un sommet qu'il vient de transformer : c'est l'intérêt des indices.

Lignes et buffer d'uniforms

Metal trace toujours ses lignes avec 1 pixel d'épaisseur, il n'existe pas de réglage de largeur. Pour des arêtes plus épaisses, il faut dessiner des rectangles fins (2 triangles par arête).

Le buffer d'uniforms n'existe qu'en un exemplaire, réécrit à chaque image. Ça fonctionne tant que draw() du Renderer se termine par waitUntilCompleted() : le GPU a fini de lire avant que le CPU n'écrive l'image suivante. Sans cette attente, utilise setVertexBytes() (prévu pour moins de 4 Ko, nos 48 octets y tiennent largement) ou un buffer par image en vol.

/// C++ — Tesseract.cpp — update:20/10/26
#include "Tesseract.hpp"

#include <cassert>

Renderer4D::Renderer4D(MTL::Device* device, MTL::Library* shaderLibrary,
                       MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat)
{
  buildTesseract(device);

  auto vertexFunction = NS::TransferPtr(shaderLibrary->newFunction(MTLSTR("vertex4D")));

  auto fragmentFunction = NS::TransferPtr(shaderLibrary->newFunction(MTLSTR("fragment4D")));

  assert(vertexFunction && "vertex4D not found in library – check Shader4D.metal is in target");
  assert(fragmentFunction && "fragment4D not found in library");

  auto renderPipelineDescriptor = NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init());
  renderPipelineDescriptor->setVertexFunction(vertexFunction.get());
  renderPipelineDescriptor->setFragmentFunction(fragmentFunction.get());

  //additive blending: wires glow nicely over dark background
  //  ca->setBlendingEnabled(true);
  //  ca->setRgbBlendOperation(MTL::BlendOperationAdd);
  //  ca->setAlphaBlendOperation(MTL::BlendOperationAdd);
  //  ca->setSourceRGBBlendFactor(MTL::BlendFactorSourceAlpha);
  //  ca->setDestinationRGBBlendFactor(MTL::BlendFactorOne);
  //  ca->setSourceAlphaBlendFactor(MTL::BlendFactorOne);
  //  ca->setDestinationAlphaBlendFactor(MTL::BlendFactorOne);

  renderPipelineDescriptor->colorAttachments()->object(0);
  renderPipelineDescriptor->colorAttachments()->object(0)->setPixelFormat(colorPixelFormat);
  renderPipelineDescriptor->setDepthAttachmentPixelFormat(depthPixelFormat);

  NS::Error* error = nullptr;
  m_pso = NS::TransferPtr(device->newRenderPipelineState(renderPipelineDescriptor.get(), &error));
  assert(!error && "Renderer4D pipeline compilation failed");

  m_ubo = NS::TransferPtr(device->newBuffer(sizeof(Uniforms4D),
                                            MTL::ResourceStorageModeShared));
}

Renderer4D::~Renderer4D()
{}
/// C++ — Tesseract.cpp — update:20/10/26
void Renderer4D::draw(MTL::RenderCommandEncoder* renderCommandEncoder, simd::float2 windowSize)
{
  Uniforms4D* uniforms = reinterpret_cast<Uniforms4D*>(m_ubo->contents());
  uniforms->windowSize = windowSize;
  uniforms->time       = m_time;
  uniforms->angleXY    = m_aXY;
  uniforms->angleXZ    = m_aXZ;
  uniforms->angleXW    = m_aXW;
  uniforms->angleYZ    = m_aYZ;
  uniforms->angleYW    = m_aYW;
  uniforms->angleZW    = m_aZW;
  uniforms->fov4D      = fov4D;
  uniforms->fov3D      = fov3D;
  uniforms->scale      = scale;

  renderCommandEncoder->setRenderPipelineState(m_pso.get());

  renderCommandEncoder->setVertexBuffer(m_vbo.get(), 0, 0); // buffer(0) : Vertex4D array
  renderCommandEncoder->setVertexBuffer(m_ubo.get(), 0, 1); // buffer(1) : Uniforms4D

  renderCommandEncoder->drawIndexedPrimitives(MTL::PrimitiveTypeLine,
                                              m_indexCount,
                                              MTL::IndexTypeUInt16,
                                              m_ibo.get(), NS::UInteger(0));
}

Brancher dans le Renderer

/// C++ — Renderer.hpp — update:20/10/26
#include "Tesseract.hpp"

private:
  Renderer4D m_4d;
/// C++ — Renderer.cpp — update:20/10/26 — initialisation = constructeur
m_4d(m_device, m_shaderLibrary, m_pixelFormat, m_depthPixelFormat)
/// C++ — Renderer.cpp — update:20/10/26 — update()
m_4d.update(delta);
/// C++ — Renderer.cpp — update:20/10/26 — draw()
m_4d.draw(renderCommandEncoder, m_windowSize);
⬡CheckPoint Compilation
Le rendu 4D au milieu de l'animation