Le framework PCG (génération procédurale de contenu) utilise le graphique de nœud procédural pour générer du contenu procédural à la fois dans l'éditeur et à l'exécution. Dans un format similaire à celui de l'Éditeur de matériau, les données spatiales sont transmises dans le graphique à partir d'un composant PCG de votre niveau et sont utilisées pour générer des points. Les points sont filtrés et modifiés par une série de nœuds, qui sont répertoriés ci-dessous :
Blueprint
| Nœud | Description |
|---|---|
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 |
Flux de contrôle
| Nœud | Description |
|---|---|
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.). Les branches de sélection (entrées) ne sont pas éliminées de l'exécution à ce stade, mais elles peuvent l'être dans une prochaine version. |
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
| Nœud | Description |
|---|---|
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. Il ne s'exécute pas dans les versions hors éditeur. |
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. |
Densité
| Nœud | Description |
|---|---|
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. Dans la plupart des cas, ce nœud est remplacé par le nœud natif Distance, qui est plus général et nettement plus efficace. |
Filtre
| Nœud | Description |
|---|---|
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. Ce nœud est entièrement remplacé par le nœud Attribute Filter, mais il est plus spécialisé et plus efficace que lui. Ce nœud doit être utilisé lorsque les performances constituent une problématique importante ou lorsqu'il permet de transposer plus facilement l'intention dans le graphique. |
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. |
Générique ;
| Nœud | Description |
|---|---|
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. |
Aides
| Nœud | Description |
|---|---|
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. |
Génération hiérarchique
| Nœud | Description |
|---|---|
Grid Size | Déterminer la grille à laquelle exécuter les nœuds en aval. Utilisé avec la génération hiérarchique. |
Entrée Sortie
| Nœud | Description |
|---|---|
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. |
Métadonnées
| Nœud | Description |
|---|---|
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. Notez que la distance sur les vecteurs est la distance euclidienne en unités du moteur, la distance sur les rotateurs est en degrés, et la distance sur les quaternions est en radians. 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. |
Opérations bit à bit sur attribut
| Nœud | Description |
|---|---|
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. |
Opérations booléennes sur attribut
| Nœud | Description |
|---|---|
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. |
Opérations de comparaison d'attributs
| Nœud | Description |
|---|---|
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. |
Opérations mathématiques sur attribut
| Nœud | Description |
|---|---|
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.
|
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. |
Opérations de réduction d'attribut
| Nœud | Description |
|---|---|
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. |
Opérations de rotation d'attribut
| Nœud | Description |
|---|---|
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. |
Opération de transformation d'attribut
| Nœud | Description |
|---|---|
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. |
Opérations de trigonométrie sur attribut
| Nœud | Description |
|---|---|
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. |
Opérations vectorielles sur attribut
| Nœud | Description |
|---|---|
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. |
Opérations de rotation d'attribut
| Nœud | Description |
|---|---|
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. |
Paramètre
| Nœud | Description |
|---|---|
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. |
Opérations sur les points
| Nœud | Description |
|---|---|
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. |
Échantillonneur
| Nœud | Description |
|---|---|
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 :
|
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. |
Spatial
| Nœud | Description |
|---|---|
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 :
|
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. À ce stade, le système repose sur une discrétisation de la spline et, à ce titre, il peut ne pas fonctionner pour les splines de très grande taille. Si tel est le cas, envisagez d'échantillonner votre spline d'abord, puis de créer une nouvelle spline (à l'aide du nœud Create Spline) avant d'utiliser ce nœud. |
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 :
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 :
|
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 :
Options supplémentaires lors de l'obtention des données de PCG :
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 :
|
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. |
Générateur
| Nœud | Description |
|---|---|
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 :
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 :
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 :
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é. |
Sous-graphique
| Nœud | Description |
|---|---|
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. |
Non classé
| Nœud | Description |
|---|---|
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). |