Aperçu de Niagaraensemble

Niagara est le système d'effets visuels de nouvelle génération d'Unreal Engine. Grâce à Niagara, l'artiste technique peut créer lui-même des fonctionnalités supplémentaires sans l'aide d'un programmeur. Le système est adaptable et flexible. Les débutants peuvent modifier des modèles ou des exemples de comportement tandis que les utilisateurs avancés peuvent créer leurs propres modules personnalisés.

Composants Niagara de base

Dans le système d'effets visuels Niagara, il y a quatre composants principaux :

• Les systèmes

• Les émetteurs

• Les modules

• Paramètres

Les systèmes

Un système Niagara est un conteneur pour tout ce dont vous aurez besoin pour créer cet effet. À l'intérieur de ce système, vous pouvez avoir différents blocs de construction qui se superposent pour vous aider à produire l'effet global.

Vous pouvez modifier certains comportements au niveau du système, qui s'appliqueront alors à l'ensemble de l'effet.

Le panneau chronologie de l'éditeur de système indique les émetteurs contenus dans le système et peut être utilisé pour gérer ces émetteurs.

Les émetteurs

Les émetteurs sont les éléments où les particules sont générées dans un système Niagara. Un émetteur contrôle l'apparition des particules, leur évolution avec le temps, ainsi que leur apparence et leur comportement.

L'émetteur est organisé en pile. À l'intérieur de cette pile, on trouve plusieurs groupes, dans lesquels on peut placer des modules qui accomplissent des tâches individuelles. Les groupes sont les suivants.

1. Génération d'émetteurs

   Ce groupe définit ce qu'il se passe à la première création d'un émetteur sur le processeur. Utilisez ce groupe pour définir les configurations initiales et les valeurs par défaut.

2. Mise à jour des émetteurs

   Ce groupe définit les modules au niveau de l'émetteur qui s'exécutent à chaque image sur le CPU. Utilisez ce groupe pour définir la génération de particules lorsque vous souhaitez qu'elles continuent à apparaître à chaque image.

3. Génération de particules

   Ce groupe est appelé une fois par particule, à la première apparition de cette particule. C'est ici que vous devez définir les paramètres d'initialisation des particules, comme l'emplacement où elles sont générées, leur couleur, leur taille, etc.

4. Mise à jour des particules

   Ce groupe est appelé par particule à chaque image. C'est ici que vous allez définir tout ce qui doit évoluer image par image au fur et à mesure que les particules vieillissent. Par exemple, si la couleur des particules change au fil du temps. Ou si les particules sont affectées par des forces telles que la gravité, le bruit Curl ou l'attraction ponctuelle. Vous pouvez même modifier la taille des particules au fil du temps.

5. Gestionnaire d'événements

   Dans le groupe Gestionnaire d'événements, vous pouvez créer des événements de génération dans un ou plusieurs émetteurs qui définissent certaines données. Vous pouvez ensuite créer des événements d'écoute dans d'autres émetteurs qui déclenchent un comportement en réaction à cet événement généré.

6. Rendu

   Le dernier groupe est le groupe de rendu. C'est là que s'effectue la définition de l'affichage de la particule et la configuration d'un ou de plusieurs outils de rendu pour les particules. Vous pouvez utiliser un outil de rendu de maillage pour définir un modèle 3D comme base de vos particules, sur lequel vous pourriez appliquer un matériau. Vous pouvez également utiliser un outil de rendu des sprites pour définir vos particules comme des sprites 2D. Un large éventail d'outils de rendu est disponible, offrant de nombreuses possibilités d'expérimentation.

Les modules

Les modules constituent les blocs de construction de base des effets dans Niagara. On ajoute des modules aux groupes pour créer une pile. Les modules sont traités séquentiellement de haut en bas.

On peut considérer un module comme un conteneur servant à effectuer des calculs. On transmet des données au module, qui effectue ensuite des calculs sur ces données, puis les restitue à la sortie du module.

Les modules sont créés à l'aide du langage HLSL (High-Level Shading Language), mais peuvent être créés visuellement dans un graphique à l'aide de nœuds. Vous pouvez créer des fonctions, inclure des commandes ou écrire dans un mappage de valeur ou de paramètre. Vous pouvez même écrire du code HLSL en ligne, en utilisant le nœud CustomHLSL dans le graphique.

Vous pouvez double-cliquer sur n'importe quel module d'un émetteur dans Niagara pour voir les calculs qui s'exécutent à l'intérieur. Vous pouvez même copier et créer vos propres modules. Par exemple, si vous double-cliquez sur le module Ajouter une vitesse pour regarder à l'intérieur, vous pouvez inspecter le flux de données.

Le script commence par récupérer des entrées (la commande de vitesse et l'espace de coordonnées). Il obtient ensuite la vitesse actuelle des particules ainsi qu'un facteur de mise à l'échelle fourni en entrée. Ensuite, la vitesse entrée est mise à l'échelle, transformée dans le bon espace de coordonnées, puis ajoutée à la vitesse actuelle des particules. Une fois cette étape terminée, la nouvelle vitesse de particule est enregistrée de façon à ce que tous les modules qui ont besoin d'informations de vitesse plus loin dans la pile puissent les récupérer.

Tous les modules suivent cette méthodologie de base, même si les calculs internes peuvent s'avérer plus complexes pour certains.

Paramètres et types de paramètres

Les paramètres sont une abstraction de données dans une simulation Niagara. Les types de paramètres sont assignés à un paramètre pour définir les données que représente un paramètre. Il existe quatre types de paramètres :

• Primitive : ce type de paramètre définit des données numériques avec une précision et des largeurs de canal variables.

• Enum : ce type de paramètre définit un ensemble fixe de valeurs nommées et suppose que l'une d'entre elles est nommée.

• Structure : ce type de paramètre permet de définir un ensemble combiné de types Primitive et Enum.

• Interfaces de données : ce type de paramètre définit les fonctions qui fournissent des données provenant de sources externes de données. Il peut s'agir de données provenant d'autres parties de UE4 ou de données provenant d'une appli externe.

Vous pouvez ajouter un module de paramètre personnalisé à un émetteur en cliquant sur l'icône du signe plus (+) et en sélectionnant Définir directement un paramètre nouveau ou existant. Ceci ajoute un module Définir paramètre à la pile. Cliquez sur l'icône signe plus (+) dans le module Définir paramètre et sélectionnez Ajouter paramètre pour définir un paramètre existant, ou Créer un nouveau paramètre pour définir un nouveau paramètre.

Modèles et exemples de comportements

Fenêtre du navigateur de ressources Niagara

Lorsque vous créez un émetteur Niagara ou un système Niagara, une fenêtre de navigateur de ressources affiche les systèmes et émetteurs Niagara disponibles dans votre projet. Vous pouvez filtre les ressources disponibles par type ou catégorie. Vous pouvez aussi créer des catégories personnalisées pour le filtre.

Pour créer un nouveau système Niagara, faites un clic droit dans le navigateur de contenu et cliquez sur Effets > Système Niagara.

La fenêtre du navigateur de ressources Niagara s'ouvrira et affichera tous les systèmes disponibles dans le projet. La fenêtre se compose des sections suivantes :

1. Zone de contenu

La zone de contenu affiche les systèmes et émetteurs disponibles en fonction des filtres et de la catégorie sélectionnés.

2. Catégories

La section affiche toutes les catégories disponibles dans le projet. Sélectionnez l'une des catégories pour voir les systèmes et émetteurs disponibles.

3. Barre d'outils

La barre d'outils propose les options suivantes :

Filtre

Le bouton filtre affiche un menu déroulant avec les filtres FX et Niagara disponibles. Sélectionnez le filtre Niagara émetteur pour afficher les émetteurs disponibles dans la zone de contenu.

Vous pouvez cliquer sur le bouton filtre pour activer ou désactiver le filtre.

Filtre émetteur Niagara actif

Filtre émetteur Niagara inactif

La barre de recherche

La barre de recherche permet de chercher des systèmes et des émetteurs par nom. Dans l'exemple ci-dessous, nous avons cherché fire pour voir tous les systèmes contenant ce mot dans leur nom.

4. Détails

La section affiche des informations sur le système ou l'émetteur sélectionné.

Dans l'exemple ci-dessus, un émetteur est sélectionné et vous pouvez voir la description de la ressource, les balises principales (catégorie), si l'émetteur est hérité d'une autre ressource et s'il fonctionne sur le processeur ou le processeur graphique.

Ajouter vos propres catégories

Le navigateur de ressources Niagara utilise des balises pour organiser les systèmes Niagara et les émetteurs à l'intérieur de la fenêtre. Les balises sont visualisées sous la forme d'une arborescence sur le côté gauche de la fenêtre, comme illustré ci-dessous.

Chaque ressource dispose d'une balise principale correspondante, qui permet de la placer dans la bonne catégorie. Dans l'exemple ci-dessous, le système Grid2D_GAS_Color a la balise principale 2D Gas, qui correspond à la catégorie 2D Gas sur le côté gauche.

Vous pouvez créer vos propres balises et les attribuer à vos ressources depuis le navigateur de contenu. Ceci, à son tour, crée des catégories personnalisées dans le navigateur de ressources.

Pour cet exemple, nous avons créé trois émetteurs Niagara nommés NE_Hit_Concrete, NE_Hit_Glass et NE_Hit_Wood, pour représenter différents effets de collision.

Pour créer des balises personnalisées, suivez ces étapes :

1. Cliquez avec le bouton droit dans le navigateur de contenu et cliquez sur FX > Avancé > Définitions des balises d'e ressources Niagara. Nommez la ressource NAD_HitEffects.

   

2. Double-cliquez sur NAD_HitEffects pour l'ouvrir. Saisissez un nom d'affichage et une description. Elle sera utilisée dans la vue Catégories du navigateur de ressources.

   

3. Cliquez sur le signe + en regard de Définition des balises pour ajouter une nouvelle balise. Développez index [0] et saisissez Hit_Glass comme balise de ressource, puis sélectionnez Émetteurs comme indicateurs de ressources.

   

4. Suivez l'étape précédente et ajoutez deux balises : Hit_Concrete et Hit_Wood.

   

5. Faites un clic droit sur NE_Hit_Concrete et cliquez sur Gérer les balises > Hit_Concrete. La balise Hit_Concrete est ainsi ajoutée à la ressource.

   

6. Ajouter les balises Hit_Glass et Hit_Wood aux émetteurs NE_Hit_Glass et NE_Hit_Wood, respectivement.

7. Faites un clic droit dans le navigateur de contenu et cliquez sur FX > Système Niagara pour ouvrir le navigateur de ressources. Cliquez sur la catégorie Effets de collision pour voir les émetteurs avec des balises qui font partie de cette définition de balise de ressource.

   

8. Cliquez maintenant sur la catégorie Hit_Glass pour voir l'émetteur avec la balise Hit Glass.

   

9. Vous pouvez créer autant de définitions de balises de ressource que vous le souhaitez pour votre projet. Dans l'exemple ci-dessous, nous avons créé une autre définition avec le nom Splash Effects et deux balises Splash_Clear et Splash_Mud.

   

Flux de travail d'effets visuels Niagara

Créer des systèmes

Créez d'abord un système Niagara dans lequel vous pouvez ajouter un ou plus émetteurs. Vous pouvez ensuite configurer les propriétés de chaque émetteur.

Créer ou ajouter des émetteurs

Dans Niagara Editor, vous pouvez ajuster votre émetteur en modifiant les propriétés des modules qu'il contient déjà ou ajouter de nouveaux modules pour l'effet recherché. Vous pouvez également copier les émetteurs et ajouter plusieurs émetteurs dans un seul système Niagara. Pour voir un exemple, consultez le tutoriel de Sparks.

Créer ou ajouter des modules

Dans votre émetteur, vous pouvez ajouter des modules existants à partir de Niagara en cliquant sur le signe plus (+) du groupe où vous voulez ajouter le module. Niagara fournit de nombreux modules préexistants. Dans la plupart des cas, vous pourrez créer vos effets ans avoir besoin de concevoir des modules personnalisés.

Toutefois, si vous souhaitez créer vos propres modules, il peut être utile de comprendre la manière dont les données transitent par un module.

• Les modules se cumulent jusqu'à constituer un espace de nom temporaire. Vous pouvez alors empiler plus modules ensemble. Tant qu'ils contribuent au même attribut, les modules s'empilent et se cumulent correctement.

• Lorsque vous écrivez un module, de nombreuses fonctions sont disponibles :

  • Opérateurs booléens

  • Expressions mathématiques

  • Expressions trigonométriques

  • Fonctions personnalisées

  • Les nœuds qui simplifient les fonctions standard

• Une fois que vous avez créé un module, n'importe qui peut l'utiliser.

• Les modules utilisent tous HLSL. Le flux logique est le suivant :

  

Paradigmes Niagara

Héritage

• Avec une hiérarchie plate, vous ne pouvez pas localiser et utiliser efficacement les ressources déjà présentes dans votre bibliothèque, ce qui implique que des personnes doivent recréer ces ressources. La duplication des efforts réduit l'efficacité et augmente les coûts.

• L'héritage hiérarchique augmente la notion de découverte et permet la réutilisation efficace des ressources existantes.

• Tout ce qui est hérité peut être remplacé pour un émetteur enfant dans un système.

• Les modules peuvent être ajoutés ou rétablis à la valeur parent.

• C'est également vrai pour les comportements au niveau de l'émetteur, tels que l'apparition, la durée de vie, la boucle, les explosions, etc.

Entrées dynamiques

• Les entrées dynamiques sont créées de la même manière que les modules.

• Les entrées dynamiques offrent aux utilisateurs une extensibilité infinie pour l'héritage.

• Au lieu d'agir sur une mappage de paramètre, les entrées dynamiques agissent sur un type de valeur.

• N'importe quelle valeur peut être pilotée par la logique de graphique et les valeurs orientées utilisateur.

• Les entrées dynamiques ont presque le même pouvoir de créer des modules, mais peuvent être sélectionnées et ajoutées à la pile sans créer de nouveaux modules.

• Les modules existants peuvent être modifiés et personnalisés de nombreuses façons en utilisant et en reliant des entrées dynamiques. Cela permet de réduire l'engorgement des module et d'améliorer les performances.

Micro-expressions

• N'importe quelle valeur intégrée peut être convertie en extrait d'expression HLSL.

• Les utilisateurs peuvent accéder à n'importe quelle variable de la particule, de l'émetteur ou du système, ainsi qu'à n'importe quelle fonction HLSL ou VM.

• Cela fonctionne bien pour les fonctionnalités ponctuelles de petite taille, qui ne nécessitent pas de nouveau module.

Événements

• Les événements sont un moyen de communiquer entre des éléments (tels que les particules, les émetteurs et les systèmes).

• Les événements peuvent être des données de tout type, empaquetées dans une charge utile (comme une structure) et envoyées. Alors, n'importe quoi d'autre peut écouter cet événement et agir en conséquence.

• Options disponibles :

  • Exécutez l'événement directement sur une particule en utilisant Particle.ID.

  • Exécutez l' événement pour chaque particule dans un système.

  • Détermine comment faire apparaître les particules en réponse à l'événement, puis comment implémenter des actions sur ces particules.

• Les événements sont un nœud spécial dans le graphique (structures). Comment utiliser le nœud Événement :

  • Nommez l'événement.

  • Ajoutez-y les données que vous voulez.

  • Ajoutez un gestionnaire d'événements dans la pile de l'émetteur.

  • Configurez les options dans le gestionnaire d'événements.

• Il existe une pile d'exécution distincte pour les événements.

  • On peut insérer une logique de graphique élaborée dans les gestionnaires d'événements.

  • Vous pouvez configurer un système de particules complet, avec une logique complexe, et définir en parallèle tout un ensemble de comportements distincts qui se déclenchent lorsqu'un événement survient.

Interfaces de données

• Il existe un système extensible qui permet d'accéder à des données arbitraires.

• Les données arbitraires incluent les données de maillage, les sons, les informations externes de CDD, les objets de code et les conteneurs de texte.

• Les interfaces de données peuvent être écrites en tant que plug-ins pour une meilleure extensibilité par la suite.

• Les utilisateurs peuvent obtenir les données associées à un maillage squelettique en utilisant une interface de données du maillage squelettique.

Houdini

• Avec Houdini, vous pouvez calculer des points de division, des lieux d'apparition, des lieux d'impact, une vitesse d'impact, des normales, etc.

• Vous pouvez ensuite exporter ces données de Houdini vers un format conteneur courant (CSV).

• Vous pouvez importer un fichier CSV dans Niagara, dans votre projet UE4.