Node Index

Area Nodes

Add Random Edges

Adds randomly picked edges from the set of provided edges to the area graph.

Port	Type	Description	Default value
In
Area Graph	AreaGraph	The area graph to randomly add edges to.	<required>
Edges	AreaGraphEdge[]	The set of edges to randomly pick from.	true
Percentage	float	The percentage of set of edges to use.	0
Min. Edges	int	The minimum number of edges to add.	<optional>
Max. Edges	int	The maximum number of edges to add.	<optional>
Out
Area Graph	AreaGraph	The area graph with randomly edges added.

Areas Centroid Points

Gets the center points from the given areas.

Port	Type	Description	Default value
In
Areas	Area[]	The areas to get the centroid points of.	<required>
Out
Centroid Points	Vector2Int[]	The set of centroid points of the given areas.

Areas Special Border Points

Gets the most top, left, right, bottom, top left, top right, bottom left and bottom right points for each area.

This can be useful for placing items or doors in certain parts of an area, for example.

Port	Type	Description	Default value
In
Areas	Area[]	The areas to get the special border points of.	<required>
Out
Top Left	Vector2Int[]	The set of the top left point for each area.
Top	Vector2Int[]	The set of the top point for each area.
Top Right	Vector2Int[]	The set of the top right point for each area.
Left	Vector2Int[]	The set of the left point for each area.
Right	Vector2Int[]	The set of the right point for each area.
Bottom Left	Vector2Int[]	The set of the bottom left point for each area.
Bottom	Vector2Int[]	The set of the bottom point for each area.
Bottom Right	Vector2Int[]	The set of the bottom right point for each area.
All	Vector2Int[]	The combined set of all the special border points.

Example of points from rectangular areas.

Example of points from more cave-like areas.

Connect Area Graph (Centroids)

Pairs the centroid positions of each connected area pair in an area graph.

Example usage: Pairing this node with a Draw Connections node to make sure that all areas of a map are connected.

Limitations: This node is not a good option for connecting areas that have a concave shape, as the centroid of a concave shape is not guaranteed to be inside of the shape itself.

Port	Type	Description	Default value
In
Area Graph	AreaGraph	The graph of connected areas to find centroid pairs for.	<required>
Out
Connected Points	Pair<Vector2Int>[]	A set of point pairs, where each point is the centroid of an area.

Connect Area Graph (Closest Border Points)

Pairs the closest border positions of each connected area pair in an area graph.

Example usage: Pairing this node with a Draw Connections node to make sure that all areas of a map are connected.

Port	Type	Description	Default value
In
Area Graph	AreaGraph	The graph of connected areas to find closest border point pairs for.	<required>
Out
Connected Points	Pair<Vector2Int>[]	A set of point pairs, where each point is the point on the area's border that's closest to the other area.

Connect Area Graph (Random Points)

Pairs random positions of each connected area pair in an area graph.

Example usage: Pairing this node with a Draw Connections node to make sure that all areas of a map are connected.

Port	Type	Description	Default value
In
Area Graph	AreaGraph	The graph of connected areas to find random point pairs for.	<required>
Out
Connected Points	Pair<Vector2Int>[]	A set of point pairs, where each point is a random point of the area it represents.

Extract Areas

Extracts areas of a certain color from a texture.

Example usage: Connecting this node with a Generate Area Graph, Connect Area Graph and a Draw Connections node, to make sure all areas in a map are reachable.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to extract areas from.	<required>
Color To Extract	Color32	Areas of this color will be extracted from the texture.	rgba(0,0,0,0)
Min. Area Size	int	If connected, areas consisting of less points than the given min. area size, will be omitted from the set outputted by the Areas out port.	<optional>
Max. Area Size	int	If connected, areas consisting of more points than the given max. area size, will be omitted from the set outputted by the Areas out port.	<optional>
Connect Diagonals?	bool	If set to true, pixels that are diagonal neighbours and are of the given color to extract, are considered to be part of the same area. If set to false, only pixels that are horizontal or vertical neighbours can be considered to be part of the same area.	false
Out
Areas	Area[]	The areas extracted from the texture.
Outer Areas	Area[]	A subset of the extracted areas, containing only the areas that are in contact with the texture's bounds.
Inner Areas	Area[]	A subset of the extracted areas, containing only the areas that aren't in contact with the texture's bounds.
Texture	TextureData	A texture that contains only the extracted areas.

Generate Area Graph

Generates a connected area graph from the given areas.

Example usage: Connecting this node with a Connect Area Graph and a Draw Connections node, to make sure all areas in a map are reachable.

Port	Type	Description	Default value
In
Areas	Area[]	The set of areas to create a connected graph for.	<required>
Out
Area Graph	AreaGraph	The connected area graph.

Generate Area Graph (Minimum)

Generates a minimum spanning tree area graph from the given connected area graph.

What this means, is that that it will basically remove any edges from the original graph that aren't necessary to keep all areas interconnected with each other, in such a way that the remaining edges have a total length that's as small as possible.

Example usage: Placing this node between a Generate Area Graph and Connect Area Graph node, to make sure there aren't more connections than necessary to connect all areas.

Port	Type	Description	Default value
In
Area Graph	AreaGraph	The area graph to create a MST area graph from.	<required>
Precise?	bool	If true, a precise check is used for determining which areas are closer together, based on comparing all their border points. It leads to more accurate results, but is way more expensive in terms of performance. If false, a simple check is used to compare the distance between centroids, which should be precise enough in most cases.	false
Out
MST Area Graph	AreaGraph	The MST area graph.
Unused Edges	AreaGraphEdge[]	The edges that are not used to connect the graph.

Generate Area Graph (Random)

Generates a random spanning tree area graph, using randomly picked edges.

It's similar to the Generate Area Graph (MST), but it provides a more random result, due to the fact that it's not guaranteed to have the smallest total edge length possible to connect the graph.

Port	Type	Description	Default value
In
Area Graph	AreaGraph	The area graph to create a RST area graph from.	<required>
Out
MST Area Graph	AreaGraph	The RST area graph.
Unused Edges	AreaGraphEdge[]	The edges that are not used to connect the graph.

Merge Areas

Merges two sets of areas into one. Any overlapping or neighbouring areas will be merged into a single area.

Port	Type	Description	Default value
In
Areas A	Area[]	The first set of areas to merge.	<required>
Areas B	Area[]	The second set of areas to merge.	<required>
Connect Diagonals?	bool	If set to true, area points that are diagonal neighbours are considered to be part of the same area. If set to false, only area points that are horizontal or vertical neighbours can be considered to be part of the same area.	false
Simple Merge?	bool	Enabling this will not merge any connected nodes together. Instead, it simply merges the two provided area arrays together as they are.	false
Out
Areas	Area[]	The merged set of areas.

Split Connections Manhattan

Takes a set of connections and splits any connections that aren't perfectly horizontal or vertical and splits them into two connections that do.

Port	Type	Description	Default value
In
Connected Points	Pair<Vector2Int>[]	The set of connections to split.	<required>
Out
Manhattan Connected Points	Pair<Vector2Int>[]	The split connections.
Horizontal Connections	Pair<Vector2Int>[]	The set of only the horizontal connections.
Vertical Connections	Pair<Vector2Int>[]	The set of only the vertical connections.

BSP Nodes

BSP Leaf Center Points

Gets the center points for each BSP leaf node.

Port	Type	Description	Default value
In
BSP Tree	BspTree	The BSP tree to extract the leafs' center points from.	<required>
Out
Center Points	Vector2Int[]	The set of center points of each leaf of the BSP tree.

Random BSP Rooms

Generates a room/rectangle within the bounds of each BSP leaf node.

Port	Type	Description	Default value
In
BSP Tree	BspTree	The BSP tree to create rooms from.	<required>
Margin	int	The minimal margin that should separate generated rooms.	0
Min. Room To Node Ratio	float	The minimal amount of space the room should take compared to the BSP node, in percentages. For example: if set to 50 the generated room will fill up at least 50% of the BSP node's space.	0
Max. Room To Node Ratio	float	The maximum amount of space the room should take compared to the BSP node, in percentages. For example: if set to 50 the generated room will fill up at most 50% of the BSP node's space.	<required>
Out
Rectangles	RectInt[]	The set of rectangles that represent the generated rooms.

Random BSP Tree

Generates a random binary space partitioning tree.

Port	Type	Description	Default value
In
Size	Vector2Int	The size of space the BSP tree should cover.	<required>
Min. Number of Divisions	int	The minimal number of times spaces should be divided. For example: if set to 2, spaces will be divided at least twice, the first division will split the space into two, the second division will split those two spaces into two each, resulting into a minimal total of 4 spaces.	0
Max. Number of Divisions	int	The maximum number of times spaces should be divided. For example: if set to 2, spaces will be divided at most twice, the first division will split the space into two, the second division will split those two spaces into two each, resulting into a maximum total of 4 spaces.	<required>
Min. Divide Offset Percentage	float	This determines where a space can be split, in percentages. For example: if set to 40, each time a space is divided, the maximum size difference is that one of the spaces will cover 40% of the parent space and the other will cover 60% of the parent space. Setting it to 30 will increase that size different to a 30%-70% split.	0
Out
BSP Tree	BspTree	The random BSP tree.

Color Nodes

Named Color

Provides a color from the graph's named color set, by the given name, selected through the dropdown field.

Port	Type	Description	Default value
Out
Color	Color32	The color that matches the selected name.

Replace Color

Replaces all pixels of one color with another color.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to replace a color on.	<required>
Find	Color32	The color to replace.	rgba(0,0,0,0)
Replace	Color32	The color to replace the "Find" color with.	rgba(0,0,0,0)
Out
Texture	TextureData	The texture with the Find color replaced with the Replace color.

Transparent Color

Provides a transparent color.

Port	Type	Description	Default value
Out
Transparent Color	Color32	The transparent color: rgba(0,0,0,0)

Constant Nodes

The constant node outputs a constant value that can be set in the graph editor.

Convert Nodes

Areas To Points

Outputs all the points that make up the given areas.

Example usage: Convert a set of areas to a set of points to use as input for nodes that expect a set of points instead of a set of areas.

Port	Type	Description	Default value
In
Areas	Area[]	The set of areas to convert to a set of points.	<required>
Out
Points	Vector2Int[]	The set of points that the areas contain.

Connected Points To Points

Unpairs the connected points and returns them in a single set, any duplicates are omitted.

Port	Type	Description	Default value
In
Connected Points	Pair<Vector2Int>[]	The connected points to convert to a set of points.	<required>
Out
Points	Vector2Int[]	The points.

Points To Areas

Converts a set of points into areas. Connected points will be added to the same area.

Port	Type	Description	Default value
In
Points	Vector2Int[]	The points to convert to areas.	<required>
Connect Diagonals?	bool	If true, points that are connected diagonally are considered to be part of the same area.	false
Single Point Areas?	bool	Enabling this will not merge any connected points together in the same area. Instead, it simply creates an area for each of the provided points.	false
Out
Areas	Area[]	The areas where each area contains a point.

Rectangles To Areas

Generates areas from a set of rectangles. Connecting or overlapping areas will be considered as part of the same area.

Port	Type	Description	Default value
In
Rectangles	RectInt[]	A set of rectangles to convert to areas.	<required>
Connect Diagonals?	bool	If true, rectangles that are connected diagonally are considered to be part of the same area.	false
Out
Areas	Area[]	A set of areas for each rectangle.

Drawing Nodes

Draw Areas

Draws the given areas in the specified color onto the texture.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw the areas on.	<required>
Areas	Area[]	The areas to draw.	<required>
Color	Color32	The draw color.	rgba(0,0,0,0)
Out
Texture	TextureData	The texture with the areas drawn.

Draw Border

Draws a border of the given color on the other edge of the texture.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to add a border to.	<required>
Width	int	The border's width.	1
Border Color	Color32	The border's color.	rgba(0,0,0,0)
Out
Texture	TextureData	The texture with the border drawn onto it.

Draw Circles

Draws circles around the provided center points.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw cicles on.	<required>
Center Points	Vector2Int[]	The points to used as the circle centers.	<required>
Radius	int	The circle radius.	<required>
Draw Color	Color32	The circle's color.	rgba(0,0,0,0)
Out
Texture	TextureData	The texture with the circles drawn onto it.

Draw Connections (Biased Random Walk)

Draws connections between each pair of points, using a biased random walk algorithm. This results into non-straight random paths between the connection points.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw the connections on.	<required>
Connected Points	Pair<Vector2Int>[]	Pairs of points to draw connections between.	<required>
Draw Color	Color32	The color used to draw the connections.	rgba(0,0,0,0)
Carve Radius	int	The width of the connection, or radius of the circle to carve with.	1
Direction Bias (%)	float	The bias the walk algorithm has towards its target point. 0% is no bias at all, meaning it will walk around the texture until it happens to run into the target point. 100% is complete bias, meaning it will walk towards the target point as quickly as possible.	50%
Randomness (%)	float	The chance the algorithm will prefer taking a (biased) random step towards its target point over moving to the best next point to get towards it target point. 0% will never prefer taking a random step, but will always pick the quickest way to the target position. 100% will always prefer taking a random step.	0%
Out
Texture	TextureData	The texture with the connections drawn onto it.

Draw Connections (Manhattan)

Draws connecting lines between each pair of points, using only horizontal and vertical lines.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw the connections on.	<required>
Connected Points	Pair<Vector2Int>[]	Pairs of points to draw connections between.	<required>
Draw Color	Color32	The color used to draw the connections.	rgba(0,0,0,0)
Connection Width	int	The thickness of the connection lines drawn.	1
Out
Texture	TextureData	The texture with the connections drawn onto it.

Draw Connections (Shortest Path)

Draws connecting lines between each pair of points.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw the connections on.	<required>
Connected Points	Pair<Vector2Int>[]	Pairs of points to draw connections between.	<required>
Draw Color	Color32	The color used to draw the connections.	rgba(0,0,0,0)
Width	int	The thickness of the connection lines drawn.	1
Out
Texture	TextureData	The texture with the connections drawn onto it.

Draw Grid

Draws grid lines onto a texture, the lines are seperated by cells of a given size.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw on.	<required>
Cell Size	Vector2Int	The size of the cells between the lines.	<required>
Line Width	int	The thickness of the lines drawn.	1
Color	Color32	The color to draw the lines with.	rgba(0,0,0,0)
Out
Texture	TextureData	The resulting texture.

Draw Noise Threshold

Draws the given color at each position that has an associated noise value above (or below) the given threshold.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw on.	<required>
Noise Data	float[]	The noise data.	<required>
Draw Color	Color32	The color to draw.	<required>
Threshold	float	The threshold value above (or below) which the point will be filled with the given color, in percentages. For example, if the threshold is set at 60% and the noise value for a particular point is above 0.6 it will be filled with the given color. If the noise value is below 0.6 it will keep its original color.	50
Below Threshold?	bool	If set to true, a color will be filled with the given color whenever the corresponding noise data is below the threshold instead of above.	false
Out
Texture	TextureData	The resulting texture.

Draw Outline

Draws outlines around colored areas (meaning the non-transparent parts).

Limitations: Outlines are drawn around opaque pixels. This means that if you want to draw colors around certain areas that are not surrounded by transparency, it won't work. To achieve this, you'll want to extract the color first using an Extract Color node and use that node's texture output to draw the outline on. You can then use the Stamp node to stamp the result on top of the original texture.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw outlines on.	<required>
Outline Color	Color32	The outline's color.	rgba(0,0,0,0)
Color To Outline	Color32	The color to outline. If not connected, all non-transparant points are outlined.	<Optional>
Overlap?	bool	If true, it draws an inline of the areas, meaning that it draws the "outline" on the inside of the colored areas.	false
Corners?	bool	If true, the corner points are drawn. If false, they are omitted. For example, this shape: ### If true, would be outlined like this: ***** *###* ***** If false, the outline would look like this: *** *###* ***	false
Width	int	The thickness of the drawn outline.	1
Width Top	int	The thickness of the top part of the outline.	Width
Width Bottom	int	The thickness of the bottom part of the outline.	Width
Width Left	int	The thickness of the left part of the outline.	Width
Width Right	int	The thickness of the right part of the outline.	Width
Out
Texture	TextureData	The texture with the connections drawn onto it.

Draw Points

Applies the color to the given pixel positions.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw the points on.	<required>
Draw Color	Color32	The color to draw the points with.	rgba(0,0,0,0)
Points	Vector2Int[]	The set of points to draw onto the texture.	<required>
Out
Texture	TextureData	The texture with the points drawn onto it.

Draw Rectangles

Draws rectangles on the texture in the specified color.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to draw the rectangles on.	<required>
Rectangles	RectInt[]	The set of rectangles to draw onto the texture.	<required>
Draw Color	Color32	The color to draw the rectangles with.	rgba(0,0,0,0)
Outline Only?	bool	If true, only the rectangle outlines will be drawn. If false, the rectangles will be drawn filled.	false
Out
Texture	TextureData	The texture with the rectangles drawn onto it.

Stamp

Stamps one texture on top of another.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to stamp on.	<required>
Stamp	TextureData	The texture to stamp with.	<required>
Offset	Vector2Int	The offset where the origin of the stamp is with respect to that of the target texture.	0,0
Out
Texture	TextureData	The texture with the stamp texture drawn on top of it.

GameObject Nodes

Replace GameObject Children

Destroys all existing children from the parent and adds the provided children.

This is used for adding generated GameObjects (the children) to a container GameObject (the parent).

Port	Type	Description	Default value
In
Parent	GameObject	The gameobject to become the parent of the Children.	<required>
Children	GameObject[]	The objects to add as children to the Parent object.	<required>
Use XZ Plane	bool	If set to true, the generated game objects will be placed on the XZ plane, instead of the default XY.	false

Texture To Child GameObjects

Generates the GameObjects from the prefab set, based on the texture. Then it places them in the scene under the parent object. Any objects under the parent object are removed.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to convert to prefabs.	<required>
Prefab Set	PrefabSet	The set containing the prefabs to generate.	<required>
Parent	GameObject	The parent gameobject.	<required>
Depth Data	float[]	If set, the placement of each generated object is offset on the Z-axis based on the corresponding entry in this array. This should contain a float for every pixel in the texture, normalized between 0 and 1. If Use ZX Plane is set to true, the offset is applied on the Y-axis and it's basically height data instead.	<optional>
Depth Layers	int	Setting this scales the given depth data, creating a more pronounced offset. A single layer is the same depth as the prefab set's prefab depth. For example, if the prefab depth is set to 1.5 and there are 4 layers, the total depth range is 6 units. If Use ZX Plane is set to true, the prefab height is used as a layer's height.	<optional>
Depth Layer Size	int	The size (height/depth) of each layer in relation to the prefab set's prefab depth/height. Where 1 is the same size as the prefab depth/height, 0.5 half and 2 double.	<optional>
Depth Snap To Layers	bool	Setting this to true, snaps generated objects to their closest layer. For example, if the calculated Z coordinate for a gameobject is 1.6 and a layer is 1.5 units deep, the Z coordinate will be set to 1.5.	<optional>
Use XZ Plane	bool	If set to true, the generated game objects will be placed on the XZ plane, instead of the default XY.	false

Texture To GameObjects

Generates the GameObjects from the prefab set, based on the texture.

Please note: Unlike the Replace GameObject Children node, Texture To GameObjects doesn't assign the GameObjects it generates to the scene and only exist in the array. Since this is technically not actually possible (in Unity a GameObject cannot exist outside a scene), the GameObjects are added temporarily to the scene and are destroyed after the graph is done being processed, resulting in any references to those GameObjects being null now.

In order to keep to those GameObjects around after processing of the Graph has finished, they need to be explicitly added to the scene using a Replace GameObject Children or your own custom node. For the latter, please note that any GameObjects generated by the Texture To GameObjects node are marked to be destroyed, even if you explicitly assign them to the scene with a node of your own. So make sure you add clones of those GameObjects to the scene instead.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to convert to prefabs.	<required>
Prefab Set	PrefabSet	The set containing the prefabs to generate.	<required>
Depth Data	float[]	If set, the placement of each generated object is offset on the Z-axis based on the corresponding entry in this array. This should contain a float for every pixel in the texture, normalized between 0 and 1.	<optional>
Depth Layers	int	Setting this scales the given depth data, creating a more pronounced offset. A single layer is the same depth as the prefab set's prefab depth. For example, if the prefab depth is set to 1.5 and there are 4 layers, the total depth range is 6 units.	<optional>
Depth Layer Size	int	The size (height/depth) of each layer in relation to the prefab set's prefab depth/height. Where 1 is the same size as the prefab depth/height, 0.5 half and 2 double.	<optional>
Depth Snap To Layers	bool	Setting this to true, snaps generated objects to their closest layer. For example, if the calculated Z coordinate for a gameobject is 1.6 and a layer is 1.5 units deep, the Z coordinate will be set to 1.5.	<optional>
Out
GameObjects	GameObject[]	The gameobjects generated from the prefabs.

Mask Nodes

Apply Mask

Applies a mask to a texture, meaning that it replaces colors with transparency if their position is masked.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to apply the mask to.	<required>
Mask	Mask	The Mask to apply to the Texture.	<required>
Out
Texture	TextureData	The texture with masked points replaced with transparency.

Invert Mask

Inverts the given mask, meaning that the unmasked points of the given mask are masked points in the inverted mask.

Port	Type	Description	Default value
In
Mask	Mask	The mask to invert.	<required>
Bounds	Vector2Int	The mask's bounds. These bounds are necessary, because a mask only contains data about unmasked points. So when you invert the mask, all the unmasked points will become masked points and all the other points within the given bounds are the unmasked points of the new mask.	<required>
Out
Inverted Mask	Mask	The inverted mask.

Merge Masks

Merges two masks together into a single mask.

The resulting mask has the combined masked points of Mask A and Mask B.

Port	Type	Description	Default value
In
Mask A	Mask	One of the masks to merge.	<required>
Mask B	Mask	The second of the masks to merge.	<required>
Out
Merged Mask	Mask	The merged mask.

Subtract Mask

Subtracts the masked points of Mask B from Mask A.

Port	Type	Description	Default value
In
Mask	Mask	The mask to subtract the other mask from.	<required>
Subtract	Mask	The mask to subtract.	<required>
Bounds	Vector2Int	The mask's bounds.	<required>
Out
Mask	Mask	The mask masking the same points as Mask A minus the points of Mask B.

Texture To Mask

Create a mask from the texture. Any non-transparent pixels will be considered to be masked.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to apply the mask to.	<required>
Inverse?	bool	The Mask to apply to the Texture.	false
Out
Mask	Mask	The resulting mask, where the opaque points are considered to be masked.

Math Nodes

Addition

Add (Float)

Adds B to A.

Port	Type	Description	Default value
In
A	float		<required>
B	float		<required>
Out
Result	float	The result.

Add (Int)

Adds B to A.

Port	Type	Description	Default value
In
A	int		<required>
B	int		<required>
Out
Result	int	The result.

Add Float To Vector2

Adds B to all components of A.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	float		<required>
Out
Result	Vector2	The result.

Add Float To Vector3

Adds B to all components of A.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	float		<required>
Out
Result	Vector3	The result.

Add Int To Vector2Int

Adds B to all components of A.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	int		<required>
Out
Result	Vector2Int	The result.

Add Int To Vector3Int

Adds B to all components of A.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	int		<required>
Out
Result	Vector3Int	The result.

Add (Vector2Int)

Adds B to A.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	Vector2Int		<required>
Out
Result	Vector2Int	The result.

Add (Vector2)

Adds B to A.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	Vector2		<required>
Out
Result	Vector2	The result.

Add (Vector3Int)

Adds B to A.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	Vector3Int		<required>
Out
Result	Vector3Int	The result.

Add (Vector3)

Adds B to A.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	Vector3		<required>
Out
Result	Vector3	The result.

Clamping

Clamp (Float)

Clamps the value between the min. and max. value. This means that any value below the min. value will be set to the min. value and any value above the max. value will be set to the max. value.

Port	Type	Description	Default value
In
Value	float		<required>
Min	float	The clamping lower bound.	<required>
Max	float	The clamping upper bound.	<required>
Out
Result	float	The clamped result.

Clamp (Int)

Clamps the value between the min. and max. value. This means that any value below the min. value will be set to the min. value and any value above the max. value will be set to the max. value.

Port	Type	Description	Default value
In
Value	int		<required>
Min	int	The clamping lower bound.	<required>
Max	int	The clamping upper bound.	<required>
Out
Result	int	The clamped result.

Division

Divide (Float)

Divides A by B.

Port	Type	Description	Default value
In
A	float		<required>
B	float		<required>
Out
Result	float	The result.

Divide (Int)

Divides A by B.

Port	Type	Description	Default value
In
A	int		<required>
B	int		<required>
Out
Result	int	The result.

Divide Vector2 By Float

Divides all components of A by B.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	float		<required>
Out
Result	Vector2	The result.

Divide Vector3 By Float

Divides all components of Vector3 A by float B.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	float		<required>
Out
Result	Vector3	The result.

Divide Vector2Int By Int

Divides all components of A by B.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	int		<required>
Out
Result	Vector2Int	The result.

Divide Vector3Int By Int

Divides all components of A by B.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	int		<required>
Out
Result	Vector3Int	The result.

Divide (Vector2Int)

Divides A by B.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	Vector2Int		<required>
Out
Result	Vector2Int	The result.

Divide (Vector2)

Divides A by B.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	Vector2		<required>
Out
Result	Vector2	The result.

Divide (Vector3Int)

Divides A by B.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	Vector3Int		<required>
Out
Result	Vector3Int	The result.

Divide (Vector3)

Divides A by B.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	Vector3		<required>
Out
Result	Vector3	The result.

Max

Max (Float)

Picks the highest of the two numbers and outputs it.

Port	Type	Description	Default value
In
A	float		<required>
B	float		<required>
Out
Result	float	The result.

Max (Int)

Picks the highest of the two numbers and outputs it.

Port	Type	Description	Default value
In
A	int		<required>
B	int		<required>
Out
Result	int	The result.

Min

Min (Float)

Picks the lowest of the two numbers and outputs it.

Port	Type	Description	Default value
In
A	float		<required>
B	float		<required>
Out
Result	float	The result.

Min (Int)

Picks the lowest of the two numbers and outputs it.

Port	Type	Description	Default value
In
A	int		<required>
B	int		<required>
Out
Result	int	The result.

Multiplication

Multiply (Float)

Multiplies A by B.

Port	Type	Description	Default value
In
A	float		<required>
B	float		<required>
Out
Result	float	The result.

Multiply (Int)

Multiplies A by B.

Port	Type	Description	Default value
In
A	int		<required>
B	int		<required>
Out
Result	int	The result.

Multiply Vector2 By Float

Multiplies all components of A by B.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	float		<required>
Out
Result	Vector2	The result.

Multiply Vector3 By Float

Multiplies all components of Vector3 A by float B.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	float		<required>
Out
Result	Vector3	The result.

Multiply Vector2Int By Int

Multiplies all components of A by B.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	int		<required>
Out
Result	Vector2Int	The result.

Multiply Vector3Int By Int

Multiplies all components of A by B.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	int		<required>
Out
Result	Vector3Int	The result.

Multiply (Vector2Int)

Multiplies A by B.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	Vector2Int		<required>
Out
Result	Vector2Int	The result.

Multiply (Vector2)

Multiplies A by B.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	Vector2		<required>
Out
Result	Vector2	The result.

Multiply (Vector3Int)

Multiplies A by B.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	Vector3Int		<required>
Out
Result	Vector3Int	The result.

Multiply (Vector3)

Multiplies A by B.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	Vector3		<required>
Out
Result	Vector3	The result.

Power

Outputs Value to the power of Power.

Port	Type	Description	Default value
In
Value	float		<required>
Power	float		<required>
Out
Result	float	The result.

Square Root

Outputs the square root of Value.

Port	Type	Description	Default value
In
Value	float		<required>
Out
Result	float	The result.

Subtraction

Subtract (Float)

Subtracts B from A.

Port	Type	Description	Default value
In
A	float		<required>
B	float		<required>
Out
Result	float	The result.

Subtract (Int)

Subtracts B from A.

Port	Type	Description	Default value
In
A	int		<required>
B	int		<required>
Out
Result	int	The result.

Subtract Float From Vector2

Subtracts B from all components of A.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	float		<required>
Out
Result	Vector2	The result.

Subtract Float From Vector3

Subtracts B from all components of A.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	float		<required>
Out
Result	Vector3	The result.

Subtract Int From Vector2Int

Subtracts B from all components of A.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	int		<required>
Out
Result	Vector2Int	The result.

Subtract Int From Vector3Int

Subtracts B from all components of A.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	int		<required>
Out
Result	Vector3Int	The result.

Subtract (Vector2Int)

Subtracts B from A.

Port	Type	Description	Default value
In
A	Vector2Int		<required>
B	Vector2Int		<required>
Out
Result	Vector2Int	The result.

Subtract (Vector2)

Subtracts B from A.

Port	Type	Description	Default value
In
A	Vector2		<required>
B	Vector2		<required>
Out
Result	Vector2	The result.

Subtract (Vector3Int)

Subtracts B from A.

Port	Type	Description	Default value
In
A	Vector3Int		<required>
B	Vector3Int		<required>
Out
Result	Vector3Int	The result.

Subtract (Vector3)

Subtracts B from A.

Port	Type	Description	Default value
In
A	Vector3		<required>
B	Vector3		<required>
Out
Result	Vector3	The result.

Parameter Nodes

Input parameters

An input node is used to output the value of an associated input parameter.

Output parameters

The output node is used to take a value from the script graph and output it as part of the return value when done processing the script graph.

Path Nodes

A-star Paths

Creates paths for each connected pair, using an A-star algorithm.

Please note: This node can fail to produce a result for one more connections, if a mask is provided. It's up to the creator of the graph to make sure that if a mask is passed, that it never blocks the generation of valid paths, or make sure that that isn't a problem to create a valid end result. In the latter case it's necessary to set the "Continue On Failure?" port to true, otherwise the node will log an error when a path cannot be found and the node will stop processing.

Port	Type	Description	Default value
In
Connected Points	Pair<Vector2Int>[]	The set of connected points to create paths for.	<required>
Bounds	Vector2Int	The bounds within the connected points exist. (Usually this would be the size of the texture the connected points are extracted from.)	<required>
Mask	Mask	Any masked points are considered not-traversable by the A-star pathfinding.	<optional>
Hex Support?	bool	Enable this to ensure correct connections on a hex grid, without any gaps.	false
Continue On Failure?	bool	If false, an error is logged each time a valid path cannot be found for a connection. If true, this is considered a valid result and no error is logged.	false
Out
Paths	Vector2Int[][]	A set of points for each pair of connected points that forms a path between the points.

Draw Paths

Draw a set of paths onto a texture.

Port	Type	Description	Default value
In
Texture/td>	TextureData	The texture to draw the paths on.	<required>
Paths/td>	Vector2Int[][]	The paths to draw.	<required>
Draw Color/td>	Color32	Color to draw the paths with.	rgba(0,0,0,0)
Out
Texture	TextureData	The texture with paths drawn.

Line Paths

Creates straight line paths for each pair of connected points.

Port	Type	Description	Default value
In
Connected Points	Pair<Vector2Int>[]	The set of connected points to create paths for.	<required>
Bounds	Vector2Int	The bounds within the connected points exist. (Usually this would be the size of the texture the connected points are extracted from.)	<required>
Hex Support?	bool	Enable this to ensure correct connections on a hex grid, without any gaps.	false
Out
Paths	Vector2Int[][]	A set of points for each pair of connected points that forms a path between the points.

Merge Paths

Takes a set of two paths and puts them together into a single set.

Port	Type	Description	Default value
In
Path A	Vector2Int[][]	Set A to merge with set B.	<required>
Path B	Vector2Int[][]	Set B to merge with set A.	<required>
Out
Paths	Vector2Int[][]	The merged set containing both paths from set A and set B.

Random Walker Paths

Creates paths for each connected pair, using a random walker.

Port	Type	Description	Default value
In
Connected Points	Pair<Vector2Int>[]	The set of connected points to create paths for.	<required>
Bounds	Vector2Int	The bounds within the connected points exist. (Usually this would be the size of the texture the connected points are extracted from.)	<required>
Direction Bias (%)	float	The bias the walk algorithm has towards its target point. 0% is no bias at all, meaning it will walk around the texture until it happens to run into the target point. 100% is complete bias, meaning it will walk towards the target point as quickly as possible.	50%
Randomness (%)	float	The chance the algorithm will prefer taking a (biased) random step towards its target point over moving to the best next point to get towards it target point. 0% will never prefer taking a random step, but will always pick the quickest way to the target position. 100% will always prefer taking a random step.	0%
Mask	Mask	Any masked points are considered not-traversable by the A-star pathfinding.	<optional>
Hex Support?	bool	Enable this to ensure correct connections on a hex grid, without any gaps.	false
Continue On Failure?	bool	If false, an error is logged each time a valid path cannot be found for a connection. If true, this is considered a valid result and no error is logged.	false
Out
Paths	Vector2Int[][]	A set of points for each pair of connected points that forms a path between the points.

Point Nodes

Corner Points

Finds corner points out of the set of points and outputs those points.

A corner point is defined as a point in the set of input points that has at least one diagonal neighbour point that isn't in the set of input points and the two neighbour points they share are either both in the input set or neither of them are.

Port	Type	Description	Default value
In
Points	Vector2Int[]	The set of points to get corner points from.	<required>
Out
Corner Points	Vector2Int[]	A subset of Points that are considered to be corner points.

Extract Points

Extracts all points of a given color.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to extract the points from.	<required>
Color To Extract	Color32	The color to extract.	<required>
Out
Points	Vector2Int[]	The extracted points.

Extract Points With Neighbours

Extracts points that have neighbours with a given color.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to extract points from.	<required>
Extract Color	Color32	The color to extract.	<required>
Neighbour Color	Color32	The color the neighbours should (or shouldn't) for the point to be extracted.	<required>
Left?	bool	If true, points with the Extract Color need to have a left neighbour with the Neighbour Color, for it to be extracted.	false
Right?	bool	If true, points with the Extract Color need to have a right neighbour with the Neighbour Color, for it to be extracted.	false
Top?	bool	If true, points with the Extract Color need to have a top neighbour with the Neighbour Color, for it to be extracted.	false
Bottom?	bool	If true, points with the Extract Color need to have a bottom neighbour with the Neighbour Color, for it to be extracted.	false
Inverse?	bool	If true, it inverses the meaning of the other boolean ports. Meaning that if "Left?" is set to true, for example, only points with a left neighbour that don't match the Neighbour Color will be extracted.	false
Out
Points	Vector2Int[]	The extracted points.

Merge Points

Merges two arrays of points together into a single set.

Port	Type	Description	Default value
In
Points A	Vector2Int[]	Set of points to merge with Points B.	<required>
Points B	Vector2Int[]	Set of points to merge with Points A.	<required>
Out
Points	Vector2Int[]	A set of points consisting of points that are either part of Points A or Points B.

Merge Point Pairs

Merges two arrays of points pairs together into a single set.

Port	Type	Description	Default value
In
Point Pairs A	Pair<Vector2Int>[]	Set of points pairs to merge with Point Pairs B.	<required>
Point Pairs B	Pair<Vector2Int>[]	Set of points pairs to merge with Point Pairs A.	<required>
Out
Point Pairs	Pair<Vector2Int>[]	A set of point pairs consisting of point pairs that are either part of Points A or Points B.

Random Points

Provides a set of random points within the given bounds.

Port	Type	Description	Default value
In
Bounds	Vector2Int	The bounds from which the random points are picked.	<required>
Mask	Mask	If set, the points masked will be excluded from the set of possible random points.	<optional>
Percentage	float	The percentage of random points to pick from the set of possible points. For example, if set to 50, half of the possible points are picked at random.	<required>
Max. placements	int	If set, only this number of points will be picked.	<optional>
Out
Points	Vector2Int[]	A set of random points.
Mask	Mask	A mask, masking the random points. It's merged with the input mask, if one is set.

Random Points Per Area

Provides a set of random points. For each area, a number of points per area is picked to add to the output.

Port	Type	Description	Default value
In
Areas	Area[]	The areas to pick points from.	<required>
Points Per Area	int	The number of points to pick from each area.	<required>
Out
Points	Vector2Int[]	The set of random points.

Random Nodes

Random Bool

Outputs random boolean value.

Port	Type	Description	Default value
In
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	bool	The random boolean value.

Random Color

Outputs a random color.

Port	Type	Description	Default value
In
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	Color32	The random Color value.

Random Float

Outputs a random float value.

Port	Type	Description	Default value
In
Min.	float	The minimum value of the range to pick a random float from.	0
Max.	float	The maximum value of the range to pick a random float from.	0
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	float	The random float value.

Random Int

Outputs a random integer value.

Port	Type	Description	Default value
In
Min.	int	The minimum value of the range to pick a random integer from.	0
Max.	int	The maximum value of the range to pick a random integer from.	0
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	int	The random integer value.

Random Vector2Int

Outputs a random Vector2Int value.

Port	Type	Description	Default value
In
Min.	Vector2Int	The minimum value of the range to pick a random Vector2Int from.	0,0
Max.	Vector2Int	The maximum value of the range to pick a random Vector2Int from.	0,0
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	Vector2Int	The Vector2Int integer value.

Random Vector2

Outputs a random Vector2 value.

Port	Type	Description	Default value
In
Min.	Vector2	The minimum value of the range to pick a random Vector2 from.	0,0
Max.	Vector2	The maximum value of the range to pick a random Vector2 from.	0,0
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	Vector2	The random Vector2 value.

Random Vector3Int

Outputs a random Vector3Int value.

Port	Type	Description	Default value
In
Min.	Vector3Int	The minimum value of the range to pick a random Vector3Int from.	0,0,0
Max.	Vector3Int	The maximum value of the range to pick a random Vector3Int from.	0,0,0
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	Vector3Int	The random Vector3Int value.

Random Vector3

Outputs a random Vector3 value.

Port	Type	Description	Default value
In
Min.	Vector3	The minimum value of the range to pick a random Vector3 from.	0,0,0
Max.	Vector3	The maximum value of the range to pick a random Vector3 from.	0,0,0
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	Vector3	The random Vector3 value.

Random RNG State

Outputs a random RNG state.

Port	Type	Description	Default value
In
Constant?	bool	If true, the random value will be consistent for each connected in port. If false, the random value will be different for each connected in port.	false
Out
Value	RngState	The random RNG state.

Rectangle Nodes

Random Rectangles

Creates random rectangles within the given bounds.

Port	Type	Description	Default value
In
Size	Vector2Int	The bounds between which the rectangles should be generated.	<required>
Mask	Mask	A mask where rectangles should not be placed.	<optional>
Min. Fill Percentage	float	How much of the bounds should min. be filled with rectangles, in percentages.	0
Max. Fill Percentage	float	How much of the bounds should max. be filled with rectangles, in percentages.	100
Max. Rectangles	int	The max. number of rectangles that should be placed.	<optional>
Min. Width	int	The minimum width of each rectangle.	0
Max. Width	int	The maximum width of each rectangle.	0
Min. Height	int	The minimum height of each rectangle.	0
Max. Height	int	The maximum height of each rectangle.	0
Overlap?	bool	If set to true, rectangles can be placed to overlap each other.	false
Out
Rectangles	RectInt[]	The set of random rectangles.
Mask	Mask	A mask, masking all the points occupied by the random rectangles. It's merged with the input mask, if one is set.

Rectangle Center Points

Gets the center points from rectangles.

Limitations: The center points aren't when the dimensions of a rectangle are even, due to the fact we're working with integers.

Port	Type	Description	Default value
In
Rectangles	RectInt[]	The set of rectangles to extract the center points from.	<required>
Out
Center Points	Vector2Int[]	The (approximate) center points of the given rectangles.

Texture Nodes

Cellular Automata Smoothing

Applies cellular automata smoothing on the provided texture.

Example use: Pair with a Randomly Fill Texture node to create cave-like structures.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to apply the cellular automata smoothing to.	<required>
Number of Passes	int	The number of times the smoothing should be applied to the texture. A higher number will result in a smoother result, but will also increase the performance cost.	<required>
Fill Color	Color32	The color used for the filled pixels (or "alive cells").	rgba(0,0,0,0)
Empty Color	Color32	The color used for the empty pixels (or "dead cells").	rgba(0,0,0,0)
Out
Texture	TextureData	The smoothed texture.

Change Texture Size

Resizes a texture to the given size. Similar to the Resize Texture node, but instead of passing the new size, you pass the change in size.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to resize.	<required>
Size Change	Vector2Int	The amount to increase (or decrease if it's a negative value) the texture's size with.	<required>
Out
Texture	TextureData	The resized texture.

Current Or Empty Texture

Variant of the Empty Texture node. If a texture is provided, it simply pass it through the Texture out port. Otherwise it provides an empty texture filled with the provided color (transparent if none provided) of the given size.

Port	Type	Description	Default value
In
Texture	TextureData	The current texture to pass.	<required, if Size is not provided.>
Size	Vector2Int	The desired size of the new texture.	<required, if Texture is not provided.>
Default Color	Color32	The color to fill all the pixels with.	rgba(0,0,0,0)
Mask	Mask	Masked points will not be filled and will remain transparent.	<optional>
Out
Empty Texture	TextureData	The new texture.

Data To Texture

Converts a MapGraph TextureData object to a Texture2D object.

Map Graph works with its own TextureData object, to avoid some of the limitations that come with working on a Texture2D object directly. This node can be used to convert TextureData back into a Texture2D object, to pass through an output parameter, for example.

Port	Type	Description	Default value
In
Data	TextureData	The TextureData object to convert to a Texture2D.	<required>
Out
Texture	Texture2D	The resulting Texture2D object.

Empty Texture

Provides an empty texture filled with the provided color (transparent if none provided) of the given size.

Port	Type	Description	Default value
In
Size	Vector2Int	The desired size of the new texture.	<required>
Default Color	Color32	The color to fill all the pixels with.	rgba(0,0,0,0)
Mask	Mask	Masked points will not be filled and will remain transparent.	<optional>
Out
Empty Texture	TextureData	The new texture.

Extract Color

Extracts the given color from the provided texture and outputs a texture with only that color. In addition, a mask is outputted that masks all the points that have that color.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to extract the color from.	<required>
Color To Extract	Color32	The color to extract from the provided texture.	rgba(0,0,0,0)
Out
Texture	TextureData	The texture with the extract color.
Mask	Mask	Mask that masks all the points with the color to extract.

Flip Texture

Flips the given texture on the X and/or Y axis.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to flip.	<required>
Horizontal	bool	Whether to flip the texture horizontally.	false
Vertical	bool	Whether to flip the texture vertically.	false
Out
Texture	TextureData	The flipped texture.

Perlin Noise Fill Texture

Fills the texture with a random Perlin noise pattern.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to add perlin noise to.	<required>
Mask	Mask	Mask containing points not to fill.	<optional>
Filled Color	Color32	The color to fill pixels with that have a perlin noise value higher than the set threshold. If not assigned, the original color will be kept intact for these pixels.	<optional>
Empty Color	Color32	The color to fill pixels with that have a perlin noise value lower than the set threshold. If not assigned, the original color will be kept intact for these pixels.	<optional>
Scale	float	The scale of the perlin noise pattern. The result will look more "zoomed out" the higher the value is.	1
Points Per Unit	Vector2Int	If a PPU is set, the PPU will be used to normalized point coordinates, instead of the texture's dimensions. Basically, this is an alternative way to scale the output, giving a consistent scale independent of the texture dimensions.	<optional>
Threshold	float	Determines which parts of the pattern will be consider filled and which parts will be considered empty. Every pixel with a noise value above this value, will be considered filled. The rest will be considered empty. This value is in percentages, 0 being the lowest possible threshold and 100 being the heighest.	50
Coordinates	Vector2Int	Get the noise based on this position. Useful if you want to be able to generate chunks that neatly fit together.	0,0
RNG State	RngState	Passing a RNG state to this node, will get random values based on that RNG State, instead the graph assigned RNG state. Useful if you want to be able to generate chunks that neatly fit together.	<optional>
Out
Texture	TextureData	The texture with perlin noise added to it.
Mask	Mask	Mask that's masking all the non-transparent points drawn by this node, plus the points masked by the input mask (if set).
Noise Data	float[]	The random noise value for each position between 0.0 and 1.0.

Random Walker

Uses a random walk algorithm to draw a random pattern onto a texture.

The random walk starts at a given point and moves into a random direction (up, down, left or right). It will do the same from the next point and will repeat this step until the fill percentage has been reached. The walker doesn't move to points it has already visited. If it gets stuck (meaning either the neighbouring points have already been visited or lay outside of the texture's bounds), a border point of the area made up by visited points will be found on the that still has valid neighbours and the walk will continue from there.

Limitations: The walker tends to get slower as the fill percentage gets higher, due to the fact that it will spent more time finding the next valid point as the number of possible valid points gets smaller.

Example usage: This is a great way to generate a path/pattern that's guaranteed to consist of a single area (meaning it's all connected).

Port	Type	Description	Default value
In
Texture	TextureData	The texture to randomly fill.	<required>
Fill Percentage	float	The percentage of the texture that should be filled with the given color.	0
Start	Vector2Int	Point to start walking from.	The default start point will be the center of the texture, where x = width / 2 and y = height / 2.
Color	Color32	The color to draw with.	rgba(0,0,0,0)
Carve Radius	int	The width of the connection, or radius of the circle to carve with.	1
Out
Texture	TextureData	The texture after the random walker has .

Randomly Fill Texture

Randomly fills pixels with the given color.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to randomly fill.	<required>
Mask	Mask	A mask, to mask off positions from being filled.	<optional>
Fill Percentage	float	The percentage of the texture that should be filled with the given color.	100 if Max. placements is connected, 0 otherwise.
Draw Color	Color32	The color to randomly fill the texture with.	rgba(0,0,0,0)
Min. placements	int	The minimum number of pixels to fill.	<optional>
Max. placements	int	The maximum number of pixels to fill.	<optional>
Out
Texture	TextureData	The randomly filled texture.
Mask	Mask	A mask with the randomly filled points masked off, merged with the input masked if assigned.
Placements	Vector2Int[]	The set of points that have been filled.

Resize Texture

Resizes a texture to the given size.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to resize.	<required>
Size	Vector2Int	The texture's new size	<required>
Out
Texture	TextureData	The resized texture.

Rotate Texture

Rotates the texture around a point.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to rotate.	<required>
Angle	float	The number of degrees to rotate the texture.	<required>
Rotate Around	Vector2	The rotate around point is the center of the texture, defined as x = (width - 1) / 2 and y = (height -1) / 2.	false
Out
Texture	TextureData	The rotated texture.

Scale Texture

Scales the texture by the given ratio.

Example usage: This node can be useful for working with tilemaps of different sizes, for example.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to scale.	<required>
Scale	float	The factor to scale the texture by. 2 would double its size, where 0.5 would half it.	<required>
Out
Texture	TextureData	The scaled texture.

Scale Texture (Vector2)

Scales the texture by the given ratio. Similar to the Scale Texture node, but supports different scales for width (x) and height (y).

Port	Type	Description	Default value
In
Texture	TextureData	The texture to scale.	<required>
Scale	Vector2Int	The factor to scale the texture by. 2 would double its size, where 0.5 would half it. X is the scale factor for width. Y is the scale factor for height.	<required>
Out
Texture	TextureData	The scaled texture.

Scale Texture To

Scales the texture to the given size.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to scale.	<required>
Target Size	Vector2Int	The size to scale to.	<required>
Out
Texture	TextureData	The scaled texture.

Shift Texture

Moves all the pixels inside the texture by the given amount inside the texture. Pixels that would "fall off" will be placed move onto the other side of the texture.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to shift.	<required>
Shift By	Vector2Int	The amount to move each pixel by.	<required>
Out
Texture	TextureData	The texture after its pixels have been shifted.

Texture Size

Outputs the texture's width and height.

This can be useful to be able to get after scaling a texture, for example.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to get the size of.	<required>
Out
Size	Vector2Int	The texture's size.

Texture To Data

Converts a Texture2D to a TextureData object.

Map Graph works with its own TextureData object, to avoid some of the limitations that come with working on a Texture2D object directly.

Example use: Converting a Texture2D passed through an input parameter.

Port	Type	Description	Default value
In
Texture	Texture2D	The Texture2D object to convert to a TextureData object.	<required>
Out
Data	TextureData	The TextureData object.

Waveform Function Collapse

Generates a texture of specified size that is locally similar to a training sample texture.

You can check out the original algorithm here: https://github.com/mxgmn/WaveFunctionCollapse

Or an (easier to understand) explanation here: https://www.procjam.com/tutorials/wfc/

Port	Type	Description	Default value
In
Sample Texture	TextureData	The training sample texture.	<required>
Output Size	Vector2Int	The desired size of the generated output.	<required>
N	int	Each NxN subset of pixels of the output texture, should exist inside the training sample. This means that a higher N will allow for capturing bigger features from the training sample, at the cost of more performance.	3
Tileable Sample?	bool	Is the provided training sample a tileable texture?	false
Tileable Output?	bool	Should the resulting output texture be tileable?	false
Reflectional Symmetry?	bool	If true, the sampled patterns to generate the output from, will include reflected versions of those patterns. This will add more variety, but might not look good depending on the training sample and desired output.	false
Rotational Symmetry	RotationalSymmetry	If set to Two Way, the sampled patterns to generate the output from, will include 180 rotated versions of those samples. If set to Four way, the sampled patterns to generate the output from, will include 90, 180 and 270 rotated versions of those samples. If set to None, no rotated variations will be used.	None
Out
Texture	TextureData	The output texture, generated based on the training sample texture.

Sample:

Tilemap Nodes

Copy Tilemap Data

Copies the tilemap data from the TilemapData object over to the Tilemap instance.

Example use: Copy generated tilemap data to a Tilemap in a scene.

Port	Type	Description	Default value
In
Data Source	TilemapData	The tilemap data to copy to the tilemap.	<required>
Tilemap	Tilemap	The tilemap to copy the tilemap data to.	<required>

Merge Tilemaps

Merges two tilemaps together. Tiles in tilemap B overwrite tiles in tilemap A.

Port	Type	Description	Default value
In
Tilemap A	TilemapData	Tilemap to merge with Tilemap B.	<required>
Tilemap B	TilemapData	Tilemap to merge with Tilemap A. If they both have a tile in the same position, the tile in this tilemap is added to the Merged Tilemap instead of the one in the Tilemap A.	<required>
Out
Merged Tilemap	TextureData	The TextureData object.

Randomly Stamp Tilemaps

Randomly stamps the given tilemap onto the the texture. Useful when you want to use pre-defined tilemap chunks to generate maps from.

Port	Type	Description	Default value
In
Bounds	Vector2Int	The bounds between which to stamp tilemaps.	<required>
Tilemap Set	TilemapSet	The tilemap set to pick the tilemaps to stamp from.	<required>
Tilemap Type Name	string	The tilemap type to randomly pick tilemap entries from to stamp with.	<required>
Mask	Mask	If set, the masked points will not be stamped on.	<optional>
Min. Fill Percentage	float	The min. percentage of the bounds that should be filled with tilemaps.	0
Max. Fill Percentage	float	The max. percentage of the bounds that should be filled with tilemaps.	100
Max. placements	int	If set, this is the maximum number of tilemaps that will be stamped.	<optional>
Margin	int	The minimal margin between stamped tilemaps.	0
Precise Margin?	bool	If false, the margin is based on the tilemap's bounding box, meaning it doesn't take any empty tiles into consideration. If true, the margin is determined by calculating the outline around all filled tiles in the tilemap. This results in a more accurate margin, but is computationally more expensive.	false
Out
Tilemap	TilemapData	A tilemap containing all the stamped tilemaps
Placements	Vector2Int[]	The positions of all tiles have been placed.
Margin Placements	Vector2Int[]	The positions that are considered to be morgin around the placed tiles.
Empty Points	Vector2Int[]	The set of points within the tilemap's bounding box that don't contain a tile. This will only contain points if "Precise Margin?" is false.

Texture To Tilemap

Generates a tilemap from a texture. Using the graph's named color set, the pixel colors are translated to tile that has the same name as the color in the named color set. The data is copied over to the given tilemap object.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to convert to a tilemap.	<required>
Tileset	Tileset	The tileset with tiles to use.	<required>
Tilemap	Tilemap	The tilemap to fill.	<required>
Offset	Vector2Int	The coordinates where to start placing the tiles into the tilemap.	0,0
Prevent Clear?	bool	If set to true, the tilemap will not be clear before adding the tiles.	false

Texture To Tilemap Data

Generates a tilemap from a texture. Using the graph's named color set, the pixel colors are translated to tile that has the same name as the color in the named color set.

Port	Type	Description	Default value
In
Texture	TextureData	The texture to convert to a tilemap.	<required>
Tileset	Tileset	The tileset with tiles to use.	<required>
Out
Tilemap	TilemapData	The resulting tilemap.
Offset	Vector2Int	The coordinates where to start placing the tiles into the tilemap.	0,0
Prevent Clear?	bool	If set to true, the tilemap will not be clear before adding the tiles.	false

Tilemap To Data

Converts tilemap to a tilemap data object.

Map Graph works with its own TilemapData object, to avoid some of the limitations that come with working on a Tilemap object directly.

Example use: Converting a Tilemap passed through an input parameter.

Port	Type	Description	Default value
In
Tilemap	Tilemap	The tilemap to convert to a texture.	<required>
Out
Data	TilemapData	The resulting texture.

Tilemap To Texture

Generates a texture from a tilemap. Tile names are used to lookup the associated color from the graph's named color set.

Port	Type	Description	Default value
In
Tilemap	Tilemap	The tilemap to convert to a texture.	<required>
Tileset	Tileset	The tileset used to lookup tile names and match them with the right named color.	<required>
Out
Texture	TextureData	The resulting texture.

Variable Nodes

Vector2Int (Floats)

Creates a Vector2Int from two floats. The floats are rounded to int.

Port	Type	Description	Default value
In
x	float	The value used for the x-coordinate, rounded to the nearest int.	0
y	float	The value used for the y-coordinate, rounded to the nearest int.	0
Out
Output	Vector2Int	The resulting Vector2Int.

Vector2Int (Ints)

Creates a Vector2Int from to integers.

Port	Type	Description	Default value
In
x	int	The value used for the x-coordinate.	0
y	int	The value used for the y-coordinate.	0
Out
Output	Vector2Int	The resulting Vector2Int.

Split Vector2Int

Gets the Vector2Int's x and y components as integers.

Port	Type	Description	Default value
In
Vector2Int	Vector2Int	The Vector2Int to get the components from.	<required>
Out
x	int	The x-coordinate as int.
y	int	The y-coordinate as int.