Import icculus.org release (2017-05-05)

1 files changed, 825 insertions, 243 deletions

diff --git a/src/opengl.c b/src/opengl.c
index 4326fc0..dd89509 100644
--- a/src/opengl.c
+++ b/src/opengl.c
@@ -46,10 +46,13 @@ extern int CloakingPhase;
 
 static D3DTexture *CurrTextureHandle;
 
+enum AVP_SHADER_PROGRAM CurrShaderProgram;
+
+GLuint DefaultTexture;
 
 static enum TRANSLUCENCY_TYPE CurrentTranslucencyMode = TRANSLUCENCY_OFF;
 static enum FILTERING_MODE_ID CurrentFilteringMode = FILTERING_BILINEAR_OFF;
-static GLenum TextureMinFilter = GL_LINEAR_MIPMAP_LINEAR;
+static GLenum TextureMinFilter = GL_LINEAR; //GL_LINEAR_MIPMAP_LINEAR;
 static D3DTexture *CurrentlyBoundTexture = NULL;
 
 #if defined(_MSC_VER)
@@ -86,23 +89,17 @@ static VertexArray *varrp = varr;
 static TriangleArray *tarrp = tarr;
 static int varrc, tarrc;
 
-static ALIGN16 TriangleArray starr[TA_MAXTRIANGLES];
-static TriangleArray *starrp = starr;
-static int starrc;
+static GLuint ElementArrayBuffer;
+static GLuint ArrayBuffer;
 
 /* Do not call this directly! */
 static void SetTranslucencyMode(enum TRANSLUCENCY_TYPE mode)
 {
-	pglDisable(GL_ALPHA_TEST);
-
 	switch(mode) {
 		case TRANSLUCENCY_OFF:
 			if (TRIPTASTIC_CHEATMODE||MOTIONBLUR_CHEATMODE) {
 				pglBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
-			} else {
-				// alien tail hack
-				pglEnable(GL_ALPHA_TEST);
-				
+			} else {			
 				pglBlendFunc(GL_ONE, GL_ZERO);
 			}
 			break;
@@ -130,101 +127,693 @@ static void SetTranslucencyMode(enum TRANSLUCENCY_TYPE mode)
 	}
 }
 
-static void SetSecondPassTranslucencyMode(enum TRANSLUCENCY_TYPE mode)
-{
-	pglDisable(GL_ALPHA_TEST);
+#if defined(USE_OPENGL_ES)
+#define SHADER_PRAGMAS "\n"
+#define SHADER_VERSION "#version 100\n"
+#else
+#define SHADER_PRAGMAS "\n"
+#define SHADER_VERSION "#version 120\n"
+#endif
 
-	switch(mode) {
-		case TRANSLUCENCY_OFF:
-			if (TRIPTASTIC_CHEATMODE||MOTIONBLUR_CHEATMODE) {
-				pglBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE);
+#if USE_OPENGL_ES
+
+#define SHADER_SETUP \
+"#define HIGHP highp\n" \
+"#define MEDIUMP mediump\n" \
+"#define LOWP lowp\n"
+
+#else
+
+#define SHADER_SETUP \
+"#ifdef GL_ES\n" \
+"#define HIGHP highp\n" \
+"#define MEDIUMP mediump\n" \
+"#define LOWP lowp\n" \
+"#else\n" \
+"#define HIGHP\n" \
+"#define MEDIUMP\n" \
+"#define LOWP\n" \
+"#endif\n"
+
+#endif
+
+static const char AVP_VERTEX_SHADER_SOURCE[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "attribute HIGHP vec4 aVertex;\n"
+   "attribute HIGHP vec2 aTexCoord;\n"
+   "attribute LOWP vec4 aColor0;\n"
+   "attribute LOWP vec4 aColor1;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "varying LOWP vec4 vColor0;\n"
+   "varying LOWP vec4 vColor1;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	gl_Position = aVertex;\n"
+   "	vTexCoord	= aTexCoord;\n"
+   "	vColor0		= aColor0;\n"
+   "	vColor1     = aColor1;\n"
+   "}\n"
+   ;
+
+static const char AVP_VERTEX_SHADER_SOURCE_NO_SECONDARY[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "attribute HIGHP vec4 aVertex;\n"
+   "attribute HIGHP vec2 aTexCoord;\n"
+   "attribute LOWP vec4 aColor0;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "varying LOWP vec4 vColor0;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	gl_Position = aVertex;\n"
+   "	vTexCoord	= aTexCoord;\n"
+   "	vColor0		= aColor0;\n"
+   "}\n"
+   ;
+
+static const char AVP_VERTEX_SHADER_SOURCE_NO_TEXTURE[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "attribute HIGHP vec4 aVertex;\n"
+   "attribute LOWP vec4 aColor0;\n"
+   "\n"
+   "varying LOWP vec4 vColor0;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	gl_Position = aVertex;\n"
+   "	vColor0		= aColor0;\n"
+   "}\n"
+   ;
+
+static const char AVP_VERTEX_SHADER_SOURCE_NO_COLOR[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "attribute HIGHP vec4 aVertex;\n"
+   "attribute HIGHP vec2 aTexCoord;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	gl_Position = aVertex;\n"
+   "	vTexCoord	= aTexCoord;\n"
+   "}\n"
+   ;
+
+static const char AVP_FRAGMENT_SHADER_SOURCE[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "uniform LOWP sampler2D uTexture;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "varying LOWP vec4 vColor0;\n"
+   "varying LOWP vec4 vColor1;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "\n"
+   "	MEDIUMP vec4 t       = texture2D( uTexture, vTexCoord );\n"
+   "	if (t.a == 0.0) discard;\n"
+   "	gl_FragColor = t * vColor0 + vColor1;\n"
+   "}\n"
+   ;
+
+static const char AVP_FRAGMENT_SHADER_SOURCE_NO_SECONDARY[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "uniform LOWP sampler2D uTexture;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "varying LOWP vec4 vColor0;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	MEDIUMP vec4 t       = texture2D( uTexture, vTexCoord );\n"
+   "	if (t.a == 0.0) discard;\n"
+   "	gl_FragColor = t * vColor0;\n"
+   "}\n"
+   ;
+
+static const char AVP_FRAGMENT_SHADER_SOURCE_NO_TEXTURE[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "varying LOWP vec4 vColor0;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	gl_FragColor = vColor0;\n"
+   "}\n"
+   ;
+
+static const char AVP_FRAGMENT_SHADER_SOURCE_NO_DISCARD[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "uniform LOWP sampler2D uTexture;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "varying LOWP vec4 vColor0;\n"
+   "varying LOWP vec4 vColor1;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	MEDIUMP vec4 t       = texture2D( uTexture, vTexCoord );\n"
+   "	gl_FragColor = t * vColor0 + vColor1;\n"
+   "}\n"
+   ;
+
+static const char AVP_FRAGMENT_SHADER_SOURCE_NO_SECONDARY_NO_DISCARD[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "uniform LOWP sampler2D uTexture;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "varying LOWP vec4 vColor0;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	MEDIUMP vec4 t       = texture2D( uTexture, vTexCoord );\n"
+   "	gl_FragColor = t * vColor0;\n"
+   "}\n"
+   ;
+
+static const char AVP_FRAGMENT_SHADER_SOURCE_NO_COLOR_NO_DISCARD[] =
+   SHADER_VERSION
+   SHADER_PRAGMAS
+   SHADER_SETUP
+   "\n"
+   "uniform LOWP sampler2D uTexture;\n"
+   "\n"
+   "varying HIGHP vec2 vTexCoord;\n"
+   "\n"
+   "void main(void)\n"
+   "{\n"
+   "	MEDIUMP vec4 t       = texture2D( uTexture, vTexCoord );\n"
+   "	gl_FragColor = t;\n"
+   "}\n"
+   ;
+
+enum AVP_VERTEX_SHADER {
+	AVP_VERTEX_SHADER_DEFAULT,
+	AVP_VERTEX_SHADER_NO_TEXTURE,
+	AVP_VERTEX_SHADER_NO_SECONDARY,
+	AVP_VERTEX_SHADER_NO_COLOR,
+	AVP_VERTEX_SHADER_MAX
+};
+
+enum AVP_FRAGMENT_SHADER {
+	AVP_FRAGMENT_SHADER_DEFAULT,
+	AVP_FRAGMENT_SHADER_NO_TEXTURE,
+	AVP_FRAGMENT_SHADER_NO_DISCARD,
+	AVP_FRAGMENT_SHADER_NO_SECONDARY,
+	AVP_FRAGMENT_SHADER_NO_SECONDARY_NO_DISCARD,
+	AVP_FRAGMENT_SHADER_NO_COLOR_NO_DISCARD,
+	AVP_FRAGMENT_SHADER_MAX
+};
+
+static const char* const AvpVertexShaderSources[AVP_VERTEX_SHADER_MAX] = {
+	AVP_VERTEX_SHADER_SOURCE,
+	AVP_VERTEX_SHADER_SOURCE_NO_TEXTURE,
+	AVP_VERTEX_SHADER_SOURCE_NO_SECONDARY,
+	AVP_VERTEX_SHADER_SOURCE_NO_COLOR
+};
+
+static const char* AvpFragmentShaderSources[AVP_FRAGMENT_SHADER_MAX] = {
+	AVP_FRAGMENT_SHADER_SOURCE,
+	AVP_FRAGMENT_SHADER_SOURCE_NO_TEXTURE,
+	AVP_FRAGMENT_SHADER_SOURCE_NO_DISCARD,
+	AVP_FRAGMENT_SHADER_SOURCE_NO_SECONDARY,
+	AVP_FRAGMENT_SHADER_SOURCE_NO_SECONDARY_NO_DISCARD,
+	AVP_FRAGMENT_SHADER_SOURCE_NO_COLOR_NO_DISCARD
+};
+
+struct AvpShaderProgramSource {
+	enum AVP_VERTEX_SHADER VertexShader;
+	enum AVP_FRAGMENT_SHADER FragmentShader;
+};
+
+struct AvpVertexShader {
+	int shaderObj;
+};
+
+struct AvpFragmentShader {
+	int shaderObj;
+};
+
+struct AvpShaderProgram {
+	int programObj;
+
+	int uTexture;
+};
+
+static const struct AvpShaderProgramSource AvpShaderProgramSources[AVP_SHADER_PROGRAM_MAX] = {
+	// AVP_SHADER_PROGRAM_DEFAULT
+	{
+		AVP_VERTEX_SHADER_DEFAULT,
+		AVP_FRAGMENT_SHADER_DEFAULT
+	},
+	// AVP_SHADER_PROGRAM_NO_SECONDARY
+	{
+		AVP_VERTEX_SHADER_NO_SECONDARY,
+		AVP_FRAGMENT_SHADER_NO_SECONDARY
+	},
+	// AVP_SHADER_PROGRAM_NO_TEXTURE
+	{
+		AVP_VERTEX_SHADER_NO_TEXTURE,
+		AVP_FRAGMENT_SHADER_NO_TEXTURE
+	},
+	// AVP_SHADER_PROGRAM_NO_DISCARD
+	{
+		AVP_VERTEX_SHADER_DEFAULT,
+		AVP_FRAGMENT_SHADER_NO_DISCARD
+	},
+	// AVP_SHADER_PROGRAM_NO_SECONDARY_NO_DISCARD
+	{
+		AVP_VERTEX_SHADER_NO_SECONDARY,
+		AVP_FRAGMENT_SHADER_NO_SECONDARY_NO_DISCARD
+	},
+	// AVP_SHADER_PROGRAM_NO_COLOR_NO_DISCARD
+	{
+		AVP_VERTEX_SHADER_NO_COLOR,
+		AVP_FRAGMENT_SHADER_NO_COLOR_NO_DISCARD
+	}
+};
+
+static const unsigned int AvpShaderProgramAttributes[AVP_SHADER_PROGRAM_MAX+1] = {
+	// AVP_SHADER_PROGRAM_DEFAULT
+	(1 << OPENGL_VERTEX_ATTRIB_INDEX) | (1 << OPENGL_TEXCOORD_ATTRIB_INDEX) | (1 << OPENGL_COLOR0_ATTRIB_INDEX) | (1 << OPENGL_COLOR1_ATTRIB_INDEX),
+	// AVP_SHADER_PROGRAM_NO_SECONDARY
+	(1 << OPENGL_VERTEX_ATTRIB_INDEX) | (1 << OPENGL_TEXCOORD_ATTRIB_INDEX) | (1 << OPENGL_COLOR0_ATTRIB_INDEX) | (0 << OPENGL_COLOR1_ATTRIB_INDEX),
+	// AVP_SHADER_PROGRAM_NO_TEXTURE
+	(1 << OPENGL_VERTEX_ATTRIB_INDEX) | (0 << OPENGL_TEXCOORD_ATTRIB_INDEX) | (1 << OPENGL_COLOR0_ATTRIB_INDEX) | (0 << OPENGL_COLOR1_ATTRIB_INDEX),
+	// AVP_SHADER_PROGRAM_NO_DISCARD
+	(1 << OPENGL_VERTEX_ATTRIB_INDEX) | (1 << OPENGL_TEXCOORD_ATTRIB_INDEX) | (1 << OPENGL_COLOR0_ATTRIB_INDEX) | (1 << OPENGL_COLOR1_ATTRIB_INDEX),
+	// AVP_SHADER_PROGRAM_NO_SECONDARY_NO_DISCARD
+	(1 << OPENGL_VERTEX_ATTRIB_INDEX) | (1 << OPENGL_TEXCOORD_ATTRIB_INDEX) | (1 << OPENGL_COLOR0_ATTRIB_INDEX) | (0 << OPENGL_COLOR1_ATTRIB_INDEX),
+	// AVP_SHADER_PROGRAM_NO_COLOR_NO_DISCARD
+	(1 << OPENGL_VERTEX_ATTRIB_INDEX) | (1 << OPENGL_TEXCOORD_ATTRIB_INDEX) | (0 << OPENGL_COLOR0_ATTRIB_INDEX) | (0 << OPENGL_COLOR1_ATTRIB_INDEX),
+	// AVP_SHADER_PROGRAM_MAX
+	0
+};
+
+static const char* AvpShaderProgramAttributeNames[4] = {
+	"aVertex",
+	"aTexCoord",
+	"aColor0",
+	"aColor1"
+};
+
+static struct AvpVertexShader AvpVertexShaders[AVP_FRAGMENT_SHADER_MAX];
+static struct AvpFragmentShader AvpFragmentShaders[AVP_FRAGMENT_SHADER_MAX];
+static struct AvpShaderProgram AvpShaderPrograms[AVP_SHADER_PROGRAM_MAX];
+
+static int CompileShader(GLuint shader, const GLchar* shaderSource) {
+	GLint infoLogLength;
+	GLchar* infoLog;
+	GLint compileStatus;
+
+	pglShaderSource(shader, 1, &shaderSource, NULL);
+	pglCompileShader(shader);
+
+	pglGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
+	if (infoLogLength > 1) {
+		infoLog = (GLchar*) malloc((size_t) infoLogLength * sizeof(GLchar));
+		if (infoLog == NULL) {
+			fprintf(stderr, "unable to allocate info log\n");
+			return GL_FALSE;
+		}
+
+		pglGetShaderInfoLog(shader, infoLogLength, NULL, infoLog);
+		printf("Shader:\n-------\n%s\n\nCompile Log:\n------------\n%s\n", shaderSource, infoLog);
+
+		free(infoLog);
+	}
+
+	pglGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
+	return compileStatus;
+}
+
+static int LinkProgram(GLuint program) {
+	GLint infoLogLength;
+	GLchar* infoLog;
+	GLint compileStatus;
+
+	pglLinkProgram(program);
+	pglGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+	if (infoLogLength > 1) {
+		infoLog = (GLchar*) malloc((size_t) infoLogLength * sizeof(GLchar));
+		if (infoLog == NULL) {
+			fprintf(stderr, "unable to allocate info log\n");
+			return GL_FALSE;
+		}
+
+		pglGetProgramInfoLog(program, infoLogLength, NULL, infoLog);
+		printf("Program Link Log:\n%s\n", infoLog);
+
+		free(infoLog);
+	}
+
+	pglGetProgramiv(program, GL_LINK_STATUS, &compileStatus);
+	return compileStatus;
+}
+
+static int ValidateProgram(GLuint program) {
+	GLint infoLogLength;
+	GLchar* infoLog;
+	GLint compileStatus;
+
+	pglValidateProgram(program);
+
+	pglGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+	if (infoLogLength > 1) {
+		infoLog = (GLchar*) malloc((size_t) infoLogLength * sizeof(GLchar));
+		if (infoLog == NULL) {
+			fprintf(stderr, "unable to allocate info log\n");
+			return GL_FALSE;
+		}
+
+		pglGetProgramInfoLog(program, infoLogLength, NULL, infoLog);
+		printf("Program Validation Log:\n%s\n", infoLog);
+
+		free(infoLog);
+	}
+
+	pglGetProgramiv(program, GL_VALIDATE_STATUS, &compileStatus);
+	return compileStatus;
+}
+
+static int CreateProgram(GLuint* pprogram, const GLchar* vertexShaderSource, const GLchar* fragmentShaderSource) {
+	GLuint program;
+	GLuint vertexShader;
+	GLuint fragmentShader;
+
+	GLint compileStatus;
+
+	// create program object
+	program = pglCreateProgram();
+
+	// vertex shader
+	vertexShader = pglCreateShader(GL_VERTEX_SHADER);
+
+	compileStatus = CompileShader(vertexShader, vertexShaderSource);
+
+	if (compileStatus == GL_FALSE) {
+		fprintf(stderr, "vertex shader compilation failed\n");
+
+		pglDeleteProgram(program);
+		return GL_FALSE;
+	}
+
+	pglAttachShader(program, vertexShader);
+	pglDeleteShader(vertexShader);
+
+	// fragment shader
+	fragmentShader = pglCreateShader(GL_FRAGMENT_SHADER);
+
+	compileStatus = CompileShader(fragmentShader, fragmentShaderSource);
+
+	if (compileStatus == GL_FALSE) {
+		fprintf(stderr, "fragment shader compilation failed\n");
+
+		pglDeleteProgram(program);
+		return GL_FALSE;
+	}
+
+	pglAttachShader(program, fragmentShader);
+	pglDeleteShader(fragmentShader);
+
+	// link the program
+	compileStatus = LinkProgram(program);
+
+	if (compileStatus == GL_FALSE) {
+		fprintf(stderr, "program failed to link\n");
+
+		pglDeleteProgram(program);
+		return GL_FALSE;
+	}
+
+	// validate the program for good measure
+	compileStatus = ValidateProgram(program);
+
+	if (compileStatus == GL_FALSE) {
+		fprintf(stderr, "program failed to validate\n");
+
+		pglDeleteProgram(program);
+		return GL_FALSE;
+	}
+
+	*pprogram = program;
+	return GL_TRUE;
+}
+
+static int CreateProgram2(GLuint* pprogram, GLuint vertexShader, GLuint fragmentShader) {
+	GLuint program;
+	GLint compileStatus;
+	int i;
+
+	// create program object
+	program = pglCreateProgram();
+
+	// vertex shader
+	pglAttachShader(program, vertexShader);
+
+	// fragment shader
+	pglAttachShader(program, fragmentShader);
+
+	// need to bind locations before linking
+	pglBindAttribLocation(program, OPENGL_VERTEX_ATTRIB_INDEX, "aVertex");
+	pglBindAttribLocation(program, OPENGL_TEXCOORD_ATTRIB_INDEX, "aTexCoord");
+	pglBindAttribLocation(program, OPENGL_COLOR0_ATTRIB_INDEX, "aColor0");
+	pglBindAttribLocation(program, OPENGL_COLOR1_ATTRIB_INDEX, "aColor1");
+
+	// link the program
+	compileStatus = LinkProgram(program);
+
+	if (compileStatus == GL_FALSE) {
+		fprintf(stderr, "program failed to link\n");
+
+		pglDeleteProgram(program);
+		return GL_FALSE;
+	}
+
+	// validate the program for good measure
+	compileStatus = ValidateProgram(program);
+
+	if (compileStatus == GL_FALSE) {
+		fprintf(stderr, "program failed to validate\n");
+
+		pglDeleteProgram(program);
+		return GL_FALSE;
+	}
+
+	*pprogram = program;
+	return GL_TRUE;
+}
+
+static int InitOpenGLPrograms(void) {
+	GLenum status;
+	int i;
+
+	for (i = 0; i < AVP_VERTEX_SHADER_MAX; i++) {
+		GLuint vertexShader;
+
+		vertexShader = pglCreateShader(GL_VERTEX_SHADER);
+
+		status = CompileShader(vertexShader, AvpVertexShaderSources[i]);
+
+		if (status == GL_FALSE) {
+			fprintf(stderr, "vertex shader compilation failed\n");
+			return GL_FALSE;
+		}
+
+		AvpVertexShaders[i].shaderObj = vertexShader;
+	}
+
+	for (i = 0; i < AVP_FRAGMENT_SHADER_MAX; i++) {
+		GLuint fragmentShader;
+
+		fragmentShader = pglCreateShader(GL_FRAGMENT_SHADER);
+
+		status = CompileShader(fragmentShader, AvpFragmentShaderSources[i]);
+
+		if (status == GL_FALSE) {
+			fprintf(stderr, "fragment shader compilation failed\n");
+			return GL_FALSE;
+		}
+
+		AvpFragmentShaders[i].shaderObj = fragmentShader;
+	}
+
+	for (i = 0; i < AVP_SHADER_PROGRAM_MAX; i++) {
+		GLuint program;
+		GLuint vertexShader;
+		GLuint fragmentShader;
+
+		vertexShader = AvpVertexShaders[AvpShaderProgramSources[i].VertexShader].shaderObj;
+		fragmentShader = AvpFragmentShaders[AvpShaderProgramSources[i].FragmentShader].shaderObj;
+
+		status = CreateProgram2(&program, vertexShader, fragmentShader);
+		if (status == GL_FALSE) {
+			fprintf(stderr, "program compilation failed\n");
+			return GL_FALSE;
+		}
+
+		AvpShaderPrograms[i].programObj = program;
+		AvpShaderPrograms[i].uTexture = pglGetUniformLocation(program, "uTexture");
+	}
+
+	return GL_TRUE;
+}
+
+void SelectProgram(enum AVP_SHADER_PROGRAM program) {
+
+	if (CurrShaderProgram != program) {
+		// supposed to flush here
+
+		unsigned int PrevAttribs = AvpShaderProgramAttributes[CurrShaderProgram];
+		unsigned int NextAttribs = AvpShaderProgramAttributes[program];
+		unsigned int DiffAttribs = PrevAttribs ^ NextAttribs;
+		int ShaderProgram = AvpShaderPrograms[program].programObj;
+		int TextureUniformIndex = AvpShaderPrograms[program].uTexture;
+
+		CurrShaderProgram = program;
+		pglUseProgram(ShaderProgram);
+
+		if ((DiffAttribs & OPENGL_VERTEX_ATTRIB_BITINDEX) != 0) {
+			if ((NextAttribs & OPENGL_VERTEX_ATTRIB_BITINDEX) != 0) {
+				pglEnableVertexAttribArray(OPENGL_VERTEX_ATTRIB_INDEX);
 			} else {
-				pglBlendFunc(GL_ONE, GL_ONE);
+				pglDisableVertexAttribArray(OPENGL_VERTEX_ATTRIB_INDEX);
 			}
-			break;
-		case TRANSLUCENCY_NORMAL:
-			pglBlendFunc(GL_SRC_ALPHA, GL_ONE);
-			break;
-		case TRANSLUCENCY_GLOWING:
-			pglBlendFunc(GL_SRC_ALPHA, GL_ONE);
-			break;
-		case TRANSLUCENCY_COLOUR:
-			//fprintf(stderr, "SetSecondPassTranslucencyMode: unsupported blend mode %d\n", mode);
-			// can't easily emulate this one
-			pglBlendFunc(GL_DST_COLOR, GL_ONE);
-			break;
-		case TRANSLUCENCY_INVCOLOUR:
-			//fprintf(stderr, "SetSecondPassTranslucencyMode: unsupported blend mode %d\n", mode);
-			// can't easily emulate this one
-			pglBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
-			break;
+		}
 
-		case TRANSLUCENCY_DARKENINGCOLOUR:
-		case TRANSLUCENCY_JUSTSETZ:
-			fprintf(stderr, "SetSecondPassTranslucencyMode: unsupported blend mode %d\n", mode);
-			pglBlendFunc(GL_SRC_ALPHA, GL_ONE);
-			break;
-		default:
-			fprintf(stderr, "SetSecondPassTranslucencyMode: invalid blend mode %d\n", mode);
-			break;
+		if ((DiffAttribs & OPENGL_TEXCOORD_ATTRIB_BITINDEX) != 0) {
+			if ((NextAttribs & OPENGL_TEXCOORD_ATTRIB_BITINDEX) != 0) {
+				pglEnableVertexAttribArray(OPENGL_TEXCOORD_ATTRIB_INDEX);
+			} else {
+				pglDisableVertexAttribArray(OPENGL_TEXCOORD_ATTRIB_INDEX);
+			}
+		}
+
+		if ((DiffAttribs & OPENGL_COLOR0_ATTRIB_BITINDEX) != 0) {
+			if ((NextAttribs & OPENGL_COLOR0_ATTRIB_BITINDEX) != 0) {
+				pglEnableVertexAttribArray(OPENGL_COLOR0_ATTRIB_INDEX);
+			} else {
+				pglDisableVertexAttribArray(OPENGL_COLOR0_ATTRIB_INDEX);
+			}
+		}
+
+		if ((DiffAttribs & OPENGL_COLOR1_ATTRIB_BITINDEX) != 0) {
+			if ((NextAttribs & OPENGL_COLOR1_ATTRIB_BITINDEX) != 0) {
+				pglEnableVertexAttribArray(OPENGL_COLOR1_ATTRIB_INDEX);
+			} else {
+				pglDisableVertexAttribArray(OPENGL_COLOR1_ATTRIB_INDEX);
+			}
+		}
+
+		if (TextureUniformIndex >= 0) {
+			pglUniform1i(TextureUniformIndex, 0);
+		}
 	}
 }
 
-/* 
-A few things:
-- Vertices with a specular color are done twice.
-  Might want to try spitting apart the three arrays and using the same vertex
-  array for both passes.
-- Fix code for separate color support.
-*/
+static void InitOpenGLDefaultTexture(void) {
+	pglGenTextures(1, &DefaultTexture);
 
-void InitOpenGL()
+	pglBindTexture(GL_TEXTURE_2D, DefaultTexture);
+
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+	GLubyte defaultTexData[4] = { 255, 255, 255, 255 };
+	pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, defaultTexData);
+}
+
+void InitOpenGL(int firsttime)
 {
-        pglHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
-        pglHint( GL_GENERATE_MIPMAP_HINT, GL_NICEST );
+	if (firsttime) {
+		InitOpenGLPrograms();
+		check_for_errors();
+		InitOpenGLDefaultTexture();
+		check_for_errors();
+	}
+
+	pglHint( GL_GENERATE_MIPMAP_HINT, GL_NICEST );
 
 #if GL_NV_multisample_filter_hint
-        if ( ogl_use_multisample_filter_hint )
-        {
-                pglHint( GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST );
-        }
+	if ( ogl_use_multisample_filter_hint )
+	{
+		pglHint( GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST );
+	}
 #endif
 
 	CurrentTranslucencyMode = TRANSLUCENCY_OFF;
 	pglBlendFunc(GL_ONE, GL_ZERO);
 	
-	pglAlphaFunc(GL_GREATER, 0.0f);
-	
 	CurrentFilteringMode = FILTERING_BILINEAR_OFF;
-	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-                        
 	CurrentlyBoundTexture = NULL;
 	pglBindTexture(GL_TEXTURE_2D, 0);
-	
-	pglEnableClientState(GL_VERTEX_ARRAY);
-	pglVertexPointer(4, GL_FLOAT, sizeof(varr[0]), varr[0].v);
-		
-	pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	pglTexCoordPointer(2, GL_FLOAT, sizeof(varr[0]), varr[0].t);
-		
-	pglEnableClientState(GL_COLOR_ARRAY);
-	pglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(varr[0]), varr[0].c);
+
+	// create array and element array buffers, as required by WebGL
+	pglGenBuffers(1, &ArrayBuffer);
+	pglGenBuffers(1, &ElementArrayBuffer);
+
+	pglBindBuffer(GL_ARRAY_BUFFER, ArrayBuffer);
+	pglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementArrayBuffer);
+
+	pglVertexAttribPointer(OPENGL_VERTEX_ATTRIB_INDEX, 4, GL_FLOAT, GL_FALSE, sizeof(varr[0]), (const GLvoid*) 0);
+	pglVertexAttribPointer(OPENGL_TEXCOORD_ATTRIB_INDEX, 2, GL_FLOAT, GL_FALSE, sizeof(varr[0]), (const GLvoid*) 16);
+	pglVertexAttribPointer(OPENGL_COLOR0_ATTRIB_INDEX, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(varr[0]), (const GLvoid*) 24);
+	pglVertexAttribPointer(OPENGL_COLOR1_ATTRIB_INDEX, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(varr[0]), (const GLvoid*) 28);
+
+	CurrShaderProgram = AVP_SHADER_PROGRAM_MAX;
+	SelectProgram(AVP_SHADER_PROGRAM_DEFAULT);
 
 	tarrc = 0;
 	tarrp = tarr;
 		
 	varrc = 0;
 	varrp = varr;
-	
-	starrc = 0;
-	starrp = starr;
+
+	check_for_errors();
 }
 
 static void FlushTriangleBuffers(int backup)
 {
 	if (tarrc) {
-		pglDrawElements(GL_TRIANGLES, tarrc*3, GL_UNSIGNED_SHORT, tarr);
+		// not optimal but required by WebGL
+		pglBufferData(GL_ARRAY_BUFFER, varrc * sizeof(varr[0]), varr, GL_STREAM_DRAW);
+		pglBufferData(GL_ELEMENT_ARRAY_BUFFER, tarrc * sizeof(tarr[0]), tarr, GL_STREAM_DRAW);
+
+		pglDrawElements(GL_TRIANGLES, tarrc*3, GL_UNSIGNED_SHORT, (const GLvoid*) 0);
 		
 		tarrc = 0;
 		tarrp = tarr;
@@ -232,57 +821,6 @@ static void FlushTriangleBuffers(int backup)
 		varrc = 0;
 		varrp = varr;
 	}
-	
-	if (starrc) {
-		//if (CurrentlyBoundTexture != NULL) {
-		//	if (!backup) CurrentlyBoundTexture = NULL;
-		//	pglBindTexture(GL_TEXTURE_2D, 0);
-		//}
-		
-		//if (CurrentTranslucencyMode != TRANSLUCENCY_GLOWING) {
-		//	if (!backup) CurrentTranslucencyMode = TRANSLUCENCY_GLOWING;
-		//	SetTranslucencyMode(TRANSLUCENCY_GLOWING);
-		//	//if (CurrentTranslucencyMode == TRANSLUCENCY_OFF)
-		//	//	pglEnable(GL_BLEND);
-		//	//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-		//}
-
-		SetSecondPassTranslucencyMode(CurrentTranslucencyMode);
-
-		pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PRIMARY_COLOR);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PRIMARY_COLOR);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
-
-		//pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
-		pglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(varr[0]), varr[0].s);
-
-		pglDrawElements(GL_TRIANGLES, starrc*3, GL_UNSIGNED_SHORT, starr);
-
-		//pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
-		pglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(varr[0]), varr[0].c);
-		
-		//if (backup) {
-		//	//if (CurrentlyBoundTexture)
-		//	//	pglBindTexture(GL_TEXTURE_2D, CurrentlyBoundTexture->id);
-		//	if (CurrentTranslucencyMode != TRANSLUCENCY_GLOWING)
-		//		SetTranslucencyMode(CurrentTranslucencyMode);
-		//} else {
-		//	//CurrentlyBoundTexture = NULL;
-		//	CurrentTranslucencyMode = TRANSLUCENCY_GLOWING;
-		//}
-
-		SetTranslucencyMode(CurrentTranslucencyMode);
-		pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
-		starrc = 0;
-		starrp = starr;
-	}
 }
 
 static void CheckBoundTextureIsCorrect(D3DTexture *tex)
@@ -293,7 +831,7 @@ static void CheckBoundTextureIsCorrect(D3DTexture *tex)
 	FlushTriangleBuffers(1);
 	
 	if (tex == NULL) {
-		pglBindTexture(GL_TEXTURE_2D, 0);
+		pglBindTexture(GL_TEXTURE_2D, DefaultTexture);
 		
 		CurrentlyBoundTexture = NULL;
 		
@@ -302,6 +840,10 @@ static void CheckBoundTextureIsCorrect(D3DTexture *tex)
 	
 	pglBindTexture(GL_TEXTURE_2D, tex->id);
 
+	/*if (tex->hasAlpha != 0 || tex->hasChroma != 0) {
+		// modulate emulation?
+	}*/
+
 	if (tex->filter != CurrentFilteringMode) {
 		switch(CurrentFilteringMode) {
 			case FILTERING_BILINEAR_OFF:
@@ -310,7 +852,7 @@ static void CheckBoundTextureIsCorrect(D3DTexture *tex)
 				break;
 			case FILTERING_BILINEAR_ON:
 				pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-				pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, TextureMinFilter);
+				pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tex->IsNpot ? GL_LINEAR : TextureMinFilter);
 				break;
 			default:
 				break;
@@ -336,7 +878,7 @@ static void CheckFilteringModeIsCorrect(enum FILTERING_MODE_ID filter)
 				break;
 			case FILTERING_BILINEAR_ON:
 				pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-				pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, TextureMinFilter);
+				pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, CurrentlyBoundTexture->IsNpot ? GL_LINEAR : TextureMinFilter);
 				break;
 			default:
 				break;
@@ -358,7 +900,7 @@ static void CheckTranslucencyModeIsCorrect(enum TRANSLUCENCY_TYPE mode)
 	CurrentTranslucencyMode = mode;
 }
 
-static void CheckTriangleBuffer(int rver, int sver, int rtri, int stri, D3DTexture *tex, enum TRANSLUCENCY_TYPE mode, enum FILTERING_MODE_ID filter)
+static void CheckTriangleBuffer(int rver, int rtri, D3DTexture *tex, enum TRANSLUCENCY_TYPE mode, enum FILTERING_MODE_ID filter)
 {
 	if ((rver+varrc) >= TA_MAXVERTICES) {
 		FlushTriangleBuffers(0);
@@ -413,44 +955,6 @@ static void CheckTriangleBuffer(int rver, int sver, int rtri, int stri, D3DTextu
 		}
 	}	
 #undef OUTPUT_TRIANGLE
-	
-#define OUTPUT_TRIANGLE(x, y, z) \
-{ \
-	starrp->a = varrc+(x);	\
-	starrp->b = varrc+(y);	\
-	starrp->c = varrc+(z);	\
-						\
-	starrp++;				\
-	starrc++; 				\
-}
-	if (stri == 0) {
-		switch(sver) {
-			case 0:
-				break;
-			case 3:
-				OUTPUT_TRIANGLE(0, 2, 1);
-				break;
-			case 5:
-				OUTPUT_TRIANGLE(0, 1, 4);
-				OUTPUT_TRIANGLE(1, 3, 4);
-				OUTPUT_TRIANGLE(1, 2, 3);
-				break;
-			case 8:
-				OUTPUT_TRIANGLE(0, 6, 7);
-			case 7:
-				OUTPUT_TRIANGLE(0, 5, 6);
-			case 6:
-				OUTPUT_TRIANGLE(0, 4, 5);
-				OUTPUT_TRIANGLE(0, 3, 4);
-			case 4:
-				OUTPUT_TRIANGLE(0, 2, 3);
-				OUTPUT_TRIANGLE(0, 1, 2);
-				break;
-			default:
-				fprintf(stderr, "DrawTriangles_T2F_C4UB_V4F: vertices = %d\n", sver);
-		}
-	}
-#undef OUTPUT_TRIANGLE
 }
 
 static unsigned int PowerOfTwo(unsigned int v) {
@@ -513,35 +1017,27 @@ GLuint CreateOGLTexture(D3DTexture *tex, unsigned char *buf)
 	pglGenTextures(1, &h);
 
 	pglBindTexture(GL_TEXTURE_2D, h);
-	pglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 
-	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
-    if (tex->IsNpot) {
-        // OpenGL 1.x compatibility
-        tex->TexWidth = PotWidth;
-        tex->TexHeight = PotHeight;
-
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	if (tex->IsNpot) {
 		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	} else {
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, TextureMinFilter);
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	}
 
-		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex->TexWidth, tex->TexHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-		pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, tex->w, tex->h, GL_RGBA, GL_UNSIGNED_BYTE, buf);
-    } else {
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-		if (tex->IsNpot) {
-			pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		} else {
-			pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, TextureMinFilter);
-		}
+	pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex->w, tex->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
 
-		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex->w, tex->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
+	if (!tex->IsNpot && TextureMinFilter != GL_LINEAR) {
+		// generate mipmaps if needed
+		// OpenGL 3.0 / ES 2 feature -- need fbo extension support
+		//pglGenerateMipmap(GL_TEXTURE_2D);
 	}
 
-	pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
     tex->buf = NULL;
 	tex->id = h;
 	tex->filter = FILTERING_BILINEAR_ON;
@@ -660,7 +1156,8 @@ void D3D_Rectangle(int x0, int y0, int x1, int y1, int r, int g, int b, int a)
 	if (y1 <= y0)
 		return;
 
-	CheckTriangleBuffer(4, 0, 0, 0, NULL, TRANSLUCENCY_GLOWING, -1);
+	CheckTriangleBuffer(4, 0, NULL, TRANSLUCENCY_GLOWING, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
 
 	x[0] = x0;
 	x[0] =  (x[0] - ScreenDescriptorBlock.SDB_CentreX)/ScreenDescriptorBlock.SDB_CentreX;
@@ -730,8 +1227,9 @@ void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDER
 	RecipW = TextureHandle->RecipW / 65536.0f;
 	RecipH = TextureHandle->RecipH / 65536.0f;
 
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, RenderPolygon.NumberOfVertices, 0, 0, TextureHandle, RenderPolygon.TranslucencyMode, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, TextureHandle, RenderPolygon.TranslucencyMode, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_DEFAULT);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		GLfloat x, y, z;
@@ -764,7 +1262,7 @@ void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDER
 		varrp->s[0] = GammaValues[vertices->SpecularR];
 		varrp->s[1] = GammaValues[vertices->SpecularG];
 		varrp->s[2] = GammaValues[vertices->SpecularB];
-		varrp->s[3] = vertices->A;
+		varrp->s[3] = 0;
 		
 		varrp++;
 		varrc++;
@@ -785,8 +1283,9 @@ void D3D_SkyPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVertice
 	RecipW = TextureHandle->RecipW / 65536.0f;
 	RecipH = TextureHandle->RecipH / 65536.0f;
 	
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, RenderPolygon.TranslucencyMode, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, TextureHandle, RenderPolygon.TranslucencyMode, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		GLfloat x, y, z;
@@ -847,8 +1346,9 @@ void D3D_ZBufferedCloakedPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *
 	RecipW = TextureHandle->RecipW / 65536.0f;
 	RecipH = TextureHandle->RecipH / 65536.0f;
 	
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, TRANSLUCENCY_NORMAL, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, TextureHandle, TRANSLUCENCY_NORMAL, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
@@ -943,8 +1443,9 @@ void D3D_Decal_Output(DECAL *decalPtr, RENDERVERTEX *renderVerticesPtr)
 		a = decalDescPtr->Alpha;
 	}
 	
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, decalDescPtr->TranslucencyType, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, TextureHandle, decalDescPtr->TranslucencyType, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
@@ -1035,8 +1536,9 @@ void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr)
 		a = particleDescPtr->Alpha;
 	}
 
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, particleDescPtr->TranslucencyType, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, TextureHandle, particleDescPtr->TranslucencyType, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
@@ -1087,8 +1589,9 @@ void D3D_PredatorThermalVisionPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVER
 	int i;
 	ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
 	
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, NULL, TRANSLUCENCY_OFF, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, NULL, TRANSLUCENCY_OFF, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
@@ -1133,8 +1636,9 @@ void D3D_ZBufferedGouraudPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *
 	
 	flags = inputPolyPtr->PolyFlags;
 	
-	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, NULL, RenderPolygon.TranslucencyMode, -1);
-	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, NULL, RenderPolygon.TranslucencyMode, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
+
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];	
 		GLfloat x, y, z;
@@ -1209,8 +1713,9 @@ void D3D_PlayerOnFireOverlay()
 	s[3] = u;
 	t[3] = v + 1.0f;
 	
-	CheckTriangleBuffer(4, 0, 0, 0, TextureHandle, TRANSLUCENCY_GLOWING, FILTERING_BILINEAR_ON);
-	
+	CheckTriangleBuffer(4, 0, TextureHandle, TRANSLUCENCY_GLOWING, FILTERING_BILINEAR_ON);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	for (i = 0; i < 4; i++) {
 		varrp->v[0] = x[i];
 		varrp->v[1] = y[i];
@@ -1266,7 +1771,7 @@ void D3D_PlayerDamagedOverlay(int intensity)
 		GLfloat x[4], y[4], s[4], t[4];
 		
 		if (i == 0) {
-			CheckTriangleBuffer(4, 0, 0, 0, TextureHandle, TRANSLUCENCY_INVCOLOUR, FILTERING_BILINEAR_ON);
+			CheckTriangleBuffer(4, 0, TextureHandle, TRANSLUCENCY_INVCOLOUR, FILTERING_BILINEAR_ON);
 
 			colour = 0xffffff - baseColour + (intensity<<24);
 			
@@ -1275,7 +1780,7 @@ void D3D_PlayerDamagedOverlay(int intensity)
 			r = (colour >> 16) & 0xFF;
 			a = (colour >> 24) & 0xFF;
 		} else {
-			CheckTriangleBuffer(4, 0, 0, 0, TextureHandle, TRANSLUCENCY_GLOWING, FILTERING_BILINEAR_ON);
+			CheckTriangleBuffer(4, 0, TextureHandle, TRANSLUCENCY_GLOWING, FILTERING_BILINEAR_ON);
 
 			colour = baseColour + (intensity<<24);
 			
@@ -1285,6 +1790,8 @@ void D3D_PlayerDamagedOverlay(int intensity)
 			a = (colour >> 24) & 0xFF;
 		}
 
+		SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 		float sin = (GetSin(theta[i]))/65536.0f/16.0f;
 		float cos = (GetCos(theta[i]))/65536.0f/16.0f;	
 
@@ -1368,7 +1875,8 @@ void DrawNoiseOverlay(int tr)
 
 	// changing the depth func manually, so flush now
 	FlushTriangleBuffers(0);
-	CheckTriangleBuffer(4, 0, 0, 0, tex, TRANSLUCENCY_GLOWING, FILTERING_BILINEAR_ON);
+	CheckTriangleBuffer(4, 0, tex, TRANSLUCENCY_GLOWING, FILTERING_BILINEAR_ON);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
 
 	for (j = 0; j < 4; j++) {
 		varrp->v[0] = x[j];
@@ -1414,11 +1922,13 @@ void D3D_ScreenInversionOverlay()
 		GLfloat x[4], y[4], s[4], t[4];
 		
 		if (i == 0) {
-			CheckTriangleBuffer(4, 0, 0, 0, tex, TRANSLUCENCY_DARKENINGCOLOUR, FILTERING_BILINEAR_ON);
+			CheckTriangleBuffer(4, 0, tex, TRANSLUCENCY_DARKENINGCOLOUR, FILTERING_BILINEAR_ON);
 		} else {
-			CheckTriangleBuffer(4, 0, 0, 0, tex, TRANSLUCENCY_COLOUR, FILTERING_BILINEAR_ON);
+			CheckTriangleBuffer(4, 0, tex, TRANSLUCENCY_COLOUR, FILTERING_BILINEAR_ON);
 		}
 
+		SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 		float sin = (GetSin(theta[i]))/65536.0f/16.0f;
 		float cos = (GetCos(theta[i]))/65536.0f/16.0f;
 		
@@ -1470,8 +1980,9 @@ void D3D_PredatorScreenInversionOverlay()
 
 	// changing the depth func manually, so flush now
 	FlushTriangleBuffers(0);
-	CheckTriangleBuffer(4, 0, 0, 0, NULL, TRANSLUCENCY_DARKENINGCOLOUR, -1);
-	
+	CheckTriangleBuffer(4, 0, NULL, TRANSLUCENCY_DARKENINGCOLOUR, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
+
 	for (j = 0; j < 4; j++) {
 
 		switch (j) {
@@ -1554,7 +2065,8 @@ void DrawScanlinesOverlay(float level)
 	
 	// changing the depth func manually, so flush now
 	FlushTriangleBuffers(0);
-	CheckTriangleBuffer(4, 0, 0, 0, tex, TRANSLUCENCY_NORMAL, FILTERING_BILINEAR_ON);
+	CheckTriangleBuffer(4, 0, tex, TRANSLUCENCY_NORMAL, FILTERING_BILINEAR_ON);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
 
 	for (j = 0; j < 4; j++) {
 		varrp->v[0] = x[j];
@@ -1594,8 +2106,9 @@ void D3D_FadeDownScreen(int brightness, int colour)
 	if (t<0) t = 0;
 	colour = (t<<24)+colour;
 	
-	CheckTriangleBuffer(4, 0, 0, 0, NULL, TRANSLUCENCY_NORMAL, -1);
-	
+	CheckTriangleBuffer(4, 0, NULL, TRANSLUCENCY_NORMAL, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
+
 	b = (colour >> 0)  & 0xFF;
 	g = (colour >> 8)  & 0xFF;
 	r = (colour >> 16) & 0xFF;
@@ -1634,6 +2147,68 @@ void D3D_FadeDownScreen(int brightness, int colour)
 	}
 }
 
+void DrawFullscreenTexture(int texureObject)
+{
+	int j;
+
+	// using a custom texture, so flush now
+	FlushTriangleBuffers(0);
+	CheckTriangleBuffer(4, 0, NULL, TRANSLUCENCY_OFF, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_COLOR_NO_DISCARD);
+	pglBindTexture(GL_TEXTURE_2D, texureObject);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+	for (j = 0; j < 4; j++) {
+
+		switch (j) {
+			case 0:
+				varrp->v[0] = -1.0f;
+				varrp->v[1] = -1.0f;
+				varrp->t[0] =  0.0f;
+				varrp->t[1] =  0.0f;
+				break;
+			case 1:
+				varrp->v[0] =  1.0f;
+				varrp->v[1] = -1.0f;
+				varrp->t[0] =  1.0f;
+				varrp->t[1] =  0.0f;
+				break;
+			case 2:
+				varrp->v[0] =  1.0f;
+				varrp->v[1] =  1.0f;
+				varrp->t[0] =  1.0f;
+				varrp->t[1] =  1.0f;
+				break;
+			case 3:
+				varrp->v[0] = -1.0f;
+				varrp->v[1] =  1.0f;
+				varrp->t[0] =  0.0f;
+				varrp->t[1] =  1.0f;
+				break;
+		}
+
+		varrp->v[2] = -1.0f;
+		varrp->v[3] =  1.0f;
+
+		varrp->c[0] = 255;
+		varrp->c[1] = 255;
+		varrp->c[2] = 255;
+		varrp->c[3] = 255;
+
+		varrp->s[0] = 0;
+		varrp->s[1] = 0;
+		varrp->s[2] = 0;
+		varrp->s[3] = 0;
+
+		varrp++;
+		varrc++;
+	}
+
+	FlushTriangleBuffers(0);
+	pglBindTexture(GL_TEXTURE_2D, 0);
+}
+
 void D3D_HUD_Setup()
 {
 	FlushTriangleBuffers(1);
@@ -1653,8 +2228,9 @@ void D3D_HUDQuad_Output(int imageNumber, struct VertexTag *quadVerticesPtr, unsi
 
 /* possibly use polygon offset? (predator hud) */
 
-	CheckTriangleBuffer(4, 0, 0, 0, tex, TRANSLUCENCY_GLOWING, -1);
-	
+	CheckTriangleBuffer(4, 0, tex, TRANSLUCENCY_GLOWING, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	RecipW = tex->RecipW / 65536.0f;
 	RecipH = tex->RecipH / 65536.0f;
 	
@@ -1982,11 +2558,11 @@ int Hardware_RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AV
 		case AVPMENUFORMAT_RIGHTJUSTIFIED:
 		{
 			int length = 0;
-			signed char *ptr = (signed char*) textPtr;
+			char *ptr = textPtr;
 
 			while(*ptr)
 			{
-				length+=AAFontWidths[*ptr++];
+				length+=AAFontWidths[(unsigned char) *ptr++];
 			}
 
 			x -= length;
@@ -1995,11 +2571,11 @@ int Hardware_RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AV
 		case AVPMENUFORMAT_CENTREJUSTIFIED:
 		{
 			int length = 0;
-			signed char *ptr = (signed char*) textPtr;
+			char *ptr = textPtr;
 
 			while(*ptr)
 			{
-				length+=AAFontWidths[*ptr++];
+				length+=AAFontWidths[(unsigned char) *ptr++];
 			}
 
 			x -= length/2;
@@ -2034,11 +2610,11 @@ int Hardware_RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha
 		case AVPMENUFORMAT_RIGHTJUSTIFIED:
 		{
 			int length = 0;
-			signed char *ptr = (signed char*) textPtr;
+			char *ptr = textPtr;
 
 			while(*ptr)
 			{
-				length+=AAFontWidths[*ptr++];
+				length+=AAFontWidths[(unsigned char) *ptr++];
 			}
 
 			x -= length;
@@ -2047,11 +2623,11 @@ int Hardware_RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha
 		case AVPMENUFORMAT_CENTREJUSTIFIED:
 		{
 			int length = 0;
-			signed char *ptr = (signed char*) textPtr;
+			char *ptr = textPtr;
 
 			while(*ptr)
 			{
-				length+=AAFontWidths[*ptr++];
+				length+=AAFontWidths[(unsigned char) *ptr++];
 			}
 
 			x -= length/2;
@@ -2489,7 +3065,8 @@ void D3D_DrawColourBar(int yTop, int yBottom, int rScale, int gScale, int bScale
 	int a;
 	int start;
 
-	CheckTriangleBuffer(256*2, 0, 255*2, 0, NULL, TRANSLUCENCY_OFF, -1);
+	CheckTriangleBuffer(256*2, 255*2, NULL, TRANSLUCENCY_OFF, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
 
 	start = varrc;
 
@@ -2593,8 +3170,9 @@ void ColourFillBackBufferQuad(int FillColour, int x0, int y0, int x1, int y1)
 	if (y1 <= y0)
 		return;
 	
-	CheckTriangleBuffer(4, 0, 0, 0, NULL, TRANSLUCENCY_OFF, -1);
-	
+	CheckTriangleBuffer(4, 0, NULL, TRANSLUCENCY_OFF, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
+
 	b = ((FillColour >> 0)  & 0xFF);
 	g = ((FillColour >> 8)  & 0xFF);
 	r = ((FillColour >> 16) & 0xFF);
@@ -2741,7 +3319,8 @@ void BltImage(RECT *dest, DDSurface *image, RECT *src)
 	s[3] = src->left * image->RecipW;
 	t[3] = src->bottom * image->RecipH;
 
-    CheckTriangleBuffer(4, 0, 0, 0, image, TRANSLUCENCY_OFF, -1);
+    CheckTriangleBuffer(4, 0, image, TRANSLUCENCY_OFF, -1);
+    SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
 
 	for (i = 0; i < 4; i++) {
 		varrp->v[0] = x[i];
@@ -2834,8 +3413,9 @@ void D3D_DrawParticle_Rain(PARTICLE *particlePtr,VECTORCH *prevPositionPtr)
 
 		ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
 
-		CheckTriangleBuffer(3, 0, 0, 0, NULL, TRANSLUCENCY_NORMAL, -1);
-				
+		CheckTriangleBuffer(3, 0, NULL, TRANSLUCENCY_NORMAL, -1);
+		SelectProgram(AVP_SHADER_PROGRAM_NO_TEXTURE);
+
 		for (i = 0; i < 3; i++) {
 			GLfloat xf, yf, zf;
 			GLfloat w;
@@ -2968,7 +3548,7 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			CheckTriangleBuffer(0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 			
 		 	D3D_DrawWaterPatch(x, y, z);		 	
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
@@ -3000,7 +3580,7 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			CheckTriangleBuffer(0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 			
 		 	D3D_DrawWaterPatch(x, y, z);		 	
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
@@ -3340,7 +3920,7 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			CheckTriangleBuffer(0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 		 	D3D_DrawWaterPatch(x, y, z);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);		 	
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z);
@@ -3369,7 +3949,7 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			CheckTriangleBuffer(0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 		 	D3D_DrawWaterPatch(x, y, z);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z);
@@ -3436,7 +4016,7 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			CheckTriangleBuffer(0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 		 	D3D_DrawWaterPatch(x, y, z);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
 		 	D3D_DrawWaterPatch(x, y, z+MeshZScale);
@@ -3518,7 +4098,7 @@ void D3D_DrawWaterTest(MODULE *testModulePtr)
 				MeshZScale/=2;
 				
 				CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-				CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+				CheckTriangleBuffer(0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 				D3D_DrawWaterPatch(x, y, z);
 				D3D_DrawWaterPatch(x+MeshXScale, y, z);
 				D3D_DrawWaterPatch(x, y, z+MeshZScale);
@@ -4708,8 +5288,9 @@ void D3D_DrawMoltenMetalMesh_Unclipped(void)
 	int i, x, y, z;
 	int start;
 	
-	CheckTriangleBuffer(256, 0, 450, 0, (D3DTexture *)-1, -1, -1);
-	
+	CheckTriangleBuffer(256, 450, (D3DTexture *)-1, -1, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
+
 	start = varrc;
 	for (i=0; i<256; i++) {
 		GLfloat xf, yf, zf;
@@ -4807,7 +5388,8 @@ void D3D_DrawMoltenMetalMesh_Clipped(void)
 		}
 	}
 	
-	CheckTriangleBuffer(256, 0, c, 0, (D3DTexture *)-1, -1, -1);
+	CheckTriangleBuffer(256, c, (D3DTexture *)-1, -1, -1);
+	SelectProgram(AVP_SHADER_PROGRAM_NO_SECONDARY);
 	start = varrc;
 	
 		for (i=0; i<256; i++)