Chapitre -105 · VFX — Particules GPU

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 :

Objectif de ce chapitreWhat you’ll learn
Wat je leert
  • Décrire une particule avec quatre nombres : position, vitesse, âge, durée de vieDescribe a particle with four values: position, velocity, age, lifetime
  • Simuler 20 000 particules dans un compute shader, sans jamais allouer de mémoireSimulate 20,000 particles in a compute shader, without ever allocating memory
  • Fabriquer du hasard sur le GPU avec une fonction de hashMake randomness on the GPU with a hash function
  • Dessiner un billboard face caméra à partir de la matrice de vueDraw a camera-facing billboard from the view matrix
  • Régler le blending additif et la profondeur pour que l'ordre de dessin n'ait plus d'importanceSet up additive blending and depth so draw order no longer matters
⏱ ~35 min
PrérequisPrerequisites
Vereisten

Une particule, c'est quatre nombres

Oublie les maillages : une particule n'a pas de triangles à elle. C'est une petite fiche :

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 :

  1. elle vieillit : age += dt ;
  2. si elle est trop vieille, elle renaît à l'émetteur avec une vitesse tirée au hasard ;
  3. 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 :

—

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;
};
Pourquoi tout ranger dans des float4 ?

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 :

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

ModeFsrcFdstEffetFaut-il trier ?
Opaque——remplacenon (la profondeur s'en charge)
AlphaSourceAlphaOneMinusSourceAlphaun calque teinté par-dessus : fumée, poussièreoui, de l'arrière vers l'avant
AdditifOneOneajoute de la lumière : feu, étincelles, magienon : \( 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 :

/// 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()));
Pourquoi le feu a des couleurs au-dessus de 1.0

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();

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.

⬡CheckPoint Compilation — un feu sous la libellule

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

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 :