texture2D(gm_BaseTexture, v_vTexcoord);

//Using the sampler 'uni_diffuse' and 1.0 bias (half resolution with mipmapping).
texture2D(uni_diffuse, v_vTexcoord, 1.0);

//Force half resolution with mipmapping.
texture2DLod(gm_BaseTexture, v_vTexcoord, 1.0);

//Project a texture using frag coordinates.
texture2DProj(gm_BaseTexture, gl_FragCoord.xyz);

//Project a texture at half resolution (using mipmapping).
texture2DProjLod(gm_BaseTexture, gl_FragCoord.xyz, 1.0);

float two = floor(2.5);

float three = ceil(2.5);

float half = fract(2.5);

float two = mod(7.0,5.0);

float one = sign(10.);

float five = abs(-5.0);

float one = min(1.0, 4.0);

float four = max(1.0, 4.0);

float five = abs(-5.0);

//Mix between the source color and destination color, by 'factor' (float or vec3)
vec3 col = mix(src, dst, factor);

//Get the source's red and green channels and the destination's blue channel.
vec3 col = mix(src, dst, vec3(0,0,1));

//Set the alpha to 0.0 if 'color.a' is less-than 0.5:
color.a = step(0.5, color.a);

//Set the light brightness to 1.0 at the center and fade out to 'radius'
float light = smoothstep(radius, 0.0, dist);

//Increase the color contrast by using a narrower range.
color = smoothstep(contrast, 1.0-contrast, color);

//Adjust for gamma correction.
vec3 gamma_encode = pow(color.rgb, vec3(2.2));

//Make a cool blue gradient using different exponents.
vec3 gradient = pow(uv.yyy, vec3(2.0, 1.0, 0.5))

//Compute sphere heightat the current position, 'pos'.
float sphere_height = sqrt(radius * radius - dot(pos, pos));

//Compute a weight value from an inverse square-root.
float weight = inversesqrt(i+1.0);

//This compute lighting with an exponentially falloff.
float light = exp(-dist * falloff);

//This compute lighting with an exponentially falloff.
float light = exp(-dist * falloff);

//Smooth maximum based off iq's smin function: https://iquilezles.org/www/articles/smin/smin.htm
float smax = log(exp(a*k)+exp(b*k))/k;

//Round x up to a power of 2 number (e.g. 2,4,8...)
float powerOf2 = exp2(ceil(log2(x)));

//Calculate a light's attenuation based the distance to the light
float light = max(1.0 - length(pixel_pos - light_pos) / radius, 0.0);

//Calculate a light's attenuation based the distance to the light
float light = max(1.0 - distance(pixel_pos, light_pos) / radius, 0.0);

//Compute the dot lighting with the light direction
float light_dot = max(dot(normal, normalize(pos - light_pos)), 0.0);

//Compute the luminance using a weighted average
float grayscale = dot(color.rgb, vec3(0.299, 0.587, 0.114));

//A gradient between a start and end point
vec2 direction = end - start;
float gradient = dot(position - start, direction) / dot(direction, direction);

//Compute the dot lighting with the light direction
float light_dot = max(dot(normal, normalize(pos - light_pos)), 0.0);

//Compute a pseudo-random hash from 'n'
float hash = fract(sin(dot(n, vec2(4.044,6.536))) * 4101.);

//Compute the side vector from the camera forward and up
vec3 side = normalize(cross(forward, up));

//Compute the normal from standard derivatives
vec3 normal = normalize(cross(dFdx(pos), dFdy(pos)));

//Compute the reflection of the viewspace direction and the normal
vec3 reflection_direction = reflect(normalize(view), normal);

//Compute the refraction vector into water
vec3 refraction_direction = refract(normalize(view), normal, 1.0/1.33);

//Flip a random kernel if it's facing against the normal
vec3 hemisphere = faceforward(kernel, kernel, normal)

//Compute weights as a component product of 'a' and 'b'
mat4 weights = matrixCompMult(a, b);

//Convert 60 degree to radians
float sixty = radians(60.0);
//Compute a rotation matrix for this angle
mat2 rotate = mat2(cos(sixty), sin(sixty), -sin(sixty), cos(sixty));

//Convert pi/2 to degrees (about 90)
float ninety = degrees(1.5707963);

//Compute the direction vector from a radian angle
vec2 direction = vec2(cos(angle), sin(angle));

//Compute a pseudo-random hash from 'n'
float hash = fract(sin(dot(n, vec2(4.044,6.536))) * 4101.);

//Compute the direction vector from a radian angle
vec2 direction = vec2(cos(angle), sin(angle));

//Compute the y/x ratio at 'angle'
float ratio = tan(angle);

//Compute angle 'a' for y = sin(a)
float angle = asin(y);

//Compute angle 'a' for x = cos(a)
float angle = acos(x);

//Compute angle for the y to x ratio
float angle = atan(y/x);

//Compute angle between p1 and p2
float angle2 = atan(p2.y-p1.y, p2.x-p1.x);

//Returns true for each axis that equals 0.0
bvec3 origin = equal(position, vec3(0.0, 0.0, 0.0));

//Returns true for each axis that does not equal 0.0
bvec3 origin = notEqual(position, vec3(0.0, 0.0, 0.0));

//Returns true for each axis that is less than 0.0
bvec3 negative = lessThan(position, vec3(0.0, 0.0, 0.0));

//Returns true if both axis of position are within 10.0 units of 0, 0
bool box = all(lessThanEqual(abs(position.xy), vec2(10.0)));

//Returns true for each axis that is greater than 0.0
bvec3 positive = greaterThan(position, vec3(0.0, 0.0, 0.0));

//Returns true if any axis is 10.0 units or more units away from of 0, 0
bool outside = any(greaterThanEqual(abs(position.xy), vec2(10.0)));

//Returns true if any axis is 10.0 units or more units away from of 0, 0
bool outside = any(greaterThanEqual(abs(position.xy), vec2(10.0)));

//Returns true if both axis of position are within 10.0 units of 0, 0
bool box = all(lessThanEqual(abs(position.xy), vec2(10.0)));

//Another way to do notEqual(a, b) in GLSL ES
bvec3 not_equal = not(equal(a, b));