#include "quakedef.h"
-cvar_t gl_mesh_maxtriangles = {0, "gl_mesh_maxtriangles", "1024"};
+cvar_t gl_mesh_maxverts = {0, "gl_mesh_maxverts", "1024"};
cvar_t gl_mesh_floatcolors = {0, "gl_mesh_floatcolors", "1"};
cvar_t gl_mesh_drawmode = {CVAR_SAVE, "gl_mesh_drawmode", "3"};
cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1"}; // whether or not to use dithering
cvar_t gl_lockarrays = {0, "gl_lockarrays", "1"};
-// this is used to increase gl_mesh_maxtriangles automatically if a mesh was
-// too large for the buffers in the previous frame
-int overflowedverts = 0;
-
int gl_maxdrawrangeelementsvertices;
int gl_maxdrawrangeelementsindices;
}
#endif
+#define BACKENDACTIVECHECK if (!backendactive) Sys_Error("GL backend function called when backend is not active\n");
+
float r_mesh_farclip;
static float viewdist;
// these are externally accessible
float mesh_colorscale;
-int *varray_element;
float *varray_vertex;
float *varray_color;
float *varray_texcoord[MAX_TEXTUREUNITS];
-int mesh_maxtris;
-int mesh_maxverts; // always mesh_maxtris * 3
+int mesh_maxverts;
-static matrix4x4_t backendmatrix;
+static matrix4x4_t backend_viewmatrix;
+static matrix4x4_t backend_modelmatrix;
+static matrix4x4_t backend_modelviewmatrix;
+static matrix4x4_t backend_glmodelviewmatrix;
static int backendunits, backendactive;
static qbyte *varray_bcolor;
static mempool_t *gl_backend_mempool;
+int polygonelements[768];
+
void GL_Backend_AllocArrays(void)
{
int i;
+ for (i = 0;i < POLYGONELEMENTS_MAXPOINTS - 2;i++)
+ {
+ polygonelements[i * 3 + 0] = 0;
+ polygonelements[i * 3 + 1] = i + 1;
+ polygonelements[i * 3 + 2] = i + 2;
+ }
+
if (!gl_backend_mempool)
gl_backend_mempool = Mem_AllocPool("GL_Backend");
- mesh_maxverts = mesh_maxtris * 3;
-
- varray_element = Mem_Alloc(gl_backend_mempool, mesh_maxtris * sizeof(int[3]));
varray_vertex = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(float[4]));
varray_color = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(float[4]));
varray_bcolor = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(qbyte[4]));
Mem_EmptyPool(gl_backend_mempool);
else
Mem_FreePool(&gl_backend_mempool);
- varray_element = NULL;
varray_vertex = NULL;
varray_color = NULL;
varray_bcolor = NULL;
static void gl_backend_start(void)
{
- Con_Printf("OpenGL Backend started with gl_mesh_maxtriangles %i\n", gl_mesh_maxtriangles.integer);
+ Con_Printf("OpenGL Backend started with gl_mesh_maxverts %i\n", gl_mesh_maxverts.integer);
if (qglDrawRangeElements != NULL)
{
qglGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &gl_maxdrawrangeelementsvertices);
Cvar_SetValueQuick(&gl_mesh_drawmode, 2);
// 21760 is (65536 / 3) rounded off to a multiple of 128
- if (gl_mesh_maxtriangles.integer < 1024)
- Cvar_SetValueQuick(&gl_mesh_maxtriangles, 1024);
- if (gl_mesh_maxtriangles.integer > 21760)
- Cvar_SetValueQuick(&gl_mesh_maxtriangles, 21760);
+ if (gl_mesh_maxverts.integer < 1024)
+ Cvar_SetValueQuick(&gl_mesh_maxverts, 1024);
+ if (gl_mesh_maxverts.integer > 21760)
+ Cvar_SetValueQuick(&gl_mesh_maxverts, 21760);
}
void GL_Backend_ResizeArrays(int numtriangles)
{
- Cvar_SetValueQuick(&gl_mesh_maxtriangles, numtriangles);
+ Cvar_SetValueQuick(&gl_mesh_maxverts, numtriangles);
GL_Backend_CheckCvars();
- mesh_maxtris = gl_mesh_maxtriangles.integer;
+ mesh_maxverts = gl_mesh_maxverts.integer;
GL_Backend_FreeArrays(true);
GL_Backend_AllocArrays();
}
Cvar_SetValue("r_render", 0);
#endif
- Cvar_RegisterVariable(&gl_mesh_maxtriangles);
+ Cvar_RegisterVariable(&gl_mesh_maxverts);
Cvar_RegisterVariable(&gl_mesh_floatcolors);
Cvar_RegisterVariable(&gl_mesh_drawmode);
GL_Backend_CheckCvars();
R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap);
}
-int arraylocked = false;
-
-void GL_LockArray(int first, int count)
-{
- if (!arraylocked && gl_supportslockarrays && gl_lockarrays.integer && gl_mesh_drawmode.integer > 0)
- {
- qglLockArraysEXT(first, count);
- CHECKGLERROR
- arraylocked = true;
- }
-}
-
-void GL_UnlockArray(void)
-{
- if (arraylocked)
- {
- qglUnlockArraysEXT();
- CHECKGLERROR
- arraylocked = false;
- }
-}
-
/*
=============
GL_SetupFrame
qglFrustum(-xmax, xmax, -ymax, ymax, zNear, zFar);CHECKGLERROR
qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
- qglLoadIdentity ();CHECKGLERROR
+ Matrix4x4_CreateRotate(&backend_viewmatrix, -90, 1, 0, 0);
+ Matrix4x4_ConcatRotate(&backend_viewmatrix, 90, 0, 0, 1);
+ Matrix4x4_ConcatRotate(&backend_viewmatrix, -r_refdef.viewangles[2], 1, 0, 0);
+ Matrix4x4_ConcatRotate(&backend_viewmatrix, -r_refdef.viewangles[0], 0, 1, 0);
+ Matrix4x4_ConcatRotate(&backend_viewmatrix, -r_refdef.viewangles[1], 0, 0, 1);
+ Matrix4x4_ConcatTranslate(&backend_viewmatrix, -r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
+ //Con_Printf("Our Matrix:\n");
+ //Matrix4x4_Print(&backend_viewmatrix);
+
+ //Matrix4x4_Transpose(&backend_glmodelviewmatrix, &backend_viewmatrix);
+ //qglLoadMatrixf(&backend_glmodelviewmatrix.m[0][0]);CHECKGLERROR
+ memset(&backend_modelmatrix, 0, sizeof(backend_modelmatrix));
+
+ /*
// put Z going up
+ qglLoadIdentity ();CHECKGLERROR
qglRotatef (-90, 1, 0, 0);CHECKGLERROR
qglRotatef (90, 0, 0, 1);CHECKGLERROR
// camera rotation
qglRotatef (-r_refdef.viewangles[1], 0, 0, 1);CHECKGLERROR
// camera location
qglTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);CHECKGLERROR
+ qglGetFloatv (GL_MODELVIEW_MATRIX, &gl_viewmatrix.m[0][0]);
+ Matrix4x4_Transpose(&backend_viewmatrix, &gl_viewmatrix);
+ Con_Printf("GL Matrix:\n");
+ Matrix4x4_Print(&backend_viewmatrix);
+ */
}
static struct
// called at beginning of frame
void R_Mesh_Start(float farclip)
{
- if (!backendactive)
- Sys_Error("R_Mesh_Clear: called when backend is not active\n");
+ BACKENDACTIVECHECK
CHECKGLERROR
c_meshtris = 0;
GL_Backend_CheckCvars();
- if (mesh_maxtris != gl_mesh_maxtriangles.integer)
- GL_Backend_ResizeArrays(gl_mesh_maxtriangles.integer);
+ if (mesh_maxverts != gl_mesh_maxverts.integer)
+ GL_Backend_ResizeArrays(gl_mesh_maxverts.integer);
GL_SetupFrame();
}
}
+/*
void GL_TransformVertices(int numverts)
{
int i;
v[2] = tempv[0] * m[8] + tempv[1] * m[9] + tempv[2] * m[10] + m[11];
}
}
+*/
void GL_DrawRangeElements(int firstvert, int endvert, int indexcount, GLuint *index)
{
unsigned int i, j, in;
qbyte *c;
float *v;
- GL_LockArray(firstvert, endvert - firstvert);
+ int arraylocked = false;
+ if (gl_supportslockarrays && gl_lockarrays.integer && gl_mesh_drawmode.integer > 0)
+ {
+ qglLockArraysEXT(firstvert, endvert - firstvert);
+ CHECKGLERROR
+ arraylocked = true;
+ }
if (gl_mesh_drawmode.integer >= 3/* && (endvert - firstvert) <= gl_maxdrawrangeelementsvertices && (indexcount) <= gl_maxdrawrangeelementsindices*/)
{
// GL 1.2 or GL 1.1 with extension
qglColor4ub(c[0], c[1], c[2], c[3]);
if (gl_state.texture[0])
{
- v = varray_texcoord[j] + in * 2;
+ v = varray_texcoord[0] + in * 2;
qglTexCoord2f(v[0], v[1]);
}
v = varray_vertex + in * 4;
qglEnd();
CHECKGLERROR
}
- GL_UnlockArray();
+ if (arraylocked)
+ {
+ qglUnlockArraysEXT();
+ CHECKGLERROR
+ arraylocked = false;
+ }
}
// enlarges geometry buffers if they are too small
-void _R_Mesh_ResizeCheck(int numverts, int numtriangles)
+void _R_Mesh_ResizeCheck(int numverts)
{
- if (numtriangles > mesh_maxtris || numverts > mesh_maxverts)
+ if (numverts > mesh_maxverts)
{
- if (!backendactive)
- Sys_Error("R_Mesh_Begin: called when backend is not active\n");
- GL_Backend_ResizeArrays(max(numtriangles, (numverts + 2) / 3) + 100);
+ BACKENDACTIVECHECK
+ GL_Backend_ResizeArrays(numverts + 100);
GL_Backend_ResetState();
}
}
// renders the mesh
-void R_Mesh_Draw(int numverts, int numtriangles)
+void R_Mesh_Draw(int numverts, int numtriangles, int *elements)
{
- if (!backendactive)
- Sys_Error("R_Mesh_End: called when backend is not active\n");
+ BACKENDACTIVECHECK
c_meshs++;
c_meshtris += numtriangles;
// drawmode 0 always uses byte colors
if (!gl_mesh_floatcolors.integer || gl_mesh_drawmode.integer <= 0)
GL_ConvertColorsFloatToByte(numverts);
- GL_TransformVertices(numverts);
+ //GL_TransformVertices(numverts);
if (!r_render.integer)
return;
- GL_DrawRangeElements(0, numverts, numtriangles * 3, varray_element);
+ GL_DrawRangeElements(0, numverts, numtriangles * 3, elements);
}
// restores backend state, used when done with 3D rendering
void R_Mesh_Finish(void)
{
int i;
+ BACKENDACTIVECHECK
+
if (backendunits > 1)
{
for (i = backendunits - 1;i >= 0;i--)
void R_Mesh_ClearDepth(void)
{
+ BACKENDACTIVECHECK
+
R_Mesh_Finish();
qglClear(GL_DEPTH_BUFFER_BIT);
R_Mesh_Start(r_mesh_farclip);
}
+void R_Mesh_Matrix(const matrix4x4_t *matrix)
+{
+ if (memcmp(matrix, &backend_modelmatrix, sizeof(matrix4x4_t)))
+ {
+ backend_modelmatrix = *matrix;
+ Matrix4x4_Concat(&backend_modelviewmatrix, &backend_viewmatrix, matrix);
+ Matrix4x4_Transpose(&backend_glmodelviewmatrix, &backend_modelviewmatrix);
+ qglLoadMatrixf(&backend_glmodelviewmatrix.m[0][0]);
+ }
+}
+
// sets up the requested state
void R_Mesh_State(const rmeshstate_t *m)
{
int texturergbscale[MAX_TEXTUREUNITS];
float scaler;
- if (!backendactive)
- Sys_Error("R_Mesh_State: called when backend is not active\n");
+ BACKENDACTIVECHECK
if (gl_backend_rebindtextures)
{
GL_SetupTextureState();
}
- backendmatrix = m->matrix; // this copies the struct
-
overbright = false;
scaler = 1;
if (m->blendfunc1 == GL_DST_COLOR)
texturergbscale[i] = 1;
}
if (overbright)
+ {
for (i = backendunits - 1;i >= 0;i--)
+ {
if (m->tex[i])
+ {
texturergbscale[i] = 4;
+ break;
+ }
+ }
+ }
if (backendunits > 1)
{
projects / xonotic / darkplaces.git / blobdiff