Question Question about transparency and rear faces

I am working on a transparent shader and am coming across an issue I'm hoping there is an easy solution to that I am simply not aware of. I am fading an object, but would like to essentially take the opaque view of the object and fade that. The transparent view shows rear faces and other geometry that I'd prefer to be hidden. In the screen shot, you can see the orange bricks coming through. Some of them are on the back of the object. Does anyone have an ideas?

 

Sorry I'm not sure exactly what I'm looking at as it looks a bit abstract, but could you maybe use alpha clip to fade your objects? Then they would pretty much fade like opaque objects... Without sorting artifacts. But I'm not sure if that's the whole thing you are fading or what. It's usually better to show a clear example case.

Could something like this work for you? (the fading object is the standard Unity sphere mesh)

 

I think that is what I am talking about. Here are more clear example. First is the object rendered as opaque. Next the same view with transparency. In the transparent view, you can see the little rectangular shape showing through. This is what I'm hoping to avoid.

 

Which renderer are you using? Standard, URP, HDRP? It would be good nowadays to tell that when posting graphics related issues as there's so many things done in different ways on different renderers.

 

Good point. I'm using URP.

 

Try this graph, something similar should work. I just put it together quickly, so...
Expose the parameter to interface. On HDRP you have to enable alpha clip in that gear (settings) menu of the Master node but I think URP had it by default visible, if I remember correctly.

 

if it is one single mesh you may try to enable depth write.

 

Thanks for this. I'm thinking that I'm overcomplicating this. I eliminated the excess geometry and got something that is close to the effect I'm going for. Doing the alpha threshold dithering seems to work somewhat, but eliminating the geometry definitely gets the job done.

 

How does one go about enabling that?

 

when it comes to shader graph - hmm, get the shader code from the master node, create a new shader and paste it there.

 

but sorry, if it one mesh it won't work...

 

Okay. Thanks.

 

I could kiss you! I was trying this approach but couldn't get it to work. This did precisely the trick. I'm not doing any vertex modification so this is ideal. Thanks so much!

 

So Ive been attempting to solve this problem aswell. Bit disapointed in URP seaming to take away shader passes, but I am happy to learn a new way if that is what Unity thinks is best.

I did notice however that this problem of a transparent mesh drawing over itself is solved by the default URP shaders...

(Left is simple custom transparent shader, Right the same terrible programmer art (points if you can guess what it is) but with the URP Unlit shader set to transparent mode)

So time to figure out how this default shader does this with out all the... "intricate"... setup proposed above. I found the default URP shader in question in the URP package (See below). It seams that the shader does include multiple passes includeing the

ZWrite On ColorMask 0

depth only pass that I would have used for this job before URP. So how come this works for Unity shaders not custom ones? Would be nice to have access to this ability as it seams to still be possible within URP.

My guess is it is to do with the "DepthOnly" program #defines which dont seam to be docummented anywhere.

Code (CSharp):

1. #pragma vertex DepthOnlyVertex
2. #pragma fragment DepthOnlyFragment

Whole shader source code...

Code (CSharp):

1. Shader "Universal Render Pipeline/Unlit"
2. {
3.     Properties
4.     {
5.         [MainTexture] _BaseMap("Texture", 2D) = "white" {}
6.         [MainColor]   _BaseColor("Color", Color) = (1, 1, 1, 1)
7.         _Cutoff("AlphaCutout", Range(0.0, 1.0)) = 0.5
8.  
9.         // BlendMode
10.         [HideInInspector] _Surface("__surface", Float) = 0.0
11.         [HideInInspector] _Blend("__blend", Float) = 0.0
12.         [HideInInspector] _AlphaClip("__clip", Float) = 0.0
13.         [HideInInspector] _SrcBlend("Src", Float) = 1.0
14.         [HideInInspector] _DstBlend("Dst", Float) = 0.0
15.         [HideInInspector] _ZWrite("ZWrite", Float) = 1.0
16.         [HideInInspector] _Cull("__cull", Float) = 2.0
17.  
18.         // Editmode props
19.         [HideInInspector] _QueueOffset("Queue offset", Float) = 0.0
20.  
21.         // ObsoleteProperties
22.         [HideInInspector] _MainTex("BaseMap", 2D) = "white" {}
23.         [HideInInspector] _Color("Base Color", Color) = (0.5, 0.5, 0.5, 1)
24.         [HideInInspector] _SampleGI("SampleGI", float) = 0.0 // needed from bakedlit
25.     }
26.     SubShader
27.     {
28.         Tags { "RenderType" = "Opaque" "IgnoreProjector" = "True" "RenderPipeline" = "UniversalPipeline" }
29.         LOD 100
30.  
31.         Blend [_SrcBlend][_DstBlend]
32.         ZWrite [_ZWrite]
33.         Cull [_Cull]
34.  
35.         Pass
36.         {
37.             Name "Unlit"
38.             HLSLPROGRAM
39.             // Required to compile gles 2.0 with standard srp library
40.             #pragma prefer_hlslcc gles
41.             #pragma exclude_renderers d3d11_9x
42.  
43.             #pragma vertex vert
44.             #pragma fragment frag
45.             #pragma shader_feature _ALPHATEST_ON
46.             #pragma shader_feature _ALPHAPREMULTIPLY_ON
47.  
48.             // -------------------------------------
49.             // Unity defined keywords
50.             #pragma multi_compile_fog
51.             #pragma multi_compile_instancing
52.  
53.             #include "UnlitInput.hlsl"
54.  
55.             struct Attributes
56.             {
57.                 float4 positionOS       : POSITION;
58.                 float2 uv               : TEXCOORD0;
59.                 UNITY_VERTEX_INPUT_INSTANCE_ID
60.             };
61.  
62.             struct Varyings
63.             {
64.                 float2 uv        : TEXCOORD0;
65.                 float fogCoord  : TEXCOORD1;
66.                 float4 vertex : SV_POSITION;
67.  
68.                 UNITY_VERTEX_INPUT_INSTANCE_ID
69.                 UNITY_VERTEX_OUTPUT_STEREO
70.             };
71.  
72.             Varyings vert(Attributes input)
73.             {
74.                 Varyings output = (Varyings)0;
75.  
76.                 UNITY_SETUP_INSTANCE_ID(input);
77.                 UNITY_TRANSFER_INSTANCE_ID(input, output);
78.                 UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
79.  
80.                 VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
81.                 output.vertex = vertexInput.positionCS;
82.                 output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
83.                 output.fogCoord = ComputeFogFactor(vertexInput.positionCS.z);
84.  
85.                 return output;
86.             }
87.  
88.             half4 frag(Varyings input) : SV_Target
89.             {
90.                 UNITY_SETUP_INSTANCE_ID(input);
91.                 UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
92.  
93.                 half2 uv = input.uv;
94.                 half4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
95.                 half3 color = texColor.rgb * _BaseColor.rgb;
96.                 half alpha = texColor.a * _BaseColor.a;
97.                 AlphaDiscard(alpha, _Cutoff);
98.  
99. #ifdef _ALPHAPREMULTIPLY_ON
100.                 color *= alpha;
101. #endif
102.  
103.                 color = MixFog(color, input.fogCoord);
104.                 alpha = OutputAlpha(alpha);
105.          
106.                 return half4(color, alpha);
107.             }
108.             ENDHLSL
109.         }
110.         Pass
111.         {
112.             Tags{"LightMode" = "DepthOnly"}
113.  
114.             ZWrite On
115.             ColorMask 0
116.  
117.             HLSLPROGRAM
118.             // Required to compile gles 2.0 with standard srp library
119.             #pragma prefer_hlslcc gles
120.             #pragma exclude_renderers d3d11_9x
121.             #pragma target 2.0
122.  
123.             #pragma vertex DepthOnlyVertex
124.             #pragma fragment DepthOnlyFragment
125.  
126.             // -------------------------------------
127.             // Material Keywords
128.             #pragma shader_feature _ALPHATEST_ON
129.  
130.             //--------------------------------------
131.             // GPU Instancing
132.             #pragma multi_compile_instancing
133.  
134.             #include "Packages/com.unity.render-pipelines.universal/Shaders/UnlitInput.hlsl"
135.             #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
136.             ENDHLSL
137.         }
138.  
139.         // This pass it not used during regular rendering, only for lightmap baking.
140.         Pass
141.         {
142.             Name "Meta"
143.             Tags{"LightMode" = "Meta"}
144.  
145.             Cull Off
146.  
147.             HLSLPROGRAM
148.             // Required to compile gles 2.0 with standard srp library
149.             #pragma prefer_hlslcc gles
150.             #pragma exclude_renderers d3d11_9x
151.             #pragma vertex UniversalVertexMeta
152.             #pragma fragment UniversalFragmentMetaUnlit
153.  
154.             #include "Packages/com.unity.render-pipelines.universal/Shaders/UnlitInput.hlsl"
155.             #include "Packages/com.unity.render-pipelines.universal/Shaders/UnlitMetaPass.hlsl"
156.  
157.             ENDHLSL
158.         }
159.     }
160.     FallBack "Hidden/Universal Render Pipeline/FallbackError"
161.     CustomEditor "UnityEditor.Rendering.Universal.ShaderGUI.UnlitShader"
162. }
163.  

 

I think it's better to go for just any material settings for the unlit shader and to pass 1 in the Pass Index (which corresponds to DepthOnly pass).

The other thing I've noticed is I didn't need any overrides, no material, no Depth override. Just Filters settings. In the newer version of URP there's a Light Mode tags setting and I provided DepthOnly and it was enough. In the older version as on the screenshot above it matches Shader Passes. But you need to make sure, the shader has the DepthOnly pass.

 

Is there anyway we can have the same effect for built in?