VFX — des particules sur le GPU
Un VFX (visual effect), dans un jeu, c'est tout ce qui n'est pas un objet solide : le feu, la fumée, les étincelles d'un choc, la poussière soulevée par un pas, la traînée d'un sort. Rien de tout ça n'a de forme fixe : on ne le modélise pas dans Blender, on le simule.
Presque tous ces effets reposent sur la même recette, et ce chapitre la construit de zéro dans le moteur :
- des milliers de petits points, les particules, chacun avec sa position, sa vitesse et son âge ;
- un compute shader qui les fait vivre : un thread par particule, toutes en même temps ;
- un billboard par particule : un carré toujours tourné vers la caméra ;
- un blending additif : chaque particule ajoute sa lumière à l'image, et c'est ce qui donne l'impression de « briller ».
- Décrire une particule avec quatre nombres : position, vitesse, âge, durée de vie
- Simuler 20 000 particules dans un compute shader, sans jamais allouer de mémoire
- Fabriquer du hasard sur le GPU avec une fonction de hash
- Dessiner un billboard face caméra à partir de la matrice de vue
- Régler le blending additif et la profondeur pour que l'ordre de dessin n'ait plus d'importance
- ↘ Curseur 3D — ton premier compute shader
- ↘ Caméra — la matrice de vue
- ↘ Tone mapping — des couleurs au-dessus de 1.0
Une particule, c'est quatre nombres
Oublie les maillages : une particule n'a pas de triangles à elle. C'est une petite fiche :
- position — où elle est, dans le monde ;
- vitesse — de combien elle bouge par seconde ;
- âge — depuis combien de temps elle existe ;
- durée de vie — l'âge auquel elle meurt.
Tout le reste se déduit de l'âge : la couleur passe du jaune au rouge, la taille diminue, l'opacité s'éteint. On appelle \( t = \text{âge} / \text{durée de vie} \) la vie normalisée : 0 à la naissance, 1 à la mort. Chaque propriété visuelle est un simple mix(debut, fin, t).
Et chaque frame, pour chaque particule :
- elle vieillit :
age += dt; - si elle est trop vieille, elle renaît à l'émetteur avec une vitesse tirée au hasard ;
- sinon elle bouge : la gravité modifie la vitesse, la vitesse modifie la position.
Une particule ne meurt donc jamais vraiment : elle est recyclée. Le tableau a une taille fixe, décidée une fois pour toutes. Pas de new, pas de push_back, pas de erase : c'est ce qui rend le système si rapide.
Joue avec avant de coder
Voici exactement l'algorithme du moteur, réécrit en JavaScript pour tourner dans ta page. Chaque curseur correspond à un champ de ParticleUniforms qu'on écrira plus bas. Essaie les préréglages, puis :
- passe le blending en alpha : le feu devient une bouillie terne ;
- coche montrer les quads : chaque « boule de lumière » est en réalité un carré ;
- mets le freinage à 0 et la gravité vers le bas : tu obtiens une fontaine parfaite, trop parfaite.
La démo simule en 2D sur le processeur, une particule après l'autre : au-delà de quelques milliers elle ralentit. C'est justement la raison de la suite : sur le GPU, le moteur en anime 20 000 sans broncher.
Pourquoi sur le GPU
Sur le CPU, la boucle ressemblerait à ça :
/// C++ — Exemple, à NE PAS faire
for (Particle& p : particles) // 20 000 tours, l'un après l'autre…
updateParticle(p, dt);
memcpy(gpuBuffer, particles, size); // …puis on recopie tout vers le GPU, chaque frame
Deux problèmes : le processeur traite les particules une à une, et il faut renvoyer tout le tableau au GPU à chaque frame. Or le calcul d'une particule ne dépend d'aucune autre : c'est le cas idéal du compute shader. On lance 20 000 threads, chacun s'occupe de sa particule (thread_position_in_grid = son indice), et le tableau ne quitte jamais la mémoire du GPU : le vertex shader le lit directement au moment de dessiner.
Le CPU, lui, ne fait plus qu'une chose : remplir une petite structure de réglages, quelques centaines d'octets, chaque frame.
Le contrat CPU ↔ GPU
Comme pour chaque module du moteur, un header partagé décrit la mémoire que le C++ et le MSL lisent ensemble. Nouveau fichier includes/SharedGPU/Particles_shared.h :
/// C++ / MSL — Particles_shared.h — update:04/11/26
struct Particle
{
simd::float4 positionAge; // xyz = position (monde), w = âge en secondes (négatif = pas encore née)
simd::float4 velocityLifetime; // xyz = vitesse (unités / s), w = durée de vie en secondes
};
struct alignas(16) ParticleUniforms
{
simd::float4x4 viewProjectionMatrix; // monde → clip, pour le billboard
simd::float4 cameraRight; // xyz : la droite de l'écran, en monde
simd::float4 cameraUp; // xyz : le haut de l'écran, en monde
simd::float4 emitterPosition; // xyz : d'où sortent les particules, w = rayon du disque d'émission
simd::float4 gravity; // xyz : accélération constante (unités / s²)
simd::float4 colorBirth; // couleur HDR à la naissance (peut dépasser 1.0)
simd::float4 colorDeath; // couleur en fin de vie
float deltaTime; // durée de la frame
float time; // temps écoulé : graine du hasard
float drag; // freinage de l'air, par seconde (0 = aucun)
float speed; // vitesse de départ
float spread; // ouverture du cône d'émission (0 = jet droit, 1 = demi-sphère)
float lifetime; // durée de vie moyenne
float sizeBirth; // taille du billboard à la naissance
float sizeDeath; // taille en fin de vie
uint32_t particleCount;
};
Un float3 occupe 16 octets, pas 12, en MSL comme dans simd. Mélanger float3 et float dans une structure, c'est risquer qu'un côté ajoute du rembourrage que l'autre n'attend pas — et le GPU lit alors l'âge à la place de la vitesse, sans erreur. Avec deux float4, la particule fait exactement 32 octets des deux côtés, et le .w libre accueille l'âge et la durée de vie.
Du hasard sans rand()
Une particule qui renaît doit partir dans une direction un peu différente de la précédente, sinon on voit un seul trait. Mais un shader n'a pas de rand() : il n'a aucun état qui survive d'un appel à l'autre. On utilise donc une fonction de hash (chapitre ↘ Fonctions de hash) : elle prend un entier et rend un entier qui « a l'air » aléatoire. On lui donne l'indice de la particule mélangé au temps : deux particules, ou deux renaissances, ne tirent jamais la même valeur.
/// MSL — Particles.metal — update:04/11/26
static uint pcgHash(uint v)
{
uint state = v * 747796405u + 2891336453u;
uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
return (word >> 22u) ^ word;
}
static float random01(thread uint& seed) // [0, 1[, et la graine avance à chaque appel
{
seed = pcgHash(seed);
return float(seed) / 4294967296.0f;
}
random01 prend la graine par thread référence et la fait avancer : chaque appel successif donne un nouveau nombre. Le static garde ces fonctions propres à Particles.metal : pas de collision avec les hash22 de Noise.metal.
Le compute shader : vieillir, renaître, bouger
Nouveau fichier Shaders/Particles.metal. Le kernel suit à la lettre les trois étapes du début :
/// MSL — Particles.metal — update:04/11/26
kernel void particles_update(device Particle* particles [[buffer(0)]],
constant ParticleUniforms& u [[buffer(1)]],
uint id [[thread_position_in_grid]])
{
if (id >= u.particleCount)
return; // la grille peut déborder du tableau
Particle p = particles[id]; // lecture : mémoire GPU → registres
float age = p.positionAge.w + u.deltaTime;
if (age < 0.0f)
{ // pas encore née : on attend son tour (l'âge négatif étale les naissances)
p.positionAge.w = age;
particles[id] = p;
return;
}
// Elle vient de naître (son âge était encore négatif à la frame d'avant) ou elle est morte :
// dans les deux cas elle (re)part de l'émetteur — le tableau ne grandit jamais
if (p.positionAge.w < 0.0f || age >= p.velocityLifetime.w)
{
uint seed = id * 1973u + uint(u.time * 1000.0f) * 9277u;
// Un point au hasard dans un disque horizontal (racine carrée : densité uniforme)
float angle = random01(seed) * 2.0f * M_PI_F;
float radius = sqrt(random01(seed)) * u.emitterPosition.w;
float3 start = u.emitterPosition.xyz + float3(cos(angle) * radius, 0.0f, sin(angle) * radius);
// Une direction dans un cône autour de +y
float phi = random01(seed) * 2.0f * M_PI_F;
float cosT = mix(1.0f, 1.0f - u.spread, random01(seed));
float sinT = sqrt(1.0f - cosT * cosT);
float3 dir = float3(cos(phi) * sinT, cosT, sin(phi) * sinT);
float speed = u.speed * mix(0.6f, 1.0f, random01(seed));
p.positionAge = float4(start, 0.0f);
p.velocityLifetime = float4(dir * speed, u.lifetime * mix(0.5f, 1.0f, random01(seed)));
particles[id] = p;
return;
}
// Vivante : intégration d'Euler, la même que pour la caméra
float3 velocity = p.velocityLifetime.xyz;
velocity += u.gravity.xyz * u.deltaTime; // la gravité change la vitesse…
velocity *= max(0.0f, 1.0f - u.drag * u.deltaTime); // …l'air la freine…
float3 position = p.positionAge.xyz + velocity * u.deltaTime; // …et la vitesse change la position
p.positionAge = float4(position, age);
p.velocityLifetime = float4(velocity, p.velocityLifetime.w);
particles[id] = p; // écriture : registres → mémoire GPU
}
Quelques détails qui comptent :
if (id >= u.particleCount) return;— la grille est découpée en groupes de 32 threads. Avec 20 001 particules, le dernier groupe déborde : sans ce test, des threads écriraient hors du tableau.- L'âge négatif. Si toutes les particules naissaient à la frame 0, elles mourraient toutes ensemble et l'émetteur « clignoterait ». On les fait donc naître dans le futur : à l'initialisation, l'âge va de 0 à −durée de vie. Elles apparaissent une à une, et le flux reste régulier pour toujours. Attention : le jour où l'âge devient positif, la particule n'a encore ni position ni vitesse — c'est pourquoi « vient de naître » passe par la même branche que « est morte ».
sqrt(random01(seed))pour le rayon : sans la racine, les points s'entassent au centre du disque (il y a moins de surface près du centre que sur le bord).- Euler. Gravité → vitesse → position, multiplié par
deltaTime: c'est le même déplacement indépendant du nombre d'images par seconde que pour la caméra. Undragfreine la vitesse : c'est lui qui fait « flotter » le feu au lieu de le projeter. - Une copie, une écriture. On lit la particule dans une variable locale (des registres), on travaille dessus, on la réécrit une seule fois. Lire et écrire plusieurs fois
particles[id]coûterait autant d'accès mémoire.
Le billboard : un carré qui regarde la caméra
Une particule est un point ; pour la voir, il lui faut une surface. On lui donne un carré de deux triangles… mais orienté comment ? Si on l'oriente dans le monde (par exemple à plat dans le plan XY), il disparaît dès qu'on le regarde par la tranche. La solution est de le construire avec les axes de l'écran : le vecteur « droite » et le vecteur « haut » de la caméra, exprimés dans le monde.
\( \text{coin} = \text{centre} + (c_x \cdot \vec{droite} + c_y \cdot \vec{haut}) \cdot \text{taille} \), avec \( c_x, c_y \in \{-1, 1\} \).
/// MSL — Particles.metal — update:04/11/26
struct ParticleOut
{
float4 position [[position]];
float2 corner; // de -1 à 1 sur le quad : sert à dessiner un disque doux
float4 color;
};
vertex ParticleOut vertex_particle(uint vid [[vertex_id]],
uint iid [[instance_id]],
const device Particle* particles [[buffer(0)]],
constant ParticleUniforms& u [[buffer(1)]])
{
// Deux triangles, sans vertex buffer : les coins sont écrits ici
const float2 corners[6] = { float2(-1, -1), float2( 1, -1), float2(-1, 1),
float2(-1, 1), float2( 1, -1), float2( 1, 1) };
Particle p = particles[iid];
float age = p.positionAge.w;
float t = saturate(age / p.velocityLifetime.w); // 0 = naissance, 1 = mort
float2 corner = corners[vid];
float size = (age < 0.0f) ? 0.0f : mix(u.sizeBirth, u.sizeDeath, t); // pas née = invisible
// Billboard : on décale le centre le long de la droite et du haut de la CAMÉRA,
// pas du monde. Le quad fait donc toujours face à l'écran.
float3 world = p.positionAge.xyz
+ (corner.x * u.cameraRight.xyz + corner.y * u.cameraUp.xyz) * size;
ParticleOut out;
out.position = u.viewProjectionMatrix * float4(world, 1.0f);
out.corner = corner;
// Apparition en 10 % de la vie, disparition sur le reste : pas de « pop »
float fade = smoothstep(0.0f, 0.1f, t) * (1.0f - smoothstep(0.4f, 1.0f, t));
out.color = mix(u.colorBirth, u.colorDeath, t) * fade;
return out;
}
Il n'y a aucun vertex buffer : les six coins sont écrits dans le shader, et [[instance_id]] dit quelle particule on dessine. Un seul drawPrimitives avec 6 sommets et 20 000 instances dessine tout le système.
Ces deux vecteurs, on les trouve sans calcul dans la matrice de vue du chapitre ↘ Caméra : sViewMatrix range l'axe droite de la caméra dans sa première ligne et l'axe haut dans la deuxième. Comme simd stocke par colonnes, la ligne i se lit columns[0][i], columns[1][i], columns[2][i] :
/// C++ — Particles.cpp — update:04/11/26
void ParticleSystem::update(const GlobalUniforms& globals, float delta, float elapsed)
{
const CameraUniforms& camera = globals.cameraUniforms;
m_uniforms->viewProjectionMatrix = camera.viewProjectionMatrix;
// La matrice de vue range les axes de la caméra dans ses LIGNES : colonne j, composante 0 = droite,
// composante 1 = haut (simd stocke par colonnes : columns[j][i] = ligne i, colonne j)
const simd::float4x4& v = camera.viewMatrix;
m_uniforms->cameraRight = { v.columns[0][0], v.columns[1][0], v.columns[2][0], 0.f };
m_uniforms->cameraUp = { v.columns[0][1], v.columns[1][1], v.columns[2][1], 0.f };
m_uniforms->deltaTime = delta;
m_uniforms->time = elapsed;
}
Reste le fragment shader. Le carré est rempli, mais on veut une boule de lumière : on calcule la distance du pixel au centre du quad et on l'éteint en douceur vers le bord.
/// MSL — Particles.metal — update:04/11/26
fragment float4 fragment_particle(ParticleOut in [[stage_in]])
{
float d = length(in.corner); // 0 au centre, 1 au bord du disque
float falloff = 1.0f - smoothstep(0.0f, 1.0f, d);
falloff *= falloff; // cœur brillant, bords qui s'évanouissent
// Blending ADDITIF (voir Particles.cpp) : on rend une lumière qui s'ajoute à l'image.
// L'alpha ne sert à rien ici, seule la couleur compte.
return float4(in.color.rgb * falloff, 0.0f);
}
Le blending additif : le vrai secret
Par défaut, un fragment shader remplace le pixel. Avec le blending, le GPU combine ce que tu renvoies (la source) avec ce qui est déjà à l'écran (la destination) :
\( \text{résultat} = \text{source} \times F_{src} \;\; \text{op} \;\; \text{destination} \times F_{dst} \)
| Mode | Fsrc | Fdst | Effet | Faut-il trier ? |
|---|---|---|---|---|
| Opaque | — | — | remplace | non (la profondeur s'en charge) |
| Alpha | SourceAlpha | OneMinusSourceAlpha | un calque teinté par-dessus : fumée, poussière | oui, de l'arrière vers l'avant |
| Additif | One | One | ajoute de la lumière : feu, étincelles, magie | non : \( a + b = b + a \) |
L'additif a deux qualités qui en font le mode roi des VFX. D'abord, là où beaucoup de particules se superposent, la lumière s'accumule : le cœur du feu devient presque blanc tout seul, sans qu'on le programme. Ensuite, l'addition est commutative : l'ordre dans lequel le GPU dessine les 20 000 quads ne change rien au résultat. Avec le blending alpha, il faudrait trier les particules par distance à la caméra à chaque frame — un vrai algorithme de tri sur le GPU.
/// C++ — Particles.cpp — update:04/11/26
// Le cœur du VFX : le blending ADDITIF. écran = source × 1 + destination × 1
// Chaque particule AJOUTE sa lumière à ce qui est déjà dessiné : là où elles se superposent,
// ça brille plus fort, et l'ordre de dessin n'a plus d'importance (a + b = b + a) → pas de tri.
auto color = descriptor->colorAttachments()->object(0);
color->setPixelFormat(colorPixelFormat);
color->setBlendingEnabled(true);
color->setRgbBlendOperation(MTL::BlendOperationAdd);
color->setAlphaBlendOperation(MTL::BlendOperationAdd);
color->setSourceRGBBlendFactor(MTL::BlendFactorOne);
color->setDestinationRGBBlendFactor(MTL::BlendFactorOne);
color->setSourceAlphaBlendFactor(MTL::BlendFactorZero); // l'alpha de l'image ne bouge pas
color->setDestinationAlphaBlendFactor(MTL::BlendFactorOne);
Et la profondeur ? Il faut deux réglages qui semblent contradictoires :
- tester la profondeur (
CompareFunctionLess) : une particule derrière la libellule doit rester cachée ; - ne pas écrire la profondeur (
setDepthWriteEnabled(false)) : sinon la première particule dessinée bouche le passage aux suivantes, et on voit des carrés noirs découpés dans le feu.
/// C++ — Particles.cpp — update:04/11/26
// Profondeur : on TESTE (une particule derrière un mur reste cachée)
// mais on n'ÉCRIT PAS (une particule ne doit pas en cacher une autre : elles s'additionnent)
auto depthDescriptor = NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init());
depthDescriptor->setDepthCompareFunction(MTL::CompareFunctionLess);
depthDescriptor->setDepthWriteEnabled(false);
m_depthState = NS::TransferPtr(device->newDepthStencilState(depthDescriptor.get()));
La couleur de naissance vaut { 4.0, 1.6, 0.4 }. Additionnées, quelques particules montent vite à 10 ou 20. C'est voulu : une flamme est une source de lumière, bien plus intense qu'un mur éclairé. Avec une cible RGBA16Float et une courbe du chapitre ↘ Tone mapping, ces valeurs se compriment joliment vers un blanc chaud au lieu d'être coupées net.
La classe ParticleSystem
Côté C++, le module suit la forme de Skybox : un constructeur qui crée pipelines et buffers, puis trois méthodes appelées chaque frame. Nouveau fichier Renderer/Particles.hpp :
/// C++ — Particles.hpp — update:04/11/26
// Un émetteur de particules entièrement sur le GPU :
// - simulate() encode un compute shader qui fait vieillir, bouger et renaître chaque particule ;
// - draw() dessine une instance (un quad face caméra) par particule, en blending additif.
// Le CPU ne touche jamais aux particules après le constructeur : il ne règle que les uniforms.
class ParticleSystem
{
public:
ParticleSystem(MTL::Device*, MTL::Library*, MTL::PixelFormat, MTL::PixelFormat, uint32_t count = 20000);
~ParticleSystem() = default;
void update(const GlobalUniforms&, float delta, float elapsed); // CPU : remplit les uniforms
void simulate(MTL::CommandBuffer*); // GPU : AVANT la passe de rendu
void draw(MTL::RenderCommandEncoder*); // GPU : APRÈS les objets opaques
ParticleUniforms& settings() { return *m_uniforms; } // régler l'effet : couleur, gravité, taille…
private:
void buildPipelines(MTL::Device*, MTL::Library*, MTL::PixelFormat, MTL::PixelFormat);
void buildBuffers(MTL::Device*);
uint32_t m_count;
NS::SharedPtr<MTL::Buffer> m_particleBuffer; // rempli une fois par le CPU, puis seul le GPU y touche
NS::SharedPtr<MTL::Buffer> m_uniformBuffer; // Shared : le CPU l'écrit chaque frame
ParticleUniforms* m_uniforms = nullptr;
NS::SharedPtr<MTL::ComputePipelineState> m_updatePso;
NS::SharedPtr<MTL::RenderPipelineState> m_drawPso;
NS::SharedPtr<MTL::DepthStencilState> m_depthState;
};
L'initialisation remplit le tableau une seule fois, avec les âges négatifs qui étalent les naissances, et règle un feu par défaut :
/// C++ — Particles.cpp — update:04/11/26
void ParticleSystem::buildBuffers(MTL::Device* device)
{
// Toutes les particules naissent « dans le futur » : âge négatif, de 0 à -lifetime.
// Le kernel les fait vieillir ; elles apparaissent donc une par une au lieu d'un seul « boum ».
const float lifetime = 2.5f;
std::vector<Particle> initial(m_count);
for (uint32_t i = 0; i < m_count; ++i)
{
const float waiting = -lifetime * (float)i / (float)m_count;
initial[i].positionAge = { 0.f, 0.f, 0.f, waiting };
initial[i].velocityLifetime = { 0.f, 0.f, 0.f, lifetime };
}
// Shared : sur Apple Silicon, CPU et GPU partagent la même mémoire. Après cette copie,
// seul le GPU écrit dedans (le kernel), le CPU n'y touche plus.
m_particleBuffer = NS::TransferPtr(device->newBuffer(initial.data(), sizeof(Particle) * m_count,
MTL::ResourceStorageModeShared));
m_uniformBuffer = NS::TransferPtr(device->newBuffer(sizeof(ParticleUniforms), MTL::ResourceStorageModeShared));
m_uniforms = reinterpret_cast<ParticleUniforms*>(m_uniformBuffer->contents());
// Réglages par défaut : un feu. Couleurs HDR (> 1) : le tone mapping s'occupe du reste.
*m_uniforms = {};
m_uniforms->emitterPosition = { 0.f, 44.f, 0.f, 1.5f }; // sous la libellule, disque de 1,5
m_uniforms->gravity = { 0.f, 6.f, 0.f, 0.f }; // positive : l'air chaud MONTE
m_uniforms->colorBirth = { 4.0f, 1.6f, 0.4f, 1.f }; // jaune-orange très lumineux
m_uniforms->colorDeath = { 0.6f, 0.05f, 0.02f, 1.f }; // rouge sombre
m_uniforms->drag = 1.2f;
m_uniforms->speed = 3.0f;
m_uniforms->spread = 0.25f;
m_uniforms->lifetime = lifetime;
m_uniforms->sizeBirth = 0.6f;
m_uniforms->sizeDeath = 0.15f;
m_uniforms->particleCount = m_count;
}
La simulation encode le kernel dans le command buffer, sur une grille d'autant de threads que de particules :
/// C++ — Particles.cpp — update:04/11/26
void ParticleSystem::simulate(MTL::CommandBuffer* commandBuffer)
{
MTL::ComputeCommandEncoder* encoder = commandBuffer->computeCommandEncoder();
encoder->setComputePipelineState(m_updatePso.get());
encoder->setBuffer(m_particleBuffer.get(), 0, 0);
encoder->setBuffer(m_uniformBuffer.get(), 0, 1);
// Une grille d'autant de threads que de particules, en groupes de la taille préférée du GPU
const NS::UInteger groupSize = m_updatePso->threadExecutionWidth(); // 32 sur Apple Silicon
encoder->dispatchThreads(MTL::Size(m_count, 1, 1), MTL::Size(groupSize, 1, 1));
encoder->endEncoding();
}
Et le dessin, en un seul appel :
/// C++ — Particles.cpp — update:04/11/26
void ParticleSystem::draw(MTL::RenderCommandEncoder* encoder)
{
encoder->setRenderPipelineState(m_drawPso.get());
encoder->setDepthStencilState(m_depthState.get());
encoder->setCullMode(MTL::CullModeNone);
encoder->setVertexBuffer(m_particleBuffer.get(), 0, 0);
encoder->setVertexBuffer(m_uniformBuffer.get(), 0, 1);
// 6 sommets (un quad) × m_count instances (une par particule) : UN seul appel pour 20 000 particules
encoder->drawPrimitives(MTL::PrimitiveTypeTriangle, NS::UInteger(0), NS::UInteger(6), NS::UInteger(m_count));
}
Brancher dans le Renderer
Quatre endroits, et l'ordre compte :
/// C++ — Renderer.hpp — update:04/11/26
#include "Particles.hpp"
// …
Skybox m_skybox;
ParticleSystem m_particles; // VFX : en dernier, il se dessine après tout le reste
/// C++ — Renderer.cpp — update:04/11/26
// 1. Le constructeur, dans la liste d'initialisation
m_skybox(m_device, m_shaderLibrary, m_pixelFormat, m_depthPixelFormat),
m_particles(m_device, m_shaderLibrary, m_pixelFormat, m_depthPixelFormat)
// 2. update(), APRÈS la caméra : sinon les billboards regardent l'ancienne position
m_particles.update(m_globalUniforms, delta, time.elapsed);
// 3. draw(), juste après la création du command buffer, AVANT la passe de rendu
MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
m_particles.simulate(commandBuffer);
// 4. draw(), dans la passe, APRÈS tous les objets opaques
m_pnj.draw(renderCommandEncoder, m_globalUniforms);
m_particles.draw(renderCommandEncoder);
renderCommandEncoder->endEncoding();
- Compute avant render. Les encodeurs d'un même command buffer s'exécutent dans l'ordre où on les crée. Encodé avant la passe, le kernel a fini d'écrire les positions quand le vertex shader les lit : Metal s'occupe de la synchronisation tout seul.
- Les particules en dernier. Elles testent la profondeur des objets opaques : ceux-ci doivent donc déjà l'avoir écrite.
- Un seul buffer d'uniforms suffit ici, parce que
draw()attend la fin du GPU (waitUntilCompleted) avant la frame suivante. Le jour où tu retires cette attente pour gagner en fluidité, il faudra un buffer d'uniforms par frame en vol (le triple buffering), sinon le CPU réécrit les réglages pendant que le GPU les lit.
Particles.cpp est trouvé tout seul par le Makefile (find Renderer -name '*.cpp'), et Particles.metal par find Shaders -name '*.metal'. Sous Xcode, ajoute les trois fichiers à la cible.
Changer d'effet
settings() rend une référence vers les uniforms : on change d'effet sans toucher au shader. Par exemple, dans le constructeur du Renderer, une fontaine bleue :
/// C++ — Renderer.cpp — Exemple
ParticleUniforms& fx = m_particles.settings();
fx.gravity = { 0.f, -9.8f, 0.f, 0.f }; // vers le bas, cette fois
fx.speed = 14.f;
fx.spread = 0.08f; // jet presque droit
fx.drag = 0.1f;
fx.colorBirth = { 0.4f, 1.2f, 3.0f, 1.f };
fx.colorDeath = { 0.0f, 0.1f, 0.4f, 1.f };
fx.sizeBirth = 0.25f;
fx.sizeDeath = 0.35f;
Quand ça ne marche pas
- Des carrés noirs ou opaques — le blending n'est pas activé (
setBlendingEnabled(true)oublié), ou la profondeur est écrite. - Rien ne s'affiche —
simulate()n'est jamais appelé (toutes les particules gardent leur âge négatif, donc une taille 0), ou l'émetteur est hors champ :emitterPositionest en coordonnées du monde. - Un trait part du centre du monde au démarrage — les particules qui sortent de leur âge négatif doivent naître à l'émetteur, pas continuer depuis leur position initiale
(0, 0, 0): d'où le testp.positionAge.w < 0.0fdans la condition de renaissance. - Le feu « respire » par vagues — les âges initiaux ne sont pas étalés : toutes les particules naissent et meurent ensemble.
- Les particules partent toutes dans la même direction — la graine ne change pas : vérifie que
timeavance bien (il vient deFrameTime::elapsed). - Les quads sont plats quand on tourne autour —
cameraRight/cameraUplus dans les colonnes au lieu des lignes de la matrice de vue. - Tout est blanc — trop de particules, couleurs trop fortes, ou pas de tone mapping : baisse
colorBirth.
Pour aller plus loin
Ce système de base est le squelette de presque tous les VFX. Les suivants s'y greffent un par un :
- Bloom — une passe d'après-rendu qui fait « baver » les pixels au-dessus de 1.0 : le feu éclaire l'air autour de lui.
- Textures et flipbooks — remplacer le disque calculé par une image de flamme ou de fumée, animée case par case selon
t. - Soft particles — lire la profondeur de la scène dans le fragment shader et effacer la particule près des surfaces : plus de coupure nette quand la fumée touche le sol.
- Turbulence — ajouter à la vitesse un champ de bruit (chapitre ↘ Noise) : la fumée tourbillonne au lieu de monter en ligne droite.
- Émission à la demande — un compteur atomique (atomic_uint) pour faire naître 500 particules d'un coup lors d'un impact, au lieu d'un flux continu.