OpenGL2: Calculate bitangent in shader, and store normal/tangent as normalized byte arrays.

15 files changed, 269 insertions, 272 deletions

diff --git a/src/renderergl2/glsl/generic_vp.glsl b/src/renderergl2/glsl/generic_vp.glsl
index 94e3c83e..baae6046 100644
--- a/src/renderergl2/glsl/generic_vp.glsl
+++ b/src/renderergl2/glsl/generic_vp.glsl
@@ -1,8 +1,8 @@
-attribute vec4 attr_Position;
+attribute vec3 attr_Position;
 attribute vec3 attr_Normal;
 
 #if defined(USE_VERTEX_ANIMATION)
-attribute vec4 attr_Position2;
+attribute vec3 attr_Position2;
 attribute vec3 attr_Normal2;
 #endif
 
@@ -167,7 +167,7 @@ vec4 CalcColor(vec3 position, vec3 normal)
 
 	if (u_AlphaGen == AGEN_LIGHTING_SPECULAR)
 	{
-		vec3 lightDir = normalize(vec3(-960.0, 1980.0, 96.0) - position.xyz);
+		vec3 lightDir = normalize(vec3(-960.0, 1980.0, 96.0) - position);
 		vec3 reflected = -reflect(lightDir, normal);
 		
 		color.a = clamp(dot(reflected, normalize(viewer)), 0.0, 1.0);
@@ -184,10 +184,10 @@ vec4 CalcColor(vec3 position, vec3 normal)
 #endif
 
 #if defined(USE_FOG)
-float CalcFog(vec4 position)
+float CalcFog(vec3 position)
 {
-	float s = dot(position, u_FogDistance) * 8.0;
-	float t = dot(position, u_FogDepth);
+	float s = (dot(position, u_FogDistance.xyz) + u_FogDistance.w) * 8.0;
+	float t = dot(position, u_FogDepth.xyz) + u_FogDepth.w;
 
 	float eyeOutside = step(0.0, -u_FogEyeT);
 	float fogged = step(eyeOutside, t);
@@ -202,27 +202,27 @@ float CalcFog(vec4 position)
 void main()
 {
 #if defined(USE_VERTEX_ANIMATION)
-	vec4 position = mix(attr_Position, attr_Position2, u_VertexLerp);
-	vec3 normal = normalize(mix(attr_Normal, attr_Normal2, u_VertexLerp));
+	vec3 position  = mix(attr_Position,  attr_Position2,  u_VertexLerp);
+	vec3 normal    = normalize(mix(attr_Normal,    attr_Normal2,    u_VertexLerp) * 2.0 - vec3(1.0));
 #else
-	vec4 position = attr_Position;
-	vec3 normal = attr_Normal;
+	vec3 position  = attr_Position;
+	vec3 normal    = attr_Normal * 2.0 - vec3(1.0);
 #endif
 
 #if defined(USE_DEFORM_VERTEXES)
-	position.xyz = DeformPosition(position.xyz, normal, attr_TexCoord0.st);
+	position = DeformPosition(position, normal, attr_TexCoord0.st);
 #endif
 
-	gl_Position = u_ModelViewProjectionMatrix * position;
+	gl_Position = u_ModelViewProjectionMatrix * vec4(position, 1.0);
 
 #if defined(USE_TCGEN)
-	vec2 tex = GenTexCoords(u_TCGen0, position.xyz, normal, u_TCGen0Vector0, u_TCGen0Vector1);
+	vec2 tex = GenTexCoords(u_TCGen0, position, normal, u_TCGen0Vector0, u_TCGen0Vector1);
 #else
 	vec2 tex = attr_TexCoord0.st;
 #endif
 
 #if defined(USE_TCMOD)
-	var_DiffuseTex = ModTexCoords(tex, position.xyz, u_DiffuseTexMatrix, u_DiffuseTexOffTurb);
+	var_DiffuseTex = ModTexCoords(tex, position, u_DiffuseTexMatrix, u_DiffuseTexOffTurb);
 #else
     var_DiffuseTex = tex;
 #endif
@@ -232,7 +232,7 @@ void main()
 #endif
 
 #if defined(USE_RGBAGEN)
-	var_Color = CalcColor(position.xyz, normal);
+	var_Color = CalcColor(position, normal);
 #else
 	var_Color = u_VertColor * attr_Color + u_BaseColor;
 #endif
diff --git a/src/renderergl2/glsl/lightall_vp.glsl b/src/renderergl2/glsl/lightall_vp.glsl
index aa0fe25b..f6164957 100644
--- a/src/renderergl2/glsl/lightall_vp.glsl
+++ b/src/renderergl2/glsl/lightall_vp.glsl
@@ -7,8 +7,7 @@ attribute vec4 attr_Color;
 attribute vec3 attr_Position;
 attribute vec3 attr_Normal;
 #if defined(USE_VERT_TANGENT_SPACE)
-attribute vec3 attr_Tangent;
-attribute vec3 attr_Bitangent;
+attribute vec4 attr_Tangent;
 #endif
 
 #if defined(USE_VERTEX_ANIMATION)
@@ -163,21 +162,24 @@ float CalcLightAttenuation(vec3 dir, float sqrRadius)
 void main()
 {
 #if defined(USE_VERTEX_ANIMATION)
-	vec3 position  =           mix(attr_Position,  attr_Position2,  u_VertexLerp);
-	vec3 normal    = normalize(mix(attr_Normal,    attr_Normal2,    u_VertexLerp));
-  #if defined(USE_VERT_TANGENT_SPACE)
-	vec3 tangent   = normalize(mix(attr_Tangent,   attr_Tangent2,   u_VertexLerp));
-	vec3 bitangent = normalize(mix(attr_Bitangent, attr_Bitangent2, u_VertexLerp));
+	vec3 position  = mix(attr_Position,  attr_Position2,  u_VertexLerp);
+	vec3 normal    = normalize(mix(attr_Normal,    attr_Normal2,    u_VertexLerp) * 2.0 - vec3(1.0));
+  #if defined(USE_VERT_TANGENT_SPACE) && defined(USE_LIGHT) && !defined(USE_FAST_LIGHT)
+	vec3 tangent   = normalize(mix(attr_Tangent.xyz,   attr_Tangent2.xyz,   u_VertexLerp) * 2.0 - vec3(1.0));
   #endif
 #else
 	vec3 position  = attr_Position;
-	vec3 normal    = attr_Normal;
-  #if defined(USE_VERT_TANGENT_SPACE)
-	vec3 tangent   = attr_Tangent;
-	vec3 bitangent = attr_Bitangent;
+	vec3 normal    = attr_Normal    * 2.0 - vec3(1.0);
+  #if defined(USE_VERT_TANGENT_SPACE) && defined(USE_LIGHT) && !defined(USE_FAST_LIGHT)
+	vec3 tangent   = attr_Tangent.xyz * 2.0 - vec3(1.0);
   #endif
 #endif
 
+#if defined(USE_VERT_TANGENT_SPACE) && defined(USE_LIGHT) && !defined(USE_FAST_LIGHT)
+  vec3 bitangent = cross(normal, tangent);
+  bitangent *= attr_Tangent.w * 2.0 - 1.0;
+#endif
+
 #if defined(USE_TCGEN)
 	vec2 texCoords = GenTexCoords(u_TCGen0, position, normal, u_TCGen0Vector0, u_TCGen0Vector1);
 #else
diff --git a/src/renderergl2/tr_animation.c b/src/renderergl2/tr_animation.c
index 5ec58903..430fd9f8 100644
--- a/src/renderergl2/tr_animation.c
+++ b/src/renderergl2/tr_animation.c
@@ -153,9 +153,9 @@ void RB_SurfaceAnim( md4Surface_t *surface ) {
 		tess.xyz[baseVertex + j][1] = tempVert[1];
 		tess.xyz[baseVertex + j][2] = tempVert[2];
 
-		tess.normal[baseVertex + j][0] = tempNormal[0];
-		tess.normal[baseVertex + j][1] = tempNormal[1];
-		tess.normal[baseVertex + j][2] = tempNormal[2];
+		tess.normal[baseVertex + j][0] = (uint8_t)(tempNormal[0] * 127.5f + 128.0f);
+		tess.normal[baseVertex + j][1] = (uint8_t)(tempNormal[1] * 127.5f + 128.0f);
+		tess.normal[baseVertex + j][2] = (uint8_t)(tempNormal[2] * 127.5f + 128.0f);
 
 		tess.texCoords[baseVertex + j][0][0] = v->texCoords[0];
 		tess.texCoords[baseVertex + j][0][1] = v->texCoords[1];
@@ -549,9 +549,9 @@ void RB_MDRSurfaceAnim( md4Surface_t *surface )
 		tess.xyz[baseVertex + j][1] = tempVert[1];
 		tess.xyz[baseVertex + j][2] = tempVert[2];
 
-		tess.normal[baseVertex + j][0] = tempNormal[0];
-		tess.normal[baseVertex + j][1] = tempNormal[1];
-		tess.normal[baseVertex + j][2] = tempNormal[2];
+		tess.normal[baseVertex + j][0] = (uint8_t)(tempNormal[0] * 127.5f + 128.0f);
+		tess.normal[baseVertex + j][1] = (uint8_t)(tempNormal[1] * 127.5f + 128.0f);
+		tess.normal[baseVertex + j][2] = (uint8_t)(tempNormal[2] * 127.5f + 128.0f);
 
 		tess.texCoords[baseVertex + j][0][0] = v->texCoords[0];
 		tess.texCoords[baseVertex + j][0][1] = v->texCoords[1];
diff --git a/src/renderergl2/tr_bsp.c b/src/renderergl2/tr_bsp.c
index 26d7fa50..082a0b9b 100644
--- a/src/renderergl2/tr_bsp.c
+++ b/src/renderergl2/tr_bsp.c
@@ -1811,12 +1811,14 @@ static void CopyVert(const srfVert_t * in, srfVert_t * out)
 		out->xyz[j]       = in->xyz[j];
 #ifdef USE_VERT_TANGENT_SPACE
 		out->tangent[j]   = in->tangent[j];
-		out->bitangent[j] = in->bitangent[j];
+		//out->bitangent[j] = in->bitangent[j];
 #endif
 		out->normal[j]    = in->normal[j];
 		out->lightdir[j]  = in->lightdir[j];
 	}
 
+	out->tangent[3] = in->tangent[3];
+
 	for(j = 0; j < 2; j++)
 	{
 		out->st[j] = in->st[j];
@@ -2001,7 +2003,7 @@ static void R_CreateWorldVBOs(void)
 
 #ifdef USE_VERT_TANGENT_SPACE
 		vbo = R_CreateVBO2(va("staticBspModel0_VBO %i", k), numVerts, verts,
-									   ATTR_POSITION | ATTR_TEXCOORD | ATTR_LIGHTCOORD | ATTR_TANGENT | ATTR_BITANGENT |
+									   ATTR_POSITION | ATTR_TEXCOORD | ATTR_LIGHTCOORD | ATTR_TANGENT |
 									   ATTR_NORMAL | ATTR_COLOR | ATTR_LIGHTDIRECTION, VBO_USAGE_STATIC);
 #else
 		vbo = R_CreateVBO2(va("staticBspModel0_VBO %i", k), numVerts, verts,
diff --git a/src/renderergl2/tr_curve.c b/src/renderergl2/tr_curve.c
index 4c5474b1..c70dee3c 100644
--- a/src/renderergl2/tr_curve.c
+++ b/src/renderergl2/tr_curve.c
@@ -248,8 +248,7 @@ static void MakeMeshTangentVectors(int width, int height, srfVert_t ctrl[MAX_GRI
 			dv[0] = &ctrl2[j * width + i];
 			dv[1] = &ctrl[j][i];
 
-			VectorCopy(dv[0]->tangent, dv[1]->tangent);
-			VectorCopy(dv[0]->bitangent, dv[1]->bitangent);
+			VectorCopy4(dv[0]->tangent, dv[1]->tangent);
 		}
 	}
 }
diff --git a/src/renderergl2/tr_glsl.c b/src/renderergl2/tr_glsl.c
index d67744f8..d0573b97 100644
--- a/src/renderergl2/tr_glsl.c
+++ b/src/renderergl2/tr_glsl.c
@@ -528,9 +528,6 @@ static int GLSL_InitGPUShader2(shaderProgram_t * program, const char *name, int
 #ifdef USE_VERT_TANGENT_SPACE
 	if(attribs & ATTR_TANGENT)
 		qglBindAttribLocationARB(program->program, ATTR_INDEX_TANGENT, "attr_Tangent");
-
-	if(attribs & ATTR_BITANGENT)
-		qglBindAttribLocationARB(program->program, ATTR_INDEX_BITANGENT, "attr_Bitangent");
 #endif
 
 	if(attribs & ATTR_NORMAL)
@@ -554,9 +551,6 @@ static int GLSL_InitGPUShader2(shaderProgram_t * program, const char *name, int
 #ifdef USE_VERT_TANGENT_SPACE
 	if(attribs & ATTR_TANGENT2)
 		qglBindAttribLocationARB(program->program, ATTR_INDEX_TANGENT2, "attr_Tangent2");
-
-	if(attribs & ATTR_BITANGENT2)
-		qglBindAttribLocationARB(program->program, ATTR_INDEX_BITANGENT2, "attr_Bitangent2");
 #endif
 
 	GLSL_LinkProgram(program->program);
@@ -1069,7 +1063,7 @@ void GLSL_InitGPUShaders(void)
 
 #ifdef USE_VERT_TANGENT_SPACE
 				Q_strcat(extradefines, 1024, "#define USE_VERT_TANGENT_SPACE\n");
-				attribs |= ATTR_TANGENT | ATTR_BITANGENT;
+				attribs |= ATTR_TANGENT;
 #endif
 
 				if ((i & LIGHTDEF_USE_PARALLAXMAP) && !(i & LIGHTDEF_ENTITY) && r_parallaxMapping->integer)
@@ -1133,7 +1127,7 @@ void GLSL_InitGPUShaders(void)
 #ifdef USE_VERT_TANGENT_SPACE
 			if (r_normalMapping->integer)
 			{
-				attribs |= ATTR_TANGENT2 | ATTR_BITANGENT2;
+				attribs |= ATTR_TANGENT2;
 			}
 #endif
 		}
@@ -1400,12 +1394,10 @@ void GLSL_ShutdownGPUShaders(void)
 	qglDisableVertexAttribArrayARB(ATTR_INDEX_NORMAL);
 #ifdef USE_VERT_TANGENT_SPACE
 	qglDisableVertexAttribArrayARB(ATTR_INDEX_TANGENT);
-	qglDisableVertexAttribArrayARB(ATTR_INDEX_BITANGENT);
 #endif
 	qglDisableVertexAttribArrayARB(ATTR_INDEX_NORMAL2);
 #ifdef USE_VERT_TANGENT_SPACE
 	qglDisableVertexAttribArrayARB(ATTR_INDEX_TANGENT2);
-	qglDisableVertexAttribArrayARB(ATTR_INDEX_BITANGENT2);
 #endif
 	qglDisableVertexAttribArrayARB(ATTR_INDEX_COLOR);
 	qglDisableVertexAttribArrayARB(ATTR_INDEX_LIGHTDIRECTION);
@@ -1565,20 +1557,6 @@ void GLSL_VertexAttribsState(uint32_t stateBits)
 			qglDisableVertexAttribArrayARB(ATTR_INDEX_TANGENT);
 		}
 	}
-
-	if(diff & ATTR_BITANGENT)
-	{
-		if(stateBits & ATTR_BITANGENT)
-		{
-			GLimp_LogComment("qglEnableVertexAttribArrayARB( ATTR_INDEX_BITANGENT )\n");
-			qglEnableVertexAttribArrayARB(ATTR_INDEX_BITANGENT);
-		}
-		else
-		{
-			GLimp_LogComment("qglDisableVertexAttribArrayARB( ATTR_INDEX_BITANGENT )\n");
-			qglDisableVertexAttribArrayARB(ATTR_INDEX_BITANGENT);
-		}
-	}
 #endif
 
 	if(diff & ATTR_COLOR)
@@ -1651,20 +1629,6 @@ void GLSL_VertexAttribsState(uint32_t stateBits)
 			qglDisableVertexAttribArrayARB(ATTR_INDEX_TANGENT2);
 		}
 	}
-
-	if(diff & ATTR_BITANGENT2)
-	{
-		if(stateBits & ATTR_BITANGENT2)
-		{
-			GLimp_LogComment("qglEnableVertexAttribArrayARB( ATTR_INDEX_BITANGENT2 )\n");
-			qglEnableVertexAttribArrayARB(ATTR_INDEX_BITANGENT2);
-		}
-		else
-		{
-			GLimp_LogComment("qglDisableVertexAttribArrayARB( ATTR_INDEX_BITANGENT2 )\n");
-			qglDisableVertexAttribArrayARB(ATTR_INDEX_BITANGENT2);
-		}
-	}
 #endif
 
 	glState.vertexAttribsState = stateBits;
@@ -1674,17 +1638,18 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 {
 	qboolean animated;
 	int newFrame, oldFrame;
+	VBO_t *vbo = glState.currentVBO;
 	
-	if(!glState.currentVBO)
+	if(!vbo)
 	{
 		ri.Error(ERR_FATAL, "GL_VertexAttribPointers: no VBO bound");
 		return;
 	}
 
 	// don't just call LogComment, or we will get a call to va() every frame!
-	GLimp_LogComment(va("--- GL_VertexAttribPointers( %s ) ---\n", glState.currentVBO->name));
+	GLimp_LogComment(va("--- GL_VertexAttribPointers( %s ) ---\n", vbo->name));
 
-	// position/normal/tangent/bitangent are always set in case of animation
+	// position/normal/tangent are always set in case of animation
 	oldFrame = glState.vertexAttribsOldFrame;
 	newFrame = glState.vertexAttribsNewFrame;
 	animated = glState.vertexAnimation;
@@ -1693,7 +1658,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_POSITION )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_POSITION, 3, GL_FLOAT, 0, glState.currentVBO->stride_xyz, BUFFER_OFFSET(glState.currentVBO->ofs_xyz + newFrame * glState.currentVBO->size_xyz));
+		qglVertexAttribPointerARB(ATTR_INDEX_POSITION, 3, GL_FLOAT, 0, vbo->stride_xyz, BUFFER_OFFSET(vbo->ofs_xyz + newFrame * vbo->size_xyz));
 		glState.vertexAttribPointersSet |= ATTR_POSITION;
 	}
 
@@ -1701,7 +1666,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_TEXCOORD )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_TEXCOORD0, 2, GL_FLOAT, 0, glState.currentVBO->stride_st, BUFFER_OFFSET(glState.currentVBO->ofs_st));
+		qglVertexAttribPointerARB(ATTR_INDEX_TEXCOORD0, 2, GL_FLOAT, 0, vbo->stride_st, BUFFER_OFFSET(vbo->ofs_st));
 		glState.vertexAttribPointersSet |= ATTR_TEXCOORD;
 	}
 
@@ -1709,7 +1674,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_LIGHTCOORD )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_TEXCOORD1, 2, GL_FLOAT, 0, glState.currentVBO->stride_lightmap, BUFFER_OFFSET(glState.currentVBO->ofs_lightmap));
+		qglVertexAttribPointerARB(ATTR_INDEX_TEXCOORD1, 2, GL_FLOAT, 0, vbo->stride_lightmap, BUFFER_OFFSET(vbo->ofs_lightmap));
 		glState.vertexAttribPointersSet |= ATTR_LIGHTCOORD;
 	}
 
@@ -1717,7 +1682,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_NORMAL )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_NORMAL, 3, GL_FLOAT, 0, glState.currentVBO->stride_normal, BUFFER_OFFSET(glState.currentVBO->ofs_normal + newFrame * glState.currentVBO->size_normal));
+		qglVertexAttribPointerARB(ATTR_INDEX_NORMAL, 3, GL_UNSIGNED_BYTE, GL_TRUE, vbo->stride_normal, BUFFER_OFFSET(vbo->ofs_normal + newFrame * vbo->size_normal));
 		glState.vertexAttribPointersSet |= ATTR_NORMAL;
 	}
 
@@ -1726,24 +1691,16 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_TANGENT )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_TANGENT, 3, GL_FLOAT, 0, glState.currentVBO->stride_tangent, BUFFER_OFFSET(glState.currentVBO->ofs_tangent + newFrame * glState.currentVBO->size_normal)); // FIXME
+		qglVertexAttribPointerARB(ATTR_INDEX_TANGENT, 4, GL_UNSIGNED_BYTE, GL_TRUE, vbo->stride_tangent, BUFFER_OFFSET(vbo->ofs_tangent + newFrame * vbo->size_normal)); // FIXME
 		glState.vertexAttribPointersSet |= ATTR_TANGENT;
 	}
-
-	if((attribBits & ATTR_BITANGENT) && (!(glState.vertexAttribPointersSet & ATTR_BITANGENT) || animated))
-	{
-		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_BITANGENT )\n");
-
-		qglVertexAttribPointerARB(ATTR_INDEX_BITANGENT, 3, GL_FLOAT, 0, glState.currentVBO->stride_bitangent, BUFFER_OFFSET(glState.currentVBO->ofs_bitangent + newFrame * glState.currentVBO->size_normal)); // FIXME
-		glState.vertexAttribPointersSet |= ATTR_BITANGENT;
-	}
 #endif
 
 	if((attribBits & ATTR_COLOR) && !(glState.vertexAttribPointersSet & ATTR_COLOR))
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_COLOR )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_COLOR, 4, GL_FLOAT, 0, glState.currentVBO->stride_vertexcolor, BUFFER_OFFSET(glState.currentVBO->ofs_vertexcolor));
+		qglVertexAttribPointerARB(ATTR_INDEX_COLOR, 4, GL_FLOAT, 0, vbo->stride_vertexcolor, BUFFER_OFFSET(vbo->ofs_vertexcolor));
 		glState.vertexAttribPointersSet |= ATTR_COLOR;
 	}
 
@@ -1751,7 +1708,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_LIGHTDIRECTION )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_LIGHTDIRECTION, 3, GL_FLOAT, 0, glState.currentVBO->stride_lightdir, BUFFER_OFFSET(glState.currentVBO->ofs_lightdir));
+		qglVertexAttribPointerARB(ATTR_INDEX_LIGHTDIRECTION, 3, GL_FLOAT, 0, vbo->stride_lightdir, BUFFER_OFFSET(vbo->ofs_lightdir));
 		glState.vertexAttribPointersSet |= ATTR_LIGHTDIRECTION;
 	}
 
@@ -1759,7 +1716,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_POSITION2 )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_POSITION2, 3, GL_FLOAT, 0, glState.currentVBO->stride_xyz, BUFFER_OFFSET(glState.currentVBO->ofs_xyz + oldFrame * glState.currentVBO->size_xyz));
+		qglVertexAttribPointerARB(ATTR_INDEX_POSITION2, 3, GL_FLOAT, 0, vbo->stride_xyz, BUFFER_OFFSET(vbo->ofs_xyz + oldFrame * vbo->size_xyz));
 		glState.vertexAttribPointersSet |= ATTR_POSITION2;
 	}
 
@@ -1767,7 +1724,7 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_NORMAL2 )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_NORMAL2, 3, GL_FLOAT, 0, glState.currentVBO->stride_normal, BUFFER_OFFSET(glState.currentVBO->ofs_normal + oldFrame * glState.currentVBO->size_normal));
+		qglVertexAttribPointerARB(ATTR_INDEX_NORMAL2, 3, GL_UNSIGNED_BYTE, GL_TRUE, vbo->stride_normal, BUFFER_OFFSET(vbo->ofs_normal + oldFrame * vbo->size_normal));
 		glState.vertexAttribPointersSet |= ATTR_NORMAL2;
 	}
 
@@ -1776,17 +1733,9 @@ void GLSL_VertexAttribPointers(uint32_t attribBits)
 	{
 		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_TANGENT2 )\n");
 
-		qglVertexAttribPointerARB(ATTR_INDEX_TANGENT2, 3, GL_FLOAT, 0, glState.currentVBO->stride_tangent, BUFFER_OFFSET(glState.currentVBO->ofs_tangent + oldFrame * glState.currentVBO->size_normal)); // FIXME
+		qglVertexAttribPointerARB(ATTR_INDEX_TANGENT2, 4, GL_UNSIGNED_BYTE, GL_TRUE, vbo->stride_tangent, BUFFER_OFFSET(vbo->ofs_tangent + oldFrame * vbo->size_normal)); // FIXME
 		glState.vertexAttribPointersSet |= ATTR_TANGENT2;
 	}
-
-	if((attribBits & ATTR_BITANGENT2) && (!(glState.vertexAttribPointersSet & ATTR_BITANGENT2) || animated))
-	{
-		GLimp_LogComment("qglVertexAttribPointerARB( ATTR_INDEX_BITANGENT2 )\n");
-
-		qglVertexAttribPointerARB(ATTR_INDEX_BITANGENT2, 3, GL_FLOAT, 0, glState.currentVBO->stride_bitangent, BUFFER_OFFSET(glState.currentVBO->ofs_bitangent + oldFrame * glState.currentVBO->size_normal)); // FIXME
-		glState.vertexAttribPointersSet |= ATTR_BITANGENT2;
-	}
 #endif
 
 }
diff --git a/src/renderergl2/tr_local.h b/src/renderergl2/tr_local.h
index b56fdf0d..557b285e 100644
--- a/src/renderergl2/tr_local.h
+++ b/src/renderergl2/tr_local.h
@@ -117,7 +117,6 @@ typedef struct VBO_s
 	uint32_t        ofs_lightdir;
 #ifdef USE_VERT_TANGENT_SPACE
 	uint32_t        ofs_tangent;
-	uint32_t        ofs_bitangent;
 #endif
 	uint32_t        stride_xyz;
 	uint32_t        stride_normal;
@@ -127,7 +126,6 @@ typedef struct VBO_s
 	uint32_t        stride_lightdir;
 #ifdef USE_VERT_TANGENT_SPACE
 	uint32_t        stride_tangent;
-	uint32_t        stride_bitangent;
 #endif
 	uint32_t        size_xyz;
 	uint32_t        size_normal;
@@ -516,19 +514,17 @@ enum
 	ATTR_INDEX_TEXCOORD0      = 1,
 	ATTR_INDEX_TEXCOORD1      = 2,
 	ATTR_INDEX_TANGENT        = 3,
-	ATTR_INDEX_BITANGENT      = 4,
-	ATTR_INDEX_NORMAL         = 5,
-	ATTR_INDEX_COLOR          = 6,
-	ATTR_INDEX_PAINTCOLOR     = 7,
-	ATTR_INDEX_LIGHTDIRECTION = 8,
-	ATTR_INDEX_BONE_INDEXES   = 9,
-	ATTR_INDEX_BONE_WEIGHTS   = 10,
+	ATTR_INDEX_NORMAL         = 4,
+	ATTR_INDEX_COLOR          = 5,
+	ATTR_INDEX_PAINTCOLOR     = 6,
+	ATTR_INDEX_LIGHTDIRECTION = 7,
+	ATTR_INDEX_BONE_INDEXES   = 8,
+	ATTR_INDEX_BONE_WEIGHTS   = 9,
 
 	// GPU vertex animations
-	ATTR_INDEX_POSITION2      = 11,
-	ATTR_INDEX_TANGENT2       = 12,
-	ATTR_INDEX_BITANGENT2     = 13,
-	ATTR_INDEX_NORMAL2        = 14
+	ATTR_INDEX_POSITION2      = 10,
+	ATTR_INDEX_TANGENT2       = 11,
+	ATTR_INDEX_NORMAL2        = 12
 };
 
 enum
@@ -614,26 +610,23 @@ enum
 	ATTR_TEXCOORD =       0x0002,
 	ATTR_LIGHTCOORD =     0x0004,
 	ATTR_TANGENT =        0x0008,
-	ATTR_BITANGENT =      0x0010,
-	ATTR_NORMAL =         0x0020,
-	ATTR_COLOR =          0x0040,
-	ATTR_PAINTCOLOR =     0x0080,
-	ATTR_LIGHTDIRECTION = 0x0100,
-	ATTR_BONE_INDEXES =   0x0200,
-	ATTR_BONE_WEIGHTS =   0x0400,
+	ATTR_NORMAL =         0x0010,
+	ATTR_COLOR =          0x0020,
+	ATTR_PAINTCOLOR =     0x0040,
+	ATTR_LIGHTDIRECTION = 0x0080,
+	ATTR_BONE_INDEXES =   0x0100,
+	ATTR_BONE_WEIGHTS =   0x0200,
 
 	// for .md3 interpolation
-	ATTR_POSITION2 =      0x0800,
-	ATTR_TANGENT2 =       0x1000,
-	ATTR_BITANGENT2 =     0x2000,
-	ATTR_NORMAL2 =        0x4000,
+	ATTR_POSITION2 =      0x0400,
+	ATTR_TANGENT2 =       0x0800,
+	ATTR_NORMAL2 =        0x1000,
 
 	ATTR_DEFAULT = ATTR_POSITION,
 	ATTR_BITS =	ATTR_POSITION |
 				ATTR_TEXCOORD |
 				ATTR_LIGHTCOORD |
 				ATTR_TANGENT |
-				ATTR_BITANGENT |
 				ATTR_NORMAL |
 				ATTR_COLOR |
 				ATTR_PAINTCOLOR |
@@ -642,7 +635,6 @@ enum
 				ATTR_BONE_WEIGHTS |
 				ATTR_POSITION2 |
 				ATTR_TANGENT2 |
-				ATTR_BITANGENT2 |
 				ATTR_NORMAL2
 };
 
@@ -987,8 +979,7 @@ typedef struct
 	vec2_t          lightmap;
 	vec3_t          normal;
 #ifdef USE_VERT_TANGENT_SPACE
-	vec3_t          tangent;
-	vec3_t          bitangent;
+	vec4_t          tangent;
 #endif
 	vec3_t          lightdir;
 	vec4_t			vertexColors;
@@ -999,7 +990,7 @@ typedef struct
 } srfVert_t;
 
 #ifdef USE_VERT_TANGENT_SPACE
-#define srfVert_t_cleared(x) srfVert_t (x) = {{0, 0, 0}, {0, 0}, {0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0, 0}}
+#define srfVert_t_cleared(x) srfVert_t (x) = {{0, 0, 0}, {0, 0}, {0, 0}, {0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0}, {0, 0, 0, 0}}
 #else
 #define srfVert_t_cleared(x) srfVert_t (x) = {{0, 0, 0}, {0, 0}, {0, 0}, {0, 0, 0}, {0, 0, 0},  {0, 0, 0, 0}}
 #endif
@@ -2097,10 +2088,9 @@ typedef struct shaderCommands_s
 {
 	glIndex_t	indexes[SHADER_MAX_INDEXES] QALIGN(16);
 	vec4_t		xyz[SHADER_MAX_VERTEXES] QALIGN(16);
-	vec4_t		normal[SHADER_MAX_VERTEXES] QALIGN(16);
+	uint8_t		normal[SHADER_MAX_VERTEXES][4] QALIGN(16);
 #ifdef USE_VERT_TANGENT_SPACE
-	vec4_t		tangent[SHADER_MAX_VERTEXES] QALIGN(16);
-	vec4_t		bitangent[SHADER_MAX_VERTEXES] QALIGN(16);
+	uint8_t		tangent[SHADER_MAX_VERTEXES][4] QALIGN(16);
 #endif
 	vec2_t		texCoords[SHADER_MAX_VERTEXES][2] QALIGN(16);
 	vec4_t		vertexColors[SHADER_MAX_VERTEXES] QALIGN(16);
diff --git a/src/renderergl2/tr_main.c b/src/renderergl2/tr_main.c
index ca6bab3c..5973b9b5 100644
--- a/src/renderergl2/tr_main.c
+++ b/src/renderergl2/tr_main.c
@@ -455,6 +455,8 @@ qboolean R_CalcTangentVectors(srfVert_t * dv[3])
 	/* do each vertex */
 	for(i = 0; i < 3; i++)
 	{
+		vec3_t bitangent, nxt;
+
 		// calculate s tangent vector
 		s = dv[i]->st[0] + 10.0f;
 		t = dv[i]->st[1];
@@ -476,12 +478,16 @@ qboolean R_CalcTangentVectors(srfVert_t * dv[3])
 		bary[1] = ((dv[2]->st[0] - s) * (dv[0]->st[1] - t) - (dv[0]->st[0] - s) * (dv[2]->st[1] - t)) / bb;
 		bary[2] = ((dv[0]->st[0] - s) * (dv[1]->st[1] - t) - (dv[1]->st[0] - s) * (dv[0]->st[1] - t)) / bb;
 
-		dv[i]->bitangent[0] = bary[0] * dv[0]->xyz[0] + bary[1] * dv[1]->xyz[0] + bary[2] * dv[2]->xyz[0];
-		dv[i]->bitangent[1] = bary[0] * dv[0]->xyz[1] + bary[1] * dv[1]->xyz[1] + bary[2] * dv[2]->xyz[1];
-		dv[i]->bitangent[2] = bary[0] * dv[0]->xyz[2] + bary[1] * dv[1]->xyz[2] + bary[2] * dv[2]->xyz[2];
+		bitangent[0] = bary[0] * dv[0]->xyz[0] + bary[1] * dv[1]->xyz[0] + bary[2] * dv[2]->xyz[0];
+		bitangent[1] = bary[0] * dv[0]->xyz[1] + bary[1] * dv[1]->xyz[1] + bary[2] * dv[2]->xyz[1];
+		bitangent[2] = bary[0] * dv[0]->xyz[2] + bary[1] * dv[1]->xyz[2] + bary[2] * dv[2]->xyz[2];
+
+		VectorSubtract(bitangent, dv[i]->xyz, bitangent);
+		VectorNormalize(bitangent);
 
-		VectorSubtract(dv[i]->bitangent, dv[i]->xyz, dv[i]->bitangent);
-		VectorNormalize(dv[i]->bitangent);
+		// store bitangent handedness
+		CrossProduct(dv[i]->normal, dv[i]->tangent, nxt);
+		dv[i]->tangent[3] = (DotProduct(nxt, bitangent) < 0.0f) ? -1.0f : 1.0f;
 
 		// debug code
 		//% Sys_FPrintf( SYS_VRB, "%d S: (%f %f %f) T: (%f %f %f)\n", i,
@@ -1557,7 +1563,8 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
 
 	for ( i = 0; i < tess.numIndexes; i += 3 )
 	{
-		vec3_t normal;
+		vec3_t normal, tNormal;
+
 		float len;
 
 		VectorSubtract( tess.xyz[tess.indexes[i]], tr.viewParms.or.origin, normal );
@@ -1568,7 +1575,11 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
 			shortest = len;
 		}
 
-		if ( DotProduct( normal, tess.normal[tess.indexes[i]] ) >= 0 )
+		tNormal[0] = tess.normal[tess.indexes[i]][0] / 127.5f - 1.0f;
+		tNormal[1] = tess.normal[tess.indexes[i]][1] / 127.5f - 1.0f;
+		tNormal[2] = tess.normal[tess.indexes[i]][2] / 127.5f - 1.0f;
+
+		if ( DotProduct( normal, tNormal ) >= 0 )
 		{
 			numTriangles--;
 		}
diff --git a/src/renderergl2/tr_model.c b/src/renderergl2/tr_model.c
index c4c2a247..a2af4156 100644
--- a/src/renderergl2/tr_model.c
+++ b/src/renderergl2/tr_model.c
@@ -690,11 +690,10 @@ static qboolean R_LoadMD3(model_t * mod, int lod, void *buffer, int bufferSize,
 		for (i = 0; i < mdvModel->numSurfaces; i++, vboSurf++, surf++)
 		{
 			vec3_t *verts;
-			vec3_t *normals;
 			vec2_t *texcoords;
+			uint8_t *normals;
 #ifdef USE_VERT_TANGENT_SPACE
-			vec3_t *tangents;
-			vec3_t *bitangents;
+			uint8_t *tangents;
 #endif
 
 			byte *data;
@@ -702,7 +701,7 @@ static qboolean R_LoadMD3(model_t * mod, int lod, void *buffer, int bufferSize,
 
 			int ofs_xyz, ofs_normal, ofs_st;
 #ifdef USE_VERT_TANGENT_SPACE
-			int ofs_tangent, ofs_bitangent;
+			int ofs_tangent;
 #endif
 
 			dataSize = 0;
@@ -711,14 +710,11 @@ static qboolean R_LoadMD3(model_t * mod, int lod, void *buffer, int bufferSize,
 			dataSize += surf->numVerts * mdvModel->numFrames * sizeof(*verts);
 
 			ofs_normal = dataSize;
-			dataSize += surf->numVerts * mdvModel->numFrames * sizeof(*normals);
+			dataSize += surf->numVerts * mdvModel->numFrames * sizeof(*normals) * 4;
 
 #ifdef USE_VERT_TANGENT_SPACE
 			ofs_tangent = dataSize;
-			dataSize += surf->numVerts * mdvModel->numFrames * sizeof(*tangents);
-
-			ofs_bitangent = dataSize;
-			dataSize += surf->numVerts * mdvModel->numFrames * sizeof(*bitangents);
+			dataSize += surf->numVerts * mdvModel->numFrames * sizeof(*tangents) * 4;
 #endif
 
 			ofs_st = dataSize;
@@ -730,18 +726,25 @@ static qboolean R_LoadMD3(model_t * mod, int lod, void *buffer, int bufferSize,
 			normals =    (void *)(data + ofs_normal);
 #ifdef USE_VERT_TANGENT_SPACE
 			tangents =   (void *)(data + ofs_tangent);
-			bitangents = (void *)(data + ofs_bitangent);
 #endif
 			texcoords =  (void *)(data + ofs_st);
 		
 			v = surf->verts;
 			for ( j = 0; j < surf->numVerts * mdvModel->numFrames ; j++, v++ )
 			{
+				vec3_t nxt;
+
+				CrossProduct(v->normal, v->tangent, nxt);
 				VectorCopy(v->xyz,       verts[j]);
-				VectorCopy(v->normal,    normals[j]);
+				normals[j*4+0] = (uint8_t)(v->normal[0] * 127.5f + 128.0f);
+				normals[j*4+1] = (uint8_t)(v->normal[1] * 127.5f + 128.0f);
+				normals[j*4+2] = (uint8_t)(v->normal[2] * 127.5f + 128.0f);
+				normals[j*4+3] = 0;
 #ifdef USE_VERT_TANGENT_SPACE
-				VectorCopy(v->tangent,   tangents[j]);
-				VectorCopy(v->bitangent, bitangents[j]);
+				tangents[j*4+0] = (uint8_t)(v->tangent[0] * 127.5f + 128.0f);
+				tangents[j*4+1] = (uint8_t)(v->tangent[1] * 127.5f + 128.0f);
+				tangents[j*4+2] = (uint8_t)(v->tangent[2] * 127.5f + 128.0f);
+				tangents[j*4+3] = (DotProduct(nxt, v->bitangent) < 0.0f) ? 0 : 255;
 #endif
 			}
 
@@ -766,20 +769,18 @@ static qboolean R_LoadMD3(model_t * mod, int lod, void *buffer, int bufferSize,
 			vboSurf->vbo->ofs_normal    = ofs_normal;
 #ifdef USE_VERT_TANGENT_SPACE
 			vboSurf->vbo->ofs_tangent   = ofs_tangent;
-			vboSurf->vbo->ofs_bitangent = ofs_bitangent;
 #endif
 			vboSurf->vbo->ofs_st        = ofs_st;
 
 			vboSurf->vbo->stride_xyz       = sizeof(*verts);
-			vboSurf->vbo->stride_normal    = sizeof(*normals);
+			vboSurf->vbo->stride_normal    = sizeof(*normals) * 4;
 #ifdef USE_VERT_TANGENT_SPACE
-			vboSurf->vbo->stride_tangent   = sizeof(*tangents);
-			vboSurf->vbo->stride_bitangent = sizeof(*bitangents);
+			vboSurf->vbo->stride_tangent   = sizeof(*tangents) * 4;
 #endif
 			vboSurf->vbo->stride_st        = sizeof(*st);
 
 			vboSurf->vbo->size_xyz    = sizeof(*verts) * surf->numVerts;
-			vboSurf->vbo->size_normal = sizeof(*normals) * surf->numVerts;
+			vboSurf->vbo->size_normal = sizeof(*normals) * surf->numVerts * 4;
 
 			ri.Free(data);
 
diff --git a/src/renderergl2/tr_model_iqm.c b/src/renderergl2/tr_model_iqm.c
index 8e826212..8eab1106 100644
--- a/src/renderergl2/tr_model_iqm.c
+++ b/src/renderergl2/tr_model_iqm.c
@@ -1024,7 +1024,7 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
 	int		i;
 
 	vec4_t		*outXYZ;
-	vec4_t		*outNormal;
+	uint8_t		*outNormal;
 	vec2_t		(*outTexCoord)[2];
 	vec4_t	*outColor;
 
@@ -1039,7 +1039,7 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
 	RB_CHECKOVERFLOW( surf->num_vertexes, surf->num_triangles * 3 );
 
 	outXYZ = &tess.xyz[tess.numVertexes];
-	outNormal = &tess.normal[tess.numVertexes];
+	outNormal = &tess.normal[tess.numVertexes][0];
 	outTexCoord = &tess.texCoords[tess.numVertexes];
 	outColor = &tess.vertexColors[tess.numVertexes];
 
@@ -1050,7 +1050,7 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
 
 	// transform vertexes and fill other data
 	for( i = 0; i < surf->num_vertexes;
-	     i++, outXYZ++, outNormal++, outTexCoord++, outColor++ ) {
+	     i++, outXYZ++, outNormal+=4, outTexCoord++, outColor++ ) {
 		int	j, k;
 		float	vtxMat[12];
 		float	nrmMat[9];
@@ -1116,19 +1116,22 @@ void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
 			vtxMat[11];
 		(*outXYZ)[3] = 1.0f;
 
-		(*outNormal)[0] =
+		(outNormal)[0] = (uint8_t)((
 			nrmMat[ 0] * data->normals[3*vtx+0] +
 			nrmMat[ 1] * data->normals[3*vtx+1] +
-			nrmMat[ 2] * data->normals[3*vtx+2];
-		(*outNormal)[1] =
+			nrmMat[ 2] * data->normals[3*vtx+2]
+			)* 127.5f + 128.0f);
+		(outNormal)[1] = (uint8_t)((
 			nrmMat[ 3] * data->normals[3*vtx+0] +
 			nrmMat[ 4] * data->normals[3*vtx+1] +
-			nrmMat[ 5] * data->normals[3*vtx+2];
-		(*outNormal)[2] =
+			nrmMat[ 5] * data->normals[3*vtx+2]
+			)* 127.5f + 128.0f);
+		(outNormal)[2] = (uint8_t)((
 			nrmMat[ 6] * data->normals[3*vtx+0] +
 			nrmMat[ 7] * data->normals[3*vtx+1] +
-			nrmMat[ 8] * data->normals[3*vtx+2];
-		(*outNormal)[3] = 0.0f;
+			nrmMat[ 8] * data->normals[3*vtx+2]
+			)* 127.5f + 128.0f);
+		(outNormal)[3] = 0;
 
 		(*outColor)[0] = data->colors[4*vtx+0] / 255.0f;
 		(*outColor)[1] = data->colors[4*vtx+1] / 255.0f;
diff --git a/src/renderergl2/tr_shade.c b/src/renderergl2/tr_shade.c
index a23ae119..95516e9d 100644
--- a/src/renderergl2/tr_shade.c
+++ b/src/renderergl2/tr_shade.c
@@ -1028,7 +1028,6 @@ static unsigned int RB_CalcShaderVertexAttribs( shaderCommands_t *input )
 			vertexAttribs |= ATTR_NORMAL2;
 #ifdef USE_VERT_TANGENT_SPACE
 			vertexAttribs |= ATTR_TANGENT2;
-			vertexAttribs |= ATTR_BITANGENT2;
 #endif
 		}
 	}
diff --git a/src/renderergl2/tr_shade_calc.c b/src/renderergl2/tr_shade_calc.c
index 2b6626a2..c3172ec2 100644
--- a/src/renderergl2/tr_shade_calc.c
+++ b/src/renderergl2/tr_shade_calc.c
@@ -117,7 +117,7 @@ void RB_CalcDeformVertexes( deformStage_t *ds )
 	vec3_t	offset;
 	float	scale;
 	float	*xyz = ( float * ) tess.xyz;
-	float	*normal = ( float * ) tess.normal;
+	uint8_t	*normal = ( uint8_t * ) tess.normal;
 	float	*table;
 
 	if ( ds->deformationWave.frequency == 0 )
@@ -126,7 +126,9 @@ void RB_CalcDeformVertexes( deformStage_t *ds )
 
 		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
 		{
-			VectorScale( normal, scale, offset );
+			offset[0] = (normal[0] / 127.5f - 1.0f) * scale;
+			offset[1] = (normal[1] / 127.5f - 1.0f) * scale;
+			offset[2] = (normal[2] / 127.5f - 1.0f) * scale;
 			
 			xyz[0] += offset[0];
 			xyz[1] += offset[1];
@@ -146,7 +148,9 @@ void RB_CalcDeformVertexes( deformStage_t *ds )
 				ds->deformationWave.phase + off,
 				ds->deformationWave.frequency );
 
-			VectorScale( normal, scale, offset );
+			offset[0] = (normal[0] / 127.5f - 1.0f) * scale;
+			offset[1] = (normal[1] / 127.5f - 1.0f) * scale;
+			offset[2] = (normal[2] / 127.5f - 1.0f) * scale;
 			
 			xyz[0] += offset[0];
 			xyz[1] += offset[1];
@@ -166,25 +170,35 @@ void RB_CalcDeformNormals( deformStage_t *ds ) {
 	int i;
 	float	scale;
 	float	*xyz = ( float * ) tess.xyz;
-	float	*normal = ( float * ) tess.normal;
+	uint8_t *normal = ( uint8_t * ) tess.normal;
 
 	for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) {
+		vec3_t fNormal;
+
+		fNormal[0] = normal[0] / 127.5f - 1.0f;
+		fNormal[1] = normal[1] / 127.5f - 1.0f;
+		fNormal[2] = normal[2] / 127.5f - 1.0f;
+
 		scale = 0.98f;
 		scale = R_NoiseGet4f( xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
 			tess.shaderTime * ds->deformationWave.frequency );
-		normal[ 0 ] += ds->deformationWave.amplitude * scale;
+		fNormal[ 0 ] += ds->deformationWave.amplitude * scale;
 
 		scale = 0.98f;
 		scale = R_NoiseGet4f( 100 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
 			tess.shaderTime * ds->deformationWave.frequency );
-		normal[ 1 ] += ds->deformationWave.amplitude * scale;
+		fNormal[ 1 ] += ds->deformationWave.amplitude * scale;
 
 		scale = 0.98f;
 		scale = R_NoiseGet4f( 200 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
 			tess.shaderTime * ds->deformationWave.frequency );
-		normal[ 2 ] += ds->deformationWave.amplitude * scale;
+		fNormal[ 2 ] += ds->deformationWave.amplitude * scale;
+
+		VectorNormalizeFast( fNormal );
 
-		VectorNormalizeFast( normal );
+		normal[0] = (uint8_t)(fNormal[0] * 127.5f + 128.0f);
+		normal[1] = (uint8_t)(fNormal[0] * 127.5f + 128.0f);
+		normal[2] = (uint8_t)(fNormal[0] * 127.5f + 128.0f);
 	}
 }
 
@@ -198,7 +212,7 @@ void RB_CalcBulgeVertexes( deformStage_t *ds ) {
 	int i;
 	const float *st = ( const float * ) tess.texCoords[0];
 	float		*xyz = ( float * ) tess.xyz;
-	float		*normal = ( float * ) tess.normal;
+	uint8_t		*normal = ( uint8_t * ) tess.normal;
 	float		now;
 
 	now = backEnd.refdef.time * ds->bulgeSpeed * 0.001f;
@@ -211,9 +225,9 @@ void RB_CalcBulgeVertexes( deformStage_t *ds ) {
 
 		scale = tr.sinTable[ off & FUNCTABLE_MASK ] * ds->bulgeHeight;
 			
-		xyz[0] += normal[0] * scale;
-		xyz[1] += normal[1] * scale;
-		xyz[2] += normal[2] * scale;
+		xyz[0] += (normal[0] / 127.5f - 1.0f) * scale;
+		xyz[1] += (normal[1] / 127.5f - 1.0f) * scale;
+		xyz[2] += (normal[2] / 127.5f - 1.0f) * scale;
 	}
 }
 
@@ -263,11 +277,17 @@ void DeformText( const char *text ) {
 	float	color[4];
 	float	bottom, top;
 	vec3_t	mid;
+	vec3_t fNormal;
 
 	height[0] = 0;
 	height[1] = 0;
 	height[2] = -1;
-	CrossProduct( tess.normal[0], height, width );
+		
+	fNormal[0] = tess.normal[0][0] / 127.5f - 1.0f;
+	fNormal[1] = tess.normal[0][1] / 127.5f - 1.0f;
+	fNormal[2] = tess.normal[0][2] / 127.5f - 1.0f;
+
+	CrossProduct( fNormal, height, width );
 
 	// find the midpoint of the box
 	VectorClear( mid );
diff --git a/src/renderergl2/tr_shader.c b/src/renderergl2/tr_shader.c
index 836fb5b8..7edb8309 100644
--- a/src/renderergl2/tr_shader.c
+++ b/src/renderergl2/tr_shader.c
@@ -1948,7 +1948,7 @@ static void ComputeVertexAttribs(void)
 #ifdef USE_VERT_TANGENT_SPACE
 			if ((pStage->glslShaderIndex & LIGHTDEF_LIGHTTYPE_MASK) && !(r_normalMapping->integer == 0 && r_specularMapping->integer == 0))
 			{
-				shader.vertexAttribs |= ATTR_BITANGENT | ATTR_TANGENT;
+				shader.vertexAttribs |= ATTR_TANGENT;
 			}
 #endif
 
diff --git a/src/renderergl2/tr_surface.c b/src/renderergl2/tr_surface.c
index eff3a257..6853bdc7 100644
--- a/src/renderergl2/tr_surface.c
+++ b/src/renderergl2/tr_surface.c
@@ -125,10 +125,25 @@ void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, float color[4],
 	// constant normal all the way around
 	VectorSubtract( vec3_origin, backEnd.viewParms.or.axis[0], normal );
 
-	VectorCopy(normal, tess.normal[ndx]);
-	VectorCopy(normal, tess.normal[ndx+1]);
-	VectorCopy(normal, tess.normal[ndx+2]);
-	VectorCopy(normal, tess.normal[ndx+3]);
+	tess.normal[ndx][0] = (uint8_t)(normal[0] * 127.5f + 128.0f);
+	tess.normal[ndx][1] = (uint8_t)(normal[1] * 127.5f + 128.0f);
+	tess.normal[ndx][2] = (uint8_t)(normal[2] * 127.5f + 128.0f);
+	tess.normal[ndx][3] = 0;
+
+	tess.normal[ndx+1][0] = (uint8_t)(normal[0] * 127.5f + 128.0f);
+	tess.normal[ndx+1][1] = (uint8_t)(normal[1] * 127.5f + 128.0f);
+	tess.normal[ndx+1][2] = (uint8_t)(normal[2] * 127.5f + 128.0f);
+	tess.normal[ndx+1][3] = 0;
+
+	tess.normal[ndx+2][0] = (uint8_t)(normal[0] * 127.5f + 128.0f);
+	tess.normal[ndx+2][1] = (uint8_t)(normal[1] * 127.5f + 128.0f);
+	tess.normal[ndx+2][2] = (uint8_t)(normal[2] * 127.5f + 128.0f);
+	tess.normal[ndx+2][3] = 0;
+
+	tess.normal[ndx+3][0] = (uint8_t)(normal[0] * 127.5f + 128.0f);
+	tess.normal[ndx+3][1] = (uint8_t)(normal[1] * 127.5f + 128.0f);
+	tess.normal[ndx+3][2] = (uint8_t)(normal[2] * 127.5f + 128.0f);
+	tess.normal[ndx+3][3] = 0;
 	
 	// standard square texture coordinates
 	VectorSet2(tess.texCoords[ndx  ][0], s1, t1);
@@ -317,9 +332,10 @@ static void RB_SurfaceVertsAndIndexes( int numVerts, srfVert_t *verts, int numIn
 	int             i;
 	glIndex_t      *inIndex;
 	srfVert_t      *dv;
-	float          *xyz, *normal, *texCoords, *lightCoords, *lightdir;
+	float          *xyz, *texCoords, *lightCoords, *lightdir;
+	uint8_t        *normal;
 #ifdef USE_VERT_TANGENT_SPACE
-	float          *tangent, *bitangent;
+	uint8_t        *tangent;
 #endif
 	glIndex_t      *outIndex;
 	float          *color;
@@ -348,7 +364,12 @@ static void RB_SurfaceVertsAndIndexes( int numVerts, srfVert_t *verts, int numIn
 		dv = verts;
 		normal = tess.normal[ tess.numVertexes ];
 		for ( i = 0 ; i < numVerts ; i++, dv++, normal+=4 )
-			VectorCopy(dv->normal, normal);
+		{
+			normal[0] = (uint8_t)(dv->normal[0] * 127.5f + 128.0f);
+			normal[1] = (uint8_t)(dv->normal[1] * 127.5f + 128.0f);
+			normal[2] = (uint8_t)(dv->normal[2] * 127.5f + 128.0f);
+			normal[3] = 0;
+		}
 	}
 
 #ifdef USE_VERT_TANGENT_SPACE
@@ -357,15 +378,12 @@ static void RB_SurfaceVertsAndIndexes( int numVerts, srfVert_t *verts, int numIn
 		dv = verts;
 		tangent = tess.tangent[ tess.numVertexes ];
 		for ( i = 0 ; i < numVerts ; i++, dv++, tangent+=4 )
-			VectorCopy(dv->tangent, tangent);
-	}
-
-	if ( tess.shader->vertexAttribs & ATTR_BITANGENT )
-	{
-		dv = verts;
-		bitangent = tess.bitangent[ tess.numVertexes ];
-		for ( i = 0 ; i < numVerts ; i++, dv++, bitangent+=4 )
-			VectorCopy(dv->bitangent, bitangent);
+		{
+			tangent[0] = (uint8_t)(dv->tangent[0] * 127.5f + 128.0f);
+			tangent[1] = (uint8_t)(dv->tangent[1] * 127.5f + 128.0f);
+			tangent[2] = (uint8_t)(dv->tangent[2] * 127.5f + 128.0f);
+			tangent[3] = (uint8_t)(dv->tangent[3] * 127.5f + 128.0f);
+		}
 	}
 #endif
 
@@ -1128,7 +1146,8 @@ static void LerpMeshVertexes_scalar(mdvSurface_t *surf, float backlerp)
     	VectorArrayNormalize((vec4_t *)tess.normal[tess.numVertexes], numVerts);
    	}
 #endif
-	float *outXyz, *outNormal;
+	float *outXyz;
+	uint8_t *outNormal;
 	mdvVertex_t *newVerts;
 	int		vertNum;
 
@@ -1145,8 +1164,16 @@ static void LerpMeshVertexes_scalar(mdvSurface_t *surf, float backlerp)
 
 		for (vertNum=0 ; vertNum < surf->numVerts ; vertNum++)
 		{
+			vec3_t normal;
+
 			VectorCopy(newVerts->xyz,    outXyz);
-			VectorCopy(newVerts->normal, outNormal);
+			VectorCopy(newVerts->normal, normal);
+
+			outNormal[0] = (uint8_t)(normal[0] * 127.5f + 128.0f);
+			outNormal[1] = (uint8_t)(normal[1] * 127.5f + 128.0f);
+			outNormal[2] = (uint8_t)(normal[2] * 127.5f + 128.0f);
+			outNormal[3] = 0;
+
 			newVerts++;
 			outXyz += 4;
 			outNormal += 4;
@@ -1164,15 +1191,22 @@ static void LerpMeshVertexes_scalar(mdvSurface_t *surf, float backlerp)
 
 		for (vertNum=0 ; vertNum < surf->numVerts ; vertNum++)
 		{
-			VectorLerp(backlerp, newVerts->xyz,    oldVerts->xyz,    outXyz);
-			VectorLerp(backlerp, newVerts->normal, oldVerts->normal, outNormal);
-			//VectorNormalize(outNormal);
+			vec3_t normal;
+
+			VectorLerp(newVerts->xyz,    oldVerts->xyz,    backlerp, outXyz);
+			VectorLerp(newVerts->normal, oldVerts->normal, backlerp, normal);
+			VectorNormalize(normal);
+
+			outNormal[0] = (uint8_t)(normal[0] * 127.5f + 128.0f);
+			outNormal[1] = (uint8_t)(normal[1] * 127.5f + 128.0f);
+			outNormal[2] = (uint8_t)(normal[2] * 127.5f + 128.0f);
+			outNormal[3] = 0;
+
 			newVerts++;
 			oldVerts++;
 			outXyz += 4;
 			outNormal += 4;
 		}
-		VectorArrayNormalize((vec4_t *)tess.normal[tess.numVertexes], surf->numVerts);
 	}
 
 }
@@ -1293,9 +1327,9 @@ static void RB_SurfaceGrid( srfBspSurface_t *srf ) {
 	int		i, j;
 	float	*xyz;
 	float	*texCoords, *lightCoords;
-	float	*normal;
+	uint8_t *normal;
 #ifdef USE_VERT_TANGENT_SPACE
-	float   *tangent, *bitangent;
+	uint8_t *tangent;
 #endif
 	float   *color, *lightdir;
 	srfVert_t	*dv;
@@ -1383,7 +1417,6 @@ static void RB_SurfaceGrid( srfBspSurface_t *srf ) {
 		normal = tess.normal[numVertexes];
 #ifdef USE_VERT_TANGENT_SPACE
 		tangent = tess.tangent[numVertexes];
-		bitangent = tess.bitangent[numVertexes];
 #endif
 		texCoords = tess.texCoords[numVertexes][0];
 		lightCoords = tess.texCoords[numVertexes][1];
@@ -1404,22 +1437,22 @@ static void RB_SurfaceGrid( srfBspSurface_t *srf ) {
 
 				if ( tess.shader->vertexAttribs & ATTR_NORMAL )
 				{
-					VectorCopy(dv->normal, normal);
+					normal[0] = (uint8_t)(dv->normal[0] * 127.5f + 128.0f);
+					normal[1] = (uint8_t)(dv->normal[1] * 127.5f + 128.0f);
+					normal[2] = (uint8_t)(dv->normal[2] * 127.5f + 128.0f);
+					normal[3] = 0;
 					normal += 4;
 				}
 
 #ifdef USE_VERT_TANGENT_SPACE
 				if ( tess.shader->vertexAttribs & ATTR_TANGENT )
 				{
-					VectorCopy(dv->tangent, tangent);
+					tangent[0] = (uint8_t)(dv->tangent[0] * 127.5f + 128.0f);
+					tangent[1] = (uint8_t)(dv->tangent[1] * 127.5f + 128.0f);
+					tangent[2] = (uint8_t)(dv->tangent[2] * 127.5f + 128.0f);
+					tangent[3] = (uint8_t)(dv->tangent[3] * 127.5f + 128.0f);	
 					tangent += 4;
 				}
-
-				if ( tess.shader->vertexAttribs & ATTR_BITANGENT )
-				{
-					VectorCopy(dv->bitangent, bitangent);
-					bitangent += 4;
-				}
 #endif
 				if ( tess.shader->vertexAttribs & ATTR_TEXCOORD )
 				{
diff --git a/src/renderergl2/tr_vbo.c b/src/renderergl2/tr_vbo.c
index 44c66d01..b18b8f93 100644
--- a/src/renderergl2/tr_vbo.c
+++ b/src/renderergl2/tr_vbo.c
@@ -142,20 +142,14 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 		if(stateBits & ATTR_NORMAL)
 		{
 			vbo->ofs_normal = dataSize;
-			dataSize += sizeof(verts[0].normal);
+			dataSize += sizeof(uint8_t) * 4;
 		}
 
 #ifdef USE_VERT_TANGENT_SPACE
 		if(stateBits & ATTR_TANGENT)
 		{
 			vbo->ofs_tangent = dataSize;
-			dataSize += sizeof(verts[0].tangent);
-		}
-
-		if(stateBits & ATTR_BITANGENT)
-		{
-			vbo->ofs_bitangent = dataSize;
-			dataSize += sizeof(verts[0].bitangent);
+			dataSize += sizeof(uint8_t) * 4;
 		}
 #endif
 
@@ -187,7 +181,6 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 		vbo->stride_normal      = dataSize;
 #ifdef USE_VERT_TANGENT_SPACE
 		vbo->stride_tangent     = dataSize;
-		vbo->stride_bitangent   = dataSize;
 #endif
 		vbo->stride_st          = dataSize;
 		vbo->stride_lightmap    = dataSize;
@@ -211,23 +204,31 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 			// normal
 			if(stateBits & ATTR_NORMAL)
 			{
-				memcpy(data + dataOfs, &verts[i].normal, sizeof(verts[i].normal));
-				dataOfs += sizeof(verts[i].normal);
+				uint8_t *p = data + dataOfs;
+
+				p[0] = (uint8_t)(verts[i].normal[0] * 127.5f + 128.0f);
+				p[1] = (uint8_t)(verts[i].normal[1] * 127.5f + 128.0f);
+				p[2] = (uint8_t)(verts[i].normal[2] * 127.5f + 128.0f);
+				p[3] = 0;
+
+				dataOfs += sizeof(uint8_t) * 4;
 			}
 
 #ifdef USE_VERT_TANGENT_SPACE
 			// tangent
 			if(stateBits & ATTR_TANGENT)
 			{
-				memcpy(data + dataOfs, &verts[i].tangent, sizeof(verts[i].tangent));
-				dataOfs += sizeof(verts[i].tangent);
-			}
+				vec3_t nxt;
+				uint8_t *p = data + dataOfs;
 
-			// bitangent
-			if(stateBits & ATTR_BITANGENT)
-			{
-				memcpy(data + dataOfs, &verts[i].bitangent, sizeof(verts[i].bitangent));
-				dataOfs += sizeof(verts[i].bitangent);
+				CrossProduct(verts[i].normal, verts[i].tangent, nxt);
+
+				p[0] = (uint8_t)(verts[i].tangent[0] * 127.5f + 128.0f);
+				p[1] = (uint8_t)(verts[i].tangent[1] * 127.5f + 128.0f);
+				p[2] = (uint8_t)(verts[i].tangent[2] * 127.5f + 128.0f);				
+				p[3] = (uint8_t)(verts[i].tangent[3] * 127.5f + 128.0f);
+
+				dataOfs += sizeof(uint8_t) * 4;
 			}
 #endif
 
@@ -267,18 +268,13 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 
 		if(stateBits & ATTR_NORMAL)
 		{
-			dataSize += sizeof(verts[0].normal);
+			dataSize += sizeof(uint8_t) * 4;
 		}
 
 #ifdef USE_VERT_TANGENT_SPACE
 		if(stateBits & ATTR_TANGENT)
 		{
-			dataSize += sizeof(verts[0].tangent);
-		}
-
-		if(stateBits & ATTR_BITANGENT)
-		{
-			dataSize += sizeof(verts[0].bitangent);
+			dataSize += sizeof(uint8_t) * 4;
 		}
 #endif
 
@@ -311,7 +307,6 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 		vbo->ofs_normal         = 0;
 #ifdef USE_VERT_TANGENT_SPACE
 		vbo->ofs_tangent        = 0;
-		vbo->ofs_bitangent      = 0;
 #endif
 		vbo->ofs_st             = 0;
 		vbo->ofs_lightmap       = 0;
@@ -319,10 +314,9 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 		vbo->ofs_lightdir       = 0;
 
 		vbo->stride_xyz         = sizeof(verts[0].xyz);
-		vbo->stride_normal      = sizeof(verts[0].normal);
+		vbo->stride_normal      = sizeof(uint8_t) * 4;
 #ifdef USE_VERT_TANGENT_SPACE
-		vbo->stride_tangent     = sizeof(verts[0].tangent);
-		vbo->stride_bitangent   = sizeof(verts[0].bitangent);
+		vbo->stride_tangent     = sizeof(uint8_t) * 4;
 #endif
 		vbo->stride_vertexcolor = sizeof(verts[0].vertexColors);
 		vbo->stride_st          = sizeof(verts[0].st);
@@ -345,8 +339,14 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 			vbo->ofs_normal = dataOfs;
 			for (i = 0; i < numVertexes; i++)
 			{
-				memcpy(data + dataOfs, &verts[i].normal, sizeof(verts[i].normal));
-				dataOfs += sizeof(verts[i].normal);
+				uint8_t *p = data + dataOfs;
+
+				p[0] = (uint8_t)(verts[i].normal[0] * 127.5f + 128.0f);
+				p[1] = (uint8_t)(verts[i].normal[1] * 127.5f + 128.0f);
+				p[2] = (uint8_t)(verts[i].normal[2] * 127.5f + 128.0f);
+				p[3] = 0;
+
+				dataOfs += sizeof(uint8_t) * 4;
 			}
 		}
 
@@ -357,19 +357,17 @@ VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
 			vbo->ofs_tangent = dataOfs;
 			for (i = 0; i < numVertexes; i++)
 			{
-				memcpy(data + dataOfs, &verts[i].tangent, sizeof(verts[i].tangent));
-				dataOfs += sizeof(verts[i].tangent);
-			}
-		}
+				vec3_t nxt;
+				uint8_t *p = data + dataOfs;
 
-		// bitangent
-		if(stateBits & ATTR_BITANGENT)
-		{
-			vbo->ofs_bitangent = dataOfs;
-			for (i = 0; i < numVertexes; i++)
-			{
-				memcpy(data + dataOfs, &verts[i].bitangent, sizeof(verts[i].bitangent));
-				dataOfs += sizeof(verts[i].bitangent);
+				CrossProduct(verts[i].normal, verts[i].tangent, nxt);
+
+				p[0] = (uint8_t)(verts[i].tangent[0] * 127.5f + 128.0f);
+				p[1] = (uint8_t)(verts[i].tangent[1] * 127.5f + 128.0f);
+				p[2] = (uint8_t)(verts[i].tangent[2] * 127.5f + 128.0f);
+				p[3] = (uint8_t)(verts[i].tangent[3] * 127.5f + 128.0f);
+
+				dataOfs += sizeof(uint8_t) * 4;
 			}
 		}
 #endif
@@ -700,7 +698,6 @@ void R_InitVBOs(void)
 	dataSize += sizeof(tess.normal[0]);
 #ifdef USE_VERT_TANGENT_SPACE
 	dataSize += sizeof(tess.tangent[0]);
-	dataSize += sizeof(tess.bitangent[0]);
 #endif
 	dataSize += sizeof(tess.vertexColors[0]);
 	dataSize += sizeof(tess.texCoords[0][0]) * 2;
@@ -715,7 +712,6 @@ void R_InitVBOs(void)
 	tess.vbo->ofs_normal      = offset; offset += sizeof(tess.normal[0])           * SHADER_MAX_VERTEXES;
 #ifdef USE_VERT_TANGENT_SPACE
 	tess.vbo->ofs_tangent     = offset; offset += sizeof(tess.tangent[0])          * SHADER_MAX_VERTEXES;
-	tess.vbo->ofs_bitangent   = offset; offset += sizeof(tess.bitangent[0])        * SHADER_MAX_VERTEXES;
 #endif
 	// these next two are actually interleaved
 	tess.vbo->ofs_st          = offset; 
@@ -729,7 +725,6 @@ void R_InitVBOs(void)
 	tess.vbo->stride_normal      = sizeof(tess.normal[0]);
 #ifdef USE_VERT_TANGENT_SPACE
 	tess.vbo->stride_tangent     = sizeof(tess.tangent[0]);
-	tess.vbo->stride_bitangent   = sizeof(tess.bitangent[0]);
 #endif
 	tess.vbo->stride_vertexcolor = sizeof(tess.vertexColors[0]);
 	tess.vbo->stride_st          = sizeof(tess.texCoords[0][0]) * 2;
@@ -887,12 +882,6 @@ void RB_UpdateVBOs(unsigned int attribBits)
 				//ri.Printf(PRINT_ALL, "offset %d, size %d\n", tess.vbo->ofs_tangent, tess.numVertexes * sizeof(tess.tangent[0]));
 				qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_tangent,     tess.numVertexes * sizeof(tess.tangent[0]),          tess.tangent);
 			}
-
-			if(attribBits & ATTR_BITANGENT)
-			{
-				//ri.Printf(PRINT_ALL, "offset %d, size %d\n", tess.vbo->ofs_bitangent, tess.numVertexes * sizeof(tess.bitangent[0]));
-				qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_bitangent,   tess.numVertexes * sizeof(tess.bitangent[0]),        tess.bitangent);
-			}
 #endif
 
 			if(attribBits & ATTR_COLOR)
@@ -914,7 +903,6 @@ void RB_UpdateVBOs(unsigned int attribBits)
 			qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_normal,      tess.numVertexes * sizeof(tess.normal[0]),           tess.normal);
 #ifdef USE_VERT_TANGENT_SPACE
 			qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_tangent,     tess.numVertexes * sizeof(tess.tangent[0]),          tess.tangent);
-			qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_bitangent,   tess.numVertexes * sizeof(tess.bitangent[0]),        tess.bitangent);
 #endif
 			qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_vertexcolor, tess.numVertexes * sizeof(tess.vertexColors[0]),     tess.vertexColors);
 			qglBufferSubDataARB(GL_ARRAY_BUFFER_ARB, tess.vbo->ofs_lightdir,    tess.numVertexes * sizeof(tess.lightdir[0]),         tess.lightdir);