2001-02-19 21:15:25 +00:00
|
|
|
/*
|
|
|
|
gl_draw.c
|
|
|
|
|
|
|
|
Draw functions for chars, textures, etc
|
|
|
|
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to:
|
|
|
|
|
|
|
|
Free Software Foundation, Inc.
|
|
|
|
59 Temple Place - Suite 330
|
|
|
|
Boston, MA 02111-1307, USA
|
|
|
|
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
2003-01-15 15:31:36 +00:00
|
|
|
|
2001-05-09 05:41:34 +00:00
|
|
|
#ifdef HAVE_STRING_H
|
|
|
|
# include <string.h>
|
|
|
|
#endif
|
2001-02-19 21:15:25 +00:00
|
|
|
#ifdef HAVE_STRINGS_H
|
2001-05-09 05:41:34 +00:00
|
|
|
# include <strings.h>
|
2001-02-19 21:15:25 +00:00
|
|
|
#endif
|
|
|
|
|
2001-05-09 05:41:34 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
|
2001-03-27 20:33:07 +00:00
|
|
|
#include "QF/cmd.h"
|
2001-05-31 03:41:35 +00:00
|
|
|
#include "QF/cvar.h"
|
2001-05-09 22:40:51 +00:00
|
|
|
#include "QF/draw.h"
|
2003-05-16 19:44:25 +00:00
|
|
|
#include "QF/dstring.h"
|
2003-09-04 18:46:59 +00:00
|
|
|
#include "QF/image.h"
|
2002-08-27 07:16:28 +00:00
|
|
|
#include "QF/quakefs.h"
|
2001-05-23 04:05:10 +00:00
|
|
|
#include "QF/render.h"
|
2001-05-09 05:41:34 +00:00
|
|
|
#include "QF/screen.h"
|
|
|
|
#include "QF/sys.h"
|
|
|
|
#include "QF/va.h"
|
2001-09-01 08:57:04 +00:00
|
|
|
#include "QF/vid.h"
|
2001-06-24 09:25:55 +00:00
|
|
|
#include "QF/GL/defines.h"
|
|
|
|
#include "QF/GL/funcs.h"
|
2012-02-22 12:53:17 +00:00
|
|
|
#include "QF/GL/qf_draw.h"
|
2001-10-28 04:23:37 +00:00
|
|
|
#include "QF/GL/qf_rmain.h"
|
|
|
|
#include "QF/GL/qf_rsurf.h"
|
2001-09-01 08:57:04 +00:00
|
|
|
#include "QF/GL/qf_textures.h"
|
2001-06-24 09:25:55 +00:00
|
|
|
#include "QF/GL/qf_vid.h"
|
2001-09-01 08:57:04 +00:00
|
|
|
#include "QF/GL/types.h"
|
2022-12-07 06:11:08 +00:00
|
|
|
#include "QF/ui/font.h"
|
2021-07-10 09:04:34 +00:00
|
|
|
#include "QF/ui/view.h"
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2002-01-19 20:45:45 +00:00
|
|
|
#include "compat.h"
|
2012-02-14 08:28:09 +00:00
|
|
|
#include "r_internal.h"
|
2002-06-13 05:24:52 +00:00
|
|
|
#include "varrays.h"
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2010-12-11 03:09:30 +00:00
|
|
|
#define CELL_SIZE (1.0 / 16.0) // conchars is 16x16
|
|
|
|
#define CELL_INSET (1.0 / 4.0) // of a pixel
|
|
|
|
typedef struct {
|
|
|
|
float tlx, tly;
|
|
|
|
float trx, try;
|
|
|
|
float brx, bry;
|
|
|
|
float blx, bly;
|
|
|
|
} cc_cell_t;
|
|
|
|
|
2012-02-17 09:33:07 +00:00
|
|
|
static int textUseVA;
|
|
|
|
static int tVAsize;
|
|
|
|
static int *tVAindices;
|
|
|
|
static int tVAcount;
|
|
|
|
static float *textVertices, *tV;
|
|
|
|
static float *textCoords, *tC;
|
|
|
|
|
|
|
|
static qpic_t *draw_backtile;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2010-12-11 03:09:30 +00:00
|
|
|
static cc_cell_t char_cells[256];
|
2022-03-15 04:29:05 +00:00
|
|
|
static GLuint translate_texture;
|
2003-09-20 04:29:42 +00:00
|
|
|
static int char_texture;
|
|
|
|
static int cs_texture; // crosshair texturea
|
2022-05-10 15:27:55 +00:00
|
|
|
static int gl_conback_texnum;
|
|
|
|
static cvar_t gl_conback_texnum_cvar = {
|
|
|
|
.name = "gl_conback_texnum",
|
|
|
|
.description =
|
|
|
|
"bind conback to this texture for debugging",
|
|
|
|
.default_value = "0",
|
|
|
|
.flags = CVAR_NONE,
|
|
|
|
.value = { .type = &cexpr_int, .value = &gl_conback_texnum },
|
|
|
|
};
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-08-30 18:24:19 +00:00
|
|
|
static byte color_0_8[4] = { 204, 204, 204, 255 };
|
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
typedef struct {
|
2003-09-20 04:29:42 +00:00
|
|
|
int texnum;
|
2001-02-19 21:15:25 +00:00
|
|
|
} glpic_t;
|
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
typedef struct cachepic_s {
|
2003-09-20 04:29:42 +00:00
|
|
|
char name[MAX_QPATH];
|
|
|
|
qboolean dirty;
|
2022-03-30 17:56:14 +00:00
|
|
|
union {
|
|
|
|
qpic_t pic;
|
|
|
|
byte padding[sizeof (qpic_t) + 32];// for appended glpic FIXME
|
|
|
|
};
|
2001-02-19 21:15:25 +00:00
|
|
|
} cachepic_t;
|
|
|
|
|
|
|
|
#define MAX_CACHED_PICS 128
|
2001-02-26 06:48:02 +00:00
|
|
|
static cachepic_t cachepics[MAX_CACHED_PICS];
|
2003-09-20 04:29:42 +00:00
|
|
|
static int numcachepics;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2003-09-20 04:29:42 +00:00
|
|
|
static byte menuplyr_pixels[4096];
|
2001-09-01 08:57:04 +00:00
|
|
|
|
2022-11-13 13:23:56 +00:00
|
|
|
static int gl_2d_scale = 1;
|
2002-06-13 05:24:52 +00:00
|
|
|
|
2022-12-05 02:28:48 +00:00
|
|
|
typedef struct glfont_s {
|
2022-12-07 06:11:08 +00:00
|
|
|
font_t *font;
|
2022-12-05 02:28:48 +00:00
|
|
|
GLuint texid;
|
|
|
|
} glfont_t;
|
|
|
|
|
|
|
|
typedef struct glfontset_s
|
|
|
|
DARRAY_TYPE (glfont_t) glfontset_t;
|
|
|
|
|
|
|
|
static glfontset_t gl_fonts = DARRAY_STATIC_INIT (16);
|
|
|
|
|
2006-12-03 06:25:57 +00:00
|
|
|
static void
|
2002-06-13 05:24:52 +00:00
|
|
|
Draw_InitText (void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-12-16 11:09:05 +00:00
|
|
|
if (vaelements < 0) {
|
|
|
|
textUseVA = 0;
|
2006-12-03 06:25:57 +00:00
|
|
|
tVAsize = 2048;
|
2021-03-29 10:58:00 +00:00
|
|
|
Sys_MaskPrintf (SYS_dev, "Text: Vertex Array use disabled.\n");
|
2011-12-16 11:09:05 +00:00
|
|
|
} else {
|
|
|
|
textUseVA = 1;
|
|
|
|
if (vaelements > 3)
|
|
|
|
tVAsize = vaelements - (vaelements % 4);
|
2012-05-21 23:23:22 +00:00
|
|
|
else
|
2011-12-16 11:09:05 +00:00
|
|
|
tVAsize = 2048;
|
2021-03-29 10:58:00 +00:00
|
|
|
Sys_MaskPrintf (SYS_dev, "Text: %i maximum vertex elements.\n",
|
2010-11-23 05:09:30 +00:00
|
|
|
tVAsize);
|
2011-12-16 11:09:05 +00:00
|
|
|
}
|
2006-12-03 06:25:57 +00:00
|
|
|
|
2011-12-16 11:09:05 +00:00
|
|
|
if (textVertices)
|
|
|
|
free (textVertices);
|
|
|
|
textVertices = calloc (tVAsize, 2 * sizeof (float));
|
2006-12-03 06:25:57 +00:00
|
|
|
|
2011-12-16 11:09:05 +00:00
|
|
|
if (textCoords)
|
|
|
|
free (textCoords);
|
|
|
|
textCoords = calloc (tVAsize, 2 * sizeof (float));
|
2006-12-03 06:25:57 +00:00
|
|
|
|
2011-12-16 11:09:05 +00:00
|
|
|
if (textUseVA) {
|
2006-12-03 06:25:57 +00:00
|
|
|
qfglTexCoordPointer (2, GL_FLOAT, 0, textCoords);
|
|
|
|
qfglVertexPointer (2, GL_FLOAT, 0, textVertices);
|
2002-06-13 05:24:52 +00:00
|
|
|
}
|
2011-12-16 11:09:05 +00:00
|
|
|
if (tVAindices)
|
|
|
|
free (tVAindices);
|
|
|
|
tVAindices = (int *) calloc (tVAsize, sizeof (int));
|
|
|
|
for (i = 0; i < tVAsize; i++)
|
|
|
|
tVAindices[i] = i;
|
2002-06-13 05:24:52 +00:00
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
qpic_t *
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_MakePic (int width, int height, const byte *data)
|
2012-02-01 08:46:15 +00:00
|
|
|
{
|
|
|
|
glpic_t *gl;
|
|
|
|
qpic_t *pic;
|
|
|
|
|
|
|
|
pic = malloc (field_offset (qpic_t, data[sizeof (glpic_t)]));
|
|
|
|
pic->width = width;
|
|
|
|
pic->height = height;
|
|
|
|
gl = (glpic_t *) pic->data;
|
|
|
|
gl->texnum = GL_LoadTexture ("", width, height, data, false, true, 1);
|
|
|
|
return pic;
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_DestroyPic (qpic_t *pic)
|
2012-02-01 08:46:15 +00:00
|
|
|
{
|
|
|
|
//FIXME gl texture management sucks
|
|
|
|
free (pic);
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
qpic_t *
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_PicFromWad (const char *name)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2003-09-20 04:29:42 +00:00
|
|
|
glpic_t *gl;
|
2022-05-09 07:30:05 +00:00
|
|
|
qpic_t *p = 0, *pic;
|
2003-09-20 04:29:42 +00:00
|
|
|
tex_t *targa;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2007-05-13 01:29:29 +00:00
|
|
|
pic = W_GetLumpName (name);
|
2021-01-19 01:15:57 +00:00
|
|
|
targa = LoadImage (name, 1);
|
2003-09-04 18:46:59 +00:00
|
|
|
if (targa) {
|
2009-12-19 10:54:23 +00:00
|
|
|
p = malloc (sizeof (qpic_t) + sizeof (glpic_t));
|
2007-05-13 01:29:29 +00:00
|
|
|
p->width = pic->width;
|
|
|
|
p->height = pic->height;
|
2003-05-14 21:08:43 +00:00
|
|
|
gl = (glpic_t *) p->data;
|
2003-09-20 04:29:42 +00:00
|
|
|
if (targa->format < 4) {
|
|
|
|
gl->texnum = GL_LoadTexture (name, targa->width, targa->height,
|
|
|
|
targa->data, false, false, 3);
|
|
|
|
} else
|
|
|
|
gl->texnum = GL_LoadTexture (name, targa->width, targa->height,
|
|
|
|
targa->data, false, true, 4);
|
2022-05-09 07:30:05 +00:00
|
|
|
} else if (pic) {
|
2007-05-13 01:29:29 +00:00
|
|
|
p = pic;
|
2003-05-14 21:08:43 +00:00
|
|
|
gl = (glpic_t *) p->data;
|
2003-09-20 04:29:42 +00:00
|
|
|
gl->texnum = GL_LoadTexture (name, p->width, p->height, p->data,
|
|
|
|
false, true, 1);
|
2003-05-14 21:08:43 +00:00
|
|
|
}
|
2001-02-19 21:15:25 +00:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2007-03-24 10:13:10 +00:00
|
|
|
static void
|
2022-06-04 07:06:04 +00:00
|
|
|
Draw_ClearCache (int phase, void *data)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-02-26 06:48:02 +00:00
|
|
|
cachepic_t *pic;
|
|
|
|
int i;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2007-03-24 10:13:10 +00:00
|
|
|
if (phase)
|
|
|
|
return;
|
2001-02-26 06:48:02 +00:00
|
|
|
for (pic = cachepics, i = 0; i < numcachepics; pic++, i++)
|
2001-02-19 21:15:25 +00:00
|
|
|
pic->dirty = true;
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
qpic_t *
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_CachePic (const char *path, qboolean alpha)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-02-26 06:48:02 +00:00
|
|
|
cachepic_t *pic;
|
|
|
|
int i;
|
|
|
|
glpic_t *gl;
|
2002-01-16 01:59:05 +00:00
|
|
|
tex_t *targa;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-05-21 03:08:07 +00:00
|
|
|
// First, check if its cached..
|
2001-02-26 06:48:02 +00:00
|
|
|
for (pic = cachepics, i = 0; i < numcachepics; pic++, i++)
|
2001-02-19 21:15:25 +00:00
|
|
|
if ((!strcmp (path, pic->name)) && !pic->dirty)
|
|
|
|
return &pic->pic;
|
|
|
|
|
|
|
|
// Its not cached, lets make sure we have space in the cache..
|
|
|
|
if (numcachepics == MAX_CACHED_PICS)
|
|
|
|
Sys_Error ("menu_numcachepics == MAX_CACHED_PICS");
|
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
gl = (glpic_t *) pic->pic.data;
|
2002-01-16 01:59:05 +00:00
|
|
|
|
2007-05-13 01:29:29 +00:00
|
|
|
if (!strcmp (path + strlen (path) - 4, ".lmp")) {
|
2003-05-14 21:08:43 +00:00
|
|
|
// Load the picture..
|
2014-01-23 02:57:57 +00:00
|
|
|
qpic_t *dat = (qpic_t *) QFS_LoadFile (QFS_FOpenFile (path), 0);
|
2003-05-14 21:08:43 +00:00
|
|
|
if (!dat)
|
|
|
|
Sys_Error ("Draw_CachePic: failed to load %s", path);
|
|
|
|
|
|
|
|
// Adjust for endian..
|
|
|
|
SwapPic (dat);
|
2007-05-13 01:29:29 +00:00
|
|
|
// Check for a .tga first
|
2021-01-19 01:15:57 +00:00
|
|
|
targa = LoadImage (path, 1);
|
2007-05-13 01:29:29 +00:00
|
|
|
if (targa) {
|
|
|
|
if (targa->format < 4) {
|
|
|
|
gl->texnum = GL_LoadTexture ("", targa->width, targa->height,
|
|
|
|
targa->data, false, alpha, 3);
|
|
|
|
} else
|
|
|
|
gl->texnum = GL_LoadTexture ("", targa->width, targa->height,
|
|
|
|
targa->data, false, alpha, 4);
|
|
|
|
} else {
|
|
|
|
gl->texnum = GL_LoadTexture ("", dat->width, dat->height,
|
|
|
|
dat->data, false, alpha, 1);
|
|
|
|
}
|
2003-05-14 21:08:43 +00:00
|
|
|
pic->pic.width = dat->width;
|
|
|
|
pic->pic.height = dat->height;
|
2003-05-15 04:37:00 +00:00
|
|
|
if (!strcmp (path, "gfx/menuplyr.lmp"))
|
|
|
|
memcpy (menuplyr_pixels, dat->data, dat->width * dat->height);
|
2007-05-13 04:21:37 +00:00
|
|
|
free (dat);
|
2003-05-14 21:08:43 +00:00
|
|
|
} else
|
|
|
|
Sys_Error ("Draw_CachePic: failed to load %s", path);
|
|
|
|
|
2018-08-19 15:05:00 +00:00
|
|
|
memset (pic->name, 0, sizeof (pic->name));
|
|
|
|
strncpy (pic->name, path, sizeof (pic->name) - 1);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
|
|
|
// Now lets mark this cache entry as used..
|
|
|
|
pic->dirty = false;
|
|
|
|
numcachepics++;
|
|
|
|
|
|
|
|
// And now we are done, return what was asked for..
|
|
|
|
return &pic->pic;
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_UncachePic (const char *path)
|
2012-02-01 07:55:35 +00:00
|
|
|
{
|
|
|
|
cachepic_t *pic;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
//FIXME chachpic and uncachepic suck in GL
|
|
|
|
for (pic = cachepics, i = 0; i < numcachepics; pic++, i++) {
|
|
|
|
if ((!strcmp (path, pic->name)) && !pic->dirty) {
|
|
|
|
pic->dirty = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_TextBox (int x, int y, int width, int lines, byte alpha)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-09-01 08:57:04 +00:00
|
|
|
int cx, cy, n;
|
2001-05-09 05:41:34 +00:00
|
|
|
qpic_t *p;
|
|
|
|
|
|
|
|
// draw left side
|
2001-11-30 03:51:43 +00:00
|
|
|
color_white[3] = alpha;
|
|
|
|
qfglColor4ubv (color_white);
|
2001-05-09 05:41:34 +00:00
|
|
|
cx = x;
|
|
|
|
cy = y;
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_tl.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy, p);
|
|
|
|
p = gl_Draw_CachePic ("gfx/box_ml.lmp", true);
|
2001-05-09 05:41:34 +00:00
|
|
|
for (n = 0; n < lines; n++) {
|
|
|
|
cy += 8;
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Pic (cx, cy, p);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_bl.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy + 8, p);
|
2001-05-09 05:41:34 +00:00
|
|
|
|
|
|
|
// draw middle
|
|
|
|
cx += 8;
|
|
|
|
while (width > 0) {
|
|
|
|
cy = y;
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_tm.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy, p);
|
|
|
|
p = gl_Draw_CachePic ("gfx/box_mm.lmp", true);
|
2001-05-09 05:41:34 +00:00
|
|
|
for (n = 0; n < lines; n++) {
|
|
|
|
cy += 8;
|
|
|
|
if (n == 1)
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_mm2.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy, p);
|
2001-05-09 05:41:34 +00:00
|
|
|
}
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_bm.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy + 8, p);
|
2001-05-09 05:41:34 +00:00
|
|
|
width -= 2;
|
|
|
|
cx += 16;
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2001-05-09 05:41:34 +00:00
|
|
|
// draw right side
|
|
|
|
cy = y;
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_tr.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy, p);
|
|
|
|
p = gl_Draw_CachePic ("gfx/box_mr.lmp", true);
|
2001-05-09 05:41:34 +00:00
|
|
|
for (n = 0; n < lines; n++) {
|
|
|
|
cy += 8;
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Pic (cx, cy, p);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
2012-02-22 07:32:34 +00:00
|
|
|
p = gl_Draw_CachePic ("gfx/box_br.lmp", true);
|
|
|
|
gl_Draw_Pic (cx, cy + 8, p);
|
2001-11-30 03:51:43 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Init (void)
|
2001-05-09 05:41:34 +00:00
|
|
|
{
|
2004-02-03 03:01:06 +00:00
|
|
|
int i;
|
2003-09-19 06:22:02 +00:00
|
|
|
tex_t *image;
|
2010-12-11 03:09:30 +00:00
|
|
|
float width, height;
|
2011-12-26 12:43:15 +00:00
|
|
|
qpic_t *ch_pic;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-08-22 11:00:25 +00:00
|
|
|
Cmd_AddCommand ("gl_texturemode", &GL_TextureMode_f,
|
|
|
|
"Texture mipmap quality.");
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2022-06-04 07:06:04 +00:00
|
|
|
QFS_GamedirCallback (Draw_ClearCache, 0);
|
2004-02-03 03:01:06 +00:00
|
|
|
|
2001-08-22 11:00:25 +00:00
|
|
|
// load the console background and the charset by hand, because we need to
|
|
|
|
// write the version string into the background before turning it into a
|
|
|
|
// texture
|
2012-05-21 23:23:22 +00:00
|
|
|
|
2021-01-19 01:15:57 +00:00
|
|
|
image = LoadImage ("gfx/conchars", 1);
|
2012-05-21 23:23:22 +00:00
|
|
|
if (image) {
|
2003-09-20 04:29:42 +00:00
|
|
|
if (image->format < 4) {
|
|
|
|
char_texture = GL_LoadTexture ("charset", image->width,
|
|
|
|
image->height, image->data, false,
|
|
|
|
false, 3);
|
|
|
|
} else
|
|
|
|
char_texture = GL_LoadTexture ("charset", image->width,
|
|
|
|
image->height, image->data, false,
|
|
|
|
true, 4);
|
2010-12-11 03:09:30 +00:00
|
|
|
width = image->width;
|
|
|
|
height = image->height;
|
2022-05-09 07:30:05 +00:00
|
|
|
} else if ((draw_chars = W_GetLumpName ("conchars"))) {
|
|
|
|
for (i = 0; i < 256 * 64; i++) {
|
|
|
|
if (draw_chars[i] == 0) {
|
2003-09-19 06:22:02 +00:00
|
|
|
draw_chars[i] = 255; // proper transparent color
|
2022-05-09 07:30:05 +00:00
|
|
|
}
|
|
|
|
}
|
2012-05-21 23:23:22 +00:00
|
|
|
|
2003-09-20 04:29:42 +00:00
|
|
|
char_texture = GL_LoadTexture ("charset", 128, 128, draw_chars, false,
|
|
|
|
true, 1);
|
2010-12-11 03:09:30 +00:00
|
|
|
width = 128;
|
|
|
|
height = 128;
|
2022-05-09 07:30:05 +00:00
|
|
|
} else {
|
|
|
|
qpic_t *charspic = Draw_Font8x8Pic ();
|
|
|
|
char_texture = GL_LoadTexture ("charset", 128, 128, charspic->data,
|
|
|
|
false, true, 1);
|
|
|
|
width = 128;
|
|
|
|
height = 128;
|
2010-12-11 03:09:30 +00:00
|
|
|
}
|
2022-11-19 16:21:45 +00:00
|
|
|
qfglTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
|
qfglTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
2010-12-11 03:09:30 +00:00
|
|
|
|
|
|
|
// initialize the character cell texture coordinates.
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
|
|
float fcol, frow;
|
|
|
|
|
|
|
|
fcol = (i & 15) * CELL_SIZE;
|
|
|
|
frow = (i >> 4) * CELL_SIZE;
|
|
|
|
|
|
|
|
char_cells[i].tlx = fcol + CELL_INSET / width;
|
|
|
|
char_cells[i].tly = frow + CELL_INSET / height;
|
|
|
|
char_cells[i].trx = fcol - CELL_INSET / width + CELL_SIZE;
|
|
|
|
char_cells[i].try = frow + CELL_INSET / height;
|
|
|
|
char_cells[i].brx = fcol - CELL_INSET / width + CELL_SIZE;
|
|
|
|
char_cells[i].bry = frow - CELL_INSET / height + CELL_SIZE;
|
|
|
|
char_cells[i].blx = fcol + CELL_INSET / width;
|
|
|
|
char_cells[i].bly = frow - CELL_INSET / height + CELL_SIZE;
|
2003-09-19 06:22:02 +00:00
|
|
|
}
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2011-12-26 12:43:15 +00:00
|
|
|
ch_pic = Draw_CrosshairPic ();
|
|
|
|
cs_texture = GL_LoadTexture ("crosshair",
|
|
|
|
CROSSHAIR_WIDTH * CROSSHAIR_TILEX,
|
|
|
|
CROSSHAIR_HEIGHT * CROSSHAIR_TILEY,
|
|
|
|
ch_pic->data, false, true, 1);
|
|
|
|
free (ch_pic);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
|
qfglTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
|
|
|
// save a texture slot for translated picture
|
2022-03-15 04:29:05 +00:00
|
|
|
qfglGenTextures (1, &translate_texture);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
|
|
|
// get the other pics we need
|
2012-02-22 07:32:34 +00:00
|
|
|
draw_backtile = gl_Draw_PicFromWad ("backtile");
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2006-12-03 06:25:57 +00:00
|
|
|
Draw_InitText ();
|
2022-05-10 15:27:55 +00:00
|
|
|
|
|
|
|
Cvar_Register (&gl_conback_texnum_cvar, 0, 0);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2002-06-18 04:13:46 +00:00
|
|
|
static inline void
|
|
|
|
flush_text (void)
|
|
|
|
{
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, char_texture);
|
2011-12-16 11:09:05 +00:00
|
|
|
if (textUseVA) {
|
|
|
|
qfglDrawElements (GL_QUADS, tVAcount, GL_UNSIGNED_INT, tVAindices);
|
|
|
|
} else {
|
|
|
|
float *v = textVertices;
|
|
|
|
float *c = textCoords;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
for (i = 0; i < tVAcount; i++) {
|
|
|
|
qfglTexCoord2fv (c);
|
|
|
|
qfglVertex2fv (v);
|
|
|
|
c += 2;
|
|
|
|
v += 2;
|
|
|
|
}
|
|
|
|
qfglEnd ();
|
|
|
|
}
|
2002-06-18 04:13:46 +00:00
|
|
|
tVAcount = 0;
|
|
|
|
tV = textVertices;
|
|
|
|
tC = textCoords;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2006-12-03 06:25:57 +00:00
|
|
|
queue_character (float x, float y, int chr)
|
2002-06-18 04:13:46 +00:00
|
|
|
{
|
2010-12-11 03:09:30 +00:00
|
|
|
float *coord = &char_cells[chr & 255].tlx;
|
2003-03-24 20:21:24 +00:00
|
|
|
*tV++ = x;
|
|
|
|
*tV++ = y;
|
|
|
|
*tV++ = x + 8.0;
|
|
|
|
*tV++ = y;
|
|
|
|
*tV++ = x + 8.0;
|
|
|
|
*tV++ = y + 8.0;
|
|
|
|
*tV++ = x;
|
|
|
|
*tV++ = y + 8.0;
|
2010-12-11 03:09:30 +00:00
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
|
|
|
*tC++ = *coord++;
|
2002-06-28 17:47:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
tVA_increment (void)
|
|
|
|
{
|
2003-09-20 04:29:42 +00:00
|
|
|
tVAcount += 4;
|
2002-06-18 04:13:46 +00:00
|
|
|
if (tVAcount + 4 > tVAsize)
|
|
|
|
flush_text ();
|
|
|
|
}
|
|
|
|
|
2022-09-15 05:24:33 +00:00
|
|
|
void
|
|
|
|
gl_Draw_CharBuffer (int x, int y, draw_charbuffer_t *buffer)
|
|
|
|
{
|
|
|
|
const byte *line = (byte *) buffer->chars;
|
|
|
|
int width = buffer->width;
|
|
|
|
int height = buffer->height;
|
|
|
|
while (height-- > 0) {
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
gl_Draw_Character (x + i * 8, y, line[i]);
|
|
|
|
}
|
|
|
|
line += width;
|
|
|
|
y += 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-19 21:15:25 +00:00
|
|
|
/*
|
2001-08-25 02:47:11 +00:00
|
|
|
Draw_Character
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-05-09 05:41:34 +00:00
|
|
|
Draws one 8*8 graphics character with 0 being transparent.
|
|
|
|
It can be clipped to the top of the screen to allow the console to be
|
|
|
|
smoothly scrolled off.
|
2001-02-19 21:15:25 +00:00
|
|
|
*/
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Character (int x, int y, unsigned int chr)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2006-12-03 06:25:57 +00:00
|
|
|
chr &= 255;
|
|
|
|
|
|
|
|
if (chr == 32)
|
2001-02-26 06:48:02 +00:00
|
|
|
return; // space
|
2001-02-19 21:15:25 +00:00
|
|
|
if (y <= -8)
|
2001-02-26 06:48:02 +00:00
|
|
|
return; // totally off screen
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2006-12-03 06:25:57 +00:00
|
|
|
queue_character ((float) x, (float) y, chr);
|
2002-06-28 17:47:26 +00:00
|
|
|
tVA_increment ();
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_String (int x, int y, const char *str)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2006-12-03 06:25:57 +00:00
|
|
|
unsigned char chr;
|
2003-03-24 20:21:24 +00:00
|
|
|
float x1, y1;
|
2001-10-05 19:01:57 +00:00
|
|
|
|
|
|
|
if (!str || !str[0])
|
|
|
|
return;
|
|
|
|
if (y <= -8)
|
|
|
|
return; // totally off screen
|
|
|
|
|
2003-03-24 20:21:24 +00:00
|
|
|
x1 = (float) x;
|
|
|
|
y1 = (float) y;
|
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
while (*str) {
|
2006-12-03 06:25:57 +00:00
|
|
|
if ((chr = *str++) != 32) { // Don't render spaces
|
|
|
|
queue_character (x1, y1, chr);
|
2002-06-28 17:47:26 +00:00
|
|
|
tVA_increment ();
|
2001-10-05 19:01:57 +00:00
|
|
|
}
|
2003-03-24 20:21:24 +00:00
|
|
|
x1 += 8.0;
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_nString (int x, int y, const char *str, int count)
|
2002-01-09 21:20:22 +00:00
|
|
|
{
|
2006-12-03 06:25:57 +00:00
|
|
|
unsigned char chr;
|
2003-03-24 20:21:24 +00:00
|
|
|
float x1, y1;
|
2002-06-28 17:47:26 +00:00
|
|
|
|
2002-01-09 21:20:22 +00:00
|
|
|
if (!str || !str[0])
|
|
|
|
return;
|
|
|
|
if (y <= -8)
|
|
|
|
return; // totally off screen
|
|
|
|
|
2003-03-24 20:21:24 +00:00
|
|
|
x1 = (float) x;
|
|
|
|
y1 = (float) y;
|
|
|
|
|
2002-01-10 03:54:00 +00:00
|
|
|
while (count-- && *str) {
|
2006-12-03 06:25:57 +00:00
|
|
|
if ((chr = *str++) != 32) { // Don't render spaces
|
|
|
|
queue_character (x1, y1, chr);
|
2002-06-28 17:47:26 +00:00
|
|
|
tVA_increment ();
|
2002-01-09 21:20:22 +00:00
|
|
|
}
|
2003-03-24 20:21:24 +00:00
|
|
|
x1 += 8.0;
|
2002-01-09 21:20:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_AltString (int x, int y, const char *str)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2006-12-03 06:25:57 +00:00
|
|
|
unsigned char chr;
|
2003-03-24 20:21:24 +00:00
|
|
|
float x1, y1;
|
2001-10-05 19:01:57 +00:00
|
|
|
|
|
|
|
if (!str || !str[0])
|
|
|
|
return;
|
|
|
|
if (y <= -8)
|
|
|
|
return; // totally off screen
|
|
|
|
|
2003-03-24 20:21:24 +00:00
|
|
|
x1 = (float) x;
|
|
|
|
y1 = (float) y;
|
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
while (*str) {
|
2006-12-03 06:25:57 +00:00
|
|
|
if ((chr = *str++ | 0x80) != (0x80 | 32)) { // Don't render spaces
|
|
|
|
queue_character (x1, y1, chr);
|
2002-06-28 17:47:26 +00:00
|
|
|
tVA_increment ();
|
2001-10-05 19:01:57 +00:00
|
|
|
}
|
2003-03-24 20:21:24 +00:00
|
|
|
x1 += 8.0;
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-13 22:16:53 +00:00
|
|
|
static void
|
|
|
|
crosshair_1 (int x, int y)
|
|
|
|
{
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Character (x - 4, y - 4, '+');
|
2004-02-13 22:16:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
crosshair_2 (int x, int y)
|
|
|
|
{
|
|
|
|
unsigned char *pColor;
|
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
pColor = (unsigned char *) &d_8to24table[crosshaircolor];
|
2004-02-13 22:16:53 +00:00
|
|
|
qfglColor4ubv (pColor);
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, cs_texture);
|
|
|
|
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
|
|
|
|
qfglTexCoord2f (0, 0);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y - 3);
|
2004-02-14 00:18:22 +00:00
|
|
|
qfglTexCoord2f (0.5, 0);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y - 3);
|
2004-02-14 00:18:22 +00:00
|
|
|
qfglTexCoord2f (0.5, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y + 5);
|
2004-02-13 22:16:53 +00:00
|
|
|
qfglTexCoord2f (0, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y + 5);
|
2004-02-13 22:16:53 +00:00
|
|
|
|
|
|
|
qfglEnd ();
|
|
|
|
qfglColor3ubv (color_white);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
crosshair_3 (int x, int y)
|
|
|
|
{
|
|
|
|
unsigned char *pColor;
|
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
pColor = (unsigned char *) &d_8to24table[crosshaircolor];
|
2004-02-13 22:16:53 +00:00
|
|
|
qfglColor4ubv (pColor);
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, cs_texture);
|
|
|
|
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
|
2004-02-14 00:18:22 +00:00
|
|
|
qfglTexCoord2f (0.5, 0);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y - 3);
|
2004-02-14 00:18:22 +00:00
|
|
|
qfglTexCoord2f (1, 0);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y - 3);
|
2004-02-13 22:16:53 +00:00
|
|
|
qfglTexCoord2f (1, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y + 5);
|
2004-02-14 00:18:22 +00:00
|
|
|
qfglTexCoord2f (0.5, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y + 5);
|
2004-02-13 22:16:53 +00:00
|
|
|
|
|
|
|
qfglEnd ();
|
|
|
|
qfglColor3ubv (color_white);
|
|
|
|
}
|
|
|
|
|
2010-11-26 00:22:04 +00:00
|
|
|
static void
|
|
|
|
crosshair_4 (int x, int y)
|
|
|
|
{
|
|
|
|
unsigned char *pColor;
|
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
pColor = (unsigned char *) &d_8to24table[crosshaircolor];
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglColor4ubv (pColor);
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, cs_texture);
|
|
|
|
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
|
|
|
|
qfglTexCoord2f (0, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y - 3);
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglTexCoord2f (0.5, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y - 5);
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglTexCoord2f (0.5, 1);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y + 5);
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglTexCoord2f (0, 1);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y + 5);
|
2010-11-26 00:22:04 +00:00
|
|
|
|
|
|
|
qfglEnd ();
|
|
|
|
qfglColor3ubv (color_white);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
crosshair_5 (int x, int y) //FIXME don't use until the data is filled in
|
|
|
|
{
|
|
|
|
unsigned char *pColor;
|
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
pColor = (unsigned char *) &d_8to24table[crosshaircolor];
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglColor4ubv (pColor);
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, cs_texture);
|
|
|
|
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
|
|
|
|
qfglTexCoord2f (0.5, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y - 3);
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglTexCoord2f (1, 0.5);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y - 3);
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglTexCoord2f (1, 1);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x + 5, y + 5);
|
2010-11-26 00:22:04 +00:00
|
|
|
qfglTexCoord2f (0.5, 1);
|
2022-11-19 15:50:59 +00:00
|
|
|
qfglVertex2f (x - 3, y + 5);
|
2010-11-26 00:22:04 +00:00
|
|
|
|
|
|
|
qfglEnd ();
|
|
|
|
qfglColor3ubv (color_white);
|
|
|
|
}
|
|
|
|
|
2004-02-13 23:16:33 +00:00
|
|
|
static void (*crosshair_func[]) (int x, int y) = {
|
|
|
|
crosshair_1,
|
|
|
|
crosshair_2,
|
|
|
|
crosshair_3,
|
2010-11-26 00:22:04 +00:00
|
|
|
crosshair_4,
|
|
|
|
crosshair_5,
|
2004-02-13 23:16:33 +00:00
|
|
|
};
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Crosshair (void)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-09-01 08:57:04 +00:00
|
|
|
int x, y;
|
2004-02-13 23:16:33 +00:00
|
|
|
int ch;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
ch = crosshair - 1;
|
2004-02-13 23:16:33 +00:00
|
|
|
if ((unsigned) ch >= sizeof (crosshair_func) / sizeof (crosshair_func[0]))
|
2004-02-13 22:16:53 +00:00
|
|
|
return;
|
|
|
|
|
2022-11-18 02:23:32 +00:00
|
|
|
int s = 2 * gl_2d_scale;
|
|
|
|
x = vid.width / s + cl_crossx;
|
|
|
|
y = vid.height / s + cl_crossy;
|
2004-02-13 22:16:53 +00:00
|
|
|
|
2004-02-13 23:16:33 +00:00
|
|
|
crosshair_func[ch] (x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_CrosshairAt (int ch, int x, int y)
|
2004-02-13 23:16:33 +00:00
|
|
|
{
|
|
|
|
ch -= 1;
|
|
|
|
if ((unsigned) ch >= sizeof (crosshair_func) / sizeof (crosshair_func[0]))
|
|
|
|
return;
|
|
|
|
|
|
|
|
crosshair_func[ch] (x, y);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Pic (int x, int y, qpic_t *pic)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-02-26 06:48:02 +00:00
|
|
|
glpic_t *gl;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
gl = (glpic_t *) pic->data;
|
2001-05-09 05:41:34 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl->texnum);
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
qfglTexCoord2f (0, 0);
|
|
|
|
qfglVertex2f (x, y);
|
|
|
|
qfglTexCoord2f (1, 0);
|
|
|
|
qfglVertex2f (x + pic->width, y);
|
|
|
|
qfglTexCoord2f (1, 1);
|
|
|
|
qfglVertex2f (x + pic->width, y + pic->height);
|
|
|
|
qfglTexCoord2f (0, 1);
|
|
|
|
qfglVertex2f (x, y + pic->height);
|
|
|
|
qfglEnd ();
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Picf (float x, float y, qpic_t *pic)
|
2012-02-06 10:32:30 +00:00
|
|
|
{
|
|
|
|
glpic_t *gl;
|
|
|
|
|
|
|
|
gl = (glpic_t *) pic->data;
|
|
|
|
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl->texnum);
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
qfglTexCoord2f (0, 0);
|
|
|
|
qfglVertex2f (x, y);
|
|
|
|
qfglTexCoord2f (1, 0);
|
|
|
|
qfglVertex2f (x + pic->width, y);
|
|
|
|
qfglTexCoord2f (1, 1);
|
|
|
|
qfglVertex2f (x + pic->width, y + pic->height);
|
|
|
|
qfglTexCoord2f (0, 1);
|
|
|
|
qfglVertex2f (x, y + pic->height);
|
|
|
|
qfglEnd ();
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_SubPic (int x, int y, qpic_t *pic, int srcx, int srcy, int width,
|
2001-02-26 06:48:02 +00:00
|
|
|
int height)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-02-26 06:48:02 +00:00
|
|
|
float newsl, newtl, newsh, newth;
|
2001-09-01 08:57:04 +00:00
|
|
|
glpic_t *gl;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-02-26 06:48:02 +00:00
|
|
|
gl = (glpic_t *) pic->data;
|
|
|
|
|
2001-06-02 20:39:54 +00:00
|
|
|
newsl = (float) srcx / (float) pic->width;
|
|
|
|
newsh = newsl + (float) width / (float) pic->width;
|
2001-02-26 06:48:02 +00:00
|
|
|
|
2001-06-02 20:39:54 +00:00
|
|
|
newtl = (float) srcy / (float) pic->height;
|
|
|
|
newth = newtl + (float) height / (float) pic->height;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_0_8);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl->texnum);
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
qfglTexCoord2f (newsl, newtl);
|
|
|
|
qfglVertex2f (x, y);
|
|
|
|
qfglTexCoord2f (newsh, newtl);
|
|
|
|
qfglVertex2f (x + width, y);
|
|
|
|
qfglTexCoord2f (newsh, newth);
|
|
|
|
qfglVertex2f (x + width, y + height);
|
|
|
|
qfglTexCoord2f (newsl, newth);
|
|
|
|
qfglVertex2f (x, y + height);
|
|
|
|
qfglEnd ();
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Draw_ConsoleBackground
|
|
|
|
|
|
|
|
Draws console background (obviously!) Completely rewritten to use
|
|
|
|
several simple yet very cool GL effects. --KB
|
|
|
|
*/
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_ConsoleBackground (int lines, byte alpha)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-09-01 08:57:04 +00:00
|
|
|
float ofs;
|
2001-02-26 06:48:02 +00:00
|
|
|
glpic_t *gl;
|
2001-09-01 08:57:04 +00:00
|
|
|
qpic_t *conback;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2002-06-13 05:24:52 +00:00
|
|
|
GL_FlushText (); // Flush text that should be rendered before the console
|
|
|
|
|
2001-02-19 21:15:25 +00:00
|
|
|
// This can be a CachePic now, just like in software
|
2012-02-22 07:32:34 +00:00
|
|
|
conback = gl_Draw_CachePic ("gfx/conback.lmp", false);
|
2001-02-26 06:48:02 +00:00
|
|
|
gl = (glpic_t *) conback->data;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
|
|
|
// spin the console? - effect described in a QER tutorial
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
if (gl_conspin) {
|
2001-02-19 21:15:25 +00:00
|
|
|
static float xangle = 0;
|
|
|
|
static float xfactor = .3f;
|
|
|
|
static float xstep = .005f;
|
2001-02-26 06:48:02 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglPushMatrix ();
|
|
|
|
qfglMatrixMode (GL_TEXTURE);
|
|
|
|
qfglPushMatrix ();
|
|
|
|
qfglLoadIdentity ();
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
xangle += gl_conspin;
|
2001-02-19 21:15:25 +00:00
|
|
|
xfactor += xstep;
|
|
|
|
if (xfactor > 8 || xfactor < .3f)
|
|
|
|
xstep = -xstep;
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglRotatef (xangle, 0, 0, 1);
|
|
|
|
qfglScalef (xfactor, xfactor, xfactor);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
// slide console up/down or stretch it?
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
if (gl_constretch) {
|
2001-02-19 21:15:25 +00:00
|
|
|
ofs = 0;
|
2003-09-20 04:29:42 +00:00
|
|
|
} else
|
2022-11-13 13:23:56 +00:00
|
|
|
ofs = (vid.height - gl_2d_scale * lines) / (float) vid.height;
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-08-30 18:24:19 +00:00
|
|
|
color_0_8[3] = alpha;
|
|
|
|
qfglColor4ubv (color_0_8);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
|
|
|
// draw the console texture
|
2022-05-10 15:27:55 +00:00
|
|
|
if (gl_conback_texnum) {
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl_conback_texnum);
|
|
|
|
} else {
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl->texnum);
|
|
|
|
}
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
qfglTexCoord2f (0, 0 + ofs);
|
|
|
|
qfglVertex2f (0, 0);
|
|
|
|
qfglTexCoord2f (1, 0 + ofs);
|
2022-11-13 13:23:56 +00:00
|
|
|
qfglVertex2f (vid.width / gl_2d_scale, 0);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglTexCoord2f (1, 1);
|
2022-11-13 13:23:56 +00:00
|
|
|
qfglVertex2f (vid.width / gl_2d_scale, lines);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglTexCoord2f (0, 1);
|
|
|
|
qfglVertex2f (0, lines);
|
|
|
|
qfglEnd ();
|
2001-02-19 21:15:25 +00:00
|
|
|
|
|
|
|
// turn off alpha blending
|
2001-08-30 18:24:19 +00:00
|
|
|
if (alpha < 255) {
|
|
|
|
qfglColor3ubv (color_0_8);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
if (gl_conspin) {
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglPopMatrix ();
|
|
|
|
qfglMatrixMode (GL_MODELVIEW);
|
|
|
|
qfglPopMatrix ();
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
2001-05-11 01:01:27 +00:00
|
|
|
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
int len = strlen (cl_verstring);
|
2022-09-21 08:31:18 +00:00
|
|
|
gl_Draw_AltString (vid.width - len * 8 - 11, lines - 14,
|
[cvar] Make cvars properly typed
This is an extremely extensive patch as it hits every cvar, and every
usage of the cvars. Cvars no longer store the value they control,
instead, they use a cexpr value object to reference the value and
specify the value's type (currently, a null type is used for strings).
Non-string cvars are passed through cexpr, allowing expressions in the
cvars' settings. Also, cvars have returned to an enhanced version of the
original (id quake) registration scheme.
As a minor benefit, relevant code having direct access to the
cvar-controlled variables is probably a slight optimization as it
removed a pointer dereference, and the variables can be located for data
locality.
The static cvar descriptors are made private as an additional safety
layer, though there's nothing stopping external modification via
Cvar_FindVar (which is needed for adding listeners).
While not used yet (partly due to working out the design), cvars can
have a validation function.
Registering a cvar allows a primary listener (and its data) to be
specified: it will always be called first when the cvar is modified. The
combination of proper listeners and direct access to the controlled
variable greatly simplifies the more complex cvar interactions as much
less null checking is required, and there's no need for one cvar's
callback to call another's.
nq-x11 is known to work at least well enough for the demos. More testing
will come.
2022-04-23 03:22:45 +00:00
|
|
|
cl_verstring);
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-05-09 05:41:34 +00:00
|
|
|
Draw_TileClear
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-05-09 05:41:34 +00:00
|
|
|
This repeats a 64*64 tile graphic to fill the screen around a sized down
|
|
|
|
refresh window.
|
2001-02-19 21:15:25 +00:00
|
|
|
*/
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_TileClear (int x, int y, int w, int h)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2022-09-22 01:33:32 +00:00
|
|
|
if (!draw_backtile) {
|
|
|
|
return;
|
|
|
|
}
|
2009-12-19 10:54:23 +00:00
|
|
|
glpic_t *gl;
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_0_8);
|
2009-12-19 10:54:23 +00:00
|
|
|
gl = (glpic_t *) draw_backtile->data;
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl->texnum);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
qfglTexCoord2f (x / 64.0, y / 64.0);
|
|
|
|
qfglVertex2f (x, y);
|
|
|
|
qfglTexCoord2f ((x + w) / 64.0, y / 64.0);
|
|
|
|
qfglVertex2f (x + w, y);
|
|
|
|
qfglTexCoord2f ((x + w) / 64.0, (y + h) / 64.0);
|
|
|
|
qfglVertex2f (x + w, y + h);
|
|
|
|
qfglTexCoord2f (x / 64.0, (y + h) / 64.0);
|
|
|
|
qfglVertex2f (x, y + h);
|
|
|
|
qfglEnd ();
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-05-09 05:41:34 +00:00
|
|
|
Draw_Fill
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-05-09 05:41:34 +00:00
|
|
|
Fills a box of pixels with a single color
|
2001-02-19 21:15:25 +00:00
|
|
|
*/
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_Fill (int x, int y, int w, int h, int c)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglDisable (GL_TEXTURE_2D);
|
2002-09-10 03:51:10 +00:00
|
|
|
qfglColor3ubv (vid.palette + c * 3);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglBegin (GL_QUADS);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglVertex2f (x, y);
|
|
|
|
qfglVertex2f (x + w, y);
|
|
|
|
qfglVertex2f (x + w, y + h);
|
|
|
|
qfglVertex2f (x, y + h);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglEnd ();
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglEnable (GL_TEXTURE_2D);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
2001-05-09 05:41:34 +00:00
|
|
|
|
2022-05-28 09:14:26 +00:00
|
|
|
void
|
|
|
|
gl_Draw_Line (int x0, int y0, int x1, int y1, int c)
|
|
|
|
{
|
|
|
|
qfglDisable (GL_TEXTURE_2D);
|
|
|
|
qfglColor3ubv (vid.palette + c * 3);
|
|
|
|
|
|
|
|
qfglBegin (GL_LINES);
|
|
|
|
|
|
|
|
qfglVertex2f (x0, y0);
|
|
|
|
qfglVertex2f (x1, y1);
|
|
|
|
|
|
|
|
qfglEnd ();
|
|
|
|
qfglColor3ubv (color_white);
|
|
|
|
qfglEnable (GL_TEXTURE_2D);
|
|
|
|
}
|
|
|
|
|
2012-02-18 13:28:42 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_FadeScreen (void)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2002-06-13 22:51:43 +00:00
|
|
|
GL_FlushText (); // Flush text that should be rendered before the menu
|
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglDisable (GL_TEXTURE_2D);
|
2001-09-14 12:11:54 +00:00
|
|
|
qfglColor4ub (0, 0, 0, 179);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglBegin (GL_QUADS);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglVertex2f (0, 0);
|
2022-09-21 08:31:18 +00:00
|
|
|
qfglVertex2f (vid.width, 0);
|
|
|
|
qfglVertex2f (vid.width, vid.height);
|
|
|
|
qfglVertex2f (0, vid.height);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglEnd ();
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglEnable (GL_TEXTURE_2D);
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
|
|
|
|
2009-12-23 06:29:11 +00:00
|
|
|
static void
|
|
|
|
set_2d (int width, int height)
|
2001-02-19 21:15:25 +00:00
|
|
|
{
|
2009-12-23 08:20:29 +00:00
|
|
|
qfglViewport (0, 0, vid.width, vid.height);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglMatrixMode (GL_PROJECTION);
|
|
|
|
qfglLoadIdentity ();
|
2022-11-19 16:17:09 +00:00
|
|
|
qfglOrtho (0, width, height, 0, -99999, 99999);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglMatrixMode (GL_MODELVIEW);
|
|
|
|
qfglLoadIdentity ();
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-06-26 02:26:46 +00:00
|
|
|
qfglDisable (GL_DEPTH_TEST);
|
|
|
|
qfglDisable (GL_CULL_FACE);
|
2001-02-19 21:15:25 +00:00
|
|
|
|
2001-08-30 18:24:19 +00:00
|
|
|
qfglColor3ubv (color_white);
|
2002-06-13 05:24:52 +00:00
|
|
|
|
|
|
|
qfglEnableClientState (GL_VERTEX_ARRAY);
|
|
|
|
qfglVertexPointer (2, GL_FLOAT, 0, textVertices);
|
|
|
|
qfglEnableClientState (GL_TEXTURE_COORD_ARRAY);
|
|
|
|
qfglTexCoordPointer (2, GL_FLOAT, 0, textCoords);
|
|
|
|
qfglDisableClientState (GL_COLOR_ARRAY);
|
2004-05-07 03:54:35 +00:00
|
|
|
}
|
|
|
|
|
2009-12-23 06:29:11 +00:00
|
|
|
void
|
|
|
|
GL_Set2D (void)
|
|
|
|
{
|
|
|
|
set_2d (vid.width, vid.height);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GL_Set2DScaled (void)
|
|
|
|
{
|
2022-11-13 13:23:56 +00:00
|
|
|
set_2d (vid.width / gl_2d_scale, vid.height / gl_2d_scale);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gl_Draw_SetScale (int scale)
|
|
|
|
{
|
|
|
|
gl_2d_scale = scale;
|
2009-12-23 06:29:11 +00:00
|
|
|
}
|
|
|
|
|
2004-05-07 03:54:35 +00:00
|
|
|
void
|
|
|
|
GL_DrawReset (void)
|
|
|
|
{
|
2002-06-13 05:24:52 +00:00
|
|
|
tVAcount = 0;
|
|
|
|
tV = textVertices;
|
|
|
|
tC = textCoords;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GL_FlushText (void)
|
|
|
|
{
|
|
|
|
if (tVAcount) {
|
2002-06-18 04:13:46 +00:00
|
|
|
flush_text ();
|
2002-06-13 05:24:52 +00:00
|
|
|
}
|
2001-02-19 21:15:25 +00:00
|
|
|
}
|
2012-01-28 11:45:14 +00:00
|
|
|
|
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
gl_Draw_BlendScreen (quat_t color)
|
2012-01-28 11:45:14 +00:00
|
|
|
{
|
|
|
|
if (!color[3])
|
|
|
|
return;
|
|
|
|
|
|
|
|
qfglDisable (GL_TEXTURE_2D);
|
|
|
|
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
|
|
|
|
qfglColor4fv (color);
|
|
|
|
qfglVertex2f (0, 0);
|
2022-09-21 08:31:18 +00:00
|
|
|
qfglVertex2f (vid.width, 0);
|
|
|
|
qfglVertex2f (vid.width, vid.height);
|
|
|
|
qfglVertex2f (0, vid.height);
|
2012-01-28 11:45:14 +00:00
|
|
|
|
|
|
|
qfglEnd ();
|
|
|
|
|
|
|
|
qfglColor3ubv (color_white);
|
|
|
|
qfglEnable (GL_TEXTURE_2D);
|
|
|
|
}
|
2022-08-31 10:23:30 +00:00
|
|
|
|
2022-10-02 23:58:27 +00:00
|
|
|
int
|
2022-12-07 06:11:08 +00:00
|
|
|
gl_Draw_AddFont (font_t *rfont)
|
2022-08-31 10:23:30 +00:00
|
|
|
{
|
2022-12-05 02:28:48 +00:00
|
|
|
int fontid = gl_fonts.size;
|
|
|
|
DARRAY_OPEN_AT (&gl_fonts, fontid, 1);
|
|
|
|
glfont_t *font = &gl_fonts.a[fontid];
|
|
|
|
|
|
|
|
font->font = rfont;
|
2022-12-05 04:35:44 +00:00
|
|
|
tex_t tex = {
|
|
|
|
.width = rfont->scrap.width,
|
|
|
|
.height = rfont->scrap.height,
|
|
|
|
.format = tex_a,
|
|
|
|
.loaded = 1,
|
|
|
|
.data = rfont->scrap_bitmap,
|
|
|
|
};
|
|
|
|
font->texid = GL_LoadTex ("", 0, &tex);
|
2022-12-05 02:28:48 +00:00
|
|
|
return fontid;
|
|
|
|
}
|
|
|
|
|
2022-12-10 09:55:08 +00:00
|
|
|
void
|
|
|
|
gl_Draw_Glyph (int x, int y, int fontid, int glyphid, int c)
|
2022-12-05 02:28:48 +00:00
|
|
|
{
|
2022-12-10 09:55:08 +00:00
|
|
|
if (fontid < 0 || (unsigned) fontid > gl_fonts.size) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
glfont_t *font = &gl_fonts.a[fontid];
|
2022-12-07 06:11:08 +00:00
|
|
|
font_t *rfont = font->font;
|
2022-12-05 02:28:48 +00:00
|
|
|
vrect_t *rect = &rfont->glyph_rects[glyphid];
|
|
|
|
|
|
|
|
float w = rect->width;
|
|
|
|
float h = rect->height;
|
|
|
|
float u = rect->x;
|
|
|
|
float v = rect->y;
|
|
|
|
float s = 1.0 / rfont->scrap.width;
|
|
|
|
float t = 1.0 / rfont->scrap.height;
|
2022-12-10 09:55:08 +00:00
|
|
|
|
|
|
|
qfglBindTexture (GL_TEXTURE_2D, gl_fonts.a[fontid].texid);
|
|
|
|
qfglBegin (GL_QUADS);
|
|
|
|
|
|
|
|
byte color[4] = { VectorExpand (vid.palette + c * 3), 255 };
|
|
|
|
qfglColor4ubv (color);
|
2022-12-05 02:28:48 +00:00
|
|
|
qfglTexCoord2f (u * s, v * t);
|
|
|
|
qfglVertex2f (x, y);
|
|
|
|
qfglTexCoord2f ((u + w) * s, v * t);
|
|
|
|
qfglVertex2f (x + w, y);
|
|
|
|
qfglTexCoord2f ((u + w) * s, (v + h) * t);
|
|
|
|
qfglVertex2f (x + w, y + h);
|
|
|
|
qfglTexCoord2f (u * s, (v + h) * t);
|
|
|
|
qfglVertex2f (x, y + h);
|
|
|
|
|
|
|
|
qfglEnd ();
|
2022-12-05 04:35:44 +00:00
|
|
|
qfglColor4ubv (color_white);
|
2022-09-02 02:38:09 +00:00
|
|
|
}
|