Toggle "Blend SrcAlpha OneMinusSrcAlpha" in a custominspector?

Hey all, I've been researching every possible angle on this one. I am a bit stumped.

Right now, I am completing the unification of my shaders into a simple multi-compile solution on Unity 4.6.3. I have a custom inspector working, and all of my multicompile features within the CGPROGRAM of the script is working great. No complaints there.

What I can't figure out is toggling the Blend keyword and SubShader tags to change the RenderType and Queue depending on what the material is being used for. From what I can tell so far, this is not possible. If it is, please enlighten me! I'm very interested in binding this to a precompiled solution and my Google-Fu is failing me.

Another way I'm looking at this problem is understanding how the Blend keyword operates in ShaderLab. In the context of mobile shader development and avoiding unnecessary blending whenever possible (like OpenGL ES 2.0 specifically with PowerVR devices), is Unity smart enough to know when I'm not using any alpha values other than 1, and "boil out" that blending process? My assumption is, "No, it is not that smart, and it is always blending." Any insights on the specifics of this would be appreciated!

Presently, my next point to test is to fidget around with some #if define directives and see if I can use Material.Enable/DisableKeyword. Wish me luck.


-d

 

Hey all, bumping for good measure.

I have already gone ahead and developed a solution to safely work around this lack of understanding. That said, I decided to play it safe and segregate Blend Off and Blend SrcAlpha OneMinusSrcAlpha into separate shaders. Regardless of this, this kind of clarification would likely save people a lot of time in the future, as well as satiate my curiosity

Cheers,

-d

 

Hey Guillaume, thank you very much for the reply. This highlights my misunderstandings very nicely and shines some light on a specific route I have never considered or read about before.

This is very helpful! I will let you know if this works in 4.6.3. Crossing my fingers!

 

Thanks for this information as it impacts some shader work i'm currently doing and had been wondering how to deal with an mega shader using blending or not. That in turn had led me to wondering how the new Standard Shader in Unity achieved this and from examining the standardShaderGUI.cs I can see its exactly as you outlined in your post.

However i'm now somewhat concerned that this means the standard shader is not as efficient as it could or should be due to a lack of being able to control the use of blending in the shader. Whilst overdraw and sorting are issues for transparent blending, when you are meant to be rendering an opaque mesh they shouldn't be.

This leads me to the big question, does using the blend keyword in a shader mean the gpu is still reading the backbuffer (to get the dst color/alpha) when for an opaque mesh it doesn't need to, and wouldn't such an action add a considerable overhead?

I'm unsure of the answer, so i'm going to do some digging online and maybe try to build a test suite. If true then I feel either Unity are going to need to update and split their standard shader ( opaque vs transparent) or there needs to be some means added to shader compilation that can provide the ability to dynamically enable or disable blending keyword in the shader completely.

There is a way to disable blend in a shader by having 'Blend Off', but i'm not sure that can be accomplished dynamically using custom material property drawers since it would need to be in the form 'Blend [ _src ] [ _dst ]'. Would 'Blend Off Off' be valid shaderlab code? If not could this maybe be implemented in a future version, along with adding 'Off' as a enumeration to the existing blendMode attributes?

 

Thanks for the fast reply and this very useful information.

 

That looks pretty smart to me!

 

Here is what I ended up using inside of my material properties in order to access these guys. I love property drawers. I'm working in Unity 4.6.3 presently:

Code (CSharp):

1. [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend ("BlendSource", Float) = 1
2. [Enum(UnityEngine.Rendering.BlendMode)] _DstBlend ("BlendDestination", Float) = 0
3. [Enum(UnityEngine.Rendering.CullMode)] _Cull ("Cull", Float) = 0
4. [Toggle] _ZWrite ("ZWrite", Float) = 0

In my custom inspector, I had it do a check to confirm if the set blending options would enable or disable, and then set the m.renderQueue value that way:

Code (CSharp):

1.  
2. //... GenericCustomMaterialInspector.cs ...
3. // ... OnInspectorGUI ...
4. // ... target as Material
5.  
6. //Check the blend settings.
7. int src = target.GetInt("_SrcBlend");
8. int dst =  target.GetInt("_DstBlend");
9.  
10. // Return true if blending. This function just checks if the paired settings are blending or not.
11. bool isBlending = DoesItBlend(src, dst);
12.  
13. //Let's set the render queue based on the current blendmode.
14. if (isBlending) {
15.      Debug.Log("GenericCustomMaterialInspector : It blends!");
16.      target.renderQueue = 3000;
17.  
18. } else {
19.      Debug.Log("GenericCustomMaterialInspector : Don't breathe this!");
20.      target.renderQueue = 2000;
21. }
22.  
23. Debug.Log (target + " has a renderQueue of " + target.renderQueue + ".");
24.  

Thanks for pointing me in the right direction y'all.

 

You can also use enums in the shaders themselves: https://gist.github.com/aras-p/b2a0952161cb0c2b2cc0

Edit: sorry, didn't see that you were doing this already.

 

It's just what I looked for! It was had to find =/
Thanks)