El grafo de Asset

En el grafo de Asset se diseña una exportación; en la ventana de exportación se ejecuta. El paso Asset convierte las listas de sprites en archivos, y lo hace mediante un grafo: las listas de sprites entran, se organizan en una hoja y salen como archivos. Son los tres tipos de conexión, y no se pueden confundir: una lista no se puede conectar a una Hoja sin organizarla primero, y una hoja no se puede etiquetar.

Sus entradas son nodos Sprites (y nodos Archivo de imagen, para imágenes de fuera), y cada uno trae listas de sprites: una acción vista por una cámara, dibujada con un Estilo, con un conjunto de partes, cortada en fotogramas, con cada capa. Un nodo Sprites los nombra todos, fijos: las opciones de la cabecera de la ventana no son suyas, así que lo que escribe un asset nunca depende de lo que se esté mostrando. Sus salidas son un nodo por archivo. Un nodo Hoja es una hoja de sprites en memoria: muestra la hoja en su cara y no escribe nada. Cada archivo es un nodo Archivo conectado desde ella: Imagen PNG para la propia hoja, luego su JSON, su .aseprite, sus SpriteFrames de Godot, su mapa de normales. Para exportar una hoja de sprites, conecta Hoja → PNG. Un grafo puede tener tantos de cada uno como archivos tenga que escribir el proyecto.

Todo lo que se le puede indicar a una exportación está en un nodo, salvo a qué carpeta va: eso es cosa de la ventana Exportar, que lista cada archivo que el grafo escribirá allí, por nombre y tipo, antes de pulsar Exportar: la forma más rápida de ver qué le hace a los archivos un cambio en el grafo. Cómo se llaman los fotogramas de una hoja está en su nodo de imagen PNG (y en el Inspector con su Hoja), su disposición en el Organizar que la alimenta, y cada otro archivo que escribe (con los ajustes propios de ese archivo: la escala de un GIF, la frecuencia de un vídeo, qué sombra, qué variantes de paleta) es un nodo Archivo conectado desde ella. Un proyecto que nunca vuelve a conectar el grafo no guarda ninguno: es una hoja con cada lista de sprites.

Una imagen puede mostrar cualquier capa. Bajo la imagen de una Hoja, aquí, Capa elige la capa que dibuja (mientras no se le indique, la que dibuja la propia Capa de la Vista 2D): el sprite, sus líneas, sus colores planos, sus normales, la profundidad, la emisión, una salida extra de un Estilo, o Todas las capas a la vez: las de un fotograma una al lado de otra, las de una lista una fila cada una.

Ese es el grafo con el que empiezas, el pipeline de asset Principal:

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

Las opciones de la cabecera de la ventana

Acción, Estilo y Asset son pipelines independientes, cada uno un grafo propio. El extremo derecho de la fila de pestañas de los espacios de trabajo tiene cuatro selectores (Cámara, Acción, Estilo, Asset) después de Reproducir/Pausa: una elección de cada uno, en todos los pasos.

Paso	Dibuja
Acción	la acción elegida, vista por la cámara elegida
Estilo	la acción elegida, vista por la cámara elegida y dibujada por el Estilo elegido
Asset	lo que nombran los nodos Sprites de su propio grafo, no las opciones de la cabecera

La lista Estilos (paso Estilo) y la lista Assets (paso Asset) son las mismas opciones que los selectores Estilo y Asset de la cabecera: un clic en cualquiera muestra lo mismo. La ventana Exportar empieza con el pipeline de asset elegido en el selector Asset de la cabecera, y escribe solo ese; sus archivos se nombran como cuando se escriben todos los pipelines de asset (pxr render --pipeline all los escribe todos).

De dónde vienen las listas de sprites

Las listas de sprites se hacen aquí, con los nodos Sprites, y solo aquí: las acciones que van en las hojas son las que toman los nodos Sprites, nada más. Un nodo Sprites nombra una cámara, una acción, un Estilo y un conjunto de partes, y contiene el corte: cómo el movimiento de la acción se convierte en fotogramas.

Su Acción es una de estas:

• Todas excepto Estático (every-one-except-static, lo que toman un nodo Sprites nuevo, el pipeline de Asset con el que empieza un proyecto y un proyecto nuevo): cada acción de la lista de Acciones salvo Estático, la pose de reposo quieta; aunque sí Estático cuando el proyecto no tiene ninguna otra acción (un modelo estático), para que una caja siga teniendo su sprite.
• Todos (vacío, o *): cada acción, Estático incluida.
• Una acción por nombre, Estático entre ellas: solo esa acción, o varias (walk, attack desde pxr graph set). Un clip del modelo se dibuja cuando un nodo Sprites lo nombra, sea o no una de las acciones del proyecto: si se nombra, sus fotogramas siempre están ahí, en la imagen del nodo, en lo que alimenta y en la exportación.

Un nombre que no corresponde a nada (una acción eliminada o renombrada en otro sitio) se indica en el nodo, con palabras claras: No hay fotogramas de Sway vistos por South: elige en el nodo Sprites una acción y una cámara que tenga el proyecto.

El corte está en su cara y en el Inspector:

• Fotogramas/s (fps): un fotograma cada tantos segundos, 12 por segundo mientras no se indique otra cosa.
• Fotogramas conservados (smart): tantos fotogramas inteligentes, elegidos como lo haría un animador: las poses donde el movimiento cambia de sentido, más donde es rápido, cada una mantenida hasta la siguiente. 0 es desactivado. Fotogramas inteligentes en su cara los activa, Usar fotogramas/s vuelve a un paso regular.
• Fotogramas elegidos (picked): tiempos en segundos, elegidos a mano. Con el nodo Sprites elegido, la línea de tiempo detrás del grafo de Asset muestra sus fotogramas: haz clic en la franja de claves para añadir o quitar uno, o arrastra una clave por ella (un paso de deshacer cada vez). La cara dice N fotogramas elegidos en la línea de tiempo.

Los fotogramas elegidos mandan cuando los hay, luego los fotogramas conservados, luego los fotogramas por segundo. Un nodo Sprites añadido a un grafo empieza cortado como el primero del grafo. Una acción hecha de nodos o de claves se corta en sus propios fotogramas. Duración (ms), junto al contador de fotogramas de la Línea de tiempo, fija la duración del fotograma mostrado (consulta mantener un fotograma más tiempo): la de la acción, así que cada nodo Sprites que toma el clip la conserva. Nada de esto cambia el paso Acción: reproduce todo el movimiento, y un fotograma de sprite cae en el tiempo en que se cortó.

Entre el nodo Sprites y el Organizar van los nodos que recortan una lista:

Nodo	Qué hace
Rango de fotogramas	Solo los fotogramas de from a to de lo que entra, contando desde 0: la preparación de un ataque como lista propia, un fotograma de un reposo como icono, una lista repartida en dos hojas. Un rango conserva lo que mostraba cada fotograma: su tiempo en el clip, su conjunto de partes, su desplazamiento de la raíz. Un rango de un rango cuenta sobre lo que entró; una parte de un bucle ya no está en bucle; un rango más allá del final conserva el último fotograma.
Mantener	Cada fotograma se mantiene tantas veces más tiempo: 2 reproduce la lista a media velocidad.

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

Elegir un nodo Sprites, Rango de fotogramas o Mantener hace que la Vista 2D reproduzca la lista que da, cortada, troceada y en capas tal como se escribirá. Ninguno de los dos cuesta un render: deciden qué fotogramas van dónde antes de que exista un píxel.

Para volver a usar una cadena, elige Sprites → Rango de fotogramas → Mantener y agrúpalos (Ctrl+G); después, Guardar kit… guarda el grupo como kit de nodos en Mis nodos; o guarda todo el pipeline de Asset como kit (consulta Pipelines de asset).

Los renders y cómo se llaman sus archivos

Un render es un encuadre, un Estilo y cómo se corta cada clip. Los nodos Sprites comparten un render mientras coinciden: el mismo Estilo, encuadrados juntos, y ningún clip cortado de dos maneras. Así, un ciclo de caminar a 8 fotogramas por segundo y un ataque elegido a mano son un render y una hoja. Un segundo nodo que corta el ciclo de caminar en fotogramas inteligentes, o lo dibuja con otro Estilo, es un render aparte.

El primer render escribe sus archivos tal como los nombra el grafo. Otro se escribe junto a ellos con las palabras que lo distinguen del primero: su cámara, el nombre de su Estilo y luego el corte de cada clip que corte de otra manera: 8fps (o 12_5fps), smart6, picked4 (cuatro fotogramas elegidos a mano). Así, out/hero.png, luego out/hero_smart6.png y out/hero_Pixel_Art_2_8fps.png, cada uno con la paleta de su Estilo. pxr names lista los archivos de cada render, con los fotogramas que conserva un Rango de fotogramas, y rechaza dos renders que escribirían un mismo archivo (dos cortes distintos de cuatro fotogramas elegidos a mano del mismo clip) antes de renderizar nada: would be written twice.

Desde 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

El Rango de fotogramas y el Mantener van entre el nodo Sprites del ataque y el Fusionar, así que solo cortan el ataque. Añadidos sin --alone, irían antes del Organizar, después del Fusionar, y cortarían todas las listas que une el Fusionar.

pxr render --fps 8, --smart-frames 6 y --keys 0,0.25,0.5 fijan a la vez el corte de todos los nodos Sprites. Una plantilla de proyecto ejecutada con pxr run game.pixorblueprint --set hold.times=4 llega al nodo Mantener de cada pipeline de Asset; --set icons/hold.times=4, solo al del pipeline icons.

El panel

Una vez guardado un grafo, la Vista 2D de encima muestra lo que escribe la salida elegida (sus tomas, bloques, posiciones, pilas y superposiciones), dibujado por el mismo código que escribe el archivo; antes de eso, es una fila por acción y lado, que puedes arrastrar para reordenar.

Grafo de Asset es un panel del paso Asset, bajo la Vista 2D, en el mismo lienzo que el grafo de Escena: cajas, conexiones, ajustes en la cara de cada nodo, un más para añadir un nodo a la cadena conectada, un menos para eliminar uno, Fotograma para verlo todo, Limpiar para volver a disponerlo, Nota para ponerle una nota, Agrupar para convertir los nodos elegidos en un grupo y Guardar kit… para guardar el grupo elegido, o sin ninguno elegido el grafo entero, como kit (Guardar el grafo de Asset como kit): la barra que tiene todo grafo, con las teclas que tiene todo grafo (Trabajar en él). Su biblioteca de nodos a la izquierda lista Entradas y Salidas, los Pipelines del proyecto y Mis pipelines, luego Entre y tus propios kits bajo Mis nodos. Clic derecho en el lienzo › Volver a una hoja lo devuelve a una sola hoja con los archivos que tenía. Iconos escribe iconos de inventario. La línea de la parte inferior dice qué escribe el grafo. Archivos generados, el primero de la barra, abre la carpeta generada en tu gestor de archivos.

Cada nodo de archivo tiene Abrir: abre el archivo de ese nodo en la aplicación con la que tu sistema abre ese tipo de archivo (la hoja en un editor de imágenes, el .aseprite en Aseprite, el vídeo en un reproductor, el archivo comprimido en un gestor de archivos comprimidos; su descripción emergente indica cuál). Un archivo que aún no se ha generado, o que está desactualizado, se genera primero, con un indicador de carga en Abrir mientras tanto.

Cada ajuste de un nodo de asset es una propiedad (consulta Nodos): una fila con un puerto a su izquierda, que se fija en el nodo o se conecta desde un valor. Eliminar elimina el nodo elegido, igual que el menos; el último nodo que escribe se queda.

Cada nodo entre las listas y los archivos muestra lo que pasa, dispuesto en una hoja: un nodo Capa su capa, un Rango de fotogramas sus fotogramas, un Voltear su reflejo, un Organizar su hoja. Una imagen muestra todo lo que nombran sus nodos Sprites, sea lo que sea lo que muestre la cabecera de la ventana: cada cámara, acción y Estilo, de cada render en el que se dibujan. Las cámaras encuadradas por separado (otra vista, inclinación o tamaño), otro Estilo o un clip cortado de otra forma son renders propios, escritos en hojas propias; una imagen alimentada por varias dispone un bloque por cada hoja, bajo el nombre del archivo en el que se escribe (hero.png, luego hero_top.png), con sus filas como las de esa hoja. Los renders que la Vista 2D no muestra se dibujan detrás, uno tras otro, y se conservan hasta que cambia el proyecto. Un nodo nunca detiene la imagen de otro: cada uno se dispone solo a partir de lo que lo alimenta, y un nodo que no puede (un archivo de imagen aún sin elegir, un Fusionar sin nada conectado) dice por qué en rojo donde estaría su imagen, y lo mismo hacen los nodos a los que alimenta, mientras los demás conservan las suyas. Las imágenes se disponen a partir de cada lista, dibujada entera: mientras un Rango de fotogramas o un Mantener elegido hace que la Vista 2D reproduzca su única lista, conservan las listas dibujadas enteras por última vez, y un nodo añadido entretanto toma su imagen de ellas. Cuando algo a partir de lo que se dibujan cambia entretanto (una parte oculta en el Esquema, un material, una lámpara), se vuelven a dibujar detrás de la Vista 2D, que sigue reproduciendo el rango. Cada nodo de archivo muestra su archivo antes de exportarlo, creado por el mismo escritor que usa una exportación: una imagen de él en el nodo, y todo él en la Vista 2D cuando se elige el nodo: un PNG o un mapa como imagen, un GIF, un APNG o un vídeo reproduciéndose, un JSON, un archivo de Godot o un archivo de texto como texto, y un ZIP como la lista de lo que contiene. Un nodo que escribe varios archivos (un GIF por clip, una capa por archivo) tiene una lista Archivo encima de la vista.

Archivos rápidos, y Generar

Lo que es rápido de generar se muestra a medida que cambia el grafo; lo lento espera al Generar de su nodo (D51). Rápido: todo lo que hay entre las listas y los archivos, la Hoja, y la imagen PNG, JSON, SpriteFrames de Godot, Paleta, Archivo de texto, Mapa de emisión, Capa de sombra y Capas de líneas y planas. Lento: GIF, APNG y Vídeo por clip, el Archivo de Aseprite, los mapas de normales y de profundidad, Variantes de paleta, Kit de luz, Cartucho de PICO-8, Informe, Archivo ZIP, Archivo de animación e Iconos: lo que vuelve a codificar cada fotograma, o renderiza. (Las capas de paper doll y de parallax son renders propios: las genera la ventana de exportación.)

Un nodo lento muestra Generar en lugar de su archivo. Al pulsarlo, el archivo se genera aparte —el botón se convierte en un indicador de carga y tú sigues trabajando—; después el nodo muestra su imagen, la Vista 2D el archivo, y el botón dice Regenerar. Cambia cualquier cosa que lo alimente y el nodo conserva lo que generó, pero indica Desactualizado en lugar de volver a generarlo: pulsa Regenerar, o Abrir, que genera primero.

Archivos generados

Lo que hacen Generar y Abrir son archivos reales, en una carpeta temporal del proyecto abierto (dentro de la carpeta temporal de tu sistema, con el nombre pixor-generated- y el del proyecto), una carpeta por pipeline de asset y otra por nodo. Archivos generados, en la barra, la abre. Se limpia sola: borrar un nodo borra sus archivos, borrar un pipeline de asset su carpeta, y cerrar el proyecto o salir de Pixor la carpeta entera; una carpeta que haya dejado un fallo se elimina la próxima vez que se inicia Pixor. Nunca son lo que escribe una exportación: la ventana Exportar escribe cada archivo desde cero.

Los ajustes del nodo elegido también están en el Inspector y, sin nada elegido, los de la propia Hoja del grafo. Ahí, bajo los ajustes de una Hoja, cada archivo que puede escribir es un interruptor: marcar JSON o Vídeo por clip añade ese nodo Archivo, conectado desde la hoja, y desmarcarlo lo quita. Así una exportación se configura en unos pocos clics sin tocar una conexión, y sigue siendo un grafo: cada interruptor es un nodo que puedes ver, con sus propios ajustes.

Los nodos

Nodos N x N. Capa, Rango de fotogramas, Mantener, Voltear, Etiqueta, Organizar y Colocar hacen lo mismo con tantas listas como tengan conectadas, y devuelven cada una en una salida propia, frente a su entrada: un nodo Capa toma las normales de cuatro listas de sprites y pasa cuatro listas. Siempre hay una entrada libre para la siguiente. Fusionar es al revés: cualquier número de listas de entrada, una de salida.

Nodo	Recibe	Da	Qué hace
Sprites	—	fotogramas	Entrada. Listas de sprites, fijadas aquí sea cual sea lo que muestre la cabecera de la ventana: con varias escenas, la escena elegida (o todas); la cámara elegida (o todas), donde una cámara es un lado; la acción elegida (Todas excepto Estático, Todos, o una por nombre, Estático incluida), dibujada con el Estilo elegido (el primero del proyecto de cada uno mientras no se indique otro), y cortada según digan sus Fotogramas/s, Fotogramas conservados o Fotogramas elegidos (consulta de dónde vienen las listas de sprites). Cámara y acción también aceptan, desde pxr graph set, una lista separada por comas (South, East, North) o el principio de un nombre y * para un anillo (turret*). Un conjunto de partes del proyecto vuelve a renderizar cada clip con ese conjunto activado en todos los fotogramas (equipo, estados de daño). Cada capa viene con la lista; un nodo Capa elige una, y sin él la hoja es del sprite terminado.
Archivo de imagen	—	fotogramas	Entrada: una imagen externa, como lista de sprites propia: un PNG (un fotograma, o una tira o cuadrícula cortada en fotogramas de Ancho del fotograma por Alto del fotograma, cada uno mantenido Cada fotograma) o un GIF, con sus fotogramas, sus retardos y si se repite en bucle. Llamado es el nombre de su fila. La imagen toma la paleta de la hoja (cada píxel su color más cercano; lo que es más de medio transparente queda vacío) y se centra en una celda; un fotograma más grande que una celda se rechaza, indicando ambos tamaños. Va en las hojas a las que está conectado su nodo y en ninguna otra.
Fusionar	fotogramas, …	fotogramas	Todas las listas conectadas, como una sola: muchas listas de sprites en una hoja.
Capa	fotogramas × N	fotogramas × N	Una capa de cada lista: final, lines o flat, o uno de los mapas con los que un juego ilumina el sprite (normal, depth, emission), lo que convierte la hoja en la que acaba en una imagen de colores en lugar de índices de paleta; o shadow, la sombra que proyecta cada fotograma, en negro (la que pide la Sombra del proyecto, o si no una sombra de contacto), que una Superposición pone bajo el sprite; o el nombre de una de las salidas extra del grafo de Estilo, cuyas filas llevan entonces su nombre (idle_South_rim). Las propias imágenes de un render también son capas: con accesorios o piezas, la base de un paper doll y cada pieza por su nombre (idle_South_helmet); con capas de parallax, de layer0 (la más lejana) a la última. Cada una se renderiza solo cuando una Capa la nombra, con pxr render, que es lo que ejecuta la ventana Exportar de la aplicación. Separa las capas de una lista con un nodo Capa por capa, cada uno a su propia Hoja; combínalas con un Fusionar, una Pila o una Superposición.
Rango de fotogramas	fotogramas × N	fotogramas × N	Los fotogramas de from a to de cada lista, contados desde 0: from=3 to=3 para una imagen fija o un icono (uno nuevo es from=0 to=0, el primer fotograma), from=2 to=5 para unos pocos. Reparte una lista en varias hojas con un Rango de fotogramas por parte.
Mantener	fotogramas × N	fotogramas × N	Cada fotograma de cada lista mantenido times veces más.
Voltear	fotogramas × N	fotogramas × N	Cada lista reflejada de izquierda a derecha, en lugar de otra cámara: un nodo Sprites de Este volteado como Oeste es walk_West, dibujado a partir de walk_East: píxeles, normales, hitboxes y root motion reflejados. Un modelo simétrico no necesita renderizar su otro lado.
Etiqueta	fotogramas × N	fotogramas × N	Si las filas se repiten en bucle (Conservar, Sí o No), y un pivote propio (x,y en píxeles de celda) para un clip que se sitúa de otra forma. Un clip que no se repite es una etiqueta que se reproduce una vez en el JSON y en el .aseprite; el pivote está en cada fotograma del JSON y en una clave del slice del pivote.
Organizar	fotogramas × N	hoja × N	Cada lista en una hoja: cuadrícula o tira, relleno, extrusión, potencia de dos, recorte, fotogramas repetidos guardados una sola vez, un ancho máximo bajo el que se reparten las filas, una altura máxima a partir de la cual la hoja se divide en páginas (clips enteros por página, cada una con su propio conjunto de archivos), y fotogramas por fila, que encadena cada clip tras el anterior como en una hoja de contactos.
Colocar	hoja × N	hoja × N	Cada hoja movida a un lugar de la imagen.
Pila	hoja, hoja	hoja	Dos hojas como una, la segunda debajo o al lado de la primera, con un espacio.
Superposición	abajo, arriba	hoja	Una hoja colocada exactamente sobre otra, como el motor apila las capas: los píxeles vacíos de la de arriba muestran la de abajo. Cada capa se puede desactivar para ver la otra sola. Las dos deben coincidir fotograma a fotograma (los mismos fotogramas en los mismos lugares), o la exportación dice qué fotograma no coincide.
Hoja	hoja	archivo	Una hoja de sprites en memoria. No escribe nada: sus archivos son nodos Archivo conectados desde ella. Llamado es su nombre.
Archivo	hoja	archivo	Salida: un archivo en disco, escrito a partir de la Hoja desde la que está conectado, con sus propios ajustes en su cara, Abrir para abrir su archivo y Generar cuando es lento de generar. Imagen PNG (la propia hoja y cómo se llaman sus archivos: Archivos en, la ruta que escribe el PNG, cuyo nombre toman los demás, dentro de la carpeta que recibe la ventana Exportar; Nombres de archivo, la plantilla con la que se nombran sus fotogramas, con el primer nombre que genera mostrado debajo; Receta en archivos, si los archivos llevan cómo se hicieron; Sus propios archivos da a la hoja una ruta, unos nombres y una receta propios y, desactivado, sus archivos van adonde exporta el proyecto; el Inspector también muestra esto con la Hoja), JSON, Archivo de Aseprite, SpriteFrames de Godot, Mapa de normales, Mapa de profundidad, Mapa de emisión, Capas de líneas y planas, Paleta, Kit de luz, Cartucho de PICO-8, Informe; GIF por clip y APNG por clip (Escala); Vídeo por clip (Escala, Fotogramas por segundo, Fondo); Capa de sombra (de contacto o proyectada); Variantes de paleta (su lista); Capas de paper doll (Piezas); Capas de parallax (Capas, Bruma en capas lejanas). Borrar una Hoja borra sus nodos Archivo.
Archivo de texto	hoja	archivo	Salida: un archivo de texto a partir de una plantilla aplicada a los fotogramas (abajo).
Archivo de animación	fotogramas	archivo	Salida: una animación de cada lista de sprites conectada, sin hoja de por medio: un GIF, un APNG o un vídeo sin comprimir (Cada lista como), Escala veces más grande, un vídeo a Fotogramas por segundo sobre Fondo. Guardar en inicia el nombre de cada archivo: out/spin escribe out/spin_walk_South.gif.
Iconos	—	archivo	Salida: iconos de inventario del modelo, desde el ángulo de ¾ bajo la luz de estudio, contorneados con el color de la Rareza (o Del nombre del archivo), Encuadrado o no, en cada uno de los Tamaños: un PNG por icono y, por tamaño, un atlas y un índice JSON, en la carpeta Guardar en. Un icono es un render propio, así que no recibe nada; pxr los genera después de las hojas, en la carpeta de la exportación. Consulta los iconos de inventario.
Archivo ZIP	archivo, …	archivo	Salida: un ZIP con los archivos de los nodos de archivo conectados a él (A es adónde va) —una Hoja conectada es todo lo que escribe esa hoja— o, sin nada conectado, con todos los archivos que escribió la exportación. Las capas de paper doll y de parallax van con el resto. Los mismos archivos dan el mismo archivo comprimido, byte a byte. Lo que se entrega a otra persona o se sube a una tienda.

Un plan, no un render. El grafo decide qué fotogramas van dónde antes de que exista un solo píxel, así que el paso Asset funciona con el paso Estilo vacío, y pxr names muestra cada nombre e id que escribirá el grafo sin renderizar.

Los fotogramas conservan su identidad. Reorganizar una hoja mueve rectángulos y deja intacto el id de cada fotograma (consulta Cómo se llaman los fotogramas y qué son).

Pipelines de asset

Un proyecto tiene tantos pipelines de Asset como quiera, cada uno un grafo de asset propio con su nombre (la hoja del personaje, un set de iconos, las imágenes fijas de una página de tienda), y la ventana Exportar escribe el que elijas (pxr render --pipeline all los escribe todos). La lista Assets a la izquierda del paso Asset y el selector Asset de la cabecera eligen el que está en el lienzo. Nuevo pipeline de Asset bajo la lista crea una copia del mostrado, con su nombre (Main 2), y el menú contextual de una fila lo renombra, lo duplica (Duplicar), lo elimina (Delete NAME…, que pregunta antes: también el primero, mientras quede otro) y:

• Guardar kit… (Guardar el pipeline de Asset como kit) escribe el pipeline como kit. Guardado en la biblioteca de pipelines (donde se abre el diálogo), aparece en la biblioteca de nodos de cada proyecto, en Mis pipelines.
• Usar kit… (Usar un kit de pipeline de Asset), o un clic en uno de Mis pipelines, hace propio de este proyecto un pipeline guardado desde otro. Sus nombres —el del pipeline, los de sus hojas, los de sus archivos— se cambian por otros que nada de aquí tenga.

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

Imágenes externas

Un nodo Archivo de imagen pone en una hoja de Pixor lo que se dibujó en otro sitio: un logotipo en una hoja de título, un efecto pintado a mano, fotogramas de otra herramienta. Añádelo, Elegir… un PNG o un GIF, y se une a las listas de sprites mediante un Fusionar; conéctalo a una hoja propia para mantenerlo aparte.

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 toma el número de un nodo de pxr graph list, su nombre (logo) o su tipo (frame-range) cuando el grafo tiene un solo nodo de ese tipo.

Una imagen toma la paleta de la hoja: cada píxel, el más cercano de sus colores. Marca Sus propios colores y conservará los suyos: se añaden al final de la paleta de la hoja (los más usados primero, tantos como quepan en la paleta), así que cada archivo de la hoja —el PNG, el .aseprite, los GIF, los archivos de paleta— los lleva, y una variante de paleta los deja como están. Los fotogramas propios de la hoja no cambian.

Una imagen más grande que la celda agranda las celdas de todos los archivos en los que aparece: los demás fotogramas se centran en las celdas más grandes, y su pivote, hitboxes y puntos de anclaje se mueven con ellos.

Varios archivos de un mismo render

Un grafo puede tener varios nodos Hoja, cada uno con un PNG conectado desde él: un solo render escribe entonces una hoja de personaje, un conjunto de iconos y una imagen promocional. Una Hoja sin PNG no escribe ninguna imagen, solo los archivos conectados desde ella, que es como se escribe únicamente el JSON de una hoja. Una segunda Hoja toma lo mismo que la primera hasta que se conecta a listas propias. Cada una tiene su propia ruta, plantilla de nombres y receta, o toma las del proyecto; los archivos que la acompañan —y su sombra, variantes y escalas— son sus nodos Archivo. Cuando dos toman las del proyecto, la primera escribe la hoja del proyecto y la siguiente escribe a su lado con su propio nombre (out/hero_icons.png para una llamada icons), así que nada se escribe dos veces; dos que nombran una misma ruta propia se rechazan con ambos nombres. Una Hoja añadida desde un script recibe un nombre que no tiene ninguna otra salida (sheet 2), como en la aplicación, y pxr names enumera los archivos con los nombres que les da el render.

Las cámaras con la misma vista, inclinación, tamaño y aspecto se encuadran juntas y escriben una sola hoja, una fila por cámara: los lados de un anillo quedan alineados. Una cámara configurada de otra forma escribe sus propias hojas, y un nodo Sprites toma las filas del grupo que se está escribiendo. Un nodo Sprites que nombra cámaras de dos grupos (South, top) las reúne en cambio en un solo archivo, escrito cuando todas las cámaras han renderizado, junto a la hoja del proyecto con el nombre de su nodo Hoja (out/hero_both.png); las filas llevan el nombre de su cámara (walk_South, walk_top). Una hoja tiene un solo tamaño de fotograma y una sola paleta, así que las cámaras que encuadran a tamaños distintos se rechazan en lugar de apretujarlas: dales el mismo tamaño.

Una cuadrícula de iconos son tres nodos: un nodo Sprites de la acción idle desde la cámara South, un Organizar en forma de tira y una Hoja cuyo PNG va a out/icons.png. Una hoja de contactos es lo mismo con relleno. No son funciones; son grafos.

Desde 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 caminata dibujada con el Estilo portrait se encuadra aparte, así que escribe sus propias hojas junto a estas: out/game_portrait_8fps.png, y la chispa, que no tiene Estilo propio, otra vez en out/sparks_South_portrait_8fps.png.

Los números son los que da el recorrido de esta página; pxr graph list imprime los de cada proyecto. --alone mantiene la cuadrícula de iconos fuera de la cadena de la hoja principal: una lista idle fusionada también en ella serían los mismos fotogramas dos veces, algo que la plantilla de nombres rechaza.

pxr graph add pone un nodo en la cadena, ya conectado: un Rango de fotogramas o un Mantener antes del Organizar, un nodo de hoja después, y un segundo nodo Sprites junto al primero mediante un Fusionar. --set en una Hoja acepta path, names y recipe; formats añade y quita sus nodos Archivo —el PNG siempre entre ellos, como en la propia lista de una exportación; quita su nodo para no escribir ninguno—, y las palabras de los ajustes que contienen sus nodos Archivo crean y fijan esos nodos: shadow=drop, variants=hit-flash,hue:120, anim_scale=4, paper_doll=yes, pieces=helmet:Helmet,Visor, parallax=3, haze=none. Los ajustes propios de un nodo Archivo se fijan en él por su número: --node 5 --set fps=60.

Líneas junto a los colores

Una hoja puede llevar más de una capa de las mismas listas. Conecta el nodo Sprites dos veces —una directamente, otra a través de una Capa de lines— y únelas con Fusionar antes de un solo Organizar, u organiza cada una y pon las dos hojas una junto a otra con Pila. El JSON nombra las filas de líneas walk_South_lines, y sus ids difieren de los de los fotogramas de color por su capa, que es lo que son. Una plantilla que no dice {layer} la añade igualmente a los nombres de esos fotogramas (hero_walk_South_00_lines.png), para que dos fotogramas nunca acaben con un mismo nombre; los fotogramas propios del sprite conservan los suyos. Un nodo Sprites de un conjunto de partes hace lo mismo con {set} (hero_attack_South_00_bare.png), y el conjunto forma parte de los ids de esos fotogramas. O coloca las dos exactamente una sobre otra con una Superposición, como las dibujará el motor.

Archivos de texto a partir de una plantilla

Un motor del que Pixor nunca ha oído hablar necesita un descriptor, y eso es un archivo de texto sobre los mismos metadatos de fotogramas que lleva el JSON. Un nodo Archivo de texto escribe uno a partir de una plantilla:

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

{#frames} ... {/frames} escribe su cuerpo una vez por fotograma. Fuera de él, las palabras son las de la hoja: {project}, {object}, {sheet} (el nombre de archivo de la imagen), {width}, {height}, {cell_w}, {cell_h}, {pivot_x}, {pivot_y}, {frames}. Dentro, las de un fotograma: {name}, {id}, {action}, {side}, {row}, {index}, {n} (el número del fotograma en la hoja), {layer}, {x}, {y}, {w}, {h}, {source_x}, {source_y}, {duration} (milisegundos), {pivot_x} y {pivot_y} (los propios del clip, cuando una Etiqueta le dio uno), {loop} (true o false), {root_x}, {root_y}, {root_dx} y {root_dy} (el root motion, tal como lo da el JSON), {boxes} y {sockets} (como JSON), y {sep}, que es una coma salvo después del último fotograma: suficiente para una lista JSON. {index:3} rellena un número con ceros; {{ y }} escriben una llave.

Una plantilla también puede estar en su propio archivo junto al proyecto: da al nodo un Archivo de plantilla (--set file=frames.tpl desde un script) y se leerá cada vez que se escriba la salida, para que un estudio edite su descriptor donde guarda sus otros archivos.

No hay condicionales, ni aritmética, ni inclusiones. Es una forma de escribir un archivo, no un lenguaje. Una palabra que Pixor no conoce se rechaza cuando se escribe la plantilla, no se escribe en un archivo.

Una disposición usada como un solo grupo

Una cuadrícula de iconos, una hoja de contactos, la forma propia de un estudio de disponer un personaje: Guardar kit… en la barra, sin ningún grupo elegido, guarda el grafo de Asset como kit (Guardar el grafo de Asset como kit): su disposición, lo que alimenta su Hoja, como un grupo que recibe listas de sprites (cada nodo Sprites pasa a ser una entrada) y da la hoja. La Hoja y los archivos que cuelgan de ella siguen siendo del proyecto. + › Usar kit… (Añadir un kit como grupo) lo pone en el grafo de Asset de otro proyecto como un grupo, para conectarlo allí a una Hoja o ponerlo en lugar de un Organizar. Haz doble clic en él, o pulsa la flecha de su título, para abrirlo en el sitio; la flecha lo vuelve a plegar. Desde 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

Lo que no hará

• Los formatos binarios siguen siendo código. PNG, .aseprite, GIF, APNG, Godot SpriteFrames, los kits de luz y .p8 son nodos Hoja y Archivo; una plantilla escribe texto.
• Sin binarios de plugins y sin nodos de script, aquí como en los demás grafos.