I have this shader of CRT-screen effect. How to make bigScanline semi-transparent? I have uniforms for this, but I don't know how to use it.
```glsl
#version 300 es
precision mediump float;
  
uniform sampler2D uSampler0;
uniform vec2 uResolution;
uniform float uTime;

// Additional Uniforms
uniform float uDistortion;          // Controls radial distortion (0.0 - 0.5)
uniform float uScanlineIntensity;   // Intensity of horizontal scanlines (0.0 - 1.0)
uniform float uChromAbShift;        // Chromatic aberration shift (0.0 - 0.01)
uniform float uBigScanlineWidth;     // Width of the big vertical scanline (0.005 - 0.02)
uniform vec3 uBigScanlineColor;      // Color of the big vertical scanline (e.g., vec3(R, G, B))
uniform float uBigScanlineSpeed;     // Speed of the big scanline movement (0.1 - 1.0)
uniform float uBigScanlineOpacity;   // Opacity of the big vertical scanline (0.0 - 1.0)

in vec2 vTexCoord;
out vec4 fragColor;

// Simple hash function for noise
float hash(vec2 p) {
    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
}

void main() {
    // Normalize coordinates to range [-1, 1]
    vec2 centeredCoord = (vTexCoord * 2.0) - 1.0;
    
    // Apply barrel uDistortion
    float dist = length(centeredCoord);
    vec2 distortedCoord = centeredCoord * (1.0 + uDistortion * pow(dist, 2.0));
    
    // Convert back to [0,1] range
    vec2 finalCoord = (distortedCoord + 1.0) / 2.0;
    
    // Prevent sampling outside the texture
    if(finalCoord.x < 0.0 || finalCoord.x > 1.0 || finalCoord.y < 0.0 || finalCoord.y > 1.0){
        fragColor = vec4(0.0);
        return;
    }
    
    // Chromatic aberration: sample red, green, blue channels with slight offsets
    vec2 redOffset = finalCoord + vec2(uChromAbShift, 0.0);
    vec2 greenOffset = finalCoord;
    vec2 blueOffset = finalCoord + vec2(-uChromAbShift, 0.0);
    
    float r = texture(uSampler0, redOffset).r;
    float g = texture(uSampler0, greenOffset).g;
    float b = texture(uSampler0, blueOffset).b;
    
    vec3 color = vec3(r, g, b);
    
    // Apply horizontal scanlines
    float scanline = sin(finalCoord.y * uResolution.y * 3.14159) * 0.5 + 0.5; // Adjust frequency as needed
    color *= mix(1.0, scanline, uScanlineIntensity);
    
    // Add noise
    float noise = hash(floor(finalCoord * uResolution.xy)) * 0.05; // Adjust noise intensity
    color += noise;

    // Add a prominent vertical scanline moving from top to bottom
    // Calculate the current scanline position based on time and speed
    float scanPos = 1.0 - mod(uTime * uBigScanlineSpeed, 1.0 + uBigScanlineWidth); // Wraps around after reaching 1.0

    // Determine distance from current fragment to the scanline position
    float distanceToScanline = abs(finalCoord.y - scanPos);

    // Create a smooth transition for the scanline edges
    float scanlineFactor = smoothstep(uBigScanlineWidth, uBigScanlineWidth - 0.001, distanceToScanline);

    // Blend the scanline color with the fragment color
    vec4 final_color = mix(vec4(uBigScanlineColor, 1.0), vec4(color, 1.0), 1.0 - scanlineFactor);
    
    // Optional: Clamp the color to [0,1]
    color = clamp(color, 0.0, 1.0);
    
    fragColor = final_color; //vec4(color, 1.0);
}
```