Partially transparent speedtrees - ideas ?

Hi forum,

I'm trying to make speedtrees (r) appear semi-transparent when located between the camera and the player, in a 3D game. Some commercial games manage to do that, even if Speedtree's native shader lacks a "transparency" variable and is not designed for that.

I'm reluctant to switch from Speedtree's native shader to something more simple since I would lose part of Speedtree's magic in the process, but I can't figure out a solution. Even manual blending between extra grabpasses (as described in details here) does not yield a perfect result as it should.

Does one of you have ideas or experience in that matter?

 

I tried to use the approach described in the post you linked to on the speedtree forums, and it works for me... in the Editor. In the Editor, I now have trees with leaves that go transparent when they appear between the camera and the terrain, whether those trees are SpeedTrees or Tree-Creator Trees, and whether they are added as terrain-trees or as manually placed game-objects.

My problem happens at compile time, where Unity complains about the uvgrab variable in the v2f struct:

Shader error in 'Nature/SpeedTree_Transparent': Inconsistent semantic definition: output semantic 'TEXCOORD1' and output semantic 'TEXCOORD3' at line 184 (on d3d9)
Shader error in 'Nature/SpeedTree_Transparent': Duplicated input semantics can't change type, size, or layout ('TEXCOORD3'), at line 185 (on d3d11)
Sbader error in 'Nature/SpeedTree_Transparent': output TEXCOORD3 used more than once at line 185 (on d3d11)

The lines in question:

struct v2f

{

    float4 vertex    : SV_POSITION;

    UNITY_FOG_COORDS(0)

    Input data        : TEXCOORD1;

    float4 uvgrab     : TEXCOORD3;

    UNITY_VERTEX_INPUT_INSTANCE_ID

    UNITY_VERTEX_OUTPUT_STEREO

};

Unfortunately I'm no shader guru, so I don't know why this is happening on compile time or how to fix it :/

 

Welp. After doing some switcheroos (uvgrab to TEXCOORD1, data to TEXCOORD4), I managed to get the transparent SpeedTree shader working in both the Editor and in a compiled build. Not sure what potential side-effects my shenanigans will cause, but for now it seems to be working. Here's the full shader code for anyone interested:

Spoiler: Transparent SpeedTree shader

Code (CSharp):

1. // Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
2.  
3. Shader "Nature/SpeedTree_Transparent"
4. {
5.     Properties
6.     {
7.         _Color ("Main Color", Color) = (1,1,1,1)
8.         _HueVariation ("Hue Variation", Color) = (1.0,0.5,0.0,0.1)
9.         _MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
10.         _DetailTex ("Detail", 2D) = "black" {}
11.         _BumpMap ("Normal Map", 2D) = "bump" {}
12.         _Cutoff ("Alpha Cutoff", Range(0,1)) = 0.333
13.         _Transparency ("Transparency", Range(0,1)) = 0.2
14.         [MaterialEnum(Off,0,Front,1,Back,2)] _Cull ("Cull", Int) = 2
15.         [MaterialEnum(None,0,Fastest,1,Fast,2,Better,3,Best,4,Palm,5)] _WindQuality ("Wind Quality", Range(0,5)) = 0
16.     }
17.  
18.     // targeting SM3.0+
19.     SubShader
20.     {
21.         Tags
22.         {
23.             "Queue"="Geometry"
24.             "IgnoreProjector"="True"
25.             "RenderType"="Opaque"
26.             "DisableBatching"="LODFading"
27.         }
28.         LOD 400
29.         Cull [_Cull]
30.  
31.         CGPROGRAM
32.             #pragma surface surf Lambert vertex:SpeedTreeVert nodirlightmap nodynlightmap noshadowmask
33.             #pragma target 3.0
34.             #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
35.             #pragma instancing_options assumeuniformscaling lodfade maxcount:50
36.             #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
37.             #pragma shader_feature EFFECT_BUMP
38.             #pragma shader_feature EFFECT_HUE_VARIATION
39.             #define ENABLE_WIND
40.             #include "SpeedTreeCommon.cginc"
41.  
42.             void surf(Input IN, inout SurfaceOutput OUT)
43.             {
44.                 SpeedTreeFragOut o;
45.                 SpeedTreeFrag(IN, o);
46.                 SPEEDTREE_COPY_FRAG(OUT, o)
47.             }
48.         ENDCG
49.  
50.         GrabPass
51.         {
52.             "_GrabFondScene"
53.         }
54.  
55.         Pass
56.         {
57.             Tags { "LightMode" = "ShadowCaster" }
58.  
59.             CGPROGRAM
60.                 #pragma vertex vert
61.                 #pragma fragment frag
62.                 #pragma target 3.0
63.                 #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
64.                 #pragma multi_compile_instancing
65.                 #pragma instancing_options assumeuniformscaling lodfade maxcount:50
66.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
67.                 #pragma multi_compile_shadowcaster
68.                 #define ENABLE_WIND
69.                 #include "SpeedTreeCommon.cginc"
70.  
71.                 struct v2f
72.                 {
73.                     V2F_SHADOW_CASTER;
74.                     #ifdef SPEEDTREE_ALPHATEST
75.                         float2 uv : TEXCOORD1;
76.                     #endif
77.                     UNITY_DITHER_CROSSFADE_COORDS_IDX(2)
78.                     UNITY_VERTEX_INPUT_INSTANCE_ID
79.                     UNITY_VERTEX_OUTPUT_STEREO
80.                 };
81.  
82.                 v2f vert(SpeedTreeVB v)
83.                 {
84.                     v2f o;
85.                     UNITY_SETUP_INSTANCE_ID(v);
86.                     UNITY_TRANSFER_INSTANCE_ID(v, o);
87.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
88.                     #ifdef SPEEDTREE_ALPHATEST
89.                         o.uv = v.texcoord.xy;
90.                     #endif
91.                     OffsetSpeedTreeVertex(v, unity_LODFade.x);
92.                     TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
93.                     UNITY_TRANSFER_DITHER_CROSSFADE_HPOS(o, o.pos)
94.  
95.                     return o;
96.                 }
97.  
98.                 float4 frag(v2f i) : SV_Target
99.                 {
100.                     UNITY_SETUP_INSTANCE_ID(i);
101.                     #ifdef SPEEDTREE_ALPHATEST
102.                         clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
103.                     #endif
104.                     UNITY_APPLY_DITHER_CROSSFADE(i)
105.                     SHADOW_CASTER_FRAGMENT(i)
106.                 }
107.             ENDCG
108.         }
109.  
110.         GrabPass { }
111.  
112.         Pass
113.         {
114.             Tags { "LightMode" = "Vertex" }
115.  
116.             CGPROGRAM
117.                 #pragma vertex vert
118.                 #pragma fragment frag
119.                 #pragma target 3.0
120.                 #pragma multi_compile_fog
121.                 #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
122.                 #pragma multi_compile_instancing
123.                 #pragma instancing_options assumeuniformscaling lodfade maxcount:50
124.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
125.                 #pragma shader_feature EFFECT_HUE_VARIATION
126.                 #define ENABLE_WIND
127.                 #include "SpeedTreeCommon.cginc"
128.  
129.                 struct v2f
130.                 {
131.                     float4 vertex    : SV_POSITION;
132.                     UNITY_FOG_COORDS(0)
133.                     Input data        : TEXCOORD1;
134.                     UNITY_VERTEX_INPUT_INSTANCE_ID
135.                     UNITY_VERTEX_OUTPUT_STEREO
136.                 };
137.  
138.                 v2f vert(SpeedTreeVB v)
139.                 {
140.                     v2f o;
141.                     UNITY_SETUP_INSTANCE_ID(v);
142.                     UNITY_TRANSFER_INSTANCE_ID(v, o);
143.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
144.                     SpeedTreeVert(v, o.data);
145.                     o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 4, true);
146.                     o.vertex = UnityObjectToClipPos(v.vertex);
147.                     UNITY_TRANSFER_FOG(o,o.vertex);
148.                     return o;
149.                 }
150.  
151.                 fixed4 frag(v2f i) : SV_Target
152.                 {
153.                     UNITY_SETUP_INSTANCE_ID(i);
154.                     SpeedTreeFragOut o;
155.                     SpeedTreeFrag(i.data, o);
156.                     fixed4 c = fixed4(o.Albedo, o.Alpha);
157.                     UNITY_APPLY_FOG(i.fogCoord, c);
158.                     return c;
159.                 }
160.             ENDCG
161.         }
162.  
163.         Pass
164.         {
165.             Tags { "LightMode" = "Always" }
166.  
167.             CGPROGRAM
168.                 #pragma vertex vert
169.                 #pragma fragment frag
170.                 #pragma target 3.0
171.                 #pragma multi_compile_fog
172.                 #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
173.                 #pragma multi_compile_instancing
174.                 #pragma instancing_options assumeuniformscaling lodfade maxcount:50
175.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
176.                 #pragma shader_feature EFFECT_HUE_VARIATION
177.                 #define ENABLE_WIND
178.                 #include "SpeedTreeCommon.cginc"
179.  
180.                 struct v2f
181.                 {
182.                     float4 vertex    : SV_POSITION;
183.                     UNITY_FOG_COORDS(0)
184.                       float4 uvgrab     : TEXCOORD1;
185.                     Input data        : TEXCOORD4;
186.                     UNITY_VERTEX_INPUT_INSTANCE_ID
187.                     UNITY_VERTEX_OUTPUT_STEREO
188.                 };
189.  
190.                 v2f vert(SpeedTreeVB v)
191.                 {
192.                     v2f o;
193.                     UNITY_SETUP_INSTANCE_ID(v);
194.                     UNITY_TRANSFER_INSTANCE_ID(v, o);
195.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
196.                     SpeedTreeVert(v, o.data);
197.                     o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 4, true);
198.                     o.vertex = UnityObjectToClipPos(v.vertex);
199.                     UNITY_TRANSFER_FOG(o,o.vertex);
200.                     o.uvgrab = ComputeGrabScreenPos(o.vertex);
201.                     return o;
202.                 }
203.  
204.                 sampler2D _GrabFondScene;
205.                 sampler2D _GrabTexture;
206.                 float _Transparency;
207.  
208.                 fixed4 frag(v2f i) : SV_Target
209.                 {
210.                     UNITY_SETUP_INSTANCE_ID(i);
211.                     SpeedTreeFragOut o;
212.                     SpeedTreeFrag(i.data, o);
213.                     fixed4 c = tex2Dproj( _GrabTexture, i.uvgrab)*(1-_Transparency) + tex2Dproj( _GrabFondScene, i.uvgrab)*_Transparency;
214.                     UNITY_APPLY_FOG(i.fogCoord, c);
215.                     return c;
216.                 }
217.             ENDCG
218.         }
219.     }
220.  
221.     // targeting SM2.0: Cross-fading, Normal-mapping, Hue variation and Wind animation are turned off for less instructions
222.     SubShader
223.     {
224.         Tags
225.         {
226.             "Queue"="Geometry"
227.             "IgnoreProjector"="True"
228.             "RenderType"="Opaque"
229.             "DisableBatching"="LODFading"
230.         }
231.         LOD 400
232.         Cull [_Cull]
233.  
234.         CGPROGRAM
235.             #pragma surface surf Lambert vertex:SpeedTreeVert nodirlightmap nodynlightmap noshadowmask
236.             #pragma multi_compile __ LOD_FADE_PERCENTAGE
237.             #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
238.             #include "SpeedTreeCommon.cginc"
239.  
240.             void surf(Input IN, inout SurfaceOutput OUT)
241.             {
242.                 SpeedTreeFragOut o;
243.                 SpeedTreeFrag(IN, o);
244.                 SPEEDTREE_COPY_FRAG(OUT, o)
245.             }
246.         ENDCG
247.  
248.         Pass
249.         {
250.             Tags { "LightMode" = "ShadowCaster" }
251.  
252.             CGPROGRAM
253.                 #pragma vertex vert
254.                 #pragma fragment frag
255.                 #pragma multi_compile __ LOD_FADE_PERCENTAGE
256.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
257.                 #pragma multi_compile_shadowcaster
258.                 #include "SpeedTreeCommon.cginc"
259.  
260.                 struct v2f
261.                 {
262.                     V2F_SHADOW_CASTER;
263.                     #ifdef SPEEDTREE_ALPHATEST
264.                         float2 uv : TEXCOORD1;
265.                     #endif
266.                 };
267.  
268.                 v2f vert(SpeedTreeVB v)
269.                 {
270.                     v2f o;
271.                     #ifdef SPEEDTREE_ALPHATEST
272.                         o.uv = v.texcoord.xy;
273.                     #endif
274.                     OffsetSpeedTreeVertex(v, unity_LODFade.x);
275.                     TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
276.                     return o;
277.                 }
278.  
279.                 float4 frag(v2f i) : SV_Target
280.                 {
281.                     #ifdef SPEEDTREE_ALPHATEST
282.                         clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
283.                     #endif
284.                     SHADOW_CASTER_FRAGMENT(i)
285.                 }
286.             ENDCG
287.         }
288.  
289.         Pass
290.         {
291.             Tags { "LightMode" = "Vertex" }
292.  
293.             CGPROGRAM
294.                 #pragma vertex vert
295.                 #pragma fragment frag
296.                 #pragma multi_compile_fog
297.                 #pragma multi_compile __ LOD_FADE_PERCENTAGE
298.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
299.                 #include "SpeedTreeCommon.cginc"
300.  
301.                 struct v2f
302.                 {
303.                     float4 vertex    : SV_POSITION;
304.                     UNITY_FOG_COORDS(0)
305.                     Input data        : TEXCOORD1;
306.                     UNITY_VERTEX_OUTPUT_STEREO
307.                 };
308.  
309.                 v2f vert(SpeedTreeVB v)
310.                 {
311.                     v2f o;
312.                     UNITY_SETUP_INSTANCE_ID(v);
313.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
314.                     SpeedTreeVert(v, o.data);
315.                     o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 2, false);
316.                     o.vertex = UnityObjectToClipPos(v.vertex);
317.                     UNITY_TRANSFER_FOG(o,o.vertex);
318.                     return o;
319.                 }
320.  
321.                 fixed4 frag(v2f i) : SV_Target
322.                 {
323.                     SpeedTreeFragOut o;
324.                     SpeedTreeFrag(i.data, o);
325.                     fixed4 c = fixed4(o.Albedo, o.Alpha);
326.                     UNITY_APPLY_FOG(i.fogCoord, c);
327.                     return c;
328.                 }
329.             ENDCG
330.         }
331.     }
332.  
333.     FallBack "Transparent/Cutout/VertexLit"
334.     CustomEditor "SpeedTreeMaterialInspector"
335. }
336.  

 

Hi ! Thank you so much for taking the time to research and document this topic !

I tried your shader but it does not seem to work as intended in my build. Nevertheless, I read it carefully and used some ideas to improve mine - this time it runs and the editor AND it compiles properly, because previously it could only run in the editor. I'm not sure what I changed that now makes it compile though :/

Its goal, as stated previously, is to create an overall transparency with no X-ray effect on the tree. I added a function to force the colorization of the tree (it can be toggled on/off), in case you want to replace the tree shape by a semi-transparent black (or grey or whatever) shape.

This shader is still not perfect though, there is a problem with "branch detail" geometry, which dance in the wind - I suppose that somewhere I must be offsetting the geometry in regard to the wind twice or something like that, but I'm too much a beginner in shadercraft to know any better, unfortunately.

Anyway, in case you need it, here is what I have. The code is not completely clean and I did not bother to translate notes from French to English, but since you can read a shader probably better than I, I guess you will have no difficulty to figure out what it does

Spoiler: Semi transparent shader for Speedtree

Code (CSharp):

1. Shader "Nature/SpeedTreeAvecTransparence"
2. {
3.     Properties
4.     {
5.         _Color ("Main Color", Color) = (1,1,1,1)
6.         _Transparence ("Transparence", Range(0.0,1.0)) = 0
7.         [Toggle] _ForceCouleur("Colorisation forcée", float) = 0
8.         _Couleur ("Ma couleur", Color) = (1,0,1,1)
9.         _HueVariation ("Hue Variation", Color) = (1.0,0.5,0.0,0.1)
10.         _MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
11.         _DetailTex ("Detail", 2D) = "black" {}
12.         _BumpMap ("Normal Map", 2D) = "bump" {}
13.         _Cutoff ("Alpha Cutoff", Range(0,1)) = 0.333
14.         [MaterialEnum(Off,0,Front,1,Back,2)] _Cull ("Cull", Int) = 2
15.         [MaterialEnum(None,0,Fastest,1,Fast,2,Better,3,Best,4,Palm,5)] _WindQuality ("Wind Quality", Range(0,5)) = 0
16.     }
17.  
18.     // targeting SM3.0+
19.     SubShader
20.     {
21.         Tags
22.         {
23.             //"Queue"="Geometry"
24.             "Queue" = "Transparent"
25.             "IgnoreProjector"="True"
26.             //"RenderType"="Opaque"
27.             "RenderType"="Transparent" //pour une raison que j'ignore, ce rendertype fout le bordel dans la géométrie de l'objet tel qu'il s'affiche... mais il reste indispensable sinon c'est opaque une fois compilé.
28.             "DisableBatching"="LODFading"
29.             //"DisableBatching"="False"
30.         }
31.  
32.         LOD 400
33.         Cull [_Cull]
34.  
35.         GrabPass { "_GrabFondScene" }
36.  
37.         CGPROGRAM
38.             #pragma surface surf Lambert vertex:SpeedTreeVert nodirlightmap nodynlightmap noshadowmask dithercrossfade
39.             #pragma target 3.0
40.             #pragma multi_compile_vertex __ LOD_FADE_PERCENTAGE
41.             #pragma instancing_options assumeuniformscaling lodfade maxcount:50
42.             #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
43.             #pragma shader_feature EFFECT_BUMP
44.             #pragma shader_feature EFFECT_HUE_VARIATION
45.             #define ENABLE_WIND
46.             #include "SpeedTreeCommon.cginc"
47.  
48.             void surf(Input IN, inout SurfaceOutput OUT)
49.             {
50.                 SpeedTreeFragOut o;
51.                 SpeedTreeFrag(IN, o);
52.                 SPEEDTREE_COPY_FRAG(OUT, o)
53.             }
54.         ENDCG
55.  
56.         Pass
57.         {
58.             Tags { "LightMode" = "ShadowCaster" }
59.             //Tags { "LightMode" = "Always" }
60.  
61.             CGPROGRAM
62.                 #pragma vertex vert
63.                 #pragma fragment frag
64.                 #pragma target 3.0
65.                 #pragma multi_compile_vertex __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
66.                 #pragma multi_compile_fragment __ LOD_FADE_CROSSFADE
67.                 #pragma multi_compile_instancing
68.                 #pragma instancing_options assumeuniformscaling lodfade maxcount:50
69.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
70.                 #pragma multi_compile_shadowcaster
71.                 #define ENABLE_WIND
72.                 #include "SpeedTreeCommon.cginc"
73.  
74.                 struct v2f
75.                 {
76.                     V2F_SHADOW_CASTER;
77.                     #ifdef SPEEDTREE_ALPHATEST
78.                         float2 uv : TEXCOORD1;
79.                     #endif
80.                     UNITY_VERTEX_INPUT_INSTANCE_ID
81.                     UNITY_VERTEX_OUTPUT_STEREO
82.                 };
83.  
84.                 float4 _Couleur;
85.                 float _Transparence;
86.  
87.                 v2f vert(SpeedTreeVB v)
88.                 {
89.                     v2f o;
90.                     UNITY_SETUP_INSTANCE_ID(v);
91.                     UNITY_TRANSFER_INSTANCE_ID(v, o);
92.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
93.                     #ifdef SPEEDTREE_ALPHATEST
94.                         o.uv = v.texcoord.xy;
95.                     #endif
96.                     OffsetSpeedTreeVertex(v, unity_LODFade.x);
97.                     TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
98.  
99.                     return o;
100.                 }
101.  
102.                 float4 frag(v2f i) : SV_Target
103.                 {
104.                     UNITY_SETUP_INSTANCE_ID(i);
105.                     #ifdef SPEEDTREE_ALPHATEST
106.                         clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
107.                     #endif
108.                     UNITY_APPLY_DITHER_CROSSFADE(i.pos.xy);
109.                     SHADOW_CASTER_FRAGMENT(i)
110.                 }
111.             ENDCG
112.         }
113.  
114.         Pass
115.         {
116.             Tags { "LightMode" = "Vertex" }
117.             //Tags { "LightMode" = "Always" }
118.  
119.             CGPROGRAM
120.                 #pragma vertex vert
121.                 #pragma fragment frag
122.                 #pragma target 3.0
123.                 #pragma multi_compile_fog
124.                 #pragma multi_compile_vertex __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
125.                 #pragma multi_compile_fragment __ LOD_FADE_CROSSFADE
126.                 #pragma multi_compile_instancing
127.                 #pragma instancing_options assumeuniformscaling lodfade maxcount:50
128.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
129.                 #pragma shader_feature EFFECT_HUE_VARIATION
130.                 #define ENABLE_WIND
131.                 #include "SpeedTreeCommon.cginc"
132.  
133.                 struct v2f
134.                 {
135.                     UNITY_POSITION(vertex);
136.                     UNITY_FOG_COORDS(0)
137.                     Input data      : TEXCOORD1;
138.                     UNITY_VERTEX_INPUT_INSTANCE_ID
139.                     UNITY_VERTEX_OUTPUT_STEREO
140.                 };
141.  
142.                 float4 _Couleur;
143.                 float _Transparence;
144.  
145.                 v2f vert(SpeedTreeVB v)
146.                 {
147.                     v2f o;
148.                     UNITY_SETUP_INSTANCE_ID(v);
149.                     UNITY_TRANSFER_INSTANCE_ID(v, o);
150.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
151.                     SpeedTreeVert(v, o.data);
152.                     o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 4, true);
153.                     o.vertex = UnityObjectToClipPos(v.vertex);
154.                     UNITY_TRANSFER_FOG(o,o.vertex);
155.                     return o;
156.                 }
157.  
158.                 fixed4 frag(v2f i) : SV_Target
159.                 {
160.                     UNITY_SETUP_INSTANCE_ID(i);
161.                     SpeedTreeFragOut o;
162.                     SpeedTreeFrag(i.data, o);
163.                     UNITY_APPLY_DITHER_CROSSFADE(i.vertex.xy);
164.                     fixed4 c = fixed4(_Couleur.rgb, o.Alpha);
165.                     UNITY_APPLY_FOG(i.fogCoord, c);
166.                     return c;
167.                 }
168.  
169.             ENDCG
170.         }
171.  
172.         //C'est là qu'on mélange le rendu normal et le fond décran pour obtenir la transparence partielle...
173.  
174.         GrabPass {}
175.  
176.         Pass
177.         {
178.             //Tags { "LightMode" = "Vertex" }
179.             Tags { "LightMode" = "Always" }
180.  
181.             CGPROGRAM
182.                 #pragma vertex vert
183.                 #pragma fragment frag
184.                 #pragma target 3.0
185.                 #pragma multi_compile_fog
186.                 #pragma multi_compile_vertex __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
187.                 #pragma multi_compile_fragment __ LOD_FADE_CROSSFADE
188.                 #pragma multi_compile_instancing
189.                 #pragma instancing_options assumeuniformscaling lodfade maxcount:50
190.                 #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
191.                 #pragma shader_feature EFFECT_HUE_VARIATION
192.                 #define ENABLE_WIND
193.                 #include "SpeedTreeCommon.cginc"
194.  
195.                 struct v2f
196.                 {
197.                     UNITY_POSITION(vertex);
198.                     UNITY_FOG_COORDS(0)
199.                     Input data      : TEXCOORD1;
200.                     UNITY_VERTEX_INPUT_INSTANCE_ID
201.                     UNITY_VERTEX_OUTPUT_STEREO
202.                     float4 uvgrab : TEXCOORD0;
203.                 };
204.  
205.                 float4 _Couleur;
206.                 float _Transparence;
207.                 float _ForceCouleur;
208.                  sampler2D _GrabTexture;
209.                  sampler2D _GrabFondScene;
210.  
211.                 v2f vert(SpeedTreeVB v)
212.                 {
213.                     v2f o;
214.                     UNITY_SETUP_INSTANCE_ID(v);
215.                     UNITY_TRANSFER_INSTANCE_ID(v, o);
216.                     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
217.                     SpeedTreeVert(v, o.data);
218.                     o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 4, true);
219.                     o.vertex = UnityObjectToClipPos(v.vertex);
220.                     UNITY_TRANSFER_FOG(o,o.vertex);
221.                     o.uvgrab = ComputeGrabScreenPos(o.vertex);
222.                     return o;
223.                 }
224.  
225.                 fixed4 frag(v2f i) : SV_Target
226.                 {
227.                     UNITY_SETUP_INSTANCE_ID(i);
228.                     SpeedTreeFragOut o;
229.                     SpeedTreeFrag(i.data, o);
230.                     UNITY_APPLY_DITHER_CROSSFADE(i.vertex.xy);
231.                     //fixed4 c = fixed4(o.Albedo, o.Alpha);
232.                     fixed4 c;
233.                     if(_ForceCouleur==1)
234.                     {
235.                         c = _Couleur*(1-_Transparence) + tex2Dproj( _GrabFondScene, i.uvgrab)*_Transparence;
236.                     }
237.                     else
238.                     {
239.                         c = tex2Dproj( _GrabTexture, i.uvgrab)*(1-_Transparence) + tex2Dproj( _GrabFondScene, i.uvgrab)*_Transparence;
240.                     }
241.                     UNITY_APPLY_FOG(i.fogCoord, c);
242.                     return c;
243.                 }
244.              ENDCG
245.         }
246.     }

 

Thanks guys, great work!

 

If you ever find a way to correct the glitch with the branch detail geometry, please feel free to share the joy