Search Unity

Partially transparent speedtrees - ideas ?

Discussion in 'Shaders' started by LeRan, Feb 26, 2018.

  1. LeRan

    LeRan

    Joined:
    Nov 24, 2015
    Posts:
    114
    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?
     
  2. Xoduz

    Xoduz

    Joined:
    Apr 6, 2013
    Posts:
    135
    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 :/
     
    LeRan likes this.
  3. Xoduz

    Xoduz

    Joined:
    Apr 6, 2013
    Posts:
    135
    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:

    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.  
     
    terrycheung, LeRan and mcmorry like this.
  4. LeRan

    LeRan

    Joined:
    Nov 24, 2015
    Posts:
    114
    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 :)

    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.     }
     
    terrycheung and Xoduz like this.
  5. terrycheung

    terrycheung

    Joined:
    Oct 9, 2014
    Posts:
    1
    Thanks guys, great work!
     
  6. LeRan

    LeRan

    Joined:
    Nov 24, 2015
    Posts:
    114
    If you ever find a way to correct the glitch with the branch detail geometry, please feel free to share the joy :)