#pragma multi_compile

Hello, I am wondering about #pragma multi_compile.

If I use #define, it works fine.

Code (csharp):

1.  
2. Shader "Test" {
3.     Properties {
4.         _Color   ("Color"     , Color) = (1, 1, 1, 1)
5.         _MainTex ("Base (RGB)", 2D   ) = "white" {}
6.         _Cube    ("Cube"      , CUBE ) = "black" {}
7.     }
8.    
9.     SubShader {
10.         Tags { "RenderType"="Opaque" }
11.         LOD 200
12.        
13.         CGPROGRAM
14.             #pragma surface surf Lambert
15.             #define ON
16.            
17.             half4 _Color;
18.            
19.             #if defined (ON)
20.                 sampler2D _MainTex;
21.                 samplerCUBE _Cube;
22.             #endif
23.            
24.             struct Input {
25.                 float2 uv_MainTex;
26.                 float3 worldRefl;
27.             };
28.            
29.             void surf (Input IN, inout SurfaceOutput o) {
30.                 half4 c = _Color;
31.                 half4 r;
32.                
33.                 #if defined (ON)
34.                     c *= tex2D (_MainTex, IN.uv_MainTex);
35.                     r  = texCUBE (_Cube, IN.worldRefl);
36.                     o.Emission = r.rgb;
37.                 #endif
38.                
39.                 o.Albedo = c.rgb;
40.                 o.Alpha  = c.a;
41.             }
42.         ENDCG
43.     }
44.    
45.     FallBack "Diffuse"
46. }
47.  

But, I use #pragma multi_compile, it doesn't works.

Code (csharp):

1.  
2. Shader "Test" {
3.     Properties {
4.         _Color   ("Color"     , Color) = (1, 1, 1, 1)
5.         _MainTex ("Base (RGB)", 2D   ) = "white" {}
6.         _Cube    ("Cube"      , CUBE ) = "black" {}
7.     }
8.    
9.     SubShader {
10.         Tags { "RenderType"="Opaque" }
11.         LOD 200
12.        
13.         CGPROGRAM
14.             #pragma surface surf Lambert
15.             #pragma multi_compile ON OFF
16.            
17.             half4 _Color;
18.            
19.             #if defined (ON)
20.                 sampler2D _MainTex;
21.                 samplerCUBE _Cube;
22.             #endif
23.            
24.             struct Input {
25.                 float2 uv_MainTex;
26.                 float3 worldRefl;
27.             };
28.            
29.             void surf (Input IN, inout SurfaceOutput o) {
30.                 half4 c = _Color;
31.                 half4 r;
32.                
33.                 #if defined (ON)
34.                     c *= tex2D (_MainTex, IN.uv_MainTex);
35.                     r  = texCUBE (_Cube, IN.worldRefl);
36.                     o.Emission = r.rgb;
37.                 #endif
38.                
39.                 o.Albedo = c.rgb;
40.                 o.Alpha  = c.a;
41.             }
42.         ENDCG
43.     }
44.    
45.     FallBack "Diffuse"
46.     CustomEditor "Test_Editor"
47. }
48.  

Code (csharp):

1.  
2. using System.Collections.Generic;
3. using UnityEngine;
4. using UnityEditor;
5. using System.Linq;
6.  
7. public class Test_Editor : MaterialEditor {
8.     public override void OnInspectorGUI () {
9.         base.OnInspectorGUI ();
10.         if (!isVisible){
11.             return;
12.         }
13.        
14.         Material targetMat = target as Material;
15.         string[] keyWords  = targetMat.shaderKeywords;
16.        
17.         bool redify = keyWords.Contains("ON");
18.        
19.         EditorGUI.BeginChangeCheck ();
20.        
21.         redify = EditorGUILayout.Toggle ("ON", redify);
22.        
23.         if (EditorGUI.EndChangeCheck ()) {
24.             var keywords = new List<string> { redify ? "ON" : "OFF"};
25.             targetMat.shaderKeywords = keywords.ToArray ();
26.             EditorUtility.SetDirty (targetMat);
27.         }
28.     }
29. }
30.  

Program 'frag_surf', variable 'surfIN' used without having been completely initialized.

 

Don't use

#if defined(symbol)

but

#if symbol

That works for me.

 

Realy?

I tried to use #if and #ifdef, but didn't work both.

 

The multi compile version get compiled twice, once with ON defined and once without it. The version withou ON gives error when compiling for D3D11 if you don't initialize emission.
Try setting emission to zero in #else block.
Hope that helps, I can't verify now.

 

Thank you for your reply but it doesn't works.

Now, I tried to get out _MainTex(uv_MainTex, tex2D) from #if, there is no error, but emission still doesn't works.:-?

 

+1. I have exactly the same problem. Please help

 

Does it work if you set the keyword globally with Shader.EnableKeyword("ON")?
I think iaanus meant #ifdef keyword instead of just #if

 

this does not work too :[

 

I may have just run into the same problem you are seeing. It appears that sometimes the shader system removes interpolators too aggressively when using #pragma multi_compile in combination with surface shaders. You can work around this problem by referencing all interpolators in all multi compile permutations. The problem does not seem to affect explicit vertex/fragment shaders.

In your case the workaround would be something like:

Code (csharp):

1.  
2. #if defined (ON)
3. c *= tex2D (_MainTex, IN.uv_MainTex);
4. r  = texCUBE (_Cube, IN.worldRefl);
5. o.Emission = r.rgb;
6. #else
7. // Reference interpolators here but multiply by a really small number so they don't really change the final result
8. o.Emission = IN.uv_MainTex.x * IN.worldRefl.x * 0.000001;
9. #endif
10.  

I have submitted a bug to Unity showing the problem. For those interested here is a package showing the bug and a workaround.

Edit: Just tried the package on PC (was testing on Mac before). Now I get a load of D3D errors and the same warning about 'surfIN' not being fully initialised. Looks to be the same problem but D3D is stricter about it than OpenGL.

 

Not at my work rig at the moment, but try using

Code (csharp):

1.  
2. #pragma multi_compile ON OFF
3.  
4. ....
5.  
6. #ifdef ON
7. #endif
8.  
9. #ifdef OFF
10. #endif
11.  

and in your script --

Code (csharp):

1.  
2. Shader.EnableKeyword("ON");
3. Shader.DisableKeyword("OFF");
4.  

..depending on which one you're after.

 

Just to clarify. The problem I have isn't to do with the usage of the shader keyword defines in the shader or the enabling/disabling of keywords from script. The problem I'm seeing is in the code Unity generates from the surface shader code. If I enable #pragma debug I can see that there are missing interpolators in the v2f_surf struct that Unity generates from the Input struct. This means that when I sample textures in the fragment shader rather than getting correct texture coordinates I just get a default value of 0.

Edit: If you open the package I posted earlier and open the compiled shader for 'ShaderBroken' you can see that there is no interpolator for the main texture coordinate in v2f_surf. If you open the compiled shader for 'ShaderWorkaround' you will see an interpolator called 'pack0', Unity packs the main texture coordinate into this and everything works fine.

 

No worries Gibbonator.
My post was in reply to #ifdef not working correctly a few posts up.. just in case it was a mixup with the defines

 

+1. I have the same problem.

 

I have solved it.

#if defined (ON) - replace - #ifndef OFF

Good to know why :?:

 

After a bit more experimentation I think I've figured out what's going on. It appears that for the purposes of determining which interpolators are required Unity assumes that none of the custom multicompile keywords are defined.

So if I do this:

Code (csharp):

1.  
2. #pragma multi_compile FEATURE_OFF FEATURE_ON
3.  
4. void surf(Input IN, inout SurfaceOutput o)
5. {
6.     #if defined(FEATURE_ON)
7.     o.Emission = tex2D(_MainTex, IN.uv_MainTex) * texCUBE(_CubeTex, IN.dir);
8.     #endif
9. }
10.  

I get these interpolators:

Code (csharp):

1.  
2. struct v2f_surf {
3.   float4 pos : SV_POSITION;
4.   float3 cust_dir : TEXCOORD0;
5.   float2 lmap : TEXCOORD1;
6.   LIGHTING_COORDS(2,3)
7. };
8.  

There is no interpolator for uv_MainTex, which is why it breaks.

But if I do this:

Code (csharp):

1.  
2. #pragma multi_compile FEATURE_OFF FEATURE_ON
3.  
4. void surf(Input IN, inout SurfaceOutput o)
5. {
6.     // Workaround code
7.     #if !defined(FEATURE_OFF)  !defined(FEATURE_ON)
8.     o.Emission = IN.uv_MainTex.x * IN.dir.x;
9.     #endif
10.    
11.     // Actual code
12.     #if defined(FEATURE_ON)
13.     o.Emission = tex2D(_MainTex, IN.uv_MainTex) * texCUBE(_CubeTex, IN.dir);
14.     #endif
15. }
16.  

I get these interpolators:

Code (csharp):

1.  
2. struct v2f_surf {
3.   float4 pos : SV_POSITION;
4.   float2 pack0 : TEXCOORD0;
5.   float3 cust_dir : TEXCOORD1;
6.   float2 lmap : TEXCOORD2;
7.   LIGHTING_COORDS(3,4)
8. };
9.  

uv_MainTex is put in the pack0 interpolator.

This is better than the previous workaround because the workaround code never makes it into the final shaders.

@Arkhivrag: Your code started working when you changed #if defined (ON) to #ifndef OFF because the code will now be present in the case when you have ON !OFF and also in the case where you have !ON !OFF.

Edit: In the interests of coming up with a tidier workaround to these problems I've come up with this:

Code (csharp):

1.  
2. #pragma multi_compile FEATURE_OFF FEATURE_ON
3.  
4. #if !defined(FEATURE_OFF)  !defined(FEATURE_ON)
5. #define GET_INTERPOLATORS
6. #endif
7.  
8. void surf(Input IN, inout SurfaceOutput o)
9. {
10.     #if defined(FEATURE_ON) || defined(GET_INTERPOLATORS)
11.     o.Emission = tex2D(_MainTex, IN.uv_MainTex) * texCUBE(_CubeTex, IN.dir);
12.     #endif
13. }
14.  

What this does is define a new keyword (GET_INTERPOLATORS) for when Unity is determining which interpolators are used. You can then use this keyword in all your multicompile code blocks to ensure that they are taken into account.

Edit 2: This also works and is more scalable if you have several multi compiles.

Code (csharp):

1.  
2. #pragma multi_compile FEATURE_OFF FEATURE_ON
3. #pragma multi_compile IS_MULTI_COMPILE
4.  
5. void surf(Input IN, inout SurfaceOutput o)
6. {
7.     #if defined(FEATURE_ON) || !defined(IS_MULTI_COMPILE)
8.     o.Emission = tex2D(_MainTex, IN.uv_MainTex) * texCUBE(_CubeTex, IN.dir);
9.     #endif
10. }
11.  

 

@Gibbonator
Thanks for answer. But as it happens only in surface shaders and not in fragment shaders - I suppose think it is a bug and requires improvement from Unity.

Here is example where your suggestion does not work. Mine too

Code (csharp):

1. Shader "Custom/test"
2. {
3.    SubShader
4.    {
5.       Tags { "RenderType" = "Opaque" }
6.       CGPROGRAM
7.       #pragma surface surf Lambert
8.       #pragma only_renderers d3d9
9.       #pragma multi_compile OFF ON
10.  
11.       #if !defined(OFF)  !defined(ON)
12.       #define GET_INTERPOLATORS
13.       #endif
14.  
15.       struct Input
16.       {
17.           float4 color : COLOR;
18.  
19.           #if defined(ON) || defined(GET_INTERPOLATORS)
20.              float3 viewDir;
21.           #endif
22.       };
23.  
24.       void surf (Input IN, inout SurfaceOutput o)
25.       {
26.           half3 albedo = half3(1, 0, 0);
27.  
28.           #if defined(ON) || defined(GET_INTERPOLATORS)
29.             albedo = IN.viewDir;
30.           #endif
31.  
32.           o.Albedo = albedo;
33.       }
34.  
35.       ENDCG
36.     }
37.  
38.     Fallback "Diffuse"
39. }

Can not use #pragma debug - unrecognized #pragma debug at line 10

 

The problem here is the conditionals in the Input struct. I'm not sure how to work around that. Given that Unity will only create one set of interpolators anyway makes trying to remove things from the Input struct redundant. That set of interpolators would need to be the set of all required interpolators across all multicompile permutations. Ideally Unity would create a new set of interpolators for each multicompile permutation but this doesn't seem to be the case

 

Did you ever get any feedback from Unity developers regarding the bug report you submitted? I just ran into this issue late last week and have been searching for a solution. I was able to narrow the compiler error down, and below is a very simplified version of my shader. If I change colorB's assignment to "colorB = tex2D(_Color2Tex, IN.uv_Color1Tex);", then everything compiles fine. Using the second uv set is causing the uninitialized component compilation error.

Code (csharp):

1.  
2. Shader "SimpleSensor/Diffuse" {
3. Properties {
4.     _Color1Tex ("Base (RGB)", 2D) = "white" {}
5.     _Color2Tex ("Heat", 2D) = "white" {}
6. }
7. SubShader {
8.     Tags { "RenderType"="Opaque" }
9.     LOD 200
10.  
11. CGPROGRAM
12. #pragma surface surf Lambert
13. #pragma multi_compile USE_COLOR_A USE_COLOR_B
14. #pragma debug
15.  
16. sampler2D _Color1Tex;
17. sampler2D _Color2Tex;
18.  
19. struct Input {
20.     float2 uv_Color1Tex;
21.     float2 uv2_Color2Tex;
22. };
23.  
24.  
25. void surf (Input IN, inout SurfaceOutput o)
26. {
27.     float4 colorA = tex2D(_Color1Tex, IN.uv_Color1Tex);
28.  
29.     // this one doesn't compile
30.     float4 colorB = tex2D(_Color2Tex, IN.uv2_Color2Tex);
31.  
32.     // replacing In.uv2_Color2Tex with In.uv_Color1Tex fixes compilation error,
33.     // but I lose my ability to use the second UV set.
34.  
35.     float4 color = 0;
36.    
37. #if USE_COLOR_A
38.     color = colorA;
39. #endif
40.  
41. #if USE_COLOR_B
42.     color = colorB;
43. #endif
44.  
45.     o.Albedo.rgb = color.rgb;
46.     o.Alpha = color.a;
47. }
48.  
49.  
50. ENDCG
51. }
52.  
53. Fallback "Diffuse"
54. }
55.  

 

Unfortunately I have not heard anything from Unity on this issue. The issue is still open in FogBugz though, so they may still get back to me.

 

Out of interest, does this work?

Code (csharp):

1.  
2. Shader "SimpleSensor/Diffuse" {
3. Properties {
4.     _Color1Tex ("Base (RGB)", 2D) = "white" {}
5.     _Color2Tex ("Heat", 2D) = "white" {}
6.  
7. }
8. SubShader {
9.     Tags { "RenderType"="Opaque" }
10.     LOD 200
11.  
12. CGPROGRAM
13. #pragma surface surf Lambert
14. #pragma multi_compile USE_COLOR_A USE_COLOR_B
15. #pragma multi_compile IS_MULTI_COMPILE
16. #pragma debug
17.  
18. sampler2D _Color1Tex;
19. sampler2D _Color2Tex;
20.  
21. struct Input {
22.     float2 uv_Color1Tex;
23.     float2 uv2_Color2Tex;
24. };
25.  
26. void surf (Input IN, inout SurfaceOutput o)
27. {
28.     float4 colorA = tex2D(_Color1Tex, IN.uv_Color1Tex);
29.  
30.     // this one doesn't compile
31.     float4 colorB = tex2D(_Color2Tex, IN.uv2_Color2Tex);
32.  
33.     // replacing In.uv2_Color2Tex with In.uv_Color1Tex fixes compilation error,
34.     // but I lose my ability to use the second UV set.
35.  
36.     float4 color = 0;
37.  
38. #if USE_COLOR_A
39.     color = colorA;
40. #endif
41.  
42. #if USE_COLOR_B
43.     color = colorB;
44. #endif
45.  
46. #if IS_MULTI_COMPILE
47.     o.Albedo.rgb = color.rgb;
48. #else
49.     o.Albedo.rgb = colorA.rgb * colorB.rgb;
50. #endif
51.     o.Alpha = color.a;
52. }
53.  
54. ENDCG
55. }
56.  
57. Fallback "Diffuse"
58. }
59.  

 

YES! Thank you! What I cannot figure out though is "why does this work?"

btw... I apologize for the late reply. I'm being pulled in multiple directions lately.

 

What does

Code (csharp):

1. multi_compile_particles

actually do?

 

Wow I've just ran into this issue in 4.2.2f1 --- seems like this wasn't important enough to fix at any point during the last 2.5 months? (Or even updating the docs for #pragma multi_compile / custom material editors could have done the trick to save some of us an hour or three of confused frustation.)

So multi_compile doesn't work with surface shaders. Well why should two great features be indeed combinable as implicated possible in the docs, right?

So we have to keep creating many .shader files for all possible permutations and cginc everything everywhere, when multi_compile could in theory solve this so elegantly (if it actually worked fully with surface shaders)? This is insanity.

So Gibbonator can you give us the FogBugz ID? Or at least let us know if anyone ever got back to you?

 

I'm stuck on this bug too. No progress yet in FogBugz?

 

Haven't heard back yet..

 

WOAH looking through the 4.3 release notes I see this nuggest:

Shaders: Fixed #pragma multi_compile shader variants not working with surface shaders in some cases

Here's hoping! Will hold out for a few days before updating though (in the middle of a mess right now etc), if anyone does before me, do report back

 

Below code works in 4.3! Haven't tested more complex stuff yet.

Code (csharp):

1. Shader "Custom/MulticompTest" {
2.     Properties {
3.         _Color ("Main Color", Color) = (1,1,1,1)
4.         _MainTex ("Base (RGB)", 2D) = "white" {}
5.         _BumpMap ("Normalmap", 2D) = "bump" {}
6.     }
7.    
8.     SubShader {
9.         Tags { "RenderType"="Opaque" }
10.         LOD 300
11.    
12.         CGPROGRAM
13.         #pragma surface surf Lambert
14.         #pragma multi_compile BUMP_OFF BUMP_ON
15.        
16.         sampler2D _MainTex;
17.         #ifdef BUMP_ON
18.         sampler2D _BumpMap;
19.         #endif
20.         fixed4 _Color;
21.        
22.         struct Input {
23.             float2 uv_MainTex;
24.             #ifdef BUMP_ON
25.             float2 uv_BumpMap;
26.             #endif
27.         };
28.        
29.         void surf (Input IN, inout SurfaceOutput o) {
30.             fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
31.             o.Albedo = c.rgb;
32.             o.Alpha = c.a;
33.             #ifdef BUMP_ON
34.             o.Normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
35.             #endif
36.         }
37.         ENDCG  
38.     }
39.    
40.     FallBack OFF
41.     CustomEditor "MulticompTest"
42. }
43.  

Code (csharp):

1. using System.Collections.Generic;
2. using UnityEngine;
3. using UnityEditor;
4. using System.Linq;
5.  
6. public class MulticompTest : MaterialEditor {
7.     public override void OnInspectorGUI () {
8.         base.OnInspectorGUI ();
9.         if (!isVisible)
10.             return;
11.        
12.         Material targetMat = target as Material;
13.         string[] keyWords = targetMat.shaderKeywords;
14.        
15.         bool bump = keyWords.Contains ("BUMP_ON");
16.         EditorGUI.BeginChangeCheck();
17.         bump = EditorGUILayout.Toggle ("Bump mappped", bump);
18.         if (EditorGUI.EndChangeCheck()) {
19.             var keywords = new List<string> { bump ? "BUMP_ON" : "BUMP_OFF"};
20.             targetMat.shaderKeywords = keywords.ToArray ();
21.             EditorUtility.SetDirty (targetMat);
22.         }
23.     }
24. }

 

Note 4.3 supposedly also introduced EnableKeyword() and DisableKeyword()

 

But they didn't change the example in the docs

 

Has there ever been an update to the docs synced timely with an update to the Editor? sometimes I think the docs are just some dude's weekend hobby..