[Résolu] Blend textures avec soft mask par dessus

[Jayme65]

Bonjour,

Je suis parvenu (notamment grâce à une aide précieuse trouvée sur ce forum pour certains points) à avoir un shader qui me permet de mixer 2 textures.

S'y est ajoutée ensuite une procédure pour garantir le bon aspect ratio en remplaçant par du noir les pixels hors de l'UV map!

Mais voila que je dois maintenant avoir un masque par dessus cela!
Pourriez-vous m'aider svp? Que dois-je ajouter à ce shader pour avoir un emplacement pour une texture qui va agir comme masque par dessus ce que j'ai déjà?

A gauche ce que j'ai (on ne voit pas l'effet blend, d'accord..mais il y en a un qui sert à switcher vers une autre image)
A droite ce que je voudrais une fois l'effet de soft mask appliqué!


D'avance un grand merci pour votre aide et pour m'aider à y voir plus clair!

Code : Tout sélectionner

Shader "Shaders/Screen_Clamped_Unlit_Fade"
{
  Properties
  {
    _Blend ( "Blend", Range ( 0, 1 ) ) = 0.5
    _Color ( "Main Color", Color ) = ( 1, 1, 1, 1 )
    _MainTex ( "Texture 1", 2D ) = "white" {}
    _Texture2 ( "Texture 2", 2D ) = "white" {}
  }
  SubShader
  {
    Tags { "RenderType"="Opaque" }
    LOD 300
    Pass
    {
      Cull Front
      SetTexture[_MainTex]
      SetTexture[_Texture2]
      {
        ConstantColor ( 0, 0, 0, [_Blend] )
        Combine texture Lerp( constant ) previous
      }
    }
  
    CGPROGRAM
    #pragma surface surf Unlit

    half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten) {
			half4 c;
			c.rgb = s.Albedo;
			c.a = 1;
			return c;
    }

    sampler2D _MainTex;
    sampler2D _Texture2;
    fixed4 _Color;
    float _Blend;
    
    struct Input
    {
      float2 uv_MainTex;
      float2 uv_Texture2;
    };
    
    void surf ( Input IN, inout SurfaceOutput o )
    {
      fixed4 t1  = tex2D( _MainTex, IN.uv_MainTex ) * _Color;
	  
      fixed4 c;
      if (IN.uv_MainTex.x > 1.0 || IN.uv_MainTex.x < 0.0 || IN.uv_MainTex.y > 1.0 || IN.uv_MainTex.y < 0.0)
        c = fixed4 (0, 0, 0, 0);
      else
        c = t1;

      fixed4 t2  = tex2D ( _Texture2, IN.uv_Texture2 ) * _Color;
      o.Albedo  = lerp(c.rgb, t2, _Blend );
    }
    ENDCG
  }
  FallBack "Diffuse"
}

PS: si au passage vous voyez des incohérences ou des choses inutiles ou dépréciées depuis dans le code, n'hésitez pas à me le signaler!

[boubouk50]

Salut,

Déjà, il faudrait que ton shader soit pour objet transparent et pas opaque (tag RenderType) avec le type de blending associé (voir les types associés OneMinusAlpha, etc, je me souviens lequel est de base le bon (le plus utilisé dans n'importe quel shader))
Il te faut juste une map d'opacité (dégradé noir à blanc) pour la couche alpha et ce devrait être bon.
Donc déclarer une texture supplémentaire pour l'opacité. -> _textureAlpha et sampler2D _textureAlpha
Utiliser le même set d'UV que la texture principale et récupérer la couleur de la texture d'opacité et la mettre dans le canal alpha -> o.alpha = tex2D ( _Texture2, IN._textureAlpha);

[Jayme65]

boubouk,
Merci beaucoup pour ta réponse, voici le shader adapté et cela fonctionne...pour autant que je le fasse passer en Lambert
Comment puis-je faire pour que cela fonctionne en Unlit (à moins qu'il n'y ait une limitation a utiliser de l'Unlit avec une transparence!?)

Code : Tout sélectionner

Shader "Shaders/Screen_Clamped_Unlit_Fade"
{
  Properties
  {
    _Blend ( "Blend", Range ( 0, 1 ) ) = 0.5
    _Color ( "Main Color", Color ) = ( 1, 1, 1, 1 )
    _MainTex ( "Texture 1", 2D ) = "white" {}
    _Texture2 ( "Texture 2", 2D ) = "white" {}
    _AlphaTex ("Alpha mask (R)", 2D) = "white" {}
  }
  SubShader
  {
      Tags { "Queue"="Transparent" "RenderType"="Transparent" }
      Blend SrcAlpha OneMinusSrcAlpha
      LOD 300
    
    Pass
    {
      Cull Front
      SetTexture[_MainTex]
      SetTexture[_Texture2]
      {
        ConstantColor ( 0, 0, 0, [_Blend] )
        Combine texture Lerp( constant ) previous
      }
    }
  
    CGPROGRAM
    #pragma surface surf Lambert alpha

    half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten) {
			half4 c;
			c.rgb = s.Albedo;
			c.a = 1;
			return c;
    }

    sampler2D _AlphaTex;
    sampler2D _MainTex;
    sampler2D _Texture2;
    fixed4 _Color;
    float _Blend;
    
    struct Input
    {
      float2 uv_MainTex;
      float2 uv_Texture2;
      float2 uv_AlphaTex;
    };
    
    void surf ( Input IN, inout SurfaceOutput o )
    {
      fixed4 t1  = tex2D( _MainTex, IN.uv_MainTex ) * _Color;
    
      fixed4 c;
      if (IN.uv_MainTex.x > 1.0 || IN.uv_MainTex.x < 0.0 || IN.uv_MainTex.y > 1.0 || IN.uv_MainTex.y < 0.0)
        c = fixed4 (0, 0, 0, 0);
      else
        c = t1;

      fixed4 t2  = tex2D ( _Texture2, IN.uv_Texture2 ) * _Color;

      o.Albedo  = lerp(c.rgb, t2, _Blend );
      o.Alpha = tex2D (_AlphaTex, IN.uv_AlphaTex).a;
    }
    ENDCG
  }
  FallBack "Diffuse"
}

[boubouk50]

Normalement, cela fonctionne puisqu'il existe de base dans Unity:
https://answers.unity.com/questions/109 ... hader.html

[Jayme65]

L'exemple donné est pour un Vertex/Fragment shader...moi c'est un Surface shader...je ne sais donc pas trop quoi retirer de cet exemple (je suis encore plus ignorant des Fragment shader que des Surface shader

[Jayme65]

Aaaarff! La valeur de l'alpha était bloqué à 1 dans la fonction LightingUnlit

Code : Tout sélectionner

half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten) {
	half4 c;
	c.rgb = s.Albedo;
	c.a = 1;
	return c;
}

...c'est mieux comme ça

Code : Tout sélectionner

half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten) {
	half4 c;
	c.rgb = s.Albedo;
	c.a = s.Alpha;
	return c;
}

Encore merci boubouk!!

[boubouk50]

Quel nul, je l'avais vu, mais j'ai pas du tout percuté...
Si résolu, alors tu peux ajouter [RESOLU] en début de titre du premier message pour signaler aux autres membres.

[Jayme65]

Je me rend compte que le shader, bien que du type Unlit normalement est réceptif à la lumière!
Pourrais tu (vous) m'aider à voir où ça cloche? Merci!

Code : Tout sélectionner

Shader "Screen_Clamped_Unlit_Fade_Alpha"
{
  Properties
  {
    _Blend ( "Blend", Range ( 0, 1 ) ) = 0.5
    _Color ( "Main Color", Color ) = ( 1, 1, 1, 1 )
    _MainTex ( "Texture 1", 2D ) = "white" {}
    _Texture2 ( "Texture 2", 2D ) = "white" {}
    _AlphaTex ("Alpha mask (R)", 2D) = "white" {}
  }
  SubShader
  {
    Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
    ZWrite Off
    Lighting Off 
    Blend SrcAlpha OneMinusSrcAlpha
    LOD 300
    
    Pass
    {
      Cull Front
      SetTexture[_MainTex]
      SetTexture[_Texture2]
      {
        ConstantColor ( 0, 0, 0, [_Blend] )
        Combine texture Lerp( constant ) previous
      }
    }
  
    CGPROGRAM
    #pragma surface surf Unlit alpha

    half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten) {
			half4 c;
			c.rgb = s.Albedo;
			c.a = s.Alpha;
			return c;
    }

    sampler2D _AlphaTex;
    sampler2D _MainTex;
    sampler2D _Texture2;
    fixed4 _Color;
    float _Blend;
    
    struct Input
    {
      float2 uv_MainTex;
      float2 uv_Texture2;
      float2 uv_AlphaTex;
    };
    
    void surf ( Input IN, inout SurfaceOutput o )
    {
      fixed4 t1  = tex2D( _MainTex, IN.uv_MainTex ) * _Color;
    
      fixed4 c;
      if (IN.uv_MainTex.x > 1.0 || IN.uv_MainTex.x < 0.0 || IN.uv_MainTex.y > 1.0 || IN.uv_MainTex.y < 0.0)
        c = fixed4 (0, 0, 0, 0);
      else
        c = t1;

      fixed4 t2  = tex2D ( _Texture2, IN.uv_Texture2 ) * _Color;

      o.Albedo  = lerp(c.rgb, t2, _Blend );
      o.Alpha = tex2D (_AlphaTex, IN.uv_AlphaTex).a;
    }
    ENDCG
  }
  FallBack "Diffuse"
}

[boubouk50]

Pourtant, tu as bien le tag Lighting Off...

Je lis plusieurs trucs:
- Eviter le surface shader pour les Unlits -> utiliser un Vertex + Fragment Shader
- Passer la couleur en émissif et mettre l'albedo à noir.
- Ajouter le tag noforwardadd dans le #pragma

Tu as la liste des tags ici:
https://docs.unity3d.com/Manual/SL-SurfaceShaders.html
tu peux également exclure des passes: exclude_path:deferred, exclude_path:forward, exclude_path:prepass

EDIT - Aussi, pour ton Fallback, n'utilise pas le Diffuse qui utilise la lumière, mais un shader Unlit plutôt. "Mobile/VertexLit" ou "Unlit/Texture"

[Jayme65]

Merci pour ta réponse! Passer la couleur en émissif et mettre l'albedo à noir fait que le shader n'est plus sensible à la lumière...mais du coup mon masque ne marche plus! Ah j'te jure!

Donc, ce qui suit est en effet émissif et non sensible à la lumière..mais du coup plus de masque!

Code : Tout sélectionner

Shader "Screen_Clamped_Emissive_Fade_Alpha" {
  Properties {
    _Color ( "Main Color", Color ) = ( 1, 1, 1, 1 )
    _Blend ( "Blend", Range ( 0, 1 ) ) = 0.5
    _MainTex ("Main Map", 2D) = "white" {}
    _Texture2 ( "Texture 2", 2D ) = "white" {}
    _AlphaTex ("Alpha mask (R)", 2D) = "white" {}
    _EmissionPower ("Emission Power", Range(0,20)) = 1.0
  }
   
  SubShader {
    Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
    ZWrite Off
    Lighting Off 
    Blend SrcAlpha OneMinusSrcAlpha
    LOD 100
      
    Pass
    {
      SetTexture[_MainTex]
      SetTexture[_Texture2]
      {
        ConstantColor ( 0, 0, 0, [_Blend] )
        Combine texture Lerp( constant ) previous
      }    
    }

    Cull Off
      
    CGPROGRAM   
    #pragma surface surf Lambert alpha
    #include "UnityCG.cginc"
      
    half4 LightingLambert (SurfaceOutput s, half3 lightDir, half atten) {
      half4 c;
      c.rgb = s.Albedo + s.Emission;
      c.a = s.Alpha;;
      return c;
    }
    
      
    sampler2D _MainTex;
    sampler2D _Texture2;
    sampler2D _AlphaTex;
    fixed4 _Color;
    float _Blend;
    float _EmissionPower;
      
    struct Input {
      float2 uv_MainTex;
      float2 uv_Texture2;
      float2 uv_AlphaTex;
    };
      
    void surf(Input IN, inout SurfaceOutput o) {
      half4 tex = tex2D(_MainTex, IN.uv_MainTex) * _Color;
      half4 c;
      if (IN.uv_MainTex.x > 1.0 || IN.uv_MainTex.x < 0.0 || IN.uv_MainTex.y > 1.0 || IN.uv_MainTex.y < 0.0)
        c = half4 (0, 0, 0, 0);
      else
        c = tex;
    	half4 tex2  = tex2D ( _Texture2, IN.uv_Texture2 ) * _Color;
      o.Emission = lerp(c.rgb * _EmissionPower, tex2 * _EmissionPower, _Blend );
      o.Albedo = fixed4 (0, 0, 0, 0);
      o.Alpha = tex2D (_AlphaTex, IN.uv_AlphaTex).a;
    }
      
    ENDCG
  }   
  Fallback "Diffuse"
}