GPU Instancing in the 2d renderer?

I'm making a game where you can shoot asteroids, and a lot of small asteroid debris fly out. They are just 3-4 different models, but they vary slightly in color and size. That seems ideal for GPU Instancing.

I made a material with the shader URP/2D/Sprite-Lit-Default and enabled the GPU Instancing checkbox and assigned this to the sprite renderer of the asteroid debris.

But when I clone a gameobject, the batches still increase. Isn't that the same as draw calls?

So am I doing this wrong?

 

I don't think the default sprite shader supports gpu instancing. I'm not completely sure though. I'd be interested in the answer to this.

 

Interesting, I just started messing with shader graph, but have no idea if that's something that could be made in there

 

Doubtful. The shader graph trades complexity and optimization in favor of abstraction and ease of use. I could be completely wrong about the default sprite shader supporting instancing as internally, sprites are represented by simple quads.

That said, I don't think the tilemap system has this issue as there is a single renderer on each tilemap. Any of the Unity 2d staff want to chime in? @rustum

 

Tilemaps should have great use of gpu instancing i guess. With the default URP>2d material there is a GPU instancing checkbox, but with my own shader graph material there isn't.

 

https://forum.unity.com/threads/2d-system-optimizations.805905/

Last word from a Unity dev for Tilemap GPU Instancing support ( Jan 31, 2020 ):

Maybe there's an update @rustum could share about 2D system optimizations Unity is working on?

 

Thank you @ChuanXin and @rustum. I will try to reproduce this in a simpler project when I have the chance.

Is there anything special to consider when using a tilemap where each tile is 512x512? We're making a cartoon like game, which has quite a high resolution, but if it doesn't work, we would need to scale it down. I guess GPU instancing here would save some performance at least.

 

@ChuanXin , @rustum
Can we please have some information on drawcall batching with Sprite rendering especially in accordance with :

1. URP
2. SRP batching
3. GPU instancing
4. 2D Renderer
5. Sorting Group component + sorting order / layer ( does this affect batching at all ? )

 

@ChuanXin Thank you! I haven't reached a stage where we're optimizing, so I'll start a new thread in the future when we reach that point.

 

Any updates on this? I have spent a lot time to figure out that rendering sprite is something very special from rendering mesh and sprite renderer not supports SRP batching even if SPRITE shader has SRP Batcher: compatible label in inspector, which is very confusing! I'm using 2020.3.22 unity.

 

It "just works", I don't know if it is optimal

Code (CSharp):

1. Shader "Universal Render Pipeline/2D/Sprite-Lit"
2. {
3.     Properties
4.     {
5.         _MainTex("Diffuse", 2D) = "white" {}
6.         _MaskTex("Mask", 2D) = "white" {}
7.         _NormalMap("Normal Map", 2D) = "bump" {}
8.     }
9.  
10.     HLSLINCLUDE
11.     #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
12.     ENDHLSL
13.  
14.     SubShader
15.     {
16.         Tags {"Queue" = "Transparent" "RenderType" = "Transparent" "RenderPipeline" = "UniversalPipeline" }
17.  
18.         Blend SrcAlpha OneMinusSrcAlpha
19.         Cull Off
20.         ZWrite Off
21.  
22.         Pass
23.         {
24.             Tags { "LightMode" = "Universal2D" }
25.             HLSLPROGRAM
26.             #pragma exclude_renderers gles gles3 glcore
27.             #pragma target 4.5
28.  
29.             #pragma vertex CombinedShapeLightVertex
30.             #pragma fragment CombinedShapeLightFragment
31.             #pragma multi_compile USE_SHAPE_LIGHT_TYPE_0 __
32.             #pragma multi_compile USE_SHAPE_LIGHT_TYPE_1 __
33.             #pragma multi_compile USE_SHAPE_LIGHT_TYPE_2 __
34.             #pragma multi_compile USE_SHAPE_LIGHT_TYPE_3 __
35.  
36.             #pragma multi_compile_instancing
37.             #pragma multi_compile _ DOTS_INSTANCING_ON
38.  
39.             struct Attributes
40.             {
41.                 float3 positionOS   : POSITION;
42.                 float4 color        : COLOR;
43.                 float2  uv           : TEXCOORD0;
44.                 UNITY_VERTEX_INPUT_INSTANCE_ID
45.             };
46.  
47.             struct Varyings
48.             {
49.                 float4  positionCS  : SV_POSITION;
50.                 half4   color       : COLOR;
51.                 float2    uv          : TEXCOORD0;
52.                 half2    lightingUV  : TEXCOORD1;
53.                 UNITY_VERTEX_OUTPUT_STEREO
54.             };
55.  
56.             #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/LightingUtility.hlsl"
57.  
58.             TEXTURE2D(_MainTex);
59.             SAMPLER(sampler_MainTex);
60.             TEXTURE2D(_MaskTex);
61.             SAMPLER(sampler_MaskTex);
62.             TEXTURE2D(_NormalMap);
63.             SAMPLER(sampler_NormalMap);
64.  
65.             CBUFFER_START(UnityPerMaterial)
66.             half4 _MainTex_ST;
67.             half4 _NormalMap_ST;
68.             CBUFFER_END
69.  
70.             #if USE_SHAPE_LIGHT_TYPE_0
71.             SHAPE_LIGHT(0)
72.             #endif
73.  
74.             #if USE_SHAPE_LIGHT_TYPE_1
75.             SHAPE_LIGHT(1)
76.             #endif
77.  
78.             #if USE_SHAPE_LIGHT_TYPE_2
79.             SHAPE_LIGHT(2)
80.             #endif
81.  
82.             #if USE_SHAPE_LIGHT_TYPE_3
83.             SHAPE_LIGHT(3)
84.             #endif
85.  
86.             Varyings CombinedShapeLightVertex(Attributes v)
87.             {
88.                 Varyings o = (Varyings)0;
89.                 UNITY_SETUP_INSTANCE_ID(v);
90.                 UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
91.  
92.                 o.positionCS = TransformObjectToHClip(v.positionOS);
93.                 o.uv = TRANSFORM_TEX(v.uv, _MainTex);
94.                 float4 clipVertex = o.positionCS / o.positionCS.w;
95.                 o.lightingUV = ComputeScreenPos(clipVertex).xy;
96.                 o.color = v.color;
97.                 return o;
98.             }
99.  
100.             #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/CombinedShapeLightShared.hlsl"
101.  
102.             half4 CombinedShapeLightFragment(Varyings i) : SV_Target
103.             {
104.                 half4 main = i.color * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
105.                 half4 mask = SAMPLE_TEXTURE2D(_MaskTex, sampler_MaskTex, i.uv);
106.  
107.                 return CombinedShapeLightShared(main, mask, i.lightingUV);
108.             }
109.             ENDHLSL
110.         }
111.  
112.         Pass
113.         {
114.             Tags { "LightMode" = "NormalsRendering"}
115.             HLSLPROGRAM
116.             #pragma exclude_renderers gles gles3 glcore
117.             #pragma target 4.5
118.  
119.             #pragma vertex NormalsRenderingVertex
120.             #pragma fragment NormalsRenderingFragment
121.  
122.             #pragma multi_compile_instancing
123.             #pragma multi_compile _ DOTS_INSTANCING_ON
124.  
125.             struct Attributes
126.             {
127.                 float3 positionOS   : POSITION;
128.                 float4 color        : COLOR;
129.                 float2 uv            : TEXCOORD0;
130.                 float4 tangent      : TANGENT;
131.                 UNITY_VERTEX_INPUT_INSTANCE_ID
132.             };
133.  
134.             struct Varyings
135.             {
136.                 float4  positionCS        : SV_POSITION;
137.                 half4   color            : COLOR;
138.                 float2    uv                : TEXCOORD0;
139.                 half3   normalWS        : TEXCOORD1;
140.                 half3   tangentWS        : TEXCOORD2;
141.                 half3   bitangentWS        : TEXCOORD3;
142.                 UNITY_VERTEX_OUTPUT_STEREO
143.             };
144.  
145.             TEXTURE2D(_MainTex);
146.             SAMPLER(sampler_MainTex);
147.             TEXTURE2D(_NormalMap);
148.             SAMPLER(sampler_NormalMap);
149.  
150.             CBUFFER_START(UnityPerMaterial)
151.             half4 _MainTex_ST;
152.             half4 _NormalMap_ST;
153.             CBUFFER_END
154.  
155.             Varyings NormalsRenderingVertex(Attributes attributes)
156.             {
157.                 Varyings o = (Varyings)0;
158.                 UNITY_SETUP_INSTANCE_ID(attributes);
159.                 UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
160.  
161.                 o.positionCS = TransformObjectToHClip(attributes.positionOS);
162.                 o.uv = TRANSFORM_TEX(attributes.uv, _NormalMap);
163.                 o.uv = attributes.uv;
164.                 o.color = attributes.color;
165.                 o.normalWS = TransformObjectToWorldDir(float3(0, 0, -1));
166.                 o.tangentWS = TransformObjectToWorldDir(attributes.tangent.xyz);
167.                 o.bitangentWS = cross(o.normalWS, o.tangentWS) * attributes.tangent.w;
168.                 return o;
169.             }
170.  
171.             #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/NormalsRenderingShared.hlsl"
172.  
173.             half4 NormalsRenderingFragment(Varyings i) : SV_Target
174.             {
175.                 half4 mainTex = i.color * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
176.                 half3 normalTS = UnpackNormal(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, i.uv));
177.                 return NormalsRenderingShared(mainTex, normalTS, i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz);
178.             }
179.             ENDHLSL
180.         }
181.         Pass
182.         {
183.             Tags { "LightMode" = "UniversalForward" "Queue"="Transparent" "RenderType"="Transparent"}
184.  
185.             HLSLPROGRAM
186.             #pragma exclude_renderers gles gles3 glcore
187.             #pragma target 4.5
188.  
189.             #pragma vertex UnlitVertex
190.             #pragma fragment UnlitFragment
191.  
192.             #pragma multi_compile_instancing
193.             #pragma multi_compile _ DOTS_INSTANCING_ON
194.  
195.             struct Attributes
196.             {
197.                 float3 positionOS   : POSITION;
198.                 float4 color        : COLOR;
199.                 float2 uv            : TEXCOORD0;
200.                 UNITY_VERTEX_INPUT_INSTANCE_ID
201.             };
202.  
203.             struct Varyings
204.             {
205.                 float4  positionCS        : SV_POSITION;
206.                 float4  color            : COLOR;
207.                 float2    uv                : TEXCOORD0;
208.                 UNITY_VERTEX_OUTPUT_STEREO
209.             };
210.  
211.             TEXTURE2D(_MainTex);
212.             SAMPLER(sampler_MainTex);
213.  
214.             CBUFFER_START(UnityPerMaterial)
215.             half4 _MainTex_ST;
216.             half4 _NormalMap_ST;
217.             CBUFFER_END
218.  
219.             Varyings UnlitVertex(Attributes attributes)
220.             {
221.                 Varyings o = (Varyings)0;
222.                 UNITY_SETUP_INSTANCE_ID(attributes);
223.                 UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
224.  
225.                 o.positionCS = TransformObjectToHClip(attributes.positionOS);
226.                 o.uv = TRANSFORM_TEX(attributes.uv, _MainTex);
227.                 o.uv = attributes.uv;
228.                 o.color = attributes.color;
229.                 return o;
230.             }
231.  
232.             float4 UnlitFragment(Varyings i) : SV_Target
233.             {
234.                 float4 mainTex = i.color * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
235.                 return mainTex;
236.             }
237.             ENDHLSL
238.         }
239.     }
240. }
241.  

 

Sorry for necroing this thread but it's important to me. Was GPU instancing finally applied to TilemapRenderers?

 

So, after reading around the forum, am I correct to say that:
Using a 2D renderer (e.g. SpriteRenderer) and a custom sprite shader, sprites cannot be batched if they have different properties?

Example:
I have a car sprite and a custom sprite shader that allows me to change the door colors. I want to render 100 cars with different door colors. Is there no way to batch this?

1. SRP Batcher is not supported
2. MaterialPropertyBlocks break batching in SRP

If I'm correct, are there any plans to support this in the future?

 

Added in 2023.1

• 2D: Added SRP Batching for 2D Renderers and Particle Renderer to support URP.