Wrap adsModel into phongFunction

This way the use is more similar to the one for metal/rough.

Change-Id: I143df910f43e29ef622f24bd97a23c90a2c8ef68
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

23 files changed, 149 insertions, 148 deletions

diff --git a/examples/qt3d/advancedcustommaterial/shaders/es2/water.frag b/examples/qt3d/advancedcustommaterial/shaders/es2/water.frag
index 4a417ab34..dfd2650bd 100644
--- a/examples/qt3d/advancedcustommaterial/shaders/es2/water.frag
+++ b/examples/qt3d/advancedcustommaterial/shaders/es2/water.frag
@@ -24,8 +24,7 @@ uniform FP float offsetx;
 uniform FP float offsety;
 uniform FP float specularity;
 uniform FP float waveStrenght;
-uniform FP vec3 ka;
-uniform FP vec3 specularColor;
+uniform FP vec4 ka;
 uniform FP float shininess;
 uniform FP float normalAmount;
 uniform FP vec3 eyePosition;
@@ -61,16 +60,15 @@ void main()
 
     FP mat3 tangentMatrix = calcWorldSpaceToTangentSpaceMatrix(worldNormal, worldTangent);
     FP mat3 invertTangentMatrix = transpose(tangentMatrix);
-    FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
-
-    // Calculate the lighting model, keeping the specular component separate
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
 
-    // Combine final fragment color
-    FP vec4 outputColor = vec4(((skycolor.rgb + ka + diffuseTextureColor.rgb * (diffuseColor))+(specularColor * specularTextureColor.a*specularity)), vpos.y );
+    FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
 
+    FP vec4 diffuse = vec4(diffuseTextureColor.rgb, vpos.y);
+    FP vec4 specular = vec4(specularTextureColor.a*specularity);
+    FP vec4 outputColor = phongFunction(ka, diffuse, specular, shininess, worldPosition, worldView, wNormal);
 
+    outputColor += vec4(skycolor.rgb, vpos.y);
     outputColor += (foamTextureColor.rgba*vpos.y);
 
     gl_FragColor = vec4(outputColor.rgb,1.0);
diff --git a/examples/qt3d/advancedcustommaterial/shaders/gl3/water.frag b/examples/qt3d/advancedcustommaterial/shaders/gl3/water.frag
index de6e87281..49d57fcaf 100644
--- a/examples/qt3d/advancedcustommaterial/shaders/gl3/water.frag
+++ b/examples/qt3d/advancedcustommaterial/shaders/gl3/water.frag
@@ -24,7 +24,7 @@ uniform float offsetx;
 uniform float offsety;
 uniform float specularity;
 uniform float waveStrenght;
-uniform vec3 ka;
+uniform vec4 ka;
 uniform vec3 specularColor;
 uniform float shininess;
 uniform float normalAmount;
@@ -65,16 +65,13 @@ void main()
     mat3 invertTangentMatrix = transpose(tangentMatrix);
 
     vec3 wNormal = normalize(invertTangentMatrix * tNormal);
+    vec3 worldView = normalize(eyePosition - worldPosition);
 
+    vec4 diffuse = vec4(diffuseTextureColor.rgb, vpos.y);
+    vec4 specular = vec4(specularTextureColor.a*specularity);
+    vec4 outputColor = phongFunction(ka, diffuse, specular, shininess, worldPosition, worldView, wNormal);
 
-    // Calculate the lighting model, keeping the specular component separate
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine final fragment color
-    vec4 outputColor = vec4(((skycolor.rgb + ka + diffuseTextureColor.rgb * (diffuseColor))+(specularColor * specularTextureColor.a*specularity)), vpos.y );
-
-
+    outputColor += vec4(skycolor.rgb, vpos.y);
     outputColor += (foamTextureColor.rgba*vpos.y);
 
     fragColor = vec4(outputColor.rgb,1.0);
diff --git a/src/extras/shaders/es2/diffusemap.frag b/src/extras/shaders/es2/diffusemap.frag
index 7d06d8e2c..974179f2a 100644
--- a/src/extras/shaders/es2/diffusemap.frag
+++ b/src/extras/shaders/es2/diffusemap.frag
@@ -1,7 +1,7 @@
 #define FP highp
 
-uniform FP vec3 ka;            // Ambient reflectivity
-uniform FP vec3 ks;            // Specular reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
+uniform FP vec4 ks;            // Specular reflectivity
 uniform FP float shininess;    // Specular shininess factor
 
 uniform FP vec3 eyePosition;
@@ -16,10 +16,7 @@ varying FP vec2 texCoord;
 
 void main()
 {
-    FP vec3 diffuseTextureColor = texture2D( diffuseTexture, texCoord ).rgb;
-
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    gl_FragColor = vec4( diffuseTextureColor * ( ka + diffuseColor ) + ks * specularColor, 1.0 );
+    FP vec4 diffuseTextureColor = texture2D( diffuseTexture, texCoord );
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
+    gl_FragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/es2/diffusespecularmap.frag b/src/extras/shaders/es2/diffusespecularmap.frag
index 4d776772c..5ad170d1d 100644
--- a/src/extras/shaders/es2/diffusespecularmap.frag
+++ b/src/extras/shaders/es2/diffusespecularmap.frag
@@ -1,7 +1,7 @@
 #define FP highp
 
 // TODO: Replace with a struct
-uniform FP vec3 ka;            // Ambient reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
 uniform FP float shininess;    // Specular shininess factor
 
 uniform FP vec3 eyePosition;
@@ -17,11 +17,8 @@ varying FP vec2 texCoord;
 
 void main()
 {
-    FP vec3 diffuseTextureColor = texture2D( diffuseTexture, texCoord ).rgb;
-    FP vec3 specularTextureColor = texture2D( specularTexture, texCoord ).rgb;
-
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    gl_FragColor = vec4( diffuseTextureColor * ( ka + diffuseColor ) + specularTextureColor * specularColor, 1.0 );
+    FP vec4 diffuseTextureColor = texture2D( diffuseTexture, texCoord );
+    FP vec4 specularTextureColor = texture2D( specularTexture, texCoord );
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
+    gl_FragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/es2/light.inc.frag b/src/extras/shaders/es2/light.inc.frag
index d19af6e2a..2c41bb37b 100644
--- a/src/extras/shaders/es2/light.inc.frag
+++ b/src/extras/shaders/es2/light.inc.frag
@@ -14,7 +14,7 @@ struct Light {
 uniform Light lights[MAX_LIGHTS];
 uniform int lightCount;
 
-void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3 eye, const in FP float shininess,
+void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3 vview, const in FP float shininess,
               out FP vec3 diffuseColor, out FP vec3 specularColor)
 {
     diffuseColor = vec3(0.0);
@@ -65,12 +65,30 @@ void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3
         FP float specular = 0.0;
         if (diffuse > 0.0 && shininess > 0.0 && att > 0.0) {
             FP vec3 r = reflect( -s, n );
-            FP vec3 v = normalize( eye - vpos );
             FP float normFactor = ( shininess + 2.0 ) / 2.0;
-            specular = normFactor * pow( max( dot( r, v ), 0.0 ), shininess );
+            specular = normFactor * pow( max( dot( r, vview ), 0.0 ), shininess );
         }
 
         diffuseColor += att * light.intensity * diffuse * light.color;
         specularColor += att * light.intensity * specular * light.color;
     }
 }
+
+FP vec4 phongFunction(const in FP vec4 ambient,
+                      const in FP vec4 diffuse,
+                      const in FP vec4 specular,
+                      const in FP float shininess,
+                      const in FP vec3 worldPosition,
+                      const in FP vec3 worldView,
+                      const in FP vec3 worldNormal)
+{
+    // Calculate the lighting model, keeping the specular component separate
+    FP vec3 diffuseColor, specularColor;
+    adsModel(worldPosition, worldNormal, worldView, shininess, diffuseColor, specularColor);
+
+    // Combine spec with ambient+diffuse for final fragment color
+    FP vec3 color = (ambient.rgb + diffuseColor) * diffuse.rgb
+                  + specularColor * specular.rgb;
+
+    return vec4(color, diffuse.a);
+}
diff --git a/src/extras/shaders/es2/light.inc.frag100 b/src/extras/shaders/es2/light.inc.frag100
index 24766168b..bf59b5e47 100644
--- a/src/extras/shaders/es2/light.inc.frag100
+++ b/src/extras/shaders/es2/light.inc.frag100
@@ -14,7 +14,7 @@ struct Light {
 uniform Light lights[MAX_LIGHTS];
 uniform int lightCount;
 
-void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3 eye, const in FP float shininess,
+void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3 vview, const in FP float shininess,
               out FP vec3 diffuseColor, out FP vec3 specularColor)
 {
     diffuseColor = vec3(0.0);
@@ -47,9 +47,8 @@ void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3
     FP float specular = 0.0;
     if (diffuse > 0.0 && shininess > 0.0 && att > 0.0) {
         FP vec3 r = reflect( -s, n );
-        FP vec3 v = normalize( eye - vpos );
         FP float normFactor = ( shininess + 2.0 ) / 2.0;
-        specular = normFactor * pow( max( dot( r, v ), 0.0 ), shininess );
+        specular = normFactor * pow( max( dot( r, vview ), 0.0 ), shininess );
     }
 
     diffuseColor += att * lights[0].intensity * diffuse * lights[0].color;
@@ -79,11 +78,29 @@ void adsModel(const in FP vec3 vpos, const in FP vec3 vnormal, const in FP vec3
     specular = 0.0;
     if (diffuse > 0.0 && shininess > 0.0 && att > 0.0) {
         FP vec3 r = reflect( -s, n );
-        FP vec3 v = normalize( eye - vpos );
         FP float normFactor = ( shininess + 2.0 ) / 2.0;
-        specular = normFactor * pow( max( dot( r, v ), 0.0 ), shininess );
+        specular = normFactor * pow( max( dot( r, vview ), 0.0 ), shininess );
     }
 
     diffuseColor += att * lights[1].intensity * diffuse * lights[1].color;
     specularColor += att * specular;
 }
+
+FP vec4 phongFunction(const in FP vec4 ambient,
+                      const in FP vec4 diffuse,
+                      const in FP vec4 specular,
+                      const in FP float shininess,
+                      const in FP vec3 worldPosition,
+                      const in FP vec3 worldView,
+                      const in FP vec3 worldNormal)
+{
+    // Calculate the lighting model, keeping the specular component separate
+    FP vec3 diffuseColor, specularColor;
+    adsModel(worldPosition, worldNormal, worldView, shininess, diffuseColor, specularColor);
+
+    // Combine spec with ambient+diffuse for final fragment color
+    FP vec3 color = (ambient.rgb + diffuseColor) * diffuse.rgb
+                  + specularColor * specular.rgb;
+
+    return vec4(color, diffuse.a);
+}
diff --git a/src/extras/shaders/es2/normaldiffusemap.frag b/src/extras/shaders/es2/normaldiffusemap.frag
index e1f19b81a..19ca27de8 100644
--- a/src/extras/shaders/es2/normaldiffusemap.frag
+++ b/src/extras/shaders/es2/normaldiffusemap.frag
@@ -9,8 +9,8 @@ uniform sampler2D diffuseTexture;
 uniform sampler2D normalTexture;
 
 // TODO: Replace with a struct
-uniform FP vec3 ka;            // Ambient reflectivity
-uniform FP vec3 ks;            // Specular reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
+uniform FP vec4 ks;            // Specular reflectivity
 uniform FP float shininess;    // Specular shininess factor
 
 uniform FP vec3 eyePosition;
@@ -28,11 +28,7 @@ void main()
     FP mat3 invertTangentMatrix = transpose(tangentMatrix);
 
     FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
 
-    // Calculate the lighting model, keeping the specular component separate
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine spec with ambient+diffuse for final fragment color
-    gl_FragColor = vec4( ka + diffuseTextureColor.rgb * diffuseColor + ks * specularColor, 1.0 );
+    gl_FragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, wNormal);
 }
diff --git a/src/extras/shaders/es2/normaldiffusemapalpha.frag b/src/extras/shaders/es2/normaldiffusemapalpha.frag
index 599445b9b..19ca27de8 100644
--- a/src/extras/shaders/es2/normaldiffusemapalpha.frag
+++ b/src/extras/shaders/es2/normaldiffusemapalpha.frag
@@ -9,8 +9,8 @@ uniform sampler2D diffuseTexture;
 uniform sampler2D normalTexture;
 
 // TODO: Replace with a struct
-uniform FP vec3 ka;            // Ambient reflectivity
-uniform FP vec3 ks;            // Specular reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
+uniform FP vec4 ks;            // Specular reflectivity
 uniform FP float shininess;    // Specular shininess factor
 
 uniform FP vec3 eyePosition;
@@ -28,12 +28,7 @@ void main()
     FP mat3 invertTangentMatrix = transpose(tangentMatrix);
 
     FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
 
-    // Calculate the lighting model, keeping the specular component separate
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine spec with ambient+diffuse for final fragment color
-    // Use the alpha from the diffuse texture (for alpha to coverage)
-    gl_FragColor = vec4( ka + diffuseTextureColor.rgb * diffuseColor + ks * specularColor, diffuseTextureColor.a );
+    gl_FragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, wNormal);
 }
diff --git a/src/extras/shaders/es2/normaldiffusespecularmap.frag b/src/extras/shaders/es2/normaldiffusespecularmap.frag
index 6dc2fba02..69322dd3a 100644
--- a/src/extras/shaders/es2/normaldiffusespecularmap.frag
+++ b/src/extras/shaders/es2/normaldiffusespecularmap.frag
@@ -10,7 +10,7 @@ uniform sampler2D specularTexture;
 uniform sampler2D normalTexture;
 
 // TODO: Replace with a struct
-uniform FP vec3 ka;            // Ambient reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
 uniform FP float shininess;    // Specular shininess factor
 
 uniform FP vec3 eyePosition;
@@ -29,11 +29,7 @@ void main()
     FP mat3 invertTangentMatrix = transpose(tangentMatrix);
 
     FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
 
-    // Calculate the lighting model, keeping the specular component separate
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine spec with ambient+diffuse for final fragment color
-    gl_FragColor = vec4( ka + diffuseTextureColor.rgb * diffuseColor + specularTextureColor.rgb * specularColor, 1.0 );
+    gl_FragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, wNormal);
 }
diff --git a/src/extras/shaders/es2/pervertexcolor.frag b/src/extras/shaders/es2/pervertexcolor.frag
index 186e93dc9..d33e11145 100644
--- a/src/extras/shaders/es2/pervertexcolor.frag
+++ b/src/extras/shaders/es2/pervertexcolor.frag
@@ -2,7 +2,7 @@
 
 varying FP vec3 worldPosition;
 varying FP vec3 worldNormal;
-varying FP vec3 color;
+varying FP vec4 color;
 
 uniform FP vec3 eyePosition;
 
@@ -10,8 +10,6 @@ uniform FP vec3 eyePosition;
 
 void main()
 {
-    FP vec3 diffuseColor;
-    FP vec3 specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, 0.0, diffuseColor, specularColor);
-    gl_FragColor = vec4( color + color * diffuseColor, 1.0 );
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
+    gl_FragColor = phongFunction(color, color, vec4(0.0), 0.0, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/es2/pervertexcolor.vert b/src/extras/shaders/es2/pervertexcolor.vert
index 7fc3e649f..bfa2e615a 100644
--- a/src/extras/shaders/es2/pervertexcolor.vert
+++ b/src/extras/shaders/es2/pervertexcolor.vert
@@ -1,10 +1,10 @@
 attribute vec3 vertexPosition;
 attribute vec3 vertexNormal;
-attribute vec3 vertexColor;
+attribute vec4 vertexColor;
 
 varying vec3 worldPosition;
 varying vec3 worldNormal;
-varying vec3 color;
+varying vec4 color;
 
 uniform mat4 modelMatrix;
 uniform mat3 modelNormalMatrix;
diff --git a/src/extras/shaders/es2/phong.frag b/src/extras/shaders/es2/phong.frag
index c00f89db0..a2d29c6cc 100644
--- a/src/extras/shaders/es2/phong.frag
+++ b/src/extras/shaders/es2/phong.frag
@@ -1,8 +1,8 @@
 #define FP highp
 
-uniform FP vec3 ka;            // Ambient reflectivity
-uniform FP vec3 kd;            // Diffuse reflectivity
-uniform FP vec3 ks;            // Specular reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
+uniform FP vec4 kd;            // Diffuse reflectivity
+uniform FP vec4 ks;            // Specular reflectivity
 uniform FP float shininess;    // Specular shininess factor
 
 uniform FP vec3 eyePosition;
@@ -14,7 +14,6 @@ varying FP vec3 worldNormal;
 
 void main()
 {
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-    gl_FragColor = vec4( ka + kd * diffuseColor + ks * specularColor, 1.0 );
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
+    gl_FragColor = phongFunction(ka, kd, ks, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/es2/phongalpha.frag b/src/extras/shaders/es2/phongalpha.frag
index c5ec43049..6378aa184 100644
--- a/src/extras/shaders/es2/phongalpha.frag
+++ b/src/extras/shaders/es2/phongalpha.frag
@@ -1,9 +1,9 @@
 #define FP highp
 
 // TODO: Replace with a struct
-uniform FP vec3 ka;            // Ambient reflectivity
-uniform FP vec3 kd;            // Diffuse reflectivity
-uniform FP vec3 ks;            // Specular reflectivity
+uniform FP vec4 ka;            // Ambient reflectivity
+uniform FP vec4 kd;            // Diffuse reflectivity
+uniform FP vec4 ks;            // Specular reflectivity
 uniform FP float shininess;    // Specular shininess factor
 uniform FP float alpha;
 
@@ -16,7 +16,6 @@ varying FP vec3 worldNormal;
 
 void main()
 {
-    FP vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-    gl_FragColor = vec4( ka + kd * diffuseColor + ks * specularColor, alpha );
+    FP vec3 worldView = normalize(eyePosition - worldPosition);
+    gl_FragColor = phongFunction(ka, vec4(kd.rgb, alpha), ks, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/gl3/diffusemap.frag b/src/extras/shaders/gl3/diffusemap.frag
index 7810fdb68..1b1b53e17 100644
--- a/src/extras/shaders/gl3/diffusemap.frag
+++ b/src/extras/shaders/gl3/diffusemap.frag
@@ -1,7 +1,7 @@
 #version 150 core
 
-uniform vec3 ka;            // Ambient reflectivity
-uniform vec3 ks;            // Specular reflectivity
+uniform vec4 ka;            // Ambient reflectivity
+uniform vec4 ks;            // Specular reflectivity
 uniform float shininess;    // Specular shininess factor
 
 uniform vec3 eyePosition;
@@ -18,10 +18,7 @@ out vec4 fragColor;
 
 void main()
 {
-    vec3 diffuseTextureColor = texture( diffuseTexture, texCoord ).rgb;
-
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    fragColor = vec4( diffuseTextureColor * ( ka + diffuseColor ) + ks * specularColor, 1.0 );
+    vec4 diffuseTextureColor = texture( diffuseTexture, texCoord );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/gl3/diffusespecularmap.frag b/src/extras/shaders/gl3/diffusespecularmap.frag
index fb809393a..00ef124bb 100644
--- a/src/extras/shaders/gl3/diffusespecularmap.frag
+++ b/src/extras/shaders/gl3/diffusespecularmap.frag
@@ -1,7 +1,7 @@
 #version 150 core
 
 // TODO: Replace with a struct
-uniform vec3 ka;            // Ambient reflectivity
+uniform vec4 ka;            // Ambient reflectivity
 uniform float shininess;    // Specular shininess factor
 
 uniform vec3 eyePosition;
@@ -19,11 +19,8 @@ out vec4 fragColor;
 
 void main()
 {
-    vec3 diffuseTextureColor = texture( diffuseTexture, texCoord ).rgb;
-    vec3 specularTextureColor = texture( specularTexture, texCoord ).rgb;
-
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    fragColor = vec4( diffuseTextureColor * ( ka + diffuseColor ) + specularTextureColor * specularColor, 1.0 );
+    vec4 diffuseTextureColor = texture( diffuseTexture, texCoord );
+    vec4 specularTextureColor = texture( specularTexture, texCoord );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/gl3/light.inc.frag b/src/extras/shaders/gl3/light.inc.frag
index c4c08c7d9..f588acce3 100644
--- a/src/extras/shaders/gl3/light.inc.frag
+++ b/src/extras/shaders/gl3/light.inc.frag
@@ -26,7 +26,7 @@ uniform int envLightCount = 0;
 
 void adsModel(const in vec3 worldPos,
               const in vec3 worldNormal,
-              const in vec3 worldEye,
+              const in vec3 worldView,
               const in float shininess,
               out vec3 diffuseColor,
               out vec3 specularColor)
@@ -36,7 +36,6 @@ void adsModel(const in vec3 worldPos,
 
     // We perform all work in world space
     vec3 n = normalize(worldNormal);
-    vec3 v = normalize(worldEye - worldPos);
     vec3 s = vec3(0.0);
 
     for (int i = 0; i < lightCount; ++i) {
@@ -84,7 +83,7 @@ void adsModel(const in vec3 worldPos,
         if (diffuse > 0.0 && shininess > 0.0) {
             float normFactor = (shininess + 2.0) / 2.0;
             vec3 r = reflect(-s, n);   // Reflection direction in world space
-            specular = normFactor * pow(max(dot(r, v), 0.0), shininess);
+            specular = normFactor * pow(max(dot(r, worldView), 0.0), shininess);
         }
 
         // Accumulate the diffuse and specular contributions
@@ -92,3 +91,22 @@ void adsModel(const in vec3 worldPos,
         specularColor += att * lights[i].intensity * specular * lights[i].color;
     }
 }
+
+vec4 phongFunction(const in vec4 ambient,
+                   const in vec4 diffuse,
+                   const in vec4 specular,
+                   const in float shininess,
+                   const in vec3 worldPosition,
+                   const in vec3 worldView,
+                   const in vec3 worldNormal)
+{
+    // Calculate the lighting model, keeping the specular component separate
+    vec3 diffuseColor, specularColor;
+    adsModel(worldPosition, worldNormal, worldView, shininess, diffuseColor, specularColor);
+
+    // Combine spec with ambient+diffuse for final fragment color
+    vec3 color = (ambient.rgb + diffuseColor) * diffuse.rgb
+               + specularColor * specular.rgb;
+
+    return vec4(color, diffuse.a);
+}
diff --git a/src/extras/shaders/gl3/normaldiffusemap.frag b/src/extras/shaders/gl3/normaldiffusemap.frag
index e814da22f..1266cafa0 100644
--- a/src/extras/shaders/gl3/normaldiffusemap.frag
+++ b/src/extras/shaders/gl3/normaldiffusemap.frag
@@ -9,8 +9,8 @@ uniform sampler2D diffuseTexture;
 uniform sampler2D normalTexture;
 
 // TODO: Replace with a struct
-uniform vec3 ka;            // Ambient reflectivity
-uniform vec3 ks;            // Specular reflectivity
+uniform vec4 ka;            // Ambient reflectivity
+uniform vec4 ks;            // Specular reflectivity
 uniform float shininess;    // Specular shininess factor
 
 uniform vec3 eyePosition;
@@ -31,10 +31,6 @@ void main()
 
     vec3 wNormal = normalize(invertTangentMatrix * tNormal);
 
-    // Calculate the lighting model, keeping the specular component separate
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine spec with ambient+diffuse for final fragment color
-    fragColor = vec4( ka + diffuseTextureColor.rgb * diffuseColor + ks * specularColor, 1.0 );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, wNormal);
 }
diff --git a/src/extras/shaders/gl3/normaldiffusemapalpha.frag b/src/extras/shaders/gl3/normaldiffusemapalpha.frag
index 030291087..1266cafa0 100644
--- a/src/extras/shaders/gl3/normaldiffusemapalpha.frag
+++ b/src/extras/shaders/gl3/normaldiffusemapalpha.frag
@@ -9,8 +9,8 @@ uniform sampler2D diffuseTexture;
 uniform sampler2D normalTexture;
 
 // TODO: Replace with a struct
-uniform vec3 ka;            // Ambient reflectivity
-uniform vec3 ks;            // Specular reflectivity
+uniform vec4 ka;            // Ambient reflectivity
+uniform vec4 ks;            // Specular reflectivity
 uniform float shininess;    // Specular shininess factor
 
 uniform vec3 eyePosition;
@@ -31,11 +31,6 @@ void main()
 
     vec3 wNormal = normalize(invertTangentMatrix * tNormal);
 
-    // Calculate the lighting model, keeping the specular component separate
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine spec with ambient+diffuse for final fragment color
-    // Use the alpha from the diffuse texture (for alpha to coverage)
-    fragColor = vec4( ka + diffuseTextureColor.rgb * diffuseColor + ks * specularColor, diffuseTextureColor.a );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, wNormal);
 }
diff --git a/src/extras/shaders/gl3/normaldiffusespecularmap.frag b/src/extras/shaders/gl3/normaldiffusespecularmap.frag
index 67daccebf..db1803c7a 100644
--- a/src/extras/shaders/gl3/normaldiffusespecularmap.frag
+++ b/src/extras/shaders/gl3/normaldiffusespecularmap.frag
@@ -11,7 +11,7 @@ uniform sampler2D diffuseTexture;
 uniform sampler2D specularTexture;
 uniform sampler2D normalTexture;
 
-uniform vec3 ka;            // Ambient reflectivity
+uniform vec4 ka;            // Ambient reflectivity
 uniform float shininess;    // Specular shininess factor
 uniform vec3 eyePosition;
 
@@ -30,11 +30,6 @@ void main()
 
     vec3 wNormal = normalize(invertTangentMatrix * tNormal);
 
-    // Calculate the lighting model, keeping the specular component separate
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, wNormal, eyePosition, shininess, diffuseColor, specularColor);
-
-    // Combine spec with ambient+diffuse for final fragment color
-    fragColor = vec4((ka + diffuseColor) * diffuseTextureColor.rgb
-                      + specularColor * specularTextureColor.rgb, 1.0);
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, wNormal);
 }
diff --git a/src/extras/shaders/gl3/pervertexcolor.frag b/src/extras/shaders/gl3/pervertexcolor.frag
index 910efe554..71318e37f 100644
--- a/src/extras/shaders/gl3/pervertexcolor.frag
+++ b/src/extras/shaders/gl3/pervertexcolor.frag
@@ -2,7 +2,7 @@
 
 in vec3 worldPosition;
 in vec3 worldNormal;
-in vec3 color;
+in vec4 color;
 
 out vec4 fragColor;
 
@@ -12,8 +12,6 @@ uniform vec3 eyePosition;
 
 void main()
 {
-    vec3 diffuseColor;
-    vec3 specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, 0.0, diffuseColor, specularColor);
-    fragColor = vec4( color + color * diffuseColor, 1.0 );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(color, color, vec4(0.0), 0.0, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/gl3/pervertexcolor.vert b/src/extras/shaders/gl3/pervertexcolor.vert
index 87713a520..1d721e945 100644
--- a/src/extras/shaders/gl3/pervertexcolor.vert
+++ b/src/extras/shaders/gl3/pervertexcolor.vert
@@ -2,11 +2,11 @@
 
 in vec3 vertexPosition;
 in vec3 vertexNormal;
-in vec3 vertexColor;
+in vec4 vertexColor;
 
 out vec3 worldPosition;
 out vec3 worldNormal;
-out vec3 color;
+out vec4 color;
 
 uniform mat4 modelMatrix;
 uniform mat3 modelNormalMatrix;
diff --git a/src/extras/shaders/gl3/phong.frag b/src/extras/shaders/gl3/phong.frag
index a4d7e0969..49e0ce1dd 100644
--- a/src/extras/shaders/gl3/phong.frag
+++ b/src/extras/shaders/gl3/phong.frag
@@ -1,8 +1,8 @@
 #version 150 core
 
-uniform vec3 ka;            // Ambient reflectivity
-uniform vec3 kd;            // Diffuse reflectivity
-uniform vec3 ks;            // Specular reflectivity
+uniform vec4 ka;            // Ambient reflectivity
+uniform vec4 kd;            // Diffuse reflectivity
+uniform vec4 ks;            // Specular reflectivity
 uniform float shininess;    // Specular shininess factor
 
 uniform vec3 eyePosition;
@@ -16,7 +16,6 @@ out vec4 fragColor;
 
 void main()
 {
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-    fragColor = vec4( ka + kd * diffuseColor + ks * specularColor, 1.0 );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, kd, ks, shininess, worldPosition, worldView, worldNormal);
 }
diff --git a/src/extras/shaders/gl3/phongalpha.frag b/src/extras/shaders/gl3/phongalpha.frag
index cb019e9aa..288a12d0f 100644
--- a/src/extras/shaders/gl3/phongalpha.frag
+++ b/src/extras/shaders/gl3/phongalpha.frag
@@ -1,9 +1,9 @@
 #version 150 core
 
 // TODO: Replace with a struct
-uniform vec3 ka;            // Ambient reflectivity
-uniform vec3 kd;            // Diffuse reflectivity
-uniform vec3 ks;            // Specular reflectivity
+uniform vec4 ka;            // Ambient reflectivity
+uniform vec4 kd;            // Diffuse reflectivity
+uniform vec4 ks;            // Specular reflectivity
 uniform float shininess;    // Specular shininess factor
 uniform float alpha;
 
@@ -18,7 +18,6 @@ out vec4 fragColor;
 
 void main()
 {
-    vec3 diffuseColor, specularColor;
-    adsModel(worldPosition, worldNormal, eyePosition, shininess, diffuseColor, specularColor);
-    fragColor = vec4( ka + kd * diffuseColor + ks * specularColor, alpha );
+    vec3 worldView = normalize(eyePosition - worldPosition);
+    fragColor = phongFunction(ka, vec4(kd.rgb, alpha), ks, shininess, worldPosition, worldView, worldNormal);
 }