fte/quakespasm
2
0
Fork 0
mirror of https://github.com/Shpoike/Quakespasm.git synced 2025-02-16 09:01:12 +00:00
Code Issues Projects Releases Packages Wiki Activity

Alias model drawing derived from RMQEngine

Browse source
This commit is contained in:
Eric Wasylishen 2014-09-26 13:20:59 -06:00
parent 985115faed
commit 9cb668e087
10 changed files with 581 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

214
quakespasm/Quake/gl_mesh.c
View file

@ -287,6 +287,7 @@ void BuildTris (void)
alltris += pheader->numtris; alltris += pheader->numtris;
} }
void GL_MakeAliasModelDisplayLists_VBO (void);
/* /*
================ ================
@ -346,5 +347,218 @@ void GL_MakeAliasModelDisplayLists (qmodel_t *m, aliashdr_t *hdr)
for (i=0 ; i<paliashdr->numposes ; i++) for (i=0 ; i<paliashdr->numposes ; i++)
for (j=0 ; j<numorder ; j++) for (j=0 ; j<numorder ; j++)
*verts++ = poseverts[i][vertexorder[j]]; *verts++ = poseverts[i][vertexorder[j]];
// ericw
GL_MakeAliasModelDisplayLists_VBO ();
} }
unsigned int r_meshindexbuffer = 0;
unsigned int r_meshvertexbuffer = 0;
void GL_MakeAliasModelDisplayLists_VBO (void)
{
int i, j;
int maxverts_vbo;
// ericw -- first, copy the verts onto the hunk
trivertx_t *verts;
verts = (trivertx_t *) Hunk_Alloc (paliashdr->numposes * paliashdr->numverts * sizeof(trivertx_t));
paliashdr->vertexes = (byte *)verts - (byte *)paliashdr;
for (i=0 ; i<paliashdr->numposes ; i++)
for (j=0 ; j<paliashdr->numverts ; j++)
verts[i*paliashdr->numverts + j] = poseverts[i][j];
// ericw --
// there can never be more than this number of verts and we just put them all on the hunk
maxverts_vbo = pheader->numtris * 3;
aliasmesh_t *desc = (aliasmesh_t *) Hunk_Alloc (sizeof (aliasmesh_t) * maxverts_vbo);
aliasmesh_t *mesh = (aliasmesh_t *) malloc (sizeof (aliasmesh_t) * maxverts_vbo);
// there will always be this number of indexes
unsigned short *indexes = (unsigned short *) Hunk_Alloc (sizeof (unsigned short) * maxverts_vbo);
pheader->indexes = (intptr_t) indexes - (intptr_t) pheader;
pheader->meshdesc = (intptr_t) desc - (intptr_t) pheader;
pheader->numindexes = 0;
pheader->numverts_vbo = 0;
for (i = 0; i < pheader->numtris; i++)
{
for (j = 0; j < 3; j++)
{
int v;
// index into hdr->vertexes
unsigned short vertindex = triangles[i].vertindex[j];
// basic s/t coords
int s = stverts[vertindex].s;
int t = stverts[vertindex].t;
// check for back side and adjust texcoord s
if (!triangles[i].facesfront && stverts[vertindex].onseam) s += pheader->skinwidth / 2;
// see does this vert already exist
for (v = 0; v < pheader->numverts_vbo; v++)
{
// it could use the same xyz but have different s and t
if (mesh[v].vertindex == vertindex && (int) mesh[v].st[0] == s && (int) mesh[v].st[1] == t)
{
// exists; emit an index for it
indexes[pheader->numindexes++] = v;
// no need to check any more
break;
}
}
if (v == pheader->numverts_vbo)
{
// doesn't exist; emit a new vert and index
indexes[pheader->numindexes++] = pheader->numverts_vbo;
mesh[pheader->numverts_vbo].vertindex = vertindex;
mesh[pheader->numverts_vbo].st[0] = s;
mesh[pheader->numverts_vbo++].st[1] = t;
}
}
}
memcpy(desc, mesh, sizeof (aliasmesh_t) * pheader->numverts_vbo);
// free our temp holding area for mesh verts
free (mesh);
// create a hunk buffer for the final mesh we'll actually use
{
// vertex/fragment programs interpolate on the GPU and need to access the data directly
unsigned short *hunkndx = (unsigned short *) Hunk_Alloc (sizeof (unsigned short) * pheader->numverts_vbo);
// move these to aliasmesh struct???
pheader->vertindexes = (intptr_t) hunkndx - (intptr_t) pheader;
for (i = 0; i < pheader->numverts_vbo; i++)
{
hunkndx[i] = desc[i].vertindex;
}
}
}
static char scratchbuf[65536];
#define NUMVERTEXNORMALS 162
extern float r_avertexnormals[NUMVERTEXNORMALS][3];
GLuint r_meshvbo = 0;
GLuint r_meshindexesvbo = 0;
void GLMesh_LoadVertexBuffers (void)
{
int j;
qmodel_t *m;
int totalindexes = 0;
int totalvbosize = 0;
// pass 1 - count the sizes we need
for (j = 1; j < MAX_MODELS; j++)
{
aliashdr_t *hdr;
if (!(m = cl.model_precache[j])) break;
if (m->type != mod_alias) continue;
hdr = Mod_Extradata (m);
hdr->vboindexofs = (totalindexes * sizeof (unsigned short));
totalindexes += hdr->numindexes;
hdr->vboxyzofs = totalvbosize;
totalvbosize += (hdr->numposes * hdr->numverts_vbo * sizeof (meshxyz_t)); // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
hdr->vbostofs = totalvbosize;
totalvbosize += (hdr->numverts_vbo * sizeof (meshst_t));
}
if (!totalindexes) return;
if (!totalvbosize) return;
// pass 2 - create the buffers
GL_DeleteBuffersFunc (1, &r_meshindexesvbo);
GL_GenBuffersFunc (1, &r_meshindexesvbo);
GL_BindBufferFunc (GL_ELEMENT_ARRAY_BUFFER, r_meshindexesvbo);
GL_BufferDataFunc (GL_ELEMENT_ARRAY_BUFFER, totalindexes * sizeof (unsigned short), NULL, GL_STATIC_DRAW);
GL_DeleteBuffersFunc (1, &r_meshvbo);
GL_GenBuffersFunc (1, &r_meshvbo);
GL_BindBufferFunc (GL_ARRAY_BUFFER, r_meshvbo);
GL_BufferDataFunc (GL_ARRAY_BUFFER, totalvbosize, NULL, GL_STATIC_DRAW);
// pass 3 - fill in the buffers
for (j = 1; j < MAX_MODELS; j++)
{
int f;
aliashdr_t *hdr;
aliasmesh_t *desc;
meshst_t *st;
float hscale, vscale;
if (!(m = cl.model_precache[j])) break;
if (m->type != mod_alias) continue;
hdr = Mod_Extradata (m);
desc = (aliasmesh_t *) ((byte *) hdr + hdr->meshdesc);
//johnfitz -- padded skins
hscale = (float)hdr->skinwidth/(float)TexMgr_PadConditional(hdr->skinwidth);
vscale = (float)hdr->skinheight/(float)TexMgr_PadConditional(hdr->skinheight);
//johnfitz
GL_BufferSubDataFunc (GL_ELEMENT_ARRAY_BUFFER,
hdr->vboindexofs,
hdr->numindexes * sizeof (unsigned short),
((byte *) hdr + hdr->indexes));
for (f = 0; f < hdr->numposes; f++) // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
{
int v;
meshxyz_t *xyz = (meshxyz_t *) scratchbuf; // FIXME - potentially unsafe here
trivertx_t *tv = (trivertx_t *) ((byte *) hdr + hdr->vertexes + (hdr->numverts * sizeof(trivertx_t) * f));
for (v = 0; v < hdr->numverts_vbo; v++)
{
trivertx_t trivert = tv[desc[v].vertindex];
xyz[v].xyz[0] = trivert.v[0];
xyz[v].xyz[1] = trivert.v[1];
xyz[v].xyz[2] = trivert.v[2];
xyz[v].xyz[3] = 1; // need w 1 for 4 byte vertex compression
xyz[v].normal[0] = r_avertexnormals[trivert.lightnormalindex][0];
xyz[v].normal[1] = r_avertexnormals[trivert.lightnormalindex][1];
xyz[v].normal[2] = r_avertexnormals[trivert.lightnormalindex][2];
}
GL_BufferSubDataFunc (GL_ARRAY_BUFFER,
hdr->vboxyzofs + (f * hdr->numverts_vbo * sizeof (meshxyz_t)),
hdr->numverts_vbo * sizeof (meshxyz_t),
xyz);
}
st = (meshst_t *) scratchbuf;
for (f = 0; f < hdr->numverts_vbo; f++)
{
st[f].st[0] = hscale * ((float) desc[f].st[0] + 0.5f) / (float) hdr->skinwidth;
st[f].st[1] = vscale * ((float) desc[f].st[1] + 0.5f) / (float) hdr->skinheight;
}
GL_BufferSubDataFunc (GL_ARRAY_BUFFER,
hdr->vbostofs,
hdr->numverts_vbo * sizeof (meshst_t),
st);
}
GL_BindBufferFunc (GL_ELEMENT_ARRAY_BUFFER, 0);
GL_BindBufferFunc (GL_ARRAY_BUFFER, 0);
}

2
quakespasm/Quake/gl_model.c
View file

@ -2515,7 +2515,7 @@ void Mod_LoadAliasModel (qmodel_t *mod, void *buffer)
Sys_Error ("model %s has too many vertices", mod->name); Sys_Error ("model %s has too many vertices", mod->name);
pheader->numtris = LittleLong (pinmodel->numtris); pheader->numtris = LittleLong (pinmodel->numtris);
if (pheader->numtris <= 0) if (pheader->numtris <= 0)
Sys_Error ("model %s has no triangles", mod->name); Sys_Error ("model %s has no triangles", mod->name);

35
quakespasm/Quake/gl_model.h
View file

@ -282,6 +282,25 @@ Alias models are position independent, so the cache manager can move them.
============================================================================== ==============================================================================
*/ */
// split out to keep vertex sizes down
typedef struct aliasmesh_s
{
float st[2];
unsigned short vertindex;
} aliasmesh_t;
typedef struct meshxyz_s
{
byte xyz[4];
float normal[3];
} meshxyz_t;
typedef struct meshst_s
{
float st[2];
} meshst_t;
typedef struct typedef struct
{ {
int firstpose; int firstpose;
@ -326,11 +345,27 @@ typedef struct {
int skinwidth; int skinwidth;
int skinheight; int skinheight;
int numverts; int numverts;
int numverts_vbo;
int numtris; int numtris;
int numframes; int numframes;
synctype_t synctype; synctype_t synctype;
int flags; int flags;
float size; float size;
intptr_t meshdesc;
intptr_t indexes;
int numindexes;
// only shaders use this
intptr_t vertindexes;
// only vbos use these
int vboindexofs;
int vboxyzofs;
int vbostofs;
// offset to (trivertx_t *) Hunk_Alloc (paliashdr->numposes * paliashdr->vertsperframe * sizeof(trivertx_t))
intptr_t vertexes;
int numposes; int numposes;
int poseverts; int poseverts;

13
quakespasm/Quake/gl_rmain.c
View file

@ -456,6 +456,11 @@ void R_SetupView (void)
// //
//============================================================================== //==============================================================================
static int R_EntitySortFunc(const void *a, const void *b)
{
return (*(entity_t **)a)->model - (*(entity_t **)b)->model;
}
/* /*
============= =============
R_DrawEntitiesOnList R_DrawEntitiesOnList
@ -463,15 +468,21 @@ R_DrawEntitiesOnList
*/ */
void R_DrawEntitiesOnList (qboolean alphapass) //johnfitz -- added parameter void R_DrawEntitiesOnList (qboolean alphapass) //johnfitz -- added parameter
{ {
entity_t *entities_sorted[MAX_VISEDICTS];
int i; int i;
if (!r_drawentities.value) if (!r_drawentities.value)
return; return;
//ericw -- draw the entities sorted by model, to eliminate redundant texture binding
memcpy (entities_sorted, cl_visedicts, cl_numvisedicts * sizeof(entity_t *));
qsort (entities_sorted, cl_numvisedicts, sizeof(entity_t *), R_EntitySortFunc);
//ericw --
//johnfitz -- sprites are not a special case //johnfitz -- sprites are not a special case
for (i=0 ; i<cl_numvisedicts ; i++) for (i=0 ; i<cl_numvisedicts ; i++)
{ {
currententity = cl_visedicts[i]; currententity = entities_sorted[i];
//johnfitz -- if alphapass is true, draw only alpha entites this time //johnfitz -- if alphapass is true, draw only alpha entites this time
//if alphapass is false, draw only nonalpha entities this time //if alphapass is false, draw only nonalpha entities this time

1
quakespasm/Quake/gl_rmisc.c
View file

@ -274,6 +274,7 @@ void R_NewMap (void)
GL_BuildLightmaps (); GL_BuildLightmaps ();
GL_BuildVBOs (); GL_BuildVBOs ();
GLMesh_LoadVertexBuffers ();
r_framecount = 0; //johnfitz -- paranoid? r_framecount = 0; //johnfitz -- paranoid?
r_visframecount = 0; //johnfitz -- paranoid? r_visframecount = 0; //johnfitz -- paranoid?

81
quakespasm/Quake/gl_vidsdl.c
View file

@ -95,6 +95,7 @@ qboolean gl_anisotropy_able = false; //johnfitz
float gl_max_anisotropy; //johnfitz float gl_max_anisotropy; //johnfitz
qboolean gl_texture_NPOT = false; //ericw qboolean gl_texture_NPOT = false; //ericw
qboolean gl_vbo_able = false; //ericw qboolean gl_vbo_able = false; //ericw
qboolean gl_glsl_able = false; //ericw
GLint gl_max_texture_units = 0; //ericw GLint gl_max_texture_units = 0; //ericw
PFNGLMULTITEXCOORD2FARBPROC GL_MTexCoord2fFunc = NULL; //johnfitz PFNGLMULTITEXCOORD2FARBPROC GL_MTexCoord2fFunc = NULL; //johnfitz
@ -102,9 +103,30 @@ PFNGLACTIVETEXTUREARBPROC GL_SelectTextureFunc = NULL; //johnfitz
PFNGLCLIENTACTIVETEXTUREARBPROC GL_ClientActiveTextureFunc = NULL; //ericw PFNGLCLIENTACTIVETEXTUREARBPROC GL_ClientActiveTextureFunc = NULL; //ericw
PFNGLBINDBUFFERARBPROC GL_BindBufferFunc = NULL; //ericw PFNGLBINDBUFFERARBPROC GL_BindBufferFunc = NULL; //ericw
PFNGLBUFFERDATAARBPROC GL_BufferDataFunc = NULL; //ericw PFNGLBUFFERDATAARBPROC GL_BufferDataFunc = NULL; //ericw
PFNGLBUFFERSUBDATAARBPROC GL_BufferSubDataFunc = NULL; //ericw
PFNGLDELETEBUFFERSARBPROC GL_DeleteBuffersFunc = NULL; //ericw PFNGLDELETEBUFFERSARBPROC GL_DeleteBuffersFunc = NULL; //ericw
PFNGLGENBUFFERSARBPROC GL_GenBuffersFunc = NULL; //ericw PFNGLGENBUFFERSARBPROC GL_GenBuffersFunc = NULL; //ericw
PFNGLCREATESHADERPROC GL_CreateShaderFunc = NULL; //ericw
PFNGLSHADERSOURCEPROC GL_ShaderSourceFunc = NULL; //ericw
PFNGLCOMPILESHADERPROC GL_CompileShaderFunc = NULL; //ericw
PFNGLGETSHADERIVPROC GL_GetShaderivFunc = NULL; //ericw
PFNGLGETSHADERINFOLOGPROC GL_GetShaderInfoLogFunc = NULL; //ericw
PFNGLGETPROGRAMIVPROC GL_GetProgramivFunc = NULL; //ericw
PFNGLGETPROGRAMINFOLOGPROC GL_GetProgramInfoLogFunc = NULL; //ericw
PFNGLCREATEPROGRAMPROC GL_CreateProgramFunc = NULL; //ericw
PFNGLATTACHSHADERPROC GL_AttachShaderFunc = NULL; //ericw
PFNGLLINKPROGRAMPROC GL_LinkProgramFunc = NULL; //ericw
PFNGLUSEPROGRAMPROC GL_UseProgramFunc = NULL; //ericw
PFNGLGETATTRIBLOCATIONPROC GL_GetAttribLocationFunc = NULL; //ericw
PFNGLVERTEXATTRIBPOINTERPROC GL_VertexAttribPointerFunc = NULL; //ericw
PFNGLENABLEVERTEXATTRIBARRAYPROC GL_EnableVertexAttribArrayFunc = NULL; //ericw
PFNGLDISABLEVERTEXATTRIBARRAYPROC GL_DisableVertexAttribArrayFunc = NULL; //ericw
PFNGLGETUNIFORMLOCATIONPROC GL_GetUniformLocationFunc = NULL; //ericw
PFNGLUNIFORM1FPROC GL_Uniform1fFunc = NULL; //ericw
PFNGLUNIFORM3FPROC GL_Uniform3fFunc = NULL; //ericw
PFNGLUNIFORM4FPROC GL_Uniform4fFunc = NULL; //ericw
//==================================== //====================================
//johnfitz -- new cvars //johnfitz -- new cvars
@ -654,6 +676,7 @@ static void VID_Restart (void)
GL_Init (); GL_Init ();
TexMgr_ReloadImages (); TexMgr_ReloadImages ();
GL_BuildVBOs (); GL_BuildVBOs ();
GLMesh_LoadVertexBuffers ();
GL_SetupState (); GL_SetupState ();
//warpimages needs to be recalculated //warpimages needs to be recalculated
@ -819,9 +842,10 @@ static void GL_CheckExtensions (void)
{ {
GL_BindBufferFunc = (PFNGLBINDBUFFERARBPROC) SDL_GL_GetProcAddress("glBindBufferARB"); GL_BindBufferFunc = (PFNGLBINDBUFFERARBPROC) SDL_GL_GetProcAddress("glBindBufferARB");
GL_BufferDataFunc = (PFNGLBUFFERDATAARBPROC) SDL_GL_GetProcAddress("glBufferDataARB"); GL_BufferDataFunc = (PFNGLBUFFERDATAARBPROC) SDL_GL_GetProcAddress("glBufferDataARB");
GL_BufferSubDataFunc = (PFNGLBUFFERSUBDATAARBPROC) SDL_GL_GetProcAddress("glBufferSubDataARB");
GL_DeleteBuffersFunc = (PFNGLDELETEBUFFERSARBPROC) SDL_GL_GetProcAddress("glDeleteBuffersARB"); GL_DeleteBuffersFunc = (PFNGLDELETEBUFFERSARBPROC) SDL_GL_GetProcAddress("glDeleteBuffersARB");
GL_GenBuffersFunc = (PFNGLGENBUFFERSARBPROC) SDL_GL_GetProcAddress("glGenBuffersARB"); GL_GenBuffersFunc = (PFNGLGENBUFFERSARBPROC) SDL_GL_GetProcAddress("glGenBuffersARB");
if (GL_BindBufferFunc && GL_BufferDataFunc && GL_DeleteBuffersFunc && GL_GenBuffersFunc) if (GL_BindBufferFunc && GL_BufferDataFunc && GL_BufferSubDataFunc && GL_DeleteBuffersFunc && GL_GenBuffersFunc)
{ {
Con_Printf("FOUND: ARB_vertex_buffer_object\n"); Con_Printf("FOUND: ARB_vertex_buffer_object\n");
gl_vbo_able = true; gl_vbo_able = true;
@ -989,6 +1013,61 @@ static void GL_CheckExtensions (void)
{ {
Con_Warning ("texture_non_power_of_two not supported\n"); Con_Warning ("texture_non_power_of_two not supported\n");
} }
// GLSL
//
if (COM_CheckParm("-noglsl"))
Con_Warning ("GLSL disabled at command line\n");
else
{
GL_CreateShaderFunc = (PFNGLCREATESHADERPROC) SDL_GL_GetProcAddress("glCreateShader");
GL_ShaderSourceFunc = (PFNGLSHADERSOURCEPROC) SDL_GL_GetProcAddress("glShaderSource");
GL_CompileShaderFunc = (PFNGLCOMPILESHADERPROC) SDL_GL_GetProcAddress("glCompileShader");
GL_GetShaderivFunc = (PFNGLGETSHADERIVPROC) SDL_GL_GetProcAddress("glGetShaderiv");
GL_GetShaderInfoLogFunc = (PFNGLGETSHADERINFOLOGPROC) SDL_GL_GetProcAddress("glGetShaderInfoLog");
GL_GetProgramivFunc = (PFNGLGETPROGRAMIVPROC) SDL_GL_GetProcAddress("glGetProgramiv");
GL_GetProgramInfoLogFunc = (PFNGLGETPROGRAMINFOLOGPROC) SDL_GL_GetProcAddress("glGetProgramInfoLog");
GL_CreateProgramFunc = (PFNGLCREATEPROGRAMPROC) SDL_GL_GetProcAddress("glCreateProgram");
GL_AttachShaderFunc = (PFNGLATTACHSHADERPROC) SDL_GL_GetProcAddress("glAttachShader");
GL_LinkProgramFunc = (PFNGLLINKPROGRAMPROC) SDL_GL_GetProcAddress("glLinkProgram");
GL_UseProgramFunc = (PFNGLUSEPROGRAMPROC) SDL_GL_GetProcAddress("glUseProgram");
GL_GetAttribLocationFunc = (PFNGLGETATTRIBLOCATIONPROC) SDL_GL_GetProcAddress("glGetAttribLocation");
GL_VertexAttribPointerFunc = (PFNGLVERTEXATTRIBPOINTERPROC) SDL_GL_GetProcAddress("glVertexAttribPointer");
GL_EnableVertexAttribArrayFunc = (PFNGLENABLEVERTEXATTRIBARRAYPROC) SDL_GL_GetProcAddress("glEnableVertexAttribArray");
GL_DisableVertexAttribArrayFunc = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) SDL_GL_GetProcAddress("glDisableVertexAttribArray");
GL_GetUniformLocationFunc = (PFNGLGETUNIFORMLOCATIONPROC) SDL_GL_GetProcAddress("glGetUniformLocation");
GL_Uniform1fFunc = (PFNGLUNIFORM1FPROC) SDL_GL_GetProcAddress("glUniform1f");
GL_Uniform3fFunc = (PFNGLUNIFORM3FPROC) SDL_GL_GetProcAddress("glUniform3f");
GL_Uniform4fFunc = (PFNGLUNIFORM4FPROC) SDL_GL_GetProcAddress("glUniform4f");
if (GL_CreateShaderFunc &&
GL_ShaderSourceFunc &&
GL_CompileShaderFunc &&
GL_GetShaderivFunc &&
GL_GetShaderInfoLogFunc &&
GL_GetProgramivFunc &&
GL_GetProgramInfoLogFunc &&
GL_CreateProgramFunc &&
GL_AttachShaderFunc &&
GL_LinkProgramFunc &&
GL_UseProgramFunc &&
GL_GetAttribLocationFunc &&
GL_VertexAttribPointerFunc &&
GL_EnableVertexAttribArrayFunc &&
GL_DisableVertexAttribArrayFunc &&
GL_GetUniformLocationFunc &&
GL_Uniform1fFunc &&
GL_Uniform3fFunc &&
GL_Uniform4fFunc)
{
Con_Printf("FOUND: GLSL\n");
gl_glsl_able = true;
}
else
{
Con_Warning ("GLSL not available\n");
}
}
} }
/* /*

25
quakespasm/Quake/glquake.h
View file

@ -167,11 +167,35 @@ extern qboolean gl_anisotropy_able;
//ericw -- VBO //ericw -- VBO
extern PFNGLBINDBUFFERARBPROC GL_BindBufferFunc; extern PFNGLBINDBUFFERARBPROC GL_BindBufferFunc;
extern PFNGLBUFFERDATAARBPROC GL_BufferDataFunc; extern PFNGLBUFFERDATAARBPROC GL_BufferDataFunc;
extern PFNGLBUFFERSUBDATAARBPROC GL_BufferSubDataFunc;
extern PFNGLDELETEBUFFERSARBPROC GL_DeleteBuffersFunc; extern PFNGLDELETEBUFFERSARBPROC GL_DeleteBuffersFunc;
extern PFNGLGENBUFFERSARBPROC GL_GenBuffersFunc; extern PFNGLGENBUFFERSARBPROC GL_GenBuffersFunc;
extern qboolean gl_vbo_able; extern qboolean gl_vbo_able;
//ericw //ericw
//ericw -- GLSL
extern PFNGLCREATESHADERPROC GL_CreateShaderFunc;
extern PFNGLSHADERSOURCEPROC GL_ShaderSourceFunc;
extern PFNGLCOMPILESHADERPROC GL_CompileShaderFunc;
extern PFNGLGETSHADERIVPROC GL_GetShaderivFunc;
extern PFNGLGETSHADERINFOLOGPROC GL_GetShaderInfoLogFunc;
extern PFNGLGETPROGRAMIVPROC GL_GetProgramivFunc;
extern PFNGLGETPROGRAMINFOLOGPROC GL_GetProgramInfoLogFunc;
extern PFNGLCREATEPROGRAMPROC GL_CreateProgramFunc;
extern PFNGLATTACHSHADERPROC GL_AttachShaderFunc;
extern PFNGLLINKPROGRAMPROC GL_LinkProgramFunc;
extern PFNGLUSEPROGRAMPROC GL_UseProgramFunc;
extern PFNGLGETATTRIBLOCATIONPROC GL_GetAttribLocationFunc;
extern PFNGLVERTEXATTRIBPOINTERPROC GL_VertexAttribPointerFunc;
extern PFNGLENABLEVERTEXATTRIBARRAYPROC GL_EnableVertexAttribArrayFunc;
extern PFNGLDISABLEVERTEXATTRIBARRAYPROC GL_DisableVertexAttribArrayFunc;
extern PFNGLGETUNIFORMLOCATIONPROC GL_GetUniformLocationFunc;
extern PFNGLUNIFORM1FPROC GL_Uniform1fFunc;
extern PFNGLUNIFORM3FPROC GL_Uniform3fFunc;
extern PFNGLUNIFORM4FPROC GL_Uniform4fFunc;
extern qboolean gl_glsl_able;
// ericw --
//ericw -- NPOT texture support //ericw -- NPOT texture support
extern qboolean gl_texture_NPOT; extern qboolean gl_texture_NPOT;
@ -277,6 +301,7 @@ void R_DrawTextureChains_Water (qmodel_t *model, entity_t *ent, texchain_t chain
void R_RenderDlights (void); void R_RenderDlights (void);
void GL_BuildLightmaps (void); void GL_BuildLightmaps (void);
void GL_BuildVBOs (void); void GL_BuildVBOs (void);
void GLMesh_LoadVertexBuffers (void);
void R_RebuildAllLightmaps (void); void R_RebuildAllLightmaps (void);
int R_LightPoint (vec3_t p); int R_LightPoint (vec3_t p);

189
quakespasm/Quake/r_alias.c
View file

@ -50,7 +50,7 @@ float r_avertexnormal_dots[SHADEDOT_QUANT][256] =
extern vec3_t lightspot; extern vec3_t lightspot;
float *shadedots = r_avertexnormal_dots[0]; float *shadedots = r_avertexnormal_dots[0];
vec3_t shadevector;
float entalpha; //johnfitz float entalpha; //johnfitz
qboolean overbright; //johnfitz qboolean overbright; //johnfitz
@ -67,6 +67,23 @@ typedef struct {
} lerpdata_t; } lerpdata_t;
//johnfitz //johnfitz
extern GLuint r_meshvbo;
extern GLuint r_meshindexesvbo;
void *GLARB_GetXYZOffset (aliashdr_t *hdr, int pose)
{
meshxyz_t dummy;
int xyzoffs = ((char*)&dummy.xyz - (char*)&dummy);
return (void *) (hdr->vboxyzofs + (hdr->numverts_vbo * pose * sizeof (meshxyz_t)) + xyzoffs);
}
void *GLARB_GetNormalOffset (aliashdr_t *hdr, int pose)
{
meshxyz_t dummy;
int normaloffs = ((char*)&dummy.normal - (char*)&dummy);
return (void *) (hdr->vboxyzofs + (hdr->numverts_vbo * pose * sizeof (meshxyz_t)) + normaloffs);
}
/* /*
============= =============
GL_DrawAliasFrame -- johnfitz -- rewritten to support colored light, lerping, entalpha, multitexture, and r_drawflat GL_DrawAliasFrame -- johnfitz -- rewritten to support colored light, lerping, entalpha, multitexture, and r_drawflat
@ -105,6 +122,165 @@ void GL_DrawAliasFrame (aliashdr_t *paliashdr, lerpdata_t lerpdata)
vertcolor[3] = entalpha; //never changes, so there's no need to put this inside the loop vertcolor[3] = entalpha; //never changes, so there's no need to put this inside the loop
// ericw -- shader
static GLuint shader;
static GLuint program;
static GLuint blendLoc;
static GLuint shadevectorLoc;
static GLuint lightColorLoc;
static GLint pose1VertexAttrIndex;
static GLint pose1NormalAttrIndex;
static GLint pose2VertexAttrIndex;
static GLint pose2NormalAttrIndex;
if (shader == 0)
{
const GLchar *source = \
"uniform float Blend;\n"
"uniform vec3 ShadeVector;\n"
"uniform vec4 LightColor;\n"
"attribute vec4 Pose1Vert;\n"
"attribute vec3 Pose1Normal;\n"
"attribute vec4 Pose2Vert;\n"
"attribute vec3 Pose2Normal;\n"
"float r_avertexnormal_dot(vec3 vertexnormal)\n"
"{\n"
" float dot = dot(vertexnormal, ShadeVector);\n"
" // wtf - this reproduces anorm_dots within as reasonable a degree of tolerance as the >= 0 case\n"
" if (dot < 0.0)\n"
" return 1.0 + dot * (13.0 / 44.0);\n"
" else\n"
" return 1.0 + dot;\n"
"}\n"
"void main()\n"
"{\n"
" gl_TexCoord[0] = gl_MultiTexCoord0;\n"
" gl_TexCoord[1] = gl_MultiTexCoord0;\n"
" gl_Position = gl_ModelViewProjectionMatrix * mix(Pose1Vert, Pose2Vert, Blend);\n"
" float dot1 = r_avertexnormal_dot(Pose1Normal);\n"
" float dot2 = r_avertexnormal_dot(Pose2Normal);\n"
" gl_FrontColor = LightColor * vec4(vec3(mix(dot1, dot2, Blend)), 1.0);\n"
"}\n"
;
shader = GL_CreateShaderFunc(GL_VERTEX_SHADER);
GL_ShaderSourceFunc(shader, 1, &source, NULL);
GL_CompileShaderFunc(shader);
GLint status;
GL_GetShaderivFunc(shader, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE)
{
static char infolog[65536];
GL_GetShaderInfoLogFunc (shader, 65536, NULL, infolog);
printf("Shader info log: %s\n", infolog);
Sys_Error("Shader failed to compile");
}
// create program
program = GL_CreateProgramFunc();
GL_AttachShaderFunc(program, shader);
GL_LinkProgramFunc(program);
GL_GetProgramivFunc(program, GL_LINK_STATUS, &status);
if (status != GL_TRUE)
{
Sys_Error("Program failed to link");
}
// get uniform location
blendLoc = GL_GetUniformLocationFunc(program, "Blend");
if (blendLoc == -1)
{
Sys_Error("GL_GetUniformLocationFunc Blend failed");
}
shadevectorLoc = GL_GetUniformLocationFunc(program, "ShadeVector");
if (shadevectorLoc == -1)
{
Sys_Error("GL_GetUniformLocationFunc shadevector failed");
}
lightColorLoc = GL_GetUniformLocationFunc(program, "LightColor");
if (lightColorLoc == -1)
{
Sys_Error("GL_GetUniformLocationFunc LightColor failed");
}
// get attributes
pose1VertexAttrIndex = GL_GetAttribLocationFunc(program, "Pose1Vert");
pose1NormalAttrIndex = GL_GetAttribLocationFunc(program, "Pose1Normal");
pose2VertexAttrIndex = GL_GetAttribLocationFunc(program, "Pose2Vert");
pose2NormalAttrIndex = GL_GetAttribLocationFunc(program, "Pose2Normal");
}
GL_UseProgramFunc(program);
// ericw --
// ericw -- bind it and stuff
GL_BindBufferFunc (GL_ARRAY_BUFFER, r_meshvbo);
GL_BindBufferFunc (GL_ELEMENT_ARRAY_BUFFER, r_meshindexesvbo);
GL_VertexAttribPointerFunc (pose1VertexAttrIndex, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof (meshxyz_t), GLARB_GetXYZOffset (paliashdr, lerpdata.pose1));
GL_EnableVertexAttribArrayFunc (pose1VertexAttrIndex);
GL_VertexAttribPointerFunc (pose2VertexAttrIndex, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof (meshxyz_t), GLARB_GetXYZOffset (paliashdr, lerpdata.pose2));
GL_EnableVertexAttribArrayFunc (pose2VertexAttrIndex);
GL_ClientActiveTextureFunc (GL_TEXTURE0_ARB);
glTexCoordPointer (2, GL_FLOAT, 0, (void *) paliashdr->vbostofs);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE1_ARB);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE2_ARB);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
GL_VertexAttribPointerFunc (pose1NormalAttrIndex, 3, GL_FLOAT, GL_FALSE, sizeof (meshxyz_t), GLARB_GetNormalOffset (paliashdr, lerpdata.pose1));
GL_EnableVertexAttribArrayFunc (pose1NormalAttrIndex);
GL_VertexAttribPointerFunc (pose2NormalAttrIndex, 3, GL_FLOAT, GL_FALSE, sizeof (meshxyz_t), GLARB_GetNormalOffset (paliashdr, lerpdata.pose2));
GL_EnableVertexAttribArrayFunc (pose2NormalAttrIndex);
// Uniform
GL_Uniform1fFunc(blendLoc, blend);
GL_Uniform3fFunc(shadevectorLoc, shadevector[0], shadevector[1], shadevector[2]);
GL_Uniform4fFunc(lightColorLoc, lightcolor[0], lightcolor[1], lightcolor[2], entalpha);
//
// ericw -- bind it and stuff
// GL_SelectTexture (GL_TEXTURE0_ARB);
// glEnable(GL_TEXTURE_2D);
glDrawElements(GL_TRIANGLES, paliashdr->numindexes, GL_UNSIGNED_SHORT, (void *)paliashdr->vboindexofs);
glDisableClientState (GL_VERTEX_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE0_ARB);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE1_ARB);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE2_ARB);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState (GL_NORMAL_ARRAY);
GL_UseProgramFunc(0);
return;
while (1) while (1)
{ {
// get the vertex count and primitive type // get the vertex count and primitive type
@ -374,8 +550,17 @@ void R_SetupAliasLighting (entity_t *e)
lightcolor[1] = 256.0f; lightcolor[1] = 256.0f;
lightcolor[2] = 256.0f; lightcolor[2] = 256.0f;
} }
int quantangle = ((int)(e->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1);
shadedots = r_avertexnormal_dots[((int)(e->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)]; float radAngle = (quantangle / 16.0) * 2.0 * 3.14159;
shadevector[0] = cos(-radAngle);
shadevector[1] = sin(-radAngle);
shadevector[2] = 1;
VectorNormalize(shadevector);
shadedots = r_avertexnormal_dots[quantangle];
VectorScale(lightcolor, 1.0f / 200.0f, lightcolor); VectorScale(lightcolor, 1.0f / 200.0f, lightcolor);
} }

2
quakespasm/Quake/r_brush.c
View file

@ -959,7 +959,7 @@ void GL_BuildLightmaps (void)
============================================================= =============================================================
*/ */
static GLuint gl_bmodel_vbo = 0; GLuint gl_bmodel_vbo = 0;
/* /*
================== ==================

25
quakespasm/Quake/r_world.c
View file

@ -770,6 +770,8 @@ void R_DrawLightmapChains (void)
} }
} }
extern GLuint gl_bmodel_vbo;
/* /*
================ ================
R_DrawTextureChains_Multitexture_VBO -- ericw R_DrawTextureChains_Multitexture_VBO -- ericw
@ -787,6 +789,29 @@ void R_DrawTextureChains_Multitexture_VBO (qmodel_t *model, entity_t *ent, texch
int lastlightmap; int lastlightmap;
gltexture_t *fullbright = NULL; gltexture_t *fullbright = NULL;
// ericw -- bind it and stuff
GL_BindBufferFunc (GL_ARRAY_BUFFER, gl_bmodel_vbo);
GL_BindBufferFunc (GL_ELEMENT_ARRAY_BUFFER, 0); // ericw -- so we pull them from client memory!
// setup vertex array. this will need to move if we use vertex arrays for other things
glVertexPointer (3, GL_FLOAT, VERTEXSIZE * sizeof(float), ((float *)0));
glEnableClientState (GL_VERTEX_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE0_ARB);
glTexCoordPointer (2, GL_FLOAT, VERTEXSIZE * sizeof(float), ((float *)0) + 3);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
GL_ClientActiveTextureFunc (GL_TEXTURE1_ARB);
glTexCoordPointer (2, GL_FLOAT, VERTEXSIZE * sizeof(float), ((float *)0) + 5);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
// TMU 2 is for fullbrights; same texture coordinates as TMU 0
GL_ClientActiveTextureFunc (GL_TEXTURE2_ARB);
glTexCoordPointer (2, GL_FLOAT, VERTEXSIZE * sizeof(float), ((float *)0) + 3);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
// ericw -- bind it and stuff
// Setup TMU 1 (lightmap) // Setup TMU 1 (lightmap)
GL_SelectTexture (GL_TEXTURE1_ARB); GL_SelectTexture (GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);