Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/armory3d/armorpaint/llms.txt

Use this file to discover all available pages before exploring further.

The material node editor is ArmorPaint’s primary tool for building procedural PBR textures. Every material slot is backed by a node graph that the shader compiler (parser_material) traverses at paint time, translating connected nodes into GPU shader code. Outputs from the graph feed directly into the PBR pipeline — base color, roughness, metallic, occlusion, normal, emission, height, and subsurface — so every change you make in the node canvas is reflected immediately on the 3D viewport.

​
Opening the Node Editor

Press Tab to toggle the material node editor open or closed over the current canvas. The editor always opens in CANVAS_TYPE_MATERIAL mode when invoked from the material slot panel.
ActionShortcut
Toggle node editorTab
Search for a nodeSpace
Zoom to fit all nodesZ (node overview)

​
Material Output Node

Every material graph must contain exactly one Material Output node (type OUTPUT_MATERIAL_PBR). It is the terminal node that drives the PBR shader. All other nodes feed into its input sockets.
Input SocketTypeDefaultDescription
Base ColorRGBA(0.8, 0.8, 0.8, 1.0)Albedo / diffuse color
OpacityVALUE1.0Alpha transparency
OcclusionVALUE1.0Ambient occlusion factor
RoughnessVALUE0.1Surface micro-roughness
MetallicVALUE0.0Metallic factor
Normal MapVECTOR(0.5, 0.5, 1.0)Tangent-space normal map
EmissionVALUE0.0Emission intensity
HeightVALUE0.0Parallax/displacement height
SubsurfaceVALUE0.0Subsurface scattering factor

​
Node Categories

Nodes that provide geometry, UV, and layer data as inputs to the graph.
  • Geometry (geometry_node) — Exposes world position, normal, and tangent vectors of the surface being shaded.
  • Texture Coordinate (texture_coordinate_node) — Provides UV, object, camera, and world-space coordinate outputs.
  • UV Map (uv_map_node) — Outputs a named UV map channel from the mesh.
  • Attribute (attribute_node) — Reads a named vertex attribute (color, etc.) from the mesh.
  • Object Info (object_info_node) — Exposes per-object data such as location and color.
  • Layer (layer_node, type LAYER) — Samples a paint layer’s textures (base color, opacity, occlusion, roughness, metallic, normal, emission, height, subsurface) directly from the layer’s paint textures. Use the Layer dropdown to select which layer slot to read. Outputs include Base Color, Opacity, Occlusion, Roughness, Metallic, Normal Map, Emission, Height, and Subsurface.
  • Tilesheet (tilesheet_node, type TILESHEET) — Computes a UV offset for a specific tile in a sprite/tilesheet atlas. Inputs: Tile X and Tile Y (0–63). Properties: Tiles X and Tiles Y grid dimensions (default 4×4). Output: UV vector.
  • Script (script_node, type SCRIPT_CPU) — Evaluates a CPU-side expression (e.g. sys_time()) and passes the result as a scalar Value output. Use the built-in Snippets menu for time-based expressions.
Procedural and image-based texture generators.
  • Image Texture (image_texture_node, type TEX_IMAGE) — Samples an asset image file. Inputs: Vector (UV override). Properties: File (asset picker), Color Space (Auto / Linear / sRGB / DirectX Normal Map). Outputs: Color (RGBA), Alpha (VALUE). Missing textures render as magenta (1, 0, 1).
  • Noise Texture (noise_texture_node, type TEX_NOISE) — Fractional Brownian Motion (fBM) 3D value noise. Inputs: Vector, Scale (default 5), Detail (0–8, default 2), Roughness (default 0.5), Lacunarity (default 2), Distortion (default 0). Outputs: Factor (VALUE), Color (RGBA).
  • Gradient Texture (gradient_texture_node) — Linear/quadratic/diagonal/spherical/easing gradient patterns.
  • Voronoi Texture (voronoi_texture_node) — Cell-based distance noise with multiple distance metrics.
  • Brick Texture (brick_texture_node) — Procedural brick/tile pattern with mortar control.
  • Checker Texture (checker_texture_node) — Two-color checkerboard.
  • Wave Texture (wave_texture_node) — Sine-based bands or rings.
  • Magic Texture (magic_texture_node) — Kaleidoscopic psychedelic color pattern.
  • Gabor Texture (gabor_texture_node) — Gabor noise for stochastic texture synthesis.
  • Tilesheet (tilesheet_node) — See Input category above; also appears here for convenience.
  • Tilesheet Animation (tilesheet_animation_node) — Time-driven tilesheet frame selector for animated sprites.
Nodes that transform, blend, or generate color values.
  • Mix Color (mix_color_node, type MIX_RGB) — Blends two RGBA colors using one of 19 blend modes: Mix, Darken, Multiply, Burn, Lighten, Screen, Dodge, Add, Overlay, Soft Light, Linear Light, Difference, Exclusion, Subtract, Divide, Hue, Saturation, Color, Value. Inputs: Factor, Color 1, Color 2. Optional: Clamp Factor and Clamp Result checkboxes.
  • Color Ramp (color_ramp_node, type VALTORGB) — Maps a scalar Factor through a multi-stop gradient with Linear or Constant interpolation. The gradient editor lets you add/remove stops and edit each stop’s color and position. Outputs: Color (RGBA), Alpha (VALUE).
  • RGB Curves (rgb_curves_node) — Per-channel curve adjustment of RGBA values.
  • Hue Saturation Value (hue_saturation_value_node) — Shifts hue, adjusts saturation, and scales value.
  • Brightness / Contrast (brightness_contrast_node) — Simple brightness and contrast control.
  • Gamma (gamma_node) — Applies a gamma power to a color.
  • Invert Color (invert_color_node) — Per-channel 1 - value inversion.
  • Replace Color (replace_color_node) — Replaces a target color with another within a tolerance range.
  • Combine Color (combine_color_node) — Assembles individual R, G, B channels into an RGBA value.
  • Separate Color (separate_color_node) — Splits RGBA into individual R, G, B, A scalar outputs.
  • RGB to BW (rgb_to_bw_node) — Converts an RGBA color to a luminance grayscale value.
  • RGB (rgb_node) — A constant RGBA color picker node.
  • Warp (warp_node, type DIRECT_WARP) — Offsets UV coordinates by an angle and mask to create swirl/distortion effects. Inputs: Color, Angle (0–360°), Mask (0–1). Output: Color (RGBA sampled at warped UV).
Nodes that operate on vector (float3) data, including normals and UV coordinates.
  • Mapping (mapping_node) — Applies translation, rotation, and scale to a vector or UV input.
  • Normal Map (normal_map_node, type NORMAL_MAP) — Decodes a tangent-space normal map texture. Inputs: Strength (default 1.0, range 0–2), Normal Map (VECTOR, default (0.5, 0.5, 1.0)). Output: Normal Map (VECTOR). Internally transforms the input from [0,1] to [-1,1], scales XY by strength, normalizes, and re-encodes to [0,1].
  • Normal (normal_node) — Outputs a fixed normal direction vector and a dot-product value.
  • Bump (bump_node) — Generates a normal from a height (displacement) input using finite differences.
  • Mix Normal Map (mix_normal_map_node) — Blends two normal map vectors with a factor.
  • Vector Math (vector_math2_node) — Applies math operations (Add, Subtract, Multiply, Normalize, Cross, Dot, etc.) to two vector inputs.
  • Vector Curves (vector_curves_node) — Applies independent curve remapping to each vector component.
  • Vector Rotate (vector_rotate_node) — Rotates a vector around an axis or center point.
  • Vector Transform (vector_transform_node) — Transforms a vector between coordinate spaces (World, Object, Camera).
Nodes that convert between types or remap value ranges.
  • Math (math2_node) — Single scalar math operations: Add, Subtract, Multiply, Divide, Power, Log, Sqrt, Abs, Round, Floor, Ceil, Min, Max, Modulo, Sine, Cosine, Tangent, Arctan2, etc.
  • Map Range (map_range_node) — Remaps a value from one range to another with optional clamping.
  • Clamp (clamp_node) — Clamps a value between a minimum and maximum.
  • Float Curve (float_curve_node) — Remaps a scalar value through an editable curve.
  • Combine XYZ (combine_xyz_node) — Assembles three scalar inputs into a single VECTOR (float3).
  • Separate XYZ (separate_xyz_node) — Splits a VECTOR into X, Y, Z scalar outputs.
  • Quantize (quantize_node) — Steps a value to the nearest multiple of a given step size (posterization).
  • Value (value_node) — A constant scalar float node.
Nodes that expose painted layer data and baking utilities.
  • Layer (layer_node) — Reads paint data from a selected layer slot. See the Input category for full details.
  • Layer Mask (layer_mask_node) — Samples the mask channel of a paint layer.
  • Bake Texture (bake_texture_node) — Bakes a cached texture result back into the graph.
  • Curvature Bake (curvature_bake_node) — Bakes surface curvature (cavity/convexity) as a grayscale value.
  • Camera Texture (camera_texture_node) — Samples the active camera’s view as a texture input.
  • Color Mask (color_mask_node) — Generates a mask from a specified color range in the base color layer.
  • Picker (picker_node) — Samples a specific UV coordinate in the current canvas as a constant color.
Nodes related to full material assignments.
  • Material (material_node) — References another material slot, compositing its PBR output into the current graph.
  • Material Output (material_output_node) — The required terminal node. See the Material Output Node section above.
  • Shader (shader_node, type SHADER_GPU) — Embeds a raw GPU shader expression. The text field contains a HLSL/WGSL expression that is inlined verbatim into the generated shader, producing a scalar Value output.
  • Script (script_node, type SCRIPT_CPU) — Evaluates a CPU-side expression and passes the result as a constant float shader parameter. Use the Snippets button to insert built-in expressions such as sys_time() for time-animated effects.
  • Blur (blur_node) — Applies a screen-space blur to the input color, useful for creating soft/blurry material layers.

​
Group Nodes

The Group node (type GROUP) lets you encapsulate a sub-graph into a reusable node with custom sockets. Groups are stored in the project’s material_groups array and can be referenced across multiple material graphs. To create a group:
  1. Add a Group node to the canvas from the Group category.
  2. Click the Nodes button inside the group node to open the group’s internal canvas.
  3. Inside, you’ll find a Group Input node (type GROUP_INPUT) and a Group Output node (type GROUP_OUTPUT). Click the Add button on each to define input and output sockets — each socket can be typed as RGBA, Vector, or Value.
  4. Build the internal node graph between Group Input and Group Output.
  5. Return to the parent canvas. The Group node’s inputs and outputs now mirror the sockets you defined.
Changes to a group’s internal sockets are automatically propagated to all Group node instances in all materials.

​
Node Previews

When node_previews is enabled in the application config, ArmorPaint bakes a small preview thumbnail for each node after every shader compilation pass. These thumbnails appear directly on the node card in the canvas, giving you an at-a-glance view of what each node produces.
Hold Ctrl and drag an existing node to create a duplicate copy of it in place, including all of its property values. This is faster than adding a new node and re-entering values.

Build docs developers (and LLMs) love

Get started for freeTalk to us