Tout ce dont tu as besoin pour ouvrir une MTKView et peut-être lancer ta première application
À partir de ce chapitre, nous ajouterons du code petit à petit au même projet, sur des dizaines de chapitres.
- Le quartz pour l'animation
- Ton premier run
Ton fichier main : ton programme débute son exécution ici
Ci-dessous se trouve le seul et unique fichier écrit en Objective-C du projet.
Grâce à lui, tu peux lancer une application macOS;
On s'occupera un peu plus tard du rendu sur l'environnement iOS, iPadOS, etc …
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // bloc de commentaire
/* + + */ // comment block
/* File: main.m +++ +++ */ // commentaarblok
/* + + */ // pour personnaliser le tien :
/* By: Laboitederemdal + + */ // to customize your own:
/* + + */ // om die van jou aan te passen:
/* Created: 16/04/2026 04:01:42 + + + + + + */ // ↘ Configuration ZSH .zshrc
/* Updated: 15/10/2026 */ // ↘ ZSH configuration .zshrc
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // ↘ ZSH-configuratie .zshrc
#import <Cocoa/Cocoa.h>
#import "AppViewController.h"
int main(int argc, const char* argv[])
{
NSApplication* application = [NSApplication sharedApplication];
ApplicationController* applicationController = [[ApplicationController alloc] init];
application.delegate = applicationController;
return (NSApplicationMain(argc, argv));
}
À partir de ce fichier tu peux déjà Créer et personnaliser le menu de ton application à droite du menu Pomme Grâce à NSMenu, NSMenuItem, NSSlider, …
Il n'existe pas de fichier header pour le fichier main. Peu importe le langage utilisé. Aucun autre fichier n'en a besoin.
La fenêtre, la vue Metal et notamment les entrées claviers/souris passent par AppKit — le framework UI de macOS, écrit en Objective-C. On ne peut pas y échapper.
Mais on limite le contact aux fichiers .mm qui font le pont entre l'Obj-C et notre code C++ pur.
AppViewController.mm gère uniquement la fenêtre et les callbacks système.
Il instancie notre rendu C++ et lui passe le pointeur vers notre GPU MTL::Device.
Un point rapide sur les éléments utiles à notre projet ;
- Cocoa.h → framework Cocoa (sans wrapper C++) → il prend directement le code en Obj-C de ton OS,
et permet notamment d'utiliser l'objet/classe NSApplication avec toutes ses propriétés, toutes ses méthodes et tous ses protocoles. - NSApplication → gère la boucle d'événement principale de toute application et conserve une liste de tous les objets NSWindow
pour distribuer les événements aux objets NSResponder appropriés sauf si la touche Commande est enfoncée lorsqu'un événement de frappe se produit. - sharedApplication → méthode (fonction associée à une classe) NSApplication qui initialise l'environnement d'affichage et connecte notre programme au serveur de fenêtres.
Elle crée l'instance unique au premier appel, puis renvoie toujours la même : on récupère ici un pointeur vers l'application, que l'on nommeapplication. - ApplicationController → alloue (allocate) de la mémoire pour ton objet Objective-C++ et l'initialise. C'est notre classe écrite en Objective-C++.
- .delegate = …; → propriété de NSApplication → notre objet devient le délégué de la boucle/de l'application. (setter).
De cette manière, notre application reçoit directement les NSNotification et nous pouvons les gérer dans notre classe
— et comme elle est écrite en Obj-C++, elle nous ouvre la porte du C++ !.
Attention :NSApplication.delegateest une référence weak.
C'est la variable localeapplicationControllerqui maintient l'objet en vie — ce qui suffit ici, puisque la fonction ne se termine jamais. - NSApplicationMain → fonction main() de l'application, elle démarre la boucle, un peu comme ton système d'exploitation pour afficher constamment à l'écran, c'est là que la magie opère
- On passe de rien à une application fonctionnelle, on va pouvoir interagir avec l'ordinateur autrement que par le terminal,
contrairement au C & C++, cette fonction ne renvoie rien, elle s'arrête lorsque l'on interrompt la boucle. Tout comme ton système d'exploitation (en partie). - argc / argv → identique au C et autres, pour notre part, l'application se lancera sans prendre d'entrée (fichier image, argument texte, …) et affichera nos rendus.
(argument count = 1) : le chemin de l'exécutable est toujours passé en premier argument. Aperçu dans le chapitre concernant la vitamine-C.
Où explorer les fonctionnalités existantes de chaque objet des frameworks Apple
- directement dans les headers Obj-C (souvent commentés par Apple)
- ou click-droit dans Xcode sur l’élément.
C'est ici que ton include #import <Cocoa/Cocoa.h> va chercher le code Obj-C :
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks
Structure des fichiers
Une fois sur le projet, tu peux le réorganiser de cette manière :
MSLearn/
├── Frameworks/ # headers officiels Apple
│ ├── metal-cpp/
│ └── metal-cpp-extensions/
├── MSLearn.entitlements # optionnel
├── Application/ # sources Objective-C / Objective-C++
│ ├── main.m
│ ├── AppViewController.h
│ ├── AppViewController.mm
│ └── macOS/
│ └── macOSInfo.plist
├── Renderer/ # logique de rendu + headers .hpp
│ ├── Renderer.cpp
│ └── Renderer.hpp
├── Shaders/ # shaders
│ └── Fullscreen.metal # fichier MSL
├── includes/ # headers .h (C++ / MSL)
│ └── SharedGPU/ # des fichiers partagés entre les langages C++ & MSL
│ └── Renderer_shared.h
├── .gitignore # du chapitre précédent, fichier caché
└── Makefile
En suivant la même structure, tu ne rencontreras aucun problème d'includes.
Xcode voit tous les fichiers, Makefile doit indiquer où ils se trouvent.
Paires clé-valeur (en XML, comme le .plist)
qui accordent à ton exécutable le droit d'utiliser un service ou une technologie protégée par le système :
iCloud, notifications push, Game Center, réseau, accès aux fichiers, etc.
La différence : le .plist décrit ton application (nom, version, icône, …), le .entitlements lui donne des permissions.
Il n'est pas copié tel quel dans le bundle : il est gravé dans la signature de l'exécutable par codesign.
Résultat, impossible de le modifier après coup sans casser la signature, et c'est le système (le noyau) qui le vérifie au lancement.
Quand entre-t-il en jeu ? Dès la signature. Il devient indispensable dès que :
— tu publies sur le Mac App Store : l'App Sandbox (com.apple.security.app-sandbox) y est obligatoire.
— ton application est sandboxée et doit sortir de sa « boîte » (réseau, dossiers de l'utilisateur, caméra, …).
— tu utilises un service Apple (iCloud/CloudKit, push, Game Center, App Groups).
Ces droits-là doivent aussi être autorisés par ton provisioning profile, sinon le système refuse de lancer l'application.
— tu distribues hors App Store avec le Hardened Runtime (nécessaire pour la notarisation)
et qu'il te faut une exception (ex. com.apple.security.cs.allow-jit).
Pour notre application Metal, qui tourne en local sans service ni sandbox, il est donc optionnel.
Exemple tiré de GlossDev, notre application Swift qui utilise plusieurs services :
<dict>
<key>aps-environment</key> <!-- notifications push -->
<string>development</string> <!-- "production" une fois distribuée -->
<key>com.apple.developer.game-center</key> <!-- Game Center -->
<true/>
<key>com.apple.developer.icloud-services</key> <!-- iCloud via CloudKit -->
<array>
<string>CloudKit</string>
</array>
<key>com.apple.security.application-groups</key> <!-- données partagées avec un widget -->
<array> <!-- ou une extension -->
<string>group.dev.learnmsl.glossdev</string>
</array>
</dict>
Avec Xcode, l'onglet Signing & Capabilities remplit ce fichier pour toi.
Avec un Makefile, tu le passes à la signature : codesign --force --options runtime --entitlements MSLearn.entitlements --sign "Developer ID Application: …" MSLearn.app, et tu vérifies le résultat avec codesign -d --entitlements - MSLearn.app.
Les règles make sign, make notarize et make appstore du ↘ Makefile enchaînent tout ça pour toi.
Cependant, c'est la seule chose que notre Makefile ne contient pas,
il est beaucoup plus facile de créer ton archive via Xcode avant de l'envoyer pour vérification.
La migration de la méthode utilisant Make jusqu'à Xcode est relativement simple.
Un fichier exemple de fichier macOSInfo.plist
→ Tu as peut-être dû supprimer le fichier Storyboard généré par Xcode ainsi que l'appel de celui-ci.
Cette liste (voir photo) correspond au fichier .plist que nous allons rédiger manuellement, écrit en XML (langage de balisage).
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>$(DEVELOPMENT_LANGUAGE)</string>
<key>CFBundleExecutable</key>
<string>$(EXECUTABLE_NAME)</string>
<key>CFBundleIdentifier</key>
<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>$(PRODUCT_NAME)</string>
<key>CFBundleShortVersionString</key>
<string>$(MARKETING_VERSION)</string>
<key>CFBundleSupportedPlatforms</key>
<array>
<string>MacOSX</string>
</array>
<key>CFBundleVersion</key>
<string>$(CURRENT_PROJECT_VERSION)</string>
<key>GCSupportsControllerUserInteraction</key>
<true/>
<key>LSApplicationCategoryType</key>
<string>public.app-category.graphics-design</string>
<key>LSMinimumSystemVersion</key>
<string>27.2</string>
<key>MetalCaptureEnabled</key>
<true/>
<key>NSHumanReadableCopyright</key>
<string>Copyright © 2026 Rémy Gralinger. All rights reserved.</string>
<key>CFBundleIconFile</key>
<string>AppIcon.icns</string>
<key>NSPrincipalClass</key>
<string>NSApplication</string>
<key>CFBundlePackageType</key>
<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
<key>CFBundleDisplayName</key>
<string>MSLearn</string>
</dict>
</plist>
Sans storyboard ni nib principal, c'est cette clé qui indique à macOS quelle classe instancier au lancement.
Si tu l'oublies, l'application se lance sans jamais afficher de fenêtre.
Si tu utilises le Makefile, les variables $() du .plist ne sont pas connues par celui-ci,
remplace simplement les valeurs par une chaîne de caractères comme suit :
XML
<key>CFBundleExecutable</key>
<string>MSLearn</string>
Pour l'instant nous n'utiliserons pas de Storyboard (.storyboard)
Le fichier .entitlements, tu peux le garder.
Configuration de l'application
Celle-ci est actuellement vide, on déclare alors ce dont on a besoin et ce qui est nécessaire.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* + + */
/* File: AppViewController.h +++ +++ */
/* + + */
/* By: Laboitederemdal + + */
/* + + */
/* Created: 16/04/2026 04:59:56 + + + + + + */
/* Updated: 12/10/2026 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#import <MetalKit/MetalKit.h> // MTKView / MTKViewDelegate
@interface ApplicationController : NSObject <NSApplicationDelegate, NSWindowDelegate, MTKViewDelegate>
@property (nonatomic, strong, readonly) MTKView* _Nonnull mtkView;
// se terminera
- (void)applicationWillTerminate:(NSNotification* _Nonnull)notification;
// a terminé son lancement
- (void)applicationDidFinishLaunching:(NSNotification* _Nonnull)notification;
// doit se terminer après la fermeture de la dernière fenêtre
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication* _Nonnull)sender;
- (void)drawInMTKView:(MTKView* _Nonnull)view;
- (void)mtkView:(MTKView* _Nonnull)view drawableSizeWillChange:(CGSize)size;
@end
Un nouveau point rapide :
- NSApplicationDelegate
/NSWindowDelegate → protocole (signatures de méthodes publiques).
Il s'agit donc d'un ensemble de méthodes accessibles depuis l'extérieur d'une classe, par lesquelles on peut agir sur un objet, ou plus généralement communiquer avec lui. - NSNotification → classe appartenant à Foundation → communication entre l'OS et notre app.
- NSObject → classe racine de la plupart des hiérarchies Objective-C,
à partir de laquelle les sous-classes héritent d'une interface de base au système d'exécution et de la capacité de se comporter comme des objets Objective-C. Prototypes des méthodes application…→ méthodes de cycle de vie AppKit.
Les redéclarer ici n'est pas obligatoire (les protocoles les fournissent déjà), mais ça rend le contrat public de ApplicationController explicite :
main.m importe ce header et en crée une instance. Le compilateur vérifie que tu respectes ce contrat et les protocoles adoptés.draw()→ "ton terrain de jeu", on va dessiner ici après avoir nous aussi créé des fonctions et shaders.- drawableSizeWillChange → appelée à chaque fois que la taille du drawable change.
- MTKViewDelegate → protocole qui fournit drawInMTKView & drawableSizeWillChange pour une MTKView (MTK::View côté C++).
Sur ce site, tu verras également comment mettre en place l'autre manière d'utiliser Metal — via un CAMetalLayer (Core Animation Layer) — qui demande davantage de configuration.
La principale différence entre Cocoa et AppKit tient au fait que Cocoa est un framework d'application complet (un parapluie),
tandis qu'AppKit en est la sous-partie spécialisée dans l'interface utilisateur sur macOS.
MetalKit.h importe AppKit en entier ; MetalKit.hpp importe AppKit.hpp.
Le préfixe NS vient de NeXTSTEP :
on le retrouve aussi bien dans Foundation (NSString, NSArray, NSNotification) que dans AppKit (NSWindow, NSView, NSApplication).
Ce n'est donc pas un marqueur de framework.
AppKit.hpp n'expose qu'une petite fraction de AppKit.h : le strict nécessaire pour créer une fenêtre et une vue.
Ce n'est pas une limitation — ce qui manque, on l'écrit dans notre fichier .mm.
L'implémentation
Il a été décidé de créer une fonction pour créer la fenêtre et une autre pour créer la vue
en supplément des fonctionnalités fournies par l'API et l'OS.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* + + */
/* File: AppViewController.mm +++ +++ */
/* + + */
/* By: Laboitederemdal + + */
/* + + */
/* Created: 16/04/2026 05:43:06 + + + + + + */
/* Updated: 12/10/2026 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#import "../Renderer/Renderer.hpp"
#import "AppViewController.h"
#pragma mark - RenderWindow // Ignoré par le compilateur
#pragma region RenderWindow { // indication visuelle
@interface RenderWindow : NSWindow // Déclaration de notre classe Obj-C
@property (weak) ApplicationController* appCoordinator; // Un pointeur vers notre classe Obj-C++
// observe son propriétaire → weak
@end
@implementation RenderWindow // Implémentation de notre classe Obj-C
{
}
- (instancetype)initWithContentRect:(NSRect)rect
styleMask:(NSWindowStyleMask)mask // Paramètres de la fonction (NSRect inclus)
backing:(NSBackingStoreType)backing
defer:(BOOL)flag
screen:(NSScreen*)screen
{
self = [super initWithContentRect:rect styleMask:mask backing:backing defer:flag screen:screen];
return self;
}
@end
#pragma endregion RenderWindow }
#pragma mark - ApplicationController
#pragma region ApplicationController {
@implementation ApplicationController
{
RenderWindow* _window; // possède RenderWindow → strong
std::unique_ptr<Renderer> m_renderer; // Notre classe C++
}
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication*)sender
{
return (YES);
}
- (void)applicationDidFinishLaunching:(NSNotification*)notification
{
[self createWindow]; // des fonctions à nous, qui sont appelées
[self createView];
}
- (void)applicationWillTerminate:(NSNotification*)notification
{
m_renderer.reset(); // Détruit (release) "std::unique_ptr"
}
- (void)createWindow
{
NSWindowStyleMask mask = NSWindowStyleMaskClosable | NSWindowStyleMaskTitled |
NSWindowStyleMaskMiniaturizable | NSWindowStyleMaskResizable;
NSRect contentRect = NSMakeRect(0, 0, 1280, 720);
NSScreen* screen = [NSScreen mainScreen];
contentRect.origin.x = 0;
contentRect.origin.y = (screen.frame.size.height / 2) - (contentRect.size.height / 2);
_window = [[RenderWindow alloc] initWithContentRect:contentRect styleMask:mask
backing:NSBackingStoreBuffered defer:NO screen:screen];
_window.releasedWhenClosed = NO;
_window.minSize = NSMakeSize(640, 360);
_window.delegate = self;
_window.appCoordinator = self;
screen = _window.screen;
NSString* title = [NSString stringWithFormat:@"LearnMSL.dev : MSL x C++ (%@ @ %ldHz, EDR max: %.2f)",
screen.localizedName, (long)screen.maximumFramesPerSecond,
screen.maximumPotentialExtendedDynamicRangeColorComponentValue];
_window.title = title;
[_window makeKeyAndOrderFront:_window];
[_window setIsVisible:YES];
[_window makeMainWindow];
}
- (void)createView
{
id<MTLDevice> device = MTLCreateSystemDefaultDevice();
_mtkView = [[MTKView alloc] initWithFrame:_window.contentLayoutRect device:device];
_mtkView.preferredFramesPerSecond = 120;
_mtkView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
_mtkView.colorPixelFormat = MTLPixelFormatRGBA16Float;
_mtkView.depthStencilPixelFormat = MTLPixelFormatDepth32Float;
_mtkView.colorspace = CGColorSpaceCreateWithName(kCGColorSpaceExtendedLinearDisplayP3);
_mtkView.framebufferOnly = YES;
_mtkView.paused = NO;
_mtkView.delegate = self;
_mtkView.enableSetNeedsDisplay = NO;
NSTrackingArea* trackingArea = [[NSTrackingArea alloc]
initWithRect:_mtkView.bounds
options:(NSTrackingMouseMoved | NSTrackingActiveInKeyWindow |
NSTrackingInVisibleRect | NSTrackingActiveAlways)
owner:self userInfo:nil];
[_mtkView addTrackingArea:trackingArea];
NSScreen* screen = _window.screen ?: [NSScreen mainScreen];
CGFloat scale = screen.backingScaleFactor ?: 1.0;
CGSize sizePts = _mtkView.bounds.size;
_mtkView.drawableSize = CGSizeMake(sizePts.width * scale, sizePts.height * scale);
_window.contentView = _mtkView;
m_renderer = std::make_unique<Renderer>((__bridge MTL::Device *)_mtkView.device,
NSBundle.mainBundle.resourcePath.UTF8String,
(NS::UInteger)_mtkView.drawableSize.width,
(NS::UInteger)_mtkView.drawableSize.height,
(MTL::PixelFormat)_mtkView.colorPixelFormat,
(MTL::PixelFormat)_mtkView.depthStencilPixelFormat);
}
- (void)drawInMTKView:(nonnull MTKView *)view
{
m_renderer->draw((__bridge MTK::View *)view, CACurrentMediaTime());
}
- (void)mouseMoved:(NSEvent *)event
{
}
- (void)mtkView:(MTKView *)view drawableSizeWillChange:(CGSize)size
{
m_renderer->resizeViewWindow((NS::UInteger)size.width, (NS::UInteger)size.height);
}
@end
#pragma endregion ApplicationController }
Pour mieux comprendre les fonctions "obligatoires" de chaque protocole à mettre en place ↘ Objective-C++ vs C++ : syntaxe & documentation.
(Tu y arriveras dans quelques chapitres.)
Un nouveau point rapide :
- applicationShouldTerminateAfterLastWindowClosed → le protocole qui renvoie si oui (YES) ou non (NO) l'application doit être fermée.
- applicationDidFinishLaunching → méthode de délégué appelée une fois le lancement terminé. C'est le bon endroit pour créer la fenêtre et la vue.
- applicationWillTerminate → appelée juste avant la fermeture. On y libère le renderer, avant que le processus ne disparaisse.
- MTLCreateSystemDefaultDevice() → fonction (pas un protocole) qui renvoie le GPU par défaut du système.
Sur les anciens Macs Intel à double GPU, l'appel provoquait le basculement vers le GPU haute performance ;
sur Apple Silicon il n'y a qu'un seul GPU, donc pas d'ambiguïté. - __bridge → (~cast) liaison de pointeurs entre objets Objective-C et objets Core Foundation (toll-free bridging),
sans transfert de propriété : le compilateur ne touche pas au compteur de références.
C'est exactement ce qu'il nous faut pour passer une MTKView ou un MTLDevice à metal-cpp. - mouseMoved() → puisque NSTrackingMouseMoved est activé, la méthode doit exister dans notre classe pour éviter une erreur de selector à l'exécution.
- NSTrackingArea → les options « actives » sont exclusives : on en choisit une seule (NSTrackingActiveInKeyWindow ici).
Passer NSTrackingActiveAlways en plus est contradictoire.
Cycle de vie
macOS · AppKit
main.m ----- NSApplication → boucle d'events macOS
Objective-C · pont | delegate
------------- ApplicationController → cycle de vie, resize
| strong | | | delegate
| | | MTKView → surface de dessin - EDR - 120 images par secondes
| | weak |
RenderWindow - - - | unique_pointeur
→ inputs |
C++ · Metal |
Renderer → draw - commandQueue
|
GPU · Metal → commandBuffer - drawable
Nous aurons besoin d'un pont Objective-C (le langage très utilisé par Apple et obligatoire pour notre projet)
afin de gérer l'audio, les manettes de jeu, l'écran tactile, …
N'hésite pas à personnaliser ta fenêtre. Par exemple, une ligne suffit pour la centrer :
// dans notre fonction createWindow() après l'allocation
[_window center];
Tu pourrais également lancer l'application en plein écran par défaut.
Nous l’avons placée au milieu à gauche. Quasiment tout est là pour configurer la fenêtre, ce qui n'est pas expliqué ici le sera après.
De cette manière tu peux déjà ouvrir une fenêtre — une application !
La classe RenderWindow (classe privée), définie entièrement dans AppViewController.mm n'a pas de header du tout, personne d'autre n'en a besoin.
Ce sont des overrides de NSResponder — elles existent déjà dans la superclasse NSWindow.
Tu ne crées pas une nouvelle interface, tu écrases un comportement existant. Le compilateur n'a pas besoin qu'on lui redéclare ce qu'il connaît déjà.
Si tu compares avec les Wrappers C++, le principe est le même.
Code de gestion mémoire injecté par le compilateur à la compilation (retain/release), que tu aurais écrit à la main en MRC (Manual Reference Counting).
ApplicationController* controller = [[ApplicationController alloc] init];
// Ce que le compilateur ARC ajoute — alloc/init renvoie déjà +1,
// ARC n'ajoute donc pas de retain, seulement le release de fin de portée
ApplicationController* controller = [[ApplicationController alloc] init]; // +1
[controller retain];
…
[controller release]; // inséré automatiquement
Chaque objet Obj-C a un retain count interne :
strong +1 au retain count Propriétaire
weak 0, mis à nil si l'objet meurt Delegate, référence inverse
assign 0, pas mis à nil (dangereux) Types primitifs uniquement
copy +1 sur une copie NSString, blocs
Nous verrons retain() qui compte automatiquement dans notre C++ (notamment le pointeur vers MTLDevice)
Retain cycle
A ──strong──▶ B retain count A = 1 (tenu par B)
▲ │ retain count B = 1 (tenu par A)
└───strong─────┘ → jamais libérés, même si plus personne d'autre ne les référence
ApplicationController ──strong───▶ RenderWindow
▲ │
└────────────────weak──────────┘
ARC ne concerne que le code Obj-C, ne t'en inquiète pas trop.
En MSL & C++ on gère manuellement la mémoire, nous avons tout de même un RAII maison qui simule ARC.
Resource Acquisition Is Initialization ou « l'acquisition de ressource est une initialisation » est un idiome de programmation, principalement utilisé en C++,
liant la gestion des ressources (mémoire, fichiers, mutex) à la durée de vie d'un objet.
La ressource est acquise au constructeur et libérée automatiquement dans le destructeur, garantissant une libération sûre.
Le minimum en C++
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* + + */
/* File: Renderer.hpp +++ +++ */
/* + + */
/* By: Laboitederemdal + + */
/* + + */
/* Created: 16/04/2026 10:33:22 + + + + + + */
/* Updated: 12/10/2026 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef RENDERER_HPP
#define RENDERER_HPP
#include <string> // std::string (utilisé dans le constructeur)
#include <simd/simd.h> // all simd
#include <iostream> // pour afficher dans la console / DEBUG
#include <MetalKit/MetalKit.hpp> // fichier C++ → wrapper C++
#include "FrameClock.hpp"
class Renderer
{
public:
Renderer(MTL::Device* device, // constructeur
const std::string& resourcePath,
NS::UInteger width, NS::UInteger height,
MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat);
~Renderer(); // destructeur
void draw(MTK::View* view, double quartz); // heure Quartz (CACurrentMediaTime)
void resizeViewWindow(NS::UInteger width, NS::UInteger height);
private:
void update(const FrameTime& time);
MTL::Device* m_device;
MTL::Library* m_shaderLibrary;
MTL::CommandQueue* m_commandQueue;
MTL::PixelFormat m_pixelFormat;
MTL::PixelFormat m_depthPixelFormat;
FrameClock m_clock; // le tempo commun : un seul delta
};
#endif /* RENDERER_HPP */
C'est presque terminé :
- Construction de notre classe principale → elle reçoit la taille de la fenêtre, le chemin du dossier des assets externes,
les formats de pixels dont on a besoin et le pointeur vers notre GPU. - Library → les shaders compilés, dans le fichier .metallib.
- GPU → il alloue la mémoire sur la puce (un M2 Pro dans mon cas),
lit les fonctions de vertex et de fragment shader écrites en MSL, détient la file de commandes, …
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* + + */
/* File: Renderer.cpp +++ +++ */
/* + + */
/* By: Laboitederemdal + + */
/* + + */
/* Created: 16/04/2026 10:33:18 + + + + + + */
/* Updated: 12/10/2026 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define NS_PRIVATE_IMPLEMENTATION
#define CA_PRIVATE_IMPLEMENTATION
#define MTL_PRIVATE_IMPLEMENTATION
#define MTK_PRIVATE_IMPLEMENTATION
#include "Renderer.hpp"
Renderer::Renderer(MTL::Device* device,
const std::string& resourcePath,
NS::UInteger width, NS::UInteger height,
MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat)
: m_device(device->retain()),
m_shaderLibrary(m_device->newDefaultLibrary()),
m_commandQueue(m_device->newCommandQueue()),
m_pixelFormat(colorPixelFormat), m_depthPixelFormat(depthPixelFormat)
{
}
Renderer::~Renderer()
{ // Pointeurs, on libère les cases mémoire allouées.
m_commandQueue->release();
m_shaderLibrary->release();
m_device->release();
}
void Renderer::update(const FrameTime& time)
{
const float delta = time.delta; // le même pour tout le monde cette frame
}
void Renderer::draw(MTK::View* view, double quartz)
{
NS::AutoreleasePool* autoreleasePool = NS::AutoreleasePool::alloc()->init();
update(m_clock.tick(quartz)); // le seul endroit où le temps avance
MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
MTL::RenderPassDescriptor* renderPassDescriptor = view->currentRenderPassDescriptor();
{
MTL::RenderCommandEncoder* renderCommandEncoder = commandBuffer->renderCommandEncoder(renderPassDescriptor);
renderCommandEncoder->endEncoding();
}
commandBuffer->presentDrawable(view->currentDrawable());
commandBuffer->commit();
commandBuffer->waitUntilCompleted();
autoreleasePool->release();
}
void Renderer::resizeViewWindow(NS::UInteger width, NS::UInteger height)
{
}
newDefaultLibrary() renvoie nullptr tant qu'aucun .metallib n'est embarqué dans le bundle
— c'est le cas si tu n'as pas encore de fichier .metal.
D'où les tests dans le destructeur : appeler release() sur un pointeur nul plante.
waitUntilCompleted() bloque le CPU jusqu'à la fin du travail GPU.
C'est pratique pour valider un premier rendu et pour déboguer, mais ça sérialise CPU et GPU.
On l'enlèvera dans le chapitre consacré à la synchronisation.
Pour terminer, un point sur les fonctionnalités et classes proposées par Metal
- newDefaultLibrary() → charge le .metallib compilé depuis les shaders du projet.
- newCommandQueue() → crée la file de commandes GPU. C'est par elle que tous les commandBuffer seront soumis au GPU.
- NS::AutoreleasePool → zone mémoire temporaire qui libère automatiquement les objets autoreleased à la fin de chaque frame.
Indispensable dans la boucle de rendu metal-cpp. - MTL::CommandBuffer → enregistre une séquence de commandes GPU pour une seule frame (une seule image). Soumis au GPU via commit().
- MTL::RenderPassDescriptor → décrit les attachements de rendu (color, depth) d'un pass.
Fourni par la MTKView via currentRenderPassDescriptor(). - MTL::RenderCommandEncoder → encode les draw calls, les états du pipeline, les buffers et les textures d'un render pass.
Tu peux juste copier-coller le code et changer à ta façon, c'est relativement intuitif.
Le tempo du rendu
Une seule horloge, avancée une fois par frame à partir de l'heure Quartz (CACurrentMediaTime). De cette manière, tous les systèmes lisent le même FrameTime : même delta, même temps écoulé.
/// C++ — FrameClock.hpp — update:22/10/26
#ifndef FrameClock_hpp
#define FrameClock_hpp
#include <algorithm>
#include <cstdint>
struct FrameTime
{
double now = 0.0; // heure Quartz de la frame, en secondes (monotone, depuis le boot)
float delta = 0.f; // durée de la frame, bornée : après une pause, pas de téléportation
float elapsed = 0.f; // somme des delta : le temps de jeu (n'avance pas pendant les gros à-coups)
uint64_t index = 0; // numéro de frame
};
class FrameClock
{
public:
static constexpr float kMaxDelta = 0.1f;
const FrameTime& tick(double now)
{ // Première frame : pas de delta (rien à rattraper)
const double raw = m_started ? now - m_time.now : 0.0;
m_started = true;
m_time.now = now;
m_time.delta = std::clamp((float)raw, 0.f, kMaxDelta); // delta time — cappé à 100ms pour éviter les sauts après suspend
m_time.elapsed += m_time.delta;
m_time.index += 1;
return m_time;
}
const FrameTime& time() const { return m_time; }
private:
FrameTime m_time;
bool m_started = false;
};
#endif /* FrameClock_hpp */
Un point rapide sur le fichier :
- CACurrentMediaTime() → l'heure Quartz de Core Animation : des secondes depuis le démarrage du Mac, en double.
Elle est monotone : elle ne recule jamais, même si l'heure du système change.
AppViewController la lit à chaque frame et la passe à draw(). - FrameTime → ce que tous les systèmes lisent pendant une frame : now (l'heure Quartz), delta (la durée de la frame), elapsed (le temps de jeu) et index (le numéro de frame).
- tick(now) → appelée une seule fois par frame, au début de draw() : le delta est l'écart avec l'heure de la frame précédente.
À la première frame, il n'y a pas de frame précédente : le delta vaut 0. - kMaxDelta + std::clamp → le delta est borné à 0.1 s.
Après un point d'arrêt du débogueur ou une mise en veille, il vaudrait plusieurs secondes, et tout ce qui bouge avec vitesse × delta se téléporterait. - elapsed → la somme des delta bornés : le temps de jeu. Pendant un gros à-coup, il avance d'au plus 0.1 s, alors que l'heure Quartz, elle, continue.
- index → le numéro de frame, pratique pour faire quelque chose toutes les N frames (time.index % 5000).
- time() const → relit le FrameTime courant sans faire avancer l'horloge.
Si chaque système appelait CACurrentMediaTime() de son côté, chacun aurait un delta légèrement différent dans la même frame, et ils se désynchroniseraient.
Ici, draw() est le seul endroit où le temps avance : update(m_clock.tick(quartz)).
Tu auras une fenêtre noire à l'exécution parce que la texture du pass est vide (00000 …). Pour la changer :
/// C++ — Renderer.cpp — update:18/05/26
MTL::RenderPassDescriptor* renderPassDescriptor = view->currentRenderPassDescriptor();
renderPassDescriptor->colorAttachments()->object(0)->setClearColor(MTL::ClearColor(1.0, 0.3725, 0.1216, 1.0));
{ // l'orange de la marque · the brand's orange · de oranje kleur van het merk
MTL::RenderCommandEncoder* renderCommandEncoder = commandBuffer->renderCommandEncoder(renderPassDescriptor);
Il y a quelques exemples de couleurs dans le chapitre ↘ Couleurs
Le menu macOS de l'application
Inutilisé dans ce cours, il permet de créer le menu à côté de la pomme en haut à droite de chaque application.
/// Objective-C — main.m — update:23/10/26 — avant : main
#import <Cocoa/Cocoa.h>
#import "AppViewController.h"
static void makeSliderSubmenu(NSMenu* parentMenu, NSString* title, SEL action, double minValue, double maxValue, double defaultValue, NSInteger tickmarks)
{
NSMenu* submenu = [[NSMenu alloc] initWithTitle:title];
NSMenuItem* sliderHostItem = [parentMenu addItemWithTitle:title action:nil keyEquivalent:@""];
sliderHostItem.submenu = submenu;
NSSlider* slider = [NSSlider sliderWithTarget:nil action:action];
slider.frame = NSMakeRect(0, 0, 160, 16);
NSMenuItem* sliderItem = [submenu addItemWithTitle:@"" action:nil keyEquivalent:@""];
sliderItem.view = slider;
slider.numberOfTickMarks = tickmarks;
slider.minValue = minValue;
slider.maxValue = maxValue;
slider.intValue = defaultValue;
slider.allowsTickMarkValuesOnly = tickmarks ? YES : NO;
slider.autoresizingMask = NSViewMinXMargin|NSViewWidthSizable|NSViewMaxXMargin|NSViewMinYMargin|NSViewMaxYMargin|NSViewHeightSizable;
[slider sizeToFit];
}
static void createApplicationMenu(NSApplication* app)
{
app.mainMenu = [[NSMenu alloc] init];
NSString* bundleName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleName"];
NSMenu* appMenu = [[NSMenu alloc] initWithTitle:@""];
NSMenuItem* appMenuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
[appMenu addItemWithTitle:[@"About " stringByAppendingString:bundleName]
action:@selector(orderFrontStandardAboutPanel:)
keyEquivalent:@""];
[appMenu addItem:[NSMenuItem separatorItem]];
[appMenu addItemWithTitle:[@"Hide " stringByAppendingString:bundleName]
action:@selector(hide:)
keyEquivalent:@"h"];
NSMenuItem* hide_other_item = [appMenu addItemWithTitle:@"Hide Others"
action:@selector(hideOtherApplications:)
keyEquivalent:@"h"];
hide_other_item.keyEquivalentModifierMask = NSEventModifierFlagOption | NSEventModifierFlagCommand;
[appMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];
[appMenu addItem:[NSMenuItem separatorItem]];
[appMenu addItemWithTitle:[@"Quit " stringByAppendingString:bundleName]
action:@selector(terminate:)
keyEquivalent:@"q"];
appMenuItem.submenu = appMenu;
[app.mainMenu addItem:appMenuItem];
NSMenu* graphicsMenu = [[NSMenu alloc] initWithTitle:@"Graphics"];
NSMenuItem* graphicsMenuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
graphicsMenuItem.submenu = graphicsMenu;
// On pourra régler ces paramètres sur un shader
makeSliderSubmenu(graphicsMenu, @"Brightness", @selector(setBrightness:), 1, 10, 5, 9);
makeSliderSubmenu(graphicsMenu, @"EDR Demo", @selector(setEDRBias:), 0, 1, 0, 0);
[app.mainMenu addItem:graphicsMenuItem];
NSMenu* windowsMenu = [[NSMenu alloc] initWithTitle:@"Window"];
NSMenuItem* windowsMenuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
[windowsMenu addItemWithTitle:NSLocalizedString(@"Minimize", @"")
action:@selector(performMiniaturize:)
keyEquivalent:@"m"];
windowsMenuItem.submenu = windowsMenu;
[app.mainMenu addItem:windowsMenuItem];
app.windowsMenu = windowsMenu;
}
int main(int argc, const char* argv[])
{
NSApplication* application = [NSApplication sharedApplication];
createApplicationMenu(application); // Appelle ton menu
ApplicationController* applicationController = [[ApplicationController alloc] init];
application.delegate = applicationController;
return (NSApplicationMain(argc, argv));
}