Unity GPU Instancing: Unlit Instanced Shader

Unity GPU instancing allows you to duplicate meshes without using much CPU overhead, which means you can render more cubes or more copies of trees, fishes, fractal geometries, or whatever else you can dream up!

You can read more at in the Unity 5.5 documentation on GPU Instancing.

To Instance a cube object, for example, create a cube GameObject, and then create another empty GameObject, whose transform we will use for the instanced cube.

For instancing to work, you have to use an Instanced Shader on the Material of your cube.  To create a new instanced shader, goto Create => Shader => Standard Surface Shader (Instanced).

The Create menu is found below the Project tab.

The Create menu is found below the Project tab.

Use this shader (or another Instanced shader) on the material of the object you want to instance.  Then add the following script to the cube:

using UnityEngine;
using System.Collections;
using UnityEngine.Rendering;

public class InstanceMesh : MonoBehaviour {

    //Attach this script to the object you want to instance, such as a cube object.  It should have a mesh renderer on it.

    Mesh mesh;
    Material mat;

    //Make an empty game object and drag it into the obj variable in the editor.  This object's transform will be used as the transform for the instanced object.
    public GameObject obj;

    Matrix4x4[] matrix ;
    ShadowCastingMode castShadows;

    public bool turnOnInstance = true;

    void Start () {

        mesh = GetComponent<MeshFilter> ().mesh;
        mat = GetComponent<Renderer> ().material;
        matrix = new Matrix4x4[2]{ obj.transform.localToWorldMatrix, this.transform.localToWorldMatrix};
        castShadows = ShadowCastingMode.On;


        Graphics.DrawMeshInstanced (mesh, 0, mat, matrix, matrix.Length, null, castShadows , true, 0, null);
    
    }

    void Update () {

        if (turnOnInstance) {
            
            mesh = GetComponent<MeshFilter> ().mesh;
            mat = GetComponent<Renderer> ().material;
            matrix = new Matrix4x4[2]{ obj.transform.localToWorldMatrix, this.transform.localToWorldMatrix};
            castShadows = ShadowCastingMode.On;


            Graphics.DrawMeshInstanced (mesh, 0, mat, matrix, matrix.Length, null, castShadows , true, 0, null);

        }
    }
}

Drag the empty GameObject you created into the "obj" public variable on this script in the Inspector.  Now hit play!  The cube should be copied using the transform of the empty GameObject.  Try modifying the position, rotation and scale parameters on the empty GameObject at runtime to see the instanced cube also change, as in the below screenshot.

The cube on the right has been Instanced and copied based on the empty GameObject's transform.

The cube on the right has been Instanced and copied based on the empty GameObject's transform.

Lighting problem

One annoying limitation is that instanced meshes do not work with lighting very well, for example point source lighting.  Only a single directional light seems to work on instanced meshes (please correct me if I am wrong!).

Directional light looks fine...

Directional light looks fine...

Point light only lights original cube...

Point light only lights original cube...

Using Unlit Instanced Shader

One way around this is to not use lighting and use instancing for unlit meshes instead. Unfortunately, there is no Standard Unlit Shader (Instanced) option in the Create menu.  So I just quickly made one:

Shader "Instanced/Unlit"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

            #pragma multi_compile_instancing

            
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            UNITY_INSTANCING_CBUFFER_START(Props)
            UNITY_DEFINE_INSTANCED_PROP(fixed4, _Color) // Make _Color an instanced property (i.e. an array)
            UNITY_INSTANCING_CBUFFER_END
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);
                return o;
            }
            
            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                // apply fog
                UNITY_APPLY_FOG(i.fogCoord, col);
                return col;
            }
            ENDCG
        }
    }
}
Using the Unlit Instanced Shader given above.

Using the Unlit Instanced Shader given above.

Using the unlit shader, you can bake in lighting, or use it for purposes where you don't want to use lighting anyway.

Please let me know if you found this useful!

Adding a detail map

As a freebee, here is also an Unlit Instanced Shader which allows a secondary detail mask so that you can create nice things like the image below:

This shader allows a detail mask that can be used to do interesting things like only highlight the edges, as in this example.

This shader allows a detail mask that can be used to do interesting things like only highlight the edges, as in this example.

Shader "Instanced/UnlitDetail"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Detail ("Detail", 2D) = "gray" {}

    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            //#pragma multi_compile_fog

            #pragma multi_compile_instancing

            
            #include "UnityCG.cginc"


            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv_MainTex : TEXCOORD0;
                float2 uv_Detail : TEXCOORD1;
            };

            struct v2f
            {
                float2 uv_MainTex : TEXCOORD0;
                float2 uv_Detail : TEXCOORD1;

                //UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            sampler2D _Detail;

            float4 _MainTex_ST;
            float4 _Detail_ST;

            UNITY_INSTANCING_CBUFFER_START(Props)
            UNITY_DEFINE_INSTANCED_PROP(fixed4, _Color) // Make _Color an instanced property (i.e. an array)
            UNITY_INSTANCING_CBUFFER_END
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv_MainTex = TRANSFORM_TEX(v.uv_MainTex, _MainTex);
                o.uv_Detail = TRANSFORM_TEX(v.uv_MainTex, _Detail);
                //UNITY_TRANSFER_FOG(o,o.vertex);
                return o;
            }
            
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = 0;

                // sample the texture
                fixed3 main = tex2D(_MainTex, i.uv_MainTex).rgb;
                fixed3 detail = tex2D(_Detail, i.uv_Detail).rgb;


                col.rgb = main * detail;

                // apply fog
                //UNITY_APPLY_FOG(i.fogCoord, col);
                return col;
            }
            ENDCG
        }
    }
}