Référence de nœud Procedural Content Generation Framework

Execute blueprint

Ce nœud exécute une classe de blueprint personnalisée spécifiée avec la méthode Execute ou Execute With Context sur une instance propre d'une classe de blueprint dérivée de UPCGBlueprintElement.

Branch

Sélectionner l'une des deux sorties en fonction d'un attribut booléen. Cela permet de transmettre les données fournies à la "Sortie A" ou la "Sortie B" en fonction d'une valeur booléenne qui peut être remplacée dans le graphique. Il contrôle le flux d'exécution dans le graphique de manière à ce que différentes parties d'un graphique soient exécutées dans des circonstances spécifiques (présence ou non d'un élément, plateforme utilisée, etc.). La branche qui n'a pas de données est éliminée de l'exécution afin d'obtenir une performance plus efficace.

Sélectionner

Sélectionner l'une des deux entrées à transmettre à une sortie unique en fonction d'un attribut booléen. Il permet de contrôler le flux d'exécution dans le graphique de manière à ce que différentes parties d'un graphique soient exécutées dans des circonstances spécifiques (présence ou non d'un élément, plateforme utilisée, etc.).

Select (Multi)

Il s'agit de la version à entrées multiples du nœud Select, qui peut être configurée pour fonctionner avec des entiers, des enums ou des chaînes. Ce nœud est particulièrement utile pour rendre les sélections de différentes données plus visibles dans le graphique. Cela permet d'éviter l'effet "valeurs magiques", notamment lorsqu'il y a plus de deux entrées parmi lesquelles effectuer une sélection.

Switch

Il s'agit de la version à entrées multiples du nœud Branch, qui peut être configurée pour sélectionner un entier, un enum ou une chaîne. Ce nœud est particulièrement utile pour rendre les sélections de différentes données plus visibles dans le graphique. Cela permet d'éviter l'effet "valeurs magiques", notamment lorsqu'il y a plus de deux entrées parmi lesquelles effectuer une sélection.

Debug

Il débogue le nœud précédent dans le graphique, mais n'est pas transitoire. Cela fonctionne de la même manière que pour activer le débogage des nœuds qui fournissent leurs données à ce nœud. Cela permet de définir un point de débogage permanent dans un graphique, car il n'est pas transitoire, même si les paramètres de débogage le sont.

Sanity Check Point Data

Valider que le ou les points de données d'entrée ont une valeur dans la plage donnée ; en dehors de cette plage, ce nœud enregistre une erreur et annule la génération. Ce nœud est utile pour valider des hypothèses dans un graphique, mais il ne doit pas être considéré comme un bloc de construction recommandé dans les graphiques.

Print String

Afficher un message qui génère éventuellement un message préfixé dans le journal, le nœud et à l'écran. Ce nœud fait office de nœud de transfert dans la version de distribution. Il ne peut donc pas générer le message préfixé à ce stade. Ce nœud est utile pour déboguer et valider des hypothèses dans un graphique, par exemple sur les branches mortes qui suivent les nœuds de flux de contrôle.

Curve Remap Density

Remapper la densité de chaque point des données de point sur une autre valeur de densité selon la courbe fournie. Dans certaines situations, on peut s'en servir pour ajuster les densités, afin d'avoir de meilleurs dégradés ou d'effectuer un traitement plus complexe en aval. Étant donné que cette option repose sur un objet de données distinct, elle est plus facile à modifier en dehors de la PCG.

Densité finale = Curve Remap(Input Density)

Density Remap

Applique une transformer linéaire aux densités de points. On peut aussi le configurer pour qu'il n'affecte pas les valeurs qui sont en dehors de la plage d'entrée.

D' = (Out_Max - Out_Min) * (D - In_min) / (In_max - In_min) + Out_Min

Distance to Density

Définir la densité de points selon la distance de chaque point par rapport à un point de référence. Il permet de calculer les dégradés de densité par rapport à un point cible, ce qui permet un contrôle plus précis.

Attribute Filter

Filtrage polyvalent des attributs et propriétés. Il fonctionne à la fois sur les données de point et les ensembles d'attributs. Cela permet de séparer les données pour éliminer les points ou permettre un traitement distinct afin d'introduire des variations. Ce filtre peut être une constante, d'autres données spatiales (lorsque l'entrée est une donnée spatiale, que vous pouvez filtrer comme si vous échantillonniez le même point ou à partir de la version ToPoint) ou un ensemble d'attributs.

Attribute Filter Range

Version du filtre d'attributs basée sur une plage, dans laquelle les données d'entrée (données de point ou ensemble d'attributs) sont séparées entre celles qui se trouvent dans la plage et celles qui n'y figurent pas. Cela permet de séparer les données pour éliminer les points ou permettre un traitement distinct afin d'introduire des variations. Ce filtre peut être une constante, d'autres données spatiales (lorsque l'entrée est une donnée spatiale, que vous pouvez filtrer comme si vous échantillonniez le même point ou à partir de la version ToPoint) ou un ensemble d'attributs.

Density Filter

Filtrer les points en fonction de la densité et des plages de filtres fournies.

Discard Points on Irregular Surface

Tester plusieurs points autour de points sources donnés pour déterminer s'ils sont sur le même plan. C'est un exemple d'utilisation de sous-graphique de PCG. Il est utilisé dans la démo Electric Dreams.

Filter Data By Attribute

Séparer les données (mais pas le contenu) selon qu'elles disposent d'un attribut de métadonnées spécifié. Les données possédant l'attribut sont dans la sortie Inside filtre (Dans le filtre) et le reste dans la sortie Outside filtre (En dehors du filtre). Cela permet d'éviter les erreurs et les avertissements sur les sections de sous-graphique qui dépendent de l'existence de certains attributs qui ne sont pas forcément présents, notamment lorsqu'on obtient des données d'acteurs dans un monde.

Filter Data by Index

Séparer les données (mais pas le contenu) en fonction de leur index et du filtre défini dans les paramètres. Ce filtre est créé à partir d'une chaîne qui contient les index individuels ou les plages séparées par des virgules. Les nombres négatifs sont pris en charge de manière similaire aux plages de Python. Par exemple, sur une matrice de taille 10 (valeurs comprises entre 0 et 9), les index sélectionnés 0, 2, 4:5, 7:-1 incluront les index 0, 2, 4, 7 et 8. Cette option est utilisée lorsqu'il existe dans votre graphique des paramètres bien connus qui permettent d'autoriser certaines données, mais il est probable que les premiers ou derniers index soient généralement les plus sélectionnés.

Filter Data By Tag

Séparer les données (mais pas le contenu) selon leurs balises. Vous pouvez spécifier une liste de balises séparées par des virgules à filtrer. Cela s'avère utile pour obtenir des données depuis le monde et pour établir des relations entre des données dans la PCG. Par exemple, le nœud Get Actor Data pourrait renvoyer tous les acteurs possédant une balise donnée, dont certains seraient inclus ou exclus. Le nœud Fitler Data By Tag permet alors de séparer les données et de les transmettre à l'endroit où elles seront utiles dans le graphique.

Filter Data By Type

Séparer les données (mais pas le contenu) selon leur type, comme l'indique le type cible. Notez qu'il est possible d'afficher la broche Outside Filter dans les paramètres. Ce nœud est utilisé dans le graphique comme méthode de filtrage automatique, mais il existe d'autres cas où il peut être utile de déterminer le comportement du graphique en fonction des types de données fournis. Ce champ est autorisé ici en coordination avec le nœud Count Data.

Point Filter

Appliquer un filtre par point sur les données de point d'entrée. Le filtre peut être une constante, des données spatiales (sur lesquelles il est possible d'appliquer un filtrage comme si l'on échantillonnait le même point ou à partir de la version ToPoint), ou un ensemble d'attributs.

Point Filter Range

Appliquer un filtre de plage sur les données de points.

Self Pruning

Supprimer les intersections entre les points dans les mêmes données de points, en hiérarchisant les données en fonction des paramètres (des plus volumineuses aux plus petites, etc.). Les points ayant un rayon similaire peuvent être sélectionnés aléatoirement à l'aide d'un élagage aléatoire afin d'éviter l'apparition de motifs.

Add Tags

Ajouter des balises aux données fournies sur la base de listes de balises séparées par des virgules. Cela permet d'améliorer le suivi des données dans les graphiques complexes en liaison avec le nœud Filter Data By Tag.

Apply On Actor

Définir les propriétés sur un acteur en fonction des propriétés fournies dans un ensemble d'attributs. Il permet aussi d'appeler des fonctions sans paramètres sur un acteur, après que les propriétés sont définies (le cas échéant). Si aucun acteur n'est fourni, cela s'applique au propriétaire du composant de PCG (qui est un acteur de partition de PCG dans un graphique partitionné). Le fonctionnement est le même que pour les descriptions de remplacement de propriétés d'acteur généré dans le nœud Spawn Actor. Ce nœud Apply On Actor doit être utilisé avec précaution, car les changements apportés à un acteur ne peuvent pas être annulés par la PCG. Un exemple utilisant ce nœud consiste à envoyer des données calculées par PCG sur des acteurs qui peuvent ou non être créés à partir de la PCG de manière flexible, par exemple pour automatiser un processus de mise à jour des données directement à partir de la PCG.

Delete Tags

Supprimer les balises des données d'entrée, soit pour toutes les correspondances par rapport à une liste séparée par des virgules, soit si une balise ne se trouve pas dans la liste fournie. Ce nœud permet de normaliser les balises sur les données à traiter en aval. Il s'agit plus d'un nœud d'organisation. Toutefois, il pourrait être utilisé pour marquer les données comme traitées dans un flux de travail où le même traitement pourrait être effectué plusieurs fois.

Gather

Prendre toutes les entrées et générer une collection unique contenant toutes les données d'entrée. Utilisé essentiellement à des fins d'organisation.

Il contient une broche Dépendance uniquement pour l'exécution de séquence dans les cas où elle est importante (comme une requête de collision de rayon dans le monde ou un contenu généré dans un graphique donné). Il convient cependant de noter que les données fournies à cette broche ne seront pas transmises à la sortie.

Get Data Count

Renvoyer un ensemble d'attributs contenant le nombre de données transmises à la broche d'entrée. Notez que les données de points vides ne sont pas ignorées. Cette propriété peut être utilisée conjointement à des opérations logiques ou en tant que booléen directement dans les nœuds d'embranchement pour effectuer un traitement uniquement au moment où cela est nécessaire.

Get Entries Count

Renvoyer le nombre d'entrées dans un ensemble d'attributs. Ceci est utile lorsqu'il est utilisé en conjonction avec les nœuds Get Attribute Set From Index et Loop pour avoir un contrôle précis sur ce qui se passe dans un sous-graphique.

Get Loop Index

Renvoyer un ensemble d'attributs contenant l'index de boucle actuel si ceci est exécuté dans un sous-graphique de boucle. Ce nœud ne renvoie que l'index du sous-graphique direct et ne remonte pas l'arborescence du graphique pour trouver la boucle la plus proche. Il peut être utilisé pour calculer les données par itération dans le cas de motifs récursifs ou à des fins de journalisation.

Proxy

Remplacement de nœud générique qui permet un remplacement dynamique pendant l'exécution du graphique. Un prototype (valeur par défaut) peut être configuré pour afficher les broches de nœud appropriées, mais le nœud en cours d'exécution peut être piloté par des remplacements de paramètres. C'est particulièrement utile pour activer certains contrôles par instance à partir de nœuds préfabriqués, notamment pour exposer certains types de bruit spécifiques.

Replace Tags

Remplacer les balises sur les données d'entrée par leur équivalent correspondant. Ce nœud prend en charge le remplacement des balises dans les relations 1:1, N:1 ou N:N à l'aide de listes séparées par des virgules.

Sort Attributes

Trier les données d'entrée (données de points et ensemble d'attributs) selon un attribut spécifié dans un ordre croissant ou décroissant. Ce nœud peut être utilisé pour organiser les données de manière à les rendre prévisibles pour les nœuds en aval. Par exemple, il est possible de classer certaines valeurs par priorité, puis d'agir en aval en fonction de cet ordre.

Sort Points

Alias du nœud Sort Attributes.

Spatial Data Bounds To Point

Calculer les limites liées et renvoyer un point unique représentant les limites d'une donnée spatiale. Ceci est utile pour afficher ou pour obtenir une représentation plus simple des données qui peuvent être fusionnées avec d'autres données du même type.

Grid Size

Déterminer la grille à laquelle exécuter les nœuds en aval. Utilisé avec la génération hiérarchique.

Data Table Row to Attribute Set

Extraire une seule ligne d'une table de données vers un ensemble d'attributs. Ce nœud permet d'accéder à une table de données à partir d'une seule ligne. Il est moins flexible que Load Data Table, mais il a quand même son utilité.

Load Alembic File

Charger un fichier Alembic dans les données de points de la PCG. Ce nœud permet d'importer et de convertir un fichier Alembic au format de données de points. Bien que les fichiers Alembic contiennent plus que des points, les autres types ne sont pas actuellement pris en charge par ce nœud. Ce nœud n'est pas destiné à être exécuté dans un graphique en cours d'itération. Nous vous recommandons d'utiliser EUW, qui effectue cette conversion et stocke le fichier Alembic dans une ressource de PCG une fois, afin de rendre le processus plus efficace.

Il utilise le plug-in Procedural Content Generation (PCG) External Data Interop.

Load Data Table

Charger une UDataTable dans les données de points de PCG. Ce nœud peut importer la table en tant que données de points ou en tant qu'ensemble d'attributs. Cela s'avère très utile pour gérer les données de PCG sans avoir à regarder le graphique de PCG. Les modifications apportées à la table de données sont propagées à la PCG lorsque le fichier est enregistré.

Load PCG Data Asset

Charger de façon synchrone ou asynchrone un objet ressource de données de PCG et transmettre ses données en aval dans le graphique.

Add Attribute

Ajouter un attribut aux données de points ou à un ensemble d'attributs.

Attribute Noise

Calculer les nouvelles valeurs d'un attribut cible pour chaque point d'un ensemble de données de points. Cela fonctionne avec les données de points et les ensembles d'attributs. La valeur dépend de l'attribut d'entrée sélectionné : mode, bruit min et bruit max. Utile pour introduire de la variation sur des paramètres continus.

Attribute Partition

Diviser les données d'entrée (données de points ou ensemble d'attributs, ou autres données spatiales à convertir en données de points si nécessaire) dans une partition selon les attributs sélectionnés. Tous les éléments avec les mêmes valeurs pour chacun des attributs sélectionnés se retrouveront dans les mêmes données de sortie. Cela est utile pour séparer les données envoyées dans un nœud Loop s'il y a un traitement à effectuer dans une situation particulière pour la même valeur d'attribut, comme les points d'échantillonnage sur un maillage utilisant l'échantillonneur de maillage et la propagation de ces points à l'aide du nœud Copy Points sur les "bons" points.

Attribute Rename

Renommer un attribut existant. Ce nœud est utilisé lorsque le traitement en aval a besoin d'attributs spécifiques. C'est utile pour transmettre des données aux sous-graphiques.

Attribute Select

Calculer la valeur min, max ou médiane sur un axe sélectionné. Notez que cette étape est comparable au calcul d'un produit scalaire avec un axe.

Attribute String Op

Effectuer des opérations d'attributs liées aux chaînes, comme l'ajout de chaînes. Ce nœud est utilisé en coordination avec le nœud Print String et le nœud Create Target Actor.

Break Transform Attribute

Décomposer un attribut Transformation en ses composants : translation, rotation, et changement d'échelle.

Break Vector Attribute

Décomposer un attribut Vecteur en ses composants : X, Y, Z et W.

Copy Attribute

Copier un attribut soit depuis la broche Attribut, soit depuis l'entrée elle-même, vers de nouvelles données de points. Ce nœud est utile en ce sens qu'il vous permet de déplacer certaines valeurs vers d'autres attributs, d'exécuter des opérations plus complexes et, si nécessaire, de réécrire les résultats dans l'attribut d'origine.

Create Attribute

Créer un ensemble d'attributs avec un seul attribut.

Delete Attributes

Filtrer (conserver ou supprimer) les attributs séparés par des virgules d'un ensemble d'attributs ou de données spatiales. Ce nœud permet de supprimer les attributs qui ne sont pas utiles en aval. Dans certains cas, il peut être judicieux de procéder ainsi afin de ne pas polluer les données de sortie avec des attributs temporaires, mais aussi parce que certaines opérations, comme Copy Points, sont plus coûteuses lorsqu'elles sont effectuées par attribut, en fonction des paramètres utilisés.

Density Noise

Alias du nœud Attribute Noise.

Filter Attributes by Name

Filtrer (conserver ou supprimer) les attributs séparés par des virgules d'un ensemble d'attributs ou de données spatiales. Il s'agit d'un alias du nœud Delete Attributes.

Get Attribute from Point Index

Ce nœud récupère un point unique des données de points et ses attributs dans un ensemble d'attributs distinct. Ce nœud est souvent utilisé à l'intérieur de boucles sur des données partitionnées pour récupérer facilement la valeur d'attribut commune.

Make Transform Attribute

Créer un attribut Transformation à partir des trois attributs fournis : translation, rotation, et changement d'échelle.

Make Vector Attribute

Créer un attribut Vecteur constitué de deux à quatre attributs en fonction du type de sortie.

Match And Set Attributes

Sélectionner une entrée dans la table Ensemble d'attributs fournie (données de correspondance) et copier ses valeurs dans les données d'entrée (données de points ou ensemble d'attributs). Il remplace le nœud Point Match and Set.

La sélection est effectuée en faisant correspondre un attribut (Attributs de correspondance) des données d'entrée (Attribut d'entrée) avec un attribut des données de correspondance (Attribut de correspondance), de sorte que les valeurs ne soient copiées à partir d'une entrée des données de correspondance que si leurs valeurs coïncident.

Lorsque les données ne correspondent pas à un attribut, toutes les entrées des données de correspondance sont considérées comme des correspondances valides. De plus, il y a une option pour conserver ou supprimer les entrées qui ne correspondent à aucun élément des données de correspondance.

Dans les cas où plusieurs correspondances potentielles existent dans les données de correspondance, il est possible de les pondérer (attribut de pondération de correspondance), ou bien une correspondance sera sélectionnée de manière aléatoire. Il est possible de faire correspondre une valeur comprise entre [0 - 1], issue des données d'entrée, à la pondération normalisée des données de correspondance, en utilisant les champs Utiliser l'attribut de pondération d'entrée et Attribut de pondération d'entrée. Cela permet de piloter une sélection aléatoire à partir d'un bruit spatial préalablement calculé.

Enfin, lors de la mise en correspondance d'attributs, il est possible de faire correspondre les valeurs avec la valeur la plus proche s'il n'y a pas de valeurs égales à celle-ci. Il est également possible de définir une distance maximale à laquelle effectuer la correspondance, mais cela se limite aux types de valeurs continues disposant d'une métrique de distance raisonnable.

Les attributs utilisés pendant l'opération de correspondance ne sont pas propagés aux données de sortie. L'attribut correspondant ou les attributs de pondération des données de correspondance ne sont donc pas copiés vers la sortie.

Ce nœud est très flexible pour injecter des données dans les ensembles de points et d'attributs. Il permet également de construire des ensembles de données complexes grâce à sa capacité à faire correspondre les valeurs. Il s'agit d'un élément fondamental des graphiques pilotés par les données. Un nœud peut charger une liste de tables de données ou de ressources de données, puis copier facilement les données correspondantes vers les points en une seule opération.

Merge Attributes

Fusionner plusieurs ensembles d'attributs (dans l'ordre de connexion). Les attributs qui ne sont pas communs sont définis sur leur valeur par défaut respective (à la création de l'attribut) dans les entrées qui ne disposaient pas de ces attributs.

Point Match and Set

Ce nœud utilise l'option Faire correspondre et définir le type pour rechercher une correspondance pour chaque point en fonction des critères de sélection, puis appliquer la valeur à un attribut.

Il permet notamment de sélectionner des maillages à utiliser en aval dans un nœud Static Mesh Spawner avec le sélecteur Par attribut.

Transfer Attribute

Définir un attribut à partir d'un objet du même type (spatial vers spatial, ou points vers points) avec la même de taille d'ensemble de données. Cela est utile si une partie du traitement est effectuée sur le même ensemble de données, mais qu'il ne reste qu'un sous-ensemble des attributs à conserver, ou s'il existe une relation 1:1 dans les données.

And

Calculer le résultat de l'opération AND bit à bit entre deux attributs.

Not

Calculer le résultat de l'opération NOT bit à bit entre deux attributs.

Or

Calculer le résultat de l'opération OR bit à bit entre deux attributs.

Xor

Calculer le résultat de l'opération XOR (Exclusive OR) bit à bit entre deux attributs.

And

Calculer le résultat de l'opération booléenne AND entre deux attributs.

Not

Calculer le résultat de l'opération booléenne NOT entre deux attributs.

Or

Calculer le résultat de l'opération booléenne OR entre deux attributs.

Xor

Calculer le résultat de l'opération XOR (Exclusive OR) booléenne entre deux attributs.

Equal

Écrire dans un attribut booléen le résultat de la comparaison Equal To entre deux attributs.

Greater

Écrire dans un attribut booléen le résultat de la comparaison Greater Than entre deux attributs.

Greater or Equal

Écrire dans un attribut booléen le résultat de la comparaison Greater Than Or Equal To entre deux attributs.

Less

Écrire dans un attribut booléen le résultat de la comparaison Less Than entre deux attributs.

Less or Equal

Écrire dans un attribut booléen le résultat de la comparaison Less Than Or Equal To entre deux attributs.

Not Equal

Écrire dans un attribut booléen le résultat de la comparaison Not Equal entre deux attributs.

Abs

Calculer la valeur de l'opération mathématique Absolute Value. Convertir une valeur d'attribut d'entrée en une valeur positive et écrire le résultat dans un attribut.

Add

Calculer la valeur de l'opération mathématique Add. Prendre deux valeurs d'entrée, les ajouter et écrire le résultat dans un attribut.

Ceil

Calculer la valeur de l'opération mathématique Ceiling. Prendre une valeur d'entrée et l'arrondir à l'entier supérieur.

Fixer

Calculer la valeur de l'opération mathématique Clamp. Prendre les valeurs d'entrées et les limiter à une plage spécifique.

Clamp Max

Fournir une valeur maximale pour l'opération mathématique Clamp.

Clamp Min

Fournir une valeur minimale pour l'opération mathématique Clamp.

Divide

Calculer la valeur de l'opération mathématique Divide. Prendre deux entrées, diviser la première entrée par la seconde et écrire le résultat dans un attribut.

Sol

Calculer la valeur de l'opération mathématique Floor. Prendre une valeur d'entrée, l'arrondir à l'entier inférieur le plus proche et écrire le résultat dans un attribut.

Frac

Calcule la valeur de l'opération mathématique Frac. Prendre une valeur d'entrée et renvoyer la partie fractionnaire de cette valeur.

Par exemple, pour une valeur d'entrée X, le résultat est X moins la valeur entière inférieure de X. La valeur de sortie varie de zéro inclus à un exclu.

Lerp

Calculer la valeur de l'opération mathématique Linear Interpolate. Cette expression trace une ligne entre deux points et utilise une troisième valeur de ratio pour déterminer la valeur d'un point le long de cette ligne. Elle écrit ensuite cette valeur dans un attribut.

Max

Calculer la valeur de l'opération mathématique Max sur le ou les attributs et écrire le résultat dans un attribut. Cette opération prend deux valeurs d'entrée et produit la plus élevée des deux.

Min

Calculer la valeur de l'opération mathématique Min sur le ou les attributs et écrire le résultat dans un attribut. Cette opération prend deux valeurs d'entrée et produit la plus basse des deux.

Modulo

Calculer la valeur de l'opération mathématique Modulo. Prendre deux valeurs d'entrée et diviser la première par la seconde. L'opération renvoie ensuite le reste et l'écrit en tant qu'attribut.

Multiplier

Calculer la valeur de l'opération mathématique Multiply. Prendre deux valeurs d'entrée, les multiplier et écrire le résultat dans un attribut.

One Minus

Calculer la valeur de l'opération mathématique One Minus sur un attribut et écrire le résultat dans un attribut. Cette expression prend une valeur d'entrée X, génère 1-X et écrit le résultat en tant qu'attribut.

Pow

Calculer la valeur de l'opération mathématique Power. Cette expression prend deux valeurs : une base et un exposant. Elle élève la valeur de base à la puissance exponentielle et génère un attribut comme résultat.

Round

Calculer la valeur de l'opération mathématique Round et écrire le résultat dans un attribut. Cette expression prend une valeur d'entrée et l'arrondit au nombre entier le plus proche.

Set

Définir l'attribut de sortie à la valeur des attributs fournis.

Sign

Calculer la valeur de l'opération mathématique Sign et écrire le résultat dans un attribut. Évaluer une valeur d'entrée et indiquer si elle est positive, négative ou exactement nulle.

• Si l'entrée est négative, ce nœud renvoie -1.

• Si l'entrée est exactement nulle, ce nœud renvoie 0.

• Si l'entrée est positive, ce nœud renvoie 1.

Sqrt

Calculer la valeur de l'opération mathématique Square Root sur une entrée et écrire le résultat dans un attribut.

Subtract

Calculer la valeur de l'opération mathématique Substract. Cette expression prend deux entrées et soustrait la seconde entrée de la première.

Truncate

Calculer la valeur de l'opération mathématique Truncate et écrire le résultat dans un attribut. Cette expression tronque une valeur en ignorant la partie fractionnaire et en conservant la valeur entière. Par exemple, une valeur de 1,4 est tronquée à 1.

Average

Rassembler des informations d'ensemble sur lesquelles le graphique peut opérer. Par exemple, vous pourriez trouver la position moyenne à utiliser comme un bon point de pivot pour changer l'échelle de tous les points de données de points.

Max

Rassembler des informations d'ensemble sur lesquelles le graphique peut opérer. Par exemple, vous pourriez trouver la position moyenne à utiliser comme un bon point de pivot pour changer l'échelle de tous les points de données de points.

Min

Rassembler des informations d'ensemble sur lesquelles le graphique peut opérer. Par exemple, vous pourriez trouver la position moyenne à utiliser comme un bon point de pivot pour changer l'échelle de tous les points de données de points.

Combine

Combiner deux valeurs de rotation et écrire le résultat en tant qu'attribut, en combinant d'abord A, puis B.

Inverse Transform Rotation

Transformer un rotateur par l'inverse de la transformation fournie.

Invert

Rechercher l'inverse d'un rotateur fourni et écrire le résultat en tant qu'attribut.

Lerp

Effectuer une interpolation linéaire entre deux entrées de rotateur A et B en fonction du ratio. Cette opération applique 100 pour cent de A lorsque le ratio est de 0 et 100 pour cent de B lorsque le ratio est de 1.

Normalize

Fixer un angle dans une plage comprise entre -180 et 180 et écrire le résultat en tant qu'attribut.

Transform Rotation

Transformer une rotation en fonction d'une transformation donnée. Ce nœud prend une rotation en entrée et appliquer la transformation donnée.

Compose

Composer deux transformations dans l'ordre : A B. L'ordre est important lors de la composition de transformations. La composition A B génère une transformation qui applique d'abord A, puis B à toute transformation ultérieure. Le résultat est écrit dans un attribut.

Invert

Inverser la transformation d'entrée et écrire la nouvelle transformation en tant qu'attribut.

Lerp

Effectuer une interpolation linéaire entre deux entrées Transformation A et B en fonction du ratio. Cette opération applique 100 pour cent de A lorsque le ratio est de 0 et 100 pour cent de B lorsque le ratio est de 1.

Acos

Renvoyer le cosinus inverse (arccos) d'une entrée et écrire le résultat dans un attribut.

Asin

Renvoyer le sinus inverse (Arc sinus) d'une entrée et écrire le résultat dans un attribut.

Atan

Renvoyer la tangente inverse (arctan) d'une entrée et écrire le résultat dans un attribut.

Atan 2

Renvoyer la tangente inverse (arctan2) de 2 entrées (B/A) et écrire le résultat dans un attribut.

Cos

Renvoyer le cosinus (cos) d'une entrée et écrire le résultat dans un attribut.

Deg to Rad

Renvoyer une valeur en radians en fonction de l'entrée en degrés et écrire le résultat dans un attribut.

Rad to Deg

Renvoyer une valeur en degrés en fonction de l'entrée en radians et écrire le résultat dans un attribut.

Sin

Renvoyer le sinus (sin) d'une entrée et écrire le résultat dans un attribut.

Tan

Renvoyer la tangente (tan) d'une entrée et écrire le résultat dans un attribut.

Cross

Générer le produit vectoriel de deux vecteurs d'entrée.

Distance

Calculer la distance entre deux entrées vectorielles.

Dot

Renvoyer le produit scalaire de deux vecteurs d'entrée.

Inverse Transform Direction

Transforme un vecteur de direction à l'aide de l'inverse de la transformation d'entrée, sans en modifier la longueur. Le résultat est écrit dans un attribut.

Inverse Transform Location

Transformer une position à l'aide de l'inverse de la transformation d'entrée. Le résultat est écrit dans un attribut.

Length

Renvoyer la longueur d'un vecteur stocké dans un vecteur d'entrée.

Normalize

Générer une copie normalisée du vecteur, ce qui permet de s'assurer que l'opération est sûre en fonction de la longueur. Renvoyer un vecteur nul si la longueur du vecteur est trop petite pour être normalisée en toute sécurité.

Rotate Around Axis

Calculer et renvoyer le résultat du vecteur A après rotation d'un angle (en degrés) autour de l'axe.

Transform Direction

Transformer un vecteur directionnel d'entrée par la transformer fournie. La longueur ne change pas. Le résultat est écrit dans un attribut.

Transform Rotation

Transformer un rotateur ou un quaternion par la transformation d'entrée. Le résultat est écrit dans un attribut.

Make Rot from Angles

Renvoyer un attribut de rotation créé à l'aide des valeurs d'entrée et de sortie de roulis, tangage et lacet.

Make Rot from Axis

Renvoyer un rotateur utilisant une image de référence créée à partir des axes Avant, Droite et Haut.

Make Rot from X

Renvoyer un attribut Rotateur créé en utilisant uniquement un axe X. Les axes Y et Z ne sont pas spécifiés, mais ils seront orthonormés.

Make Rot from XY

Renvoyer un attribut Rotateur créé avec les axes X et Y. L'axe X reste fixe, mais l'axe Y peut légèrement varier afin de garantir l'orthogonalité. Le nœud calcule également la valeur Z.

Make Rot from XZ

Renvoyer un attribut de rotation créé avec les axes X et Z. L'axe X reste fixe, mais l'axe Z peut légèrement varier afin de garantir l'orthogonalité. Ce nœud calcule également la valeur Y.

Make Rot from Y

Renvoyer un attribut Rotateur créé en utilisant uniquement un axe Y. Les axes X et Z ne sont pas spécifiés, mais ils seront orthonormés.

Make Rot from YX

Renvoyer un attribut Rotateur créé à l'aide des axes X et Y. L'axe Y reste fixe, mais l'axe X peut légèrement varier afin de garantir l'orthogonalité. Le nœud calcule également la valeur Z.

Make Rot from YZ

Renvoyer un attribut Rotateur créé à l'aide des axes Y et Z. L'axe Y reste fixe, mais l'axe Z peut légèrement varier afin de garantir l'orthogonalité. Ce nœud calcule également la valeur X.

Make Rot from Z

Renvoyer un attribut Rotateur créé en utilisant uniquement un axe Z. Les axes X et Y ne sont pas spécifiés, mais ils seront orthonormés.

Make Rot from ZX

Renvoyer un attribut Rotateur créé à l'aide des axes X et Z. L'axe Z reste fixe, mais l'axe X peut légèrement varier afin de garantir l'orthogonalité. Ce nœud calcule également la valeur Y.

Make Rot from ZY

Renvoyer un attribut Rotateur créé à l'aide des axes Y et Z. L'axe Z reste fixe, mais l'axe Y peut légèrement varier afin de garantir l'orthogonalité. Ce nœud calcule également la valeur X.

Get Actor Property

Récupérer le contenu d'une propriété depuis l'acteur qui renferme le composant de PCG (ou un niveau supérieur dans la hiérarchie des objets).

Par défaut, ce nœud examine les propriétés au niveau des acteurs (utile pour les variables de blueprint), mais il peut aussi examiner les propriétés des composants grâce à l'option Sélectionner le composant.

Cette propriété peut contenir une structure "plate" (comme une structure sans matrices) ou être une matrice valide d'un type pris en charge. Dans le cas d'une matrice, la sortie sera un ensemble d'attributs comportant plusieurs entrées.

Ce nœud est utile pour récupérer des données d'acteurs dans le monde (lui-même ou autre) afin de permettre un contrôle par instance dans le graphique avec la même interface que le nœud Get Actor Data. Il pourrait, par exemple, contenir une liste de maillages statiques pour faire apparaître des matériaux, du sable, etc.

Get Property From Object Path

Récupérer le contenu d'une propriété depuis l'acteur qui renferme le composant de PCG (ou un niveau supérieur dans la hiérarchie des objets). Ce nœud est similaire au nœud Get Actor Property, à ceci près qu'il peut accepter des références d'acteurs (chemins d'objet logiciels) par le biais d'un ensemble d'attributs. Ce nœud est utile dans les cas d'utilisation fondés sur les données, où une table de données peut contenir des références à des acteurs et pourrait facilement en récupérer des propriétés si nécessaire sans avoir à passer par la sélection des acteurs.

Point To Attribute Set

Convertir des données de points en un ensemble d'attributs en supprimant toutes les propriétés de points pour ne conserver que les attributs de points. Si les données de points d'entrée ne possèdent pas d'attribut, aucun ensemble d'attributs n'est généré. Ce nœud peut s'avérer utile pour optimiser le traitement ou la mémoire dans certains cas, ou pour rendre homogènes les types de données dans le graphique.

Apply Scale to Bounds

Pour chaque point des données de points d'entrée, les limites min et max sont multipliées par leur échelle et l'échelle est réinitialisée à 1, mais les valeurs négatives sont préservées.

Bounds Modifier

Modifier la propriété de limites sur les points dans les données de points fournies. Ce nœud permet de modifier les limites des données de points d'entrée de manière simple, ce qui peut s'avérer utile, par exemple, avant un nœud Self Pruning, des intersections ou des différences, afin d'ajuster le résultat final.

Build Rotation From Up Vector

Combine Points

Pour chaque donnée de point d'entrée, générer de nouvelles données de points contenant un point unique qui englobe tous les points de leurs données de points respectives. Il permet de recalculer les données de points et de configurer une transformation spécifique. Ce nœud est utilisé, dans certains cas, comme une optimisation ou une vue de plus haut niveau sur certaines données.

Duplicate Point

Pour chaque point, dupliquer le point et le déplacer le long d'un axe défini par la direction, puis appliquer une transformation au nouveau point. Répéter le processus le nombre de fois indiqué par les itérations. Si l'option "Direction appliquée dans l'espace relatif" est sélectionnée, l'axe de déplacement est choisi itérativement depuis le nouveau point. Ce nœud est utilisé pour générer rapidement un grand nombre de points et créer des motifs de type fractal.

Extents Modifier

Modifier l'étendue de chaque point des données de points en manipulant les limites.

Split Points

Pour chaque point, créer deux points répartis entre "Avant division" et "Après division", en scindant les limites selon les axe et position de division spécifiés. Par exemple, si Position de division est défini sur 0,5, chaque point est coupé en son milieu et chaque moitié correspond à une sortie différente. Ce nœud permet d'effectuer des assemblages de points plus complexes en prenant en charge la sous-division.

Transform Points

Modifier les transformations des points (soit sur place, soit vers un attribut avec Appliquer à l'attribut) à l'aide de règles aléatoires de base. Chaque composant de la transformation (translation, rotation, changement d'échelle) peut être défini sur une valeur absolue plutôt que sur la valeur relative pour plus de contrôle.

Les options suivantes sont disponibles :

Uniform Scale : Change l'échelle des données de points avec le même ratio X, Y, Z.

Recompute Seed : forcer la mise à jour de la valeur de départ des points en fonction de leur nouvelle position dans le monde.

Example : utiliser un nœud Transform Points avec une Rotation absolue et une rotation Z nulle permet de s'assurer que les points sur Z pointent vers le haut. Ainsi, on s'assure que les points sont orientés vers le haut après l'échantillonnage du paysage.

Ce nœud est utile pour générer des variations spatiales avec des contrôles sur les données de points d'entrée. C'est un élément incontournable des graphiques générant des données d'apparence naturelle.

Copy Points

Copier une instance de tous les points de l'entrée Source par point de la cible. Il existe de nombreuses options permettant d'hériter des propriétés spatiales, mais l'héritage d'attribut a le plus d'impact sur les performances de ce nœud. Vous pouvez utiliser ce nœud pour effectuer des copies d'une boucle imbriquée. Vous pouvez donc avoir une source avec deux cibles à deux sorties, ou deux sources avec deux cibles à quatre sorties. Ce nœud est souvent utilisé pour instancier des données de points générées dans l'espace local (à savoir, dans les assemblages/ressources de PCG). Avant le post-traitement à leur position dans le monde.

Mesh Sampler

Échantillonner les points sur un maillage statique spécifié. Il faut noter que cette opération est coûteuse.

Ce nœud nécessite les plug-ins PCG Geometry Script Interop et Geometry Script.

Texture Sampler

Échantillonner les UV d'une texture à chaque point. À partir d'une entrée de texture, la méthode de mappage de texture "Planaire provenant des données de texture" transforme les coordonnées UV en fonction du nœud Get Texture Data et échantillonne la texture sur les entrées de point. Si la méthode de mappage de texture est "Utiliser les coordonnées UV des points explicites", les coordonnées UV sont comprises entre 0 et 1, avec des options supplémentaires permettant de déterminer quel attribut est utilisé pour les UV, ainsi que d'adresser la texture à encapsuler à l'aide du quadrillage avancé ou la fixer dans la plage 0-1.

Select Points

Sélectionner un sous-ensemble de points à partir des données de points d'entrée en utilisant la probabilité qu'un point donné soit sélectionné ou non. En pratique, cela signifie qu'en adoptant un ratio de 0,5, on aura environ la moitié des points d'entrée, mais on ne peut pas garantir que ce sera exactement la moitié ou non. La décision de sélectionner ou non un point étant prise indépendamment, cette opération suit une distribution normale.

Spline Sampler

Échantillonner les points en utilisant la spline comme matériau source. L'échantillonnage sur la spline s'effectue directement sur la courbe de la spline. Les options Horizontal, Vertical et Volume échantillonnent sur le volume de la spline (piloté par le rayon des points de contrôle des axes Y/Z).

Une spline doit être fermée avant qu'il soit possible d'échantillonner à l'intérieur de celle-ci.

Surface Sampler

Échantillonner les points des données de surface, dans un motif de grille standard. Ce nœud contient les options suivantes :

• Point Extents : définir la taille de base des cellules de la grille sur la surface.

• Loopness : définir la taille des cellules pour permettre une certaine variation En pratique, la taille des cellules est définie par la formule suivante : étendues des points * (1 + souplesse).

• Points Per Square Meter : calculer le ratio de cellules conservées. Cette propriété limite la saturation lorsque la grille est de grande taille.

Volume Sampler

Échantillonner les données spatiales fournies sur une grille 3D standard. Ce nœud adopte un comportement de 'type voxel' et peut être coûteux pour les données volumineuses ou les densités élevées.

Attribute Set To Point

Convertir un ensemble d'attributs en point de données en créant un point par défaut par entrée dans l'ensemble d'attributs. Les données de points qui en résultent ont les mêmes attributs que l'ensemble d'attributs d'origine.

Create Points

Créer des données de points contenant des points à partir d'une description statique de points. Ce nœud permet généralement de créer un point unique comme valeur de départ pour un autre processus qui nécessiterait une position dans le monde ou un élément similaire.

Create Points Grid

Créer des données de points contenant une simple grille de points définie par les paramètres. Ce nœud est utilisé dans le mode d'espace local et s'associe au nœud Copy Points pour créer des grilles autour de plusieurs sources.

Create Spline

Créer une spline à partir des données de points d'entrée. Ce nœud contient des options permettant de créer les éléments suivants :

• Créer un composant ou créer des données uniquement

• Splines fermées ou linéaires

• Appliquer des tangentes d'entrée et de sortie personnalisées à partir de noms d'attributs.

Create Surface From Spline

Créer une surface implicite à partir d'une spline fermée. Cette surface peut ensuite être utilisée comme les autres surfaces dans l'échantillonneur de surface, Difference, Intersection, etc.

Cull Points Outside Actor Bounds

Supprimer le point des données de points d'entrée en fonction des limites du composant actuel (acteur de partition ou original), avec un contrôle supplémentaire pour l'extension des limites. Cela permet de s'assurer que les données d'entrée sont pertinentes pour le traitement actuel tout en permettant un certain chevauchement si nécessaire.

Difference

Générer le résultat de la différence de chaque source par rapport à l'union des différences. Ce nœud dispose des options suivantes :

Density Function : Déterminer la fonction de densité à utiliser une fois l'opération terminée. Ce nœud contient les options suivantes :

• Minimum : la densité finale est égale à la densité de la source moins la densité maximale de toutes les différences.

• Clamped Subtraction : la densité finale est égale à la densité de la source moins la densité cumulée de toutes les différences. Cette valeur est fixée entre 0 et 1.

• Binary : la densité finale est égale à 0 si la densité de la différence est supérieure à zéro. Sinon, la densité finale est égale à la densité de la source.

Mode : contrôler le comportement du nœud Difference en présence de données spatiales concrètes ou de données continues (d'autres types, plus proches de fonctions de distribution). Notez que dans certains cas où nous voulons sélectionner un élément concret, il faudrait définir ce nœud sur Discrete, sinon la fonction de densité qui en résulte pourrait ne pas être plate. Ce nœud contient les options suivantes :

• Inferred : discret si la source ou les différences sont des points, et continu dans le cas contraire.

• Continuous : la fonction de densité n'est pas réduite.

• Discrete : réduire la fonction de densité, ce qui signifie que le nœud convertit les données en données de points.

Distance

Pour chaque point de la première entrée, calculer la distance qui le sépare du point le plus proche dans la deuxième entrée et ignorer automatiquement le point lui-même lors du calcul de la distance entre un même ensemble de données de points. Le nœud peut également générer le vecteur de distance en tant qu'attribut. Ce nœud permet de simuler des champs de distance ou de créer des dégradés en fonction de la distance dans des données de points. Il peut être utilisé pour changer l'échelle des arbres sur les arêtes des forêts ou de celles qui sont trop proches d'une branche.

Find Convex Hull 2D

Calculer une convexe 2D à partir des données de points d'entrée en utilisant uniquement la position (et non les limites) de chaque point. Ce nœud peut être utilisé avec le nœud Create Spline afin de créer une spline qui englobe tous les points et qui, à son tour, peut être transmise au nœud Create Surface From Spline.

Get Actor Data

Version générale des nœuds Get … Data. Lire les données d'un acteur à l'aide du filtre d'acteur et du mode.

Les options suivantes sont disponibles :

Actor Filter : déterminer les acteurs à prendre en compte lors de la récupération de données d'acteur.

Include Children : déterminer s'il faut prendre en compte les acteurs enfants de l'entrée.

Mode : contient les options suivantes :

• Parse Actor Components : générer des données de PCG à partir des composants de l'acteur.

• Get Single Point : renvoyer des données de points contenant un point par acteur avec sa transformation et ses limites locales. Utilisez l'option MergeSinglePointData si nécessaire.

• Get Data from PCG Composant : renvoyer le résultat de l'exécution du la PCG d'un autre acteur. Notez que seules les données transmises au nœud Output sont stockées sur le composant de PCG. En outre, seuls certains types sont pris en charge (données de points et ensemble d'attributs), et seront interrogés en conséquence. La PCG s'assure que l'exécution de l'acteur distant a bien lieu avant de poursuivre. Notez que les données doivent être déjà générées (ou en cours de génération) et qu'elles ne peuvent pas être sur le même acteur que le composant qu'il exécute.

• Get Data from PCG component ou Parse Actor components : renvoyer la sortie de PCG en premier, si présente. Analyser ensuite les acteurs, si nécessaire.

Options supplémentaires lors de l'obtention des données de PCG :

• Expected Pins : Si vous obtenez des données de PCG, vous pouvez également fournir une liste des broches attendues qui correspondent au nœud de sortie du graphique de PCG qui a généré les données.

• Get Data On All Grids : obtenir des données de chaque de taille de grille sur les composants cibles.

  • Allowed Grids : si vous n'utilisez pas l'option Get Data On All Grids, sélectionnez l'ensemble de tailles de grilles duquel les données peuvent être extraites.

  • Components Must Overlap Self : obtenir des données uniquement des composants qui chevauchent les limites de votre composant source. Cette Il s'agit d'une optimisation facultative permettant d'éviter de recevoir des données qui ne sont pas pertinentes pour le composant.

Ce nœud est le moyen le plus courant d'accéder aux données de la PCG, en particulier dans les graphiques racines.

Get Bounds

Créer un ensemble d'attributs contenant les limites dans l'espace du monde (min et max) de données spatiales. Notez que ce nœud est plus général que le nœud Combine Points, car il renvoie des limites de plusieurs types. Ce nœud peut être utilisé comme construction de niveau supérieur pour effectuer un traitement à plus grande échelle dans un graphique.

Get Landscape Data

Spécialisation du nœud Get Actor Data qui renvoie des données de paysage correctement typées et construites.

Get PCG Component Data

Spécialisation du nœud Get Actor Data qui renvoie uniquement la sortie générée à partir des composants de PCG de l'acteur sélectionné.

Get Points Count

Renvoyer le nombre de points dans les données de points d'entrée fournies. Cela crée un ensemble d'attributs unique, quel que soit le nombre d'entrées et une entrée dans cet ensemble d'attributs par données de points d'entrée.

Get Primitive Data

Spécialisation du nœud Get Actor Data qui renvoie des données primitives correctement typées et filtrées.

Get Spline Data

Spécialisation du nœud Get Actor Data qui renvoie des données de spline correctement typées et filtrées.

Get Texture Data

Charger une texture sur des données de surface. Notez que l'exécution du processeur graphique est requise pour la plupart des types de textures compressées. Ce nœud prend en charge l'échantillonnage des textures compressées, les UTexture2DArrays avec un index permettant de sélectionner la texture UTexture2d souhaitée, l'échantillonnage des textures utilisables par le CPU, qui peuvent être créées à l'aide de la propriété Availability de n'importe quelle texture UTexture, et l'option de filtrage des points, au lieu d'un simple filtrage bilinéaire. Ce nœud permet également à l'option exclusive à l'éditeur de forcer l'échantillonnage du CPU. Il crée un double de la texture cible, visible par le CPU et non compressée, et l'échantillonne à la place. Il évite les artefacts de compression liés à l'échantillonnage du GPU.

Get Volume Data

Spécialisation du nœud Get Actor Data qui renvoie des données de volume correctement typées et filtrées.

Inner Intersection

Calculer l'intersection interne de toutes les données fournies au nœud, quelles que soient leurs broches.

Exemple : L'entrée contient [A, B, C]

Résultat : A ∩ B ∩ C

Intersection

Calculer une intersection extérieure pour chaque donnée fournie dans la broche Source principale. Le résultat est une intersection par donnée sur la broche Source principale par rapport à l'union des données de chacune des autres broches Source.

Exemple : La source principale contient [A, B] La source 1 contient [C, D]. La source 2 contient [E].

Résultat : A ∩ (C ∪ D) ∩ E, B ∩ (C ∪ D) ∩ E

Make Concrete

Réduire les types de données composites (intersection, différence, union) en données de points. Pour les données déjà concrètes, cela n'a aucun effet. Ce nœud n'est normalement pas utilisé directement, mais il s'agit d'une étape de conversion en nœuds spécifiques.

Merge Points

Combiner plusieurs données de points d'entrée en une seule. Les attributs sont fusionnés et les attributs non communs sont insérés par défaut.

Mutate Seed

Modifier la valeur de départ de chaque point dans les données de points d'entrée en fonction de sa position, de sa valeur de départ précédente, de celle de ce nœud et de celle du composant. Ce nœud est utile pour différencier les comportements aléatoires après certaines opérations qui dupliquent des points sans pour autant modifier leur valeur de départ.

Normal To Density

Calculer la densité des données de points en fonction de la normale de point et des paramètres fournis (Normale, Décalage, Force, Mode de densité) qui sont similaires à un produit scalaire, avec une flexibilité supplémentaire. Ce nœud est souvent utilisé pour modifier certains points en fonction de leur alignement avec un axe donné, par exemple, pour rendre certains arbres plus hauts (ceux les plus alignés), ou en supprimer d'autres (ceux les moins alignés, comme sur des pentes raides).

Point Neighborhood

Calculer des valeurs basées sur le voisinage et les appliquer aux données de points d'entrée, en fonction d'une distance de recherche (exprimée en unités du moteur). Les valeurs incluent la distance par rapport au centre, le centre moyen du voisinage, la densité moyenne et la couleur moyenne. Ce nœud permet de lisser des valeurs de densité d'un point à l'autre, ce qui est souvent utile pour les processus procéduraux naturels.

Point From Mesh

Créer des données de points contenant un point avec les limites du maillage statique fourni et une référence à ce maillage. Cela est utile lorsque la sélection du maillage potentiel est effectuée en amont, puis que ses limites sont transférées aux points (souvent via une combinaison de nœuds Partition, Loop et Point From Mesh) avant d'effectuer des tests d'intersection ou un auto-élagage.

Projection

Créer des données de projection à partir de la donnée source pour projeter sur une cible. Il convient de noter que s'il n'existe pas de représentation de projection spéciale de ces données sources vers ces données cibles, alors les données sont converties en points. Ce nœud est très souvent utilisé pour reprojeter des points sur les surfaces après quelques manipulations dans le graphique. Par exemple, il suffit souvent de suivre un nœud Copy Points pour replacer les points dans la position appropriée dans leur environnement.

Spatial Noise

Construire un motif de bruit spatialement cohérent (tel que le bruit de Perlin) et l'écrire dans un attribut spécifié. Ce nœud peut être utilisé en coordination avec les nœuds Match et Set Attributes et les pondérations déterminées par les entrées afin d'appliquer le bruit spatial à la sélection. En général, ce nœud permet d'obtenir des distributions d'aspect plus naturel.

To Point

Convertir les données en données de points si elles le sont déjà, ou discrétiser les données spatiales pour les transformer en données de points.

Union

Créer une union logique entre les données, du point de vue de la fonction de distribution. Le résultat dépend de l'option de fonction de densité choisie.

Density Function : Déterminer la fonction de densité à utiliser une fois l'opération terminée. Ce nœud contient les options suivantes :

• Maximum : la densité finale est égale à la densité maximale de la source.

• Clamped Addition : la densité finale est égale à la somme des densités de toutes les différences. Cette valeur est fixée entre 0 et 1.

• Binary : la densité finale est égale à 1 si une densité de la source est supérieure à zéro. Notez que ceci est rarement utile sauf dans le contexte d'une différence binaire.

World Ray Hit Query

Créer un type de donnée semblable à une surface, qui effectue des projections de rayons dans le monde physique. Il peut transmettre des données à n'importe quel nœud qui attend des données de surface.

Par défaut, la taille et l'orientation des rayons sont régies par les propriétés d'acteur du composant source (généralement un volume), mais ces propriétés de rayon peuvent être remplacées. Les options suivantes sont disponibles :

Apply Metadata From Landscape : obtenir les valeurs de la couche de paysage si la projection de rayon touche le paysage. Cela implique un léger coût en performances.

Ignore PCG Hits : ignorer toutes les ressources générées par la PCG. Cette option est utile lorsqu'il n'y a pas d'ordre par rapport à d'autres nœuds qui créent des données dans le monde (ou dans d'autres graphiques).

Il est éventuellement possible de renvoyer le matériau physique et l'acteur touché.

Les éléments de filtrage sont utilisés pour un contrôle plus précis, afin d'ignorer ou de conserver uniquement certaines collisions.

World Volumetric Query

Créer un type de donnée semblable à un volume, qui collecte des points depuis le monde physique. Il peut transmettre des données à n'importe quel nœud qui attend des données de surface.

Le paramètre Search for overlap check (Rechercher un contrôle de chevauchement) détermine si les chevauchements sont renvoyés sous forme de points, ou si seules les requêtes ne chevauchant aucun élément (sous réserve de filtrage) sont renvoyées.

Il peut aussi renvoyer l'acteur "trouvé" dans ce volume.

Create Target Actor

Créer un acteur vide à partir d'un modèle qui peut être utilisé comme cible pour l'écriture d'artefacts de PCG, comme le générateur de maillages statiques.

Point from Player Pawn

Créer un point à la position actuelle du pion joueur. Utilisé lors de la génération à l'exécution.

Spawn Actor

Générer soit le contenu d'un acteur, soit un acteur par point dans les données d'entrée fournies. L'acteur est régi par la classe d'acteurs modèle, par l'acteur modèle instancié, ou par un attribut en fonction des paramètres.

Les options suivantes sont disponibles :

Classe d'acteurs modèle : liste des acteurs disponibles dans votre projet.

Option :

• Collapse Actors : rassembler certains des composants d'acteur (composants de maillage statique et composants de PCG) et agir à l'intérieur de l'acteur cible.

• Merge PCG only : générer un acteur par point. Si l'acteur généré dispose d'un composant de PCG, ses d'entrées sont regroupées dans une seule exécution de graphique.

• No Merging : générer un acteur par point.

Dans le cas No Merging, il est possible de définir des propriétés pour les acteurs à partir d'attributs sur les points via les ‘Descriptions de remplacement de propriété d'acteur généré'.

Mode Attach :

• Not attached : aucune relation reconnue par le moteur n'existera entre l'acteur d'origine (propriétaire du composant de PCG) et l'acteur créé.

• Attached : l'acteur cible créé sera joint en tant enfant à l'acteur propriétaire du composant de PCG. Notez que cela a un impact sur le chargement dynamique de l'acteur créé dans les mappages activés par la World Partition. Par exemple, cet acteur sera chargé avec le parent.

• In Folder : aucune relation reconnue par le moteur n'existe, mais le ou les acteurs seront placés dans un dossier nommé en fonction de l'acteur propriétaire du composant de PCG, pour une visualisation plus facile dans l'organiseur de scène. Cela n'a aucun effet sur le chargement dynamique.

Ce nœud peut être utilisé pour créer des acteurs de type partition et rassembler des artefacts (visuels ou autres) sur des acteurs pouvant être correctement chargés lors de l'exécution.

Static Mesh Spawner

Générer un maillage statique par point dans les données de points fournies.

Les options de maillage statique sont ajoutées à la matrice Entrées de maillage et sélectionnées à l'aide de la pondération de chaque entrée. Pour ce faire, il prend la somme de toutes les valeurs de pondération et la convertit en pourcentage pour chaque entrée. Par exemple, si la matrice contient quatre entrées avec chacune une valeur de 1, la valeur de la somme est 4. La pondération de chaque entrée est ensuite divisée par la somme et convertie en pourcentage. Cela signifie que chaque entrée a une probabilité d'apparition de 25%.

La sélection du maillage statique s'effectue à l'aide de variations et en fonction de l'option Type de sélecteur de maillage.

Les options suivantes sont disponibles :

• PCG Mesh Selector Weighted : sélectionner une entrée en fonction de la pondération totale des entrées.

• PCG Mesh Selector By Attribute : sélectionner une entrée en fonction d'un attribut présent sur le maillage.

• PCG Mesh Selector Weighted By Category : sélectionner une catégorie en recherchant un attribut sur le point, puis sélectionner une entrée en fonction de la pondération.

Le maillage sélectionné est écrit dans un attribut sur les données de points de sortie, et les limites du maillage sélectionné sont poussées vers les limites des points.

Pour chaque remplacement de propriété de maillage créé, un attribut peut être sélectionné pour être appliqué à une cible de propriété dans le descripteur de modèle de l'ISM lorsqu'il sera généré.

Boucle

Exécuter un autre graphique en tant que sous-graphique, une fois par données dans les broches de boucle. Les broches hors boucle sont transmises telles quelles. Les propriétés des broches sont configurées sur les nœuds d'entrée et de sortie dans chaque graphique. L'utilisation des broches détermine leur comportement lorsqu'elles sont exécutées dans une boucle. Les broches de retour ont un comportement particulier. Elles doivent donc être associées à une autre broche de même nom dans la sortie. Pendant l'exécution, la première itération reçoit les données de la broche de retour du graphique d'appel, mais les itérations suivantes reçoivent leurs données de l'itération précédente. Ce nœud est extrêmement important pour simplifier le traitement local des mêmes données. Par exemple, il permet l'échantillonnage d'un seul maillage (avec le nœud Mesh Sampler), puis de copier ces données uniquement sur les données pertinentes. Il permet également de générer des ensembles de données interdépendants (séquences de sélection et exclusions) et autres.

Sous-graphique

Exécuter un autre graphique en tant que sous-graphique. Notez qu'un graphique peut s'appeler de façon récursive ; le graphique est exécuté jusqu'à ce que ce nœud Subgraph soit retiré de l'exécution (en raison des nœuds Control Flow) ou s'il ne comporte plus de données d'entrée. Les nœuds Subgraph permettent de réduire la complexité graphique et d'optimiser la réutilisation. Ils permettent également la récursivité, ce qui peut être utile dans certaines situations.

Add Comment

Aide visuelle pour classer et organiser un graphique. Il ne s'agit pas d'un nœud réel.

Add Reroute Node

Outil d'organisation de graphique permettant d'ajouter des points de contrôle sur les arêtes afin d'améliorer leur apparence dans le graphique.

Nœud Add Named Reroute Declaration

Les nœuds de redirection nommés sont similaires aux nœuds de redirection classiques, mais ils n'ont pas d'arêtes visuelles. Ils permettent de supprimer les très longues arêtes ou les arêtes en spaghetti dans les grands graphiques. Ils peuvent être renommés et utilisés à plusieurs endroits, mais ils ne peuvent être définis qu'en un seul endroit dans un graphique (définition).