GLSL Shader: Half a colour value in var A, other half in var B, without conditional statement - glsl

Question

I'm working on a texture / terrain splatting GLSL shader that will support 8 textures.
The first version I made uses RGBA as input - each channel is the intensity for each texture.
The second version I tried to double the "channels" by splitting them in half. For example;
R0 = nothing on Texture1
R64 = Half on texture 1
R127 = Full texture 1
R128 = nothing Texture 5
R196 = half texture 5
R254 = Full texture 5
andsoforth.
I've come to know that if- statements in shaders are very bad practice - it also felt like doing something wrong.
The thing is, I dont know the mathmatical functions to take half of each channel as use it as a full variable.
Here's the fragment shader code;
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
uniform sampler2D texture; //Texture
uniform float surfWidth;
uniform float surfHeight;
uniform float xpos;
uniform float ypos;
void main()
{
//Setting the main texture position
vec2 texpos = (v_vTexcoord*vec2(surfWidth, surfHeight)) + vec2(xpos, ypos);
//Modulo 1 for repeat, devide by 4 because its a 4x4 texture sheet
float tpx = mod(texpos.x,1.0)/4.0;
float tpy = mod(texpos.y,1.0)/4.0;
//Setup terrain "intensities"
float t1 = 0.0;
float t2 = 0.0;
float t3 = 0.0;
float t4 = 0.0;
float t5 = 0.0;
float t6 = 0.0;
float t7 = 0.0;
float t8 = 0.0;
//Load from the surface (splatmap)
float btr = (v_vColour * texture2D(gm_BaseTexture, v_vTexcoord)).r;
float btg = (v_vColour * texture2D(gm_BaseTexture, v_vTexcoord)).g;
float btb = (v_vColour * texture2D(gm_BaseTexture, v_vTexcoord)).b;
float bta = (v_vColour * texture2D(gm_BaseTexture, v_vTexcoord)).a;
//Calculating what texture to use (also deviding each channel into 2)
if (btr <= 0.5) {
t1 = btr*2.0;
} else {
t5 = (btr-0.5)*2.0;
}
if (btg <= 0.5) {
t2 = btg*2.0;
} else {
t6 = (btg-0.5)*2.0;
}
if (btb <= 0.5) {
t3 = btb*2.0;
} else {
t7 = (btb-0.5)*2.0;
}
if (bta <= 0.5) {
t4 = bta*2.0;
} else {
t8 = (bta-0.5)*2.0;
}
//Get terrain pixels at proper positions
vec4 ter1 = texture2D(texture, vec2(tpx, tpy));
ter1.a = t1;
vec4 ter2 = texture2D(texture, vec2(tpx+0.25, tpy));
ter2.a = t2;
vec4 ter3 = texture2D(texture, vec2(tpx+0.50, tpy));
ter3.a = t3;
vec4 ter4 = texture2D(texture, vec2(tpx+0.75, tpy));
ter4.a = t4;
vec4 ter5 = texture2D(texture, vec2(tpx, tpy+0.25));
ter5.a = t5;
vec4 ter6 = texture2D(texture, vec2(tpx+0.25, tpy+0.25));
ter6.a = t6;
vec4 ter7 = texture2D(texture, vec2(tpx+0.50, tpy+0.25));
ter7.a = t7;
vec4 ter8 = texture2D(texture, vec2(tpx+0.75, tpy+0.25));
ter8.a = t8;
//Output to screen
gl_FragColor =
ter1*vec4(t1) +
ter2*vec4(t2) +
ter3*vec4(t3) +
ter4*vec4(t4) +
ter5*vec4(t5) +
ter6*vec4(t6) +
ter7*vec4(t7) +
ter8*vec4(t8);
}
I'm quite sure that I'm going to need something like clamp() or lerp() but I can't wrap my head around it..
Also, when textures overlap, they get "brighter" (because both textures are simply added in the last statement... I have no idea how I could prevent that from happening and always outputting a "maximum" of the texture itself (so that it doesn't "light up"). Excuse me if I sound dumb, this is my first real shader :)

Answer 1

Branches are not that bad on modern hardware assuming they span multiple fragments and potentially save quite a bunch of work. Writing your logic wihout branches would look like this:
btr *= 2.;
t1 = fract(min(btr,1.));
t5 = max(btr-1.,0.);
Note that with your approach you can not blend two "splatting channels" that are packed in the same color channel(i.e. blending t1 and t5). It would be simpler(and probably more efficient) to just sample another splatmap.
As to blending the final output, assuming you want to linearly blend you'd divide the individual weights by the sum of all weights.
float sum = t1+t2+t3+t4+t5+t6+t7+t8;
gl_FragColor = ter1*(t1/sum) + ter2*(t2/sum) + ter3*(t3/sum) + ...