{{ message }}

# Some useful GLSL functions

##### Clone this wiki locally

2D grid:

``````bool grid(vec2 uv)
{
return fract(uv.x) > 0.5 ^^ fract(uv.y) > 0.5;
}
``````

Circle:

``````bool circle(vec2 pos, float rad, vec2 uv)
{
}
``````

Smooth circle:

``````float smooth_circle(float sm, vec2 pos, float rad, vec2 uv)
{
}
``````

Convert boolean to float:

``````float b2f(bool a)
{
if(a) {return 1.0;} else {return 0.0;}
}
``````

Sphere:

``````float sphere(in vec3 pos, in float r, in vec3 ro, in vec3 rd, out vec3 nor)
{
ro -= pos;
float b = dot(ro, rd);
float h = b*b - dot(ro, ro) + r*r;
if (h<0.0) return -1.0;
float t = -b - sqrt(h);
nor = (ro + rd * t)/r;
return t;
}
``````

Horizontal plane:

``````float horizontal_plane(in float height, in vec3 ro, in vec3 rd, out vec3 nor)
{
nor = vec3(0.0, 1.0, 0.0);
return -(ro.y - height)/rd.y;
}
``````

Cube:

``````float cube(in vec3 a, in vec3 b, in vec3 ro, in vec3 rd, out vec3 nor)
{
float min_t = -1.0;
float t;
t = -(ro.y - b.y)/rd.y;
{
vec3 pos = ro + rd * t;
vec2 ins = step(b.xz, pos.xz) - step(a.xz, pos.xz);
if(ins.x * ins.y > 0.0)
{
nor = vec3(0.0, 1.0, 0.0);
min_t = t;
}
}
t = -(ro.y - a.y)/rd.y;
if(min_t == -1.0 || t < min_t)
{
vec3 pos = ro + rd * t;
vec2 ins = step(b.xz, pos.xz) - step(a.xz, pos.xz);
if(ins.x * ins.y > 0.0)
{
nor = vec3(0.0, -1.0, 0.0);
min_t = t;
}
}
t = -(ro.x - b.x)/rd.x;
if(min_t == -1.0 || t < min_t)
{
vec3 pos = ro + rd * t;
vec2 ins = step(b.yz, pos.yz) - step(a.yz, pos.yz);
if(ins.x * ins.y > 0.0)
{
nor = vec3(1.0, 0.0, 0.0);
min_t = t;
}
}
t = -(ro.x - a.x)/rd.x;
if(min_t == -1.0 || t < min_t)
{
vec3 pos = ro + rd * t;
vec2 ins = step(b.yz, pos.yz) - step(a.yz, pos.yz);
if(ins.x * ins.y > 0.0)
{
nor = vec3(-1.0, 0.0, 0.0);
min_t = t;
}
}
t = -(ro.z - b.z)/rd.z;
if(min_t == -1.0 || t < min_t)
{
vec3 pos = ro + rd * t;
vec2 ins = step(b.xy, pos.xy) - step(a.xy, pos.xy);
if(ins.x * ins.y > 0.0)
{
nor = vec3(0.0, 0.0, -1.0);
min_t = t;
}
}
t = -(ro.z - a.z)/rd.z;
if(min_t == -1.0 || t < min_t)
{
vec3 pos = ro + rd * t;
vec2 ins = step(b.xy, pos.xy) - step(a.xy, pos.xy);
if(ins.x * ins.y > 0.0)
{
nor = vec3(0.0, 0.0, 1.0);
min_t = t;
}
}

return min_t;
}
``````

Order intersection results:

``````void order(in int oid, in float ot, in vec3 onor,
in int ignore_id, inout int id, inout float t, inout vec3 nor)
{
if(ignore_id != oid && ot > 0.0 && ot < t) {t = ot; nor = onor; id = oid;}
}
``````

Setup rays for ray tracing:

``````vec2 uv = fragCoord.xy / iResolution.xy;
uv.y *= iResolution.y / iResolution.x;

// Generate a ray with origin ro and direction rd.
vec3 ro = vec3( 0.0, 1.0, 4.0 );
vec3 rd = normalize( vec3( -1.0+2.0*uv, -1.0 ) );
``````

Random number from 2D coordinates:

``````float rand(vec2 co)
{
return fract(sin(dot(co.xy, vec2(12.9898,78.233))) * 43758.5453);
}
``````

Random direction from 2D coordinates:

``````vec3 rand_dir(vec2 p)
{
return normalize(vec3(rand(p)-0.5, rand(p + vec2(1.0))-0.5, rand(p + vec2(2.0))-0.5));
}
``````

Convert from RGB to HSB:

``````vec3 rgb2hsb( in vec3 c ){
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = mix(vec4(c.bg, K.wz),
vec4(c.gb, K.xy),
step(c.b, c.g));
vec4 q = mix(vec4(p.xyw, c.r),
vec4(c.r, p.yzx),
step(p.x, c.r));
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)),
d / (q.x + e),
q.x);
}
``````

Convert from HSB to RGB (official standard):

``````vec3 hsv2rgb( in vec3 c )
{
vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 );
return c.z * mix( vec3(1.0), rgb, c.y);
}
``````

Smooth conversion from HSB to RGB (https://www.shadertoy.com/view/MsS3Wc):

``````vec3 hsv2rgb_smooth( in vec3 c )
{
vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 );
rgb = rgb*rgb*(3.0-2.0*rgb); // cubic smoothing
return c.z * mix( vec3(1.0), rgb, c.y);
}
``````