Move towards geometry instancing for shadows

shader/positional/blank.frag

@@ -0,0 +1,6 @@
+#version 450 core
+out vec4 fColor;
+void main()
+{
+  fColor = vec4 (0,0,0,0);
+}

shader/positional/blank.vert

@@ -0,0 +1,6 @@
+#version 450 core
+layout (location = 0) in vec3 pos;
+layout (std140, binding = 0) uniform TheMat { mat4 theMat; } ;
+void main() {
+  gl_Position = theMat * vec4(pos,1);
+}

shader/shadow/cap.geom

@@ -0,0 +1,42 @@
+#version 450 core
+layout (triangles) in;
+layout (triangle_strip, max_vertices = 3) out;
+layout (std140, binding = 0) uniform TheMat { mat4 theMat; } ;
+//layout (std140, binding = 1) uniform LightsBlock
+//{
+//    vec4 posBool[20];
+//    vec4 colRad[20];
+//} ;
+uniform vec3 lightPos;
+uniform int lightID;
+// this code is duplicated in lineShadow.geom, should not be changed on its own
+vec4 projNear (vec4 pos)
+{
+    // note we project to a specific height
+    // this is quite brittle, not ideal
+    vec3 dir = pos.xyz - lightPos ;
+    float a = (140 - pos.z) / dir.z ;
+    vec2 xy = (pos.xyz + a * dir).xy ;
+    return vec4 ( xy, 140 , 1) ;
+}
+void main()
+{
+    vec4 p0 = gl_in[0].gl_Position ;
+    vec4 p1 = gl_in[1].gl_Position ;
+    vec4 p2 = gl_in[2].gl_Position ;
+    if ( //if Light Source is below all vertices, draw cap 
+        // TODO think about when LS is beside the object
+            ( p0.z - lightPos.z > 0 )
+            && ( p1.z - lightPos.z > 0 )
+            && ( p2.z - lightPos.z > 0 )
+            )
+    {
+        // the front cap
+        vec4 v1 = vec4 (0,0,1,0) ;
+        gl_Position = theMat * projNear(p0); EmitVertex();
+        gl_Position = theMat * projNear(p1); EmitVertex();
+        gl_Position = theMat * projNear(p2); EmitVertex();
+        EndPrimitive();
+    }
+    else {}
+}

shader/shadow/cap.vert

@@ -0,0 +1,11 @@
+#version 450 core
+layout (location = 0) in vec3 position;
+layout (std140, binding = 0) uniform TheMat { mat4 theMat; } ;
+uniform vec3 lightPos;
+uniform vec4 lumRad;
+out vec3 dField;
+out vec3 lum;
+void main()
+{
+    gl_Position = vec4(position,1);
+}

shader/shadow/edge.geom

@@ -0,0 +1,81 @@
+#version 450 core
+layout (lines_adjacency) in;
+layout (triangle_strip, max_vertices = 4) out;
+layout (std140, binding = 0) uniform TheMat { mat4 theMat; } ;
+layout (std140, binding = 1) uniform LightsBlock
+{
+    vec4 posBool[20];
+    vec4 colRad[20];
+} ;
+//uniform vec3 lightPos;
+//uniform float radiusUniform;
+uniform int lightID;
+vec3 lightPos1 = posBool[lightID].xyz;
+//vec3 lightPos1 = lightPos;
+float theBool = posBool[lightID].w;
+vec4 shift (vec4 p) { return (vec4 (p.xyz + (100000*(p.xyz-lightPos1)), 1));} ;
+vec4 shiftBy (float x,vec4 p) { return (vec4 (lightPos1 + (x*normalize(p.xyz-lightPos1)), 1));} ;
+// copied from lighting/cap.geom, should not be changed on its own
+vec4 projNear (vec4 pos)
+{
+    // note we project to a specific height
+    // this is quite brittle, not ideal
+    vec3 dir = pos.xyz - lightPos1 ;
+    float a = (140 - pos.z) / dir.z ;
+    vec2 xy = (pos.xyz + a * dir).xy ;
+    return vec4 ( xy, 140 , 1) ;
+} ;
+vec4 shiftNear (vec4 pos)
+{ vec4 sp = shift(pos);
+    if (sp.z > 140)
+    { return projNear(pos) ; }
+    else
+    { return sp ; }
+} ;
+vec4 f (vec4 p) {return (theMat * p);} ;
+void main()
+{
+    if (theBool == 1){
+//    float ru2 = radiusUniform * radiusUniform ;
+    float ru = colRad[lightID].w ;
+    float ru2 = ru * ru;
+    vec4 p0 = gl_in[0].gl_Position;
+    vec4 p1 = gl_in[1].gl_Position;
+    vec4 mid = 0.5*(p0 + p1);
+    vec3 n0a = gl_in[2].gl_Position.xyz;
+    vec3 n1a = gl_in[3].gl_Position.xyz;
+    vec3 n0 = cross(p1.xyz - p0.xyz, n0a - p0.xyz) ;
+    vec3 n1 = cross(p0.xyz - p1.xyz, n1a - p1.xyz) ;
+    
+    //vec3 n2 = n0 + n1; // assumes the summands are normalized
+    vec3 lightDir = p0.xyz - lightPos1.xyz;
+    vec3 lightDir2 = p1.xyz - lightPos1.xyz;
+    // first test if the edge is part of the silhouette
+    // that is, if the normals of the faces connected by the edge point are in
+    // "different directions" wrt the light direction
+    if ( dot(n0 , lightDir) * dot(n1 , lightDir) <= 0 && 
+                (dot(lightDir,lightDir) < ru2 || dot(lightDir2,lightDir2) < ru2) )
+                // using <= rather than < seems to get rid of overlapping shadow
+                // artefacts
+    {
+        vec4 p2 = shiftNear(p0);
+        vec4 p3 = shiftNear(p1);
+        if ( dot(n0 , lightDir) > 0)
+        {
+            gl_Position = f(p0); EmitVertex();
+            gl_Position = f(p1); EmitVertex();
+            gl_Position = f(p2); EmitVertex();
+            gl_Position = f(p3); EmitVertex();
+        }
+        else
+        {
+            gl_Position = f(p1); EmitVertex();
+            gl_Position = f(p0); EmitVertex();
+            gl_Position = f(p3); EmitVertex();
+            gl_Position = f(p2); EmitVertex();
+        }
+        EndPrimitive();
+    }
+    else { }
+    }else {}
+}

shader/shadow/edge.vert

@@ -0,0 +1,6 @@
+#version 450 core
+layout (location = 0) in vec3 pos;
+void main()
+{
+    gl_Position = vec4(pos,1);
+}

shader/shadow/light.frag

@@ -0,0 +1,20 @@
+#version 450 core
+layout (std140, binding = 1) uniform LightsBlock
+{
+    vec4 posBool[20];
+    vec4 colRad[20];
+} ;
+uniform vec3 lightPos;
+uniform vec4 lumRad;
+uniform sampler2D screenTexture;
+in vec2 vTexPos;
+out vec4 fColor;
+void main()
+{
+    vec3 distVec = texture(screenTexture,vTexPos).xyz - lightPos;
+    float dist = dot(distVec,distVec);
+    if (dist > lumRad.a) {discard;}
+    float x = 1 - dist / lumRad.a ;
+    vec3 c = (x * x * x) * lumRad.rgb ;
+    fColor = vec4(c,0);
+}

shader/shadow/light.vert

@@ -0,0 +1,9 @@
+#version 450 core
+layout (location = 0) in vec2 pos;
+layout (location = 1) in vec2 texPos;
+out vec2 vTexPos;
+void main()
+{
+  gl_Position = vec4(pos,0,1);
+  vTexPos = texPos;
+}

shader/shadow/wallShadow.geom

@@ -0,0 +1,74 @@
+#version 450 core
+layout (points) in;
+layout (triangle_strip, max_vertices = 8) out;
+layout (std140, binding = 0) uniform TheMat { mat4 theMat; } ;
+layout (std140, binding = 1) uniform LightsBlock
+{
+    vec4 posBool[20];
+    vec4 colRad[20];
+} ;
+uniform vec3 lightPos;
+uniform int lightID;
+vec4 shift (vec4 p)
+{ return vec4 (p.xy + (200 * (p.xy-lightPos.xy)), 0 , 1);
+}
+float isLHS (vec2 startV, vec2 testV)
+{
+    return sign( -startV.x * testV.y + startV.y * testV.x);
+}
+// construct a box with openings on bottom face and face away from wall
+void main()
+{
+vec4 p1 = vec4 (gl_in[0].gl_Position.xy,0,1);
+vec4 p2 = vec4 (gl_in[0].gl_Position.zw,0,1);
+if (isLHS (p1.xy - lightPos.xy, p2.xy - lightPos.xy) < 0)
+{
+vec4 p3 = vec4 (p1.xy,100,1);
+vec4 p4 = vec4 (p2.xy,100,1);
+vec4 p5 = shift(p1);
+vec4 p6 = shift(p2);
+vec4 p7 = vec4 (p6.xy,100,1);
+vec4 p8 = vec4 (p5.xy,100,1);
+
+vec4 a1 = theMat * p1;
+vec4 a2 = theMat * p2;
+vec4 a3 = theMat * p3;
+vec4 a4 = theMat * p4;
+vec4 a5 = theMat * p5;
+vec4 a6 = theMat * p6;
+vec4 a7 = theMat * p7;
+vec4 a8 = theMat * p8;
+
+  //gl_Position = a4; EmitVertex();
+  //gl_Position = a3; EmitVertex();
+  //gl_Position = a7; EmitVertex();
+  //gl_Position = a8; EmitVertex();
+  //gl_Position = a5; EmitVertex();
+  //gl_Position = a3; EmitVertex();
+  //gl_Position = a1; EmitVertex();
+  //gl_Position = a4; EmitVertex();
+  //gl_Position = a2; EmitVertex();
+  //gl_Position = a7; EmitVertex();
+  //gl_Position = a6; EmitVertex();
+
+  gl_Position = a1; EmitVertex();
+  gl_Position = a5; EmitVertex();
+  gl_Position = a3; EmitVertex();
+  gl_Position = a8; EmitVertex();
+  gl_Position = a4; EmitVertex();
+  gl_Position = a7; EmitVertex();
+  gl_Position = a2; EmitVertex();
+  gl_Position = a6; EmitVertex();
+
+  //gl_Position = a5; EmitVertex();
+  //gl_Position = a1; EmitVertex();
+  //gl_Position = a8; EmitVertex();
+  //gl_Position = a3; EmitVertex();
+  //gl_Position = a7; EmitVertex();
+  //gl_Position = a4; EmitVertex();
+  //gl_Position = a6; EmitVertex();
+  //gl_Position = a2; EmitVertex();
+
+  EndPrimitive();
+} else {}
+}

shader/shadow/wallShadow.vert

@@ -0,0 +1,6 @@
+#version 450 core
+layout (location = 0) in vec4 poss;
+void main()
+{
+  gl_Position = poss;
+}