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.

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, nous l'améliorerons sans oublier notre objectif. Grâce à lui, tu peux lancer une application macOS, on s'occupera un peu plus tard du rendu sur l'environnement IOS, iPadOS etc…

Le langage de ce début de chapitre sera rarement utilisé mais il est indispensable.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                        +       +          */
/*      File: main.m            +++     +++                  */
/*                                        +       +          */ // bloc de commentaire
/*      By: Laboitederemdal                +       +         */ // pour personnaliser le tien :
/*                                       +           +       */ // → Configuration ZSH .zshrc
/*      Created: 16/04/2026 04:01:42      + + + + + +        */
/*      Updated: 27/08/2026                                  */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#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));
}

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'ObjC et notre code C++ pur.

Création du projet

Xcode (pour les plus gros projets, recommandé)

Personnalisé (make)

Parce que c'est juste un fichier qui facile la compilation sans utiliser Xcode, nous te proposons la méthode la + répondue dans le monde du coding.

Dans le chapitre → Makefile se trouve un exemple solide et expliqué (en Shell).

Structure des fichiers

Un fois sur le projet tu peux le réorganiser de cette manière :

MSLearn/
├── MSLearn.entitlements        ← optionnel
├── Application/                ← sources Objective-C / Objective-C++
│   ├── main.m
│   ├── AppViewController.h
│   ├── AppViewController.mm
│   └── macOS/
│       └── macOSInfo.plist
├── Frameworks/                 ← headers officiels Apple
│   ├── metal-cpp/
│   └── metal-cpp-extensions/
├── 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
├── Makefile
└── .gitignore                  ← du chapitre précédent, fichier caché

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>26.0</string>
    <key>MetalCaptureEnabled</key>
    <true/>
    <key>NSHumanReadableCopyright</key>
    <string>Copyright © 2026 Laboitederemdal. 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>

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>

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: 27/08/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

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.

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: 27/08/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 ObjC

@property (weak) ApplicationController* appCoordinator;     // Un pointeur vers notre classe ObjC++
                                                            // observe son propriétaire → weak
@end

@implementation RenderWindow                                // Implémentation de notre classe ObjC
{
}

- (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> _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
{
    _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;
    _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
{
    static CFTimeInterval lastTime = CACurrentMediaTime();
    CFTimeInterval now = CACurrentMediaTime();
    float delta = (float)(now - lastTime);
    lastTime = now;
    delta = fminf(delta, 0.1f);
    _renderer->draw((__bridge MTK::View *)view, now, delta);
}

- (void)mouseMoved:(NSEvent *)event
{
}

- (void)mtkView:(MTKView *)view drawableSizeWillChange:(CGSize)size
{
    _renderer->resizeViewWindow((NS::UInteger)size.width, (NS::UInteger)size.height);
}

@end

#pragma endregion ApplicationController }

Pour mieux comprendre les fonctions "obligatoires" de chaque protocoles à mettre en place → Objective-C++ vs C++ : synthaxe & documentation. (Tu y arriveras dans quelques chapitres.)

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, …)

// dans notre fonction createWindow() après l'allocation
[_window center];

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.

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

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

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──────────┘

Le minimum en C++

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                        +       +          */
/*      File: Renderer.hpp            +++     +++            */
/*                                        +       +          */
/*      By: Laboitederemdal                +       +         */
/*                                       +           +       */
/*      Created: 16/04/2026 10:33:22      + + + + + +        */
/*      Updated: 27/08/2026                                  */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef RENDERER_HPP
#define RENDERER_HPP

#include <string>                     // std::string (utilisé dans le constructeur)
#include <simd/simd.h>                // all simd

#include <MetalKit/MetalKit.hpp>      // fichier C++ → wrapper C++

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 timeStamp, float delta);
    void resizeViewWindow(NS::UInteger width, NS::UInteger height);

private:
    void update(float delta);

    MTL::Device*                m_device;
    MTL::Library*               m_shaderLibrary;
    MTL::CommandQueue*          m_commandQueue;
    MTL::PixelFormat            m_pixelFormat;
    MTL::PixelFormat            m_depthPixelFormat;

    uint64_t                    frame;
};

#endif /* RENDERER_HPP */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                        +       +          */
/*      File: Renderer.cpp            +++     +++            */
/*                                        +       +          */
/*      By: Laboitederemdal                +       +         */
/*                                       +           +       */
/*      Created: 16/04/2026 10:33:18      + + + + + +        */
/*      Updated: 27/08/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),
frame(0)
{
}

Renderer::~Renderer()
{   // ← pointeurs, on libère les cases mémoire allouées.
    m_commandQueue->release();
    m_shaderLibrary->release();
    m_device->release();
}

void Renderer::update(float delta)
{
}

void Renderer::draw(MTK::View* view, double timeStamp, float delta)
{
    NS::AutoreleasePool* autoreleasePool = NS::AutoreleasePool::alloc()->init();
    
    frame += 1;

    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)
{
}

/// C++ — Renderer.cpp — update:18/05/26
MTL::RenderPassDescriptor* renderPassDescriptor = view->currentRenderPassDescriptor();
renderPassDescriptor->colorAttachments()->object(0)->setClearColor(MTL::ClearColor(0.9, 0.9, 0.9, 1.0));
{
    MTL::RenderCommandEncoder* renderCommandEncoder = commandBuffer->renderCommandEncoder(renderPassDescriptor);

Il y a quelques exemples de couleurs dans le chapitre → Couleurs.