shader.glsl

// VERTEX SHADER ------------------------------------------------------------
#version 150

out int face_index;

void main () {
    face_index = gl_VertexID;
}

// GEOMETRY SHADER ------------------------------------------------------------
#version 150


#extension GL_ARB_shader_bit_encoding : enable

layout(points) in;

layout(max_vertices = 6, triangle_strip) out;

vec3 hue2rgb(float hue) {
    return clamp( 
        abs(mod(hue * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 
        0.0, 1.0);
}

vec3 normhue(float n) {
    return hue2rgb(0.66667*(1.0 - clamp(n,0.0,1.0)));
}

vec3 hsl2rgb(vec3 c) {
    vec3 rgb = hue2rgb(c.x);
    return c.z + c.y * (rgb - 0.5) * (1.0 - abs(2.0 * c.z - 1.0));
}

vec3 hsv2rgb(vec3 c) {
    vec3 rgb = hue2rgb(c.x);
    return c.z * mix(vec3(1.0), rgb, c.y);
}

vec3 hsv2rgbc(vec3 c) {
    vec3 rgb = hue2rgb(c.x);
    // rgb = smoothstep(vec3(0.0),vec3(1.0),rgb);
    rgb = rgb * rgb * (3.0 - 2.0*rgb);
    return c.z * mix(vec3(1.0), rgb, c.y);
}

// ratio: 3 = neon, 4 = refracted, 5+ = approximate white
vec3 physhue2rgb(float hue, float ratio) {
    return smoothstep(
        vec3(0.0),vec3(1.0),
        abs(mod(hue + vec3(0.0,1.0,2.0)*(1.0/ratio),1.0)*2.0-1.0));
}

in int[1] face_index;

uint uread (usamplerBuffer smp, int index) {
    return texelFetch(smp, index) . r;
}
uniform usamplerBuffer face_buffer;

out vec3 col;

ivec3 iread3 (usamplerBuffer smp, int index) {
    return ivec3(uread(smp, index), uread(smp, index + 1), uread(smp, index + 2));
}
out vec3 vxid;

layout(std140) uniform _WorldParams {
    mat3 camera_aim;
    vec3 camera_origin;
    vec3 mtx_proj;
    float time;
} WorldParams;

vec4 transform_vertex (vec3 p) {
    p . xy = (p . xy - WorldParams . camera_origin . xy) * WorldParams . mtx_proj . xy;
    p . xy;
    return vec4(p, 1);
}
void emit_tri (vec3 p0, vec3 p1, vec3 p2) {
    vxid = vec3(1, 0, 0);
    gl_Position = transform_vertex(p0);
    EmitVertex();
    vxid = vec3(0, 1, 0);
    gl_Position = transform_vertex(p1);
    EmitVertex();
    vxid = vec3(0, 0, 1);
    gl_Position = transform_vertex(p2);
    EmitVertex();
    EndPrimitive();
}
float fread (usamplerBuffer smp, int index) {
    return uintBitsToFloat(uread(smp, index));
}
vec2 fread2 (usamplerBuffer smp, int index) {
    return vec2(fread(smp, index), fread(smp, index + 1));
}
uniform usamplerBuffer vertex_buffer;

vec3 read_vertex (int index) {
    return vec3(fread2(vertex_buffer, index * 5), 0);
}
void main () {
    int face_offset;
    face_offset = face_index[0] * 7;
    if (uread(face_buffer, face_offset + 6) == uint(0)) {
        col = hsl2rgb(vec3(float(face_index[0]) * 0.166670, 0.900000, 0.900000));
        ivec3 face_verts;
        face_verts = iread3(face_buffer, face_offset);
        emit_tri(read_vertex(face_verts[0]), read_vertex(face_verts[1]), read_vertex(face_verts[2]));
    }
}

// FRAGMENT SHADER ------------------------------------------------------------
#version 150

in vec3 vxid;

float min3 (vec3 v) {
    return min(min(v . x, v . y), v . z);
}
out vec4 color;

float max3 (vec3 v) {
    return max(max(v . x, v . y), v . z);
}
void main () {
    vec3 d;
    d = 1.500000 * fwidth(vxid);
    vec3 a3;
    a3 = smoothstep(vec3(0), d, vxid);
    float ef;
    ef = min3(a3);
    vec3 corners;
    corners = smoothstep(float(20) * d, vec3(0), float(1) - vxid);
    vec3 edges;
    edges = smoothstep(float(5) * d, vec3(0), vxid);
    color = ef * vec4(mix(mix(vec3(1), edges, max3(edges)), corners, max3(corners)), 1);
}