diff --git a/src/hardware/hw_drv.h b/src/hardware/hw_drv.h
index 7b45b09744971081723c17dbc95d7a2f94d325a5..c1ece091ae93f6ac00a0157d7265c90ed17e4009 100644
--- a/src/hardware/hw_drv.h
+++ b/src/hardware/hw_drv.h
@@ -63,10 +63,8 @@ EXPORT void HWRAPI(SetTransform) (FTransform *ptransform);
EXPORT INT32 HWRAPI(GetTextureUsed) (void);
EXPORT INT32 HWRAPI(GetRenderVersion) (void);
-#ifdef SHUFFLE
#define SCREENVERTS 10
EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2]);
-#endif
EXPORT void HWRAPI(FlushScreenTextures) (void);
EXPORT void HWRAPI(StartScreenWipe) (void);
EXPORT void HWRAPI(EndScreenWipe) (void);
@@ -105,9 +103,7 @@ struct hwdriver_s
#ifndef HAVE_SDL
Shutdown pfnShutdown;
#endif
-#ifdef SHUFFLE
PostImgRedraw pfnPostImgRedraw;
-#endif
FlushScreenTextures pfnFlushScreenTextures;
StartScreenWipe pfnStartScreenWipe;
EndScreenWipe pfnEndScreenWipe;
diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index fb5e2a71639c8caf154930511b8dcf3e4914a805..e1d5d99a7bfc058b55af47685020663e374df81c 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -6637,7 +6637,6 @@ void HWR_DoPostProcessor(player_t *player)
if (splitscreen) // Not supported in splitscreen - someone want to add support?
return;
-#ifdef SHUFFLE
// Drunken vision! WooOOooo~
if (*type == postimg_water || *type == postimg_heat)
{
@@ -6680,7 +6679,6 @@ void HWR_DoPostProcessor(player_t *player)
HWD.pfnMakeScreenTexture();
}
// Flipping of the screen isn't done here anymore
-#endif // SHUFFLE
}
void HWR_StartScreenWipe(void)
diff --git a/src/hardware/hw_md2load.c b/src/hardware/hw_md2load.c
index 49fdbf8ab214cae012984a9ef6a87f261cce225a..d29414b0f4f971514dc8252f7bf0d052a2d1e782 100644
--- a/src/hardware/hw_md2load.c
+++ b/src/hardware/hw_md2load.c
@@ -17,7 +17,7 @@
#define NUMVERTEXNORMALS 162
-// Quake 2 normals are indexed. Use avertexnormals[normalindex][x/y/z] and
+// Quake 2 normals are indexed. Use avertexnormals[normalindex][x/y/z] and
// you'll have your normals.
float avertexnormals[NUMVERTEXNORMALS][3] = {
{-0.525731f, 0.000000f, 0.850651f},
@@ -186,71 +186,57 @@ float avertexnormals[NUMVERTEXNORMALS][3] = {
typedef struct
{
- int ident; // A "magic number" that's used to identify the .md2 file
- int version; // The version of the file, always 8
- int skinwidth; // Width of the skin(s) in pixels
- int skinheight; // Height of the skin(s) in pixels
- int framesize; // Size of each frame in bytes
- int numSkins; // Number of skins with the model
- int numXYZ; // Number of vertices in each frame
- int numST; // Number of texture coordinates in each frame.
- int numTris; // Number of triangles in each frame
- int numGLcmds; // Number of dwords (4 bytes) in the gl command list.
- int numFrames; // Number of frames
- int offsetSkins; // Offset, in bytes from the start of the file, to the list of skin names.
- int offsetST; // Offset, in bytes from the start of the file, to the list of texture coordinates
- int offsetTris; // Offset, in bytes from the start of the file, to the list of triangles
- int offsetFrames; // Offset, in bytes from the start of the file, to the list of frames
- int offsetGLcmds; // Offset, in bytes from the start of the file, to the list of gl commands
- int offsetEnd; // Offset, in bytes from the start of the file, to the end of the file (filesize)
+ int ident; // A "magic number" that's used to identify the .md2 file
+ int version; // The version of the file, always 8
+ int skinwidth; // Width of the skin(s) in pixels
+ int skinheight; // Height of the skin(s) in pixels
+ int framesize; // Size of each frame in bytes
+ int numSkins; // Number of skins with the model
+ int numXYZ; // Number of vertices in each frame
+ int numST; // Number of texture coordinates in each frame.
+ int numTris; // Number of triangles in each frame
+ int numGLcmds; // Number of dwords (4 bytes) in the gl command list.
+ int numFrames; // Number of frames
+ int offsetSkins; // Offset, in bytes from the start of the file, to the list of skin names.
+ int offsetST; // Offset, in bytes from the start of the file, to the list of texture coordinates
+ int offsetTris; // Offset, in bytes from the start of the file, to the list of triangles
+ int offsetFrames; // Offset, in bytes from the start of the file, to the list of frames
+ int offsetGLcmds; // Offset, in bytes from the start of the file, to the list of gl commands
+ int offsetEnd; // Offset, in bytes from the start of the file, to the end of the file (filesize)
} md2header_t;
typedef struct
{
- unsigned short meshIndex[3]; // indices into the array of vertices in each frames
- unsigned short stIndex[3]; // indices into the array of texture coordinates
+ unsigned short meshIndex[3]; // indices into the array of vertices in each frames
+ unsigned short stIndex[3]; // indices into the array of texture coordinates
} md2triangle_t;
typedef struct
{
- short s;
- short t;
+ short s;
+ short t;
} md2texcoord_t;
typedef struct
{
- unsigned char v[3]; // Scaled vertices. You'll need to multiply them with scale[x] to make them normal.
- unsigned char lightNormalIndex; // Index to the array of normals
+ unsigned char v[3]; // Scaled vertices. You'll need to multiply them with scale[x] to make them normal.
+ unsigned char lightNormalIndex; // Index to the array of normals
} md2vertex_t;
typedef struct
{
- float scale[3]; // Used by the v member in the md2framePoint structure
- float translate[3]; // Used by the v member in the md2framePoint structure
- char name[16]; // Name of the frame
+ float scale[3]; // Used by the v member in the md2framePoint structure
+ float translate[3]; // Used by the v member in the md2framePoint structure
+ char name[16]; // Name of the frame
} md2frame_t;
// Load the model
model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
{
+ useFloat = true;
model_t *retModel = NULL;
md2header_t *header;
- size_t fileLen;
- size_t fileReadLen;
- int i, j, t;
-
- size_t namelen;
- char *texturefilename, *buffer;
- const char *texPos;
-
- const float WUNITS = 1.0f;
- float dataScale;
-
- md2triangle_t *tris;
- md2texcoord_t *texcoords;
- md2frame_t *frames;
-
FILE *f = fopen(fileName, "rb");
if (!f)
@@ -258,7 +244,13 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
- texPos = strchr(fileName, '/');
+ size_t fileLen;
+
+ int i, j;
+
+ size_t namelen;
+ char *texturefilename;
+ const char *texPos = strchr(fileName, '/');
if (texPos)
{
@@ -274,9 +266,9 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
strcpy(texturefilename, fileName);
}
- texturefilename[namelen-2] = 'z';
- texturefilename[namelen-3] = 'u';
- texturefilename[namelen-4] = 'b';
+ texturefilename[namelen - 2] = 'z';
+ texturefilename[namelen - 3] = 'u';
+ texturefilename[namelen - 4] = 'b';
// find length of file
fseek(f, 0, SEEK_END);
@@ -284,25 +276,23 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
fseek(f, 0, SEEK_SET);
// read in file
- buffer = malloc(fileLen);
- fileReadLen = fread(buffer, fileLen, 1, f);
+ char *buffer = malloc(fileLen);
+ fread(buffer, fileLen, 1, f);
fclose(f);
- (void)fileReadLen; // intentionally ignore return value, per buildbot
-
// get pointer to file header
header = (md2header_t*)buffer;
retModel->numMeshes = 1; // MD2 only has one mesh
retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, 0);
retModel->meshes[0].numFrames = header->numFrames;
-
- dataScale = WUNITS;
+ const float WUNITS = 1.0f;
+ float dataScale = WUNITS;
// Tris and ST are simple structures that can be straight-copied
- tris = (md2triangle_t*)&buffer[header->offsetTris];
- texcoords = (md2texcoord_t*)&buffer[header->offsetST];
- frames = (md2frame_t*)&buffer[header->offsetFrames];
+ md2triangle_t *tris = (md2triangle_t*)&buffer[header->offsetTris];
+ md2texcoord_t *texcoords = (md2texcoord_t*)&buffer[header->offsetST];
+ md2frame_t *frames = (md2frame_t*)&buffer[header->offsetFrames];
// Read in textures
retModel->numMaterials = header->numSkins;
@@ -312,6 +302,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
+ int t;
for (t = 0; t < retModel->numMaterials; t++)
{
retModel->materials[t].ambient[0] = 0.8f;
@@ -333,86 +324,76 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
retModel->materials[t].shininess = 0.0f;
retModel->materials[t].spheremap = false;
-/* retModel->materials[t].texture = Texture::ReadTexture((char*)texturefilename, ZT_TEXTURE);
-
- if (!systemSucks)
- {
- // Check for a normal map...??
- Resource::resource_t *res
- char openfilename[1024];
- char normalMapName[1024];
- strcpy(normalMapName, texturefilename);
- size_t len = strlen(normalMapName);
- char *ptr = &normalMapName[len];
- ptr--; // z
- ptr--; // u
- ptr--; // b
- ptr--; // .
- *ptr++ = '_';
- *ptr++ = 'n';
- *ptr++ = '.';
- *ptr++ = 'b';
- *ptr++ = 'u';
- *ptr++ = 'z';
- *ptr++ = '\0';
-
- sprintf(openfilename, "%s/%s", "textures", normalMapName);
- // Convert backslashes to forward slashes
- for (int k = 0; k < 1024; k++)
- {
- if (openfilename[k] == '\0')
- break;
-
- if (openfilename[k] == '\\')
- openfilename[k] = '/';
- }
-
- res = Resource::Open(openfilename);
- if (res)
- {
- Resource::Close(res);
- retModel->materials[t].lightmap = Texture::ReadTexture(normalMapName, ZT_TEXTURE);
- }
- }*/
+ /* retModel->materials[t].texture = Texture::ReadTexture((char*)texturefilename, ZT_TEXTURE);
+
+ if (!systemSucks)
+ {
+ // Check for a normal map...??
+ char openfilename[1024];
+ char normalMapName[1024];
+ strcpy(normalMapName, texturefilename);
+ size_t len = strlen(normalMapName);
+ char *ptr = &normalMapName[len];
+ ptr--; // z
+ ptr--; // u
+ ptr--; // b
+ ptr--; // .
+ *ptr++ = '_';
+ *ptr++ = 'n';
+ *ptr++ = '.';
+ *ptr++ = 'b';
+ *ptr++ = 'u';
+ *ptr++ = 'z';
+ *ptr++ = '\0';
+
+ sprintf(openfilename, "%s/%s", "textures", normalMapName);
+ // Convert backslashes to forward slashes
+ for (int k = 0; k < 1024; k++)
+ {
+ if (openfilename[k] == '\0')
+ break;
+
+ if (openfilename[k] == '\\')
+ openfilename[k] = '/';
+ }
+
+ Resource::resource_t *res = Resource::Open(openfilename);
+ if (res)
+ {
+ Resource::Close(res);
+ retModel->materials[t].lightmap = Texture::ReadTexture(normalMapName, ZT_TEXTURE);
+ }
+ }*/
}
retModel->meshes[0].numTriangles = header->numTris;
if (!useFloat) // Decompress to MD3 'tinyframe' space
{
- char *ptr = (char*)frames;
- md2triangle_t *trisPtr;
- unsigned short *indexptr;
- float *uvptr;
-
dataScale = 0.015624f; // 1 / 64.0f
retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, 0);
retModel->meshes[0].numVertices = header->numXYZ;
- retModel->meshes[0].uvs = (float*)Z_Malloc (sizeof(float)*2*retModel->meshes[0].numVertices, ztag, 0);
+ retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
+ byte *ptr = (byte*)frames;
for (i = 0; i < header->numFrames; i++, ptr += header->framesize)
{
- short *vertptr;
- char *normptr;
- //char *tanptr;
md2frame_t *framePtr = (md2frame_t*)ptr;
- md2vertex_t *vertex;
-
- retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short)*3*header->numXYZ, ztag, 0);
- retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char)*3*header->numXYZ, ztag, 0);
+ retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, 0);
+ retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, 0);
-// if (retModel->materials[0].lightmap)
-// retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
+ // if (retModel->materials[0].lightmap)
+ // retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, 0);
- vertptr = retModel->meshes[0].tinyframes[i].vertices;
- normptr = retModel->meshes[0].tinyframes[i].normals;
+ short *vertptr = retModel->meshes[0].tinyframes[i].vertices;
+ char *normptr = retModel->meshes[0].tinyframes[i].normals;
-// tanptr = retModel->meshes[0].tinyframes[i].tangents;
+ // char *tanptr = retModel->meshes[0].tinyframes[i].tangents;
retModel->meshes[0].tinyframes[i].material = &retModel->materials[0];
framePtr++; // Advance to vertex list
- vertex = (md2vertex_t*)framePtr;
+ md2vertex_t *vertex = (md2vertex_t*)framePtr;
framePtr--;
for (j = 0; j < header->numXYZ; j++, vertex++)
{
@@ -425,15 +406,15 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
// Normal
*normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][0] * 127);
- *normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][1] * 127);
*normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][2] * 127);
+ *normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][1] * 127);
}
}
// This doesn't need to be done every frame!
- trisPtr = tris;
- indexptr = retModel->meshes[0].indices;
- uvptr = (float*)retModel->meshes[0].uvs;
+ md2triangle_t *trisPtr = tris;
+ unsigned short *indexptr = retModel->meshes[0].indices;
+ float *uvptr = (float*)retModel->meshes[0].uvs;
for (j = 0; j < header->numTris; j++, trisPtr++)
{
*indexptr = trisPtr->meshIndex[0];
@@ -453,15 +434,12 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
}
else // Full float loading method
{
- md2triangle_t *trisPtr = tris;
- float *uvptr;
- char *ptr = (char*)frames;
-
- retModel->meshes[0].numVertices = header->numTris*3;
+ retModel->meshes[0].numVertices = header->numTris * 3;
retModel->meshes[0].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*header->numFrames, ztag, 0);
- retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float)*2*retModel->meshes[0].numVertices, ztag, 0);
- uvptr = retModel->meshes[0].uvs;
+ retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
+ md2triangle_t *trisPtr = tris;
+ float *uvptr = retModel->meshes[0].uvs;
for (i = 0; i < retModel->meshes[0].numTriangles; i++, trisPtr++)
{
*uvptr++ = texcoords[trisPtr->stIndex[0]].s / (float)header->skinwidth;
@@ -472,16 +450,15 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
*uvptr++ = (texcoords[trisPtr->stIndex[2]].t / (float)header->skinheight);
}
+ byte *ptr = (byte*)frames;
for (i = 0; i < header->numFrames; i++, ptr += header->framesize)
{
- md2vertex_t *vertex;
md2frame_t *framePtr = (md2frame_t*)ptr;
+ retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
+ retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
+ // if (retModel->materials[0].lightmap)
+ // retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag);
float *vertptr, *normptr;
- retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag, 0);
- retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag, 0);
-// if (retModel->materials[0].lightmap)
-// retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag);
-
normptr = (float*)retModel->meshes[0].frames[i].normals;
vertptr = (float*)retModel->meshes[0].frames[i].vertices;
trisPtr = tris;
@@ -489,7 +466,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
retModel->meshes[0].frames[i].material = &retModel->materials[0];
framePtr++; // Advance to vertex list
- vertex = (md2vertex_t*)framePtr;
+ md2vertex_t *vertex = (md2vertex_t*)framePtr;
framePtr--;
for (j = 0; j < header->numTris; j++, trisPtr++)
{
@@ -515,26 +492,17 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
vertptr++;
*normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][0];
- *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][1];
*normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][2];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][1];
*normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][0];
- *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][1];
*normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][2];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][1];
*normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][0];
- *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][1];
*normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][2];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][1];
}
- /*
- // Rotate MD2 by 90 degrees in code BLAAHH
- vector_t *normVecptr = (vector_t*)retModel->meshes[0].frames[i].normals;
- vector_t *vertVecptr = (vector_t*)retModel->meshes[0].frames[i].vertices;
- for (j = 0; j < header->numTris * 3; j++, normVecptr++, vertVecptr++)
- {
- VectorRotate(normVecptr, &vectorYaxis, -90.0f);
- VectorRotate(vertVecptr, &vectorYaxis, -90.0f);
- }*/
}
}
diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c
index fec8c33a3cdc35a1feef15334f3db2b36a338ded..4f77680d95d0faa614ddf83b80bbd2fb603027bd 100644
--- a/src/hardware/r_opengl/r_opengl.c
+++ b/src/hardware/r_opengl/r_opengl.c
@@ -29,11 +29,6 @@
#include <stdarg.h>
#include <math.h>
-#ifndef SHUFFLE
-#ifndef KOS_GL_COMPATIBILITY
-#define SHUFFLE
-#endif
-#endif
#include "r_opengl.h"
#if defined (HWRENDER) && !defined (NOROPENGL)
@@ -83,9 +78,7 @@ GLint screen_height = 0;
GLbyte screen_depth = 0;
GLint textureformatGL = 0;
GLint maximumAnisotropy = 0;
-#ifndef KOS_GL_COMPATIBILITY
static GLboolean MipMap = GL_FALSE;
-#endif
static GLint min_filter = GL_LINEAR;
static GLint mag_filter = GL_LINEAR;
static GLint anisotropic_filter = 0;
@@ -94,11 +87,9 @@ static FTransform md2_transform;
const GLubyte *gl_extensions = NULL;
//Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-)
-#ifndef MINI_GL_COMPATIBILITY
static GLdouble modelMatrix[16];
static GLdouble projMatrix[16];
static GLint viewport[4];
-#endif
#ifdef USE_PALETTED_TEXTURE
@@ -167,11 +158,6 @@ float byteasfloat(UINT8 fbyte)
static I_Error_t I_Error_GL = NULL;
-#ifndef MINI_GL_COMPATIBILITY
-static boolean gl13 = false; // whether we can use opengl 1.3 functions
-#endif
-
-
// -----------------+
// DBG_Printf : Output error messages to debug log if DEBUG_TO_FILE is defined,
// : else do nothing
@@ -207,14 +193,10 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglScissor glScissor
#define pglEnable glEnable
#define pglDisable glDisable
-#ifndef MINI_GL_COMPATIBILITY
#define pglGetDoublev glGetDoublev
-#endif
//glGetIntegerv
//glGetString
-#ifdef KOS_GL_COMPATIBILITY
#define pglHint glHint
-#endif
/* Depth Buffer */
#define pglClearDepth glClearDepth
@@ -228,11 +210,8 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglPushMatrix glPushMatrix
#define pglPopMatrix glPopMatrix
#define pglLoadIdentity glLoadIdentity
-#ifdef MINI_GL_COMPATIBILITY
#define pglMultMatrixf glMultMatrixf
-#else
#define pglMultMatrixd glMultMatrixd
-#endif
#define pglRotatef glRotatef
#define pglScalef glScalef
#define pglTranslatef glTranslatef
@@ -241,6 +220,7 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglBegin glBegin
#define pglEnd glEnd
#define pglVertex3f glVertex3f
+#define pglVertex3fv glVertex3fv
#define pglVertex3sv glVertex3sv
#define pglNormal3f glNormal3f
#define pglNormal3bv glNormal3bv
@@ -254,7 +234,8 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglDrawArrays glDrawArrays
#define pglDrawElements glDrawElements
#define pglEnableClientState glEnableClientState
-#define pglDisableClientState pglDisableClientState
+#define pglDisableClientState glDisableClientState
+#define pglClientActiveTexture glClientActiveTexture
/* Lighting */
#define pglShadeModel glShadeModel
@@ -280,10 +261,8 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglDeleteTextures glDeleteTextures
#define pglBindTexture glBindTexture
/* texture mapping */ //GL_EXT_copy_texture
-#ifndef KOS_GL_COMPATIBILITY
#define pglCopyTexImage2D glCopyTexImage2D
#define pglCopyTexSubImage2D glCopyTexSubImage2D
-#endif
#else //!STATIC_OPENGL
@@ -310,10 +289,8 @@ typedef void (APIENTRY * PFNglEnable) (GLenum cap);
static PFNglEnable pglEnable;
typedef void (APIENTRY * PFNglDisable) (GLenum cap);
static PFNglDisable pglDisable;
-#ifndef MINI_GL_COMPATIBILITY
typedef void (APIENTRY * PFNglGetDoublev) (GLenum pname, GLdouble *params);
static PFNglGetDoublev pglGetDoublev;
-#endif
//glGetIntegerv
//glGetString
@@ -338,13 +315,10 @@ typedef void (APIENTRY * PFNglPopMatrix) (void);
static PFNglPopMatrix pglPopMatrix;
typedef void (APIENTRY * PFNglLoadIdentity) (void);
static PFNglLoadIdentity pglLoadIdentity;
-#ifdef MINI_GL_COMPATIBILITY
typedef void (APIENTRY * PFNglMultMatrixf) (const GLfloat *m);
static PFNglMultMatrixf pglMultMatrixf;
-#else
typedef void (APIENTRY * PFNglMultMatrixd) (const GLdouble *m);
static PFNglMultMatrixd pglMultMatrixd;
-#endif
typedef void (APIENTRY * PFNglRotatef) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
static PFNglRotatef pglRotatef;
typedef void (APIENTRY * PFNglScalef) (GLfloat x, GLfloat y, GLfloat z);
@@ -359,6 +333,8 @@ typedef void (APIENTRY * PFNglEnd) (void);
static PFNglEnd pglEnd;
typedef void (APIENTRY * PFNglVertex3f) (GLfloat x, GLfloat y, GLfloat z);
static PFNglVertex3f pglVertex3f;
+typedef void (APIENTRY * PFNglVertex3fv)(const GLfloat *v);
+static PFNglVertex3fv pglVertex3fv;
typedef void (APIENTRY * PFNglVertex3sv) (const GLshort *v);
static PFNglVertex3sv pglVertex3sv;
typedef void (APIENTRY * PFNglNormal3f) (GLfloat x, GLfloat y, GLfloat z);
@@ -434,15 +410,16 @@ static PFNglCopyTexSubImage2D pglCopyTexSubImage2D;
typedef GLint (APIENTRY * PFNgluBuild2DMipmaps) (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data);
static PFNgluBuild2DMipmaps pgluBuild2DMipmaps;
-#ifndef MINI_GL_COMPATIBILITY
/* 1.3 functions for multitexturing */
typedef void (APIENTRY *PFNglActiveTexture) (GLenum);
static PFNglActiveTexture pglActiveTexture;
typedef void (APIENTRY *PFNglMultiTexCoord2f) (GLenum, GLfloat, GLfloat);
static PFNglMultiTexCoord2f pglMultiTexCoord2f;
-#endif
+typedef void (APIENTRY *PFNglMultiTexCoord2fv) (GLenum target, const GLfloat *v);
+static PFNglMultiTexCoord2fv pglMultiTexCoord2fv;
+typedef void (APIENTRY *PFNglClientActiveTexture) (GLenum);
+static PFNglClientActiveTexture pglClientActiveTexture;
-#ifndef MINI_GL_COMPATIBILITY
/* 1.2 Parms */
/* GL_CLAMP_TO_EDGE_EXT */
#ifndef GL_CLAMP_TO_EDGE
@@ -463,14 +440,6 @@ static PFNglMultiTexCoord2f pglMultiTexCoord2f;
#define GL_TEXTURE1 0x84C1
#endif
-#endif
-
-#ifdef MINI_GL_COMPATIBILITY
-#undef GL_CLAMP_TO_EDGE
-#undef GL_TEXTURE_MIN_LOD
-#undef GL_TEXTURE_MAX_LOD
-#endif
-
boolean SetupGLfunc(void)
{
#ifndef STATIC_OPENGL
@@ -493,9 +462,7 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglScissor , glScissor)
GETOPENGLFUNC(pglEnable , glEnable)
GETOPENGLFUNC(pglDisable , glDisable)
-#ifndef MINI_GL_COMPATIBILITY
GETOPENGLFUNC(pglGetDoublev , glGetDoublev)
-#endif
GETOPENGLFUNC(pglGetIntegerv , glGetIntegerv)
GETOPENGLFUNC(pglGetString , glGetString)
@@ -509,11 +476,8 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglPushMatrix , glPushMatrix)
GETOPENGLFUNC(pglPopMatrix , glPopMatrix)
GETOPENGLFUNC(pglLoadIdentity , glLoadIdentity)
-#ifdef MINI_GL_COMPATIBILITY
GETOPENGLFUNC(pglMultMatrixf , glMultMatrixf)
-#else
GETOPENGLFUNC(pglMultMatrixd , glMultMatrixd)
-#endif
GETOPENGLFUNC(pglRotatef , glRotatef)
GETOPENGLFUNC(pglScalef , glScalef)
GETOPENGLFUNC(pglTranslatef , glTranslatef)
@@ -521,6 +485,7 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglBegin , glBegin)
GETOPENGLFUNC(pglEnd , glEnd)
GETOPENGLFUNC(pglVertex3f , glVertex3f)
+ GETOPENGLFUNC(pglVertex3fv, glVertex3fv)
GETOPENGLFUNC(pglVertex3sv, glVertex3sv)
GETOPENGLFUNC(pglNormal3f , glNormal3f)
GETOPENGLFUNC(pglNormal3bv, glNormal3bv)
@@ -535,6 +500,9 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglDrawElements, glDrawElements)
GETOPENGLFUNC(pglEnableClientState, glEnableClientState)
GETOPENGLFUNC(pglDisableClientState, glDisableClientState)
+ GETOPENGLFUNC(pglClientActiveTexture, glClientActiveTexture)
+ if (!pglClientActiveTexture)
+ GETOPENGLFUNC(pglClientActiveTexture, glClientActiveTextureARB)
GETOPENGLFUNC(pglShadeModel , glShadeModel)
GETOPENGLFUNC(pglLightfv, glLightfv)
@@ -566,47 +534,15 @@ boolean SetupGLfunc(void)
}
// This has to be done after the context is created so the version number can be obtained
+// This is stupid -- even some of the oldest usable OpenGL hardware today supports 1.3-level featureset.
boolean SetupGLFunc13(void)
{
-#ifdef MINI_GL_COMPATIBILITY
- return false;
-#else
- const GLubyte *version = pglGetString(GL_VERSION);
- int glmajor, glminor;
-
- gl13 = false;
- // Parse the GL version
- if (version != NULL)
- {
- if (sscanf((const char*)version, "%d.%d", &glmajor, &glminor) == 2)
- {
- // Look, we gotta prepare for the inevitable arrival of GL 2.0 code...
- if (glmajor == 1 && glminor >= 3)
- gl13 = true;
- else if (glmajor > 1)
- gl13 = true;
- }
- }
-
- if (gl13)
- {
- pglActiveTexture = GetGLFunc("glActiveTexture");
- pglMultiTexCoord2f = GetGLFunc("glMultiTexCoord2f");
- }
- else if (isExtAvailable("GL_ARB_multitexture", gl_extensions))
- {
- // Get the functions
- pglActiveTexture = GetGLFunc("glActiveTextureARB");
- pglMultiTexCoord2f = GetGLFunc("glMultiTexCoord2fARB");
-
- gl13 = true; // This is now true, so the new fade mask stuff can be done, if OpenGL version is less than 1.3, it still uses the old fade stuff.
- DBG_Printf("GL_ARB_multitexture support: enabled\n");
-
- }
- else
- DBG_Printf("GL_ARB_multitexture support: disabled\n");
+ pglActiveTexture = GetGLFunc("glActiveTexture");
+ pglMultiTexCoord2f = GetGLFunc("glMultiTexCoord2f");
+ pglClientActiveTexture = GetGLFunc("glClientActiveTexture");
+ pglMultiTexCoord2fv = GetGLFunc("glMultiTexCoord2fv");
+
return true;
-#endif
}
// -----------------+
@@ -624,11 +560,7 @@ static void SetNoTexture(void)
static void GLPerspective(GLdouble fovy, GLdouble aspect)
{
-#ifdef MINI_GL_COMPATIBILITY
- GLfloat m[4][4] =
-#else
GLdouble m[4][4] =
-#endif
{
{ 1.0f, 0.0f, 0.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f, 0.0f},
@@ -651,14 +583,10 @@ static void GLPerspective(GLdouble fovy, GLdouble aspect)
m[1][1] = cotangent;
m[2][2] = -(zFar + zNear) / deltaZ;
m[3][2] = -2.0f * zNear * zFar / deltaZ;
-#ifdef MINI_GL_COMPATIBILITY
- pglMultMatrixf(&m[0][0]);
-#else
+
pglMultMatrixd(&m[0][0]);
-#endif
}
-#ifndef MINI_GL_COMPATIBILITY
static void GLProject(GLdouble objX, GLdouble objY, GLdouble objZ,
GLdouble* winX, GLdouble* winY, GLdouble* winZ)
{
@@ -698,7 +626,6 @@ static void GLProject(GLdouble objX, GLdouble objY, GLdouble objZ,
*winY=in[1];
*winZ=in[2];
}
-#endif
// -----------------+
// SetModelView :
@@ -729,10 +656,8 @@ void SetModelView(GLint w, GLint h)
//pglScalef(1.0f, 320.0f/200.0f, 1.0f); // gr_scalefrustum (ORIGINAL_ASPECT)
// added for new coronas' code (without depth buffer)
-#ifndef MINI_GL_COMPATIBILITY
pglGetIntegerv(GL_VIEWPORT, viewport);
pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
-#endif
}
@@ -757,17 +682,15 @@ void SetStates(void)
//pglShadeModel(GL_FLAT);
pglEnable(GL_TEXTURE_2D); // two-dimensional texturing
-#ifndef KOS_GL_COMPATIBILITY
+
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
-#endif
+
//pglBlendFunc(GL_ONE, GL_ZERO); // copy pixel to frame buffer (opaque)
pglEnable(GL_BLEND); // enable color blending
-#ifndef KOS_GL_COMPATIBILITY
pglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-#endif
//pglDisable(GL_DITHER); // faB: ??? (undocumented in OpenGL 1.1)
// Hurdler: yes, it is!
@@ -792,9 +715,7 @@ void SetStates(void)
//tex_downloaded = NOTEXTURE_NUM;
//pglTexImage2D(GL_TEXTURE_2D, 0, 4, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, Data);
-#ifndef KOS_GL_COMPATIBILITY
pglPolygonOffset(-1.0f, -1.0f);
-#endif
//pglEnable(GL_CULL_FACE);
//pglCullFace(GL_FRONT);
@@ -815,9 +736,7 @@ void SetStates(void)
// bp : when no t&l :)
pglLoadIdentity();
pglScalef(1.0f, 1.0f, -1.0f);
-#ifndef MINI_GL_COMPATIBILITY
pglGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
-#endif
}
@@ -921,14 +840,6 @@ EXPORT void HWRAPI(ClearMipMapCache) (void)
EXPORT void HWRAPI(ReadRect) (INT32 x, INT32 y, INT32 width, INT32 height,
INT32 dst_stride, UINT16 * dst_data)
{
-#ifdef KOS_GL_COMPATIBILITY
- (void)x;
- (void)y;
- (void)width;
- (void)height;
- (void)dst_stride;
- (void)dst_data;
-#else
INT32 i;
// DBG_Printf ("ReadRect()\n");
if (dst_stride == width*3)
@@ -970,7 +881,6 @@ EXPORT void HWRAPI(ReadRect) (INT32 x, INT32 y, INT32 width, INT32 height,
}
free(image);
}
-#endif
}
@@ -991,10 +901,8 @@ EXPORT void HWRAPI(GClipRect) (INT32 minx, INT32 miny, INT32 maxx, INT32 maxy, f
pglMatrixMode(GL_MODELVIEW);
// added for new coronas' code (without depth buffer)
-#ifndef MINI_GL_COMPATIBILITY
pglGetIntegerv(GL_VIEWPORT, viewport);
pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
-#endif
}
@@ -1041,12 +949,9 @@ EXPORT void HWRAPI(Draw2DLine) (F2DCoord * v1,
GLRGBAFloat c;
// DBG_Printf ("DrawLine() (%f %f %f) %d\n", v1->x, -v1->y, -v1->z, v1->argb);
-#ifdef MINI_GL_COMPATIBILITY
- GLfloat px1, px2, px3, px4;
- GLfloat py1, py2, py3, py4;
+ GLfloat p[12];
GLfloat dx, dy;
GLfloat angle;
-#endif
// BP: we should reflect the new state in our variable
//SetBlend(PF_Modulated|PF_NoTexture);
@@ -1058,33 +963,24 @@ EXPORT void HWRAPI(Draw2DLine) (F2DCoord * v1,
c.blue = byte2float[Color.s.blue];
c.alpha = byte2float[Color.s.alpha];
-#ifndef MINI_GL_COMPATIBILITY
- pglColor4fv(&c.red); // is in RGBA float format
- pglBegin(GL_LINES);
- pglVertex3f(v1->x, -v1->y, 1.0f);
- pglVertex3f(v2->x, -v2->y, 1.0f);
- pglEnd();
-#else
+ // This is the preferred, 'modern' way of rendering lines -- creating a polygon.
if (v2->x != v1->x)
angle = (float)atan((v2->y-v1->y)/(v2->x-v1->x));
else
- angle = N_PI_DEMI;
+ angle = (float)N_PI_DEMI;
dx = (float)sin(angle) / (float)screen_width;
dy = (float)cos(angle) / (float)screen_height;
- px1 = v1->x - dx; py1 = v1->y + dy;
- px2 = v2->x - dx; py2 = v2->y + dy;
- px3 = v2->x + dx; py3 = v2->y - dy;
- px4 = v1->x + dx; py4 = v1->y - dy;
-
- pglColor4f(c.red, c.green, c.blue, c.alpha);
- pglBegin(GL_TRIANGLE_FAN);
- pglVertex3f(px1, -py1, 1);
- pglVertex3f(px2, -py2, 1);
- pglVertex3f(px3, -py3, 1);
- pglVertex3f(px4, -py4, 1);
- pglEnd();
-#endif
+ p[0] = v1->x - dx; p[1] = -(v1->y + dy); p[2] = 1;
+ p[3] = v2->x - dx; p[4] = -(v2->y + dy); p[5] = 1;
+ p[6] = v2->x + dx; p[7] = -(v2->y - dy); p[8] = 1;
+ p[9] = v1->x + dx; p[10] = -(v1->y - dy); p[11] = 1;
+
+ pglColor4fv(&c.red); // is in RGBA float format
+ pglEnableClientState(GL_VERTEX_ARRAY);
+ pglVertexPointer(3, GL_FLOAT, 0, p);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ pglDisableClientState(GL_VERTEX_ARRAY);
pglEnable(GL_TEXTURE_2D);
}
@@ -1114,60 +1010,42 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
switch (PolyFlags & PF_Blending) {
case PF_Translucent & PF_Blending:
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
-#endif
break;
case PF_Masked & PF_Blending:
// Hurdler: does that mean lighting is only made by alpha src?
// it sounds ok, but not for polygonsmooth
pglBlendFunc(GL_SRC_ALPHA, GL_ZERO); // 0 alpha = holes in texture
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_GREATER, 0.5f);
-#endif
break;
case PF_Additive & PF_Blending:
-#ifdef ATI_RAGE_PRO_COMPATIBILITY
- pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
-#else
pglBlendFunc(GL_SRC_ALPHA, GL_ONE); // src * alpha + dest
-#endif
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
-#endif
break;
case PF_Environment & PF_Blending:
pglBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
-#endif
break;
case PF_Substractive & PF_Blending:
// good for shadow
- // not realy but what else ?
+ // not really but what else ?
pglBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
-#endif
break;
case PF_Fog & PF_Fog:
// Sryder: Fog
// multiplies input colour by input alpha, and destination colour by input colour, then adds them
pglBlendFunc(GL_SRC_ALPHA, GL_SRC_COLOR);
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
-#endif
break;
default : // must be 0, otherwise it's an error
// No blending
pglBlendFunc(GL_ONE, GL_ZERO); // the same as no blending
-#ifndef KOS_GL_COMPATIBILITY
pglAlphaFunc(GL_GREATER, 0.5f);
-#endif
break;
}
}
-#ifndef KOS_GL_COMPATIBILITY
+
if (Xor & PF_NoAlphaTest)
{
if (PolyFlags & PF_NoAlphaTest)
@@ -1183,7 +1061,7 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
else
pglDisable(GL_POLYGON_OFFSET_FILL);
}
-#endif
+
if (Xor&PF_NoDepthTest)
{
if (PolyFlags & PF_NoDepthTest)
@@ -1210,10 +1088,6 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
-#ifdef KOS_GL_COMPATIBILITY
- if (Xor&PF_Modulated && !(PolyFlags & PF_Modulated))
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-#else
if (Xor&PF_Modulated)
{
#if defined (__unix__) || defined (UNIXCOMMON)
@@ -1233,7 +1107,6 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
}
-#endif
if (Xor & PF_Occlude) // depth test but (no) depth write
{
@@ -1287,11 +1160,7 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
else
{
// Download a mipmap
-#ifdef KOS_GL_COMPATIBILITY
- static GLushort tex[2048*2048];
-#else
static RGBA_t tex[2048*2048];
-#endif
const GLvoid *ptex = tex;
INT32 w, h;
@@ -1310,102 +1179,7 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
}
else
#endif
-#ifdef KOS_GL_COMPATIBILITY
- if ((pTexInfo->grInfo.format == GR_TEXFMT_P_8) ||
- (pTexInfo->grInfo.format == GR_TEXFMT_AP_88))
- {
- const GLubyte *pImgData = (const GLubyte *)pTexInfo->grInfo.data;
- INT32 i, j;
-
- for (j = 0; j < h; j++)
- {
- for (i = 0; i < w; i++)
- {
- if ((*pImgData == HWR_PATCHES_CHROMAKEY_COLORINDEX) &&
- (pTexInfo->flags & TF_CHROMAKEYED))
- {
- tex[w*j+i] = 0;
- }
- else
- {
- if (pTexInfo->grInfo.format == GR_TEXFMT_AP_88 && !(pTexInfo->flags & TF_CHROMAKEYED))
- tex[w*j+i] = 0;
- else
- tex[w*j+i] = (myPaletteData[*pImgData].s.alpha>>4)<<12;
-
- tex[w*j+i] |= (myPaletteData[*pImgData].s.red >>4)<<8;
- tex[w*j+i] |= (myPaletteData[*pImgData].s.green>>4)<<4;
- tex[w*j+i] |= (myPaletteData[*pImgData].s.blue >>4);
- }
-
- pImgData++;
-
- if (pTexInfo->grInfo.format == GR_TEXFMT_AP_88)
- {
- if (!(pTexInfo->flags & TF_CHROMAKEYED))
- tex[w*j+i] |= ((*pImgData)>>4)<<12;
- pImgData++;
- }
-
- }
- }
- }
- else if (pTexInfo->grInfo.format == GR_RGBA)
- {
- // corona test : passed as ARGB 8888, which is not in glide formats
- // Hurdler: not used for coronas anymore, just for dynamic lighting
- const RGBA_t *pImgData = (const RGBA_t *)pTexInfo->grInfo.data;
- INT32 i, j;
-
- for (j = 0; j < h; j++)
- {
- for (i = 0; i < w; i++)
- {
- tex[w*j+i] = (pImgData->s.alpha>>4)<<12;
- tex[w*j+i] |= (pImgData->s.red >>4)<<8;
- tex[w*j+i] |= (pImgData->s.green>>4)<<4;
- tex[w*j+i] |= (pImgData->s.blue >>4);
- pImgData++;
- }
- }
- }
- else if (pTexInfo->grInfo.format == GR_TEXFMT_ALPHA_INTENSITY_88)
- {
- const GLubyte *pImgData = (const GLubyte *)pTexInfo->grInfo.data;
- INT32 i, j;
- for (j = 0; j < h; j++)
- {
- for (i = 0; i < w; i++)
- {
- const GLubyte sID = (*pImgData)>>4;
- tex[w*j+i] = sID<<8 | sID<<4 | sID;
- pImgData++;
- tex[w*j+i] |= ((*pImgData)>>4)<<12;
- pImgData++;
- }
- }
- }
- else if (pTexInfo->grInfo.format == GR_TEXFMT_ALPHA_8) // Used for fade masks
- {
- const GLubyte *pImgData = (const GLubyte *)pTexInfo->grInfo.data;
- INT32 i, j;
-
- for (j = 0; j < h; j++)
- {
- for (i = 0; i < w; i++)
- {
- tex[w*j+i] = (pImgData>>4)<<12;
- tex[w*j+i] |= (255>>4)<<8;
- tex[w*j+i] |= (255>>4)<<4;
- tex[w*j+i] |= (255>>4);
- pImgData++;
- }
- }
- }
- else
- DBG_Printf ("SetTexture(bad format) %ld\n", pTexInfo->grInfo.format);
-#else
if ((pTexInfo->grInfo.format == GR_TEXFMT_P_8) ||
(pTexInfo->grInfo.format == GR_TEXFMT_AP_88))
{
@@ -1488,7 +1262,6 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
}
else
DBG_Printf ("SetTexture(bad format) %ld\n", pTexInfo->grInfo.format);
-#endif
pTexInfo->downloaded = NextTexAvail++;
tex_downloaded = pTexInfo->downloaded;
@@ -1497,13 +1270,8 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
// disable texture filtering on any texture that has holes so there's no dumb borders or blending issues
if (pTexInfo->flags & TF_TRANSPARENT)
{
-#ifdef KOS_GL_COMPATIBILITY
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NONE);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NONE);
-#else
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-#endif
}
else
{
@@ -1511,29 +1279,6 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
}
-#ifdef KOS_GL_COMPATIBILITY
- pglTexImage2D(GL_TEXTURE_2D, 0, GL_ARGB4444, w, h, 0, GL_ARGB4444, GL_UNSIGNED_BYTE, ptex);
-#else
-#ifdef MINI_GL_COMPATIBILITY
- //if (pTexInfo->grInfo.format == GR_TEXFMT_ALPHA_INTENSITY_88)
- //pglTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
- //else
- if (MipMap)
- pgluBuild2DMipmaps(GL_TEXTURE_2D, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
- else
- pglTexImage2D(GL_TEXTURE_2D, 0, 4, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
-#else
-#ifdef USE_PALETTED_TEXTURE
- //Hurdler: not really supported and not tested recently
- if (glColorTableEXT &&
- (pTexInfo->grInfo.format == GR_TEXFMT_P_8) &&
- !(pTexInfo->flags & TF_CHROMAKEYED))
- {
- glColorTableEXT(GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, palette_tex);
- pglTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, w, h, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, pTexInfo->grInfo.data);
- }
- else
-#endif
if (pTexInfo->grInfo.format == GR_TEXFMT_ALPHA_INTENSITY_88)
{
//pglTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
@@ -1593,8 +1338,6 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
else
pglTexImage2D(GL_TEXTURE_2D, 0, textureformatGL, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
}
-#endif
-#endif
if (pTexInfo->flags & TF_WRAPX)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@@ -1618,19 +1361,6 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
else // initialisation de la liste
gr_cachetail = gr_cachehead = pTexInfo;
}
-#ifdef MINI_GL_COMPATIBILITY
- switch (pTexInfo->flags)
- {
- case 0 :
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
- break;
- default:
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- break;
- }
-#endif
}
@@ -1644,18 +1374,11 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
FBITFIELD PolyFlags)
{
FUINT i;
-#ifndef MINI_GL_COMPATIBILITY
FUINT j;
-#endif
GLRGBAFloat c = {0,0,0,0};
-#ifdef MINI_GL_COMPATIBILITY
- if (PolyFlags & PF_Corona)
- PolyFlags &= ~PF_NoDepthTest;
-#else
if ((PolyFlags & PF_Corona) && (oglflags & GLF_NOZBUFREAD))
PolyFlags &= ~(PF_NoDepthTest|PF_Corona);
-#endif
SetBlend(PolyFlags); //TODO: inline (#pragma..)
@@ -1677,16 +1400,11 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
c.alpha = byte2float[pSurf->FlatColor.s.alpha];
}
-#ifdef MINI_GL_COMPATIBILITY
- pglColor4f(c.red, c.green, c.blue, c.alpha);
-#else
pglColor4fv(&c.red); // is in RGBA float format
-#endif
}
// this test is added for new coronas' code (without depth buffer)
// I think I should do a separate function for drawing coronas, so it will be a little faster
-#ifndef MINI_GL_COMPATIBILITY
if (PolyFlags & PF_Corona) // check to see if we need to draw the corona
{
//rem: all 8 (or 8.0f) values are hard coded: it can be changed to a higher value
@@ -1733,19 +1451,17 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
c.alpha *= scalef; // change the alpha value (it seems better than changing the size of the corona)
pglColor4fv(&c.red);
}
-#endif
+
if (PolyFlags & PF_MD2)
return;
- pglBegin(GL_TRIANGLE_FAN);
- for (i = 0; i < iNumPts; i++)
- {
- pglTexCoord2f(pOutVerts[i].sow, pOutVerts[i].tow);
- //Hurdler: test code: -pOutVerts[i].z => pOutVerts[i].z
- pglVertex3f(pOutVerts[i].x, pOutVerts[i].y, pOutVerts[i].z);
- //pglVertex3f(pOutVerts[i].x, pOutVerts[i].y, -pOutVerts[i].z);
- }
- pglEnd();
+ pglEnableClientState(GL_VERTEX_ARRAY);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglVertexPointer(3, GL_FLOAT, sizeof(FOutVector), &pOutVerts[0].x);
+ pglTexCoordPointer(2, GL_FLOAT, sizeof(FOutVector), &pOutVerts[0].sow);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, iNumPts);
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglDisableClientState(GL_VERTEX_ARRAY);
if (PolyFlags & PF_RemoveYWrap)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
@@ -1827,41 +1543,15 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
break;
case HWD_SET_POLYGON_SMOOTH:
-#ifdef KOS_GL_COMPATIBILITY // GL_POLYGON_SMOOTH_HINT
- if (Value)
- pglHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
- else
- pglHint(GL_POLYGON_SMOOTH_HINT,GL_FASTEST);
-#else
if (Value)
pglEnable(GL_POLYGON_SMOOTH);
else
pglDisable(GL_POLYGON_SMOOTH);
-#endif
break;
case HWD_SET_TEXTUREFILTERMODE:
switch (Value)
{
-#ifdef KOS_GL_COMPATIBILITY
- case HWD_SET_TEXTUREFILTER_TRILINEAR:
- case HWD_SET_TEXTUREFILTER_BILINEAR:
- min_filter = mag_filter = GL_FILTER_BILINEAR;
- break;
- case HWD_SET_TEXTUREFILTER_POINTSAMPLED:
- min_filter = mag_filter = GL_FILTER_NONE;
- case HWD_SET_TEXTUREFILTER_MIXED1:
- min_filter = GL_FILTER_NONE;
- mag_filter = GL_LINEAR;
- case HWD_SET_TEXTUREFILTER_MIXED2:
- min_filter = GL_LINEAR;
- mag_filter = GL_FILTER_NONE;
- break;
- case HWD_SET_TEXTUREFILTER_MIXED3:
- min_filter = GL_FILTER_BILINEAR;
- mag_filter = GL_FILTER_NONE;
- break;
-#elif !defined (MINI_GL_COMPATIBILITY)
case HWD_SET_TEXTUREFILTER_TRILINEAR:
min_filter = GL_LINEAR_MIPMAP_LINEAR;
mag_filter = GL_LINEAR;
@@ -1890,14 +1580,9 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
mag_filter = GL_NEAREST;
MipMap = GL_TRUE;
break;
-#endif
default:
-#ifdef KOS_GL_COMPATIBILITY
- min_filter = mag_filter = GL_FILTER_NONE;
-#else
mag_filter = GL_LINEAR;
min_filter = GL_NEAREST;
-#endif
}
if (!pgluBuild2DMipmaps)
{
@@ -1918,26 +1603,64 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
}
}
+static float *vertBuffer = NULL;
+static float *normBuffer = NULL;
+static size_t lerpBufferSize = 0;
+static short *vertTinyBuffer = NULL;
+static char *normTinyBuffer = NULL;
+static size_t lerpTinyBufferSize = 0;
+
+// Static temporary buffer for doing frame interpolation
+// 'size' is the vertex size
+static void AllocLerpBuffer(size_t size)
+{
+ if (lerpBufferSize >= size)
+ return;
+
+ if (vertBuffer != NULL)
+ free(vertBuffer);
+
+ if (normBuffer != NULL)
+ free(normBuffer);
+
+ lerpBufferSize = size;
+ vertBuffer = malloc(lerpBufferSize);
+ normBuffer = malloc(lerpBufferSize);
+}
+
+// Static temporary buffer for doing frame interpolation
+// 'size' is the vertex size
+static void AllocLerpTinyBuffer(size_t size)
+{
+ if (lerpTinyBufferSize >= size)
+ return;
+
+ if (vertTinyBuffer != NULL)
+ free(vertTinyBuffer);
+
+ if (normTinyBuffer != NULL)
+ free(normTinyBuffer);
+
+ lerpTinyBufferSize = size;
+ vertTinyBuffer = malloc(lerpTinyBufferSize);
+ normTinyBuffer = malloc(lerpTinyBufferSize / 2);
+}
+
static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex, FTransform *pos, float scale, UINT8 flipped, UINT8 *color)
{
GLfloat ambient[4];
GLfloat diffuse[4];
float pol = 0.0f;
-
- float scalex, scaley, scalez;
+ scale *= 0.5f;
+ float scalex = scale, scaley = scale, scalez = scale;
boolean useTinyFrames;
int i;
// Because Otherwise, scaling the screen negatively vertically breaks the lighting
-#ifndef KOS_GL_COMPATIBILITY
GLfloat LightPos[] = {0.0f, 1.0f, 0.0f, 0.0f};
-#endif
-
- scale *= 0.5f;
- scalex = scaley = scalez = scale;
if (duration != 0 && duration != -1 && tics != -1) // don't interpolate if instantaneous or infinite in length
{
@@ -1997,9 +1720,7 @@ static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32
}
#endif
-#ifndef KOS_GL_COMPATIBILITY
pglLightfv(GL_LIGHT0, GL_POSITION, LightPos);
-#endif
pglShadeModel(GL_SMOOTH);
if (color)
@@ -2033,6 +1754,10 @@ static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32
if (useTinyFrames)
pglScalef(1 / 64.0f, 1 / 64.0f, 1 / 64.0f);
+ pglEnableClientState(GL_VERTEX_ARRAY);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglEnableClientState(GL_NORMAL_ARRAY);
+
for (i = 0; i < model->numMeshes; i++)
{
mesh_t *mesh = &model->meshes[i];
@@ -2047,46 +1772,30 @@ static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32
if (!nextframe || pol == 0.0f)
{
- pglEnableClientState(GL_VERTEX_ARRAY);
- pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
- pglEnableClientState(GL_NORMAL_ARRAY);
pglVertexPointer(3, GL_SHORT, 0, frame->vertices);
pglNormalPointer(GL_BYTE, 0, frame->normals);
pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
pglDrawElements(GL_TRIANGLES, mesh->numTriangles * 3, GL_UNSIGNED_SHORT, mesh->indices);
- pglDisableClientState(GL_NORMAL_ARRAY);
- pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
- pglDisableClientState(GL_VERTEX_ARRAY);
}
else
{
// Dangit, I soooo want to do this in a GLSL shader...
- short *buffer = malloc(mesh->numVertices * sizeof(short) * 3);
- short *vertPtr = buffer;
- char *normBuffer = malloc(mesh->numVertices * sizeof(char) * 3);
- char *normPtr = normBuffer;
+ AllocLerpTinyBuffer(mesh->numVertices * sizeof(short) * 3);
+ short *vertPtr = vertTinyBuffer;
+ char *normPtr = normTinyBuffer;
int j = 0;
- for (j = 0; j < mesh->numVertices; j++)
+ for (j = 0; j < mesh->numVertices * 3; j++)
{
// Interpolate
*vertPtr++ = (short)(frame->vertices[j] + (pol * (nextframe->vertices[j] - frame->vertices[j])));
*normPtr++ = (char)(frame->normals[j] + (pol * (nextframe->normals[j] - frame->normals[j])));
}
- pglEnableClientState(GL_VERTEX_ARRAY);
- pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
- pglEnableClientState(GL_NORMAL_ARRAY);
- pglVertexPointer(3, GL_SHORT, 0, buffer);
- pglNormalPointer(GL_BYTE, 0, normBuffer);
+ pglVertexPointer(3, GL_SHORT, 0, vertTinyBuffer);
+ pglNormalPointer(GL_BYTE, 0, normTinyBuffer);
pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
pglDrawElements(GL_TRIANGLES, mesh->numTriangles * 3, GL_UNSIGNED_SHORT, mesh->indices);
- pglDisableClientState(GL_NORMAL_ARRAY);
- pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
- pglDisableClientState(GL_VERTEX_ARRAY);
-
- free(buffer);
- free(normBuffer);
}
}
else
@@ -2100,61 +1809,38 @@ static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32
if (!nextframe || pol == 0.0f)
{
// Zoom! Take advantage of just shoving the entire arrays to the GPU.
- pglEnableClientState(GL_VERTEX_ARRAY);
- pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
- pglEnableClientState(GL_NORMAL_ARRAY);
pglVertexPointer(3, GL_FLOAT, 0, frame->vertices);
pglNormalPointer(GL_FLOAT, 0, frame->normals);
pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
pglDrawArrays(GL_TRIANGLES, 0, mesh->numTriangles * 3);
- pglDisableClientState(GL_NORMAL_ARRAY);
- pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
- pglDisableClientState(GL_VERTEX_ARRAY);
}
else
{
- int j = 0;
- float *uvPtr = mesh->uvs;
- float *frameVert = frame->vertices;
- float *frameNormal = frame->normals;
- float *nextFrameVert = nextframe->vertices;
- float *nextFrameNormal = nextframe->normals;
-
// Dangit, I soooo want to do this in a GLSL shader...
- pglBegin(GL_TRIANGLES);
+ AllocLerpBuffer(mesh->numVertices * sizeof(float) * 3);
+ float *vertPtr = vertBuffer;
+ float *normPtr = normBuffer;
+ int j = 0;
- for (j = 0; j < mesh->numTriangles * 3; j++)
+ for (j = 0; j < mesh->numVertices * 3; j++)
{
// Interpolate
- float px1 = *frameVert++;
- float py1 = *frameVert++;
- float pz1 = *frameVert++;
- float px2 = *nextFrameVert++;
- float py2 = *nextFrameVert++;
- float pz2 = *nextFrameVert++;
- float nx1 = *frameNormal++;
- float ny1 = *frameNormal++;
- float nz1 = *frameNormal++;
- float nx2 = *nextFrameNormal++;
- float ny2 = *nextFrameNormal++;
- float nz2 = *nextFrameNormal++;
-
- pglTexCoord2fv(uvPtr);
- pglNormal3f((nx1 + pol * (nx2 - nx1)),
- (ny1 + pol * (ny2 - ny1)),
- (nz1 + pol * (nz2 - nz1)));
- pglVertex3f((px1 + pol * (px2 - px1)),
- (py1 + pol * (py2 - py1)),
- (pz1 + pol * (pz2 - pz1)));
-
- uvPtr += 2;
+ *vertPtr++ = frame->vertices[j] + (pol * (nextframe->vertices[j] - frame->vertices[j]));
+ *normPtr++ = frame->normals[j] + (pol * (nextframe->normals[j] - frame->normals[j]));
}
- pglEnd();
+ pglVertexPointer(3, GL_FLOAT, 0, vertBuffer);
+ pglNormalPointer(GL_FLOAT, 0, normBuffer);
+ pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
+ pglDrawArrays(GL_TRIANGLES, 0, mesh->numVertices);
}
}
}
+ pglDisableClientState(GL_NORMAL_ARRAY);
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglDisableClientState(GL_VERTEX_ARRAY);
+
pglPopMatrix(); // should be the same as glLoadIdentity
if (color)
pglDisable(GL_LIGHTING);
@@ -2204,9 +1890,7 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
GLPerspective(53.13l, 2*ASPECT_RATIO); // 53.13 = 2*atan(0.5)
else
GLPerspective(stransform->fovxangle, ASPECT_RATIO);
-#ifndef MINI_GL_COMPATIBILITY
pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
-#endif
pglMatrixMode(GL_MODELVIEW);
}
else
@@ -2220,15 +1904,11 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
else
//Hurdler: is "fov" correct?
GLPerspective(fov, ASPECT_RATIO);
-#ifndef MINI_GL_COMPATIBILITY
pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
-#endif
pglMatrixMode(GL_MODELVIEW);
}
-#ifndef MINI_GL_COMPATIBILITY
pglGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
-#endif
}
EXPORT INT32 HWRAPI(GetTextureUsed) (void)
@@ -2249,7 +1929,6 @@ EXPORT INT32 HWRAPI(GetRenderVersion) (void)
return VERSION;
}
-#ifdef SHUFFLE
EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
{
INT32 x, y;
@@ -2269,16 +1948,25 @@ EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
pglDisable(GL_DEPTH_TEST);
pglDisable(GL_BLEND);
- pglBegin(GL_QUADS);
+
+ const float blackBack[16] =
+ {
+ -16.0f, -16.0f, 6.0f,
+ -16.0f, 16.0f, 6.0f,
+ 16.0f, 16.0f, 6.0f,
+ 16.0f, -16.0f, 6.0f
+ };
+
+ pglEnableClientState(GL_VERTEX_ARRAY);
// Draw a black square behind the screen texture,
// so nothing shows through the edges
pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- pglVertex3f(-16.0f, -16.0f, 6.0f);
- pglVertex3f(-16.0f, 16.0f, 6.0f);
- pglVertex3f(16.0f, 16.0f, 6.0f);
- pglVertex3f(16.0f, -16.0f, 6.0f);
+
+ pglVertexPointer(3, GL_FLOAT, 0, blackBack);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
for(x=0;x<SCREENVERTS-1;x++)
{
for(y=0;y<SCREENVERTS-1;y++)
@@ -2291,25 +1979,44 @@ EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
float_nextx = (float)(x+1)/(xfix);
float_nexty = (float)(y+1)/(yfix);
- // Attach the squares together.
- pglTexCoord2f( float_x, float_y);
- pglVertex3f(points[x][y][0], points[x][y][1], 4.4f);
-
- pglTexCoord2f( float_x, float_nexty);
- pglVertex3f(points[x][y+1][0], points[x][y+1][1], 4.4f);
-
- pglTexCoord2f( float_nextx, float_nexty);
- pglVertex3f(points[x+1][y+1][0], points[x+1][y+1][1], 4.4f);
-
- pglTexCoord2f( float_nextx, float_y);
- pglVertex3f(points[x+1][y][0], points[x+1][y][1], 4.4f);
+ float stCoords[8];
+ stCoords[0] = float_x;
+ stCoords[1] = float_y;
+ stCoords[2] = float_x;
+ stCoords[3] = float_nexty;
+ stCoords[4] = float_nextx;
+ stCoords[5] = float_nexty;
+ stCoords[6] = float_nextx;
+ stCoords[7] = float_y;
+
+ pglTexCoordPointer(2, GL_FLOAT, 0, stCoords);
+
+ float vertCoords[12];
+ vertCoords[0] = points[x][y][0];
+ vertCoords[1] = points[x][y][1];
+ vertCoords[2] = 4.4f;
+ vertCoords[3] = points[x][y + 1][0];
+ vertCoords[4] = points[x][y + 1][1];
+ vertCoords[5] = 4.4f;
+ vertCoords[6] = points[x + 1][y + 1][0];
+ vertCoords[7] = points[x + 1][y + 1][1];
+ vertCoords[8] = 4.4f;
+ vertCoords[9] = points[x + 1][y][0];
+ vertCoords[10] = points[x + 1][y][1];
+ vertCoords[11] = 4.4f;
+
+ pglVertexPointer(3, GL_FLOAT, 0, vertCoords);
+
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
}
- pglEnd();
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+ pglDisableClientState(GL_VERTEX_ARRAY);
+
pglEnable(GL_DEPTH_TEST);
pglEnable(GL_BLEND);
}
-#endif //SHUFFLE
// Sryder: This needs to be called whenever the screen changes resolution in order to reset the screen textures to use
// a new size
@@ -2344,23 +2051,14 @@ EXPORT void HWRAPI(StartScreenWipe) (void)
if (firstTime)
{
-#ifdef KOS_GL_COMPATIBILITY
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
-#else
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-#endif
Clamp2D(GL_TEXTURE_WRAP_S);
Clamp2D(GL_TEXTURE_WRAP_T);
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
-#endif
}
else
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
-#endif
tex_downloaded = startScreenWipe;
}
@@ -2384,24 +2082,14 @@ EXPORT void HWRAPI(EndScreenWipe)(void)
if (firstTime)
{
-#ifdef KOS_GL_COMPATIBILITY
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
-#else
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-#endif
Clamp2D(GL_TEXTURE_WRAP_S);
Clamp2D(GL_TEXTURE_WRAP_T);
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
-#endif
}
else
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
-#endif
-
tex_downloaded = endScreenWipe;
}
@@ -2421,29 +2109,36 @@ EXPORT void HWRAPI(DrawIntermissionBG)(void)
xfix = 1/((float)(texsize)/((float)((screen_width))));
yfix = 1/((float)(texsize)/((float)((screen_height))));
- pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
- pglBindTexture(GL_TEXTURE_2D, screentexture);
- pglBegin(GL_QUADS);
-
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
+ const float screenVerts[12] =
+ {
+ -1.0f, -1.0f, 1.0f,
+ -1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, -1.0f, 1.0f
+ };
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
+ float fix[8];
+ fix[0] = 0.0f;
+ fix[1] = 0.0f;
+ fix[2] = 0.0f;
+ fix[3] = yfix;
+ fix[4] = xfix;
+ fix[5] = yfix;
+ fix[6] = xfix;
+ fix[7] = 0.0f;
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(1.0f, 1.0f, 1.0f);
+ pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
+ pglBindTexture(GL_TEXTURE_2D, screentexture);
+ pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- pglEnd();
+ pglEnableClientState(GL_VERTEX_ARRAY);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglDisableClientState(GL_VERTEX_ARRAY);
tex_downloaded = screentexture;
}
@@ -2454,9 +2149,7 @@ EXPORT void HWRAPI(DoScreenWipe)(float alpha)
INT32 texsize = 2048;
float xfix, yfix;
-#ifndef MINI_GL_COMPATIBILITY
INT32 fademaskdownloaded = tex_downloaded; // the fade mask that has been set
-#endif
// Use a power of two texture, dammit
if(screen_width <= 1024)
@@ -2467,105 +2160,76 @@ EXPORT void HWRAPI(DoScreenWipe)(float alpha)
xfix = 1/((float)(texsize)/((float)((screen_width))));
yfix = 1/((float)(texsize)/((float)((screen_height))));
+ const float screenVerts[12] =
+ {
+ -1.0f, -1.0f, 1.0f,
+ -1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, -1.0f, 1.0f
+ };
+
+ float fix[8];
+ fix[0] = 0.0f;
+ fix[1] = 0.0f;
+ fix[2] = 0.0f;
+ fix[3] = yfix;
+ fix[4] = xfix;
+ fix[5] = yfix;
+ fix[6] = xfix;
+ fix[7] = 0.0f;
+
pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
SetBlend(PF_Modulated|PF_NoDepthTest|PF_Clip|PF_NoZClip);
// Draw the original screen
pglBindTexture(GL_TEXTURE_2D, startScreenWipe);
- pglBegin(GL_QUADS);
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
+ pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+ pglEnableClientState(GL_VERTEX_ARRAY);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
-
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(1.0f, 1.0f, 1.0f);
+ SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest|PF_Clip|PF_NoZClip);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
+ // Draw the end screen that fades in
+ pglActiveTexture(GL_TEXTURE0);
+ pglEnable(GL_TEXTURE_2D);
+ pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
+ pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
- pglEnd();
+ pglActiveTexture(GL_TEXTURE1);
+ pglEnable(GL_TEXTURE_2D);
+ pglBindTexture(GL_TEXTURE_2D, fademaskdownloaded);
- SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest|PF_Clip|PF_NoZClip);
+ pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-#ifndef MINI_GL_COMPATIBILITY
- if (gl13)
+ const float defaultST[8] =
{
- // Draw the end screen that fades in
- pglActiveTexture(GL_TEXTURE0);
- pglEnable(GL_TEXTURE_2D);
- pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
- pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
- pglActiveTexture(GL_TEXTURE1);
- pglEnable(GL_TEXTURE_2D);
- pglBindTexture(GL_TEXTURE_2D, fademaskdownloaded);
-
- pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- pglBegin(GL_QUADS);
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-
- // Bottom left
- pglMultiTexCoord2f(GL_TEXTURE0, 0.0f, 0.0f);
- pglMultiTexCoord2f(GL_TEXTURE1, 0.0f, 1.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
-
- // Top left
- pglMultiTexCoord2f(GL_TEXTURE0, 0.0f, yfix);
- pglMultiTexCoord2f(GL_TEXTURE1, 0.0f, 0.0f);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
-
- // Top right
- pglMultiTexCoord2f(GL_TEXTURE0, xfix, yfix);
- pglMultiTexCoord2f(GL_TEXTURE1, 1.0f, 0.0f);
- pglVertex3f(1.0f, 1.0f, 1.0f);
-
- // Bottom right
- pglMultiTexCoord2f(GL_TEXTURE0, xfix, 0.0f);
- pglMultiTexCoord2f(GL_TEXTURE1, 1.0f, 1.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
- pglEnd();
-
- pglDisable(GL_TEXTURE_2D); // disable the texture in the 2nd texture unit
- pglActiveTexture(GL_TEXTURE0);
- tex_downloaded = endScreenWipe;
- }
- else
- {
-#endif
- // Draw the end screen that fades in
- pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
- pglBegin(GL_QUADS);
- pglColor4f(1.0f, 1.0f, 1.0f, alpha);
+ 0.0f, 1.0f,
+ 0.0f, 0.0f,
+ 1.0f, 0.0f,
+ 1.0f, 1.0f
+ };
+
+ pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
+ pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
+ pglClientActiveTexture(GL_TEXTURE0);
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglClientActiveTexture(GL_TEXTURE1);
+ pglTexCoordPointer(2, GL_FLOAT, 0, defaultST);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglDisableClientState(GL_VERTEX_ARRAY);
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(1.0f, 1.0f, 1.0f);
+ pglClientActiveTexture(GL_TEXTURE0);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
- pglEnd();
+ pglDisable(GL_TEXTURE_2D); // disable the texture in the 2nd texture unit
+ pglActiveTexture(GL_TEXTURE0);
tex_downloaded = endScreenWipe;
-#ifndef MINI_GL_COMPATIBILITY
- }
-#endif
}
@@ -2588,23 +2252,14 @@ EXPORT void HWRAPI(MakeScreenTexture) (void)
if (firstTime)
{
-#ifdef KOS_GL_COMPATIBILITY
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
-#else
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-#endif
Clamp2D(GL_TEXTURE_WRAP_S);
Clamp2D(GL_TEXTURE_WRAP_T);
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
-#endif
}
else
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
-#endif
tex_downloaded = screentexture;
}
@@ -2627,26 +2282,16 @@ EXPORT void HWRAPI(MakeScreenFinalTexture) (void)
if (firstTime)
{
-#ifdef KOS_GL_COMPATIBILITY
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
- pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
-#else
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-#endif
Clamp2D(GL_TEXTURE_WRAP_S);
Clamp2D(GL_TEXTURE_WRAP_T);
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
-#endif
}
else
-#ifndef KOS_GL_COMPATIBILITY
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
-#endif
tex_downloaded = finalScreenTexture;
-
}
EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
@@ -2678,33 +2323,49 @@ EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
yoff = newaspect / origaspect;
}
+ float off[12];
+ off[0] = -xoff;
+ off[1] = -yoff;
+ off[2] = 1.0f;
+ off[3] = -xoff;
+ off[4] = yoff;
+ off[5] = 1.0f;
+ off[6] = xoff;
+ off[7] = yoff;
+ off[8] = 1.0f;
+ off[9] = xoff;
+ off[10] = -yoff;
+ off[11] = 1.0f;
+
+ float fix[8];
+ fix[0] = 0.0f;
+ fix[1] = 0.0f;
+ fix[2] = 0.0f;
+ fix[3] = yfix;
+ fix[4] = xfix;
+ fix[5] = yfix;
+ fix[6] = xfix;
+ fix[7] = 0.0f;
+
pglViewport(0, 0, width, height);
clearColour.red = clearColour.green = clearColour.blue = 0;
clearColour.alpha = 1;
ClearBuffer(true, false, &clearColour);
pglBindTexture(GL_TEXTURE_2D, finalScreenTexture);
- pglBegin(GL_QUADS);
-
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-xoff, -yoff, 1.0f);
-
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-xoff, yoff, 1.0f);
-
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(xoff, yoff, 1.0f);
+
+ pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+ pglEnableClientState(GL_VERTEX_ARRAY);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(xoff, -yoff, 1.0f);
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, off);
- pglEnd();
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglDisableClientState(GL_VERTEX_ARRAY);
+
tex_downloaded = finalScreenTexture;
}
diff --git a/src/hardware/r_opengl/r_opengl.h b/src/hardware/r_opengl/r_opengl.h
index 6a2eba1df00e548cb93e52abae6e9c4f2d8ee81a..e6cf164bb088b72ae778bc40fa02814e7f96fcd9 100644
--- a/src/hardware/r_opengl/r_opengl.h
+++ b/src/hardware/r_opengl/r_opengl.h
@@ -37,13 +37,11 @@
#include <GL/gl.h>
#include <GL/glu.h>
-#ifndef MINI_GL_COMPATIBILITY
#ifdef STATIC_OPENGL // Because of the 1.3 functions, you'll need GLext to compile it if static
#define GL_GLEXT_PROTOTYPES
#include <GL/glext.h>
#endif
#endif
-#endif
#define _CREATE_DLL_ // necessary for Unix AND Windows
#include "../../doomdef.h"
diff --git a/src/sdl/hwsym_sdl.c b/src/sdl/hwsym_sdl.c
index 7962e01b1037905edfcf6e80eaa31e07ebf6459e..9f844c62359fa522d17bbcd4798f96e24d54948c 100644
--- a/src/sdl/hwsym_sdl.c
+++ b/src/sdl/hwsym_sdl.c
@@ -90,9 +90,7 @@ void *hwSym(const char *funcName,void *handle)
GETFUNC(DrawModel);
GETFUNC(SetTransform);
GETFUNC(GetRenderVersion);
-#ifdef SHUFFLE
GETFUNC(PostImgRedraw);
-#endif //SHUFFLE
GETFUNC(FlushScreenTextures);
GETFUNC(StartScreenWipe);
GETFUNC(EndScreenWipe);
diff --git a/src/sdl/i_video.c b/src/sdl/i_video.c
index 6ce11fc7403949730bf9c93442185b0a341c67b9..543499b09ae9a5f082f265b3d513c7ac850ea13e 100644
--- a/src/sdl/i_video.c
+++ b/src/sdl/i_video.c
@@ -1486,9 +1486,7 @@ void I_StartupGraphics(void)
HWD.pfnDrawModel = hwSym("DrawModel",NULL);
HWD.pfnSetTransform = hwSym("SetTransform",NULL);
HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
-#ifdef SHUFFLE
HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
-#endif
HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
diff --git a/src/win32/Srb2win-vc10.vcxproj.filters b/src/win32/Srb2win-vc10.vcxproj.filters
index 1a2a7f80d0d4864b8865c82e296daddfba71af2d..8f607796971841cb543a447e368407872c729ea9 100644
--- a/src/win32/Srb2win-vc10.vcxproj.filters
+++ b/src/win32/Srb2win-vc10.vcxproj.filters
@@ -108,21 +108,9 @@
<ClCompile Include="..\hardware\hw_md2.c">
<Filter>Hw_Hardware</Filter>
</ClCompile>
- <ClInclude Include="..\hardware\hw_md2load.c">
- <Filter>Hw_Hardware</Filter>
- </ClInclude>
- <ClInclude Include="..\hardware\hw_md3load.c">
- <Filter>Hw_Hardware</Filter>
- </ClInclude>
- <ClInclude Include="..\hardware\hw_model.c">
- <Filter>Hw_Hardware</Filter>
- </ClInclude>
<ClCompile Include="..\hardware\hw_trick.c">
<Filter>Hw_Hardware</Filter>
</ClCompile>
- <ClInclude Include="..\hardware\u_list.c">
- <Filter>Hw_Hardware</Filter>
- </ClInclude>
<ClCompile Include="..\hardware\hw3sound.c">
<Filter>Hw_Hardware</Filter>
</ClCompile>
@@ -465,6 +453,10 @@
<ClCompile Include="..\string.c">
<Filter>M_Misc</Filter>
</ClCompile>
+ <ClCompile Include="..\hardware\hw_md2load.c" />
+ <ClCompile Include="..\hardware\hw_md3load.c" />
+ <ClCompile Include="..\hardware\hw_model.c" />
+ <ClCompile Include="..\hardware\u_list.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="afxres.h">