Unable to mask a MovieTexture in Unity

Question

I'm currently playing a movie in Unity using MovieTexture and applying a custom shader to allow an alpha channel. Problem is I need to have the top half of the video masked and nothing seems to work. I believe it's the shader preventing it (correct me if I'm wrong).

I tried 3 different masking techniques:

• Standard Mask component on the video layer (quad) with a black and transparent PNG image as mask.
• DepthMask applied to a 3D object intersecting video layer - Uses a special shader that affects render queue or draw calls (I forget) to prevent anything from being drawn that is behind or within the 3D object.
• Putting the quad inside a Canvas and Panel UI layer and adjusting them so canvas and panel are half the size of the video layer. (Had to use a quad as I don't believe you can add a materiel to a UI element?)

None of these are blocking any of the video, unfortunately.

(This is the alpha shader I'm using: https://github.com/keijiro/AotsMovieTexture)

Here's the code for the shader as well:

Shader "Custom/Aots Movie Texture" {
    Properties
    {
        _MainTex("Base Texture", 2D) = "" {}
        _ColorTint("Color Tint", Color) = (0.5, 0.5, 0.5, 1)
    }

    CGINCLUDE

#include "UnityCG.cginc"

sampler2D _MainTex;
half4 _ColorTint;

struct v2f
{
    float4 position : SV_POSITION;
    float2 texcoord : TEXCOORD0;
};

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

float4 frag(v2f i) : SV_Target 
{
    float2 uv1 = i.texcoord;
    float2 uv2 = i.texcoord;

    uv1.x *= 0.5f;
    uv2.x *= 0.5f;
    uv2.x += 0.5f;

    half4 color = tex2D(_MainTex, uv1);
    half4 mask = tex2D(_MainTex, uv2);

    color.rgb *= _ColorTint.rgb * 2;
    color.a = mask.r * _ColorTint.a;

    return color;
}

    ENDCG

    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }
        Pass
        {
            ZTest Always Cull Off ZWrite Off
            Fog { Mode off }
            Blend SrcAlpha OneMinusSrcAlpha
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            ENDCG
        }
    } 
}

Edit:

Just explain in more details what I'm looking to do, we have a 4K video divided into quads. Top two quads will be independent videos and bottom two will be used for the alpha videos. I just need the top two quads (top half of the 4k video) hidden, so you only see the alpha channel when the video is layered on top like the shader I linked to.

Answer 1

So, shader will be look like that:

Shader "StackOverFlow/splitVideo"{
    Properties
    {
        _MainTex("Base Texture", 2D) = "" {}
        _ColorTint("Color Tint", Color) = (0.5, 0.5, 0.5, 1)
        [MaterialToggle]ShowLeft("Show Only Left", Float) = 0 
        [MaterialToggle]ShowRight("Show Only Right", Float) = 0
    }

    CGINCLUDE

    #include "UnityCG.cginc"
    #pragma multi_compile _ SHOWLEFT_ON
    #pragma multi_compile _ SHOWRIGHT_ON
    sampler2D _MainTex;
    half4 _ColorTint;

    struct v2f
    {
        float4 position : SV_POSITION;
        float2 texcoord : TEXCOORD0;
    };

    v2f vert(appdata_base v)
    {
        v2f o;
        o.position = UnityObjectToClipPos(v.vertex);
        o.texcoord = v.texcoord;
        return o;
    }

    float4 frag(v2f i) : SV_Target
    {
        float2 uv1 = i.texcoord;
        float2 uv2 = i.texcoord;

#ifdef SHOWLEFT_ON   
        uv1.x *= 0.5;
        uv2.x *= 0.5;
#else
#ifdef SHOWRIGHT_ON
        uv1.x *= 0.5;
        uv2.x *= 0.5;
        uv2.x += 0.5;
        uv1.x += 0.5;
#endif  
#endif          
        uv1.y *= 0.5; // line 1
        uv1.y += 0.5; // line 2
        uv2.y *= 0.5;

        half4 color = tex2D(_MainTex, uv1);
        half4 mask = tex2D(_MainTex, uv2);

        color.rgb *= _ColorTint.rgb * 2;
        color.a = mask.b *_ColorTint.a;

        return color;
    }

    ENDCG

    SubShader
    {
        Tags{ "RenderType" = "Transparent" "Queue" = "Transparent" }
        Pass
        {
            ZTest Always Cull Off ZWrite Off
            Fog{ Mode off }
            Blend SrcAlpha OneMinusSrcAlpha
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            ENDCG
        }
    }
}

About vertex and fragment shaders you can read here.

Let's explain, what is going on here! (in offsets)

We want to see our videos cutted by alpha masks! (isn't it?)

I using that texture (or video. it doesn't matter):

By default your Fragment will looks like that:

 float4 frag(v2f i) : SV_Target
 {
     half4 color = tex2D(_MainTex, i.texcoord);
     return color;
 }

First step, let's try to draw both videos on quad without masks!

To do that, let's save default texture coordinates in temp variable float2 uv1 = i.texcoord;. And multiply uv1.y by 0.5; what we will see, and why we do that?

We seem to have stretched the texture twice vertically, and shader draws only bottom half of the texture. Because uv.y coords of top half outside of quad. Yes it is good, but we want videos! So, let's move the texture vertically by half size of texture coords uv1.y +=0.5. What we have?

Yes! Our videos is best! (example to draw only videos)

 float4 frag(v2f i) : SV_Target
 {
     float2 uv1 = i.texcoord;
     uv1.y *= 0.5;
     uv1.y += 0.5;
     half4 color = tex2D(_MainTex, uv1);
     return color;
 }

Second step. To use masks, we need two variables to use it! Our texture is single, but we have to use it like it's two different. (videos and masks)! Declare a new variable

float2 uv2 = i.texcoord;

and cut top half videos uv2.y *= 0.5;. Same story as uv1, but without move the texture. Second variable will be

half4 mask = tex2D(_MainTex, uv2);

Animals is our friends! We do not see them, but they see us!

Since we use black color to cut, we can assign the alpha channel of videos from the current color of masks.

color.a = mask.r;

simple Shader without any settings will look like this:

float4 frag(v2f i) : SV_Target
{
    float2 uv1 = i.texcoord;
    float2 uv2 = i.texcoord;      
    uv1.y *= 0.5;
    uv1.y += 0.5;
    uv2.y *= 0.5;
    half4 color = tex2D(_MainTex, uv1);
    half4 mask = tex2D(_MainTex, uv2);
    color.a = mask.r;
    return color;
}

To control alpha and current color of videos let's add _ColorTint:

//...
half4 mask = tex2D(_MainTex, uv2);
color.rgb *= _ColorTint.rgb * 2;
color.a = mask.r *_ColorTint.a;
return color;
//...

So, you can ask me, -"why you are using mask.r?", -"r is RED?", -"why not g or b?"

Answer: black color is (0,0,0) and white is (1,1,1). If i use other channels(g or b), it will not change anything. When you multiply "color.a" to 0, it will be Tranparent.

That's all.

Sorry for my bad and poor English!