No desenvolvimento de funções, às vezes alguns efeitos especiais são adicionados à interface do usuário para obter melhores efeitos, como adicionar um efeito de partícula de anel no quadro do avatar, mas devido aos diferentes métodos de renderização de partículas e interface do usuário, a interface do usuário e os efeitos especiais aparecerão intercalados entre, a exibição não é ideal. E se a lista de caracteres for exibida em ScrollRect, os efeitos de partícula não podem ser mascarados ao deslizar a barra de rolagem. Aqui nos concentramos em resolver esses dois problemas:
Primeiro, resolva como fazer os efeitos de partícula exibidos na interface do usuário:
1. Defina o modo de renderização do Canvas:
Ao adicionar um objeto de interface do usuário, se não houver Canvas sob a hierarquia, o sistema UGUI adicionará automaticamente o objeto e o modo de renderização padrão do Canvas é Screen Space - Overlay. O Canvas possui três modos de renderização:
Espaço da tela - Sobreposição: independentemente de quaisquer outros objetos 3D, a interface do usuário é sempre exibida na frente da tela
Espaço da tela - Câmera: neste momento, há uma certa distância entre a câmera e a tela, e alguns objetos 3D podem ser adicionados a essa distância, como efeitos de partículas, etc., e podem ser exibidos na interface do usuário ajustando o Coordenadas Z dos objetos de partícula. Obviamente, existem outras maneiras de obter esse efeito, que serão apresentadas posteriormente.
World Space: Neste modo, a interface do usuário é a mesma dos objetos espaciais 3D comuns, como a esfera e a caixa que acompanham o mecanismo.
Como os efeitos de partículas pertencem a objetos 3D, para permitir que os efeitos de partículas sejam exibidos na interface do usuário, é necessário alterar o modo de renderização do Canvas para "Espaço da tela - Câmera":
Neste modo, você precisa especificar a câmera de renderização para a Tela e definir a Camada e a ordem na camada desta Tela ao mesmo tempo. Após a conclusão da configuração, todas as interfaces do usuário sob esta tela pertencem à mesma camada e a ordem na camada permanece consistente. Ao renderizar, a relação de oclusão entre as interfaces do usuário é determinada de acordo com a ordem de cima para baixo
2. Defina a ordem na camada entre a interface do usuário e os efeitos de partícula:
Primeiro, explique detalhadamente a relação de renderização entre a interface do usuário :
Cada interface do usuário é separada de acordo com a Camada definida por si só e classificada de acordo com a Ordem na camada na mesma camada. Quanto maior o valor, mais ele é exibido na parte superior . As interfaces do usuário na mesma ordem na camada são renderizadas sequencialmente de cima para baixo na hierarquia. O último obscurecerá a interface do usuário renderizada anteriormente .
As configurações da interface do usuário e os efeitos de exibição na Hierarquia são os seguintes:
Sob a mesma tela, de acordo com a ordem de renderização de cima para baixo, o vermelho definitivamente bloqueará a imagem do azul. Então, como o azul pode ser exibido no vermelho, mesmo que seja renderizado antes do vermelho? Nesse caso, você precisa alterar a camada da interface do usuário ou a Ordem na camada - geralmente, alterar a Ordem na camada pode obter o efeito, portanto, não há necessidade de alterar a camada da camada
Existem duas maneiras de obter o efeito:
1. Como o Vermelho deve bloquear o Azul na mesma tela, o Vermelho é extraído do Azul aqui. Para fins de demonstração, o Vermelho ainda é colocado sob o Azul. Em seguida, adicione Canvas ao Blue para alterar a ordem do Blue na camada
O vermelho é renderizado na Tela padrão, portanto, sua camada - padrão, Ordem na camada - 0. Ao adicionar Canvas a Blue e habilitar a classificação Override e definir Order in layer como 0, a interface do usuário que foi renderizada pelo Order in layer será redefinida e a interface do usuário após a redefinição será exibida por padrão - mas apenas para a mesma tela coordenadas Redefina a área onde duas UIs se sobrepõem e exiba a UI anterior na área onde não há sobreposição :
No caso acima, Azul - tamanho: 200 x 200, Vermelho - tamanho: 100 x 100 , quando a tela do Azul for redefinida, o Azul redefinirá a mesma Ordem na camada, bloqueando completamente o Vermelho. Mas se alterar Azul - tamanho: 50 x 5 0, ele mostrará:
Pode-se ver acima que a chamada redefinição é apenas para o caso em que há vários monitores de interface do usuário na mesma área e aqueles fora da área não serão afetados
2. O princípio do segundo método é semelhante ao primeiro, mas sem alterar a relação pai-filho entre Azul e Vermelho, altere diretamente a Ordem na camada de Vermelho. Por padrão, tanto Azul quanto Vermelho estão em Camada - padrão, Ordem na camada - 0 e, em seguida, renderizados de cima para baixo. Para fazer o Azul aparecer em cima do Vermelho, você precisa redefinir o Vermelho.
Embora uma tela seja adicionada para vermelho para redefinir a ordem na camada, uma vez que as camadas de renderização azul e vermelha e as configurações de ordem são as mesmas, e o tamanho vermelho é pequeno, mesmo a redefinição afetará apenas uma pequena área. Portanto, é necessário alterar a ordem do vermelho para que o vermelho seja renderizado após o azul, para que o azul possa ser exibido no vermelho. Como a ordem padrão na camada de Azul é 0, basta definir a ordem na camada de Vermelho para "-1" aqui .
Nota: UGUI mescla Drawcalls de acordo com Canvas. Canvas diferentes não podem mesclar Drawcalls mesmo que tenham a mesma camada e ordem na camada. Portanto, o layout geral da interface do usuário do projeto precisa ser projetado com antecedência . Para não afetar a otimização posterior, tente não adicionar Canvas à vontade para alterar o relacionamento de renderização da interface do usuário
De acordo com a explicação acima, para exibir os efeitos de partícula na interface do usuário, você só precisa alterar a "Camada de classificação" e "Ordem na camada" dos efeitos de partícula. Normalmente, alterar a "Ordem na camada" pode atingir o efeito. A "Ordem na camada" padrão da interface do usuário é "0", portanto, basta definir a "Ordem na camada" do efeito de partícula para ser maior que 0.
O efeito de corrida é o seguinte:
Desta forma, os efeitos das partículas são exibidos na interface do usuário. Ao definir a ordem na camada entre as partículas e a interface do usuário, o problema de interpenetração da interface do usuário relacionado pode ser resolvido.
2. Como resolver o problema de que o efeito de partícula não pode ser mascarado quando o ScrollRect desliza?
Antes de tudo, precisamos saber como funciona a máscara Máscara?
Aqui precisamos introduzir uma função Shader de "Stencil Buffer - Stencil Buffer" Quando o Shader usado pelo material suporta Stencil Buffer, você pode customizar a oclusão e selecionar a relação entre UIs ajustando os parâmetros.
1. Análise de parâmetros: os principais parâmetros do Stencil Buffer no Shader:
Properties
{
.................
_Stencil ("Stencil ID", Float) = 0
_StencilComp ("Stencil Comparison", Float) = 8
_StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
_ColorMask("Color Mask", Float) = 15
.................
}
SubShader
{
.................
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
..................
..................
ColorMask[_ColorMask]
.................
.................
}Normalmente, os parâmetros alterados ao personalizar efeitos são: Ref [_Stencil], Comp [_StencilComp], Pass [_StencilOp]
Ref: O referenceValue usado pela UI, que será comparado com o valor armazenado no Stencil Buffer ao calcular a cor. Para um shader com função stencil buffer, cada pixel da UI será marcado com um referenceValue e armazenado no stencil buffer, ou seja, stencilBufferValue = referenceValue, para posterior comparação com outros referenceValues. O intervalo de valores é um número inteiro de 0 a 255
O valor referenceValue do Stencil Buffer padroniza para 0 no estado inicial
Comp: A operação de comparação do valor Ref com o valor armazenado no Stencil Buffer, como maior que, igual a, menor que, etc.
A situação de várias operações é a seguinte: o valor que representa cada operação é incrementado sequencialmente de 0 a 8
Pass: representa a operação realizada no pixel após a comparação do valor de referência acima mencionada e representa que o valor de cada operação é incrementado de 0 a 7
PS: Em circunstâncias normais, o ReadMask e o WriteMask não serão modificados, apenas mantenha os valores padrão.
ReadMask ：
从字面意思的理解就是读遮罩，readMask将和referenceValue以及stencilBufferValue进行按位与（&）操作，readMask取值范围也是0-255的整数，默认值为255，二进制位11111111，即读取的时候不对referenceValue和stencilBufferValue产生效果，读取的还是原始值。
WriteMask：
是当写入模板缓冲时进行掩码操作（按位与&），writeMask取值范围是0-255的整数，默认值也是255，即当修改stencilBufferValue值时，写入的仍然是原始值。
和深度测试一样，在unity中，每个像素的模板测试也有它自己一套独立的依据，具体公式如下：
if（referenceValue&readMask comparisonFunction stencilBufferValue&readMask）
通过像素
else
抛弃像素
通过的像素操作则根据 stencilOperation命令值 来确定，并更新模板缓冲内的值：
在更新模板缓冲值的时候，也有writeMask进行掩码操作，用来对特定的位进行写入和屏蔽，默认值为255（11111111），即所有位数全部写入，不进行屏蔽操作。Explicação detalhada de cada parâmetro: UnityShader instance 09: Stencil Buffer&Stencil Test_lupeng's Blog-CSDN Blog_shader stencil
Perceber:
Quando "_StencilComp" passar no teste, o pixel será desenhado e exibido , mas "_StencilOp" refere-se ao processamento do valor da tag correspondente ao pixel no "Stencil Buffer" após passar no teste de modelo ou profundidade. Isso é o mesmo que Se este pixel será exibido é irrelevante, é apenas para o valor armazenado no stencil buffer , o padrão é manter, ou seja, o referenceValue usado por esta interface do usuário não será gravado no stencil buffer e o stencil buffer ainda retém o valor anterior Valor - Este valor continuará a ser usado para a próxima comparação "stencilComp"
2. Operação da instância do Stencil Buffer:
Ao criar uma nova imagem de UI, você pode ver que o shader padrão usado pela imagem é "UI/Default", que já suporta a função Stencil Buffer:
Mas como ele usa o material padrão "Default UI Material" na UGUI, os parâmetros não podem ser personalizados.
Para obter um efeito de oclusão personalizado, você pode criar um novo materialA e definir seu sombreador como "UI/Padrão":
Desta forma, você pode definir livremente os parâmetros para obter o efeito desejado
Conforme mostrado nos parâmetros acima, por padrão referenceValue = 0, Comp = Always, Op = Keep
Conforme mostrado abaixo, crie duas imagens, ambas usando o material padrão:
Como os parâmetros permanecem padrão, ao desenhar o Azul primeiro, ele sempre passa no teste do estêncil e o Azul é desenhado como um todo; depois desenha o Vermelho e, na sobreposição das duas imagens, o Vermelho é desenhado no teste do estêncil, então o Vermelho será cobrir parcialmente Azul Neste momento , os dados armazenados no buffer do estêncil permanecem 0 porque stencilOp = manter
De acordo com a situação acima, como desenhar Azul e Vermelho sequencialmente de cima para baixo e ainda exibir Azul na sobreposição?
Neste ponto, você pode ajustar diretamente os parâmetros, basta definir Red para não passar no teste do estêncil:
Análise: Porque é necessário conseguir a sobreposição de Azul e Vermelho, o Vermelho não pode passar no teste do estêncil, mas a parte não sobreposta pode passar no teste do estêncil, por isso é necessário fazer o estêncil da área de exibição do Azul e o área não exibida antes de desenhar Vermelho Os valores armazenados no buffer são diferentes. Por padrão, stencilBufferValue = 0 no buffer de estêncil, então você precisa alterar o valor de referência de Blue = 1, stencilOp = 2 (Substituir), stencilComp = 8 (Sempre). Depois de passar no teste do estêncil, escreva o referenceValue no stencilBufferValue de acordo com o stencilOp.
Neste momento, o stencilBufferValue da área de desenho Azul = 1 e o stencilBufferValue da área sem desenho permanece em 0 por padrão. Ou seja, o requisito foi atendido.
Para Red, a parte sobreposta não pode passar no teste de estêncil e tem stencilBufferValue = 1. Portanto, defina o valor de referência de Red = 0, stencilComp = Equal(3), stencilOp = 0. Como a comparação Equal é usada na sobreposição, o Red não deve passar no teste do estêncil e não será desenhado, mas o referenceValue = stencilBufferValue no não sobreposto, portanto, o Red pode ser desenhado por meio do teste do estêncil . Para o parâmetro stencilOp, não há necessidade de alterá-lo em geral, e o valor padrão de Keep ainda é mantido aqui . O efeito é o seguinte:
PS: A função dos parâmetros "Use Alpha Clip" e "Color Mask":
1. Parâmetro "Use Alpha Clip": Conforme mostrado na figura acima, embora o efeito possa ser alcançado, ainda existem alguns pixels no canto inferior esquerdo bloqueados:
Isso ocorre porque quando a Textura importada é definida no formato "Sprite", o Unity corta automaticamente os pixels extras da textura, mas alguns cantos ainda ficam com um pouco de resíduo. Quando "Usar Alpha Clip" está marcado:
Após a verificação deste parâmetro, os pixels cujo alfa for menor que 0,001 na imagem serão descartados automaticamente. Dessa forma, ao desenhar a interface do usuário, é equivalente a nenhum pixel aqui e não afetará a oclusão entre as interfaces do usuário.
Nota: Se o alfa de uma determinada área de uma determinada textura do artista for muito baixo, mas porque ainda há pixels aqui, ele ainda bloqueará outras UIs e, se o stencilOp for substituído, a área com um alfa muito baixo ainda será gravado no stencilBufferValue . Para resolver esse problema, "Usar Alpha Clip" descartará pixels com alfa baixo na imagem
Conforme mostrado na figura acima, embora o alfa seja muito pequeno, ele ainda bloqueará as imagens por trás. Ao descartar pixels nesta área,
Desta forma, um melhor efeito de exibição pode ser obtido.
2. Parâmetro "Máscara de Cor": Mascarar os pixels que passarem no teste do estêncil nesta interface do usuário. Observe que a máscara aqui é apenas para si mesma. Por exemplo, os pixels nesta área foram desenhados antes e esta interface do usuário não passou no teste de estêncil. No momento, mesmo que "Máscara de cor = 0" seja definido, isso não afetará os pixels anteriores nesta área.
Se o pixel será exibido depende se o pixel passa no teste de estêncil e o valor definido pela máscara de cor. Por padrão, "máscara de cor = 15", então, desde que o pixel passe no teste do estêncil, ele será exibido.
Por exemplo, ao definir a "máscara de cor = 0" do BlueMat - você pode usar este método para obter alguns efeitos de esvaziamento
Embora Blue tenha passado no teste do estêncil, ele não será exibido devido à máscara de cores. E ajustando o valor de "Máscara de Cor", diferentes efeitos de exibição podem ser obtidos:
Máscara de cor = 5: Máscara de cor = 10:
3. Adicione a função de buffer de estêncil ao sombreador de partículas:
Conforme mostrado abaixo, adicione efeitos de partícula em Azul e você poderá ver claramente que as partículas excedem o limite da imagem - o shader usado aqui é "Legacy Shaders/Particles/Additive". A razão para isso é que o sombreador de partículas não tem a função Stencil Buffer
Para obter o efeito de máscara, é necessário adicionar um Stencil Buffer ao shader da partícula. Crie um novo script Shader, copie o código-fonte do shader usado pela partícula para o script shader recém-criado e adicione os parâmetros-chave do Stencil Buffer acima mencionados Property e Stencil a ele e crie um novo material para usar o shader, para que você pode ajustar livremente os parâmetros para obter o efeito.
Por exemplo: use o Shader interno do Unity aqui: "Particle Add.shader"
Crie um novo Shader - CustomParticleShader.shader, copie o código-fonte de "Particle Add.shader" e adicione os principais parâmetros de StencilBuffer ao arquivo de script CustomParticleShader.shader:
Shader "Custom/CustomParticleShader"
{
Properties{
_TintColor("Tint Color", Color) = (0.5,0.5,0.5,0.5)
_MainTex("Particle Texture", 2D) = "white" {}
_InvFade("Soft Particles Factor", Range(0.01,3.0)) = 1.0
_Stencil("Stencil ID", Float) = 0
_StencilComp("Stencil Comparison", Float) = 8
_StencilOp("Stencil Operation", Float) = 0
_StencilWriteMask("Stencil Write Mask", Float) = 255
_StencilReadMask("Stencil Read Mask", Float) = 255
_ColorMask("Color Mask", Float) = 15
}
Category{
Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" "PreviewType" = "Plane" }
Stencil
{
Ref[_Stencil]
Comp[_StencilComp]
Pass[_StencilOp]
ReadMask[_StencilReadMask]
WriteMask[_StencilWriteMask]
}
Blend SrcAlpha One
ColorMask RGB
Cull Off Lighting Off ZWrite Off
ColorMask[_ColorMask]
SubShader {
Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 2.0
#pragma multi_compile_particles
#pragma multi_compile_fog
#include "UnityCG.cginc"
sampler2D _MainTex;
fixed4 _TintColor;
struct appdata_t {
float4 vertex : POSITION;
fixed4 color : COLOR;
float2 texcoord : TEXCOORD0;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct v2f {
float4 vertex : SV_POSITION;
fixed4 color : COLOR;
float2 texcoord : TEXCOORD0;
UNITY_FOG_COORDS(1)
#ifdef SOFTPARTICLES_ON
float4 projPos : TEXCOORD2;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
float4 _MainTex_ST;
v2f vert(appdata_t v)
{
v2f o;
UNITY_SETUP_INSTANCE_ID(v);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
o.vertex = UnityObjectToClipPos(v.vertex);
#ifdef SOFTPARTICLES_ON
o.projPos = ComputeScreenPos(o.vertex);
COMPUTE_EYEDEPTH(o.projPos.z);
#endif
o.color = v.color;
o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
UNITY_TRANSFER_FOG(o,o.vertex);
return o;
}
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float _InvFade;
fixed4 frag(v2f i) : SV_Target
{
#ifdef SOFTPARTICLES_ON
float sceneZ = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos)));
float partZ = i.projPos.z;
float fade = saturate(_InvFade * (sceneZ - partZ));
i.color.a *= fade;
#endif
fixed4 col = 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord);
col.a = saturate(col.a); // alpha should not have double-brightness applied to it, but we can't fix that legacy behavior without breaking everyone's effects, so instead clamp the output to get sensible HDR behavior (case 967476)
UNITY_APPLY_FOG_COLOR(i.fogCoord, col, fixed4(0,0,0,0)); // fog towards black due to our blend mode
return col;
}
ENDCG
}
}
}
}
Neste ponto, o novo material ParticleMat de CustomParticleShader.shader será usado para atribuir o efeito de partícula:
O efeito a ser alcançado é que, quando as partículas ultrapassarem o limite azul, elas serão automaticamente cortadas e não serão exibidas, portanto, os parâmetros do ParticleMat precisam ser ajustados. Como o stencilBufferValue na área azul = 1 e o stencilBufferValue = 0 fora da área, você pode definir "referenceValue = 1, stencilComp = Equal(3), stencilOp = Keep(0)" no ParticleMat, o efeito é o seguinte:
O efeito de mascaramento de tais efeitos de partículas também é realizado.
Endereço do código-fonte do projeto: funções de bloqueio e máscara entre a interface do usuário e os efeitos de partícula no Unity-Unity3D Document Class Resources-CSDN Download
PS:
1. Código-fonte Shader integrado do Unity:
Uma delas é baixar do site oficial : https://unity3d.com/get-unity/download/archive
Depois de selecionar a plataforma e a versão correspondentes, clique em "Built in shaders"
A segunda é baixá-lo no Github . Existe um endereço de projeto de código aberto: https://github.com/TwoTailsGames/Unity-Built-in-Shaders
Anexado aqui está o arquivo de código fonte Unity2018.4.1f1 built-in Shaders baixado: Unity2018.4.1f1 built-in Shaders source code file-Unity3D Documentation Resources-CSDN Download
2. O sombreador do buffer de estêncil de partículas usado acima terá alguns problemas no efeito de exibição no uso real, fazendo com que as partículas pareçam quadradas. Você pode usar os seguintes shaders: —— Buffer de estêncil de suporte:
Shader "UI/Particles/Additive" {
Properties {
_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
_MainTex ("Particle Texture", 2D) = "white" {}
_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
_StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
_StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
_ColorMask ("Color Mask", Float) = 15
[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
// Soft Mask support
// Soft Mask determines that shader supports soft masking by presence of this property.
[PerRendererData] _SoftMask("Mask", 2D) = "white" {}
}
Category {
Tags {
"Queue"="Transparent"
"IgnoreProjector"="True"
"RenderType"="Transparent"
"PreviewType"="Plane"
"CanUseSpriteAtlas"="True"
}
Blend SrcAlpha One
ColorMask RGB
Cull Off Lighting Off ZWrite Off
SubShader {
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 2.0
#pragma multi_compile_particles
#pragma multi_compile_fog
#include "UnityCG.cginc"
#include "UnityUI.cginc"
// Soft Mask Support
// You also can use full path (Assets/...)
#include "Assets/Plugins/SoftMask/Shaders/SoftMask.cginc"
#pragma multi_compile __ UNITY_UI_ALPHACLIP
// Soft Mask Support
#pragma multi_compile __ SOFTMASK_SIMPLE SOFTMASK_SLICED SOFTMASK_TILED
sampler2D _MainTex;
fixed4 _TintColor;
struct appdata_t {
float4 vertex : POSITION;
fixed4 color : COLOR;
float2 texcoord : TEXCOORD0;
};
struct v2f {
float4 vertex : SV_POSITION;
fixed4 color : COLOR;
float2 texcoord : TEXCOORD0;
UNITY_FOG_COORDS(1)
//#ifdef SOFTPARTICLES_ON
//float4 projPos : TEXCOORD2;
//#endif
// Soft Mask Support
// The number in braces determines what TEXCOORDn Soft Mask may use
// (it required only one TEXCOORD).
SOFTMASK_COORDS(2)
};
float4 _MainTex_ST;
v2f vert (appdata_t IN)
{
v2f v;
v.vertex = UnityObjectToClipPos(IN.vertex);
//#ifdef SOFTPARTICLES_ON
//v.projPos = ComputeScreenPos (v.vertex);
//COMPUTE_EYEDEPTH(v.projPos.z);
//#endif
v.color = IN.color;
v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex);
UNITY_TRANSFER_FOG(v,v.vertex);
SOFTMASK_CALCULATE_COORDS(v, IN.vertex) // Soft Mask Support
return v;
}
sampler2D_float _CameraDepthTexture;
float _InvFade;
fixed4 frag (v2f IN) : SV_Target
{
//#ifdef SOFTPARTICLES_ON
//float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(IN.projPos)));
//float partZ = IN.projPos.z;
//float fade = saturate (_InvFade * (sceneZ-partZ));
//IN.color.a *= fade;
//#endif
fixed4 col = 2.0f * IN.color * _TintColor * tex2D(_MainTex, IN.texcoord);
UNITY_APPLY_FOG_COLOR(IN.fogCoord, col, fixed4(0,0,0,0)); // fog towards black due to our blend mode
col.a *= SOFTMASK_GET_MASK(IN); // Soft Mask Support
return col;
}
ENDCG
}
}
}
}