Upload 10 files

lib/renderer/gl/data/color.fs

@@ -0,0 +1,20 @@
+#version 330 core
+
+layout (location = 0) out vec4 FragColor;
+layout (location = 1) out vec4 FragNormal;
+layout (location = 2) out vec4 FragDepth;
+
+in vec3 Color;
+in vec3 CamNormal;
+in vec3 depth;
+
+
+void main() 
+{
+    FragColor = vec4(Color,1.0);
+
+    vec3 cam_norm_normalized = normalize(CamNormal);
+    vec3 rgb = (cam_norm_normalized + 1.0) / 2.0;
+	FragNormal = vec4(rgb, 1.0);
+    FragDepth = vec4(depth.xyz, 1.0);
+}

lib/renderer/gl/data/color.vs

@@ -0,0 +1,29 @@
+#version 330 core
+
+layout (location = 0) in vec3 a_Position;
+layout (location = 1) in vec3 a_Color;
+layout (location = 2) in vec3 a_Normal;
+
+out vec3 CamNormal;
+out vec3 CamPos;
+out vec3 Color;
+out vec3 depth;
+
+
+uniform mat3 RotMat;
+uniform mat4 NormMat;
+uniform mat4 ModelMat;
+uniform mat4 PerspMat;
+
+void main()
+{
+    vec3 a_Position = (NormMat * vec4(a_Position,1.0)).xyz;
+    gl_Position = PerspMat * ModelMat * vec4(RotMat * a_Position, 1.0);
+    Color = a_Color;
+
+    mat3 R = mat3(ModelMat) * RotMat;
+    CamNormal = (R * a_Normal);
+
+    depth = vec3(gl_Position.z / gl_Position.w);
+   
+}

lib/renderer/gl/data/normal.fs

@@ -0,0 +1,12 @@
+#version 330
+
+out vec4 FragColor;
+
+in vec3 CamNormal;
+
+void main()
+{
+    vec3 cam_norm_normalized = normalize(CamNormal);
+    vec3 rgb = (cam_norm_normalized + 1.0) / 2.0;
+	FragColor = vec4(rgb, 1.0);
+}

lib/renderer/gl/data/normal.vs

@@ -0,0 +1,15 @@
+#version 330
+
+layout (location = 0) in vec3 Position;
+layout (location = 1) in vec3 Normal;
+
+out vec3 CamNormal;
+
+uniform mat4 ModelMat;
+uniform mat4 PerspMat;
+
+void main()
+{
+	gl_Position = PerspMat * ModelMat * vec4(Position, 1.0);
+	CamNormal = (ModelMat * vec4(Normal, 0.0)).xyz;
+}

lib/renderer/gl/data/prt.fs

@@ -0,0 +1,157 @@
+#version 330
+
+uniform vec3 SHCoeffs[9];
+uniform uint analytic;
+
+uniform uint hasNormalMap;
+uniform uint hasAlbedoMap;
+
+uniform sampler2D AlbedoMap;
+uniform sampler2D NormalMap;
+
+in VertexData {
+    vec3 Position;
+    vec3 Depth;
+    vec3 ModelNormal;
+    vec2 Texcoord;
+    vec3 Tangent;
+    vec3 Bitangent;
+    vec3 PRT1;
+    vec3 PRT2;
+    vec3 PRT3;
+    vec3 Label;
+} VertexIn;
+
+layout (location = 0) out vec4 FragColor;
+layout (location = 1) out vec4 FragNormal;
+layout (location = 2) out vec4 FragPosition;
+layout (location = 3) out vec4 FragAlbedo;
+layout (location = 4) out vec4 FragShading;
+layout (location = 5) out vec4 FragPRT1;
+layout (location = 6) out vec4 FragPRT2;
+// layout (location = 7) out vec4 FragPRT3;
+layout (location = 7) out vec4 FragLabel;
+
+
+vec4 gammaCorrection(vec4 vec, float g)
+{
+    return vec4(pow(vec.x, 1.0/g), pow(vec.y, 1.0/g), pow(vec.z, 1.0/g), vec.w);
+}
+
+vec3 gammaCorrection(vec3 vec, float g)
+{
+    return vec3(pow(vec.x, 1.0/g), pow(vec.y, 1.0/g), pow(vec.z, 1.0/g));
+}
+
+void evaluateH(vec3 n, out float H[9])
+{
+    float c1 = 0.429043, c2 = 0.511664,
+        c3 = 0.743125, c4 = 0.886227, c5 = 0.247708;
+
+    H[0] = c4;
+    H[1] = 2.0 * c2 * n[1];
+    H[2] = 2.0 * c2 * n[2];
+    H[3] = 2.0 * c2 * n[0];
+    H[4] = 2.0 * c1 * n[0] * n[1];
+    H[5] = 2.0 * c1 * n[1] * n[2];
+    H[6] = c3 * n[2] * n[2] - c5;
+    H[7] = 2.0 * c1 * n[2] * n[0];
+    H[8] = c1 * (n[0] * n[0] - n[1] * n[1]);
+}
+
+vec3 evaluateLightingModel(vec3 normal)
+{
+    float H[9];
+    evaluateH(normal, H);
+    vec3 res = vec3(0.0);
+    for (int i = 0; i < 9; i++) {
+        res += H[i] * SHCoeffs[i];
+    }
+    return res;
+}
+
+// nC: coarse geometry normal, nH: fine normal from normal map
+vec3 evaluateLightingModelHybrid(vec3 nC, vec3 nH, mat3 prt)
+{
+    float HC[9], HH[9];
+    evaluateH(nC, HC);
+    evaluateH(nH, HH);
+    
+    vec3 res = vec3(0.0);
+    vec3 shadow = vec3(0.0);
+    vec3 unshadow = vec3(0.0);
+    for(int i = 0; i < 3; ++i){
+        for(int j = 0; j < 3; ++j){
+            int id = i*3+j;
+            res += HH[id]* SHCoeffs[id];
+            shadow += prt[i][j] * SHCoeffs[id];
+            unshadow += HC[id] * SHCoeffs[id];
+        }
+    }
+    vec3 ratio = clamp(shadow/unshadow,0.0,1.0);
+    res = ratio * res;
+
+    return res;
+}
+
+vec3 evaluateLightingModelPRT(mat3 prt)
+{
+    vec3 res = vec3(0.0);
+    for(int i = 0; i < 3; ++i){
+        for(int j = 0; j < 3; ++j){
+            res += prt[i][j] * SHCoeffs[i*3+j];
+        }
+    }
+
+    return res;
+}
+
+void main()
+{
+    vec2 uv = VertexIn.Texcoord;
+    vec3 nC = normalize(VertexIn.ModelNormal);
+    vec3 nml = nC;
+    mat3 prt = mat3(VertexIn.PRT1, VertexIn.PRT2, VertexIn.PRT3);
+
+    if(hasAlbedoMap == uint(0))
+        FragAlbedo = vec4(1.0);
+    else
+        FragAlbedo = texture(AlbedoMap, uv);//gammaCorrection(texture(AlbedoMap, uv), 1.0/2.2);
+
+    if(hasNormalMap == uint(0))
+    {
+        if(analytic == uint(0))
+            FragShading = vec4(evaluateLightingModelPRT(prt), 1.0f);
+        else
+            FragShading = vec4(evaluateLightingModel(nC), 1.0f);
+    }
+    else
+    {
+        vec3 n_tan = normalize(texture(NormalMap, uv).rgb*2.0-vec3(1.0));
+
+        mat3 TBN = mat3(normalize(VertexIn.Tangent),normalize(VertexIn.Bitangent),nC);
+        vec3 nH = normalize(TBN * n_tan);
+
+        if(analytic == uint(0))
+            FragShading = vec4(evaluateLightingModelHybrid(nC,nH,prt),1.0f);
+        else
+            FragShading = vec4(evaluateLightingModel(nH), 1.0f);
+    
+        nml = nH;
+    }
+
+    FragShading = gammaCorrection(FragShading, 2.2);
+    FragColor = clamp(FragAlbedo * FragShading, 0.0, 1.0);
+    FragNormal = vec4(0.5*(nml+vec3(1.0)), 1.0);
+    FragPosition = vec4(VertexIn.Depth.xyz, 1.0);
+    FragShading = vec4(clamp(0.5*FragShading.xyz, 0.0, 1.0),1.0);
+    // FragColor = gammaCorrection(clamp(FragAlbedo * FragShading, 0.0, 1.0),2.2);
+    // FragNormal = vec4(0.5*(nml+vec3(1.0)), 1.0);
+    // FragPosition = vec4(VertexIn.Position,VertexIn.Depth.x);
+    // FragShading = vec4(gammaCorrection(clamp(0.5*FragShading.xyz, 0.0, 1.0),2.2),1.0);
+    // FragAlbedo = gammaCorrection(FragAlbedo,2.2);
+    FragPRT1 = vec4(VertexIn.PRT1,1.0);
+    FragPRT2 = vec4(VertexIn.PRT2,1.0);
+    // FragPRT3 = vec4(VertexIn.PRT3,1.0);
+    FragLabel = vec4(VertexIn.Label,1.0);
+}

lib/renderer/gl/data/prt.vs

@@ -0,0 +1,171 @@
+#version 330
+
+layout (location = 0) in vec3 a_Position;
+layout (location = 1) in vec3 a_Normal;
+layout (location = 2) in vec2 a_TextureCoord;
+layout (location = 3) in vec3 a_Tangent;
+layout (location = 4) in vec3 a_Bitangent;
+layout (location = 5) in vec3 a_PRT1;
+layout (location = 6) in vec3 a_PRT2;
+layout (location = 7) in vec3 a_PRT3;
+layout (location = 8) in vec3 a_Label;
+
+out VertexData {
+    vec3 Position;
+    vec3 Depth;
+    vec3 ModelNormal;
+    vec2 Texcoord;
+    vec3 Tangent;
+    vec3 Bitangent;
+    vec3 PRT1;
+    vec3 PRT2;
+    vec3 PRT3;
+    vec3 Label;
+} VertexOut;
+
+uniform mat3 RotMat;
+uniform mat4 NormMat;
+uniform mat4 ModelMat;
+uniform mat4 PerspMat;
+
+float s_c3 = 0.94617469575; // (3*sqrt(5))/(4*sqrt(pi))
+float s_c4 = -0.31539156525;// (-sqrt(5))/(4*sqrt(pi))
+float s_c5 = 0.54627421529; // (sqrt(15))/(4*sqrt(pi))
+
+float s_c_scale = 1.0/0.91529123286551084;
+float s_c_scale_inv = 0.91529123286551084;
+
+float s_rc2 = 1.5853309190550713*s_c_scale;
+float s_c4_div_c3 = s_c4/s_c3;
+float s_c4_div_c3_x2 = (s_c4/s_c3)*2.0;
+
+float s_scale_dst2 = s_c3 * s_c_scale_inv;
+float s_scale_dst4 = s_c5 * s_c_scale_inv;
+
+void OptRotateBand0(float x[1], mat3 R, out float dst[1])
+{
+    dst[0] = x[0];
+}
+
+// 9 multiplies
+void OptRotateBand1(float x[3], mat3 R, out float dst[3])
+{
+    // derived from  SlowRotateBand1
+    dst[0] = ( R[1][1])*x[0] + (-R[1][2])*x[1] + ( R[1][0])*x[2];
+    dst[1] = (-R[2][1])*x[0] + ( R[2][2])*x[1] + (-R[2][0])*x[2];
+    dst[2] = ( R[0][1])*x[0] + (-R[0][2])*x[1] + ( R[0][0])*x[2];
+}
+
+// 48 multiplies
+void OptRotateBand2(float x[5], mat3 R, out float dst[5])
+{
+    // Sparse matrix multiply
+    float sh0 =  x[3] + x[4] + x[4] - x[1];
+    float sh1 =  x[0] + s_rc2*x[2] +  x[3] + x[4];
+    float sh2 =  x[0];
+    float sh3 = -x[3];
+    float sh4 = -x[1];
+    
+    // Rotations.  R0 and R1 just use the raw matrix columns
+    float r2x = R[0][0] + R[0][1];
+    float r2y = R[1][0] + R[1][1];
+    float r2z = R[2][0] + R[2][1];
+    
+    float r3x = R[0][0] + R[0][2];
+    float r3y = R[1][0] + R[1][2];
+    float r3z = R[2][0] + R[2][2];
+    
+    float r4x = R[0][1] + R[0][2];
+    float r4y = R[1][1] + R[1][2];
+    float r4z = R[2][1] + R[2][2];
+    
+    // dense matrix multiplication one column at a time
+    
+    // column 0
+    float sh0_x = sh0 * R[0][0];
+    float sh0_y = sh0 * R[1][0];
+    float d0 = sh0_x * R[1][0];
+    float d1 = sh0_y * R[2][0];
+    float d2 = sh0 * (R[2][0] * R[2][0] + s_c4_div_c3);
+    float d3 = sh0_x * R[2][0];
+    float d4 = sh0_x * R[0][0] - sh0_y * R[1][0];
+    
+    // column 1
+    float sh1_x = sh1 * R[0][2];
+    float sh1_y = sh1 * R[1][2];
+    d0 += sh1_x * R[1][2];
+    d1 += sh1_y * R[2][2];
+    d2 += sh1 * (R[2][2] * R[2][2] + s_c4_div_c3);
+    d3 += sh1_x * R[2][2];
+    d4 += sh1_x * R[0][2] - sh1_y * R[1][2];
+    
+    // column 2
+    float sh2_x = sh2 * r2x;
+    float sh2_y = sh2 * r2y;
+    d0 += sh2_x * r2y;
+    d1 += sh2_y * r2z;
+    d2 += sh2 * (r2z * r2z + s_c4_div_c3_x2);
+    d3 += sh2_x * r2z;
+    d4 += sh2_x * r2x - sh2_y * r2y;
+    
+    // column 3
+    float sh3_x = sh3 * r3x;
+    float sh3_y = sh3 * r3y;
+    d0 += sh3_x * r3y;
+    d1 += sh3_y * r3z;
+    d2 += sh3 * (r3z * r3z + s_c4_div_c3_x2);
+    d3 += sh3_x * r3z;
+    d4 += sh3_x * r3x - sh3_y * r3y;
+    
+    // column 4
+    float sh4_x = sh4 * r4x;
+    float sh4_y = sh4 * r4y;
+    d0 += sh4_x * r4y;
+    d1 += sh4_y * r4z;
+    d2 += sh4 * (r4z * r4z + s_c4_div_c3_x2);
+    d3 += sh4_x * r4z;
+    d4 += sh4_x * r4x - sh4_y * r4y;
+    
+    // extra multipliers
+    dst[0] = d0;
+    dst[1] = -d1;
+    dst[2] = d2 * s_scale_dst2;
+    dst[3] = -d3;
+    dst[4] = d4 * s_scale_dst4;
+}
+
+void main()
+{
+    // normalization
+    vec3 pos = (NormMat * vec4(a_Position,1.0)).xyz;
+
+    mat3 R = mat3(ModelMat) * RotMat;
+    VertexOut.ModelNormal = (R * a_Normal);
+    VertexOut.Position = R * pos;
+    VertexOut.Texcoord = a_TextureCoord;
+    VertexOut.Tangent = (R * a_Tangent);
+    VertexOut.Bitangent = (R * a_Bitangent);
+    VertexOut.Label = a_Label;
+
+    float PRT0, PRT1[3], PRT2[5];
+    PRT0 = a_PRT1[0];
+    PRT1[0] = a_PRT1[1];
+    PRT1[1] = a_PRT1[2];
+    PRT1[2] = a_PRT2[0];
+    PRT2[0] = a_PRT2[1];
+    PRT2[1] = a_PRT2[2];
+    PRT2[2] = a_PRT3[0];
+    PRT2[3] = a_PRT3[1];
+    PRT2[4] = a_PRT3[2];
+
+    OptRotateBand1(PRT1, R, PRT1);
+    OptRotateBand2(PRT2, R, PRT2);
+
+    VertexOut.PRT1 = vec3(PRT0,PRT1[0],PRT1[1]);
+    VertexOut.PRT2 = vec3(PRT1[2],PRT2[0],PRT2[1]);
+    VertexOut.PRT3 = vec3(PRT2[2],PRT2[3],PRT2[4]);
+
+    gl_Position = PerspMat * ModelMat * vec4(RotMat * pos, 1.0);
+    
+    VertexOut.Depth = vec3(gl_Position.z / gl_Position.w);
+}

lib/renderer/gl/data/prt_uv.fs

@@ -0,0 +1,141 @@
+#version 330
+
+uniform vec3 SHCoeffs[9];
+uniform uint analytic;
+
+uniform uint hasNormalMap;
+uniform uint hasAlbedoMap;
+
+uniform sampler2D AlbedoMap;
+uniform sampler2D NormalMap;
+
+in VertexData {
+    vec3 Position;
+    vec3 ModelNormal;
+    vec3 CameraNormal;
+    vec2 Texcoord;
+    vec3 Tangent;
+    vec3 Bitangent;
+    vec3 PRT1;
+    vec3 PRT2;
+    vec3 PRT3;
+} VertexIn;
+
+layout (location = 0) out vec4 FragColor;
+layout (location = 1) out vec4 FragPosition;
+layout (location = 2) out vec4 FragNormal;
+
+vec4 gammaCorrection(vec4 vec, float g)
+{
+    return vec4(pow(vec.x, 1.0/g), pow(vec.y, 1.0/g), pow(vec.z, 1.0/g), vec.w);
+}
+
+vec3 gammaCorrection(vec3 vec, float g)
+{
+    return vec3(pow(vec.x, 1.0/g), pow(vec.y, 1.0/g), pow(vec.z, 1.0/g));
+}
+
+void evaluateH(vec3 n, out float H[9])
+{
+    float c1 = 0.429043, c2 = 0.511664,
+        c3 = 0.743125, c4 = 0.886227, c5 = 0.247708;
+
+    H[0] = c4;
+    H[1] = 2.0 * c2 * n[1];
+    H[2] = 2.0 * c2 * n[2];
+    H[3] = 2.0 * c2 * n[0];
+    H[4] = 2.0 * c1 * n[0] * n[1];
+    H[5] = 2.0 * c1 * n[1] * n[2];
+    H[6] = c3 * n[2] * n[2] - c5;
+    H[7] = 2.0 * c1 * n[2] * n[0];
+    H[8] = c1 * (n[0] * n[0] - n[1] * n[1]);
+}
+
+vec3 evaluateLightingModel(vec3 normal)
+{
+    float H[9];
+    evaluateH(normal, H);
+    vec3 res = vec3(0.0);
+    for (int i = 0; i < 9; i++) {
+        res += H[i] * SHCoeffs[i];
+    }
+    return res;
+}
+
+// nC: coarse geometry normal, nH: fine normal from normal map
+vec3 evaluateLightingModelHybrid(vec3 nC, vec3 nH, mat3 prt)
+{
+    float HC[9], HH[9];
+    evaluateH(nC, HC);
+    evaluateH(nH, HH);
+    
+    vec3 res = vec3(0.0);
+    vec3 shadow = vec3(0.0);
+    vec3 unshadow = vec3(0.0);
+    for(int i = 0; i < 3; ++i){
+        for(int j = 0; j < 3; ++j){
+            int id = i*3+j;
+            res += HH[id]* SHCoeffs[id];
+            shadow += prt[i][j] * SHCoeffs[id];
+            unshadow += HC[id] * SHCoeffs[id];
+        }
+    }
+    vec3 ratio = clamp(shadow/unshadow,0.0,1.0);
+    res = ratio * res;
+
+    return res;
+}
+
+vec3 evaluateLightingModelPRT(mat3 prt)
+{
+    vec3 res = vec3(0.0);
+    for(int i = 0; i < 3; ++i){
+        for(int j = 0; j < 3; ++j){
+            res += prt[i][j] * SHCoeffs[i*3+j];
+        }
+    }
+
+    return res;
+}
+
+void main()
+{
+    vec2 uv = VertexIn.Texcoord;
+    vec3 nM = normalize(VertexIn.ModelNormal);
+    vec3 nC = normalize(VertexIn.CameraNormal);
+    vec3 nml = nC;
+    mat3 prt = mat3(VertexIn.PRT1, VertexIn.PRT2, VertexIn.PRT3);
+
+    vec4 albedo, shading;
+    if(hasAlbedoMap == uint(0))
+        albedo = vec4(1.0);
+    else
+        albedo = texture(AlbedoMap, uv);//gammaCorrection(texture(AlbedoMap, uv), 1.0/2.2);
+
+    if(hasNormalMap == uint(0))
+    {
+        if(analytic == uint(0))
+            shading = vec4(evaluateLightingModelPRT(prt), 1.0f);
+        else
+            shading = vec4(evaluateLightingModel(nC), 1.0f);
+    }
+    else
+    {
+        vec3 n_tan = normalize(texture(NormalMap, uv).rgb*2.0-vec3(1.0));
+
+        mat3 TBN = mat3(normalize(VertexIn.Tangent),normalize(VertexIn.Bitangent),nC);
+        vec3 nH = normalize(TBN * n_tan);
+
+        if(analytic == uint(0))
+            shading = vec4(evaluateLightingModelHybrid(nC,nH,prt),1.0f);
+        else
+            shading = vec4(evaluateLightingModel(nH), 1.0f);
+    
+        nml = nH;
+    }
+
+    shading = gammaCorrection(shading, 2.2);
+    FragColor = clamp(albedo * shading, 0.0, 1.0);
+    FragPosition = vec4(VertexIn.Position,1.0);
+    FragNormal = vec4(0.5*(nM+vec3(1.0)),1.0);
+}

lib/renderer/gl/data/prt_uv.vs

@@ -0,0 +1,168 @@
+#version 330
+
+layout (location = 0) in vec3 a_Position;
+layout (location = 1) in vec3 a_Normal;
+layout (location = 2) in vec2 a_TextureCoord;
+layout (location = 3) in vec3 a_Tangent;
+layout (location = 4) in vec3 a_Bitangent;
+layout (location = 5) in vec3 a_PRT1;
+layout (location = 6) in vec3 a_PRT2;
+layout (location = 7) in vec3 a_PRT3;
+
+out VertexData {
+    vec3 Position;
+    vec3 ModelNormal;
+    vec3 CameraNormal;
+    vec2 Texcoord;
+    vec3 Tangent;
+    vec3 Bitangent;
+    vec3 PRT1;
+    vec3 PRT2;
+    vec3 PRT3;
+} VertexOut;
+
+uniform mat3 RotMat;
+uniform mat4 NormMat;
+uniform mat4 ModelMat;
+uniform mat4 PerspMat;
+
+#define pi 3.1415926535897932384626433832795
+
+float s_c3 = 0.94617469575; // (3*sqrt(5))/(4*sqrt(pi))
+float s_c4 = -0.31539156525;// (-sqrt(5))/(4*sqrt(pi))
+float s_c5 = 0.54627421529; // (sqrt(15))/(4*sqrt(pi))
+
+float s_c_scale = 1.0/0.91529123286551084;
+float s_c_scale_inv = 0.91529123286551084;
+
+float s_rc2 = 1.5853309190550713*s_c_scale;
+float s_c4_div_c3 = s_c4/s_c3;
+float s_c4_div_c3_x2 = (s_c4/s_c3)*2.0;
+
+float s_scale_dst2 = s_c3 * s_c_scale_inv;
+float s_scale_dst4 = s_c5 * s_c_scale_inv;
+
+void OptRotateBand0(float x[1], mat3 R, out float dst[1])
+{
+    dst[0] = x[0];
+}
+
+// 9 multiplies
+void OptRotateBand1(float x[3], mat3 R, out float dst[3])
+{
+    // derived from  SlowRotateBand1
+    dst[0] = ( R[1][1])*x[0] + (-R[1][2])*x[1] + ( R[1][0])*x[2];
+    dst[1] = (-R[2][1])*x[0] + ( R[2][2])*x[1] + (-R[2][0])*x[2];
+    dst[2] = ( R[0][1])*x[0] + (-R[0][2])*x[1] + ( R[0][0])*x[2];
+}
+
+// 48 multiplies
+void OptRotateBand2(float x[5], mat3 R, out float dst[5])
+{
+    // Sparse matrix multiply
+    float sh0 =  x[3] + x[4] + x[4] - x[1];
+    float sh1 =  x[0] + s_rc2*x[2] +  x[3] + x[4];
+    float sh2 =  x[0];
+    float sh3 = -x[3];
+    float sh4 = -x[1];
+    
+    // Rotations.  R0 and R1 just use the raw matrix columns
+    float r2x = R[0][0] + R[0][1];
+    float r2y = R[1][0] + R[1][1];
+    float r2z = R[2][0] + R[2][1];
+    
+    float r3x = R[0][0] + R[0][2];
+    float r3y = R[1][0] + R[1][2];
+    float r3z = R[2][0] + R[2][2];
+    
+    float r4x = R[0][1] + R[0][2];
+    float r4y = R[1][1] + R[1][2];
+    float r4z = R[2][1] + R[2][2];
+    
+    // dense matrix multiplication one column at a time
+    
+    // column 0
+    float sh0_x = sh0 * R[0][0];
+    float sh0_y = sh0 * R[1][0];
+    float d0 = sh0_x * R[1][0];
+    float d1 = sh0_y * R[2][0];
+    float d2 = sh0 * (R[2][0] * R[2][0] + s_c4_div_c3);
+    float d3 = sh0_x * R[2][0];
+    float d4 = sh0_x * R[0][0] - sh0_y * R[1][0];
+    
+    // column 1
+    float sh1_x = sh1 * R[0][2];
+    float sh1_y = sh1 * R[1][2];
+    d0 += sh1_x * R[1][2];
+    d1 += sh1_y * R[2][2];
+    d2 += sh1 * (R[2][2] * R[2][2] + s_c4_div_c3);
+    d3 += sh1_x * R[2][2];
+    d4 += sh1_x * R[0][2] - sh1_y * R[1][2];
+    
+    // column 2
+    float sh2_x = sh2 * r2x;
+    float sh2_y = sh2 * r2y;
+    d0 += sh2_x * r2y;
+    d1 += sh2_y * r2z;
+    d2 += sh2 * (r2z * r2z + s_c4_div_c3_x2);
+    d3 += sh2_x * r2z;
+    d4 += sh2_x * r2x - sh2_y * r2y;
+    
+    // column 3
+    float sh3_x = sh3 * r3x;
+    float sh3_y = sh3 * r3y;
+    d0 += sh3_x * r3y;
+    d1 += sh3_y * r3z;
+    d2 += sh3 * (r3z * r3z + s_c4_div_c3_x2);
+    d3 += sh3_x * r3z;
+    d4 += sh3_x * r3x - sh3_y * r3y;
+    
+    // column 4
+    float sh4_x = sh4 * r4x;
+    float sh4_y = sh4 * r4y;
+    d0 += sh4_x * r4y;
+    d1 += sh4_y * r4z;
+    d2 += sh4 * (r4z * r4z + s_c4_div_c3_x2);
+    d3 += sh4_x * r4z;
+    d4 += sh4_x * r4x - sh4_y * r4y;
+    
+    // extra multipliers
+    dst[0] = d0;
+    dst[1] = -d1;
+    dst[2] = d2 * s_scale_dst2;
+    dst[3] = -d3;
+    dst[4] = d4 * s_scale_dst4;
+}
+
+void main()
+{ 
+    // normalization
+    mat3 R = mat3(ModelMat) * RotMat;
+    VertexOut.ModelNormal = a_Normal;
+    VertexOut.CameraNormal = (R * a_Normal);
+    VertexOut.Position = a_Position;
+    VertexOut.Texcoord = a_TextureCoord;
+    VertexOut.Tangent = (R * a_Tangent);
+    VertexOut.Bitangent = (R * a_Bitangent);
+    float PRT0, PRT1[3], PRT2[5];
+    PRT0 = a_PRT1[0];
+    PRT1[0] = a_PRT1[1];
+    PRT1[1] = a_PRT1[2];
+    PRT1[2] = a_PRT2[0];
+    PRT2[0] = a_PRT2[1];
+    PRT2[1] = a_PRT2[2];
+    PRT2[2] = a_PRT3[0];
+    PRT2[3] = a_PRT3[1];
+    PRT2[4] = a_PRT3[2];
+
+    OptRotateBand1(PRT1, R, PRT1);
+    OptRotateBand2(PRT2, R, PRT2);
+
+    VertexOut.PRT1 = vec3(PRT0,PRT1[0],PRT1[1]);
+    VertexOut.PRT2 = vec3(PRT1[2],PRT2[0],PRT2[1]);
+    VertexOut.PRT3 = vec3(PRT2[2],PRT2[3],PRT2[4]);
+
+    gl_Position = vec4(a_TextureCoord, 0.0, 1.0) - vec4(0.5, 0.5, 0, 0);
+    gl_Position[0] *= 2.0;
+    gl_Position[1] *= 2.0;
+}

lib/renderer/gl/data/quad.fs

@@ -0,0 +1,11 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform sampler2D screenTexture;
+
+void main()
+{
+    FragColor = texture(screenTexture, TexCoord);
+}

lib/renderer/gl/data/quad.vs

@@ -0,0 +1,11 @@
+#version 330 core
+layout (location = 0) in vec2 aPos;
+layout (location = 1) in vec2 aTexCoord;
+
+out vec2 TexCoord;
+
+void main()
+{
+    gl_Position = vec4(aPos.x, aPos.y, 0.0, 1.0);
+    TexCoord = aTexCoord;
+}