qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-05-31 00:30:57 +00:00
Code Issues Projects Releases Packages Wiki Activity

Clean up global symbols for the glsl renderer.

Browse source 
Where possible, symbols have been made static, prefixed with glsl_/GLSL_ or
moved into the code shared by all renderers. This will make doing plugins
easier but done now for link testing. The moving was done via the gl
commit.
This commit is contained in:
Bill Currie 2012-02-17 18:57:13 +09:00
parent 447ff2f2f5
commit ef37ed39a9
14 changed files with 196 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

31
include/QF/GLSL/qf_textures.h
View file

@ -42,24 +42,21 @@ typedef struct subpic_s {
const float size; ///< size factor for tex coords (mult) const float size; ///< size factor for tex coords (mult)
} subpic_t; } subpic_t;
int GL_LoadQuakeTexture (const char *identifier, int width, int height, int GLSL_LoadQuakeTexture (const char *identifier, int width, int height,
byte *data); byte *data);
struct texture_s; struct texture_s;
int GL_LoadQuakeMipTex (const struct texture_s *tex); int GLSL_LoadQuakeMipTex (const struct texture_s *tex);
int GL_LoadRGBTexture (const char *identifier, int width, int height, int GLSL_LoadRGBTexture (const char *identifier, int width, int height,
byte *data); byte *data);
void GL_ReleaseTexture (int tex); void GLSL_ReleaseTexture (int tex);
void GL_TextureInit (void); void GLSL_TextureInit (void);
scrap_t *GL_CreateScrap (int size, int format); scrap_t *GLSL_CreateScrap (int size, int format);
void GL_DestroyScrap (scrap_t *scrap); void GLSL_DestroyScrap (scrap_t *scrap);
void GL_ScrapClear (scrap_t *scrap); void GLSL_ScrapClear (scrap_t *scrap);
int GL_ScrapTexture (scrap_t *scrap); int GLSL_ScrapTexture (scrap_t *scrap);
subpic_t *GL_ScrapSubpic (scrap_t *scrap, int width, int height); //XXX slow! subpic_t *GLSL_ScrapSubpic (scrap_t *scrap, int width, int height); //XXX slow!
void GL_SubpicDelete (subpic_t *subpic); //XXX slow! void GLSL_SubpicDelete (subpic_t *subpic); //XXX slow!
void GL_SubpicUpdate (subpic_t *subpic, byte *data); void GLSL_SubpicUpdate (subpic_t *subpic, byte *data);
int GL_LoadTexture (const char *identifier, int width, int height, byte *data,
qboolean mipmap, qboolean alpha, int bytesperpixel);
#endif//__QF_GLSL_textures_h #endif//__QF_GLSL_textures_h

8
include/QF/GLSL/qf_vid.h
View file

@ -41,9 +41,9 @@ extern int glsl_palette;
extern int glsl_colormap; extern int glsl_colormap;
void GL_EndRendering (void); void GL_EndRendering (void);
int GL_CompileShader (const char *name, const char *shader_src, int type); int GLSL_CompileShader (const char *name, const char *shader_src, int type);
int GL_LinkProgram (const char *name, int vert, int frag); int GLSL_LinkProgram (const char *name, int vert, int frag);
int GL_ResolveShaderParam (int program, shaderparam_t *param); int GLSL_ResolveShaderParam (int program, shaderparam_t *param);
void GL_DumpAttribArrays (void); void GLSL_DumpAttribArrays (void);
#endif // __QF_GLSL_vid_h #endif // __QF_GLSL_vid_h

6
libs/models/alias/glsl_model_alias.c
View file

@ -81,10 +81,10 @@ glsl_alias_clear (model_t *m)
if (skins[i].type == ALIAS_SKIN_GROUP) { if (skins[i].type == ALIAS_SKIN_GROUP) {
group = (maliasskingroup_t *) ((byte *) hdr + skins[i].skin); group = (maliasskingroup_t *) ((byte *) hdr + skins[i].skin);
for (j = 0; j < group->numskins; j++) { for (j = 0; j < group->numskins; j++) {
GL_ReleaseTexture (group->skindescs[j].texnum); GLSL_ReleaseTexture (group->skindescs[j].texnum);
} }
} else { } else {
GL_ReleaseTexture (skins[i].texnum); GLSL_ReleaseTexture (skins[i].texnum);
} }
} }
@ -111,7 +111,7 @@ Mod_LoadSkin (byte *skin, int skinsize, int snum, int gnum, qboolean group,
name = va ("%s_%i_%i", loadmodel->name, snum, gnum); name = va ("%s_%i_%i", loadmodel->name, snum, gnum);
else else
name = va ("%s_%i", loadmodel->name, snum); name = va ("%s_%i", loadmodel->name, snum);
skindesc->texnum = GL_LoadQuakeTexture (name, w, h, tskin); skindesc->texnum = GLSL_LoadQuakeTexture (name, w, h, tskin);
free (tskin); free (tskin);
return skin + skinsize; return skin + skinsize;
} }

8
libs/models/brush/glsl_model_brush.c
View file

@ -67,7 +67,7 @@ glsl_brush_clear (model_t *m)
for (i = 0; i < m->numtextures; i++) { for (i = 0; i < m->numtextures; i++) {
// NOTE: some maps (eg e1m2) have empty texture slots // NOTE: some maps (eg e1m2) have empty texture slots
if (m->textures[i] && m->textures[i]->gl_texturenum) { if (m->textures[i] && m->textures[i]->gl_texturenum) {
GL_ReleaseTexture (m->textures[i]->gl_texturenum); GLSL_ReleaseTexture (m->textures[i]->gl_texturenum);
m->textures[i]->gl_texturenum = 0; m->textures[i]->gl_texturenum = 0;
} }
} }
@ -97,14 +97,14 @@ Mod_ProcessTexture (texture_t *tx)
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
for (j = 0; j < 128; j++) for (j = 0; j < 128; j++)
memcpy (&data[j * 128], &tx_data[j * 256 + i * 128], 128); memcpy (&data[j * 128], &tx_data[j * 256 + i * 128], 128);
tx->sky_tex[i] = GL_LoadQuakeTexture (tx->name, 128, 128, data); tx->sky_tex[i] = GLSL_LoadQuakeTexture (tx->name, 128, 128, data);
// GL_LoadQuakeTexture () leaves the texture bound // GLSL_LoadQuakeTexture () leaves the texture bound
qfglTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); qfglTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qfglTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); qfglTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
} }
tx->gl_texturenum = 0; tx->gl_texturenum = 0;
} else { } else {
tx->gl_texturenum = GL_LoadQuakeMipTex (tx); tx->gl_texturenum = GLSL_LoadQuakeMipTex (tx);
} }
} }

8
libs/models/sprite/glsl_model_sprite.c
View file

@ -61,12 +61,12 @@ glsl_sprite_clear (model_t *m)
for (i = 0; i < sprite->numframes; i++) { for (i = 0; i < sprite->numframes; i++) {
if (sprite->frames[i].type == SPR_SINGLE) { if (sprite->frames[i].type == SPR_SINGLE) {
frame = sprite->frames[i].frameptr; frame = sprite->frames[i].frameptr;
GL_ReleaseTexture (frame->gl_texturenum); GLSL_ReleaseTexture (frame->gl_texturenum);
} else { } else {
group = (mspritegroup_t *) sprite->frames[i].frameptr; group = (mspritegroup_t *) sprite->frames[i].frameptr;
for (j = 0; j < group->numframes; j++) { for (j = 0; j < group->numframes; j++) {
frame = group->frames[j]; frame = group->frames[j];
GL_ReleaseTexture (frame->gl_texturenum); GLSL_ReleaseTexture (frame->gl_texturenum);
} }
} }
} }
@ -80,6 +80,6 @@ Mod_SpriteLoadTexture (mspriteframe_t *pspriteframe, int framenum)
loadmodel->clear = glsl_sprite_clear; loadmodel->clear = glsl_sprite_clear;
name = va ("%s_%i", loadmodel->name, framenum); name = va ("%s_%i", loadmodel->name, framenum);
pspriteframe->gl_texturenum = pspriteframe->gl_texturenum =
GL_LoadQuakeTexture (name, pspriteframe->width, pspriteframe->height, GLSL_LoadQuakeTexture (name, pspriteframe->width, pspriteframe->height,
pspriteframe->pixels); pspriteframe->pixels);
} }

45
libs/video/renderer/glsl/glsl_alias.c
View file

@ -110,28 +110,29 @@ R_InitAlias (void)
int vert; int vert;
int frag; int frag;
vert = GL_CompileShader ("quakemdl.vert", quakemdl_vert, GL_VERTEX_SHADER); vert = GLSL_CompileShader ("quakemdl.vert", quakemdl_vert,
frag = GL_CompileShader ("quakemdl.frag", quakemdl_frag, GL_VERTEX_SHADER);
GL_FRAGMENT_SHADER); frag = GLSL_CompileShader ("quakemdl.frag", quakemdl_frag,
quake_mdl.program = GL_LinkProgram ("quakemdl", vert, frag); GL_FRAGMENT_SHADER);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.mvp_matrix); quake_mdl.program = GLSL_LinkProgram ("quakemdl", vert, frag);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.norm_matrix); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.mvp_matrix);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin_size); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.norm_matrix);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.blend); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin_size);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colora); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.blend);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colorb); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colora);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.sta); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colorb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.stb); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.sta);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normala); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.stb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normalb); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normala);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexa); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normalb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexb); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexa);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colormap); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colormap);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.ambient); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.shadelight); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.ambient);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.lightvec); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.shadelight);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.fog); GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.lightvec);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.fog);
} }
static void static void

96
libs/video/renderer/glsl/glsl_bsp.c
View file

@ -66,10 +66,10 @@ typedef struct {
#define ALLOC_CHUNK 64 #define ALLOC_CHUNK 64
instsurf_t *waterchain = NULL; static instsurf_t *waterchain = NULL;
instsurf_t **waterchain_tail = &waterchain; static instsurf_t **waterchain_tail = &waterchain;
instsurf_t *sky_chain; static instsurf_t *sky_chain;
instsurf_t **sky_chain_tail = &sky_chain; static instsurf_t **sky_chain_tail = &sky_chain;
static texture_t **r_texture_chains; static texture_t **r_texture_chains;
static int r_num_texture_chains; static int r_num_texture_chains;
@ -1225,52 +1225,54 @@ R_InitBsp (void)
int vert; int vert;
int frag; int frag;
vert = GL_CompileShader ("quakebsp.vert", quakebsp_vert, GL_VERTEX_SHADER); vert = GLSL_CompileShader ("quakebsp.vert", quakebsp_vert,
frag = GL_CompileShader ("quakebsp.frag", quakebsp_frag, GL_VERTEX_SHADER);
GL_FRAGMENT_SHADER); frag = GLSL_CompileShader ("quakebsp.frag", quakebsp_frag,
quake_bsp.program = GL_LinkProgram ("quakebsp", vert, frag); GL_FRAGMENT_SHADER);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.mvp_matrix); quake_bsp.program = GLSL_LinkProgram ("quakebsp", vert, frag);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.tlst); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.mvp_matrix);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.vertex); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.tlst);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.colormap); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.vertex);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.texture); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.colormap);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.lightmap); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.texture);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.color); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.lightmap);
GL_ResolveShaderParam (quake_bsp.program, &quake_bsp.fog); GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.color);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.fog);
frag = GL_CompileShader ("quaketrb.frag", quaketurb_frag, frag = GLSL_CompileShader ("quaketrb.frag", quaketurb_frag,
GL_FRAGMENT_SHADER); GL_FRAGMENT_SHADER);
quake_turb.program = GL_LinkProgram ("quaketrb", vert, frag); quake_turb.program = GLSL_LinkProgram ("quaketrb", vert, frag);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.mvp_matrix); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.mvp_matrix);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.tlst); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.tlst);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.vertex); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.vertex);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.palette); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.palette);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.texture); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.texture);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.realtime); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.realtime);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.color); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.color);
GL_ResolveShaderParam (quake_turb.program, &quake_turb.fog); GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.fog);
vert = GL_CompileShader ("quakesky.vert", quakesky_vert, GL_VERTEX_SHADER); vert = GLSL_CompileShader ("quakesky.vert", quakesky_vert,
frag = GL_CompileShader ("quakeski.frag", quakeskyid_frag, GL_VERTEX_SHADER);
GL_FRAGMENT_SHADER); frag = GLSL_CompileShader ("quakeski.frag", quakeskyid_frag,
quake_skyid.program = GL_LinkProgram ("quakeskyid", vert, frag); GL_FRAGMENT_SHADER);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.mvp_matrix); quake_skyid.program = GLSL_LinkProgram ("quakeskyid", vert, frag);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.sky_matrix); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.mvp_matrix);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.vertex); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.sky_matrix);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.palette); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.vertex);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.solid); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.palette);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.trans); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.solid);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.realtime); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.trans);
GL_ResolveShaderParam (quake_skyid.program, &quake_skyid.fog); GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.realtime);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.fog);
frag = GL_CompileShader ("quakeskb.frag", quakeskybox_frag, frag = GLSL_CompileShader ("quakeskb.frag", quakeskybox_frag,
GL_FRAGMENT_SHADER); GL_FRAGMENT_SHADER);
quake_skybox.program = GL_LinkProgram ("quakeskybox", vert, frag); quake_skybox.program = GLSL_LinkProgram ("quakeskybox", vert, frag);
GL_ResolveShaderParam (quake_skybox.program, &quake_skybox.mvp_matrix); GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.mvp_matrix);
GL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky_matrix); GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky_matrix);
GL_ResolveShaderParam (quake_skybox.program, &quake_skybox.vertex); GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.vertex);
GL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky); GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky);
GL_ResolveShaderParam (quake_skybox.program, &quake_skybox.fog); GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.fog);
} }
static inline int static inline int

44
libs/video/renderer/glsl/glsl_draw.c
View file

@ -136,7 +136,8 @@ make_glpic (const char *name, qpic_t *p)
pic = malloc (sizeof (qpic_t) + sizeof (glpic_t)); pic = malloc (sizeof (qpic_t) + sizeof (glpic_t));
*pic = *p; *pic = *p;
gl = (glpic_t *) pic->data; gl = (glpic_t *) pic->data;
gl->texnum = GL_LoadQuakeTexture (name, p->width, p->height, p->data); gl->texnum = GLSL_LoadQuakeTexture (name, p->width, p->height,
p->data);
} }
return pic; return pic;
} }
@ -146,7 +147,7 @@ pic_free (qpic_t *pic)
{ {
glpic_t *gl = (glpic_t *) pic->data; glpic_t *gl = (glpic_t *) pic->data;
GL_ReleaseTexture (gl->texnum); GLSL_ReleaseTexture (gl->texnum);
free (pic); free (pic);
} }
@ -395,35 +396,38 @@ Draw_Init (void)
crosshaircolor->callback (crosshaircolor); crosshaircolor->callback (crosshaircolor);
char_queue = dstring_new (); char_queue = dstring_new ();
vert = GL_CompileShader ("quaketxt.vert", quaketext_vert, GL_VERTEX_SHADER); vert = GLSL_CompileShader ("quaketxt.vert", quaketext_vert,
frag = GL_CompileShader ("quake2d.frag", quake2d_frag, GL_FRAGMENT_SHADER); GL_VERTEX_SHADER);
quake_text.program = GL_LinkProgram ("quaketxt", vert, frag); frag = GLSL_CompileShader ("quake2d.frag", quake2d_frag,
GL_ResolveShaderParam (quake_text.program, &quake_text.charmap); GL_FRAGMENT_SHADER);
GL_ResolveShaderParam (quake_text.program, &quake_text.palette); quake_text.program = GLSL_LinkProgram ("quaketxt", vert, frag);
GL_ResolveShaderParam (quake_text.program, &quake_text.matrix); GLSL_ResolveShaderParam (quake_text.program, &quake_text.charmap);
GL_ResolveShaderParam (quake_text.program, &quake_text.vertex); GLSL_ResolveShaderParam (quake_text.program, &quake_text.palette);
GL_ResolveShaderParam (quake_text.program, &quake_text.color); GLSL_ResolveShaderParam (quake_text.program, &quake_text.matrix);
GL_ResolveShaderParam (quake_text.program, &quake_text.dchar); GLSL_ResolveShaderParam (quake_text.program, &quake_text.vertex);
GLSL_ResolveShaderParam (quake_text.program, &quake_text.color);
GLSL_ResolveShaderParam (quake_text.program, &quake_text.dchar);
vert = GL_CompileShader ("quakeico.vert", quakeicon_vert, GL_VERTEX_SHADER); vert = GLSL_CompileShader ("quakeico.vert", quakeicon_vert,
quake_icon.program = GL_LinkProgram ("quakeico", vert, frag); GL_VERTEX_SHADER);
GL_ResolveShaderParam (quake_icon.program, &quake_icon.icon); quake_icon.program = GLSL_LinkProgram ("quakeico", vert, frag);
GL_ResolveShaderParam (quake_icon.program, &quake_icon.palette); GLSL_ResolveShaderParam (quake_icon.program, &quake_icon.icon);
GL_ResolveShaderParam (quake_icon.program, &quake_icon.matrix); GLSL_ResolveShaderParam (quake_icon.program, &quake_icon.palette);
GL_ResolveShaderParam (quake_icon.program, &quake_icon.vertex); GLSL_ResolveShaderParam (quake_icon.program, &quake_icon.matrix);
GL_ResolveShaderParam (quake_icon.program, &quake_icon.color); GLSL_ResolveShaderParam (quake_icon.program, &quake_icon.vertex);
GLSL_ResolveShaderParam (quake_icon.program, &quake_icon.color);
draw_chars = W_GetLumpName ("conchars"); draw_chars = W_GetLumpName ("conchars");
for (i = 0; i < 256 * 64; i++) for (i = 0; i < 256 * 64; i++)
if (draw_chars[i] == 0) if (draw_chars[i] == 0)
draw_chars[i] = 255; // proper transparent color draw_chars[i] = 255; // proper transparent color
char_texture = GL_LoadQuakeTexture ("conchars", 128, 128, draw_chars); char_texture = GLSL_LoadQuakeTexture ("conchars", 128, 128, draw_chars);
pic = (qpic_t *) QFS_LoadFile ("gfx/conback.lmp", 0); pic = (qpic_t *) QFS_LoadFile ("gfx/conback.lmp", 0);
if (pic) { if (pic) {
SwapPic (pic); SwapPic (pic);
conback_texture = GL_LoadQuakeTexture ("conback", conback_texture = GLSL_LoadQuakeTexture ("conback",
pic->width, pic->height, pic->width, pic->height,
pic->data); pic->data);
free (pic); free (pic);

12
libs/video/renderer/glsl/glsl_lightmap.c
View file

@ -140,7 +140,7 @@ R_BuildLightMap_1 (msurface_t *surf)
memset (blocklights, 0, size * sizeof (blocklights[0])); memset (blocklights, 0, size * sizeof (blocklights[0]));
if (!r_worldentity.model->lightdata) { if (!r_worldentity.model->lightdata) {
// because we by-pass the inversion, "no light" = "full bright" // because we by-pass the inversion, "no light" = "full bright"
GL_SubpicUpdate (surf->lightpic, (byte *) blocklights); GLSL_SubpicUpdate (surf->lightpic, (byte *) blocklights);
return; return;
} }
@ -173,7 +173,7 @@ R_BuildLightMap_1 (msurface_t *surf)
*out++ = t; *out++ = t;
} }
GL_SubpicUpdate (surf->lightpic, (byte *) blocklights); GLSL_SubpicUpdate (surf->lightpic, (byte *) blocklights);
} }
static void static void
@ -182,7 +182,7 @@ create_surf_lightmap (msurface_t *surf)
int smax, tmax; int smax, tmax;
smax = (surf->extents[0] >> 4) + 1; smax = (surf->extents[0] >> 4) + 1;
tmax = (surf->extents[1] >> 4) + 1; tmax = (surf->extents[1] >> 4) + 1;
surf->lightpic = GL_ScrapSubpic (light_scrap, smax, tmax); surf->lightpic = GLSL_ScrapSubpic (light_scrap, smax, tmax);
if (!surf->lightpic) if (!surf->lightpic)
Sys_Error ("FIXME taniwha is being lazy"); Sys_Error ("FIXME taniwha is being lazy");
if (smax > bl_extents[0]) if (smax > bl_extents[0])
@ -199,10 +199,10 @@ R_BuildLightmaps (model_t **models, int num_models)
//FIXME RGB support //FIXME RGB support
if (!light_scrap) { if (!light_scrap) {
light_scrap = GL_CreateScrap (2048, GL_LUMINANCE); light_scrap = GLSL_CreateScrap (2048, GL_LUMINANCE);
light_data = malloc (BLOCK_SIZE * MAX_LIGHTMAPS); light_data = malloc (BLOCK_SIZE * MAX_LIGHTMAPS);
} else { } else {
GL_ScrapClear (light_scrap); GLSL_ScrapClear (light_scrap);
memset (light_data, 0, BLOCK_SIZE * MAX_LIGHTMAPS); memset (light_data, 0, BLOCK_SIZE * MAX_LIGHTMAPS);
} }
R_BuildLightMap = R_BuildLightMap_1; R_BuildLightMap = R_BuildLightMap_1;
@ -249,5 +249,5 @@ R_BuildLightmaps (model_t **models, int num_models)
int int
R_LightmapTexture (void) R_LightmapTexture (void)
{ {
return GL_ScrapTexture (light_scrap); return GLSL_ScrapTexture (light_scrap);
} }

7
libs/video/renderer/glsl/glsl_main.c
View file

@ -282,13 +282,6 @@ R_LineGraph (int x, int y, int *h_vals, int count)
{ {
} }
VISIBLE int
GL_LoadTexture (const char *identifier, int width, int height, byte *data,
qboolean mipmap, qboolean alpha, int bytesperpixel)
{
return 0;
}
VISIBLE void VISIBLE void
R_ClearState (void) R_ClearState (void)
{ {

42
libs/video/renderer/glsl/glsl_particles.c
View file

@ -220,28 +220,28 @@ R_InitParticles (void)
qfglGetFloatv (GL_ALIASED_POINT_SIZE_RANGE, v); qfglGetFloatv (GL_ALIASED_POINT_SIZE_RANGE, v);
Sys_MaskPrintf (SYS_GLSL, "point size: %g - %g\n", v[0], v[1]); Sys_MaskPrintf (SYS_GLSL, "point size: %g - %g\n", v[0], v[1]);
vert = GL_CompileShader ("quakepnt.vert", quakepoint_vert, vert = GLSL_CompileShader ("quakepnt.vert", quakepoint_vert,
GL_VERTEX_SHADER); GL_VERTEX_SHADER);
frag = GL_CompileShader ("quakepnt.frag", quakepoint_frag, frag = GLSL_CompileShader ("quakepnt.frag", quakepoint_frag,
GL_FRAGMENT_SHADER); GL_FRAGMENT_SHADER);
quake_point.program = GL_LinkProgram ("quakepoint", vert, frag); quake_point.program = GLSL_LinkProgram ("quakepoint", vert, frag);
GL_ResolveShaderParam (quake_point.program, &quake_point.mvp_matrix); GLSL_ResolveShaderParam (quake_point.program, &quake_point.mvp_matrix);
GL_ResolveShaderParam (quake_point.program, &quake_point.vertex); GLSL_ResolveShaderParam (quake_point.program, &quake_point.vertex);
GL_ResolveShaderParam (quake_point.program, &quake_point.palette); GLSL_ResolveShaderParam (quake_point.program, &quake_point.palette);
GL_ResolveShaderParam (quake_point.program, &quake_point.color); GLSL_ResolveShaderParam (quake_point.program, &quake_point.color);
GL_ResolveShaderParam (quake_point.program, &quake_point.fog); GLSL_ResolveShaderParam (quake_point.program, &quake_point.fog);
vert = GL_CompileShader ("quakepar.vert", quakepart_vert, vert = GLSL_CompileShader ("quakepar.vert", quakepart_vert,
GL_VERTEX_SHADER); GL_VERTEX_SHADER);
frag = GL_CompileShader ("quakepar.frag", quakepart_frag, frag = GLSL_CompileShader ("quakepar.frag", quakepart_frag,
GL_FRAGMENT_SHADER); GL_FRAGMENT_SHADER);
quake_part.program = GL_LinkProgram ("quakepart", vert, frag); quake_part.program = GLSL_LinkProgram ("quakepart", vert, frag);
GL_ResolveShaderParam (quake_part.program, &quake_part.mvp_matrix); GLSL_ResolveShaderParam (quake_part.program, &quake_part.mvp_matrix);
GL_ResolveShaderParam (quake_part.program, &quake_part.st); GLSL_ResolveShaderParam (quake_part.program, &quake_part.st);
GL_ResolveShaderParam (quake_part.program, &quake_part.vertex); GLSL_ResolveShaderParam (quake_part.program, &quake_part.vertex);
GL_ResolveShaderParam (quake_part.program, &quake_part.color); GLSL_ResolveShaderParam (quake_part.program, &quake_part.color);
GL_ResolveShaderParam (quake_part.program, &quake_part.texture); GLSL_ResolveShaderParam (quake_part.program, &quake_part.texture);
GL_ResolveShaderParam (quake_part.program, &quake_part.fog); GLSL_ResolveShaderParam (quake_part.program, &quake_part.fog);
memset (data, 0, sizeof (data)); memset (data, 0, sizeof (data));
qfglGenTextures (1, &part_tex); qfglGenTextures (1, &part_tex);

32
libs/video/renderer/glsl/glsl_sprite.c
View file

@ -97,22 +97,22 @@ R_InitSprites (void)
{ {
int frag, vert; int frag, vert;
vert = GL_CompileShader ("quakespr.vert", quakesprite_vert, vert = GLSL_CompileShader ("quakespr.vert", quakesprite_vert,
GL_VERTEX_SHADER); GL_VERTEX_SHADER);
frag = GL_CompileShader ("quakespr.frag", quakesprite_frag, frag = GLSL_CompileShader ("quakespr.frag", quakesprite_frag,
GL_FRAGMENT_SHADER); GL_FRAGMENT_SHADER);
quake_sprite.program = GL_LinkProgram ("quakespr", vert, frag); quake_sprite.program = GLSL_LinkProgram ("quakespr", vert, frag);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.spritea); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.spritea);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.spriteb); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.spriteb);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.palette); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.palette);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.matrix); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.matrix);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.vertexa); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.vertexa);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.vertexb); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.vertexb);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.colora); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.colora);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.colorb); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.colorb);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.uvab); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.uvab);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.blend); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.blend);
GL_ResolveShaderParam (quake_sprite.program, &quake_sprite.fog); GLSL_ResolveShaderParam (quake_sprite.program, &quake_sprite.fog);
} }
static void static void

41
libs/video/renderer/glsl/glsl_textures.c
View file

@ -66,7 +66,8 @@ static scrap_t *scrap_list;
static int max_tex_size; static int max_tex_size;
int int
GL_LoadQuakeTexture (const char *identifier, int width, int height, byte *data) GLSL_LoadQuakeTexture (const char *identifier, int width, int height,
byte *data)
{ {
GLuint tnum; GLuint tnum;
@ -84,7 +85,7 @@ GL_LoadQuakeTexture (const char *identifier, int width, int height, byte *data)
} }
static void static void
GL_Resample8BitTexture (unsigned char *in, int inwidth, int inheight, GLSL_Resample8BitTexture (unsigned char *in, int inwidth, int inheight,
unsigned char *out, int outwidth, int outheight) unsigned char *out, int outwidth, int outheight)
{ {
// Improvements here should be mirrored in build_skin_8 in gl_skin.c // Improvements here should be mirrored in build_skin_8 in gl_skin.c
@ -106,7 +107,7 @@ GL_Resample8BitTexture (unsigned char *in, int inwidth, int inheight,
} }
static void static void
GL_Mipmap8BitTexture (const byte *src, unsigned width, unsigned height, GLSL_Mipmap8BitTexture (const byte *src, unsigned width, unsigned height,
byte *mip) byte *mip)
{ {
unsigned mw = width >> 1; unsigned mw = width >> 1;
@ -124,7 +125,7 @@ GL_Mipmap8BitTexture (const byte *src, unsigned width, unsigned height,
} }
int int
GL_LoadQuakeMipTex (const texture_t *tex) GLSL_LoadQuakeMipTex (const texture_t *tex)
{ {
unsigned swidth, sheight; unsigned swidth, sheight;
GLuint tnum; GLuint tnum;
@ -164,7 +165,7 @@ GL_LoadQuakeMipTex (const texture_t *tex)
w = max (w >> lod, 1); w = max (w >> lod, 1);
h = max (h >> lod, 1); h = max (h >> lod, 1);
GL_Resample8BitTexture (data + tex->offsets[lod], w, h, GLSL_Resample8BitTexture (data + tex->offsets[lod], w, h,
buffer, swidth, sheight); buffer, swidth, sheight);
scaled = buffer; scaled = buffer;
} else { } else {
@ -179,7 +180,7 @@ GL_LoadQuakeMipTex (const texture_t *tex)
byte *mip = mipmap; byte *mip = mipmap;
while (swidth > 1 || sheight > 1) { while (swidth > 1 || sheight > 1) {
// scaled holds the source of the last lod uploaded // scaled holds the source of the last lod uploaded
GL_Mipmap8BitTexture (scaled, swidth, sheight, mip); GLSL_Mipmap8BitTexture (scaled, swidth, sheight, mip);
swidth >>= 1; swidth >>= 1;
sheight >>= 1; sheight >>= 1;
swidth = max (swidth, 1); swidth = max (swidth, 1);
@ -198,7 +199,7 @@ GL_LoadQuakeMipTex (const texture_t *tex)
} }
int int
GL_LoadRGBTexture (const char *identifier, int width, int height, byte *data) GLSL_LoadRGBTexture (const char *identifier, int width, int height, byte *data)
{ {
GLuint tnum; GLuint tnum;
@ -216,7 +217,7 @@ GL_LoadRGBTexture (const char *identifier, int width, int height, byte *data)
} }
void void
GL_ReleaseTexture (int tex) GLSL_ReleaseTexture (int tex)
{ {
GLuint tnum = tex; GLuint tnum = tex;
qfglDeleteTextures (1, &tnum); qfglDeleteTextures (1, &tnum);
@ -248,7 +249,7 @@ glsl_scraps_f (void)
} }
void void
GL_TextureInit (void) GLSL_TextureInit (void)
{ {
qfglGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_tex_size); qfglGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_tex_size);
Sys_MaskPrintf (SYS_GLSL, "max texture size: %d\n", max_tex_size); Sys_MaskPrintf (SYS_GLSL, "max texture size: %d\n", max_tex_size);
@ -257,7 +258,7 @@ GL_TextureInit (void)
} }
scrap_t * scrap_t *
GL_CreateScrap (int size, int format) GLSL_CreateScrap (int size, int format)
{ {
int i; int i;
int bpp; int bpp;
@ -314,7 +315,7 @@ GL_CreateScrap (int size, int format)
} }
void void
GL_ScrapClear (scrap_t *scrap) GLSL_ScrapClear (scrap_t *scrap)
{ {
vrect_t *t; vrect_t *t;
subpic_t *sp; subpic_t *sp;
@ -339,7 +340,7 @@ GL_ScrapClear (scrap_t *scrap)
} }
void void
GL_DestroyScrap (scrap_t *scrap) GLSL_DestroyScrap (scrap_t *scrap)
{ {
scrap_t **s; scrap_t **s;
@ -349,20 +350,20 @@ GL_DestroyScrap (scrap_t *scrap)
break; break;
} }
} }
GL_ScrapClear (scrap); GLSL_ScrapClear (scrap);
VRect_Delete (scrap->free_rects); VRect_Delete (scrap->free_rects);
GL_ReleaseTexture (scrap->tnum); GLSL_ReleaseTexture (scrap->tnum);
free (scrap); free (scrap);
} }
int int
GL_ScrapTexture (scrap_t *scrap) GLSL_ScrapTexture (scrap_t *scrap)
{ {
return scrap->tnum; return scrap->tnum;
} }
subpic_t * subpic_t *
GL_ScrapSubpic (scrap_t *scrap, int width, int height) GLSL_ScrapSubpic (scrap_t *scrap, int width, int height)
{ {
int i, w, h; int i, w, h;
vrect_t **t, **best; vrect_t **t, **best;
@ -419,7 +420,7 @@ GL_ScrapSubpic (scrap_t *scrap, int width, int height)
} }
void void
GL_SubpicDelete (subpic_t *subpic) GLSL_SubpicDelete (subpic_t *subpic)
{ {
scrap_t *scrap = (scrap_t *) subpic->scrap; scrap_t *scrap = (scrap_t *) subpic->scrap;
vrect_t *rect = (vrect_t *) subpic->rect; vrect_t *rect = (vrect_t *) subpic->rect;
@ -431,14 +432,14 @@ GL_SubpicDelete (subpic_t *subpic)
if (*sp == subpic) if (*sp == subpic)
break; break;
if (*sp != subpic) if (*sp != subpic)
Sys_Error ("GL_ScrapDelSubpic: broken subpic"); Sys_Error ("GLSL_ScrapDelSubpic: broken subpic");
*sp = (subpic_t *) subpic->next; *sp = (subpic_t *) subpic->next;
free (subpic); free (subpic);
for (t = &scrap->rects; *t; t = &(*t)->next) for (t = &scrap->rects; *t; t = &(*t)->next)
if (*t == rect) if (*t == rect)
break; break;
if (*t != rect) if (*t != rect)
Sys_Error ("GL_ScrapDelSubpic: broken subpic"); Sys_Error ("GLSL_ScrapDelSubpic: broken subpic");
*t = rect->next; *t = rect->next;
do { do {
@ -460,7 +461,7 @@ GL_SubpicDelete (subpic_t *subpic)
} }
void void
GL_SubpicUpdate (subpic_t *subpic, byte *data) GLSL_SubpicUpdate (subpic_t *subpic, byte *data)
{ {
scrap_t *scrap = (scrap_t *) subpic->scrap; scrap_t *scrap = (scrap_t *) subpic->scrap;
vrect_t *rect = (vrect_t *) subpic->rect; vrect_t *rect = (vrect_t *) subpic->rect;

14
libs/video/targets/vid_common_glsl.c
View file

@ -67,7 +67,7 @@ VISIBLE float gldepthmin, gldepthmax;
VISIBLE qboolean is8bit = false; VISIBLE qboolean is8bit = false;
static void static void
GL_Common_Init_Cvars (void) GLSL_Common_Init_Cvars (void)
{ {
} }
@ -152,9 +152,9 @@ GL_Init_Common (void)
{ {
GLF_FindFunctions (); GLF_FindFunctions ();
GL_Common_Init_Cvars (); GLSL_Common_Init_Cvars ();
GL_TextureInit (); GLSL_TextureInit ();
qfglClearColor (0, 0, 0, 0); qfglClearColor (0, 0, 0, 0);
@ -194,7 +194,7 @@ D_EndDirectRect (int x, int y, int width, int height)
} }
int int
GL_CompileShader (const char *name, const char *shader_src, int type) GLSL_CompileShader (const char *name, const char *shader_src, int type)
{ {
const char *src[1]; const char *src[1];
int shader; int shader;
@ -317,7 +317,7 @@ dump_program (const char *name, int program)
} }
int int
GL_LinkProgram (const char *name, int vert, int frag) GLSL_LinkProgram (const char *name, int vert, int frag)
{ {
int program; int program;
int linked; int linked;
@ -349,7 +349,7 @@ GL_LinkProgram (const char *name, int vert, int frag)
} }
int int
GL_ResolveShaderParam (int program, shaderparam_t *param) GLSL_ResolveShaderParam (int program, shaderparam_t *param)
{ {
if (param->uniform) { if (param->uniform) {
param->location = qfglGetUniformLocation (program, param->name); param->location = qfglGetUniformLocation (program, param->name);
@ -368,7 +368,7 @@ GL_ResolveShaderParam (int program, shaderparam_t *param)
} }
void void
GL_DumpAttribArrays (void) GLSL_DumpAttribArrays (void)
{ {
GLint max = 0; GLint max = 0;
GLint ind; GLint ind;