Still working on GL update

libraries/model/src/model/Material.slh

@@ -26,4 +26,9 @@ Material getMaterial() {
     return _mat;
 }
 
+float getMaterialOpacity(Material m) { return m._diffuse.a; }
+vec3 getMaterialDiffuse(Material m) { return m._diffuse.rgb; }
+vec3 getMaterialSpecular(Material m) { return m._specular.rgb; }
+float getMaterialShininess(Material m) { return m._specular.a; }
+
 <@endif@>

libraries/render-utils/src/model.slf

@@ -18,22 +18,22 @@
 // the diffuse texture
 uniform sampler2D diffuseMap;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-varying vec3 color;
+in vec4 _position;
+in vec4 _normal;
+in vec3 _color;
+in vec2 _texCoord0;
 
 
 void main(void) {
     // Fetch diffuse map
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
 
     Material mat = getMaterial();
 
     packDeferredFragment(
-        normalize(interpolatedNormal.xyz), 
+        normalize(_normal.xyz), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         getMaterialSpecular(mat),
         getMaterialShininess(mat));
 }

libraries/render-utils/src/model.slv

@@ -11,6 +11,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+<@include gpu/Inputs.slh@>
+
 <@include gpu/Transform.slh@>
 
 <$declareStandardTransform()$>
@@ -19,27 +21,22 @@ const int MAX_TEXCOORDS = 2;
 
 uniform mat4 texcoordMatrices[MAX_TEXCOORDS];
 
-// interpolated eye position
-varying vec4 interpolatedPosition;
-
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-varying vec3 color;
+out vec4 _position;
+out vec3 _normal;
+out vec3 _color;
+out vec2 _texCoord0;
 
 void main(void) {
     
     // pass along the diffuse color
-    color = gl_Color.xyz;
+    _color = inColor.xyz;
     
     // and the texture coordinates
-    gl_TexCoord[0] = texcoordMatrices[0] * vec4(gl_MultiTexCoord0.xy, 0.0, 1.0);
+    _texCoord0 = (texcoordMatrices[0] * vec4(inTexCoord0.st, 0.0, 1.0)).st;
 
     // standard transform
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
-    <$transformModelToEyeAndClipPos(cam, obj, gl_Vertex, interpolatedPosition, gl_Position)$>
-    <$transformModelToEyeDir(cam, obj, gl_Normal, interpolatedNormal.xyz)$>
-
-    interpolatedNormal = vec4(normalize(interpolatedNormal.xyz), 0.0);
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
 }

libraries/render-utils/src/model_lightmap.slf

@@ -23,25 +23,22 @@ uniform sampler2D diffuseMap;
 uniform sampler2D emissiveMap;
 uniform vec2 emissiveParams;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-varying vec3 color;
-
-// the interpolated texcoord1
-varying vec2 interpolatedTexcoord1;
+out vec4 _position;
+out vec2 _texCoord0;
+out vec2 _texCoord1;
+out vec3 _normal;
+out vec3 _color;
 
 void main(void) {
-    // set the diffuse, normal, specular data
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-    vec4 emissive = texture2D(emissiveMap, interpolatedTexcoord1.st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
+    vec4 emissive = texture(emissiveMap, _texCoord1);
 
     Material mat = getMaterial();
 
     packDeferredFragmentLightmap(
-        normalize(interpolatedNormal.xyz), 
+        normalize(_normal), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         getMaterialSpecular(mat),
         getMaterialShininess(mat),
         (vec3(emissiveParams.x) + emissiveParams.y * emissive.rgb));

libraries/render-utils/src/model_lightmap.slv

@@ -12,6 +12,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+<@include gpu/Inputs.slh@>
+
 <@include gpu/Transform.slh@>
 
 <$declareStandardTransform()$>
@@ -20,32 +22,23 @@ const int MAX_TEXCOORDS = 2;
 
 uniform mat4 texcoordMatrices[MAX_TEXCOORDS];
 
-attribute vec2 texcoord1;
-
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated texcoord1
-varying vec2 interpolatedTexcoord1;
-
-varying vec3 color;
-
+out vec4 _position;
+out vec2 _texCoord0;
+out vec2 _texCoord1;
+out vec3 _normal;
+out vec3 _color;
 
 void main(void) {
-    // pass along the diffuse color
-    color = gl_Color.xyz;
-    
+    _color = inColor.xyz;
+
     // and the texture coordinates
-    gl_TexCoord[0] = texcoordMatrices[0] * vec4(gl_MultiTexCoord0.xy, 0.0, 1.0);
-  //  interpolatedTexcoord1 = vec2(texcoordMatrices[1] * vec4(gl_MultiTexCoord0.xy, 0.0, 1.0)).xy;
-    interpolatedTexcoord1 = vec2(texcoordMatrices[1] * vec4(texcoord1.xy, 0.0, 1.0)).xy;
+    _texCoord0 = (texcoordMatrices[0] * vec4(inTexCoord0.st, 0.0, 1.0)).st;
+    _texCoord1 = (texcoordMatrices[1] * vec4(inTexCoord1.st, 0.0, 1.0)).st;
 
     // standard transform
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
-    <$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>
-    <$transformModelToEyeDir(cam, obj, gl_Normal, interpolatedNormal.xyz)$>
-
-    interpolatedNormal = vec4(normalize(interpolatedNormal.xyz), 0.0);
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
 }
 

libraries/render-utils/src/model_lightmap_normal_map.slf

@@ -26,35 +26,32 @@ uniform sampler2D normalMap;
 uniform sampler2D emissiveMap;
 uniform vec2 emissiveParams;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated tangent
-varying vec4 interpolatedTangent;
-
-varying vec2 interpolatedTexcoord1;
-
-varying vec3 color;
+in vec4 _position;
+in vec2 _texCoord0;
+in vec2 _texCoord1;
+in vec3 _normal;
+in vec3 _tangent;
+in vec3 _color;
 
 void main(void) {
     // compute the view normal from the various bits
-    vec3 normalizedNormal = normalize(vec3(interpolatedNormal));
-    vec3 normalizedTangent = normalize(vec3(interpolatedTangent));
+    vec3 normalizedNormal = normalize(_normal);
+    vec3 normalizedTangent = normalize(_tangent);
     vec3 normalizedBitangent = normalize(cross(normalizedNormal, normalizedTangent));
-    vec3 localNormal = vec3(texture2D(normalMap, gl_TexCoord[0].st)) - vec3(0.5, 0.5, 0.5);
+    vec3 localNormal = vec3(texture(normalMap, _texCoord0)) - vec3(0.5, 0.5, 0.5);
     vec4 viewNormal = vec4(normalizedTangent * localNormal.x +
         normalizedBitangent * localNormal.y + normalizedNormal * localNormal.z, 0.0);
     
     // set the diffuse, normal, specular data
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-    vec4 emissive = texture2D(emissiveMap, interpolatedTexcoord1.st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
+    vec4 emissive = texture(emissiveMap, _texCoord1);
 
     Material mat = getMaterial();
 
     packDeferredFragmentLightmap(
         normalize(viewNormal.xyz), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         getMaterialSpecular(mat),
         getMaterialShininess(mat),
         (vec3(emissiveParams.x) + emissiveParams.y * emissive.rgb));

libraries/render-utils/src/model_lightmap_normal_map.slv

@@ -12,47 +12,34 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-<@include gpu/Transform.slh@>
-
 <@include gpu/Inputs.slh@>
 
+<@include gpu/Transform.slh@>
+
 <$declareStandardTransform()$>
 
 const int MAX_TEXCOORDS = 2;
 
 uniform mat4 texcoordMatrices[MAX_TEXCOORDS];
 
-
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated tangent
-varying vec4 interpolatedTangent;
-
-// the interpolated texcoord1
-varying vec2 interpolatedTexcoord1;
-
-varying vec3 color;
+out vec4 _position;
+out vec2 _texCoord0;
+out vec2 _texCoord1;
+out vec3 _normal;
+out vec3 _tangent;
+out vec3 _color;
 
 void main(void) {
-    // transform and store the normal and tangent for interpolation
-    //interpolatedNormal = gl_ModelViewMatrix * vec4(gl_Normal, 0.0);
-    //interpolatedTangent = gl_ModelViewMatrix * vec4(tangent, 0.0);
-    
-    // pass along the diffuse color
-    color = gl_Color.xyz;
-    
+    _color = inColor.xyz;
+
     // and the texture coordinates
-    gl_TexCoord[0] = texcoordMatrices[0] * vec4(gl_MultiTexCoord0.xy, 0.0, 1.0);
-    interpolatedTexcoord1 = vec2(texcoordMatrices[1] * vec4(texcoord1.xy, 0.0, 1.0)).xy;
-   
+    _texCoord0 = (texcoordMatrices[0] * vec4(inTexCoord0.st, 0.0, 1.0)).st;
+    _texCoord1 = (texcoordMatrices[1] * vec4(inTexCoord1.st, 0.0, 1.0)).st;
+
     // standard transform
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
-    <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$>
-    <$transformModelToEyeDir(cam, obj, inNormal, interpolatedNormal.xyz)$>
-    <$transformModelToEyeDir(cam, obj, inTangent, interpolatedTangent.xyz)$>
-
-    interpolatedNormal = vec4(normalize(interpolatedNormal.xyz), 0.0);
-    interpolatedTangent = vec4(normalize(interpolatedTangent.xyz), 0.0);
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
+    <$transformModelToEyeDir(cam, obj, inTangent.xyz, _tangent)$>
 }

libraries/render-utils/src/model_lightmap_normal_specular_map.slf

@@ -29,37 +29,33 @@ uniform sampler2D normalMap;
 // the specular map texture
 uniform sampler2D specularMap;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated tangent
-varying vec4 interpolatedTangent;
-
-varying vec2 interpolatedTexcoord1;
-
-varying vec3 color;
-
+in vec4 _position;
+in vec2 _texCoord0;
+in vec2 _texCoord1;
+in vec3 _normal;
+in vec3 _tangent;
+in vec3 _color;
 
 void main(void) {
     // compute the view normal from the various bits
-    vec3 normalizedNormal = normalize(vec3(interpolatedNormal));
-    vec3 normalizedTangent = normalize(vec3(interpolatedTangent));
+    vec3 normalizedNormal = normalize(_normal);
+    vec3 normalizedTangent = normalize(_tangent);
     vec3 normalizedBitangent = normalize(cross(normalizedNormal, normalizedTangent));
-    vec3 localNormal = vec3(texture2D(normalMap, gl_TexCoord[0].st)) - vec3(0.5, 0.5, 0.5);
+    vec3 localNormal = vec3(texture(normalMap, _texCoord0)) - vec3(0.5, 0.5, 0.5);
     vec4 viewNormal = vec4(normalizedTangent * localNormal.x +
         normalizedBitangent * localNormal.y + normalizedNormal * localNormal.z, 0.0);
     
     // set the diffuse, normal, specular data
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-    vec3 specular = texture2D(specularMap, gl_TexCoord[0].st).rgb;
-    vec4 emissive = texture2D(emissiveMap, interpolatedTexcoord1.st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
+    vec3 specular = texture(specularMap, _texCoord0).rgb;
+    vec4 emissive = texture(emissiveMap, _texCoord1);
 
     Material mat = getMaterial();
 
     packDeferredFragmentLightmap(
         normalize(viewNormal.xyz), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         specular, // no use of getMaterialSpecular(mat)
         getMaterialShininess(mat),
         (vec3(emissiveParams.x) + emissiveParams.y * emissive.rgb));

libraries/render-utils/src/model_lightmap_specular_map.slf

@@ -26,25 +26,24 @@ uniform vec2 emissiveParams;
 // the specular texture
 uniform sampler2D specularMap;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-varying vec2 interpolatedTexcoord1;
-
-varying vec3 color;
+in vec4 _position;
+in vec2 _texCoord0;
+in vec2 _texCoord1;
+in vec3 _normal;
+in vec3 _color;
 
 void main(void) {
     // set the diffuse, normal, specular data
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-    vec3 specular = texture2D(specularMap, gl_TexCoord[0].st).rgb;
-    vec4 emissive = texture2D(emissiveMap, interpolatedTexcoord1.st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
+    vec3 specular = texture(specularMap, _texCoord0).rgb;
+    vec4 emissive = texture(emissiveMap, _texCoord1);
 
     Material mat = getMaterial();
 
     packDeferredFragmentLightmap(
-        normalize(interpolatedNormal.xyz), 
+        normalize(_normal), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         specular, // no use of getMaterialSpecular(mat)
         getMaterialShininess(mat),
         (vec3(emissiveParams.x) + emissiveParams.y * emissive.rgb));

libraries/render-utils/src/model_normal_map.slf

@@ -22,31 +22,29 @@ uniform sampler2D diffuseMap;
 // the normal map texture
 uniform sampler2D normalMap;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated tangent
-varying vec4 interpolatedTangent;
-
-varying vec3 color;
+in vec4 _position;
+in vec4 _texCoord0;
+in vec4 _normal;
+in vec4 _tangent;
+in vec3 _color;
 
 void main(void) {
     // compute the view normal from the various bits
-    vec3 normalizedNormal = normalize(vec3(interpolatedNormal));
-    vec3 normalizedTangent = normalize(vec3(interpolatedTangent));
+    vec3 normalizedNormal = normalize(_normal.xyz);
+    vec3 normalizedTangent = normalize(_tangent.xyz);
     vec3 normalizedBitangent = normalize(cross(normalizedNormal, normalizedTangent));
-    vec3 localNormal = normalize(vec3(texture2D(normalMap, gl_TexCoord[0].st)) - vec3(0.5, 0.5, 0.5));
+    vec3 localNormal = normalize(vec3(texture(normalMap, _texCoord0.st)) - vec3(0.5, 0.5, 0.5));
     vec4 viewNormal = vec4(normalizedTangent * localNormal.x +
         normalizedBitangent * localNormal.y + normalizedNormal * localNormal.z, 0.0);
 
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0.st);
 
     Material mat = getMaterial();
 
     packDeferredFragment(
         normalize(viewNormal.xyz), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         getMaterialSpecular(mat),
         getMaterialShininess(mat));
 }

libraries/render-utils/src/model_normal_map.slv

@@ -2,7 +2,7 @@
 <$VERSION_HEADER$>
 //  Generated on <$_SCRIBE_DATE$>
 //
-//  model.vert
+//  model_normal_map.vert
 //  vertex shader
 //
 //  Created by Andrzej Kapolka on 10/14/13.
@@ -12,6 +12,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+<@include gpu/Inputs.slh@>
+
 <@include gpu/Transform.slh@>
 
 <$declareStandardTransform()$>
@@ -20,38 +22,23 @@ const int MAX_TEXCOORDS = 2;
 
 uniform mat4 texcoordMatrices[MAX_TEXCOORDS];
 
-// the tangent vector
-attribute vec3 tangent;
-
-// interpolated eye position
-varying vec4 interpolatedPosition;
-
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated tangent
-varying vec4 interpolatedTangent;
-
-varying vec3 color;
+out vec4 _position;
+out vec2 _texCoord0;
+out vec3 _normal;
+out vec3 _tangent;
+out vec3 _color;
 
 void main(void) {
-    // transform and store the normal and tangent for interpolation
-    //interpolatedNormal = gl_ModelViewMatrix * vec4(gl_Normal, 0.0);
-    //interpolatedTangent = gl_ModelViewMatrix * vec4(tangent, 0.0);
-    
     // pass along the diffuse color
-    color = gl_Color.xyz;
-    
+    _color = inColor.rgb;
+
     // and the texture coordinates
-    gl_TexCoord[0] = texcoordMatrices[0] * vec4(gl_MultiTexCoord0.xy, 0.0, 1.0);
-    
+    _texCoord0 = (texcoordMatrices[0] * vec4(inTexCoord0.xy, 0.0, 1.0)).st;
+
     // standard transform
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
-    <$transformModelToEyeAndClipPos(cam, obj, gl_Vertex, interpolatedPosition, gl_Position)$>
-    <$transformModelToEyeDir(cam, obj, gl_Normal, interpolatedNormal.xyz)$>
-    <$transformModelToEyeDir(cam, obj, tangent, interpolatedTangent.xyz)$>
-
-    interpolatedNormal = vec4(normalize(interpolatedNormal.xyz), 0.0);
-    interpolatedTangent = vec4(normalize(interpolatedTangent.xyz), 0.0);
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
+    <$transformModelToEyeDir(cam, obj, inTangent.xyz, _tangent)$>
 }

libraries/render-utils/src/model_normal_specular_map.slf

@@ -25,33 +25,31 @@ uniform sampler2D normalMap;
 // the specular map texture
 uniform sampler2D specularMap;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-// the interpolated tangent
-varying vec4 interpolatedTangent;
-
-varying vec3 color;
+in vec4 _position;
+in vec2 _texCoord0;
+in vec3 _normal;
+in vec3 _tangent;
+in vec3 _color;
 
 void main(void) {
     // compute the view normal from the various bits
-    vec3 normalizedNormal = normalize(vec3(interpolatedNormal));
-    vec3 normalizedTangent = normalize(vec3(interpolatedTangent));
+    vec3 normalizedNormal = normalize(_normal);
+    vec3 normalizedTangent = normalize(_tangent);
     vec3 normalizedBitangent = normalize(cross(normalizedNormal, normalizedTangent));
-    vec3 localNormal = normalize(vec3(texture2D(normalMap, gl_TexCoord[0].st)) - vec3(0.5, 0.5, 0.5));
+    vec3 localNormal = normalize(vec3(texture2D(normalMap, _texCoord0)) - vec3(0.5, 0.5, 0.5));
     vec4 viewNormal = vec4(normalizedTangent * localNormal.x +
         normalizedBitangent * localNormal.y + normalizedNormal * localNormal.z, 0.0);
     
     // set the diffuse, normal, specular data
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-    vec3 specular = texture2D(specularMap, gl_TexCoord[0].st).rgb;
+    vec4 diffuse = texture2D(diffuseMap, _texCoord0);
+    vec3 specular = texture2D(specularMap, _texCoord0).rgb;
 
     Material mat = getMaterial();
 
     packDeferredFragment(
         normalize(viewNormal.xyz), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         specular, //getMaterialSpecular(mat),
         getMaterialShininess(mat));
 }

libraries/render-utils/src/model_shadow.slf

@@ -12,7 +12,9 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+out vec4 _fragColor;
+
 void main(void) {
     // fixed color for now (we may eventually want to use texture alpha)
-    gl_FragColor = vec4(1.0, 1.0, 1.0, 0.0);
+    _fragColor = vec4(1.0, 1.0, 1.0, 0.0);
 }

libraries/render-utils/src/model_shadow.slv

@@ -1,5 +1,5 @@
-<@include gpu/Config.slh@>
-<$VERSION_HEADER$>
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
 //  Generated on <$_SCRIBE_DATE$>
 //
 //  model_shadow.vert
@@ -11,12 +11,16 @@
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
-<@include gpu/Transform.slh@>
-<$declareStandardTransform()$>
+
+<@include gpu/Inputs.slh@>
+
+<@include gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
 
 void main(void) {
-    // standard transform
-    TransformCamera cam = getTransformCamera();
-    TransformObject obj = getTransformObject();
-    <$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$>
 }

libraries/render-utils/src/model_specular_map.slf

@@ -22,22 +22,23 @@ uniform sampler2D diffuseMap;
 // the specular texture
 uniform sampler2D specularMap;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
+out vec4 _position;
+out vec2 _texCoord0;
+out vec3 _normal;
+out vec3 _color;
 
-varying vec3 color;
 
 void main(void) {
     // set the diffuse, normal, specular data
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-    vec3 specular = texture2D(specularMap, gl_TexCoord[0].st).rgb;
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
+    vec3 specular = texture(specularMap, _texCoord0).rgb;
 
     Material mat = getMaterial();
 
     packDeferredFragment(
-        normalize(interpolatedNormal.xyz), 
+        normalize(_normal), 
         evalOpaqueFinalAlpha(getMaterialOpacity(mat), diffuse.a),
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
+        getMaterialDiffuse(mat) * diffuse.rgb * _color,
         specular, //getMaterialSpecular(mat),
         getMaterialShininess(mat));
 }

libraries/render-utils/src/model_translucent.slf

@@ -11,34 +11,6 @@
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
-<!/*<@include DeferredBufferWrite.slh@>
-
-<@include model/Material.slh@>
-
-// the diffuse texture
-uniform sampler2D diffuseMap;
-
-varying vec4 interpolatedNormal;
-
-varying vec3 color;
-
-void main(void) {
-
-    // Fetch diffuse map
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
-
-    Material mat = getMaterial();
-
-    packDeferredFragmentTranslucent(
-        normalize(interpolatedNormal.xyz),
-        getMaterialOpacity(mat) * diffuse.a,
-        getMaterialDiffuse(mat) * diffuse.rgb * color,
-        getMaterialSpecular(mat),
-        getMaterialShininess(mat));
-
-    // set the diffuse data
- //   gl_FragData[0] = gl_Color * texture2D(diffuseMap, gl_TexCoord[0].st);
-}*/!>
 <@include model/Material.slh@>
 
 // Everything about global lighting
@@ -99,34 +71,31 @@ vec4 evalGlobalColor(float shadowAttenuation, vec3 position, vec3 normal, vec3 d
 // the diffuse texture
 uniform sampler2D diffuseMap;
 
-// the interpolated view position
-varying vec4 interpolatedPosition;
+in vec4 _position;
+in vec2 _texCoord0;
+in vec3 _normal;
+in vec3 _color;
 
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-varying vec3 color;
+out vec4 _fragColor;
 
 void main(void) {
-    vec3 fragPosition = interpolatedPosition.xyz;
+    vec3 fragPosition = _position.xyz;
 
     // Fetch diffuse map
-    vec4 diffuse = texture2D(diffuseMap, gl_TexCoord[0].st);
+    vec4 diffuse = texture(diffuseMap, _texCoord0);
 
     Material mat = getMaterial();
-    vec3 fragNormal = normalize(interpolatedNormal.xyz);
+    vec3 fragNormal = normalize(_normal);
     float fragOpacity = getMaterialOpacity(mat) * diffuse.a;
-    vec3 fragDiffuse = getMaterialDiffuse(mat) * diffuse.rgb * color;
+    vec3 fragDiffuse = getMaterialDiffuse(mat) * diffuse.rgb * _color;
     vec3 fragSpecular = getMaterialSpecular(mat);
     float fragGloss = getMaterialShininess(mat);
 
-    vec4 fragColor =  evalGlobalColor(1.0,
+    _fragColor =  evalGlobalColor(1.0,
                                     fragPosition,
                                     fragNormal,
                                     fragDiffuse,
                                     fragSpecular,
                                     fragGloss,
                                     fragOpacity);
-
-    gl_FragColor = fragColor;
 }

libraries/render-utils/src/point_light.slf

@@ -2,7 +2,7 @@
 <$VERSION_HEADER$>
 //  Generated on <$_SCRIBE_DATE$>
 //
-//  spot_light.frag
+//  point_light.frag
 //  fragment shader
 //
 //  Created by Andrzej Kapolka on 9/18/14.
@@ -24,9 +24,12 @@
 // The view Matrix
 uniform mat4 invViewMat;
 
+in vec4 _texCoord0;
+out vec4 _fragColor;
+
 void main(void) {
     // Grab the fragment data from the uv
-    vec2 texCoord = gl_TexCoord[0].st / gl_TexCoord[0].q;
+    vec2 texCoord = _texCoord0.st / _texCoord0.q;
     DeferredFragment frag = unpackDeferredFragment(texCoord);
       
     // Kill if in front of the light volume
@@ -62,14 +65,14 @@ void main(void) {
 
     // Final Lighting color
     vec3 fragColor = shading.w * (frag.diffuse + shading.xyz);
-    gl_FragColor = vec4(fragColor * radialAttenuation * getLightColor(light) * getLightIntensity(light), 0.0);
+    _fragColor = vec4(fragColor * radialAttenuation * getLightColor(light) * getLightIntensity(light), 0.0);
 
     if (getLightShowContour(light) > 0.0) {
         // Show edge
         float edge =  abs(2.0 * ((getLightRadius(light) - fragLightDistance) / (0.1)) - 1.0);
         if (edge < 1) {
             float edgeCoord = exp2(-8.0*edge*edge);
-            gl_FragColor = vec4(edgeCoord * edgeCoord * getLightShowContour(light) * getLightColor(light), 0.0);
+            _fragColor = vec4(edgeCoord * edgeCoord * getLightShowContour(light) * getLightColor(light), 0.0);
         }
     }
 }

libraries/render-utils/src/skin_model.slv

@@ -12,7 +12,10 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+<@include gpu/Inputs.slh@>
+
 <@include gpu/Transform.slh@>
+
 <$declareStandardTransform()$>
 
 const int MAX_TEXCOORDS = 2;
@@ -22,38 +25,31 @@ const int INDICES_PER_VERTEX = 4;
 uniform mat4 clusterMatrices[MAX_CLUSTERS];
 uniform mat4 texcoordMatrices[MAX_TEXCOORDS];
 
-attribute vec4 clusterIndices;
-attribute vec4 clusterWeights;
-
-// interpolated eye position
-varying vec4 interpolatedPosition;
-
-// the interpolated normal
-varying vec4 interpolatedNormal;
-
-varying vec3 color;
+out vec4 _position;
+out vec2 _texCoord0;
+out vec3 _normal;
+out vec3 _color;
 
 void main(void) {
     vec4 position = vec4(0.0, 0.0, 0.0, 0.0);
-    interpolatedNormal = vec4(0.0, 0.0, 0.0, 0.0);
+    vec4 interpolatedNormal = vec4(0.0, 0.0, 0.0, 0.0);
     for (int i = 0; i < INDICES_PER_VERTEX; i++) {
-        mat4 clusterMatrix = clusterMatrices[int(clusterIndices[i])];
-        float clusterWeight = clusterWeights[i];
-        position += clusterMatrix * gl_Vertex * clusterWeight;
-        interpolatedNormal += clusterMatrix * vec4(gl_Normal, 0.0) * clusterWeight;
+        mat4 clusterMatrix = clusterMatrices[inSkinClusterIndex[i])];
+        float clusterWeight = inSkinClusterWeight[i].x;
+        position += clusterMatrix * inPosition * clusterWeight;
+        interpolatedNormal += clusterMatrix * vec4(inNormal.xyz, 0.0) * clusterWeight;
     }
 
     // pass along the diffuse color
-    color = gl_Color.xyz;
+    _color = gl_Color.xyz;
 
     // and the texture coordinates
-    gl_TexCoord[0] = texcoordMatrices[0] * vec4(gl_MultiTexCoord0.xy, 0.0, 1.0);
+    _texCoord0[0] = texcoordMatrices[0] * vec4(inTexCoord0.st, 0.0, 1.0);
     
     // standard transform
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
-    <$transformModelToEyeAndClipPos(cam, obj, position, interpolatedPosition, gl_Position)$>
+    <$transformModelToEyeAndClipPos(cam, obj, position, _position, gl_Position)$>
     <$transformModelToEyeDir(cam, obj, interpolatedNormal.xyz, interpolatedNormal.xyz)$>
-
-    interpolatedNormal = vec4(normalize(interpolatedNormal.xyz), 0.0);
+    _normal = interpolatedNormal.xyz;
 }

libraries/render-utils/src/spot_light.slf

@@ -24,9 +24,12 @@
 // The view Matrix
 uniform mat4 invViewMat;
 
+in vec4 _texCoord0;
+out vec4 _fragColor;
+
 void main(void) {
     // Grab the fragment data from the uv
-    vec2 texCoord = gl_TexCoord[0].st / gl_TexCoord[0].q;
+    vec2 texCoord = _texCoord0.st / _texCoord0.q;
     DeferredFragment frag = unpackDeferredFragment(texCoord);
       
     // Kill if in front of the light volume
@@ -70,7 +73,7 @@ void main(void) {
 
     // Final Lighting color
     vec3 fragColor = shading.w * (frag.diffuse + shading.xyz);
-    gl_FragColor = vec4(fragColor * angularAttenuation * radialAttenuation * getLightColor(light) * getLightIntensity(light), 0.0);
+    _fragColor = vec4(fragColor * angularAttenuation * radialAttenuation * getLightColor(light) * getLightIntensity(light), 0.0);
 
     if (getLightShowContour(light) > 0.0) {
         // Show edges
@@ -80,7 +83,7 @@ void main(void) {
         float edge =  abs(2.0 * (edgeDist / (0.1)) - 1.0);
         if (edge < 1) {
             float edgeCoord = exp2(-8.0*edge*edge);
-            gl_FragColor = vec4(edgeCoord * edgeCoord * getLightColor(light), 0.0);
+            _fragColor = vec4(edgeCoord * edgeCoord * getLightColor(light), 0.0);
         }
     }
 }

libraries/render-utils/src/standardDrawTexture.slf

@@ -14,11 +14,12 @@
 // the texture
 uniform sampler2D colorMap;
 
-varying vec2 varTexcoord;
-varying vec4 varColor;
+in vec2 varTexcoord;
+in vec4 varColor;
 
+out vec4 _fragColor;
 
 void main(void) {
-    vec4 color = texture2D(colorMap, varTexcoord);
-    gl_FragColor = color * varColor;
+    vec4 color = texture(colorMap, varTexcoord);
+    _fragColor = color * varColor;
 }

libraries/render-utils/src/standardTransformPNTC.slv

@@ -16,14 +16,14 @@
 
 <$declareStandardTransform()$>
 
-varying vec3 varPosition;
-varying vec3 varNormal;
-varying vec2 varTexcoord;
-varying vec4 varColor;
+out vec3 varPosition;
+out vec3 varNormal;
+out vec2 varTexcoord;
+out vec4 varColor;
 
 void main(void) {
-    varTexcoord = gl_MultiTexCoord0.xy;
-    varColor = gl_Color;
+    varTexcoord = inTexCoord0.st;
+    varColor = inColor;
     
     // standard transform
     TransformCamera cam = getTransformCamera();
@@ -31,5 +31,5 @@ void main(void) {
     <$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>
     <$transformModelToEyeDir(cam, obj, gl_Normal, varNormal)$>
     varNormal = normalize(varNormal);
-    varPosition = gl_Vertex.xyz;
+    varPosition = inPosition.xyz;
 }

tests/render-utils/src/main.cpp

@@ -73,6 +73,28 @@
 #include "point_light_frag.h"
 #include "spot_light_frag.h"
 
+#include "standardTransformPNTC_vert.h"
+#include "standardDrawTexture_frag.h"
+
+#include "model_vert.h"
+#include "model_shadow_vert.h"
+#include "model_normal_map_vert.h"
+#include "model_lightmap_vert.h"
+#include "model_lightmap_normal_map_vert.h"
+#include "skin_model_vert.h"
+#include "skin_model_shadow_vert.h"
+#include "skin_model_normal_map_vert.h"
+
+#include "model_frag.h"
+#include "model_shadow_frag.h"
+#include "model_normal_map_frag.h"
+#include "model_normal_specular_map_frag.h"
+#include "model_specular_map_frag.h"
+#include "model_lightmap_frag.h"
+#include "model_lightmap_normal_map_frag.h"
+#include "model_lightmap_normal_specular_map_frag.h"
+#include "model_lightmap_specular_map_frag.h"
+#include "model_translucent_frag.h"
 
 class RateCounter {
     std::vector<float> times;
@@ -308,8 +330,28 @@ void QTestWindow::draw() {
         testShaderBuild(deferred_light_vert, directional_skybox_light_cascaded_shadow_map_frag);
         testShaderBuild(deferred_light_limited_vert, point_light_frag);
         testShaderBuild(deferred_light_limited_vert, spot_light_frag);
+        testShaderBuild(standardTransformPNTC_vert, standardDrawTexture_frag);
 
-   });
+        testShaderBuild(model_vert, model_frag);
+        testShaderBuild(model_normal_map_vert, model_normal_map_frag);
+        testShaderBuild(model_vert, model_specular_map_frag);
+        testShaderBuild(model_normal_map_vert, model_normal_specular_map_frag);
+        testShaderBuild(model_vert, model_translucent_frag);
+        testShaderBuild(model_normal_map_vert, model_translucent_frag);
+        testShaderBuild(model_lightmap_vert, model_lightmap_frag);
+        testShaderBuild(model_lightmap_normal_map_vert, model_lightmap_normal_map_frag);
+        testShaderBuild(model_lightmap_vert, model_lightmap_specular_map_frag);
+        testShaderBuild(model_lightmap_normal_map_vert, model_lightmap_normal_specular_map_frag);
+
+        testShaderBuild(skin_model_vert, model_frag);
+        testShaderBuild(skin_model_normal_map_vert, model_normal_map_frag);
+        testShaderBuild(skin_model_vert, model_specular_map_frag);
+        testShaderBuild(skin_model_normal_map_vert, model_normal_specular_map_frag);
+        testShaderBuild(skin_model_vert, model_translucent_frag);
+        testShaderBuild(skin_model_normal_map_vert, model_translucent_frag);
+
+        testShaderBuild(model_shadow_vert, model_shadow_frag);
+    });
     //    renderText();
 
     _context->swapBuffers(this);