Z-Fail shadow volume

[vertex shader]
///////////////////
/** Definitions **/
#version 420 core           // OpenGL 4.2 / GLSL 420

/////////////
/** Input **/
layout(location = 0) in vec4 vertex;    // Vertex positions at attribute 0

////////////////
/** Uniforms **/
uniform mat4 ModelMatrix;       // Model transformation matrix

//////////////
/** Output **/
out vec3 worldPos;          // World-space vertex position

//////////////////
/** Procedures **/

/* Main */
void main()
{
    // Transform vertices by their model matrix from local-space position to world-space position
    worldPos = (ModelMatrix * vertex).xyz;
}

[geometry shader]
///////////////////
/** Definitions **/
#version 420 core               // OpenGL 4.2 / GLSL 420

layout(triangles_adjacency) in;         // Input triangle with adjacencies
layout(triangle_strip, max_vertices = 18) out;  // Output triangle strips, 18 vertices at most

/////////////
/** Input **/
in vec3 worldPos[];             // World-space positions

////////////////
/** Uniforms **/
uniform mat4 ViewProjectionMatrix;      // View * Projection matrix
uniform vec3 LightPos;              // Light position (in world-space)
uniform vec3 Offset;                // Offset to single object (to avoid z-fighting), vector from light to object center can work just fine

//////////////////
/** Procedures **/

/* Emit Triangle */
// Creates triangle from specified 3 vertices (v0, v1 and v2)
void emit_triangle(in vec4 v0, in vec4 v1, in vec4 v2)
{
    gl_Position = ViewProjectionMatrix * v0;
    EmitVertex();

    gl_Position = ViewProjectionMatrix * v1;
    EmitVertex();

    gl_Position = ViewProjectionMatrix * v2;
    EmitVertex();

    EndPrimitive();
}

/* Process Edge */
// Determines whether edge(e0, e1) is part of silhouette (e.g. adjacent triangle (e1, adj, e0) isn't lit by light), if so, then extrudes this edge to infinity
void process_edge(in vec3 e0, in vec3 e1, in vec3 adj)
{
    vec3 n = cross(e1 - adj, e0 - adj);
    vec3 l = LightPos - adj;

    if(dot(n, l) < 0.0)
    {
        gl_Position = ViewProjectionMatrix * vec4(e0 + Offset, 1.0);
        EmitVertex();

        gl_Position = ViewProjectionMatrix * vec4(e0 - LightPos, 0.0);
        EmitVertex();

        gl_Position = ViewProjectionMatrix * vec4(e1 + Offset, 1.0);
        EmitVertex();

        gl_Position = ViewProjectionMatrix * vec4(e1 - LightPos, 0.0);
        EmitVertex();

        EndPrimitive();
    }
}

/* Main */
void main()
{
    // Determine whether current triangle is lit by light
    vec3 normal = cross(worldPos[2] - worldPos[0], worldPos[4] - worldPos[0]);
    vec3 lightDir = normalize(LightPos - worldPos[0]);

    if(dot(normal, lightDir) >= 0.0)
    {
        // If so, emit front cap
        emit_triangle(vec4(worldPos[0] + Offset, 1), vec4(worldPos[2] + Offset, 1), vec4(worldPos[4] + Offset, 1));
        // Emit back cap
        emit_triangle(vec4(worldPos[0] - LightPos, 0), vec4(worldPos[4] - LightPos, 0), vec4(worldPos[2] - LightPos, 0));

        // And process whether edges are part of silhouette (if so, extrude them)
        process_edge(worldPos[0], worldPos[2], worldPos[1]);
        process_edge(worldPos[2], worldPos[4], worldPos[3]);
        process_edge(worldPos[4], worldPos[0], worldPos[5]);
    }
}

[pixel shader]
///////////////////
/** Definitions **/
#version 420 core       // OpenGL 4.2 / GLSL 420

//////////////
/** Output **/
out vec4 mFragColor;        // Fragment color output

//////////////////
/** Procedures **/

/* Main */
void main()
{
    // Output just black color (basically we dont write to color buffer so we don't care about color)
    mFragColor = vec4(0.0, 0.0, 0.0, 0.0);
}