Generación procedural
Bosques, prados llenos de flores, piedras a lo largo de un río, vallas junto a un camino: contenido que describes una vez y Gobu coloca por ti, tantas veces como quieras y siempre igual. Se describe con un grafo procedural (ProceduralGraph), como el PCG de Unreal. Los nodos crean puntos, se quedan con algunos y les dan valores, y los puntos dicen dónde va cada cosa. Sirve para juegos 2D y 3D.
result : ProceduralResult = Procedural.run_2d(bosque, 1234, Rect2(0, 0, 2048, 2048))arboles : ProceduralPoints = result.get_points(&"Out")for i : int in range(arboles.get_size()) { print(arboles.get_position_2d(i))}El mismo grafo, con la misma semilla y los mismos límites, da siempre los mismos puntos, en cualquier máquina y con cualquier número de hilos. Un juego puede generar su mundo a partir de una semilla, y otra semilla da otro mundo.
Cómo funciona un grafo
Sección titulada «Cómo funciona un grafo»Un grafo es una cadena de pasos. Un bosque típico:
- Area Sampler: puntos a unos 16 píxeles entre sí por toda la zona.
- Noise: cada punto recibe el ruido de su sitio como densidad (de 0 a 1).
- Density Filter: solo quedan los puntos con densidad mayor que 0,55. Ya hay manchas.
- Difference: se van los puntos del camino o de dentro de las casas.
- Self Pruning: se van los puntos demasiado juntos, para que los árboles no se pisen.
- Transform Points: cada uno se gira y se escala un poco al azar.
- Pick by Weight: cada uno recibe
kind, “roble” el 70 % de las veces y “pino” el 30 %. - Output: lo que llega aquí es el resultado.

Solo se ejecuta lo que llega a un nodo Output. Un grafo puede tener varios (arboles,
flores…), y cada uno se lee por su nombre.
Cada punto tiene una posición, una rotación, una escala, una caja a su alrededor (sus
bounds), una densidad de 0 a 1, un color y una semilla. La semilla sale de su posición,
así que un sitio recibe siempre el mismo azar, cambie lo que cambie en el resto del grafo. Los
nodos también pueden darles atributos con cualquier nombre (tipo, altura, edad…).
Los nodos que leen o escriben un valor de los puntos lo reciben como texto:
| Texto | Qué es |
|---|---|
$position, $position.x | dónde está el punto (o una coordenada) |
$rotation | cómo está girado, en grados |
$scale, $extents, $bounds_min, $bounds_max | su tamaño y su caja |
$density, $color, $seed, $index | lo demás ($index solo se lee) |
tipo | un atributo |
objetos[0], stats[velocidad], stats[dir].y | un elemento de un atributo que guarda arrays o diccionarios (solo se lee) |
@last | el último atributo escrito |
En 2D, los puntos están en x, y (z es la capa). En 3D están en el suelo, x y z, con y hacia arriba. En 3D, los samplers los ponen en la parte de abajo de los límites.
Los nodos
Sección titulada «Los nodos»| Tipo | Nodos |
|---|---|
| Entrada | Input (datos dados desde el código), Bounds (la zona de la generación), Polygon, Curve, Get Surface (3D: las mallas de la escena) |
| Muestreo | Area Sampler (puntos repartidos), Grid Sampler (uno por celda, alineados con el mundo: para tiles), Curve Sampler (a lo largo de una línea), Surface Sampler (3D: sobre una superficie) |
| Formas | Polygon Operation (unión, intersección, diferencia, xor), Offset Polygon, Curve to Polygon (un camino a partir de su trazado), Polygon to Curve, Convex Hull, Subdivide Curve (una gramática: vallas, muros), Room Layout (salas y pasillos) |
| Densidad | Noise, Distance to Density (cerca de algo vale 1, lejos 0), Density Remap, Curve Remap (una curva convierte cada valor en otro), Texture to Density (una textura dice dónde), Mask to Density (una máscara pintada en el generador), Slope to Density (3D: el llano vale 1, lo empinado 0) |
| Filtro | Density Filter, Attribute Filter, Self Pruning, Difference, Intersection, Union, Cull Outside Bounds, Random Choice |
| Puntos | Transform Points, Bounds Modifier, Snap to Grid, Copy Points (un patrón en cada punto), Merge, Sort, Point Processor (una función de Grost), Project to Surface (3D) |
| Atributos | Create Attribute, Math, Compare, Boolean, Vector, Pick by Weight, Partition by Attribute (una nube por valor), Rename Attribute, Delete Attributes |
| Control | Branch, Subgraph (otro grafo como un solo nodo), Loop (un grafo una vez por dato), Biomes, Grid Size (celdas más grandes, en el juego), Reroute (un codo en un cable), Print |
Las formas (polígonos, curvas, los límites) entran en los samplers para decir dónde van los puntos, y en Difference o Intersection para decir dónde no. Cuando se juntan con otras formas no se calcula nada: solo se resuelven en los sitios que pregunta un sampler. Los nodos de Formas en cambio las calculan ya: polígonos de verdad para agrandar, recortar y seguir.
El editor del grafo
Sección titulada «El editor del grafo»Selecciona un recurso ProceduralGraph, o un ProceduralGenerator2D de la escena, y se abre abajo la pestaña Procedural Graph:
- Add Actor, o el clic derecho, abre un buscador con los nodos por tipo. Si sueltas un cable en el vacío, solo salen los nodos que aceptan lo que lleva ese cable, y el nuevo nodo queda conectado.
- Arrastra de un pin a otro para conectarlos; si no encajan, el editor dice por qué (llevan otros datos, o la conexión haría un bucle). Todo se puede deshacer.
- Al hacer clic en un nodo, sus ajustes salen en el inspector.
- Con Preview activado, el grafo se ejecuta tras cada cambio. Cada nodo muestra cuántos puntos hizo y cuánto tardó, y la tabla de la derecha muestra los puntos del nodo elegido (posición, densidad, semilla y atributos). Es rápido gracias a la caché: al cambiar un nodo, solo corren él y los que van después.
- El grafo de un generador se previsualiza en la escena de ese generador (sus límites, su semilla, sus tiles). Un grafo suelto usa la Seed y el Size de la barra.
- Los puntos del nodo elegido también se dibujan en el viewport 2D, encima de lo colocado: un cuadrado por punto, de azul (poca densidad) a amarillo (mucha), del mismo tamaño con cualquier zoom.

Los pines tienen el color de lo que llevan: verde para puntos, azul para formas, gris para los dos. Ctrl+C, Ctrl+V y Ctrl+D copian, pegan y duplican los nodos seleccionados con las conexiones entre ellos, también de un grafo a otro.
Comment (en la barra, o clic derecho con nodos elegidos) pone un recuadro de comentario alrededor de los nodos elegidos, o uno vacío: escribe su título y elige su color en su barra. Sus nodos se mueven con él; suelta un nodo sobre un comentario para meterlo, y clic derecho → Remove Selected from Comment para sacarlo. Un doble clic en un cable pone ahí un Reroute, un codo que deja pasar lo que le llega. Ninguno de los dos cambia lo que hace el grafo.

Un Subgraph puede tener sus propios spawners: lo que les llega también se coloca.
Subgrafos dentro del grafo
Sección titulada «Subgrafos dentro del grafo»Open en un nodo Subgraph, Loop o Biomes (o un doble clic en él) edita el grafo que lleva dentro en el mismo sitio, y la ruta encima del grafo (Graph › Subgraph 12) te devuelve. Un Subgraph sin grafo recibe uno, con un Input y un Output. Dentro, cada nodo muestra los puntos del primer dato que le llega en la vista previa del grafo principal (la primera vuelta de un bucle, los puntos de un bioma).
Los pines de un Subgraph son los nodos Input y Output de su grafo, por nombre: un Input llamado
Rocas dentro es un pin Rocas fuera. Collapse to Subgraph mete los nodos elegidos en un Subgraph
nuevo, incrustado en el grafo: los cables que entraban pasan a ser sus pines de entrada, los que
salían sus pines de salida, y genera lo mismo. Se puede deshacer.

Montar un grafo desde el código
Sección titulada «Montar un grafo desde el código»fn crear_bosque() ProceduralGraph { grafo : ProceduralGraph = ProceduralGraph.new() muestreo : ProceduralNodeAreaSampler = ProceduralNodeAreaSampler.new() muestreo.spacing = 16.0 filtro : ProceduralNodeDensityFilter = ProceduralNodeDensityFilter.new() filtro.lower = 0.55
m : int = grafo.add_node(muestreo) r : int = grafo.add_node(ProceduralNodeNoise.new()) f : int = grafo.add_node(filtro) s : int = grafo.add_node(ProceduralNodeOutput.new()) conectar(grafo, m, &"Out", r, &"In") conectar(grafo, r, &"Out", f, &"In") conectar(grafo, f, &"Inside", s, &"In") return grafo}
# connect_nodes() dice si se hizo la conexión (los pines existen, aceptan los mismos datos, sin bucles).fn conectar(grafo: ProceduralGraph, desde: int, salida: StringName, hasta: int, entrada: StringName) void { if grafo.connect_nodes(desde, salida, hasta, entrada) != OK { push_error("No se pudo conectar %s con %s" % [salida, entrada]) }}Un grafo es un recurso: se puede guardar (ResourceSaver.save(grafo, "res://bosque.resource"))
y cargar con use resource::Bosque as bosque : ProceduralGraph.
Tu propio nodo: Point Processor
Sección titulada «Tu propio nodo: Point Processor»Para lo que no hace ningún nodo, un Point Processor llama a una static fn de un archivo
.gro (Code, y su nombre en Function). La función recibe una copia de los puntos y
devuelve los que siguen: los mismos cambiados, menos, u otros.
# res://procedural/sombrear.grostatic fn sombrear(puntos: ProceduralPoints) ProceduralPoints { for i : int in range(puntos.get_size()) { puntos.set_density(i, puntos.get_density(i) * 0.5) puntos.set_attribute(&"marca", i, "sombreado") } return puntos}Al cambiar el archivo, el nodo se vuelve a ejecutar. Que la función dependa solo de los puntos que recibe (sin números al azar propios, sin nada de la escena): los mismos puntos tienen que dar el mismo resultado, o la caché y las celdas de un mundo At Runtime dejan de coincidir.
Parámetros
Sección titulada «Parámetros»Los parámetros de un grafo mueven ajustes de sus nodos, así que el mismo grafo hace un bosque denso o uno claro:
grafo.set_parameter(&"arboles", 0.5)if grafo.bind_parameter(id_eleccion, &"ratio", &"arboles") != OK { # El Random Choice se queda esa parte. push_error("No existe ese ajuste")}
peticion : ProceduralRequest = ProceduralRequest.new()peticion.graph = grafopeticion.seed = 7peticion.set_bounds_2d(Rect2(0, 0, 2048, 2048))peticion.set_parameter(&"arboles", 0.9)resultado : ProceduralResult = Procedural.execute(peticion)ProceduralRequest también da datos a los nodos Input del grafo (add_input), por
ejemplo un polígono del nivel donde no crece nada.
Rápido al cambiar cosas
Sección titulada «Rápido al cambiar cosas»Gobu guarda lo que hizo cada nodo según lo que recibió. Al cambiar un nodo, solo se vuelven a ejecutar ese nodo y los que van después. Los nodos reparten sus puntos entre todos los hilos de la CPU, y el resultado es el mismo con un hilo o con muchos.
El tamaño de esa caché se ajusta en Project Settings > Procedural > Cache > Max Megabytes (64 MB por defecto).
Ponerlo en la escena: ProceduralGenerator2D
Sección titulada «Ponerlo en la escena: ProceduralGenerator2D»Añade un nodo ProceduralGenerator2D a una escena 2D, dale un Graph y ajusta sus Bounds (el rectángulo verde del editor). Los nodos spawner del grafo dicen qué va a la escena para los puntos que les llegan:
| Spawner | Qué pone |
|---|---|
| Spawn Tiles | un tile en la celda de cada punto de un TileMapLayer: el terreno, enlazado con sus vecinos como el pincel de terrenos; un tile fijo; o nada (Erase) |
| Spawn Sprites | un sprite en cada punto, todos en unos pocos MultiMesh: miles de flores o piedras cuestan poco |
| Spawn Prefab | un prefab en cada punto. Un atributo con el nombre de una de sus propiedades la ajusta (tipo, element_type…), y cada uno recibe un nombre que sale de su sitio (Arbol_3f9a21c0, siempre el mismo) |
| Spawn Entities | una entidad de ECS en cada punto, sin nodo, con los componentes que le pongas: miles de cosas con lógica sencilla, movidas por sistemas de ECS |
| Spawn Curve | una Line2D (o un Path2D) que pasa por los puntos en orden: caminos, ríos, vallas. Con un Curve Sampler con Curve Attribute y Distance Attribute (y esos como Group Attribute y Order Attribute), cada curva del grafo es una línea |
El grafo también puede leer la escena:
- Get Tiles: un punto en cada tile de una capa (solo la hierba, solo un terreno…), con
su
terrain,sourceyatlas. - Get Nodes: un punto en cada nodo de un grupo. Conéctalo a Difference para que los árboles no salgan pegados a las casas.
- Match and Set: da a cada punto los valores de una fila de una tabla, por ejemplo los ajustes de cada tipo de árbol.
Lo que hace el generador es suyo. Al generar otra vez se reemplaza, Clear lo quita y los tiles vuelven a como estaban.
Entidades (ECS)
Sección titulada «Entidades (ECS)»Spawn Entities hace una entidad de ECS por punto, con los structs de Grost de Components. Cada campo recibe un valor del punto:
- un campo que se llama como un atributo de los puntos recibe ese atributo;
- si no,
position,rotation,scale,density,seedycolorreciben los del punto, en el mundo (las entidades no tienen padre: cuenta la posición del generador); - la
xy lay(y laz) del Position Component (Positionpor defecto) reciben dónde está el punto; - los demás campos se quedan con su valor por defecto.
module Critters
# Un Spawn Entities con Components ["Position", "Wander"] hace una entidad por punto:# Position recibe el sitio del punto, Wander.seed su semilla y Wander.speed se queda con su valor por defecto.Position :: struct { x : float = 0 y : float = 0}
Wander :: struct { speed : float = 20 seed : int = 0}
fn move_critters(it: EcsSystemIterator) void { dt : float = it.delta() positions := it.field("Position") wanders := it.field("Wander") for i : int in range(it.count()) { position := positions[i] wander := wanders[i] # Cada una va por su lado: a la derecha o a la izquierda según su semilla. direction : float = 1.0 if wander.seed % 2 == 0 else -1.0 position.x += wander.speed * direction * dt }}
fn _ready() void { ECS.world().system(move_critters, "process", ["Position", "Wander"])}Los structs tienen que existir cuando corre el generador: decláralos en un script de la escena o
en un archivo .component.gro (esos se cargan al empezar el juego). Las entidades solo se crean
en el juego, no en el editor (no se ven; el editor del grafo muestra sus puntos). Se van con la
celda que las hizo, con Clear y cuando el generador genera otra vez.
Generate Mode:
- In Editor (por defecto): genera mientras editas, cuando cambian el grafo, la semilla, los límites o los parámetros, o al pulsar Generate. Lo que hizo se guarda con la escena: al cargarla, en el editor o en el juego, vuelve igual sin ejecutar el grafo, siempre que no haya cambiado nada de lo que depende.
- On Ready: genera cada vez que empieza el juego (otra semilla en cada partida, otro mundo).
- Manually: solo cuando tu código llama a
generate(). - At Runtime: en el juego, genera las celdas alrededor de la cámara y de los nodos ProceduralSource2D (uno en el jugador, en un vehículo…), un poco cada frame, y quita las celdas que quedan lejos. Lo explicamos abajo, y en Mundos grandes.
Para que se ordenen en Y con el jugador, pon en Spawn Parent el nodo donde está el jugador y activa Y Sort Enabled en el generador.
use actor::Bosque as bosque : ProceduralGenerator2D
fn _ready() void { bosque.seed = randi() if bosque.generate() != OK { push_error("No se generó el bosque") }}Cambiar a mano lo que hizo
Sección titulada «Cambiar a mano lo que hizo»Un bosque generado es un punto de partida: un árbol que estorba en un camino, otro más junto a la casa, un pino donde había un roble. Los cambios a mano se guardan con la escena y se aplican cada vez que el generador vuelve a generar, así que puedes seguir cambiando el grafo, el ruido o la semilla.
Selecciona el generador: cada cosa que hizo (prefabs y sprites) tiene un pequeño tirador en el viewport 2D.
- Haz clic en una para elegirla y arrástrala para moverla.
- Supr la quita (una añadida a mano simplemente deja de añadirse).
- Esc la suelta. Un clic en otro sitio selecciona otros nodos como siempre.
- Todo se puede deshacer.

La pestaña Overrides del panel Procedural Graph lista los cambios: qué hace cada uno, su spawner, un botón para deshacerlo y Clear All.
Cada cosa se conoce por su id estable: el hexadecimal del final de su nombre (Arbol_3f9a21c0).
Sale de dónde se hizo su punto, así que un cambio sigue a su cosa mientras el grafo la haga. Si el
grafo ya no hace ese punto (otro filtro, otro ruido), el cambio queda huérfano: la pestaña lo
muestra en otro color. Quítalo o haz el mismo cambio en una cosa que sí esté.
Pintar dónde van las cosas: máscaras
Sección titulada «Pintar dónde van las cosas: máscaras»Con un generador seleccionado, pulsa Paint Mask en la barra del panel y pinta en el viewport 2D (o, con un generador 3D, sobre el suelo de su caja en el viewport 3D): el botón izquierdo pinta, Mayús borra, y el campo de al lado es el radio del pincel (píxeles en 2D, metros en 3D). Cada trazo se puede deshacer, y el generador vuelve a generar al terminarlo.

La máscara se guarda con la escena y cubre los límites del generador (Mask Texel Size dice lo grande que es cada texel). Un nodo Mask to Density con su nombre la lee: Set para “solo donde pinté”, Multiply para aclarar el bosque a mano, Invert para “en todas partes menos ahí”. Un generador puede tener varias máscaras, cada una con su nombre (el campo tras Paint Mask).
Desde el código (también en el juego): paint_mask(nombre, posición, radio, valor) pinta, y
set_mask(nombre, imagen) termina un trazo (vuelve a generar).
Desde el código (también en el juego):
# Cambios a mano en lo que hizo un generador: se quedan cuando vuelve a generar.fn clear_around(generator: ProceduralGenerator2D, at: Vector2) void { hit : Dictionary = generator.find_generated(at, 24.0) if hit.is_empty() { return } generator.remove_generated((hit["id"] as int) ?? 0) if generator.generate() != OK { push_error("The forest could not generate again") }}
# Un árbol más a mano, para el nodo spawner 7 del grafo, y un pino donde había un roble.fn plant(generator: ProceduralGenerator2D, at: Vector2, oak: int) void { pine : int = generator.add_generated(7, at, { "kind": "pine" }) print("planted ", pine) generator.set_generated_attribute(oak, &"kind", "pine") for orphan : int in generator.get_orphan_overrides() { print("its tree is not generated any more: ", orphan) }}overrides es una propiedad del generador (se guarda con la escena); set_override(id, {})
deshace uno. En el juego, un generador At Runtime rehace sus celdas con los cambios; los demás
los aplican la próxima vez que generan.
Mundos sin fin: At Runtime
Sección titulada «Mundos sin fin: At Runtime»Con Generate Mode en At Runtime, el generador divide el mundo en celdas de Cell Size y, mientras corre el juego, genera las que quedan dentro de Generation Radius de sus fuentes:
- la cámara actual (Use Camera);
- cada nodo ProceduralSource2D, con su Radius Scale.

Primero van las celdas más cercanas. Una celda se quita cuando queda más lejos que el radio por Cleanup Radius Multiplier de todas las fuentes, y sus tiles vuelven a como estaban. Al volver, se genera otra vez igual: un sitio tiene siempre el mismo contenido.
Con Reuse Instances en un Spawn Prefab, los prefabs de una celda que se va no se liberan:
esperan fuera del árbol y las celdas siguientes los vuelven a usar. Así se crean menos nodos
mientras recorres el mundo. Uno reutilizado conserva los valores que tenía (un árbol talado sigue
talado) y su _ready vuelve a correr, así que reinicia ahí lo que deba empezar de nuevo. Los
objetos de Online no se reutilizan nunca.
Trabaja un poco cada frame, dentro de Project Settings > Procedural > Runtime > Frame Budget
Ms (2 ms por defecto). Los prefabs se colocan de pocos en pocos, para que una celda llena de
árboles no pare el juego un frame: el generador mide cuánto tarda en hacerse uno de los tuyos (su
_ready, sus scripts) y hace los que caben. En release, una celda de un prado 2D tarda unos 0,8 ms
con sprites; con prefabs, lo que tarden sus propios scripts. Con Unbounded no tiene Bounds: genera donde vayan
las fuentes, un mundo sin fin.
En el editor, un generador At Runtime muestra una vista previa alrededor de lo que enseña el viewport 2D (Preview In Editor). La vista previa no toca los tiles, así que las capas de la escena se quedan como están.
Cada celda coloca solo los puntos que caen dentro de ella, así que el resultado es el mismo que generar toda la zona de una vez: nada repetido y nada que falte donde se juntan las celdas. Get Tiles da solo los tiles de la celda que se genera.
Más grande que una celda: Grid Size
Sección titulada «Más grande que una celda: Grid Size»Cada nodo se ejecuta para la celda que se genera. Algunas cosas necesitan ver más lejos: las manchas grandes de un bioma, un río que cruza muchas celdas, un Self Pruning que no debe cortarse en el borde de una celda. Un nodo Grid Size hace que los nodos que van después se ejecuten para una celda más grande (de su Grid Size) que contiene a la celda: una sola vez para todas las celdas pequeñas de dentro, que comparten lo que hizo gracias a la caché. Cada celda pequeña sigue colocando solo sus puntos.
- Sin nada conectado, Grid Size da su celda como zona: conéctalo a un sampler.
- Una rejilla de
0es el mundo entero (los Bounds del generador). - El Default Grid Size del grafo es la rejilla de los nodos que no reciben nada de otros nodos; los demás usan la rejilla más pequeña de lo que les llega.
- Fuera de un mundo por celdas (In Editor, On Ready, Manually), Grid Size no cambia nada.
use actor::Mundo as mundo : ProceduralGenerator2D
on mundo.cell_generated(celda: Vector2i) { print("Lista: ", celda)}Bucles y particiones
Sección titulada «Bucles y particiones»Partition by Attribute parte una nube en una por cada valor de un atributo (tipo, biome,
$position.y…), en el orden en que salen los valores. Loop ejecuta su grafo una vez por cada
dato que llega a In, solo (o Count veces si In no tiene cable), y junta lo que da cada vuelta en
Out. Dentro, tres nodos Input leen los datos: In (el dato de esta vuelta), Fixed (todo lo del
pin Fixed, en cada vuelta) y Feedback (lo que la vuelta anterior dio en su salida Feedback: la
primera recibe el pin Feedback). Los parámetros iteration e iterations del grafo dicen qué vuelta
es, y con Vary Seed cada vuelta elige sus propios números al azar.
Los parámetros de un Subgraph toman el valor del parámetro de la generación que se llama igual:
un parámetro densidad del grafo principal llega a todos los subgrafos que también lo tengan.
Formas: caminos y parcelas
Sección titulada «Formas: caminos y parcelas»Los nodos de Shape calculan los polígonos ya, así se pueden agrandar, recortar y seguir:
| Nodo | Qué hace |
|---|---|
| Curve to Polygon | un camino a partir de su trazado: una franja tan ancha como Width (puntas redondas, cuadradas o planas); una curva cerrada da lo que encierra |
| Polygon Operation | unión, intersección, diferencia o xor de todo lo de A con todo lo de B (polígonos y cajas: Bounds menos los caminos son las parcelas) |
| Offset Polygon | agranda cada polígono (un margen), o lo encoge por debajo de 0 (el patio dentro de una valla) |
| Polygon to Curve | una curva cerrada por cada contorno, para una valla o un muro |
| Convex Hull | el polígono convexo más pequeño alrededor de cada nube de puntos |
Gramáticas: vallas, muros y fachadas
Sección titulada «Gramáticas: vallas, muros y fachadas»Subdivide Curve corta cada curva (cada tramo recto, con Per Segment, así los postes caen en
las esquinas) en módulos según una gramática, y da un punto en el centro de cada uno, girado a lo
largo de la curva, con su caja tan larga como el módulo. Modules dice el tamaño de cada módulo:
{ "Post": 8, "Fence": 48, "Gate": 64 }.
| Gramática | Significa |
|---|---|
Post | un módulo |
A,B | uno tras otro; [A,B] es un grupo |
X* | tantos como quepan; X+, uno o más |
{A,B} | uno de ellos al azar; {A:3,B:1} con pesos |
<A,B> | el primero que quepa (ninguno si no cabe ninguno) |
Post,[{Fence:4,Gate:1},Post]* es una valla con un poste en cada punta y de vez en cuando un
portón. Lo que va después de una repetición conserva su sitio: [Fence,Post]*,Gate siempre acaba con
su portón. Con Fit en Stretch, los módulos Scalable (todos, si no se nombra ninguno) crecen un
poco para que cada tramo quede justo; los postes conservan su tamaño.
Cada punto recibe symbol (el nombre del módulo) y module (su lugar en Modules): un Spawn
Prefab con Prefabs en el mismo orden y Prefab Attribute module pone el que toca en cada
punto. Los muros son lo mismo con otros módulos (Wall, Window, Door). Para una fachada, Levels
repite la fila en tantos pisos, separados Level Height (hacia arriba en 3D, hacia -y en la pantalla
en 2D), y Ground Grammar da a la planta baja una gramática propia: [Wall,Window]*,Door,[Window,Wall]*
abajo y Wall,[Window,Wall]* arriba. Cada punto recibe su level.
Mazmorras: Room Layout
Sección titulada «Mazmorras: Room Layout»Room Layout corta la zona de In (o los límites) en dos una y otra vez, pone una sala en cada trozo (entre Room Min y Room Max, en una rejilla de Cell Size) y une todas las salas con pasillos (primero las más cercanas, y algunos bucles más con Loops). Da las Rooms (un punto en el centro de cada sala, su caja la sala), los Corridors (curvas), las Doors (donde los pasillos llegan a las salas) y el Floor (un solo polígono): un Grid Sampler sobre el Floor da los tiles del suelo, y Polygon to Curve con Subdivide Curve sus muros.
# Rooms and corridors in 2048 x 2048, on a grid of 16 (the tile size): floor tiles on the rooms and# corridors, a chest in each room.fn make_dungeon(chest: PackedScene) ProceduralGraph { graph : ProceduralGraph = ProceduralGraph.new() layout : ProceduralNodeRoomLayout = ProceduralNodeRoomLayout.new() layout.room_min = Vector2(96, 96) layout.room_max = Vector2(256, 192) layout.cell_size = 16.0 layout.loops = 0.2 # Some corridors more than a tree: loops to run around. tiles : ProceduralNodeGridSampler = ProceduralNodeGridSampler.new() tiles.cell_size = Vector3(16, 16, 1) floor_tiles : ProceduralNodeSpawnTiles = ProceduralNodeSpawnTiles.new() floor_tiles.layer = NodePath("../Floor") chests : ProceduralNodeSpawnPrefab = ProceduralNodeSpawnPrefab.new() chests.prefab = chest r : int = graph.add_node(layout) t : int = graph.add_node(tiles) f : int = graph.add_node(floor_tiles) c : int = graph.add_node(chests) wire(graph, r, &"Floor", t, &"In") wire(graph, t, &"Out", f, &"In") wire(graph, r, &"Rooms", c, &"In") return graph}Un nodo Biomes reparte los puntos entre biomas según un valor de cada uno (su Map: un ruido,
una máscara, la altura). Cada ProceduralBiome dice qué valores toma (de Range Min a Range
Max) y qué crece ahí: su Graph, que se ejecuta con sus puntos (un nodo Input llamado In los
recibe). Los biomas son recursos, así que varios grafos pueden compartirlos.
Donde se juntan dos biomas, a menos de Blend de sus rangos, cada punto va a uno u otro al azar,
más a menudo al más cercano: el bosque se aclara hacia la pradera en vez de acabar en una línea. Out
da lo que dan los grafos de los biomas en su Out; Points da todos los puntos con el nombre de su
bioma en biome.
Un pueblo
Sección titulada «Un pueblo»Todo junto: dos caminos, cuatro parcelas valladas con portones y casas, y un bosque y una pradera en su suelo que se mezclan donde se juntan.
# A village on 1600 x 1600: two roads that cross, the four plots between them with a fence (and gates)# around each and houses inside, and the ground of the yards split between a forest and a meadow by a# noise, mixed where they meet.fn make_village(post: PackedScene, fence: PackedScene, gate: PackedScene, house: PackedScene, tree: PackedScene, flower: Texture2D) ProceduralGraph { graph : ProceduralGraph = ProceduralGraph.new()
# Roads 80 wide, and a margin of 40 on each side. road_h : ProceduralNodeCurve = ProceduralNodeCurve.new() road_h.points = [Vector2(0, 800), Vector2(1600, 800)] road_v : ProceduralNodeCurve = ProceduralNodeCurve.new() road_v.points = [Vector2(800, 0), Vector2(800, 1600)] roads : ProceduralNodeCurveToPolygon = ProceduralNodeCurveToPolygon.new() roads.width = 80.0 roads.ends = ProceduralNodeCurveToPolygon.ENDS_BUTT margin : ProceduralNodeOffsetPolygon = ProceduralNodeOffsetPolygon.new() margin.offset = 40.0 margin.join = ProceduralNodeOffsetPolygon.JOIN_MITER
# The plots: the bounds without the roads. The yards: 24 inside them. plots : ProceduralNodePolygonOperation = ProceduralNodePolygonOperation.new() plots.operation = ProceduralNodePolygonOperation.OPERATION_DIFFERENCE yards : ProceduralNodeOffsetPolygon = ProceduralNodeOffsetPolygon.new() yards.offset = -24.0 yards.join = ProceduralNodeOffsetPolygon.JOIN_MITER
# Around each yard a fence: posts at the corners and, between posts, a fence or now and then a gate. outline : ProceduralNodePolygonToCurve = ProceduralNodePolygonToCurve.new() grammar : ProceduralNodeSubdivideCurve = ProceduralNodeSubdivideCurve.new() grammar.modules = { "Post": 8.0, "Fence": 48.0, "Gate": 64.0 } grammar.grammar = "Post,[{Fence:4,Gate:1},Post]*" grammar.scalable = ["Fence", "Gate"] # Posts keep their size. fences : ProceduralNodeSpawnPrefab = ProceduralNodeSpawnPrefab.new() fences.prefabs = [post, fence, gate] # In the order of the modules: "module" picks one. fences.prefab_attribute = &"module"
# Houses on a grid in the middle of the plots, each taking 140 x 140. lots : ProceduralNodeOffsetPolygon = ProceduralNodeOffsetPolygon.new() lots.offset = -120.0 lots.join = ProceduralNodeOffsetPolygon.JOIN_MITER grid : ProceduralNodeGridSampler = ProceduralNodeGridSampler.new() grid.cell_size = Vector3(240, 240, 1) grid.point_extents = Vector3(70, 70, 0.5) houses : ProceduralNodeSpawnPrefab = ProceduralNodeSpawnPrefab.new() houses.prefab = house
# The ground of the yards (not under the houses), its humidity, and two biomes on it. ground : ProceduralNodeAreaSampler = ProceduralNodeAreaSampler.new() ground.spacing = 24.0 open_ground : ProceduralNodeDifference = ProceduralNodeDifference.new() humidity : ProceduralNodeNoise = ProceduralNodeNoise.new() wet : FastNoiseLite = FastNoiseLite.new() wet.frequency = 0.003 humidity.noise = wet humidity.target = "humidity" biomes : ProceduralNodeBiomes = ProceduralNodeBiomes.new() biomes.map = "humidity" biomes.blend = 0.06 # From 0.44 to 0.56 both grow, more of the nearer one. biomes.biomes = [make_biome(&"meadow", 0.0, 0.5, meadow(flower)), make_biome(&"forest", 0.5, 1.0, forest(tree))]
h : int = graph.add_node(road_h) v : int = graph.add_node(road_v) r : int = graph.add_node(roads) m : int = graph.add_node(margin) b : int = graph.add_node(ProceduralNodeBounds.new()) p : int = graph.add_node(plots) y : int = graph.add_node(yards) o : int = graph.add_node(outline) gr : int = graph.add_node(grammar) f : int = graph.add_node(fences) l : int = graph.add_node(lots) g : int = graph.add_node(grid) hs : int = graph.add_node(houses) s : int = graph.add_node(ground) fr : int = graph.add_node(open_ground) hu : int = graph.add_node(humidity) bi : int = graph.add_node(biomes) wire(graph, h, &"Out", r, &"In") wire(graph, v, &"Out", r, &"In") wire(graph, r, &"Out", m, &"In") wire(graph, b, &"Out", p, &"A") wire(graph, m, &"Out", p, &"B") wire(graph, p, &"Out", y, &"In") wire(graph, y, &"Out", o, &"In") wire(graph, o, &"Out", gr, &"In") wire(graph, gr, &"Out", f, &"In") wire(graph, p, &"Out", l, &"In") wire(graph, l, &"Out", g, &"In") wire(graph, g, &"Out", hs, &"In") wire(graph, y, &"Out", s, &"In") wire(graph, s, &"Out", fr, &"In") wire(graph, g, &"Out", fr, &"Subtract") wire(graph, fr, &"Out", hu, &"In") wire(graph, hu, &"Out", bi, &"In") return graph}
# The forest: its points thinned to 40 apart, a tree on each.fn forest(tree: PackedScene) ProceduralGraph { graph : ProceduralGraph = ProceduralGraph.new() spread : ProceduralNodeSelfPruning = ProceduralNodeSelfPruning.new() spread.radius = 40.0 trees : ProceduralNodeSpawnPrefab = ProceduralNodeSpawnPrefab.new() trees.prefab = tree i : int = graph.add_node(ProceduralNodeInput.new()) # "In": the biome's points. s : int = graph.add_node(spread) t : int = graph.add_node(trees) wire(graph, i, &"Out", s, &"In") wire(graph, s, &"Out", t, &"In") return graph}
# The meadow: flowers on a third of its points.fn meadow(flower: Texture2D) ProceduralGraph { graph : ProceduralGraph = ProceduralGraph.new() some : ProceduralNodeRandomChoice = ProceduralNodeRandomChoice.new() some.ratio = 0.3 flowers : ProceduralNodeSpawnSprites = ProceduralNodeSpawnSprites.new() flowers.texture = flower i : int = graph.add_node(ProceduralNodeInput.new()) c : int = graph.add_node(some) s : int = graph.add_node(flowers) wire(graph, i, &"Out", c, &"In") wire(graph, c, &"Chosen", s, &"In") return graph}
fn make_biome(biome_name: StringName, from: float, to: float, graph: ProceduralGraph) ProceduralBiome { biome : ProceduralBiome = ProceduralBiome.new() biome.biome_name = biome_name biome.range_min = from biome.range_max = to biome.graph = graph return biome}
fn wire(graph: ProceduralGraph, from: int, from_port: StringName, to: int, to_port: StringName) void { if graph.connect_nodes(from, from_port, to, to_port) != OK { push_error("Can't wire %s to %s" % [from_port, to_port]) }}# The village in a level, generated when the game starts.fn place_village(level: Spatial2D, graph: ProceduralGraph) ProceduralGenerator2D { generator : ProceduralGenerator2D = ProceduralGenerator2D.new() generator.bounds = Rect2(0, 0, 1600, 1600) generator.seed = 7 # Another seed: another village on the same roads. generator.generate_mode = ProceduralGenerator2D.GENERATE_ON_READY generator.graph = graph level.add_child(generator) return generator}Un mundo generado no gasta red: cada juego lo genera. Activa Use Online Seed en el generador:
- La semilla del mundo es Project Settings > Online > World > Seed (con Advanced Settings
activado, el interruptor que está arriba en la barra lateral de Project Settings). Con
0, el servidor elige una al azar y se la manda a cada jugador al entrar. Para un mundo que se guarda entre partidas (los árboles talados siguen talados), pon una semilla fija. - Online trata los prefabs con Online Mode (un árbol que todos pueden talar) como si
estuvieran colocados en el nivel. Sus nombres salen de su sitio y son iguales en todos los
juegos. El servidor los ejecuta y guarda sus
@persistent, y un jugador que genera uno le pide al servidor cómo está.Online.is_generated_object(nodo)los distingue. - En modo At Runtime, el servidor genera alrededor del personaje de cada jugador, y cada jugador alrededor de su cámara. Una celda que se quita solo quita sus objetos en ese juego.
- Cada jugador le dice al servidor lo que puso en cada celda (un hash de dónde están sus puntos). Si una celda le salió distinta, el servidor le manda lo que puso él y el jugador lo usa en vez de lo suyo. El azar de Gobu usa enteros para que todas las máquinas generen lo mismo, pero el punto flotante aún puede variar un pelo entre CPUs (x86, ARM, WebAssembly) y hacer que un punto pase un filtro.
- Un jugador con otro grafo (otra versión del juego) recibe un aviso: genera otro mundo (las celdas que comprueba con el servidor reciben las del servidor, si su grafo tiene los mismos spawners).
- Un grafo cuenta los prefabs, texturas, mallas y scripts que usa por su ruta: se convierten al exportar el juego, y así el editor y el juego exportado (Windows, la web) coinciden en el grafo. Un cambio dentro de un prefab no es otro grafo; las curvas, gradientes, ruidos, biomas y subgrafos cuentan por lo que tienen. En el editor, una textura o malla reimportada vuelve a generar.
3D: ProceduralGenerator3D
Sección titulada «3D: ProceduralGenerator3D»Los mismos grafos funcionan en 3D. Un ProceduralGenerator3D cubre una caja (Bounds, un AABB): su suelo es x, z y la y va hacia arriba. Los puntos de un sampler empiezan en el fondo de la caja, así que una caja de altura 0 es suelo plano (la caja amarilla del viewport 3D).

| Spawner | Qué pone |
|---|---|
| Spawn Meshes | una malla en cada punto, todas en unos pocos MultiMesh (uno por malla). Con Visibility Range, una celda lejana oculta todas sus mallas a la vez: un nivel de detalle por celda |
| Spawn Prefab | un prefab 3D en cada punto, girado y escalado como él |
| Spawn Entities | una entidad de ECS en cada punto, con su position en 3D |
| Spawn Grid Map | un objeto de la MeshLibrary de un GridMap en la celda de cada punto (o la celda vaciada), girado como él: el Spawn Tiles del 3D. Las celdas vuelven a como estaban |
| Spawn Curve | un Path3D que pasa por los puntos en orden |
| Spawn Grass | muchas briznas alrededor de cada punto, en una MultiMesh que rellena la GPU (ver abajo) |
Lo demás es igual que en 2D:
- los modos (In Editor, que se guarda con la escena, y At Runtime por celdas);
- los nodos ProceduralSource3D y la cámara como fuentes (en el editor, la vista previa sigue a la cámara 3D);
- Get Nodes (un grupo de nodos 3D);
- los cambios a mano: selecciona el generador y sus cosas tienen tiradores en el viewport 3D
(arrastra uno para moverlo por el suelo a su altura, Supr lo quita);
move_generatedrecibe un Vector3; - la red con la semilla del mundo.
# Un bosque 3D: árboles (un prefab) y rocas (una malla, en MultiMeshes) sobre el suelo de una caja de 512 x 512.fn make_world(trees: PackedScene, rock: Mesh) ProceduralGenerator3D { graph : ProceduralGraph = ProceduralGraph.new() scatter : ProceduralNodeAreaSampler = ProceduralNodeAreaSampler.new() scatter.spacing = 6.0 spawn_trees : ProceduralNodeSpawnPrefab = ProceduralNodeSpawnPrefab.new() spawn_trees.prefab = trees stones : ProceduralNodeGridSampler = ProceduralNodeGridSampler.new() stones.cell_size = Vector3(4, 4, 4) stones.jitter = 0.8 spawn_rocks : ProceduralNodeSpawnMeshes = ProceduralNodeSpawnMeshes.new() spawn_rocks.mesh = rock spawn_rocks.visibility_range = 150.0 # Las celdas lejanas ocultan sus rocas. wire(graph, graph.add_node(scatter), &"Out", graph.add_node(spawn_trees), &"In") wire(graph, graph.add_node(stones), &"Out", graph.add_node(spawn_rocks), &"In")
generator : ProceduralGenerator3D = ProceduralGenerator3D.new() generator.bounds = AABB(Vector3(0, 0, 0), Vector3(512, 0, 512)) generator.generate_mode = ProceduralGenerator3D.GENERATE_AT_RUNTIME # Celdas alrededor de la cámara. generator.cell_size = 64.0 generator.generation_radius = 160.0 generator.graph = graph return generator}
fn wire(graph: ProceduralGraph, from: int, from_port: StringName, to: int, to_port: StringName) void { if graph.connect_nodes(from, from_port, to, to_port) != OK { push_error("Can't wire %s to %s" % [from_port, to_port]) }}Hierba en la GPU
Sección titulada «Hierba en la GPU»Spawn Grass convierte unos pocos puntos en muchas briznas: cada punto recibe hasta Blades briznas repartidas por su huella (su caja en el suelo), tantas como dice su densidad, cada una girada y de un tamaño al azar. Van en una MultiMesh por celda. Con GPU activado, un compute shader del renderer la rellena a partir de los puntos: la CPU escribe 10.000 puntos, no medio millón de briznas. Sin él, la CPU la rellena con las mismas briznas, y la imagen es la misma.
# Grass on the ground of the scene: a point every metre, in patches (a noise), and up to 48 blades around# each one, put in a MultiMesh by the GPU. The blade comes from the scene, so exports bake its material.fn make_grass(blade: Mesh) ProceduralGraph { graph : ProceduralGraph = ProceduralGraph.new() ground : ProceduralNodeGetSurface = ProceduralNodeGetSurface.new() ground.group = &"ground" sampler : ProceduralNodeSurfaceSampler = ProceduralNodeSurfaceSampler.new() sampler.spacing = 1.0 patches : ProceduralNodeNoise = ProceduralNodeNoise.new() grass : ProceduralNodeSpawnGrass = ProceduralNodeSpawnGrass.new() grass.mesh = blade grass.blades = 48 # With density 1; 0.5 gives about 24. grass.gpu = true # false: the CPU fills the MultiMesh (the same blades). grass.visibility_range = 80.0 g : int = graph.add_node(ground) s : int = graph.add_node(sampler) n : int = graph.add_node(patches) b : int = graph.add_node(grass) wire(graph, g, &"Out", s, &"Surface") wire(graph, s, &"Out", n, &"In") wire(graph, n, &"Out", b, &"In") return graph}
fn wire(graph: ProceduralGraph, from: int, from_port: StringName, to: int, to_port: StringName) void { if graph.connect_nodes(from, from_port, to, to_port) != OK { push_error("Can't wire %s to %s" % [from_port, to_port]) }}En 100 x 100 m con un punto por metro (un juego exportado, release), colocar 264.000 briznas (48 por punto) cuesta unos 0,3 ms en la GPU y 23 ms en la CPU; 700.000 (128 por punto), 0,3 ms y 61 ms. Dibujarlas cuesta lo mismo de las dos maneras. En 2D (Texture) es igual, con un MultiMeshInstance2D.
El material de la brizna tiene que estar en un recurso del proyecto (una malla en una escena, un
.material) para que la exportación lo hornee.
Sobre el suelo de la escena: superficies
Sección titulada «Sobre el suelo de la escena: superficies»Un mundo 3D casi nunca es plano. Get Surface lee las mallas de la escena como una superficie (pines naranjas): los MeshInstance3D de un grupo, o un nodo y lo que tiene dentro. Después:
- Surface Sampler reparte puntos sobre ella. Cada punto queda en el sitio más alto sobre su
lugar en el suelo, con los atributos
normalyslope(grados). - Project to Surface pone sobre ella puntos cualesquiera (de un Grid Sampler, una curva, la escena), con un Offset sobre el suelo.
- Slope to Density convierte la pendiente en densidad: árboles en las laderas suaves, rocas en las empinadas.

Align to Normal gira cada punto como el suelo que tiene debajo. La semilla de un punto (y el nombre de lo que va ahí) sale de dónde está en el suelo, no de su altura, así que todas las máquinas lo nombran igual. Mover o cambiar una malla de la superficie vuelve a generar.
# Sobre un terreno (los MeshInstance3D del grupo "terrain"): árboles donde es suave, rocas donde es empinado.fn make_hillside(tree: Mesh, rock: Mesh) ProceduralGraph { graph : ProceduralGraph = ProceduralGraph.new() terrain : ProceduralNodeGetSurface = ProceduralNodeGetSurface.new() terrain.group = &"terrain" scatter : ProceduralNodeSurfaceSampler = ProceduralNodeSurfaceSampler.new() scatter.spacing = 5.0 gentle : ProceduralNodeSlopeToDensity = ProceduralNodeSlopeToDensity.new() gentle.max_slope = 25.0 # 1 en llano, 0 desde 25 grados. keep : ProceduralNodeDensityFilter = ProceduralNodeDensityFilter.new() keep.lower = 0.5 trees : ProceduralNodeSpawnMeshes = ProceduralNodeSpawnMeshes.new() trees.mesh = tree rocks : ProceduralNodeSpawnMeshes = ProceduralNodeSpawnMeshes.new() rocks.mesh = rock
g : int = graph.add_node(terrain) s : int = graph.add_node(scatter) d : int = graph.add_node(gentle) f : int = graph.add_node(keep) wire(graph, g, &"Out", s, &"Surface") wire(graph, s, &"Out", d, &"In") wire(graph, d, &"Out", f, &"In") wire(graph, f, &"Inside", graph.add_node(trees), &"In") wire(graph, f, &"Outside", graph.add_node(rocks), &"In") # Los empinados. return graph}
fn wire(graph: ProceduralGraph, from: int, from_port: StringName, to: int, to_port: StringName) void { if graph.connect_nodes(from, from_port, to, to_port) != OK { push_error("Can't wire %s to %s" % [from_port, to_port]) }}Lo que viene
Sección titulada «Lo que viene»Lo que falte del PCG de Unreal que pida un juego: dinos qué echas en falta.