Unity Shader podświetlanie pokrywa

Question

Próbuję napisać shader dla jedności, która będzie podkreślać nakładających się fragmentów oczek. Powinien działać dla jednego obiektu nakładającego się na siebie, jak również wielu obiektów.

Wynik powinien wyglądać załączonym obrazku.

Najpierw próbowałem to zrobić z wykrywaniem kolizji, ale myślę, że najlepszym sposobem jest napisanie modułu cieniującego.

nie jestem bardzo obeznany z shaderów więc jeśli ktoś może mi pomóc byłbym wdzięczny.

Myślę, że można to zrobić za pomocą szablonów cieniowania, takich jak tutaj http://docs.unity3d.com/Manual/SL-Stencil.html , ale te shadery renderują tylko przecięcie dwóch obiektów bez renderowania całego obiektu.

Znalazłem również shader oparte na głębokość (https://chrismflynn.wordpress.com/2012/09/06/fun-with-shaders-and-the-depth-buffer/), ale również działać na dwóch obiektach i nie działa na jednej siatki, które pokrywają się

Odnośnie komentarza @Zze z pojęcia o Dwuprzebiegowe Mam teraz dwa shaderów . I działa na dwóch obiektach, gdy jeden ma jeden moduł cieniujący, a drugi drugi.

Może ktoś może mi pomóc, jak połączyć je w jeden moduł cieniujący, który będzie działał także w obiekt, który będzie pokrywać się?

ShaderOne

Shader "Custom/ShaderOne" 
{ 
    SubShader { 
     Tags { "RenderType"="Opaque" "Queue"="Geometry"} 
     Pass { 
      Stencil { 
       Ref 2 
       Comp always 
       Pass keep 
       Fail decrWrap 
       ZFail keep 
      } 

      CGPROGRAM 
      #pragma vertex vert 
      #pragma fragment frag 
      struct appdata { 
       float4 vertex : POSITION; 
      }; 
      struct v2f { 
       float4 pos : SV_POSITION; 
      }; 
      v2f vert(appdata v) { 
       v2f o; 
       o.pos = mul(UNITY_MATRIX_MVP, v.vertex); 
       return o; 
      } 
      half4 frag(v2f i) : SV_Target { 
       return half4(0,1,0,1); 
      } 
      ENDCG 
     } 
     Pass { 
      Stencil { 
       Ref 2 
       Comp equal 
      } 

      CGPROGRAM 
      #pragma vertex vert 
      #pragma fragment frag 
      struct appdata { 
       float4 vertex : POSITION; 
      }; 
      struct v2f { 
       float4 pos : SV_POSITION; 
      }; 
      v2f vert(appdata v) { 
       v2f o; 
       o.pos = mul(UNITY_MATRIX_MVP, v.vertex); 
       return o; 
      } 
      half4 frag(v2f i) : SV_Target { 
       return half4(0,0,1,1); 
      } 
      ENDCG 
     } 

    } 
} 

ShaderTwo

Shader "Custom/ShaderTwo" 
{ 
    SubShader { 
     Tags { "RenderType"="Opaque" "Queue"="Geometry"} 
     Pass { 
      Stencil { 
       Ref 2 
       Comp always 
       Pass replace 
       ZFail keep 
      } 

      CGPROGRAM 
      #pragma vertex vert 
      #pragma fragment frag 
      struct appdata { 
       float4 vertex : POSITION; 
      }; 
      struct v2f { 
       float4 pos : SV_POSITION; 
      }; 
      v2f vert(appdata v) { 
       v2f o; 
       o.pos = mul(UNITY_MATRIX_MVP, v.vertex); 
       return o; 
      } 
      half4 frag(v2f i) : SV_Target { 
       return half4(1,0,0,1); 
      } 
      ENDCG 
     } 
    } 
} 

wynik wygląda na załączonym obrazem

Answer 1

Problem ten można rozwiązać przy pomocy buforu do wzornika i jeden, dwa przejścia module. Idea jest następująca:

• Pierwsze przejście porównuje wartość w bufor szablonowy 0. W obu przypadkach (pass/fail) zwiększenie wartości w buforze.
• Drugie przejście porównuje wartość w buforze szablonu z 1. Jeśli wartość odniesienia 1 jest mniejsza, niż przejeżdżamy i podświetlamy zachodzący piksel.

Możesz chcieć dodać więcej podań, które są takie same jak w drugim, ale z inną wartością odniesienia, aby wyróżnić regiony, które nakłada się dwa razy, trzy razy itd

W notacji shaderlab Jedności, to powinien coś takiego:

Pass 
    { 
     Stencil { 
      Ref 0 
      Comp Equal 
      Pass IncrSat 
      Fail IncrSat 
     } 

     // Shader for not overlapping regions goes here. 
    } 

    Pass 
    { 
     Stencil { 
      Ref 1 
      Comp Less 
     } 

     // Shader for one-time overlapping regions goes here. 
    } 

    Pass 
    { 
     Stencil { 
      Ref 2 
      Comp Less 
     } 

     // Shader for two-time overlapping regions goes here. 
    } 

przykład:

Shader:

Shader "Unlit/Stencil" 
{ 
    Properties 
    { 
     _MainTex ("Texture", 2D) = "white" {} 
    } 
    SubShader 
    { 
     Tags { "RenderType"="Opaque" } 
     LOD 100 

     Pass 
     { 
      Stencil { 
       Ref 0 
       Comp Equal 
       Pass IncrSat 
       Fail IncrSat 
      } 

      CGPROGRAM 
      #pragma vertex vert 
      #pragma fragment frag 

      #include "UnityCG.cginc" 

      struct appdata 
      { 
       float4 vertex : POSITION; 
      }; 

      struct v2f 
      { 
       float4 vertex : SV_POSITION; 
      }; 

      v2f vert (appdata v) 
      { 
       v2f o; 
       o.vertex = mul(UNITY_MATRIX_MVP, v.vertex); 
       return o; 
      } 

      fixed4 frag (v2f i) : SV_Target 
      { 
       fixed4 col = fixed4(0.0, 0.0, 1.0, 1.0); 
       return col; 
      } 
      ENDCG 
     } 

     Pass 
     { 
      Stencil { 
       Ref 1 
       Comp Less 
      } 

      CGPROGRAM 
      #pragma vertex vert 
      #pragma fragment frag 

      #include "UnityCG.cginc" 

      struct appdata 
      { 
       float4 vertex : POSITION; 
      }; 

      struct v2f 
      { 
       float4 vertex : SV_POSITION; 
      }; 

      v2f vert (appdata v) 
      { 
       v2f o; 
       o.vertex = mul(UNITY_MATRIX_MVP, v.vertex); 
       return o; 
      } 

      fixed4 frag (v2f i) : SV_Target 
      { 
       fixed4 col = fixed4(1.0, 1.0, 0.0, 1.0); 
       return col; 
      } 
      ENDCG 
     } 

     Pass 
     { 
      Stencil { 
       Ref 2 
       Comp Less 
      } 

      CGPROGRAM 
      #pragma vertex vert 
      #pragma fragment frag 

      #include "UnityCG.cginc" 

      struct appdata 
      { 
       float4 vertex : POSITION; 
      }; 

      struct v2f 
      { 
       float4 vertex : SV_POSITION; 
      }; 

      v2f vert (appdata v) 
      { 
       v2f o; 
       o.vertex = mul(UNITY_MATRIX_MVP, v.vertex); 
       return o; 
      } 

      fixed4 frag (v2f i) : SV_Target 
      { 
       fixed4 col = fixed4(1.0, 0.0, 0.0, 1.0); 
       return col; 
      } 
      ENDCG 
     } 
    } 
}