Merge pull request #807 from Unity-Technologies/LightweightGpuInstancing

GPU instancing in Lightweight renderpipeline

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/UnityInstancing.hlsl

 #ifndef UNITY_INSTANCING_INCLUDED
 #define UNITY_INSTANCING_INCLUDED
 
-#ifndef UNITY_SHADER_VARIABLES_INCLUDED
-    // We will redefine some built-in shader params e.g. unity_ObjectToWorld and unity_WorldToObject.
-    #error "Please include ShaderVariables.hlsl first."
-#endif
-
 #if SHADER_TARGET >= 35 && (defined(SHADER_API_D3D11) || defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PSSL) || defined(SHADER_API_VULKAN) || defined(SHADER_API_METAL))
     #define UNITY_SUPPORT_INSTANCING
 #endif
             unity_InstanceID = inputInstanceID + unity_BaseInstanceID;
         #endif
     }
-    void UnitySetupCompoundMatrices();
+
-            #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)      { UnitySetupInstanceID(UNITY_GET_INSTANCE_ID(input)); UNITY_INSTANCING_PROCEDURAL_FUNC(); UnitySetupCompoundMatrices(); }
+            #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)      { UnitySetupInstanceID(UNITY_GET_INSTANCE_ID(input)); UNITY_INSTANCING_PROCEDURAL_FUNC();}
-        #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)          { UnitySetupInstanceID(UNITY_GET_INSTANCE_ID(input)); UnitySetupCompoundMatrices(); }
+        #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)          { UnitySetupInstanceID(UNITY_GET_INSTANCE_ID(input));}
     #endif
     #define UNITY_TRANSFER_INSTANCE_ID(input, output)   output.instanceID = UNITY_GET_INSTANCE_ID(input)
 #else
     #endif
 
     #if defined(UNITY_INSTANCED_SH) && !defined(LIGHTMAP_ON)
-        #if UNITY_SHOULD_SAMPLE_SH
+        //In HDRenderpipe we only decide to look at probe data based on Lightmap flags.
+        #if !defined(DYNAMICLIGHTMAP_ON) 
-        #if defined(UNITY_PASS_DEFERRED) && defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
+        #if defined(SHADOWS_SHADOWMASK)
             #define UNITY_USE_PROBESOCCLUSION_ARRAY
         #endif
     #endif
         #endif
     UNITY_INSTANCING_BUFFER_END(unity_Builtins2)
 
-    #define unity_ObjectToWorld     UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_ObjectToWorldArray)
+    #undef UNITY_MATRIX_M
+    #define UNITY_MATRIX_M     UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_ObjectToWorldArray)
-    #define unity_WorldToObject     UNITY_ACCESS_INSTANCED_PROP(MERGE_UNITY_BUILTINS_INDEX(UNITY_WORLDTOOBJECTARRAY_CB), unity_WorldToObjectArray)
+    #undef UNITY_MATRIX_I_M
+    #define UNITY_MATRIX_I_M     UNITY_ACCESS_INSTANCED_PROP(MERGE_UNITY_BUILTINS_INDEX(UNITY_WORLDTOOBJECTARRAY_CB), unity_WorldToObjectArray)
-        return mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, float4(pos, 1.0)));
+        return mul(UNITY_MATRIX_VP, mul(UNITY_MATRIX_M, float4(pos, 1.0)));
     }
     inline float4 UnityObjectToClipPosInstanced(float4 pos)
     {
     #define UNITY_ACCESS_INSTANCED_PROP(arr, var)           var
 
 #endif // UNITY_INSTANCING_ENABLED
-
-#if defined(UNITY_INSTANCING_ENABLED) || defined(UNITY_PROCEDURAL_INSTANCING_ENABLED) || defined(UNITY_STEREO_INSTANCING_ENABLED)
-    // The following matrix evaluations depend on the static var unity_InstanceID & unity_StereoEyeIndex. They need to be initialized after UnitySetupInstanceID.
-    static float4x4 unity_MatrixMVP_Instanced;
-    static float4x4 unity_MatrixMV_Instanced;
-    static float4x4 unity_MatrixTMV_Instanced;
-    static float4x4 unity_MatrixITMV_Instanced;
-    void UnitySetupCompoundMatrices()
-    {
-        unity_MatrixMVP_Instanced = mul(UNITY_MATRIX_VP, unity_ObjectToWorld);
-        unity_MatrixMV_Instanced = mul(UNITY_MATRIX_V, unity_ObjectToWorld);
-        unity_MatrixTMV_Instanced = transpose(unity_MatrixMV_Instanced);
-        unity_MatrixITMV_Instanced = transpose(mul(unity_WorldToObject, unity_MatrixInvV));
-    }
-    #undef UNITY_MATRIX_MVP
-    #undef UNITY_MATRIX_MV
-    #undef UNITY_MATRIX_T_MV
-    #undef UNITY_MATRIX_IT_MV
-    #define UNITY_MATRIX_MVP    unity_MatrixMVP_Instanced
-    #define UNITY_MATRIX_MV     unity_MatrixMV_Instanced
-    #define UNITY_MATRIX_T_MV   unity_MatrixTMV_Instanced
-    #define UNITY_MATRIX_IT_MV  unity_MatrixITMV_Instanced
-#endif
 
 #endif // UNITY_INSTANCING_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightStandardSimpleLightingGUI.cs

         public static string shininessLabel = "Shininess";
         public static string normalMapLabel = "Normal map";
         public static string emissionColorLabel = "Emission Color";
+        public static string advancedText = "Advanced Options";
     }
 
     public override void FindProperties(MaterialProperty[] properties)
             m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);
             if (EditorGUI.EndChangeCheck())
                 emissionMapProp.textureScaleAndOffset = albedoMapProp.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
+
+            GUILayout.Label(Styles.advancedText, EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.EnableInstancingField();
+            EditorGUI.indentLevel--;
         }
         if (EditorGUI.EndChangeCheck())
         {

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Core.hlsl

 {
     half sign = vertexTangent.w * GetOddNegativeScale();
     normalWS = TransformObjectToWorldNormal(vertexNormal);
-    tangentWS = normalize(mul((half3x3)unity_ObjectToWorld, vertexTangent.xyz));
+    tangentWS = normalize(mul((half3x3)UNITY_MATRIX_M, vertexTangent.xyz));
     binormalWS = cross(normalWS, tangentWS) * sign;
 }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Input.hlsl

 #define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
 
 #include "InputBuiltin.hlsl"
+#include "CoreRP/ShaderLibrary/UnityInstancing.hlsl"
 #include "CoreFunctions.hlsl"
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     float4 tangent : TANGENT;
     float2 texcoord : TEXCOORD0;
     float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+
 };
 
 struct LightweightVertexOutput
     half4 fogFactorAndVertexLight   : TEXCOORD7; // x: fogFactor, yzw: vertex light
 
     float4 clipPos                  : SV_POSITION;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 {
     LightweightVertexOutput o = (LightweightVertexOutput)0;
 
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+
     o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
 
     o.posWS = TransformObjectToWorld(v.vertex.xyz);
 // Used for Standard shader
 half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
 {
+    UNITY_SETUP_INSTANCE_ID(IN);
+
     SurfaceData surfaceData;
     InitializeStandardLitSurfaceData(IN.uv, surfaceData);
 
 // Used for StandardSimpleLighting shader
 half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
 {
+    UNITY_SETUP_INSTANCE_ID(IN);
+
     float2 uv = IN.uv;
 
     half4 diffuseAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassShadow.hlsl

 {
     float4 position : POSITION;
     float3 normal   : NORMAL;
+
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_SETUP_INSTANCE_ID(v);
+
     float3 positionWS = TransformObjectToWorld(v.position.xyz);
     float3 normalWS = TransformObjectToWorldDir(v.normal);
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED LIGHTMAP_ON
 
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+
             // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
             // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
             #ifdef DIRLIGHTMAP_COMBINED
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+
             #pragma vertex ShadowPassVertex
             #pragma fragment ShadowPassFragment
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED LIGHTMAP_ON
 
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+
             // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
             // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
             #ifdef DIRLIGHTMAP_COMBINED
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+
             #pragma vertex ShadowPassVertex
             #pragma fragment ShadowPassFragment
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightUnlit.shader

             #pragma multi_compile_fog
             #pragma shader_feature _SAMPLE_GI
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma multi_compile_instancing
 
             // Lighting include is needed because of GI
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
                 float2 uv           : TEXCOORD0;
                 float2 lightmapUV   : TEXCOORD1;
                 float3 normal       : NORMAL;
+
+                UNITY_VERTEX_INPUT_INSTANCE_ID
             };
 
             struct VertexOutput
     #endif
 #endif
                 float4 vertex : SV_POSITION;
+
+                UNITY_VERTEX_INPUT_INSTANCE_ID
             };
 
             VertexOutput vert(VertexInput v)
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_TRANSFER_INSTANCE_ID(v, o);
+                
                 o.vertex = TransformObjectToHClip(v.vertex.xyz);
                 o.uv0AndFogCoord.xy = TRANSFORM_TEX(v.uv, _MainTex);
                 o.uv0AndFogCoord.z = ComputeFogFactor(o.vertex.z);
 
             half4 frag(VertexOutput IN) : SV_Target
             {
+                UNITY_SETUP_INSTANCE_ID(IN);
+
                 half2 uv = IN.uv0AndFogCoord.xy;
                 half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
                 half3 color = texColor.rgb * _Color.rgb;