Le graphe d’asset

Le graphe d’asset est l’endroit où l’on conçoit un export ; la fenêtre d’export est l’endroit où on le lance. L’étape Asset transforme les listes de sprites en fichiers, et sa façon de le faire est un graphe : les listes de sprites arrivent, sont disposées sur une planche, et sortent sous forme de fichiers. Ce sont les trois sortes de liens, et on ne peut pas les confondre — une liste ne peut pas être reliée à une Planche sans avoir d’abord été disposée, et une planche ne peut pas recevoir de tag.

Ses entrées sont des nœuds Sprites (et des nœuds Fichier image, pour les images venues de l’extérieur), chacun apportant des listes de sprites : une action vue par une caméra, dessinée avec un Style, avec un jeu de parties, découpée en images, avec chaque calque. Un nœud Sprites les nomme tous, de façon fixe : les choix de l’en-tête de la fenêtre ne sont pas les siens, si bien que ce qu’écrit un asset ne dépend jamais de ce qui se trouve être affiché. Ses sorties sont un nœud par fichier. Un nœud Planche est une planche de sprites en mémoire : il affiche la planche sur sa face et n’écrit rien. Chaque fichier est un nœud Fichier relié à lui — Image PNG pour la planche elle-même, puis son JSON, son .aseprite, ses SpriteFrames Godot, sa carte de normales. Pour exporter une planche de sprites, reliez Planche → PNG. Un graphe peut en avoir autant que le projet a de fichiers à écrire.

Tout ce qu’on peut indiquer à un export se trouve sur un nœud, sauf le dossier où il va : cela relève de la fenêtre Exporter, qui liste chaque fichier que le graphe y écrira, par nom et par type, avant que vous n’appuyiez sur Exporter — le moyen le plus rapide de voir ce qu’une modification du graphe fait aux fichiers. La façon dont les images d’une planche sont nommées se trouve sur son nœud d’image PNG (et dans l’Inspecteur avec sa Planche), sa disposition sur le Disposer qui l’alimente, et chaque autre fichier qu’elle écrit — avec les réglages propres à ce fichier : l’échelle d’un GIF, la cadence d’une vidéo, quelle ombre, quelles variantes de palette — est un nœud Fichier relié à partir d’elle. Un projet qui ne relie jamais autrement le graphe n’en stocke aucun : c’est une seule planche de chaque liste de sprites.

Une image peut montrer n’importe quel calque. Sous l’image d’une Planche, ici, Calque choisit le calque qu’elle dessine — tant qu’on ne lui a rien dit, celui que dessine le Calque de la Vue 2D elle-même — le sprite, ses traits, ses aplats, ses normales, la profondeur, l’émission, une sortie supplémentaire d’un Style — ou Tous les calques à la fois : ceux d’une image côte à côte, ceux d’une liste une rangée chacun.

C’est le graphe de départ, le pipeline d’asset Principal :

Sprites (every action except Static)  →  Arrange  →  Sheet (sheet)  →  PNG image

Les choix de l’en-tête de la fenêtre

Action, Style et Asset sont des pipelines indépendants, chacun étant un graphe à part. L’extrémité droite de la rangée d’onglets des espaces de travail contient quatre sélecteurs — Caméra, Action, Style, Asset — après Lecture/Pause : un choix de chaque, valable pour toutes les étapes.

Palier	Dessine
Action	l’action choisie, vue par la caméra choisie
Style	l’action choisie, vue par la caméra choisie, dessinée par le Style choisi
Asset	ce que nomment les nœuds Sprites de son propre graphe — pas les choix de l’en-tête

La liste Styles (étape Style) et la liste Assets (étape Asset) sont les mêmes choix que les sélecteurs Style et Asset de l’en-tête : un clic dans l’un ou l’autre montre la même chose. La fenêtre d’export démarre avec le pipeline d’asset choisi dans le sélecteur Asset de l’en-tête, et n’écrit que lui ; ses fichiers sont nommés comme lorsque tous les pipelines d’asset sont écrits (pxr render --pipeline all les écrit tous).

D’où viennent les listes de sprites

Les listes de sprites se font ici, par les nœuds Sprites, et seulement ici : les actions qui vont dans les planches sont celles que prennent les nœuds Sprites, rien d’autre. Un nœud Sprites nomme une caméra, une action, un Style et un jeu de parties, et contient la découpe : comment le mouvement de l’action devient des images.

Son Action est l’une de celles-ci :

• Tous sauf Statique (every-one-except-static, ce que prennent un nouveau nœud Sprites, le pipeline d’asset avec lequel commence un projet et un nouveau projet) : chaque action de la liste des actions sauf Statique, la pose de repos immobile — Statique malgré tout quand le projet n’a aucune autre action (un modèle immobile), pour qu’une caisse ait quand même son sprite.
• Tous (vide, ou *) : chaque action, Statique comprise.
• Une action par son nom, Statique comprise : cette action seule, ou plusieurs (walk, attack depuis pxr graph set). Un clip du modèle est dessiné quand un nœud Sprites le nomme, qu’il fasse ou non partie des actions du projet — une fois nommé, ses images sont toujours là, dans l’image du nœud, dans ce qu’il alimente et dans l’export.

Un nom qui ne désigne rien (une action supprimée ou renommée ailleurs) est signalé sur le nœud, en termes simples : Aucune image de Sway vue par South : choisissez une action et une caméra du projet sur le nœud Sprites.

La découpe est sur sa face et dans l’Inspecteur :

• Images/s (fps) : une image toutes les tant de secondes, 12 par seconde tant qu’on ne dit pas autre chose.
• Images gardées (smart) : autant d’images intelligentes, choisies comme le ferait un animateur — les poses où le mouvement change de sens, davantage là où il est rapide, chacune tenue jusqu’à la suivante. 0 les désactive. Images intelligentes sur sa face les active, Utiliser images/s revient à un pas régulier.
• Images choisies (picked) : des instants en secondes, choisis à la main. Quand le nœud Sprites est choisi, la Timeline derrière le graphe d’asset montre ses images : cliquez sur la bande des clés pour en ajouter ou en retirer une, ou faites glisser une clé le long de celle-ci (une étape d’annulation à chaque fois). La face indique N images choisies sur la timeline.

Les images choisies l’emportent quand il y en a, puis les images gardées, puis les images par seconde. Un nœud Sprites ajouté à un graphe commence découpé comme le premier du graphe. Une action faite de nœuds ou de clés est découpée à ses propres images. Tenue (ms), à côté du compteur d’images de la Timeline, règle la tenue de l’image affichée (voir tenir une image plus longtemps) : celle de l’action, si bien que chaque nœud Sprites qui prend le clip la conserve. L’étape Action n’est pas modifiée par tout cela : elle joue tout le mouvement, et une image de sprite tombe sur le temps où elle a été découpée.

Entre le nœud Sprites et le Disposer se placent les nœuds qui découpent une liste :

Nœud	Ce qu’il fait
Plage d’images	Seulement les images de from à to de ce qui arrive, comptées à partir de 0 : la préparation d’une attaque comme liste à part, une image d’un idle comme icône, une liste sur deux planches. Une plage garde ce que montrait chaque image — son temps dans le clip, son jeu de parties, son déplacement racine. Une plage d’une plage compte dans ce qui est arrivé ; une partie d’une boucle ne boucle plus ; une plage au-delà de la fin garde la dernière image.
Tenue	Chaque image tenue autant de fois plus longtemps : 2 joue la liste à mi-vitesse.

Sprites (South, attack, Pixel Art, smart 6) → Frame range (2 to 5) → Hold (×2) → Arrange → Sheet → PNG image

Choisir un nœud Sprites, Plage d’images ou Tenue fait jouer à la Vue 2D la liste qu’il donne, découpée, tranchée et en calques comme elle sera écrite. Aucun de ces nœuds ne coûte de rendu : ils décident quelles images vont où avant qu’un seul pixel n’existe.

Pour réutiliser une chaîne, choisissez Sprites → Plage d’images → Tenue et groupez-les (Ctrl+G), puis Enregistrer le kit… garde le groupe comme kit de nœuds sous Mes nœuds ; ou enregistrez tout le pipeline d’asset comme kit (voir Pipelines d’asset).

Les rendus, et le nom de leurs fichiers

Un rendu, c’est un cadrage, un Style et la façon dont chaque clip est découpé. Les nœuds Sprites partagent un même rendu tant qu’ils s’accordent : même Style, cadrés ensemble, et aucun clip découpé de deux façons. Ainsi, une marche à 8 images par seconde et une attaque choisie à la main font un seul rendu et une seule planche. Un second nœud qui découpe la marche en images intelligentes, ou la dessine avec un autre Style, est un rendu à part.

Le premier rendu écrit ses fichiers comme le graphe les nomme. Un autre est écrit à côté sous les mots qui diffèrent du premier : sa caméra, le nom de son Style, puis la découpe de chaque clip qu’il découpe autrement — 8fps (ou 12_5fps), smart6, picked4 (quatre images choisies à la main). D’où out/hero.png, puis out/hero_smart6.png et out/hero_Pixel_Art_2_8fps.png, chacun sur la palette de son Style. pxr names liste les fichiers de chaque rendu, avec les images que conserve une Plage d’images, et refuse deux rendus qui écriraient un même fichier — deux découpes différentes de quatre images choisies à la main dans le même clip — avant tout rendu : would be written twice.

Depuis un script :

pxr graph add game.pixor --which asset --node sprites --set action=attack --set smart=6   # node 4, merged in by node 5
pxr graph add game.pixor --which asset --node frame-range --set from=2 --set to=5 --alone --in frames=4   # node 6
pxr graph add game.pixor --which asset --node hold --set times=2 --alone --in frames=6                    # node 7
pxr graph wire game.pixor --which asset --from 7 --to 5 --slot frames2   # the cut attack into the Merge, in place of node 4
pxr graph set game.pixor --which asset --node frame-range --set to=6
pxr project set game.pixor --add-style portrait
pxr graph add game.pixor --which asset --node sprites --set action=walk --set style=portrait --set fps=8
pxr names game.pixor

La Plage d’images et la Tenue se placent entre le nœud Sprites de l’attaque et le nœud Fusionner : elles ne découpent donc que l’attaque. Ajoutées sans --alone, elles iraient avant Disposer, après Fusionner, et découperaient chaque liste que Fusionner réunit.

pxr render --fps 8, --smart-frames 6 et --keys 0,0.25,0.5 règlent d’un coup la découpe de chaque nœud Sprites. Un plan de projet exécuté avec pxr run game.pixorblueprint --set hold.times=4 atteint le nœud Tenue de chaque pipeline d’asset, --set icons/hold.times=4 seulement celui du pipeline icons.

Le panneau

Une fois un graphe enregistré, la Vue 2D au-dessus montre ce qu’écrit la sortie choisie — ses prises, ses blocs, ses placements, ses piles et ses superpositions — dessiné par le code même qui écrit le fichier ; avant cela, c’est une rangée par action et par côté, que vous pouvez faire glisser pour les réordonner.

Graphe d’asset est un panneau de l’étape Asset, sous la Vue 2D, sur le même canevas que le graphe de scène : des boîtes, des liens, des réglages sur la face de chaque nœud, un plus pour ajouter un nœud dans la chaîne reliée, un moins pour en supprimer un, Cadrer pour tout voir, Nettoyer pour le réorganiser, Note pour y poser une note, Grouper pour faire des nœuds choisis un groupe, et Enregistrer le kit… pour conserver le groupe choisi, ou sans choix le graphe entier, comme kit (Enregistrer le graphe d’asset comme kit) — la barre qu’a chaque graphe, avec les touches qu’a chaque graphe (Travailler dedans). Sa bibliothèque de nœuds, à gauche, liste Entrées et Sorties, les Pipelines du projet et Mes pipelines, puis Entre et vos propres kits sous Mes nœuds. Clic droit sur le canevas › Revenir à une seule planche le ramène à une seule planche avec les fichiers qu’il avait. Icônes écrit des icônes d’inventaire. La ligne en bas indique ce qu’écrit le graphe. Fichiers générés, en premier sur la barre, ouvre le dossier généré dans votre gestionnaire de fichiers.

Chaque nœud de fichier a Ouvrir : il ouvre le fichier de ce nœud dans l’application avec laquelle votre système ouvre ce type de fichier — la planche dans un éditeur d’images, le .aseprite dans Aseprite, la vidéo dans un lecteur, l’archive dans un gestionnaire d’archives (son infobulle indique lequel). Un fichier pas encore généré, ou périmé, est d’abord généré, avec un indicateur de chargement sur Ouvrir pendant ce temps.

Chaque réglage d’un nœud d’asset est une propriété (voir nœuds) : une ligne avec un port à sa gauche, réglée sur le nœud ou reliée à une valeur. Supprimer supprime le nœud choisi, comme le moins ; le dernier nœud qui écrit reste.

Chaque nœud entre les listes et les fichiers montre ce qu’il transmet, disposé sur une planche : un nœud Calque son calque, une Plage d’images ses images, un Retourner son miroir, un Disposer sa planche. Une image montre tout ce que nomment ses nœuds Sprites, quoi qu’affiche l’en-tête de la fenêtre : chaque caméra, action et Style, de chaque rendu dans lequel ils sont dessinés. Des caméras cadrées à part (une autre vue, inclinaison ou taille), un autre Style ou un clip découpé autrement sont des rendus à part, écrits dans des planches à part ; une image alimentée par plusieurs dispose un bloc pour chaque planche, sous le nom du fichier dans lequel il est écrit (hero.png, puis hero_top.png), ses rangées comme celles de cette planche. Les rendus que la Vue 2D ne montre pas sont dessinés en arrière-plan, l’un après l’autre, et conservés jusqu’à ce que le projet change. Un nœud n’empêche jamais l’image d’un autre : chacune est disposée à partir de ce qui l’alimente seul, et un nœud qui ne peut pas l’être — un fichier image pas encore choisi, un Fusionner auquel rien n’est relié — dit pourquoi en rouge à la place de son image, tout comme les nœuds qu’il alimente, tandis que les autres gardent la leur. Les images sont disposées à partir de chaque liste, dessinée en entier : tant qu’une Plage d’images ou une Tenue choisie fait jouer à la Vue 2D sa seule liste, elles gardent les listes dessinées en entier en dernier, et un nœud ajouté entre-temps reçoit son image à partir d’elles. Quand quelque chose à partir de quoi elles sont dessinées change entre-temps — une partie masquée dans l’Arborescence, un matériau, une lampe — elles sont redessinées derrière la Vue 2D, qui continue de jouer la plage. Chaque nœud de fichier montre son fichier avant qu’il ne soit exporté, produit par le même rédacteur que celui d’un export : une image de celui-ci sur le nœud, et le fichier entier dans la Vue 2D quand le nœud est choisi — un PNG ou une carte en image, un GIF, un APNG ou une vidéo en lecture, un JSON, un fichier Godot ou un fichier texte en texte, et un ZIP sous forme de la liste de son contenu. Un nœud qui écrit plusieurs fichiers (un GIF par clip, un calque par fichier) a une liste Fichier au-dessus de la vue.

Fichiers rapides, et Générer

Ce qui est rapide à produire s’affiche à mesure que le graphe change ; ce qui est lent attend le Générer de son nœud (D51). Rapide : tout ce qui se trouve entre les listes et les fichiers, la Planche, et l’image PNG, le JSON, les SpriteFrames Godot, la Palette, le Fichier texte, la Carte d’émission, le Calque d’ombre et les Calques de traits et d’aplats. Lent : GIF, APNG et Vidéo par clip, le Fichier Aseprite, les Cartes de normales et de profondeur, les Variantes de palette, le Kit de lumière, la Cartouche PICO-8, le Rapport, l’Archive ZIP, le Fichier d’animation et les Icônes — ce qui réencode chaque image ou fait un rendu. (Les calques paper doll et de parallaxe sont des rendus à part entière : c’est la fenêtre d’export qui les produit.)

Un nœud lent affiche Générer au lieu de son fichier. Une fois pressé, le fichier est produit en arrière-plan — le bouton devient un indicateur de chargement, et vous continuez à travailler —, puis le nœud affiche son image, la Vue 2D le fichier, et le bouton indique Régénérer. Modifiez quoi que ce soit qui l’alimente, et le nœud garde ce qu’il a produit mais indique Pas à jour au lieu de le refaire : appuyez sur Régénérer, ou sur Ouvrir, qui génère d’abord.

Fichiers générés

Ce que produisent Générer et Ouvrir sont de vrais fichiers, dans un dossier temporaire du projet ouvert (dans le dossier temporaire de votre système, nommé pixor-generated- suivi du projet), un dossier par pipeline d’asset et un par nœud. Fichiers générés dans la barre l’ouvre. Il se nettoie tout seul : supprimer un nœud supprime ses fichiers, supprimer un pipeline d’asset son dossier, et fermer le projet ou quitter Pixor le dossier entier ; un dossier laissé par un plantage est supprimé au prochain démarrage de Pixor. Ce n’est jamais ce qu’écrit un export : la fenêtre d’export écrit chaque fichier à neuf.

Les réglages du nœud choisi sont aussi dans l’Inspecteur — et, si rien n’est choisi, ceux de la Planche du graphe. Sous les réglages d’une Planche, chaque fichier qu’elle peut écrire est une case à cocher : cocher JSON ou Vidéo par clip ajoute ce nœud Fichier, relié à la planche, et le décocher le retire. Un export se règle ainsi en quelques clics sans toucher à un lien, et cela reste un graphe : chaque case est un nœud visible, avec ses propres réglages.

Les nœuds

Nœuds N x N. Calque, Plage d’images, Tenue, Retourner, Tag, Disposer et Placer font la même chose à autant de listes qu’on leur en relie, et rendent chacune sur une sortie à part, en face de son entrée : un seul nœud Calque prend les normales de quatre listes de sprites et transmet quatre listes. Une entrée libre est toujours là pour la suivante. Fusionner fonctionne dans l’autre sens : autant de listes que voulu en entrée, une seule en sortie.

Nœud	Prend	Donne	Ce qu’il fait
Sprites	—	images	Entrée. Des listes de sprites, fixées ici quoi qu’affiche l’en-tête de la fenêtre : avec plusieurs scènes, la scène choisie (ou chacune) ; la caméra choisie (ou chacune) — une caméra est un côté — l’action choisie (Tous sauf Statique, Tous, ou une par son nom, Statique comprise), dessinée avec le Style choisi (le premier du projet pour chacun tant qu’on ne dit pas autre chose), et découpée selon ses Images/s, Images gardées ou Images choisies (voir d’où viennent les listes de sprites). Caméra et action acceptent aussi, depuis pxr graph set, une liste séparée par des virgules (South, East, North) ou le début d’un nom suivi de * pour un anneau (turret*). Un jeu de parties du projet rend à nouveau chaque clip avec ce jeu activé sur chaque image (équipement, états de dégâts). Chaque calque accompagne la liste ; un nœud Calque en choisit un, et sans lui la planche est celle du sprite fini.
Fichier image	—	images	Entrée : une image venue d’ailleurs, comme liste de sprites à part : un PNG — une seule image, ou une bande ou une grille découpée en images de Largeur d’image sur Hauteur d’image, chacune tenue Chaque image — ou un GIF, avec ses images, leurs délais et s’il boucle. Appelé est le nom de sa rangée. L’image prend la palette de la planche (chaque pixel sa couleur la plus proche ; ce qui est plus qu’à moitié transparent est vide) et est centrée dans une case ; une image plus grande qu’une case est refusée, avec les deux tailles. Elle va sur les planches auxquelles son nœud est relié et sur aucune autre.
Fusionner	images, …	images	Toutes les listes reliées, réunies en une : plusieurs listes de sprites sur une planche.
Calque	images × N	images × N	Un calque de chaque liste : final, lines ou flat, ou l’une des cartes avec lesquelles un jeu éclaire le sprite — normal, depth, emission —, ce qui fait de la planche où il arrive une image en couleurs plutôt qu’en indices de palette — ou shadow, l’ombre que projette chaque image, en noir (celle que demande le réglage Ombre du projet, sinon une ombre de contact), qu’une Superposition place sous le sprite ; ou le nom de l’une des sorties supplémentaires du graphe de Style, dont les rangées sont alors nommées d’après elle (idle_South_rim). Les images propres d’un rendu sont aussi des calques : avec des accessoires ou des pièces, la base d’un paper doll et chaque pièce par son nom (idle_South_helmet) ; avec des calques de parallaxe, de layer0 (le plus lointain) au dernier. Chacun n’est rendu que lorsqu’un Calque le nomme, par pxr render — ce que lance la fenêtre Exporter de l’application. Séparez les calques d’une liste avec un nœud Calque par calque, chacun vers sa propre Planche ; combinez-les avec un Fusionner, une Pile ou une Superposition.
Plage d’images	images × N	images × N	Les images de from à to de chaque liste, comptées à partir de 0 : from=3 to=3 pour une image fixe ou une icône (une nouvelle est from=0 to=0, la première image), from=2 to=5 pour quelques-unes. Répartissez une liste sur plusieurs planches avec une Plage d’images par partie.
Tenue	images × N	images × N	Chaque image de chaque liste tenue fois plus longtemps.
Retourner	images × N	images × N	Chaque liste mise en miroir de gauche à droite, à la place d’une autre caméra : un nœud Sprites de l’Est retourné en Ouest donne walk_West, dessiné à partir de walk_East — pixels, normales, hitboxes et root motion mis en miroir. Un modèle symétrique n’a pas besoin de rendre son autre côté.
Tag	images × N	images × N	Si les rangées bouclent (Garder, Oui ou Non), et un pivot à elles (x,y en pixels de case) pour un clip qui se tient autrement. Un clip qui ne boucle pas est un tag joué une seule fois dans le JSON et le .aseprite ; le pivot figure sur chaque image du JSON et comme clé de la slice de pivot.
Disposer	images × N	planche × N	Chaque liste sur une planche : grille ou bande, marge, extrusion, puissance de deux, rognage, images répétées stockées une seule fois, une largeur maximale au-delà de laquelle les rangées passent à la ligne, une hauteur maximale au-delà de laquelle la planche est découpée en pages (des clips entiers par page, chacune avec ses propres fichiers), et images par rangée, qui enchaîne chaque clip après le précédent comme une planche contact.
Placer	planche × N	planche × N	Chaque planche déplacée à un endroit de l’image.
Pile	planche, planche	planche	Deux planches réunies en une, la seconde sous la première ou à côté, avec un espace.
Superposition	bas, haut	planche	Une planche posée exactement sur une autre, comme le moteur empile les calques : les pixels vides du dessus laissent voir le dessous. Chaque calque peut être désactivé pour voir l’autre seul. Les deux doivent correspondre image pour image — les mêmes images aux mêmes endroits — sinon l’export indique quelle image ne correspond pas.
Planche	planche	fichier	Une planche de sprites en mémoire. Il n’écrit rien : ses fichiers sont des nœuds Fichier reliés à partir de lui. Appelé est son nom.
Fichier	planche	fichier	Sortie : un fichier sur le disque, écrit à partir de la Planche dont il est relié, avec ses propres réglages sur sa face, Ouvrir pour ouvrir son fichier, et Générer quand il est long à produire. Image PNG (la planche elle-même, et le nom de ses fichiers : Fichiers vers, le chemin où le PNG est écrit, dont les autres reprennent le nom, sous le dossier donné à la fenêtre Exporter ; Noms de fichiers, le modèle selon lequel ses images sont nommées, avec le premier nom qu’il produit affiché dessous ; Recette dans les fichiers, si les fichiers indiquent comment ils ont été faits ; Ses propres fichiers donne à la planche un chemin, des noms et une recette à elle, et désactivé, ses fichiers vont là où le projet exporte — l’Inspecteur les montre aussi avec la Planche), JSON, Fichier Aseprite, SpriteFrames Godot, Carte de normales, Carte de profondeur, Carte d’émission, Calques de traits et d’aplats, Palette, Kit de lumière, Cartouche PICO-8, Rapport ; Un GIF par clip et APNG par clip (Échelle) ; Vidéo par clip (Échelle, Images par seconde, Arrière-plan) ; Calque d’ombre (contact ou portée) ; Variantes de palette (leur liste) ; Calques paper doll (Pièces) ; Calques de parallaxe (Calques, Brumer les calques lointains). Supprimer une Planche supprime ses nœuds Fichier.
Fichier texte	planche	fichier	Sortie : un fichier texte issu d’un modèle appliqué aux images (ci-dessous).
Fichier d’animation	images	fichier	Sortie : une animation de chaque liste de sprites reliée, sans planche entre les deux : un GIF, un APNG ou une vidéo non compressée (Chaque liste en), Échelle fois plus grande, une vidéo à Images par seconde sur Arrière-plan. Vers commence le nom de chaque fichier : out/spin écrit out/spin_walk_South.gif.
Icônes	—	fichier	Sortie : des icônes d’inventaire du modèle, vues sous l’angle ¾ sous la lumière de studio, cernées de la couleur de la Rareté (ou D’après le nom du fichier), Cadré ou non, à chacune des Tailles : par taille, un PNG par icône, un atlas et un index JSON, dans le dossier Vers. Une icône est un rendu à part entière, elle ne prend donc rien en entrée ; pxr les crée après les planches, dans le dossier de l’export. Voir les icônes d’inventaire.
Archive ZIP	fichier, …	fichier	Sortie : un ZIP des fichiers des nœuds de fichier qui y sont reliés (Vers indique où il va) — une Planche reliée, c’est tout ce que cette planche écrit — ou, sans rien de relié, de tous les fichiers écrits par l’export. Les calques paper doll et de parallaxe y vont avec le reste. Les mêmes fichiers donnent la même archive, octet pour octet. C’est ce qu’on remet à quelqu’un d’autre ou qu’on envoie sur une boutique.

Un plan, pas un rendu. Le graphe décide quelles images vont où avant qu’un seul pixel n’existe, si bien que l’étape Asset fonctionne avec l’étape Style vide, et pxr names affiche chaque nom et chaque identifiant que le graphe écrira, sans rendre.

Les images gardent leur identité. Réorganiser une planche déplace des rectangles et ne touche pas à l’identifiant de chaque image (voir Comment s’appellent les images, et ce qu’elles sont).

Pipelines d’asset

Un projet peut avoir autant de pipelines d’asset qu’il le souhaite, chacun étant un graphe d’asset à part sous son nom — la planche du personnage, un jeu d’icônes, les visuels d’une page de boutique — et la fenêtre Exporter écrit celui que vous choisissez (pxr render --pipeline all les écrit tous). La liste Assets à gauche de l’étape Asset et le sélecteur Asset de l’en-tête choisissent celui qui est sur le canevas. Nouveau pipeline d’asset sous la liste crée une copie de celui affiché, nommée d’après lui (Main 2), et le menu du clic droit d’une ligne permet de le renommer, de le Dupliquer, de le supprimer (Supprimer NAME…, qui demande d’abord confirmation : le premier aussi, tant qu’il en reste un autre), et :

• Enregistrer le kit… (Enregistrer le pipeline d’asset comme kit) écrit le pipeline sous forme de kit. Enregistré dans la bibliothèque des pipelines (où s’ouvre la boîte de dialogue), il est listé dans la bibliothèque de nœuds de chaque projet sous Mes pipelines.
• Utiliser un kit… (Utiliser un kit de pipeline d’asset), ou un clic sur l’un d’eux sous Mes pipelines, fait d’un pipeline enregistré depuis un autre projet un pipeline de ce projet. Ses noms — celui du pipeline, de ses planches, de ses fichiers — sont remplacés par des noms qu’aucun élément d’ici ne porte.

pxr project set game.pixor --add-pipeline icons
pxr graph set game.pixor --which asset --pipeline icons --node arrange --set layout=strip
pxr graph save game.pixor --which asset --pipeline icons --as-pipeline -o icons.pixorkit
pxr project set other.pixor --use-pipeline icons.pixorkit
pxr project set other.pixor --remove-pipeline icons

Des images venues d’ailleurs

Un nœud Fichier image place sur une planche Pixor ce qui a été dessiné ailleurs : un logo sur une planche de titre, un effet peint à la main, des images d’un autre outil. Ajoutez-le, Choisir… un PNG ou un GIF, et il rejoint les listes de sprites via un Fusionner ; reliez-le à une planche à lui pour le garder à part.

pxr graph add game.pixor --which asset --node image-file --set name=logo --set file=art/logo.png
pxr graph add game.pixor --which asset --node image-file --set name=spark --set file=art/spark.gif
pxr graph list game.pixor --which asset                                             # every node, numbered
pxr graph set game.pixor --which asset --node logo --set cell_w=16 --set cell_h=16   # a strip of 16 px frames
pxr graph set game.pixor --which asset --node logo --set own_colours=true            # keep its colours

--node prend le numéro d’un nœud donné par pxr graph list, son nom (logo) ou son type (frame-range) quand le graphe n’a qu’un nœud de ce type.

Une image prend la palette de la planche : chaque pixel prend la plus proche de ses couleurs. Cochez Ses propres couleurs et elle garde plutôt les siennes : elles sont ajoutées à la fin de la palette de la planche (les plus utilisées d’abord, autant que la palette a de place), si bien que chaque fichier de la planche — le PNG, le .aseprite, les GIF, les fichiers de palette — les contient, et qu’une variante de palette les laisse telles quelles. Les images propres à la planche ne changent pas.

Une image plus grande que la cellule agrandit les cellules de chaque fichier où elle figure : les autres images sont centrées dans les cellules agrandies, et leur pivot, leurs hitboxes et leurs points d’attache se déplacent avec elles.

Plusieurs fichiers à partir d’un seul rendu

Un graphe peut avoir plusieurs nœuds Planche, chacun avec un PNG relié depuis lui : un seul rendu écrit alors une planche de personnage, un jeu d’icônes et une image promotionnelle. Une Planche sans PNG n’écrit aucune image — seulement les fichiers qui en sont reliés, c’est ainsi qu’on écrit le JSON d’une planche seul. Une seconde Planche prend ce que prend la première tant qu’elle n’est pas reliée à ses propres listes. Chacune a son propre chemin, son modèle de nom et sa recette, ou reprend ceux du projet ; les fichiers à côté d’elle — et leur ombre, leurs variantes et leurs échelles — sont ses nœuds Fichier. Quand deux reprennent ceux du projet, la première écrit la planche du projet et la suivante écrit à côté sous son propre nom (out/hero_icons.png pour une planche appelée icons), si bien que rien n’est écrit deux fois ; deux planches qui nomment un même chemin à elles sont refusées, avec les deux noms. Une Planche ajoutée depuis un script reçoit un nom qu’aucune autre sortie ne porte (sheet 2), comme dans l’application, et pxr names liste les fichiers sous les noms que leur donne le rendu.

Les caméras ayant la même vue, la même inclinaison, la même taille et le même look sont cadrées ensemble et écrivent une seule planche, une rangée pour chacune : les côtés d’un anneau s’alignent. Une caméra réglée autrement écrit ses propres planches, et un nœud Sprites prend les rangées du groupe en cours d’écriture. Un nœud Sprites qui nomme des caméras de deux groupes — South, top — les rassemble plutôt dans un seul fichier, écrit une fois que chaque caméra a rendu, à côté de la planche du projet sous le nom de son nœud Planche (out/hero_both.png) ; les rangées sont nommées d’après leur caméra (walk_South, walk_top). Une planche a une seule taille d’image et une seule palette, si bien que des caméras qui cadrent à des tailles différentes sont refusées plutôt que tassées ensemble : donnez-leur la même taille.

Une grille d’icônes, ce sont trois nœuds : un nœud Sprites de l’action idle depuis la caméra South, un Disposer en bande, et une Planche dont le PNG va dans out/icons.png. Une planche-contact, c’est la même chose avec une marge. Ce ne sont pas des fonctionnalités ; ce sont des graphes.

Depuis un script :

pxr graph add game.pixor --which asset --node sprites --set action=idle --set camera=South --alone   # node 11
pxr graph add game.pixor --which asset --node arrange --set layout=strip --alone --in frames=11      # node 12
pxr graph add game.pixor --which asset --node sheet --set name=icons --set path=out/icons.png --set formats=png --alone --in sheet=12
pxr graph set game.pixor --which asset --node icons --set formats=json,godot   # its File nodes
pxr graph wire game.pixor --which asset --from 10 --to 12 --slot frames2       # the spark into the Arrange's spare input
pxr graph add game.pixor --which asset --node sheet --set name=sparks --set path=out/sparks.png --set formats=png --alone --in sheet=12.1   # output 1 of an N x N node
pxr graph list game.pixor --which asset          # every node, and every output's path
pxr graph drop game.pixor --which asset --node logo   # the logo's Image file node
pxr render game.pixor                            # out/game.png, out/icons.png (.json, .tres), out/sparks.png

La marche dessinée dans le Style portrait est cadrée à part : elle écrit donc ses propres planches à côté de celles-ci : out/game_portrait_8fps.png, et l’étincelle, qui n’a pas de Style à elle, à nouveau dans out/sparks_South_portrait_8fps.png.

Les numéros sont ceux que donne la démonstration de cette page ; pxr graph list affiche ceux d’un projet. --alone garde la grille d’icônes hors de la chaîne de la planche principale : une liste idle fusionnée en plus serait les mêmes images en double, ce que refuse le modèle de nom.

pxr graph add insère un nœud dans la chaîne, relié : une Plage d’images ou une Tenue avant le Disposer, un nœud de planche après lui, et un second nœud Sprites à côté du premier via un Fusionner. --set sur une Planche accepte path, names et recipe ; formats ajoute et retire ses nœuds Fichier — le PNG toujours parmi eux, comme dans la liste propre à un export ; supprimez son nœud pour n’en écrire aucun —, et les mots des réglages que portent ses nœuds Fichier créent et règlent ces nœuds : shadow=drop, variants=hit-flash,hue:120, anim_scale=4, paper_doll=yes, pieces=helmet:Helmet,Visor, parallax=3, haze=none. Les réglages propres à un nœud Fichier se règlent sur lui par son numéro : --node 5 --set fps=60.

Des traits à côté des couleurs

Une planche peut porter plus d’un calque des mêmes listes. Reliez le nœud Sprites deux fois — une fois directement, une fois via un Calque de lines — et soit réunissez-les avec Fusionner avant un seul Disposer, soit disposez chacun et placez les deux planches côte à côte avec Pile. Le JSON nomme les lignes de traits walk_South_lines, et leurs identifiants diffèrent de ceux des images en couleur par leur calque, qui est bien ce qu’elles sont. Un modèle qui ne mentionne pas {layer} l’ajoute quand même aux noms de ces images (hero_walk_South_00_lines.png), si bien que deux images ne tombent jamais sur un même nom ; les images propres au sprite gardent les leurs. Un nœud Sprites d’un jeu de parties fait de même avec {set} (hero_attack_South_00_bare.png), et le jeu fait partie des identifiants de ces images. Ou superposez exactement les deux avec une Superposition, comme le moteur les dessinera.

Fichiers texte à partir d’un modèle

Un moteur dont Pixor n’a jamais entendu parler a besoin d’un descripteur, c’est-à-dire d’un fichier texte construit sur les mêmes métadonnées d’images que celles du JSON. Un nœud Fichier texte en écrit un à partir d’un modèle :

{sheet} {width}x{height}
{#frames}{name} {x} {y} {w} {h} {duration}{sep}
{/frames}

{#frames} ... {/frames} écrit son contenu une fois par image. En dehors, les mots sont ceux de la planche : {project}, {object}, {sheet} (le nom du fichier de l’image), {width}, {height}, {cell_w}, {cell_h}, {pivot_x}, {pivot_y}, {frames}. À l’intérieur, ceux d’une image : {name}, {id}, {action}, {side}, {row}, {index}, {n} (le numéro de l’image sur la planche), {layer}, {x}, {y}, {w}, {h}, {source_x}, {source_y}, {duration} (millisecondes), {pivot_x} et {pivot_y} (ceux du clip, quand un Tag lui en a donné), {loop} (true ou false), {root_x}, {root_y}, {root_dx} et {root_dy} (le root motion, tel que le JSON le donne), {boxes} et {sockets} (en JSON), et {sep}, qui est une virgule sauf après la dernière image — de quoi faire une liste JSON. {index:3} complète un nombre avec des zéros ; {{ et }} écrivent une accolade.

Un modèle de texte peut aussi vivre dans son propre fichier à côté du projet : donnez au nœud un Fichier modèle (--set file=frames.tpl depuis un script), et il est lu à chaque écriture de la sortie, si bien qu’un studio modifie son descripteur là où il garde ses autres fichiers.

Il n’y a ni conditions, ni arithmétique, ni inclusions. C’est une façon d’écrire un nom de fichier, pas un langage. Un mot que Pixor ne connaît pas est refusé quand le modèle est tapé, et n’est pas écrit dans un fichier.

Une disposition utilisée comme un seul groupe

Une grille d’icônes, une planche-contact, la façon propre à un studio de disposer un personnage : Enregistrer le kit… dans la barre, sans groupe choisi, enregistre le graphe d’asset sous forme de kit (Enregistrer le graphe d’asset comme kit) : sa disposition et ce qui alimente sa Planche, en un seul groupe qui prend des listes de sprites en entrée (chaque nœud Sprites devient une entrée) et donne la planche en sortie. La Planche et les fichiers qui en dépendent restent au projet. + › Utiliser un kit… (Ajouter un kit comme groupe) le place dans le graphe d’asset d’un autre projet sous forme d’un seul groupe, à relier à une Planche ou à mettre à la place d’un Disposer. Double-cliquez dessus, ou appuyez sur la flèche de son titre, pour l’ouvrir sur place ; la flèche le replie. Depuis un script :

pxr graph save hero.pixor --which asset -o icon-grid.pixorkit --name "Icon grid"
pxr graph add villain.pixor --which asset --kit icon-grid.pixorkit --alone --in 0=0   # fed by node 0
pxr graph swap villain.pixor --which asset --node arrange --kit icon-grid.pixorkit

Ce qu’il ne fera pas

• Les formats binaires restent du code. PNG, .aseprite, GIF, APNG, SpriteFrames de Godot, les kits de lumière et .p8 sont des nœuds Planche et Fichier ; un modèle écrit du texte.
• Ni binaires de plugin ni nœuds de script, ici comme dans les autres graphes.