Vertex colors are one of the most underused tools in a game artist's kit. While PBR texture sets dominate most workflows, vertex color data travels inside the mesh itself — no extra texture slot, no UV space, no sample cost. Whether you're blending terrain materials, driving ambient occlusion, or masking procedural effects, vertex colors give you per-vertex control at virtually zero runtime overhead.
This guide covers the full pipeline: painting vertex colors in Blender, exporting correctly via GLB or FBX, and wiring them up as masks and blend inputs in Unity URP, Unreal Engine 5, and Godot 4.
What Are Vertex Colors and Why Game Artists Use Them
Vertex colors store RGBA values directly on each vertex of a mesh. Unlike textures, they don't require UV unwrapping and they scale with geometry density rather than texture resolution. A high-poly mesh has finer vertex color detail; a low-poly mesh has coarser transitions — which is exactly the tradeoff you want for LODs.
Common game art use cases include:
- Terrain blend masks: Paint which vertices receive grass, dirt, rock, or snow textures, then blend between tiling textures in a shader using vertex color channels as weights.
- Ambient occlusion baking: Store a cheap AO approximation in the vertex color alpha channel for assets that don't justify a dedicated AO texture.
- Foliage wind masks: Store wind influence per-vertex (white = full wind, black = anchored) to drive procedural wind shaders without an extra texture lookup.
- Destructible highlighting: Use a vertex color channel to isolate damage zones driven by game logic at runtime.
- Stylized shading: Drive cel-shading thresholds or rimlight masks using painted vertex data instead of texture-based gradients.
For marketplace assets at BitSoul Marketplace, vertex color masks are a powerful way to add material flexibility without increasing texture count — a major selling point for environment and prop assets.
Setting Up Vertex Color Painting in Blender
Blender's vertex color system changed significantly in version 3.2 with the introduction of Color Attributes. In Blender 3.2+, you work with Color Attributes instead of the old Vertex Color layer system, which aligns better with modern engine expectations.
Create a Color Attribute
- Select your mesh and enter Object Data Properties (green triangle icon).
- Under Color Attributes, click + to add a new attribute.
- Set Domain to `Face Corner` for the smoothest painting experience (interpolated per vertex across faces). Use `Point` (Vertex) domain if you want hard per-vertex values.
- Set Data Type to `Byte Color` for standard RGBA (0–255 per channel, compact). Use `Float Color` only if you need HDR vertex colors — most game engines don't support this and will clamp on import.
- Name the attribute descriptively: `BlendMask`, `WindWeight`, or `AOLayer`.
Enter Vertex Paint Mode
Switch to Vertex Paint mode from the mode dropdown (top-left of the 3D viewport, or `Ctrl+Tab`). Your mesh will display the current vertex colors immediately.
Key settings in the Tool panel (`N` sidebar → Tool tab):
- Radius: brush size in pixels
- Strength: opacity per stroke
- Blend Mode: Normal for painting, Multiply/Add for layered effects
- Color: the RGBA value to paint — use the color picker or enter hex directly
Painting Tips for Clean Results
```python
# Blender Python snippet: fill entire mesh with a base color via script
import bpy
obj = bpy.context.active_object
mesh = obj.data
# Get or create the Color Attribute
if "BlendMask" not in mesh.color_attributes:
mesh.color_attributes.new(name="BlendMask", type='BYTE_COLOR', domain='CORNER')
attr = mesh.color_attributes["BlendMask"]
# Fill all corners with white (1, 1, 1, 1)
for data in attr.data:
data.color = (1.0, 1.0, 1.0, 1.0)
print(f"Filled {len(attr.data)} face corners.")
```
Use the Fill tool (`Shift+K` in Vertex Paint mode) to flood-fill a selection with a flat color before detail painting. This gives you a clean baseline to paint on top of. For gradient transitions, reduce brush strength to 0.1–0.2 and build up coverage gradually — vertex color edges can look harsh at low poly counts if you paint too hard.
Using Vertex Colors for Terrain Blend Materials
The most powerful application for game environments is using vertex color channels to blend between tiling detail textures. Each channel (R, G, B, A) acts as a weight for a different material layer.
| Channel | Typical Use |
|---------|-------------|
| R (Red) | Grass / base ground |
| G (Green) | Dirt / path |
| B (Blue) | Rock / cliff |
| A (Alpha) | Snow / wetness |
In practice, keep your masks single-channel and inverted if your engine expects 0 = no influence, 1 = full influence. Avoid using all four channels simultaneously on low-poly meshes — transitions become muddy at vertex density below 1 vertex per 50 cm.
### Blending Rules
- Paint one dominant channel at a time (R fully white in a zone before touching G)
- Leave 1–3 edge loops of gradual transition between zones for smooth blending
- Keep the alpha channel clean (all 1.0) unless explicitly needed — some exporters use alpha for transparency
Exporting Vertex Colors: GLB, FBX, and Engine Import Settings
Vertex colors are exported differently depending on format and destination engine.
GLB / GLTF Export (Recommended)
GLB is the cleanest format for vertex color preservation. In Blender's GLTF exporter:
- File → Export → glTF 2.0 (.glb/.gltf)
- Under Mesh, ensure Colors is checked
- Vertex Color attribute named `COLOR_0` exports as the primary color; `COLOR_1` as secondary (if present)
- Note: glTF vertex colors are encoded as linear RGBA floats (0.0–1.0). Blender handles the sRGB→linear conversion on export automatically for `Byte Color` attributes.
Godot 4 imports `COLOR_0` directly as `COLOR` in the vertex shader. Unity 2021+ reads it as `mesh.colors`. UE5 reads it from the Vertex Color node in Material Editor.
FBX Export
FBX vertex color export is reliable but watch for this: Blender exports vertex colors in sRGB space by default in FBX. If your engine applies gamma correction twice, your blend masks will look washed out. The fix:
```
Export FBX → Geometry tab → uncheck "Apply Modifiers" if you have subdivision
In UE5 import settings → enable "Import Vertex Colors" explicitly
In Unity, vertex colors in FBX are read automatically; no extra step needed
```
Engine Shader Setup Cheatsheet
| Engine | Node / Method |
|--------|---------------|
| Unity URP | `Shader Graph → Vertex Color node` → connect to Lerp/blend |
| Unreal Engine 5 | `Vertex Color` node in Material Editor → mask individual channels |
| Godot 4 | `COLOR` built-in in VisualShader or shader code → `COLOR.r` / `.g` |
For Unity, apply the vertex color to a `Lerp` node between two texture samples — the vertex color R channel becomes the blend weight. In UE5, multiply the vertex color channel by each texture's BaseColor output before summing them. In Godot 4, use a `mix()` function in a custom shader:
```glsl
// Godot 4 spatial shader snippet
void fragment() {
vec4 grass = texture(grass_tex, UV);
vec4 dirt = texture(dirt_tex, UV);
float blend = COLOR.r; // red channel from vertex paint
ALBEDO = mix(dirt.rgb, grass.rgb, blend);
}
```
Vertex Color Tips for Marketplace-Ready Assets
If you're publishing assets on BitSoul Marketplace or other 3D asset platforms, well-documented vertex color data significantly increases asset value and usability. Follow these conventions to make your vertex color layers immediately useful to buyers:
Naming conventions:
- Name Color Attributes explicitly (`BlendMask`, `WindWeight`, `DamageAO`) — don't leave them as `Col` (Blender's default)
- Document channel usage in your product description (e.g., "R = blend weight, A = AO")
Data hygiene:
- Remove unused Color Attributes before export (`-` button in Object Data Properties)
- Verify the exported GLB with a validator like gltf.report — it shows vertex attribute lists clearly
- Test your asset in all three major engines before publishing; vertex color interpretation can differ
Performance notes:
- Vertex colors add approximately 16 bytes per vertex (RGBA Byte Color) — negligible for most props
- High vertex count foliage with vertex color wind masks is still faster than a wind texture lookup at scale
- For mobile targets, prefer single-channel masks (R only) to minimize shader ALU cost
Combine with texture baking strategically. Vertex color ambient occlusion works well for large environment meshes where baked AO texture would be too low-resolution or not worth the texture slot. For hero props and characters, baked AO textures remain sharper — use vertex color AO only as a fallback or for background assets.
Vertex colors are a mature, broadly supported feature with zero texture overhead. Used deliberately, they let you ship more flexible, engine-agnostic assets with fewer textures and cleaner shader graphs. Start with a single blend mask channel, verify it in your target engine, and build from there.
Browse vertex-color-ready environment and prop assets at BitSoul Marketplace to see these techniques applied to production-ready packs.