askvity

How to Use Vertex Colors in Unity?

Published in Unity Graphics 4 mins read

To use vertex colors in Unity, you'll typically apply colors directly to the vertices of a mesh, enabling effects like gradient coloring, highlighting, and blending between different materials. Here's how you can do it:

1. Using a Mesh Editor (e.g., ProBuilder):

If you're using a mesh editing tool like ProBuilder, the process is often integrated directly into the editor.

  • a. Select Editing Mode: Select the desired editing mode from the ProBuilder Edit mode toolbar.

  • b. Select Object/Elements: Select the object(s) or element(s) (vertices, faces, edges) you want to color.

  • c. Access Vertex Colors Tool: Click the "Vertex Colors" tool in the ProBuilder toolbar. This should open the Vertex Colors window.

  • d. Apply Color: Choose your desired color and click the "Apply" button. This will apply the selected color to the chosen vertices.

2. Scripting Approach:

If you need more dynamic control or want to generate vertex colors programmatically, you can use a script.

  • a. Access Mesh Data: Get the Mesh component of your GameObject. You'll need to access the mesh data to modify the vertex colors.
   Mesh mesh = GetComponent<MeshFilter>().mesh;
  • b. Create Color Array: Create an array of Color structures. The length of this array must match the number of vertices in your mesh.
   Color[] colors = new Color[mesh.vertexCount];

  • c. Assign Colors to Vertices: Iterate through the vertices and assign a color to each. This part depends on how you want to color the vertices. Examples include:

    • Constant Color: Apply the same color to all vertices.

      for (int i = 0; i < colors.Length; i++)
{
    colors[i] = Color.red; // Example: Red color
}

    • Gradient Based on Height: Apply a color based on the vertex's Y position.

      Vector3[] vertices = mesh.vertices;
float minHeight = float.MaxValue;
float maxHeight = float.MinValue;

// Find min and max height for normalization
foreach (Vector3 vertex in vertices)
{
    minHeight = Mathf.Min(minHeight, vertex.y);
    maxHeight = Mathf.Max(maxHeight, vertex.y);
}

for (int i = 0; i < colors.Length; i++)
{
    float height = vertices[i].y;
    float normalizedHeight = Mathf.InverseLerp(minHeight, maxHeight, height); // 0 to 1

    // Example: Gradient from blue to green
    colors[i] = Color.Lerp(Color.blue, Color.green, normalizedHeight);
}

  • d. Apply Colors to Mesh: Assign the colors array to the colors property of the mesh.

   mesh.colors = colors;
  • e. Material Setup: Ensure your material uses a shader that supports vertex colors. The standard shader can use vertex colors through the "VertexLit" rendering path or a custom shader with vertex color sampling. Often you'll want to create a dedicated shader that samples the COLOR semantic from the vertex data. Example HLSL code:
  ```hlsl
  struct appdata
  {
      float4 vertex : POSITION;
      float3 normal : NORMAL;
      float4 color : COLOR; // Vertex color
  };

  struct v2f
  {
      float4 vertex : SV_POSITION;
      float4 color : COLOR;
  };

  v2f vert (appdata v)
  {
      v2f o;
      o.vertex = UnityObjectToClipPos(v.vertex);
      o.color = v.color; // Pass the vertex color to the fragment shader
      return o;
  }

  fixed4 frag (v2f i) : SV_Target
  {
      return i.color; // Output the vertex color as the final color
  }

  ```

Important Considerations:

  • Performance: Modifying mesh data at runtime (especially every frame) can be performance-intensive. Consider baking vertex colors at edit time or using them sparingly.
  • Mesh Read/Write Enabled: Make sure "Read/Write Enabled" is checked in the Mesh Import Settings of your model. Otherwise, you won't be able to modify the mesh data at runtime.
  • Material Support: The material assigned to your object must use a shader that utilizes vertex colors. The standard shader can be adapted, or custom shaders written.
  • Lightmapping: Vertex colors will not bake into lightmaps. You'll need a separate lightmapping solution if you want similar baked lighting effects.

In summary, you can use vertex colors in Unity either through direct mesh editing tools like ProBuilder or programmatically via scripts, allowing for dynamic and custom coloring effects. Make sure your material's shader is set up to display the vertex colors correctly.

Related Articles