Deriving transparency from alpha channel of Albedo texture in Surface shader

[eco_bach]

Hi
Have a challenging issue for a shader novice like myself. I have an existing shader which uses vertex animation to deform a mesh at render time using previously created position and normal vertex maps.
It works fine.
However, since this is supposed to be an ocean surface I would like to add a little translucency, and optionally, subsurface scattering to the shader.
The color is controlled by an additional Albedo map with alpha.

Here is the Surface Shader and a screen grab of the actual mesh is attached. I’ve also included an inspector view of the mesh prefab

(See this sidefx article for the entire workflow)

Shader "sidefx/vertex_soft_body_shader" {
    Properties {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
        _boundingMax("Bounding Max", Float) = 1.0
        _boundingMin("Bounding Min", Float) = 1.0
        _numOfFrames("Number Of Frames", int) = 240
        _speed("Speed", Float) = 0.33
        [MaterialToggle] _pack_normal ("Pack Normal", Float) = 0
        _posTex ("Position Map (RGB)", 2D) = "white" {}
        _nTex ("Normal Map (RGB)", 2D) = "grey" {}
    }
    SubShader {
        Tags { "RenderType"="Opaque" }
        LOD 200
     
        CGPROGRAM
        // Physically based Standard lighting model, and enable shadows on all light types
        #pragma surface surf Standard addshadow vertex:vert

        // Use shader model 3.0 target, to get nicer looking lighting
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _posTex;
        sampler2D _nTex;
        uniform float _pack_normal;
        uniform float _boundingMax;
        uniform float _boundingMin;
        uniform float _speed;
        uniform int _numOfFrames;

        struct Input {
            float2 uv_MainTex;
        };

        half _Glossiness;
        half _Metallic;
        fixed4 _Color;

        // Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
        // See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
        // #pragma instancing_options assumeuniformscaling
        UNITY_INSTANCING_CBUFFER_START(Props)
            // put more per-instance properties here
        UNITY_INSTANCING_CBUFFER_END

        //vertex function
        void vert(inout appdata_full v){
            //calcualte uv coordinates
            float timeInFrames = ((ceil(frac(-_Time.y * _speed) * _numOfFrames))/_numOfFrames) + (1.0/_numOfFrames);

            //get position and normal from textures
            float4 texturePos = tex2Dlod(_posTex,float4(v.texcoord1.x, (timeInFrames + v.texcoord1.y), 0, 0));
            float3 textureN = tex2Dlod(_nTex,float4(v.texcoord1.x, (timeInFrames + v.texcoord1.y), 0, 0));

            //expand normalised position texture values to world space
            float expand = _boundingMax - _boundingMin;
            texturePos.xyz *= expand;
            texturePos.xyz += _boundingMin;
            texturePos.x *= -1;  //flipped to account for right-handedness of unity
            v.vertex.xyz += texturePos.xzy;  //swizzle y and z because textures are exported with z-up

            //calculate normal
            if (_pack_normal){
                //decode float to float2
                float alpha = texturePos.w * 1024;
                float2 f2;
                f2.x = floor(alpha / 32.0) / 31.5;
                f2.y = (alpha - (floor(alpha / 32.0)*32.0)) / 31.5;

                //decode float2 to float3
                float3 f3;
                f2 *= 4;
                f2 -= 2;
                float f2dot = dot(f2,f2);
                f3.xy = sqrt(1 - (f2dot/4.0)) * f2;
                f3.z = 1 - (f2dot/2.0);
                f3 = clamp(f3, -1.0, 1.0);
                f3 = f3.xzy;
                f3.x *= -1;
                v.normal = f3;
            } else {
                textureN = textureN.xzy;
                textureN *= 2;
                textureN -= 1;
                textureN.x *= -1;
                v.normal = textureN;
            }
        }

        void surf (Input IN, inout SurfaceOutputStandard o) {
            // Albedo comes from a texture tinted by color
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
            o.Albedo = c.rgb;
            // Metallic and smoothness come from slider variables
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

[eco_bach]

ok so some progress!

Am able to add global transparency following these instructions

Shader Help: Adding transparency to a shader.

Edit 1
_MainTex (“Texture”, 2D) = “white” {}
Tags { “RenderType” = “Opaque” }
to:
_MainTex (“Color (RGB) Alpha (A)”, 2D) = “white”
Tags { “Queue”=“Transparent” “RenderType”=“Transparent” }

Edit 2
Append “alpha”:
#pragma surface surf Lambert alpha

Edit 3
Added this line after o.Albedo…
o.Alpha = tex2D (_MainTex, IN.uv_MainTex).a;

But how would I change alpha based on the alpha channel of my Main Texture(albedo map)?

[Namey5]

Those are the steps. In fact, I would recommend that you keep the alpha as “c.a” like you had in the original, so that you can also control transparency through the main colour’s alpha channel if need be.

[brownboot67]

This is bad "o.Alpha = tex2D (_MainTex, IN.uv_MainTex).a;" You’re re-sampling a texture you’ve already sampled. The shader code you started with already sets the output Alpha to your sampled MainTex’s alpha channel times the tint Color’s alpha.

Adjusting the tags and adding alpha to end of the surface pragma line is all you have to do.