icculus quake2 doxygen  1.0 dev
Classes | Macros | Typedefs | Enumerations | Functions | Variables
gl_local.h File Reference
#include <windows.h>
#include <stdio.h>
#include <ctype.h>
#include <GL/gl.h>
#include <math.h>
#include "../client/ref.h"
#include "qgl.h"
#include "gl_model.h"

Go to the source code of this file.

Classes

struct  viddef_t
 
struct  image_s
 
struct  glvert_t
 
struct  glconfig_t
 
struct  glstate_t
 

Macros

#define REF_VERSION   "GL 0.01"
 
#define PITCH   0
 
#define YAW   1
 
#define ROLL   2
 
#define __VIDDEF_T
 
#define TEXNUM_LIGHTMAPS   1024
 
#define TEXNUM_SCRAPS   1152
 
#define TEXNUM_IMAGES   1153
 
#define MAX_GLTEXTURES   1024
 
#define MAX_LBM_HEIGHT   480
 
#define BACKFACE_EPSILON   0.01
 
#define GL_RENDERER_VOODOO   0x00000001
 
#define GL_RENDERER_VOODOO2   0x00000002
 
#define GL_RENDERER_VOODOO_RUSH   0x00000004
 
#define GL_RENDERER_BANSHEE   0x00000008
 
#define GL_RENDERER_3DFX   0x0000000F
 
#define GL_RENDERER_PCX1   0x00000010
 
#define GL_RENDERER_PCX2   0x00000020
 
#define GL_RENDERER_PMX   0x00000040
 
#define GL_RENDERER_POWERVR   0x00000070
 
#define GL_RENDERER_PERMEDIA2   0x00000100
 
#define GL_RENDERER_GLINT_MX   0x00000200
 
#define GL_RENDERER_GLINT_TX   0x00000400
 
#define GL_RENDERER_3DLABS_MISC   0x00000800
 
#define GL_RENDERER_3DLABS   0x00000F00
 
#define GL_RENDERER_REALIZM   0x00001000
 
#define GL_RENDERER_REALIZM2   0x00002000
 
#define GL_RENDERER_INTERGRAPH   0x00003000
 
#define GL_RENDERER_3DPRO   0x00004000
 
#define GL_RENDERER_REAL3D   0x00008000
 
#define GL_RENDERER_RIVA128   0x00010000
 
#define GL_RENDERER_DYPIC   0x00020000
 
#define GL_RENDERER_V1000   0x00040000
 
#define GL_RENDERER_V2100   0x00080000
 
#define GL_RENDERER_V2200   0x00100000
 
#define GL_RENDERER_RENDITION   0x001C0000
 
#define GL_RENDERER_O2   0x00100000
 
#define GL_RENDERER_IMPACT   0x00200000
 
#define GL_RENDERER_RE   0x00400000
 
#define GL_RENDERER_IR   0x00800000
 
#define GL_RENDERER_SGI   0x00F00000
 
#define GL_RENDERER_MCD   0x01000000
 
#define GL_RENDERER_OTHER   0x80000000
 

Typedefs

typedef struct image_s image_t
 

Enumerations

enum  imagetype_t {
  it_skin, it_sprite, it_wall, it_pic,
  it_sky, it_skin, it_sprite, it_wall,
  it_pic, it_sky
}
 
enum  rserr_t {
  rserr_ok, rserr_invalid_fullscreen, rserr_invalid_mode, rserr_unknown,
  rserr_ok, rserr_invalid_fullscreen, rserr_invalid_mode, rserr_unknown
}
 

Functions

void GL_BeginRendering (int *x, int *y, int *width, int *height)
 
void GL_EndRendering (void)
 
void GL_SetDefaultState (void)
 
void GL_UpdateSwapInterval (void)
 
void R_TranslatePlayerSkin (int playernum)
 
void GL_Bind (int texnum)
 
void GL_MBind (GLenum target, int texnum)
 
void GL_TexEnv (GLenum value)
 
void GL_EnableMultitexture (qboolean enable)
 
void GL_SelectTexture (GLenum)
 
void R_LightPoint (vec3_t p, vec3_t color)
 
void R_PushDlights (void)
 
void V_AddBlend (float r, float g, float b, float a, float *v_blend)
 
int R_Init (void *hinstance, void *hWnd)
 
void R_Shutdown (void)
 
void R_RenderView (refdef_t *fd)
 
void GL_ScreenShot_f (void)
 
void R_DrawAliasModel (entity_t *e)
 
void R_DrawBrushModel (entity_t *e)
 
void R_DrawSpriteModel (entity_t *e)
 
void R_DrawBeam (entity_t *e)
 
void R_DrawWorld (void)
 
void R_RenderDlights (void)
 
void R_DrawAlphaSurfaces (void)
 
void R_RenderBrushPoly (msurface_t *fa)
 
void R_InitParticleTexture (void)
 
void Draw_InitLocal (void)
 
void GL_SubdivideSurface (msurface_t *fa)
 
qboolean R_CullBox (vec3_t mins, vec3_t maxs)
 
void R_RotateForEntity (entity_t *e)
 
void R_MarkLeaves (void)
 
glpoly_t * WaterWarpPolyVerts (glpoly_t *p)
 
void EmitWaterPolys (msurface_t *fa)
 
void R_AddSkySurface (msurface_t *fa)
 
void R_ClearSkyBox (void)
 
void R_DrawSkyBox (void)
 
void R_MarkLights (dlight_t *light, int bit, mnode_t *node)
 
void COM_StripExtension (char *in, char *out)
 
void Draw_GetPicSize (int *w, int *h, char *name)
 
void Draw_Pic (int x, int y, char *name)
 
void Draw_StretchPic (int x, int y, int w, int h, char *name)
 
void Draw_Char (int x, int y, int c)
 
void Draw_TileClear (int x, int y, int w, int h, char *name)
 
void Draw_Fill (int x, int y, int w, int h, int c)
 
void Draw_FadeScreen (void)
 
void Draw_StretchRaw (int x, int y, int w, int h, int cols, int rows, byte *data)
 
void R_BeginFrame (float camera_separation)
 
void R_SwapBuffers (int)
 
void R_SetPalette (const unsigned char *palette)
 
int Draw_GetPalette (void)
 
void GL_ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight)
 
struct image_s * R_RegisterSkin (char *name)
 
void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
 
image_t * GL_LoadPic (char *name, byte *pic, int width, int height, imagetype_t type, int bits)
 
image_t * GL_FindImage (char *name, imagetype_t type)
 
void GL_TextureMode (char *string)
 
void GL_ImageList_f (void)
 
void GL_SetTexturePalette (unsigned palette[256])
 
void GL_InitImages (void)
 
void GL_ShutdownImages (void)
 
void GL_FreeUnusedImages (void)
 
void GL_TextureAlphaMode (char *string)
 
void GL_TextureSolidMode (char *string)
 
void GL_DrawParticles (int n, const particle_t particles[], const unsigned colortable[768])
 
void GLimp_BeginFrame (float camera_separation)
 
void GLimp_EndFrame (void)
 
int GLimp_Init (void *hinstance, void *hWnd)
 
void GLimp_Shutdown (void)
 
int GLimp_SetMode (int *pwidth, int *pheight, int mode, qboolean fullscreen)
 
void GLimp_AppActivate (qboolean active)
 
void GLimp_EnableLogging (qboolean enable)
 
void GLimp_LogNewFrame (void)
 

Variables

viddef_t vid
 
float gldepthmin
 
float gldepthmax
 
image_t gltextures [MAX_GLTEXTURES]
 
int numgltextures
 
image_t * r_notexture
 
image_t * r_particletexture
 
entity_t * currententity
 
model_t * currentmodel
 
int r_visframecount
 
int r_framecount
 
cplane_t frustum [4]
 
int c_brush_polys
 
int c_alias_polys
 
int gl_filter_min
 
int gl_filter_max
 
vec3_t vup
 
vec3_t vpn
 
vec3_t vright
 
vec3_t r_origin
 
refdef_t r_newrefdef
 
int r_viewcluster
 
int r_viewcluster2
 
int r_oldviewcluster
 
int r_oldviewcluster2
 
cvar_t * r_norefresh
 
cvar_t * r_lefthand
 
cvar_t * r_drawentities
 
cvar_t * r_drawworld
 
cvar_t * r_speeds
 
cvar_t * r_fullbright
 
cvar_t * r_novis
 
cvar_t * r_nocull
 
cvar_t * r_lerpmodels
 
cvar_t * r_lightlevel
 
cvar_t * gl_vertex_arrays
 
cvar_t * gl_ext_swapinterval
 
cvar_t * gl_ext_palettedtexture
 
cvar_t * gl_ext_multitexture
 
cvar_t * gl_ext_pointparameters
 
cvar_t * gl_ext_compiled_vertex_array
 
cvar_t * gl_particle_min_size
 
cvar_t * gl_particle_max_size
 
cvar_t * gl_particle_size
 
cvar_t * gl_particle_att_a
 
cvar_t * gl_particle_att_b
 
cvar_t * gl_particle_att_c
 
cvar_t * gl_nosubimage
 
cvar_t * gl_bitdepth
 
cvar_t * gl_mode
 
cvar_t * gl_log
 
cvar_t * gl_lightmap
 
cvar_t * gl_shadows
 
cvar_t * gl_stencilshadow
 
cvar_t * gl_dynamic
 
cvar_t * gl_monolightmap
 
cvar_t * gl_nobind
 
cvar_t * gl_round_down
 
cvar_t * gl_picmip
 
cvar_t * gl_skymip
 
cvar_t * gl_showtris
 
cvar_t * gl_finish
 
cvar_t * gl_ztrick
 
cvar_t * gl_clear
 
cvar_t * gl_cull
 
cvar_t * gl_poly
 
cvar_t * gl_texsort
 
cvar_t * gl_polyblend
 
cvar_t * gl_flashblend
 
cvar_t * gl_lightmaptype
 
cvar_t * gl_modulate
 
cvar_t * gl_playermip
 
cvar_t * gl_drawbuffer
 
cvar_t * gl_3dlabs_broken
 
cvar_t * gl_driver
 
cvar_t * gl_swapinterval
 
cvar_t * gl_texturemode
 
cvar_t * gl_texturealphamode
 
cvar_t * gl_texturesolidmode
 
cvar_t * gl_saturatelighting
 
cvar_t * gl_lockpvs
 
cvar_t * vid_fullscreen
 
cvar_t * vid_gamma
 
cvar_t * intensity
 
int gl_lightmap_format
 
int gl_solid_format
 
int gl_alpha_format
 
int gl_tex_solid_format
 
int gl_tex_alpha_format
 
int c_visible_lightmaps
 
int c_visible_textures
 
float r_world_matrix [16]
 
model_t * r_worldmodel
 
unsigned d_8to24table [256]
 
int registration_sequence
 
glconfig_t gl_config
 
glstate_t gl_state
 
refimport_t ri
 

Macro Definition Documentation

◆ __VIDDEF_T

#define __VIDDEF_T

Definition at line 62 of file gl_local.h.

◆ BACKFACE_EPSILON

#define BACKFACE_EPSILON   0.01

Definition at line 148 of file gl_local.h.

◆ GL_RENDERER_3DFX

#define GL_RENDERER_3DFX   0x0000000F

Definition at line 368 of file gl_local.h.

◆ GL_RENDERER_3DLABS

#define GL_RENDERER_3DLABS   0x00000F00

Definition at line 379 of file gl_local.h.

◆ GL_RENDERER_3DLABS_MISC

#define GL_RENDERER_3DLABS_MISC   0x00000800

Definition at line 378 of file gl_local.h.

◆ GL_RENDERER_3DPRO

#define GL_RENDERER_3DPRO   0x00004000

Definition at line 385 of file gl_local.h.

◆ GL_RENDERER_BANSHEE

#define GL_RENDERER_BANSHEE   0x00000008

Definition at line 367 of file gl_local.h.

◆ GL_RENDERER_DYPIC

#define GL_RENDERER_DYPIC   0x00020000

Definition at line 388 of file gl_local.h.

◆ GL_RENDERER_GLINT_MX

#define GL_RENDERER_GLINT_MX   0x00000200

Definition at line 376 of file gl_local.h.

◆ GL_RENDERER_GLINT_TX

#define GL_RENDERER_GLINT_TX   0x00000400

Definition at line 377 of file gl_local.h.

◆ GL_RENDERER_IMPACT

#define GL_RENDERER_IMPACT   0x00200000

Definition at line 396 of file gl_local.h.

◆ GL_RENDERER_INTERGRAPH

#define GL_RENDERER_INTERGRAPH   0x00003000

Definition at line 383 of file gl_local.h.

◆ GL_RENDERER_IR

#define GL_RENDERER_IR   0x00800000

Definition at line 398 of file gl_local.h.

◆ GL_RENDERER_MCD

#define GL_RENDERER_MCD   0x01000000

Definition at line 401 of file gl_local.h.

◆ GL_RENDERER_O2

#define GL_RENDERER_O2   0x00100000

Definition at line 395 of file gl_local.h.

◆ GL_RENDERER_OTHER

#define GL_RENDERER_OTHER   0x80000000

Definition at line 402 of file gl_local.h.

◆ GL_RENDERER_PCX1

#define GL_RENDERER_PCX1   0x00000010

Definition at line 370 of file gl_local.h.

◆ GL_RENDERER_PCX2

#define GL_RENDERER_PCX2   0x00000020

Definition at line 371 of file gl_local.h.

◆ GL_RENDERER_PERMEDIA2

#define GL_RENDERER_PERMEDIA2   0x00000100

Definition at line 375 of file gl_local.h.

◆ GL_RENDERER_PMX

#define GL_RENDERER_PMX   0x00000040

Definition at line 372 of file gl_local.h.

◆ GL_RENDERER_POWERVR

#define GL_RENDERER_POWERVR   0x00000070

Definition at line 373 of file gl_local.h.

◆ GL_RENDERER_RE

#define GL_RENDERER_RE   0x00400000

Definition at line 397 of file gl_local.h.

◆ GL_RENDERER_REAL3D

#define GL_RENDERER_REAL3D   0x00008000

Definition at line 386 of file gl_local.h.

◆ GL_RENDERER_REALIZM

#define GL_RENDERER_REALIZM   0x00001000

Definition at line 381 of file gl_local.h.

◆ GL_RENDERER_REALIZM2

#define GL_RENDERER_REALIZM2   0x00002000

Definition at line 382 of file gl_local.h.

◆ GL_RENDERER_RENDITION

#define GL_RENDERER_RENDITION   0x001C0000

Definition at line 393 of file gl_local.h.

◆ GL_RENDERER_RIVA128

#define GL_RENDERER_RIVA128   0x00010000

Definition at line 387 of file gl_local.h.

◆ GL_RENDERER_SGI

#define GL_RENDERER_SGI   0x00F00000

Definition at line 399 of file gl_local.h.

◆ GL_RENDERER_V1000

#define GL_RENDERER_V1000   0x00040000

Definition at line 390 of file gl_local.h.

◆ GL_RENDERER_V2100

#define GL_RENDERER_V2100   0x00080000

Definition at line 391 of file gl_local.h.

◆ GL_RENDERER_V2200

#define GL_RENDERER_V2200   0x00100000

Definition at line 392 of file gl_local.h.

◆ GL_RENDERER_VOODOO

#define GL_RENDERER_VOODOO   0x00000001

Definition at line 364 of file gl_local.h.

◆ GL_RENDERER_VOODOO2

#define GL_RENDERER_VOODOO2   0x00000002

Definition at line 365 of file gl_local.h.

◆ GL_RENDERER_VOODOO_RUSH

#define GL_RENDERER_VOODOO_RUSH   0x00000004

Definition at line 366 of file gl_local.h.

◆ MAX_GLTEXTURES

#define MAX_GLTEXTURES   1024

Definition at line 114 of file gl_local.h.

◆ MAX_LBM_HEIGHT

#define MAX_LBM_HEIGHT   480

Definition at line 146 of file gl_local.h.

◆ PITCH

#define PITCH   0

Definition at line 52 of file gl_local.h.

◆ REF_VERSION

#define REF_VERSION   "GL 0.01"

Definition at line 49 of file gl_local.h.

◆ ROLL

#define ROLL   2

Definition at line 58 of file gl_local.h.

◆ TEXNUM_IMAGES

#define TEXNUM_IMAGES   1153

Definition at line 112 of file gl_local.h.

◆ TEXNUM_LIGHTMAPS

#define TEXNUM_LIGHTMAPS   1024

Definition at line 110 of file gl_local.h.

◆ TEXNUM_SCRAPS

#define TEXNUM_SCRAPS   1152

Definition at line 111 of file gl_local.h.

◆ YAW

#define YAW   1

Definition at line 55 of file gl_local.h.

Typedef Documentation

◆ image_t

typedef struct image_s image_t

Enumeration Type Documentation

◆ imagetype_t

enum imagetype_t
Enumerator
it_skin 
it_sprite 
it_wall 
it_pic 
it_sky 
it_skin 
it_sprite 
it_wall 
it_pic 
it_sky 

Definition at line 85 of file gl_local.h.

86 {
87  it_skin,
88  it_sprite,
89  it_wall,
90  it_pic,
91  it_sky
92 } imagetype_t;

◆ rserr_t

enum rserr_t
Enumerator
rserr_ok 
rserr_invalid_fullscreen 
rserr_invalid_mode 
rserr_unknown 
rserr_ok 
rserr_invalid_fullscreen 
rserr_invalid_mode 
rserr_unknown 

Definition at line 118 of file gl_local.h.

119 {
120  rserr_ok,
121 
122  rserr_invalid_fullscreen,
123  rserr_invalid_mode,
124 
125  rserr_unknown
126 } rserr_t;

Function Documentation

◆ COM_StripExtension()

void COM_StripExtension ( char *  in,
char *  out 
)

Definition at line 826 of file q_shared.c.

827 {
828  while (*in && *in != '.')
829  *out++ = *in++;
830  *out = 0;
831 }

Referenced by CL_CheckOrDownloadFile(), and CL_Download_f().

◆ Draw_Char()

void Draw_Char ( int  x,
int  y,
int  c 
)

Definition at line 74 of file r_draw.c.

75 {
76  byte *dest;
77  byte *source;
78  int drawline;
79  int row, col;
80 
81  num &= 255;
82 
83  if (num == 32 || num == 32+128)
84  return;
85 
86  if (y <= -8)
87  return; // totally off screen
88 
89 // if ( ( y + 8 ) >= vid.height )
90  if ( ( y + 8 ) > vid.height ) // PGM - status text was missing in sw...
91  return;
92 
93 #ifdef PARANOID
94  if (y > vid.height - 8 || x < 0 || x > vid.width - 8)
95  ri.Sys_Error (ERR_FATAL,"Con_DrawCharacter: (%i, %i)", x, y);
96  if (num < 0 || num > 255)
97  ri.Sys_Error (ERR_FATAL,"Con_DrawCharacter: char %i", num);
98 #endif
99 
100  row = num>>4;
101  col = num&15;
102  source = draw_chars->pixels[0] + (row<<10) + (col<<3);
103 
104  if (y < 0)
105  { // clipped
106  drawline = 8 + y;
107  source -= 128*y;
108  y = 0;
109  }
110  else
111  drawline = 8;
112 
113 
114  dest = vid.buffer + y*vid.rowbytes + x;
115 
116  while (drawline--)
117  {
118  if (source[0] != TRANSPARENT_COLOR)
119  dest[0] = source[0];
120  if (source[1] != TRANSPARENT_COLOR)
121  dest[1] = source[1];
122  if (source[2] != TRANSPARENT_COLOR)
123  dest[2] = source[2];
124  if (source[3] != TRANSPARENT_COLOR)
125  dest[3] = source[3];
126  if (source[4] != TRANSPARENT_COLOR)
127  dest[4] = source[4];
128  if (source[5] != TRANSPARENT_COLOR)
129  dest[5] = source[5];
130  if (source[6] != TRANSPARENT_COLOR)
131  dest[6] = source[6];
132  if (source[7] != TRANSPARENT_COLOR)
133  dest[7] = source[7];
134  source += 128;
135  dest += vid.rowbytes;
136  }
137 }

◆ Draw_FadeScreen()

void Draw_FadeScreen ( void  )

Definition at line 428 of file r_draw.c.

429 {
430  int x,y;
431  byte *pbuf;
432  int t;
433 
434  for (y=0 ; y<vid.height ; y++)
435  {
436  pbuf = (byte *)(vid.buffer + vid.rowbytes*y);
437  t = (y & 1) << 1;
438 
439  for (x=0 ; x<vid.width ; x++)
440  {
441  if ((x & 3) != t)
442  pbuf[x] = 0;
443  }
444  }
445 }

◆ Draw_Fill()

void Draw_Fill ( int  x,
int  y,
int  w,
int  h,
int  c 
)

Definition at line 394 of file r_draw.c.

395 {
396  byte *dest;
397  int u, v;
398 
399  if (x+w > vid.width)
400  w = vid.width - x;
401  if (y+h > vid.height)
402  h = vid.height - y;
403  if (x < 0)
404  {
405  w += x;
406  x = 0;
407  }
408  if (y < 0)
409  {
410  h += y;
411  y = 0;
412  }
413  if (w < 0 || h < 0)
414  return;
415  dest = vid.buffer + y*vid.rowbytes + x;
416  for (v=0 ; v<h ; v++, dest += vid.rowbytes)
417  for (u=0 ; u<w ; u++)
418  dest[u] = c;
419 }

◆ Draw_GetPalette()

int Draw_GetPalette ( void  )

Definition at line 1326 of file r_main.c.

1327 {
1328  byte *pal, *out;
1329  int i;
1330  int r, g, b;
1331 
1332  // get the palette and colormap
1333  LoadPCX ("pics/colormap.pcx", &vid.colormap, &pal, NULL, NULL);
1334  if (!vid.colormap)
1335  ri.Sys_Error (ERR_FATAL, "Couldn't load pics/colormap.pcx");
1336  vid.alphamap = vid.colormap + 64*256;
1337 
1338  out = (byte *)d_8to24table;
1339  for (i=0 ; i<256 ; i++, out+=4)
1340  {
1341  r = pal[i*3+0];
1342  g = pal[i*3+1];
1343  b = pal[i*3+2];
1344 
1345  out[0] = r;
1346  out[1] = g;
1347  out[2] = b;
1348  }
1349 
1350  free (pal);
1351 }

Referenced by GL_InitImages(), and R_Init().

◆ Draw_GetPicSize()

void Draw_GetPicSize ( int *  w,
int *  h,
char *  name 
)

Definition at line 144 of file r_draw.c.

145 {
146  image_t *gl;
147 
148  gl = Draw_FindPic (pic);
149  if (!gl)
150  {
151  *w = *h = -1;
152  return;
153  }
154  *w = gl->width;
155  *h = gl->height;
156 }

Referenced by GetRefAPI().

◆ Draw_InitLocal()

void Draw_InitLocal ( void  )

Definition at line 58 of file r_draw.c.

59 {
60  draw_chars = Draw_FindPic ("conchars");
61 }

Referenced by R_Init().

◆ Draw_Pic()

void Draw_Pic ( int  x,
int  y,
char *  name 
)

Definition at line 253 of file r_draw.c.

254 {
255  image_t *pic;
256  byte *dest, *source;
257  int v, u;
258  int tbyte;
259  int height;
260 
261  pic = Draw_FindPic (name);
262  if (!pic)
263  {
264  ri.Con_Printf (PRINT_ALL, "Can't find pic: %s\n", name);
265  return;
266  }
267 
268  if ((x < 0) ||
269  (x + pic->width > vid.width) ||
270  (y + pic->height > vid.height))
271  return; // ri.Sys_Error (ERR_FATAL,"Draw_Pic: bad coordinates");
272 
273  height = pic->height;
274  source = pic->pixels[0];
275  if (y < 0)
276  {
277  height += y;
278  source += pic->width*-y;
279  y = 0;
280  }
281 
282  dest = vid.buffer + y * vid.rowbytes + x;
283 
284  if (!pic->transparent)
285  {
286  for (v=0 ; v<height ; v++)
287  {
288  memcpy (dest, source, pic->width);
289  dest += vid.rowbytes;
290  source += pic->width;
291  }
292  }
293  else
294  {
295  if (pic->width & 7)
296  { // general
297  for (v=0 ; v<height ; v++)
298  {
299  for (u=0 ; u<pic->width ; u++)
300  if ( (tbyte=source[u]) != TRANSPARENT_COLOR)
301  dest[u] = tbyte;
302 
303  dest += vid.rowbytes;
304  source += pic->width;
305  }
306  }
307  else
308  { // unwound
309  for (v=0 ; v<height ; v++)
310  {
311  for (u=0 ; u<pic->width ; u+=8)
312  {
313  if ( (tbyte=source[u]) != TRANSPARENT_COLOR)
314  dest[u] = tbyte;
315  if ( (tbyte=source[u+1]) != TRANSPARENT_COLOR)
316  dest[u+1] = tbyte;
317  if ( (tbyte=source[u+2]) != TRANSPARENT_COLOR)
318  dest[u+2] = tbyte;
319  if ( (tbyte=source[u+3]) != TRANSPARENT_COLOR)
320  dest[u+3] = tbyte;
321  if ( (tbyte=source[u+4]) != TRANSPARENT_COLOR)
322  dest[u+4] = tbyte;
323  if ( (tbyte=source[u+5]) != TRANSPARENT_COLOR)
324  dest[u+5] = tbyte;
325  if ( (tbyte=source[u+6]) != TRANSPARENT_COLOR)
326  dest[u+6] = tbyte;
327  if ( (tbyte=source[u+7]) != TRANSPARENT_COLOR)
328  dest[u+7] = tbyte;
329  }
330  dest += vid.rowbytes;
331  source += pic->width;
332  }
333  }
334  }
335 }

◆ Draw_StretchPic()

void Draw_StretchPic ( int  x,
int  y,
int  w,
int  h,
char *  name 
)

Definition at line 220 of file r_draw.c.

221 {
222  image_t *pic;
223 
224  pic = Draw_FindPic (name);
225  if (!pic)
226  {
227  ri.Con_Printf (PRINT_ALL, "Can't find pic: %s\n", name);
228  return;
229  }
230  Draw_StretchPicImplementation (x, y, w, h, pic);
231 }

Referenced by GetRefAPI().

◆ Draw_StretchRaw()

void Draw_StretchRaw ( int  x,
int  y,
int  w,
int  h,
int  cols,
int  rows,
byte *  data 
)

Definition at line 238 of file r_draw.c.

239 {
240  image_t pic;
241 
242  pic.pixels[0] = data;
243  pic.width = cols;
244  pic.height = rows;
245  Draw_StretchPicImplementation (x, y, w, h, &pic);
246 }

Referenced by GetRefAPI().

◆ Draw_TileClear()

void Draw_TileClear ( int  x,
int  y,
int  w,
int  h,
char *  name 
)

Definition at line 345 of file r_draw.c.

346 {
347  int i, j;
348  byte *psrc;
349  byte *pdest;
350  image_t *pic;
351  int x2;
352 
353  if (x < 0)
354  {
355  w += x;
356  x = 0;
357  }
358  if (y < 0)
359  {
360  h += y;
361  y = 0;
362  }
363  if (x + w > vid.width)
364  w = vid.width - x;
365  if (y + h > vid.height)
366  h = vid.height - y;
367  if (w <= 0 || h <= 0)
368  return;
369 
370  pic = Draw_FindPic (name);
371  if (!pic)
372  {
373  ri.Con_Printf (PRINT_ALL, "Can't find pic: %s\n", name);
374  return;
375  }
376  x2 = x + w;
377  pdest = vid.buffer + y*vid.rowbytes;
378  for (i=0 ; i<h ; i++, pdest += vid.rowbytes)
379  {
380  psrc = pic->pixels[0] + pic->width * ((i+y)&63);
381  for (j=x ; j<x2 ; j++)
382  pdest[j] = psrc[j&63];
383  }
384 }

◆ EmitWaterPolys()

void EmitWaterPolys ( msurface_t *  fa)

Definition at line 211 of file gl_warp.c.

212 {
213  glpoly_t *p, *bp;
214  float *v;
215  int i;
216  float s, t, os, ot;
217  float scroll;
218  float rdt = r_newrefdef.time;
219 
220  if (fa->texinfo->flags & SURF_FLOWING)
221  scroll = -64 * ( (r_newrefdef.time*0.5) - (int)(r_newrefdef.time*0.5) );
222  else
223  scroll = 0;
224  for (bp=fa->polys ; bp ; bp=bp->next)
225  {
226  p = bp;
227 
228  qglBegin (GL_TRIANGLE_FAN);
229  for (i=0,v=p->verts[0] ; i<p->numverts ; i++, v+=VERTEXSIZE)
230  {
231  os = v[3];
232  ot = v[4];
233 
234 #if !id386
235  s = os + r_turbsin[(int)((ot*0.125+r_newrefdef.time) * TURBSCALE) & 255];
236 #else
237  s = os + r_turbsin[Q_ftol( ((ot*0.125+rdt) * TURBSCALE) ) & 255];
238 #endif
239  s += scroll;
240  s *= (1.0/64);
241 
242 #if !id386
243  t = ot + r_turbsin[(int)((os*0.125+rdt) * TURBSCALE) & 255];
244 #else
245  t = ot + r_turbsin[Q_ftol( ((os*0.125+rdt) * TURBSCALE) ) & 255];
246 #endif
247  t *= (1.0/64);
248 
249  qglTexCoord2f (s, t);
250  qglVertex3fv (v);
251  }
252  qglEnd ();
253  }
254 }

Referenced by R_DrawAlphaSurfaces(), and R_RenderBrushPoly().

◆ GL_BeginRendering()

void GL_BeginRendering ( int *  x,
int *  y,
int *  width,
int *  height 
)

◆ GL_Bind()

void GL_Bind ( int  texnum)

Definition at line 136 of file gl_image.c.

137 {
138  extern image_t *draw_chars;
139 
140  if (gl_nobind->value && draw_chars) // performance evaluation option
141  texnum = draw_chars->texnum;
142  if ( gl_state.currenttextures[gl_state.currenttmu] == texnum)
143  return;
144  gl_state.currenttextures[gl_state.currenttmu] = texnum;
145  qglBindTexture (GL_TEXTURE_2D, texnum);
146 }

Referenced by Draw_Char(), Draw_InitLocal(), Draw_Pic(), Draw_StretchPic(), Draw_StretchRaw(), Draw_TileClear(), GL_BeginBuildingLightmaps(), GL_DrawParticles(), GL_LoadPic(), GL_MBind(), GL_TextureMode(), LM_UploadBlock(), R_BlendLightmaps(), R_DrawAliasModel(), R_DrawAlphaSurfaces(), R_DrawSkyBox(), R_DrawSpriteModel(), R_RenderBrushPoly(), and Scrap_Upload().

◆ GL_DrawParticles()

void GL_DrawParticles ( int  n,
const particle_t  particles[],
const unsigned  colortable[768] 
)

Definition at line 410 of file gl_rmain.c.

411 {
412  const particle_t *p;
413  int i;
414  vec3_t up, right;
415  float scale;
416  byte color[4];
417 
418  GL_Bind(r_particletexture->texnum);
419  qglDepthMask( GL_FALSE ); // no z buffering
420  qglEnable( GL_BLEND );
421  GL_TexEnv( GL_MODULATE );
422  qglBegin( GL_TRIANGLES );
423 
424  VectorScale (vup, 1.5, up);
425  VectorScale (vright, 1.5, right);
426 
427  for ( p = particles, i=0 ; i < num_particles ; i++,p++)
428  {
429  // hack a scale up to keep particles from disapearing
430  scale = ( p->origin[0] - r_origin[0] ) * vpn[0] +
431  ( p->origin[1] - r_origin[1] ) * vpn[1] +
432  ( p->origin[2] - r_origin[2] ) * vpn[2];
433 
434  if (scale < 20)
435  scale = 1;
436  else
437  scale = 1 + scale * 0.004;
438 
439  *(int *)color = colortable[p->color];
440  color[3] = p->alpha*255;
441 
442  qglColor4ubv( color );
443 
444  qglTexCoord2f( 0.0625, 0.0625 );
445  qglVertex3fv( p->origin );
446 
447  qglTexCoord2f( 1.0625, 0.0625 );
448  qglVertex3f( p->origin[0] + up[0]*scale,
449  p->origin[1] + up[1]*scale,
450  p->origin[2] + up[2]*scale);
451 
452  qglTexCoord2f( 0.0625, 1.0625 );
453  qglVertex3f( p->origin[0] + right[0]*scale,
454  p->origin[1] + right[1]*scale,
455  p->origin[2] + right[2]*scale);
456  }
457 
458  qglEnd ();
459  qglDisable( GL_BLEND );
460  qglColor4f( 1,1,1,1 );
461  qglDepthMask( 1 ); // back to normal Z buffering
462  GL_TexEnv( GL_REPLACE );
463 }

Referenced by R_DrawParticles().

◆ GL_EnableMultitexture()

void GL_EnableMultitexture ( qboolean  enable)

Definition at line 70 of file gl_image.c.

71 {
72  if ( !qglSelectTextureSGIS && !qglActiveTextureARB )
73  return;
74 
75  if ( enable )
76  {
77  GL_SelectTexture( QGL_TEXTURE1 );
78  qglEnable( GL_TEXTURE_2D );
79  GL_TexEnv( GL_REPLACE );
80  }
81  else
82  {
83  GL_SelectTexture( QGL_TEXTURE1 );
84  qglDisable( GL_TEXTURE_2D );
85  GL_TexEnv( GL_REPLACE );
86  }
87  GL_SelectTexture( QGL_TEXTURE0 );
88  GL_TexEnv( GL_REPLACE );
89 }

Referenced by DrawTextureChains(), GL_BeginBuildingLightmaps(), GL_EndBuildingLightmaps(), R_DrawBrushModel(), R_DrawInlineBModel(), and R_DrawWorld().

◆ GL_EndRendering()

void GL_EndRendering ( void  )

◆ GL_FindImage()

image_t* GL_FindImage ( char *  name,
imagetype_t  type 
)

Definition at line 1393 of file gl_image.c.

1394 {
1395  image_t *image;
1396  int i, len;
1397  byte *pic, *palette;
1398  int width, height;
1399  char *ptr;
1400 
1401  if (!name)
1402  return NULL; // ri.Sys_Error (ERR_DROP, "GL_FindImage: NULL name");
1403  len = strlen(name);
1404  if (len<5)
1405  return NULL; // ri.Sys_Error (ERR_DROP, "GL_FindImage: bad name: %s", name);
1406 
1407 #ifndef _WIN32
1408  // fix backslashes
1409  while ((ptr=strchr(name,'\\'))) {
1410  *ptr = '/';
1411  }
1412 #endif
1413 
1414  // look for it
1415  for (i=0, image=gltextures ; i<numgltextures ; i++,image++)
1416  {
1417  if (!strcmp(name, image->name))
1418  {
1419  image->registration_sequence = registration_sequence;
1420  return image;
1421  }
1422  }
1423 
1424  //
1425  // load the pic from disk
1426  //
1427  pic = NULL;
1428  palette = NULL;
1429  if (!strcmp(name+len-4, ".pcx"))
1430  {
1431  LoadPCX (name, &pic, &palette, &width, &height);
1432  if (!pic)
1433  return NULL; // ri.Sys_Error (ERR_DROP, "GL_FindImage: can't load %s", name);
1434  image = GL_LoadPic (name, pic, width, height, type, 8);
1435  }
1436  else if (!strcmp(name+len-4, ".wal"))
1437  {
1438  image = GL_LoadWal (name);
1439  }
1440  else if (!strcmp(name+len-4, ".tga"))
1441  {
1442  LoadTGA (name, &pic, &width, &height);
1443  if (!pic)
1444  return NULL; // ri.Sys_Error (ERR_DROP, "GL_FindImage: can't load %s", name);
1445  image = GL_LoadPic (name, pic, width, height, type, 32);
1446  }
1447  else
1448  return NULL; // ri.Sys_Error (ERR_DROP, "GL_FindImage: bad extension on: %s", name);
1449 
1450 
1451  if (pic)
1452  free(pic);
1453  if (palette)
1454  free(palette);
1455 
1456  return image;
1457 }

Referenced by Draw_FindPic(), Draw_InitLocal(), Mod_LoadAliasModel(), Mod_LoadSpriteModel(), Mod_LoadTexinfo(), R_RegisterModel(), R_RegisterSkin(), and R_SetSky().

◆ GL_FreeUnusedImages()

void GL_FreeUnusedImages ( void  )

Definition at line 1480 of file gl_image.c.

1481 {
1482  int i;
1483  image_t *image;
1484 
1485  // never free r_notexture or particle texture
1486  r_notexture->registration_sequence = registration_sequence;
1487  r_particletexture->registration_sequence = registration_sequence;
1488 
1489  for (i=0, image=gltextures ; i<numgltextures ; i++, image++)
1490  {
1491  if (image->registration_sequence == registration_sequence)
1492  continue; // used this sequence
1493  if (!image->registration_sequence)
1494  continue; // free image_t slot
1495  if (image->type == it_pic)
1496  continue; // don't free pics
1497  // free it
1498  qglDeleteTextures (1, (GLuint *)&image->texnum);
1499  memset (image, 0, sizeof(*image));
1500  }
1501 }

Referenced by R_EndRegistration().

◆ GL_ImageList_f()

void GL_ImageList_f ( void  )

Definition at line 302 of file gl_image.c.

303 {
304  int i;
305  image_t *image;
306  int texels;
307  const char *palstrings[2] =
308  {
309  "RGB",
310  "PAL"
311  };
312 
313  ri.Con_Printf (PRINT_ALL, "------------------\n");
314  texels = 0;
315 
316  for (i=0, image=gltextures ; i<numgltextures ; i++, image++)
317  {
318  if (image->texnum <= 0)
319  continue;
320  texels += image->upload_width*image->upload_height;
321  switch (image->type)
322  {
323  case it_skin:
324  ri.Con_Printf (PRINT_ALL, "M");
325  break;
326  case it_sprite:
327  ri.Con_Printf (PRINT_ALL, "S");
328  break;
329  case it_wall:
330  ri.Con_Printf (PRINT_ALL, "W");
331  break;
332  case it_pic:
333  ri.Con_Printf (PRINT_ALL, "P");
334  break;
335  default:
336  ri.Con_Printf (PRINT_ALL, " ");
337  break;
338  }
339 
340  ri.Con_Printf (PRINT_ALL, " %3i %3i %s: %s\n",
341  image->upload_width, image->upload_height, palstrings[image->paletted], image->name);
342  }
343  ri.Con_Printf (PRINT_ALL, "Total texel count (not counting mipmaps): %i\n", texels);
344 }

Referenced by R_Register().

◆ GL_InitImages()

void GL_InitImages ( void  )

Definition at line 1547 of file gl_image.c.

1548 {
1549  int i, j;
1550  float g = vid_gamma->value;
1551 
1552  registration_sequence = 1;
1553 
1554  // init intensity conversions
1555  intensity = ri.Cvar_Get ("intensity", "2", 0);
1556 
1557  if ( intensity->value <= 1 )
1558  ri.Cvar_Set( "intensity", "1" );
1559 
1560  gl_state.inverse_intensity = 1 / intensity->value;
1561 
1562  Draw_GetPalette ();
1563 
1564  if ( qglColorTableEXT )
1565  {
1566  ri.FS_LoadFile( "pics/16to8.dat", (void **)&gl_state.d_16to8table );
1567  if ( !gl_state.d_16to8table )
1568  ri.Sys_Error( ERR_FATAL, "Couldn't load pics/16to8.pcx");
1569  }
1570 
1571  if ( gl_config.renderer & ( GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2 ) )
1572  {
1573  g = 1.0F;
1574  }
1575 
1576  for ( i = 0; i < 256; i++ )
1577  {
1578  if ( g == 1 || gl_state.hwgamma )
1579  {
1580  gammatable[i] = i;
1581  }
1582  else
1583  {
1584  float inf;
1585 
1586  inf = 255 * pow ( (i+0.5)/255.5 , g ) + 0.5;
1587  if (inf < 0)
1588  inf = 0;
1589  if (inf > 255)
1590  inf = 255;
1591  gammatable[i] = inf;
1592  }
1593  }
1594 
1595  for (i=0 ; i<256 ; i++)
1596  {
1597  j = i*intensity->value;
1598  if (j > 255)
1599  j = 255;
1600  intensitytable[i] = j;
1601  }
1602 }

Referenced by R_Init().

◆ GL_LoadPic()

image_t* GL_LoadPic ( char *  name,
byte *  pic,
int  width,
int  height,
imagetype_t  type,
int  bits 
)

Definition at line 1255 of file gl_image.c.

1256 {
1257  image_t *image;
1258  int i;
1259 #ifdef RETEX
1260  miptex_t *mt;
1261  int len;
1262  char s[128];
1263 #endif
1264 
1265  // find a free image_t
1266  for (i=0, image=gltextures ; i<numgltextures ; i++,image++)
1267  {
1268  if (!image->texnum)
1269  break;
1270  }
1271  if (i == numgltextures)
1272  {
1273  if (numgltextures == MAX_GLTEXTURES)
1274  ri.Sys_Error (ERR_DROP, "MAX_GLTEXTURES");
1275  numgltextures++;
1276  }
1277  image = &gltextures[i];
1278 
1279  if (strlen(name) >= sizeof(image->name))
1280  ri.Sys_Error (ERR_DROP, "Draw_LoadPic: \"%s\" is too long", name);
1281  strcpy (image->name, name);
1282  image->registration_sequence = registration_sequence;
1283 
1284  image->width = width;
1285  image->height = height;
1286  image->type = type;
1287 
1288 #ifdef RETEX
1289  len = strlen(name);
1290  strcpy(s,name);
1291 
1292  if (!strcmp(s+len-4, ".tga") || !strcmp(s+len-4, ".jpg") || !strcmp(s+len-4, ".png"))
1293  {
1294  s[len-3] = 'w'; s[len-2] = 'a'; s[len-1] = 'l';
1295  ri.FS_LoadFile (s, (void **)&mt); //load .wal file
1296 
1297  if (mt) {
1298  image->width = LittleLong (mt->width);
1299  image->height = LittleLong (mt->height);
1300  ri.FS_FreeFile ((void *)mt);
1301  }
1302  }
1303 #endif
1304 
1305  if (type == it_skin && bits == 8)
1306  R_FloodFillSkin(pic, width, height);
1307 
1308  // load little pics into the scrap
1309  if (image->type == it_pic && bits == 8
1310  && image->width < 64 && image->height < 64)
1311  {
1312  int x, y;
1313  int i, j, k;
1314  int texnum;
1315 
1316  texnum = Scrap_AllocBlock (image->width, image->height, &x, &y);
1317  if (texnum == -1)
1318  goto nonscrap;
1319  scrap_dirty = true;
1320 
1321  // copy the texels into the scrap block
1322  k = 0;
1323  for (i=0 ; i<image->height ; i++)
1324  for (j=0 ; j<image->width ; j++, k++)
1325  scrap_texels[texnum][(y+i)*BLOCK_WIDTH + x + j] = pic[k];
1326  image->texnum = TEXNUM_SCRAPS + texnum;
1327  image->scrap = true;
1328  image->has_alpha = true;
1329  image->sl = (x+0.01)/(float)BLOCK_WIDTH;
1330  image->sh = (x+image->width-0.01)/(float)BLOCK_WIDTH;
1331  image->tl = (y+0.01)/(float)BLOCK_WIDTH;
1332  image->th = (y+image->height-0.01)/(float)BLOCK_WIDTH;
1333  }
1334  else
1335  {
1336 nonscrap:
1337  image->scrap = false;
1338  image->texnum = TEXNUM_IMAGES + (image - gltextures);
1339  GL_Bind(image->texnum);
1340  if (bits == 8)
1341  image->has_alpha = GL_Upload8 (pic, width, height, (image->type != it_pic && image->type != it_sky), image->type == it_sky );
1342  else
1343  image->has_alpha = GL_Upload32 ((unsigned *)pic, width, height, (image->type != it_pic && image->type != it_sky) );
1344  image->upload_width = upload_width; // after power of 2 and scales
1345  image->upload_height = upload_height;
1346  image->paletted = uploaded_paletted;
1347  image->sl = 0;
1348  image->sh = 1;
1349  image->tl = 0;
1350  image->th = 1;
1351  }
1352 
1353  return image;
1354 }

Referenced by GL_FindImage(), and GL_LoadWal().

◆ GL_MBind()

void GL_MBind ( GLenum  target,
int  texnum 
)

Definition at line 148 of file gl_image.c.

149 {
150  GL_SelectTexture( target );
151  if ( target == QGL_TEXTURE0 )
152  {
153  if ( gl_state.currenttextures[0] == texnum )
154  return;
155  }
156  else
157  {
158  if ( gl_state.currenttextures[1] == texnum )
159  return;
160  }
161  GL_Bind( texnum );
162 }

Referenced by GL_RenderLightmappedPoly().

◆ GL_ResampleTexture()

void GL_ResampleTexture ( unsigned *  in,
int  inwidth,
int  inheight,
unsigned *  out,
int  outwidth,
int  outheight 
)

Definition at line 835 of file gl_image.c.

836 {
837  int i, j;
838  unsigned *inrow, *inrow2;
839  unsigned frac, fracstep;
840  unsigned p1[1024], p2[1024];
841  byte *pix1, *pix2, *pix3, *pix4;
842 
843  fracstep = inwidth*0x10000/outwidth;
844 
845  frac = fracstep>>2;
846  for (i=0 ; i<outwidth ; i++)
847  {
848  p1[i] = 4*(frac>>16);
849  frac += fracstep;
850  }
851  frac = 3*(fracstep>>2);
852  for (i=0 ; i<outwidth ; i++)
853  {
854  p2[i] = 4*(frac>>16);
855  frac += fracstep;
856  }
857 
858  for (i=0 ; i<outheight ; i++, out += outwidth)
859  {
860  inrow = in + inwidth*(int)((i+0.25)*inheight/outheight);
861  inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight);
862  frac = fracstep >> 1;
863  for (j=0 ; j<outwidth ; j++)
864  {
865  pix1 = (byte *)inrow + p1[j];
866  pix2 = (byte *)inrow + p2[j];
867  pix3 = (byte *)inrow2 + p1[j];
868  pix4 = (byte *)inrow2 + p2[j];
869  ((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2;
870  ((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2;
871  ((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2;
872  ((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2;
873  }
874  }
875 }

Referenced by GL_Upload32().

◆ GL_ScreenShot_f()

void GL_ScreenShot_f ( void  )

Definition at line 100 of file gl_rmisc.c.

101 {
102  byte *buffer;
103  char picname[80];
104  char checkname[MAX_OSPATH];
105  int i, c, temp;
106  FILE *f;
107 
108  // create the scrnshots directory if it doesn't exist
109  Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot", ri.FS_Gamedir());
110  Sys_Mkdir (checkname);
111 
112 //
113 // find a file name to save it to
114 //
115  strcpy(picname,"quake00.tga");
116 
117  for (i=0 ; i<=99 ; i++)
118  {
119  picname[5] = i/10 + '0';
120  picname[6] = i%10 + '0';
121  Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot/%s", ri.FS_Gamedir(), picname);
122  f = fopen (checkname, "rb");
123  if (!f)
124  break; // file doesn't exist
125  fclose (f);
126  }
127  if (i==100)
128  {
129  ri.Con_Printf (PRINT_ALL, "SCR_ScreenShot_f: Couldn't create a file\n");
130  return;
131  }
132 
133 
134  buffer = malloc(vid.width*vid.height*3 + 18);
135  memset (buffer, 0, 18);
136  buffer[2] = 2; // uncompressed type
137  buffer[12] = vid.width&255;
138  buffer[13] = vid.width>>8;
139  buffer[14] = vid.height&255;
140  buffer[15] = vid.height>>8;
141  buffer[16] = 24; // pixel size
142 
143  qglReadPixels (0, 0, vid.width, vid.height, GL_RGB, GL_UNSIGNED_BYTE, buffer+18 );
144 
145  // swap rgb to bgr
146  c = 18+vid.width*vid.height*3;
147  for (i=18 ; i<c ; i+=3)
148  {
149  temp = buffer[i];
150  buffer[i] = buffer[i+2];
151  buffer[i+2] = temp;
152  }
153 
154  f = fopen (checkname, "wb");
155  fwrite (buffer, 1, c, f);
156  fclose (f);
157 
158  free (buffer);
159  ri.Con_Printf (PRINT_ALL, "Wrote %s\n", picname);
160 }

Referenced by R_Register().

◆ GL_SelectTexture()

void GL_SelectTexture ( GLenum  )

Definition at line 91 of file gl_image.c.

92 {
93  int tmu;
94 
95  if ( !qglSelectTextureSGIS && !qglActiveTextureARB )
96  return;
97 
98  if ( texture == QGL_TEXTURE0 )
99  {
100  tmu = 0;
101  }
102  else
103  {
104  tmu = 1;
105  }
106 
107  if ( tmu == gl_state.currenttmu )
108  {
109  return;
110  }
111 
112  gl_state.currenttmu = tmu;
113 
114  if ( qglSelectTextureSGIS )
115  {
116  qglSelectTextureSGIS( texture );
117  }
118  else if ( qglActiveTextureARB )
119  {
120  qglActiveTextureARB( texture );
121  qglClientActiveTextureARB( texture );
122  }
123 }

Referenced by GL_BeginBuildingLightmaps(), GL_EnableMultitexture(), GL_MBind(), R_DrawBrushModel(), and R_DrawWorld().

◆ GL_SetDefaultState()

void GL_SetDefaultState ( void  )

Definition at line 176 of file gl_rmisc.c.

177 {
178  qglClearColor (1,0, 0.5 , 0.5);
179  qglCullFace(GL_FRONT);
180  qglEnable(GL_TEXTURE_2D);
181 
182  qglEnable(GL_ALPHA_TEST);
183  qglAlphaFunc(GL_GREATER, 0.666);
184 
185  qglDisable (GL_DEPTH_TEST);
186  qglDisable (GL_CULL_FACE);
187  qglDisable (GL_BLEND);
188 
189  qglColor4f (1,1,1,1);
190 
191  qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
192  qglShadeModel (GL_FLAT);
193 
194  GL_TextureMode( gl_texturemode->string );
195  GL_TextureAlphaMode( gl_texturealphamode->string );
196  GL_TextureSolidMode( gl_texturesolidmode->string );
197 
198  qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
199  qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
200 
201  qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
202  qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
203 
204  qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
205 
206  GL_TexEnv( GL_REPLACE );
207 
208  if ( qglPointParameterfEXT )
209  {
210  float attenuations[3];
211 
212  attenuations[0] = gl_particle_att_a->value;
213  attenuations[1] = gl_particle_att_b->value;
214  attenuations[2] = gl_particle_att_c->value;
215 
216  qglEnable( GL_POINT_SMOOTH );
217  qglPointParameterfEXT( GL_POINT_SIZE_MIN_EXT, gl_particle_min_size->value );
218  qglPointParameterfEXT( GL_POINT_SIZE_MAX_EXT, gl_particle_max_size->value );
219  qglPointParameterfvEXT( GL_DISTANCE_ATTENUATION_EXT, attenuations );
220  }
221 
222  if ( qglColorTableEXT && gl_ext_palettedtexture->value )
223  {
224  qglEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
225 
226  GL_SetTexturePalette( d_8to24table );
227  }
228 
229  GL_UpdateSwapInterval();
230 }

Referenced by R_Init().

◆ GL_SetTexturePalette()

void GL_SetTexturePalette ( unsigned  palette[256])

Definition at line 47 of file gl_image.c.

48 {
49  int i;
50  unsigned char temptable[768];
51 
52  if ( qglColorTableEXT && gl_ext_palettedtexture->value )
53  {
54  for ( i = 0; i < 256; i++ )
55  {
56  temptable[i*3+0] = ( palette[i] >> 0 ) & 0xff;
57  temptable[i*3+1] = ( palette[i] >> 8 ) & 0xff;
58  temptable[i*3+2] = ( palette[i] >> 16 ) & 0xff;
59  }
60 
61  qglColorTableEXT( GL_SHARED_TEXTURE_PALETTE_EXT,
62  GL_RGB,
63  256,
64  GL_RGB,
65  GL_UNSIGNED_BYTE,
66  temptable );
67  }
68 }

Referenced by GL_SetDefaultState(), and R_SetPalette().

◆ GL_ShutdownImages()

void GL_ShutdownImages ( void  )

Definition at line 1609 of file gl_image.c.

1610 {
1611  int i;
1612  image_t *image;
1613 
1614  for (i=0, image=gltextures ; i<numgltextures ; i++, image++)
1615  {
1616  if (!image->registration_sequence)
1617  continue; // free image_t slot
1618  // free it
1619  qglDeleteTextures (1, (GLuint *)&image->texnum);
1620  memset (image, 0, sizeof(*image));
1621  }
1622 }

Referenced by R_Shutdown().

◆ GL_SubdivideSurface()

void GL_SubdivideSurface ( msurface_t *  fa)

Definition at line 164 of file gl_warp.c.

165 {
166  vec3_t verts[64];
167  int numverts;
168  int i;
169  int lindex;
170  float *vec;
171 
172  warpface = fa;
173 
174  //
175  // convert edges back to a normal polygon
176  //
177  numverts = 0;
178  for (i=0 ; i<fa->numedges ; i++)
179  {
180  lindex = loadmodel->surfedges[fa->firstedge + i];
181 
182  if (lindex > 0)
183  vec = loadmodel->vertexes[loadmodel->edges[lindex].v[0]].position;
184  else
185  vec = loadmodel->vertexes[loadmodel->edges[-lindex].v[1]].position;
186  VectorCopy (vec, verts[numverts]);
187  numverts++;
188  }
189 
190  SubdividePolygon (numverts, verts[0]);
191 }

Referenced by Mod_LoadFaces().

◆ GL_TexEnv()

void GL_TexEnv ( GLenum  value)

Definition at line 125 of file gl_image.c.

126 {
127  static int lastmodes[2] = { -1, -1 };
128 
129  if ( mode != lastmodes[gl_state.currenttmu] )
130  {
131  qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode );
132  lastmodes[gl_state.currenttmu] = mode;
133  }
134 }

Referenced by DrawTextureChains(), GL_DrawParticles(), GL_EnableMultitexture(), GL_SetDefaultState(), R_DrawAliasModel(), R_DrawAlphaSurfaces(), R_DrawBrushModel(), R_DrawInlineBModel(), R_DrawSkyBox(), R_DrawSpriteModel(), R_DrawWorld(), and R_RenderBrushPoly().

◆ GL_TextureAlphaMode()

void GL_TextureAlphaMode ( char *  string)

Definition at line 254 of file gl_image.c.

255 {
256  int i;
257 
258  for (i=0 ; i< NUM_GL_ALPHA_MODES ; i++)
259  {
260  if ( !Q_stricmp( gl_alpha_modes[i].name, string ) )
261  break;
262  }
263 
264  if (i == NUM_GL_ALPHA_MODES)
265  {
266  ri.Con_Printf (PRINT_ALL, "bad alpha texture mode name\n");
267  return;
268  }
269 
270  gl_tex_alpha_format = gl_alpha_modes[i].mode;
271 }

Referenced by GL_SetDefaultState(), and R_BeginFrame().

◆ GL_TextureMode()

void GL_TextureMode ( char *  string)

Definition at line 217 of file gl_image.c.

218 {
219  int i;
220  image_t *glt;
221 
222  for (i=0 ; i< NUM_GL_MODES ; i++)
223  {
224  if ( !Q_stricmp( modes[i].name, string ) )
225  break;
226  }
227 
228  if (i == NUM_GL_MODES)
229  {
230  ri.Con_Printf (PRINT_ALL, "bad filter name\n");
231  return;
232  }
233 
234  gl_filter_min = modes[i].minimize;
235  gl_filter_max = modes[i].maximize;
236 
237  // change all the existing mipmap texture objects
238  for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++)
239  {
240  if (glt->type != it_pic && glt->type != it_sky )
241  {
242  GL_Bind (glt->texnum);
243  qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
244  qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
245  }
246  }
247 }

Referenced by GL_SetDefaultState(), and R_BeginFrame().

◆ GL_TextureSolidMode()

void GL_TextureSolidMode ( char *  string)

Definition at line 278 of file gl_image.c.

279 {
280  int i;
281 
282  for (i=0 ; i< NUM_GL_SOLID_MODES ; i++)
283  {
284  if ( !Q_stricmp( gl_solid_modes[i].name, string ) )
285  break;
286  }
287 
288  if (i == NUM_GL_SOLID_MODES)
289  {
290  ri.Con_Printf (PRINT_ALL, "bad solid texture mode name\n");
291  return;
292  }
293 
294  gl_tex_solid_format = gl_solid_modes[i].mode;
295 }

Referenced by GL_SetDefaultState(), and R_BeginFrame().

◆ GL_UpdateSwapInterval()

void GL_UpdateSwapInterval ( void  )

Definition at line 232 of file gl_rmisc.c.

233 {
234  if ( gl_swapinterval->modified )
235  {
236  gl_swapinterval->modified = false;
237 
238  if ( !gl_state.stereo_enabled )
239  {
240 #ifdef _WIN32
241  if ( qwglSwapIntervalEXT )
242  qwglSwapIntervalEXT( gl_swapinterval->value );
243 #endif
244  }
245  }
246 }

Referenced by GL_SetDefaultState(), and R_BeginFrame().

◆ GLimp_AppActivate()

void GLimp_AppActivate ( qboolean  active)

Definition at line 604 of file glw_imp.c.

605 {
606  if ( active )
607  {
608  SetForegroundWindow( glw_state.hWnd );
609  ShowWindow( glw_state.hWnd, SW_RESTORE );
610  }
611  else
612  {
613  if ( vid_fullscreen->value )
614  ShowWindow( glw_state.hWnd, SW_MINIMIZE );
615  }
616 }

Referenced by GetRefAPI().

◆ GLimp_BeginFrame()

void GLimp_BeginFrame ( float  camera_separation)

Definition at line 554 of file glw_imp.c.

555 {
556  if ( gl_bitdepth->modified )
557  {
558  if ( gl_bitdepth->value != 0 && !glw_state.allowdisplaydepthchange )
559  {
560  ri.Cvar_SetValue( "gl_bitdepth", 0 );
561  ri.Con_Printf( PRINT_ALL, "gl_bitdepth requires Win95 OSR2.x or WinNT 4.x\n" );
562  }
563  gl_bitdepth->modified = false;
564  }
565 
566  if ( camera_separation < 0 && gl_state.stereo_enabled )
567  {
568  qglDrawBuffer( GL_BACK_LEFT );
569  }
570  else if ( camera_separation > 0 && gl_state.stereo_enabled )
571  {
572  qglDrawBuffer( GL_BACK_RIGHT );
573  }
574  else
575  {
576  qglDrawBuffer( GL_BACK );
577  }
578 }

Referenced by R_BeginFrame().

◆ GLimp_EnableLogging()

void GLimp_EnableLogging ( qboolean  enable)

Definition at line 3427 of file qgl_win.c.

3428 {
3429  if ( enable )
3430  {
3431  if ( !glw_state.log_fp )
3432  {
3433  struct tm *newtime;
3434  time_t aclock;
3435  char buffer[1024];
3436 
3437  time( &aclock );
3438  newtime = localtime( &aclock );
3439 
3440  asctime( newtime );
3441 
3442  Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", ri.FS_Gamedir() );
3443  glw_state.log_fp = fopen( buffer, "wt" );
3444 
3445  fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
3446  }
3447 
3448  qglAccum = logAccum;
3449  qglAlphaFunc = logAlphaFunc;
3450  qglAreTexturesResident = logAreTexturesResident;
3451  qglArrayElement = logArrayElement;
3452  qglBegin = logBegin;
3453  qglBindTexture = logBindTexture;
3454  qglBitmap = logBitmap;
3455  qglBlendFunc = logBlendFunc;
3456  qglCallList = logCallList;
3457  qglCallLists = logCallLists;
3458  qglClear = logClear;
3459  qglClearAccum = logClearAccum;
3460  qglClearColor = logClearColor;
3461  qglClearDepth = logClearDepth;
3462  qglClearIndex = logClearIndex;
3463  qglClearStencil = logClearStencil;
3464  qglClipPlane = logClipPlane;
3465  qglColor3b = logColor3b;
3466  qglColor3bv = logColor3bv;
3467  qglColor3d = logColor3d;
3468  qglColor3dv = logColor3dv;
3469  qglColor3f = logColor3f;
3470  qglColor3fv = logColor3fv;
3471  qglColor3i = logColor3i;
3472  qglColor3iv = logColor3iv;
3473  qglColor3s = logColor3s;
3474  qglColor3sv = logColor3sv;
3475  qglColor3ub = logColor3ub;
3476  qglColor3ubv = logColor3ubv;
3477  qglColor3ui = logColor3ui;
3478  qglColor3uiv = logColor3uiv;
3479  qglColor3us = logColor3us;
3480  qglColor3usv = logColor3usv;
3481  qglColor4b = logColor4b;
3482  qglColor4bv = logColor4bv;
3483  qglColor4d = logColor4d;
3484  qglColor4dv = logColor4dv;
3485  qglColor4f = logColor4f;
3486  qglColor4fv = logColor4fv;
3487  qglColor4i = logColor4i;
3488  qglColor4iv = logColor4iv;
3489  qglColor4s = logColor4s;
3490  qglColor4sv = logColor4sv;
3491  qglColor4ub = logColor4ub;
3492  qglColor4ubv = logColor4ubv;
3493  qglColor4ui = logColor4ui;
3494  qglColor4uiv = logColor4uiv;
3495  qglColor4us = logColor4us;
3496  qglColor4usv = logColor4usv;
3497  qglColorMask = logColorMask;
3498  qglColorMaterial = logColorMaterial;
3499  qglColorPointer = logColorPointer;
3500  qglCopyPixels = logCopyPixels;
3501  qglCopyTexImage1D = logCopyTexImage1D;
3502  qglCopyTexImage2D = logCopyTexImage2D;
3503  qglCopyTexSubImage1D = logCopyTexSubImage1D;
3504  qglCopyTexSubImage2D = logCopyTexSubImage2D;
3505  qglCullFace = logCullFace;
3506  qglDeleteLists = logDeleteLists ;
3507  qglDeleteTextures = logDeleteTextures ;
3508  qglDepthFunc = logDepthFunc ;
3509  qglDepthMask = logDepthMask ;
3510  qglDepthRange = logDepthRange ;
3511  qglDisable = logDisable ;
3512  qglDisableClientState = logDisableClientState ;
3513  qglDrawArrays = logDrawArrays ;
3514  qglDrawBuffer = logDrawBuffer ;
3515  qglDrawElements = logDrawElements ;
3516  qglDrawPixels = logDrawPixels ;
3517  qglEdgeFlag = logEdgeFlag ;
3518  qglEdgeFlagPointer = logEdgeFlagPointer ;
3519  qglEdgeFlagv = logEdgeFlagv ;
3520  qglEnable = logEnable ;
3521  qglEnableClientState = logEnableClientState ;
3522  qglEnd = logEnd ;
3523  qglEndList = logEndList ;
3524  qglEvalCoord1d = logEvalCoord1d ;
3525  qglEvalCoord1dv = logEvalCoord1dv ;
3526  qglEvalCoord1f = logEvalCoord1f ;
3527  qglEvalCoord1fv = logEvalCoord1fv ;
3528  qglEvalCoord2d = logEvalCoord2d ;
3529  qglEvalCoord2dv = logEvalCoord2dv ;
3530  qglEvalCoord2f = logEvalCoord2f ;
3531  qglEvalCoord2fv = logEvalCoord2fv ;
3532  qglEvalMesh1 = logEvalMesh1 ;
3533  qglEvalMesh2 = logEvalMesh2 ;
3534  qglEvalPoint1 = logEvalPoint1 ;
3535  qglEvalPoint2 = logEvalPoint2 ;
3536  qglFeedbackBuffer = logFeedbackBuffer ;
3537  qglFinish = logFinish ;
3538  qglFlush = logFlush ;
3539  qglFogf = logFogf ;
3540  qglFogfv = logFogfv ;
3541  qglFogi = logFogi ;
3542  qglFogiv = logFogiv ;
3543  qglFrontFace = logFrontFace ;
3544  qglFrustum = logFrustum ;
3545  qglGenLists = logGenLists ;
3546  qglGenTextures = logGenTextures ;
3547  qglGetBooleanv = logGetBooleanv ;
3548  qglGetClipPlane = logGetClipPlane ;
3549  qglGetDoublev = logGetDoublev ;
3550  qglGetError = logGetError ;
3551  qglGetFloatv = logGetFloatv ;
3552  qglGetIntegerv = logGetIntegerv ;
3553  qglGetLightfv = logGetLightfv ;
3554  qglGetLightiv = logGetLightiv ;
3555  qglGetMapdv = logGetMapdv ;
3556  qglGetMapfv = logGetMapfv ;
3557  qglGetMapiv = logGetMapiv ;
3558  qglGetMaterialfv = logGetMaterialfv ;
3559  qglGetMaterialiv = logGetMaterialiv ;
3560  qglGetPixelMapfv = logGetPixelMapfv ;
3561  qglGetPixelMapuiv = logGetPixelMapuiv ;
3562  qglGetPixelMapusv = logGetPixelMapusv ;
3563  qglGetPointerv = logGetPointerv ;
3564  qglGetPolygonStipple = logGetPolygonStipple ;
3565  qglGetString = logGetString ;
3566  qglGetTexEnvfv = logGetTexEnvfv ;
3567  qglGetTexEnviv = logGetTexEnviv ;
3568  qglGetTexGendv = logGetTexGendv ;
3569  qglGetTexGenfv = logGetTexGenfv ;
3570  qglGetTexGeniv = logGetTexGeniv ;
3571  qglGetTexImage = logGetTexImage ;
3572  qglGetTexLevelParameterfv = logGetTexLevelParameterfv ;
3573  qglGetTexLevelParameteriv = logGetTexLevelParameteriv ;
3574  qglGetTexParameterfv = logGetTexParameterfv ;
3575  qglGetTexParameteriv = logGetTexParameteriv ;
3576  qglHint = logHint ;
3577  qglIndexMask = logIndexMask ;
3578  qglIndexPointer = logIndexPointer ;
3579  qglIndexd = logIndexd ;
3580  qglIndexdv = logIndexdv ;
3581  qglIndexf = logIndexf ;
3582  qglIndexfv = logIndexfv ;
3583  qglIndexi = logIndexi ;
3584  qglIndexiv = logIndexiv ;
3585  qglIndexs = logIndexs ;
3586  qglIndexsv = logIndexsv ;
3587  qglIndexub = logIndexub ;
3588  qglIndexubv = logIndexubv ;
3589  qglInitNames = logInitNames ;
3590  qglInterleavedArrays = logInterleavedArrays ;
3591  qglIsEnabled = logIsEnabled ;
3592  qglIsList = logIsList ;
3593  qglIsTexture = logIsTexture ;
3594  qglLightModelf = logLightModelf ;
3595  qglLightModelfv = logLightModelfv ;
3596  qglLightModeli = logLightModeli ;
3597  qglLightModeliv = logLightModeliv ;
3598  qglLightf = logLightf ;
3599  qglLightfv = logLightfv ;
3600  qglLighti = logLighti ;
3601  qglLightiv = logLightiv ;
3602  qglLineStipple = logLineStipple ;
3603  qglLineWidth = logLineWidth ;
3604  qglListBase = logListBase ;
3605  qglLoadIdentity = logLoadIdentity ;
3606  qglLoadMatrixd = logLoadMatrixd ;
3607  qglLoadMatrixf = logLoadMatrixf ;
3608  qglLoadName = logLoadName ;
3609  qglLogicOp = logLogicOp ;
3610  qglMap1d = logMap1d ;
3611  qglMap1f = logMap1f ;
3612  qglMap2d = logMap2d ;
3613  qglMap2f = logMap2f ;
3614  qglMapGrid1d = logMapGrid1d ;
3615  qglMapGrid1f = logMapGrid1f ;
3616  qglMapGrid2d = logMapGrid2d ;
3617  qglMapGrid2f = logMapGrid2f ;
3618  qglMaterialf = logMaterialf ;
3619  qglMaterialfv = logMaterialfv ;
3620  qglMateriali = logMateriali ;
3621  qglMaterialiv = logMaterialiv ;
3622  qglMatrixMode = logMatrixMode ;
3623  qglMultMatrixd = logMultMatrixd ;
3624  qglMultMatrixf = logMultMatrixf ;
3625  qglNewList = logNewList ;
3626  qglNormal3b = logNormal3b ;
3627  qglNormal3bv = logNormal3bv ;
3628  qglNormal3d = logNormal3d ;
3629  qglNormal3dv = logNormal3dv ;
3630  qglNormal3f = logNormal3f ;
3631  qglNormal3fv = logNormal3fv ;
3632  qglNormal3i = logNormal3i ;
3633  qglNormal3iv = logNormal3iv ;
3634  qglNormal3s = logNormal3s ;
3635  qglNormal3sv = logNormal3sv ;
3636  qglNormalPointer = logNormalPointer ;
3637  qglOrtho = logOrtho ;
3638  qglPassThrough = logPassThrough ;
3639  qglPixelMapfv = logPixelMapfv ;
3640  qglPixelMapuiv = logPixelMapuiv ;
3641  qglPixelMapusv = logPixelMapusv ;
3642  qglPixelStoref = logPixelStoref ;
3643  qglPixelStorei = logPixelStorei ;
3644  qglPixelTransferf = logPixelTransferf ;
3645  qglPixelTransferi = logPixelTransferi ;
3646  qglPixelZoom = logPixelZoom ;
3647  qglPointSize = logPointSize ;
3648  qglPolygonMode = logPolygonMode ;
3649  qglPolygonOffset = logPolygonOffset ;
3650  qglPolygonStipple = logPolygonStipple ;
3651  qglPopAttrib = logPopAttrib ;
3652  qglPopClientAttrib = logPopClientAttrib ;
3653  qglPopMatrix = logPopMatrix ;
3654  qglPopName = logPopName ;
3655  qglPrioritizeTextures = logPrioritizeTextures ;
3656  qglPushAttrib = logPushAttrib ;
3657  qglPushClientAttrib = logPushClientAttrib ;
3658  qglPushMatrix = logPushMatrix ;
3659  qglPushName = logPushName ;
3660  qglRasterPos2d = logRasterPos2d ;
3661  qglRasterPos2dv = logRasterPos2dv ;
3662  qglRasterPos2f = logRasterPos2f ;
3663  qglRasterPos2fv = logRasterPos2fv ;
3664  qglRasterPos2i = logRasterPos2i ;
3665  qglRasterPos2iv = logRasterPos2iv ;
3666  qglRasterPos2s = logRasterPos2s ;
3667  qglRasterPos2sv = logRasterPos2sv ;
3668  qglRasterPos3d = logRasterPos3d ;
3669  qglRasterPos3dv = logRasterPos3dv ;
3670  qglRasterPos3f = logRasterPos3f ;
3671  qglRasterPos3fv = logRasterPos3fv ;
3672  qglRasterPos3i = logRasterPos3i ;
3673  qglRasterPos3iv = logRasterPos3iv ;
3674  qglRasterPos3s = logRasterPos3s ;
3675  qglRasterPos3sv = logRasterPos3sv ;
3676  qglRasterPos4d = logRasterPos4d ;
3677  qglRasterPos4dv = logRasterPos4dv ;
3678  qglRasterPos4f = logRasterPos4f ;
3679  qglRasterPos4fv = logRasterPos4fv ;
3680  qglRasterPos4i = logRasterPos4i ;
3681  qglRasterPos4iv = logRasterPos4iv ;
3682  qglRasterPos4s = logRasterPos4s ;
3683  qglRasterPos4sv = logRasterPos4sv ;
3684  qglReadBuffer = logReadBuffer ;
3685  qglReadPixels = logReadPixels ;
3686  qglRectd = logRectd ;
3687  qglRectdv = logRectdv ;
3688  qglRectf = logRectf ;
3689  qglRectfv = logRectfv ;
3690  qglRecti = logRecti ;
3691  qglRectiv = logRectiv ;
3692  qglRects = logRects ;
3693  qglRectsv = logRectsv ;
3694  qglRenderMode = logRenderMode ;
3695  qglRotated = logRotated ;
3696  qglRotatef = logRotatef ;
3697  qglScaled = logScaled ;
3698  qglScalef = logScalef ;
3699  qglScissor = logScissor ;
3700  qglSelectBuffer = logSelectBuffer ;
3701  qglShadeModel = logShadeModel ;
3702  qglStencilFunc = logStencilFunc ;
3703  qglStencilMask = logStencilMask ;
3704  qglStencilOp = logStencilOp ;
3705  qglTexCoord1d = logTexCoord1d ;
3706  qglTexCoord1dv = logTexCoord1dv ;
3707  qglTexCoord1f = logTexCoord1f ;
3708  qglTexCoord1fv = logTexCoord1fv ;
3709  qglTexCoord1i = logTexCoord1i ;
3710  qglTexCoord1iv = logTexCoord1iv ;
3711  qglTexCoord1s = logTexCoord1s ;
3712  qglTexCoord1sv = logTexCoord1sv ;
3713  qglTexCoord2d = logTexCoord2d ;
3714  qglTexCoord2dv = logTexCoord2dv ;
3715  qglTexCoord2f = logTexCoord2f ;
3716  qglTexCoord2fv = logTexCoord2fv ;
3717  qglTexCoord2i = logTexCoord2i ;
3718  qglTexCoord2iv = logTexCoord2iv ;
3719  qglTexCoord2s = logTexCoord2s ;
3720  qglTexCoord2sv = logTexCoord2sv ;
3721  qglTexCoord3d = logTexCoord3d ;
3722  qglTexCoord3dv = logTexCoord3dv ;
3723  qglTexCoord3f = logTexCoord3f ;
3724  qglTexCoord3fv = logTexCoord3fv ;
3725  qglTexCoord3i = logTexCoord3i ;
3726  qglTexCoord3iv = logTexCoord3iv ;
3727  qglTexCoord3s = logTexCoord3s ;
3728  qglTexCoord3sv = logTexCoord3sv ;
3729  qglTexCoord4d = logTexCoord4d ;
3730  qglTexCoord4dv = logTexCoord4dv ;
3731  qglTexCoord4f = logTexCoord4f ;
3732  qglTexCoord4fv = logTexCoord4fv ;
3733  qglTexCoord4i = logTexCoord4i ;
3734  qglTexCoord4iv = logTexCoord4iv ;
3735  qglTexCoord4s = logTexCoord4s ;
3736  qglTexCoord4sv = logTexCoord4sv ;
3737  qglTexCoordPointer = logTexCoordPointer ;
3738  qglTexEnvf = logTexEnvf ;
3739  qglTexEnvfv = logTexEnvfv ;
3740  qglTexEnvi = logTexEnvi ;
3741  qglTexEnviv = logTexEnviv ;
3742  qglTexGend = logTexGend ;
3743  qglTexGendv = logTexGendv ;
3744  qglTexGenf = logTexGenf ;
3745  qglTexGenfv = logTexGenfv ;
3746  qglTexGeni = logTexGeni ;
3747  qglTexGeniv = logTexGeniv ;
3748  qglTexImage1D = logTexImage1D ;
3749  qglTexImage2D = logTexImage2D ;
3750  qglTexParameterf = logTexParameterf ;
3751  qglTexParameterfv = logTexParameterfv ;
3752  qglTexParameteri = logTexParameteri ;
3753  qglTexParameteriv = logTexParameteriv ;
3754  qglTexSubImage1D = logTexSubImage1D ;
3755  qglTexSubImage2D = logTexSubImage2D ;
3756  qglTranslated = logTranslated ;
3757  qglTranslatef = logTranslatef ;
3758  qglVertex2d = logVertex2d ;
3759  qglVertex2dv = logVertex2dv ;
3760  qglVertex2f = logVertex2f ;
3761  qglVertex2fv = logVertex2fv ;
3762  qglVertex2i = logVertex2i ;
3763  qglVertex2iv = logVertex2iv ;
3764  qglVertex2s = logVertex2s ;
3765  qglVertex2sv = logVertex2sv ;
3766  qglVertex3d = logVertex3d ;
3767  qglVertex3dv = logVertex3dv ;
3768  qglVertex3f = logVertex3f ;
3769  qglVertex3fv = logVertex3fv ;
3770  qglVertex3i = logVertex3i ;
3771  qglVertex3iv = logVertex3iv ;
3772  qglVertex3s = logVertex3s ;
3773  qglVertex3sv = logVertex3sv ;
3774  qglVertex4d = logVertex4d ;
3775  qglVertex4dv = logVertex4dv ;
3776  qglVertex4f = logVertex4f ;
3777  qglVertex4fv = logVertex4fv ;
3778  qglVertex4i = logVertex4i ;
3779  qglVertex4iv = logVertex4iv ;
3780  qglVertex4s = logVertex4s ;
3781  qglVertex4sv = logVertex4sv ;
3782  qglVertexPointer = logVertexPointer ;
3783  qglViewport = logViewport ;
3784  }
3785  else
3786  {
3787  qglAccum = dllAccum;
3788  qglAlphaFunc = dllAlphaFunc;
3789  qglAreTexturesResident = dllAreTexturesResident;
3790  qglArrayElement = dllArrayElement;
3791  qglBegin = dllBegin;
3792  qglBindTexture = dllBindTexture;
3793  qglBitmap = dllBitmap;
3794  qglBlendFunc = dllBlendFunc;
3795  qglCallList = dllCallList;
3796  qglCallLists = dllCallLists;
3797  qglClear = dllClear;
3798  qglClearAccum = dllClearAccum;
3799  qglClearColor = dllClearColor;
3800  qglClearDepth = dllClearDepth;
3801  qglClearIndex = dllClearIndex;
3802  qglClearStencil = dllClearStencil;
3803  qglClipPlane = dllClipPlane;
3804  qglColor3b = dllColor3b;
3805  qglColor3bv = dllColor3bv;
3806  qglColor3d = dllColor3d;
3807  qglColor3dv = dllColor3dv;
3808  qglColor3f = dllColor3f;
3809  qglColor3fv = dllColor3fv;
3810  qglColor3i = dllColor3i;
3811  qglColor3iv = dllColor3iv;
3812  qglColor3s = dllColor3s;
3813  qglColor3sv = dllColor3sv;
3814  qglColor3ub = dllColor3ub;
3815  qglColor3ubv = dllColor3ubv;
3816  qglColor3ui = dllColor3ui;
3817  qglColor3uiv = dllColor3uiv;
3818  qglColor3us = dllColor3us;
3819  qglColor3usv = dllColor3usv;
3820  qglColor4b = dllColor4b;
3821  qglColor4bv = dllColor4bv;
3822  qglColor4d = dllColor4d;
3823  qglColor4dv = dllColor4dv;
3824  qglColor4f = dllColor4f;
3825  qglColor4fv = dllColor4fv;
3826  qglColor4i = dllColor4i;
3827  qglColor4iv = dllColor4iv;
3828  qglColor4s = dllColor4s;
3829  qglColor4sv = dllColor4sv;
3830  qglColor4ub = dllColor4ub;
3831  qglColor4ubv = dllColor4ubv;
3832  qglColor4ui = dllColor4ui;
3833  qglColor4uiv = dllColor4uiv;
3834  qglColor4us = dllColor4us;
3835  qglColor4usv = dllColor4usv;
3836  qglColorMask = dllColorMask;
3837  qglColorMaterial = dllColorMaterial;
3838  qglColorPointer = dllColorPointer;
3839  qglCopyPixels = dllCopyPixels;
3840  qglCopyTexImage1D = dllCopyTexImage1D;
3841  qglCopyTexImage2D = dllCopyTexImage2D;
3842  qglCopyTexSubImage1D = dllCopyTexSubImage1D;
3843  qglCopyTexSubImage2D = dllCopyTexSubImage2D;
3844  qglCullFace = dllCullFace;
3845  qglDeleteLists = dllDeleteLists ;
3846  qglDeleteTextures = dllDeleteTextures ;
3847  qglDepthFunc = dllDepthFunc ;
3848  qglDepthMask = dllDepthMask ;
3849  qglDepthRange = dllDepthRange ;
3850  qglDisable = dllDisable ;
3851  qglDisableClientState = dllDisableClientState ;
3852  qglDrawArrays = dllDrawArrays ;
3853  qglDrawBuffer = dllDrawBuffer ;
3854  qglDrawElements = dllDrawElements ;
3855  qglDrawPixels = dllDrawPixels ;
3856  qglEdgeFlag = dllEdgeFlag ;
3857  qglEdgeFlagPointer = dllEdgeFlagPointer ;
3858  qglEdgeFlagv = dllEdgeFlagv ;
3859  qglEnable = dllEnable ;
3860  qglEnableClientState = dllEnableClientState ;
3861  qglEnd = dllEnd ;
3862  qglEndList = dllEndList ;
3863  qglEvalCoord1d = dllEvalCoord1d ;
3864  qglEvalCoord1dv = dllEvalCoord1dv ;
3865  qglEvalCoord1f = dllEvalCoord1f ;
3866  qglEvalCoord1fv = dllEvalCoord1fv ;
3867  qglEvalCoord2d = dllEvalCoord2d ;
3868  qglEvalCoord2dv = dllEvalCoord2dv ;
3869  qglEvalCoord2f = dllEvalCoord2f ;
3870  qglEvalCoord2fv = dllEvalCoord2fv ;
3871  qglEvalMesh1 = dllEvalMesh1 ;
3872  qglEvalMesh2 = dllEvalMesh2 ;
3873  qglEvalPoint1 = dllEvalPoint1 ;
3874  qglEvalPoint2 = dllEvalPoint2 ;
3875  qglFeedbackBuffer = dllFeedbackBuffer ;
3876  qglFinish = dllFinish ;
3877  qglFlush = dllFlush ;
3878  qglFogf = dllFogf ;
3879  qglFogfv = dllFogfv ;
3880  qglFogi = dllFogi ;
3881  qglFogiv = dllFogiv ;
3882  qglFrontFace = dllFrontFace ;
3883  qglFrustum = dllFrustum ;
3884  qglGenLists = dllGenLists ;
3885  qglGenTextures = dllGenTextures ;
3886  qglGetBooleanv = dllGetBooleanv ;
3887  qglGetClipPlane = dllGetClipPlane ;
3888  qglGetDoublev = dllGetDoublev ;
3889  qglGetError = dllGetError ;
3890  qglGetFloatv = dllGetFloatv ;
3891  qglGetIntegerv = dllGetIntegerv ;
3892  qglGetLightfv = dllGetLightfv ;
3893  qglGetLightiv = dllGetLightiv ;
3894  qglGetMapdv = dllGetMapdv ;
3895  qglGetMapfv = dllGetMapfv ;
3896  qglGetMapiv = dllGetMapiv ;
3897  qglGetMaterialfv = dllGetMaterialfv ;
3898  qglGetMaterialiv = dllGetMaterialiv ;
3899  qglGetPixelMapfv = dllGetPixelMapfv ;
3900  qglGetPixelMapuiv = dllGetPixelMapuiv ;
3901  qglGetPixelMapusv = dllGetPixelMapusv ;
3902  qglGetPointerv = dllGetPointerv ;
3903  qglGetPolygonStipple = dllGetPolygonStipple ;
3904  qglGetString = dllGetString ;
3905  qglGetTexEnvfv = dllGetTexEnvfv ;
3906  qglGetTexEnviv = dllGetTexEnviv ;
3907  qglGetTexGendv = dllGetTexGendv ;
3908  qglGetTexGenfv = dllGetTexGenfv ;
3909  qglGetTexGeniv = dllGetTexGeniv ;
3910  qglGetTexImage = dllGetTexImage ;
3911  qglGetTexLevelParameterfv = dllGetTexLevelParameterfv ;
3912  qglGetTexLevelParameteriv = dllGetTexLevelParameteriv ;
3913  qglGetTexParameterfv = dllGetTexParameterfv ;
3914  qglGetTexParameteriv = dllGetTexParameteriv ;
3915  qglHint = dllHint ;
3916  qglIndexMask = dllIndexMask ;
3917  qglIndexPointer = dllIndexPointer ;
3918  qglIndexd = dllIndexd ;
3919  qglIndexdv = dllIndexdv ;
3920  qglIndexf = dllIndexf ;
3921  qglIndexfv = dllIndexfv ;
3922  qglIndexi = dllIndexi ;
3923  qglIndexiv = dllIndexiv ;
3924  qglIndexs = dllIndexs ;
3925  qglIndexsv = dllIndexsv ;
3926  qglIndexub = dllIndexub ;
3927  qglIndexubv = dllIndexubv ;
3928  qglInitNames = dllInitNames ;
3929  qglInterleavedArrays = dllInterleavedArrays ;
3930  qglIsEnabled = dllIsEnabled ;
3931  qglIsList = dllIsList ;
3932  qglIsTexture = dllIsTexture ;
3933  qglLightModelf = dllLightModelf ;
3934  qglLightModelfv = dllLightModelfv ;
3935  qglLightModeli = dllLightModeli ;
3936  qglLightModeliv = dllLightModeliv ;
3937  qglLightf = dllLightf ;
3938  qglLightfv = dllLightfv ;
3939  qglLighti = dllLighti ;
3940  qglLightiv = dllLightiv ;
3941  qglLineStipple = dllLineStipple ;
3942  qglLineWidth = dllLineWidth ;
3943  qglListBase = dllListBase ;
3944  qglLoadIdentity = dllLoadIdentity ;
3945  qglLoadMatrixd = dllLoadMatrixd ;
3946  qglLoadMatrixf = dllLoadMatrixf ;
3947  qglLoadName = dllLoadName ;
3948  qglLogicOp = dllLogicOp ;
3949  qglMap1d = dllMap1d ;
3950  qglMap1f = dllMap1f ;
3951  qglMap2d = dllMap2d ;
3952  qglMap2f = dllMap2f ;
3953  qglMapGrid1d = dllMapGrid1d ;
3954  qglMapGrid1f = dllMapGrid1f ;
3955  qglMapGrid2d = dllMapGrid2d ;
3956  qglMapGrid2f = dllMapGrid2f ;
3957  qglMaterialf = dllMaterialf ;
3958  qglMaterialfv = dllMaterialfv ;
3959  qglMateriali = dllMateriali ;
3960  qglMaterialiv = dllMaterialiv ;
3961  qglMatrixMode = dllMatrixMode ;
3962  qglMultMatrixd = dllMultMatrixd ;
3963  qglMultMatrixf = dllMultMatrixf ;
3964  qglNewList = dllNewList ;
3965  qglNormal3b = dllNormal3b ;
3966  qglNormal3bv = dllNormal3bv ;
3967  qglNormal3d = dllNormal3d ;
3968  qglNormal3dv = dllNormal3dv ;
3969  qglNormal3f = dllNormal3f ;
3970  qglNormal3fv = dllNormal3fv ;
3971  qglNormal3i = dllNormal3i ;
3972  qglNormal3iv = dllNormal3iv ;
3973  qglNormal3s = dllNormal3s ;
3974  qglNormal3sv = dllNormal3sv ;
3975  qglNormalPointer = dllNormalPointer ;
3976  qglOrtho = dllOrtho ;
3977  qglPassThrough = dllPassThrough ;
3978  qglPixelMapfv = dllPixelMapfv ;
3979  qglPixelMapuiv = dllPixelMapuiv ;
3980  qglPixelMapusv = dllPixelMapusv ;
3981  qglPixelStoref = dllPixelStoref ;
3982  qglPixelStorei = dllPixelStorei ;
3983  qglPixelTransferf = dllPixelTransferf ;
3984  qglPixelTransferi = dllPixelTransferi ;
3985  qglPixelZoom = dllPixelZoom ;
3986  qglPointSize = dllPointSize ;
3987  qglPolygonMode = dllPolygonMode ;
3988  qglPolygonOffset = dllPolygonOffset ;
3989  qglPolygonStipple = dllPolygonStipple ;
3990  qglPopAttrib = dllPopAttrib ;
3991  qglPopClientAttrib = dllPopClientAttrib ;
3992  qglPopMatrix = dllPopMatrix ;
3993  qglPopName = dllPopName ;
3994  qglPrioritizeTextures = dllPrioritizeTextures ;
3995  qglPushAttrib = dllPushAttrib ;
3996  qglPushClientAttrib = dllPushClientAttrib ;
3997  qglPushMatrix = dllPushMatrix ;
3998  qglPushName = dllPushName ;
3999  qglRasterPos2d = dllRasterPos2d ;
4000  qglRasterPos2dv = dllRasterPos2dv ;
4001  qglRasterPos2f = dllRasterPos2f ;
4002  qglRasterPos2fv = dllRasterPos2fv ;
4003  qglRasterPos2i = dllRasterPos2i ;
4004  qglRasterPos2iv = dllRasterPos2iv ;
4005  qglRasterPos2s = dllRasterPos2s ;
4006  qglRasterPos2sv = dllRasterPos2sv ;
4007  qglRasterPos3d = dllRasterPos3d ;
4008  qglRasterPos3dv = dllRasterPos3dv ;
4009  qglRasterPos3f = dllRasterPos3f ;
4010  qglRasterPos3fv = dllRasterPos3fv ;
4011  qglRasterPos3i = dllRasterPos3i ;
4012  qglRasterPos3iv = dllRasterPos3iv ;
4013  qglRasterPos3s = dllRasterPos3s ;
4014  qglRasterPos3sv = dllRasterPos3sv ;
4015  qglRasterPos4d = dllRasterPos4d ;
4016  qglRasterPos4dv = dllRasterPos4dv ;
4017  qglRasterPos4f = dllRasterPos4f ;
4018  qglRasterPos4fv = dllRasterPos4fv ;
4019  qglRasterPos4i = dllRasterPos4i ;
4020  qglRasterPos4iv = dllRasterPos4iv ;
4021  qglRasterPos4s = dllRasterPos4s ;
4022  qglRasterPos4sv = dllRasterPos4sv ;
4023  qglReadBuffer = dllReadBuffer ;
4024  qglReadPixels = dllReadPixels ;
4025  qglRectd = dllRectd ;
4026  qglRectdv = dllRectdv ;
4027  qglRectf = dllRectf ;
4028  qglRectfv = dllRectfv ;
4029  qglRecti = dllRecti ;
4030  qglRectiv = dllRectiv ;
4031  qglRects = dllRects ;
4032  qglRectsv = dllRectsv ;
4033  qglRenderMode = dllRenderMode ;
4034  qglRotated = dllRotated ;
4035  qglRotatef = dllRotatef ;
4036  qglScaled = dllScaled ;
4037  qglScalef = dllScalef ;
4038  qglScissor = dllScissor ;
4039  qglSelectBuffer = dllSelectBuffer ;
4040  qglShadeModel = dllShadeModel ;
4041  qglStencilFunc = dllStencilFunc ;
4042  qglStencilMask = dllStencilMask ;
4043  qglStencilOp = dllStencilOp ;
4044  qglTexCoord1d = dllTexCoord1d ;
4045  qglTexCoord1dv = dllTexCoord1dv ;
4046  qglTexCoord1f = dllTexCoord1f ;
4047  qglTexCoord1fv = dllTexCoord1fv ;
4048  qglTexCoord1i = dllTexCoord1i ;
4049  qglTexCoord1iv = dllTexCoord1iv ;
4050  qglTexCoord1s = dllTexCoord1s ;
4051  qglTexCoord1sv = dllTexCoord1sv ;
4052  qglTexCoord2d = dllTexCoord2d ;
4053  qglTexCoord2dv = dllTexCoord2dv ;
4054  qglTexCoord2f = dllTexCoord2f ;
4055  qglTexCoord2fv = dllTexCoord2fv ;
4056  qglTexCoord2i = dllTexCoord2i ;
4057  qglTexCoord2iv = dllTexCoord2iv ;
4058  qglTexCoord2s = dllTexCoord2s ;
4059  qglTexCoord2sv = dllTexCoord2sv ;
4060  qglTexCoord3d = dllTexCoord3d ;
4061  qglTexCoord3dv = dllTexCoord3dv ;
4062  qglTexCoord3f = dllTexCoord3f ;
4063  qglTexCoord3fv = dllTexCoord3fv ;
4064  qglTexCoord3i = dllTexCoord3i ;
4065  qglTexCoord3iv = dllTexCoord3iv ;
4066  qglTexCoord3s = dllTexCoord3s ;
4067  qglTexCoord3sv = dllTexCoord3sv ;
4068  qglTexCoord4d = dllTexCoord4d ;
4069  qglTexCoord4dv = dllTexCoord4dv ;
4070  qglTexCoord4f = dllTexCoord4f ;
4071  qglTexCoord4fv = dllTexCoord4fv ;
4072  qglTexCoord4i = dllTexCoord4i ;
4073  qglTexCoord4iv = dllTexCoord4iv ;
4074  qglTexCoord4s = dllTexCoord4s ;
4075  qglTexCoord4sv = dllTexCoord4sv ;
4076  qglTexCoordPointer = dllTexCoordPointer ;
4077  qglTexEnvf = dllTexEnvf ;
4078  qglTexEnvfv = dllTexEnvfv ;
4079  qglTexEnvi = dllTexEnvi ;
4080  qglTexEnviv = dllTexEnviv ;
4081  qglTexGend = dllTexGend ;
4082  qglTexGendv = dllTexGendv ;
4083  qglTexGenf = dllTexGenf ;
4084  qglTexGenfv = dllTexGenfv ;
4085  qglTexGeni = dllTexGeni ;
4086  qglTexGeniv = dllTexGeniv ;
4087  qglTexImage1D = dllTexImage1D ;
4088  qglTexImage2D = dllTexImage2D ;
4089  qglTexParameterf = dllTexParameterf ;
4090  qglTexParameterfv = dllTexParameterfv ;
4091  qglTexParameteri = dllTexParameteri ;
4092  qglTexParameteriv = dllTexParameteriv ;
4093  qglTexSubImage1D = dllTexSubImage1D ;
4094  qglTexSubImage2D = dllTexSubImage2D ;
4095  qglTranslated = dllTranslated ;
4096  qglTranslatef = dllTranslatef ;
4097  qglVertex2d = dllVertex2d ;
4098  qglVertex2dv = dllVertex2dv ;
4099  qglVertex2f = dllVertex2f ;
4100  qglVertex2fv = dllVertex2fv ;
4101  qglVertex2i = dllVertex2i ;
4102  qglVertex2iv = dllVertex2iv ;
4103  qglVertex2s = dllVertex2s ;
4104  qglVertex2sv = dllVertex2sv ;
4105  qglVertex3d = dllVertex3d ;
4106  qglVertex3dv = dllVertex3dv ;
4107  qglVertex3f = dllVertex3f ;
4108  qglVertex3fv = dllVertex3fv ;
4109  qglVertex3i = dllVertex3i ;
4110  qglVertex3iv = dllVertex3iv ;
4111  qglVertex3s = dllVertex3s ;
4112  qglVertex3sv = dllVertex3sv ;
4113  qglVertex4d = dllVertex4d ;
4114  qglVertex4dv = dllVertex4dv ;
4115  qglVertex4f = dllVertex4f ;
4116  qglVertex4fv = dllVertex4fv ;
4117  qglVertex4i = dllVertex4i ;
4118  qglVertex4iv = dllVertex4iv ;
4119  qglVertex4s = dllVertex4s ;
4120  qglVertex4sv = dllVertex4sv ;
4121  qglVertexPointer = dllVertexPointer ;
4122  qglViewport = dllViewport ;
4123  }
4124 }

Referenced by R_BeginFrame().

◆ GLimp_EndFrame()

void GLimp_EndFrame ( void  )

Definition at line 587 of file glw_imp.c.

588 {
589  int err;
590 
591  err = qglGetError();
592  assert( err == GL_NO_ERROR );
593 
594  if ( stricmp( gl_drawbuffer->string, "GL_BACK" ) == 0 )
595  {
596  if ( !qwglSwapBuffers( glw_state.hDC ) )
597  ri.Sys_Error( ERR_FATAL, "GLimp_EndFrame() - SwapBuffers() failed!\n" );
598  }
599 }

Referenced by GetRefAPI().

◆ GLimp_Init()

int GLimp_Init ( void *  hinstance,
void *  hWnd 
)

Definition at line 347 of file glw_imp.c.

348 {
349 #define OSR2_BUILD_NUMBER 1111
350 
351  OSVERSIONINFO vinfo;
352 
353  vinfo.dwOSVersionInfoSize = sizeof(vinfo);
354 
355  glw_state.allowdisplaydepthchange = false;
356 
357  if ( GetVersionEx( &vinfo) )
358  {
359  if ( vinfo.dwMajorVersion > 4 )
360  {
361  glw_state.allowdisplaydepthchange = true;
362  }
363  else if ( vinfo.dwMajorVersion == 4 )
364  {
365  if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
366  {
367  glw_state.allowdisplaydepthchange = true;
368  }
369  else if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
370  {
371  if ( LOWORD( vinfo.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
372  {
373  glw_state.allowdisplaydepthchange = true;
374  }
375  }
376  }
377  }
378  else
379  {
380  ri.Con_Printf( PRINT_ALL, "GLimp_Init() - GetVersionEx failed\n" );
381  return false;
382  }
383 
384  glw_state.hInstance = ( HINSTANCE ) hinstance;
385  glw_state.wndproc = wndproc;
386 
387  return true;
388 }

Referenced by R_Init().

◆ GLimp_LogNewFrame()

void GLimp_LogNewFrame ( void  )

Definition at line 4127 of file qgl_win.c.

4128 {
4129  fprintf( glw_state.log_fp, "*** R_BeginFrame ***\n" );
4130 }

Referenced by R_BeginFrame().

◆ GLimp_SetMode()

int GLimp_SetMode ( int *  pwidth,
int *  pheight,
int  mode,
qboolean  fullscreen 
)

Definition at line 159 of file glw_imp.c.

160 {
161  int width, height;
162  const char *win_fs[] = { "W", "FS" };
163 
164  ri.Con_Printf( PRINT_ALL, "Initializing OpenGL display\n");
165 
166  ri.Con_Printf (PRINT_ALL, "...setting mode %d:", mode );
167 
168  if ( !ri.Vid_GetModeInfo( &width, &height, mode ) )
169  {
170  ri.Con_Printf( PRINT_ALL, " invalid mode\n" );
171  return rserr_invalid_mode;
172  }
173 
174  ri.Con_Printf( PRINT_ALL, " %d %d %s\n", width, height, win_fs[fullscreen] );
175 
176  // destroy the existing window
177  if (glw_state.hWnd)
178  {
179  GLimp_Shutdown ();
180  }
181 
182  // do a CDS if needed
183  if ( fullscreen )
184  {
185  DEVMODE dm;
186 
187  ri.Con_Printf( PRINT_ALL, "...attempting fullscreen\n" );
188 
189  memset( &dm, 0, sizeof( dm ) );
190 
191  dm.dmSize = sizeof( dm );
192 
193  dm.dmPelsWidth = width;
194  dm.dmPelsHeight = height;
195  dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
196 
197  if ( gl_bitdepth->value != 0 )
198  {
199  dm.dmBitsPerPel = gl_bitdepth->value;
200  dm.dmFields |= DM_BITSPERPEL;
201  ri.Con_Printf( PRINT_ALL, "...using gl_bitdepth of %d\n", ( int ) gl_bitdepth->value );
202  }
203  else
204  {
205  HDC hdc = GetDC( NULL );
206  int bitspixel = GetDeviceCaps( hdc, BITSPIXEL );
207 
208  ri.Con_Printf( PRINT_ALL, "...using desktop display depth of %d\n", bitspixel );
209 
210  ReleaseDC( 0, hdc );
211  }
212 
213  ri.Con_Printf( PRINT_ALL, "...calling CDS: " );
214  if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
215  {
216  *pwidth = width;
217  *pheight = height;
218 
219  gl_state.fullscreen = true;
220 
221  ri.Con_Printf( PRINT_ALL, "ok\n" );
222 
223  if ( !VID_CreateWindow (width, height, true) )
224  return rserr_invalid_mode;
225 
226  return rserr_ok;
227  }
228  else
229  {
230  *pwidth = width;
231  *pheight = height;
232 
233  ri.Con_Printf( PRINT_ALL, "failed\n" );
234 
235  ri.Con_Printf( PRINT_ALL, "...calling CDS assuming dual monitors:" );
236 
237  dm.dmPelsWidth = width * 2;
238  dm.dmPelsHeight = height;
239  dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
240 
241  if ( gl_bitdepth->value != 0 )
242  {
243  dm.dmBitsPerPel = gl_bitdepth->value;
244  dm.dmFields |= DM_BITSPERPEL;
245  }
246 
247  /*
248  ** our first CDS failed, so maybe we're running on some weird dual monitor
249  ** system
250  */
251  if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
252  {
253  ri.Con_Printf( PRINT_ALL, " failed\n" );
254 
255  ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
256 
257  ChangeDisplaySettings( 0, 0 );
258 
259  *pwidth = width;
260  *pheight = height;
261  gl_state.fullscreen = false;
262  if ( !VID_CreateWindow (width, height, false) )
263  return rserr_invalid_mode;
264  return rserr_invalid_fullscreen;
265  }
266  else
267  {
268  ri.Con_Printf( PRINT_ALL, " ok\n" );
269  if ( !VID_CreateWindow (width, height, true) )
270  return rserr_invalid_mode;
271 
272  gl_state.fullscreen = true;
273  return rserr_ok;
274  }
275  }
276  }
277  else
278  {
279  ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
280 
281  ChangeDisplaySettings( 0, 0 );
282 
283  *pwidth = width;
284  *pheight = height;
285  gl_state.fullscreen = false;
286  if ( !VID_CreateWindow (width, height, false) )
287  return rserr_invalid_mode;
288  }
289 
290  return rserr_ok;
291 }

Referenced by R_SetMode().

◆ GLimp_Shutdown()

void GLimp_Shutdown ( void  )

Definition at line 302 of file glw_imp.c.

303 {
304  if ( qwglMakeCurrent && !qwglMakeCurrent( NULL, NULL ) )
305  ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - wglMakeCurrent failed\n");
306  if ( glw_state.hGLRC )
307  {
308  if ( qwglDeleteContext && !qwglDeleteContext( glw_state.hGLRC ) )
309  ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - wglDeleteContext failed\n");
310  glw_state.hGLRC = NULL;
311  }
312  if (glw_state.hDC)
313  {
314  if ( !ReleaseDC( glw_state.hWnd, glw_state.hDC ) )
315  ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - ReleaseDC failed\n" );
316  glw_state.hDC = NULL;
317  }
318  if (glw_state.hWnd)
319  {
320  DestroyWindow ( glw_state.hWnd );
321  glw_state.hWnd = NULL;
322  }
323 
324  if ( glw_state.log_fp )
325  {
326  fclose( glw_state.log_fp );
327  glw_state.log_fp = 0;
328  }
329 
330  UnregisterClass (WINDOW_CLASS_NAME, glw_state.hInstance);
331 
332  if ( gl_state.fullscreen )
333  {
334  ChangeDisplaySettings( 0, 0 );
335  gl_state.fullscreen = false;
336  }
337 }

Referenced by GLimp_SetMode(), and R_Shutdown().

◆ LoadPCX()

void LoadPCX ( char *  filename,
byte **  pic,
byte **  palette,
int *  width,
int *  height 
)

Definition at line 87 of file r_image.c.

88 {
89  byte *raw;
90  pcx_t *pcx;
91  int x, y;
92  int len;
93  int dataByte, runLength;
94  byte *out, *pix;
95 
96  *pic = NULL;
97 
98  //
99  // load the file
100  //
101  len = ri.FS_LoadFile (filename, (void **)&raw);
102  if (!raw)
103  {
104  ri.Con_Printf (PRINT_DEVELOPER, "Bad pcx file %s\n", filename);
105  return;
106  }
107 
108  //
109  // parse the PCX file
110  //
111  pcx = (pcx_t *)raw;
112 
113  pcx->xmin = LittleShort(pcx->xmin);
114  pcx->ymin = LittleShort(pcx->ymin);
115  pcx->xmax = LittleShort(pcx->xmax);
116  pcx->ymax = LittleShort(pcx->ymax);
117  pcx->hres = LittleShort(pcx->hres);
118  pcx->vres = LittleShort(pcx->vres);
119  pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
120  pcx->palette_type = LittleShort(pcx->palette_type);
121 
122  raw = &pcx->data;
123 
124  if (pcx->manufacturer != 0x0a
125  || pcx->version != 5
126  || pcx->encoding != 1
127  || pcx->bits_per_pixel != 8
128  || pcx->xmax >= 640
129  || pcx->ymax >= 480)
130  {
131  ri.Con_Printf (PRINT_ALL, "Bad pcx file %s\n", filename);
132  return;
133  }
134 
135  out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
136 
137  *pic = out;
138 
139  pix = out;
140 
141  if (palette)
142  {
143  *palette = malloc(768);
144  memcpy (*palette, (byte *)pcx + len - 768, 768);
145  }
146 
147  if (width)
148  *width = pcx->xmax+1;
149  if (height)
150  *height = pcx->ymax+1;
151 
152  for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
153  {
154  for (x=0 ; x<=pcx->xmax ; )
155  {
156  dataByte = *raw++;
157 
158  if((dataByte & 0xC0) == 0xC0)
159  {
160  runLength = dataByte & 0x3F;
161  dataByte = *raw++;
162  }
163  else
164  runLength = 1;
165 
166  while(runLength-- > 0)
167  pix[x++] = dataByte;
168  }
169 
170  }
171 
172  if ( raw - (byte *)pcx > len)
173  {
174  ri.Con_Printf (PRINT_DEVELOPER, "PCX file %s was malformed", filename);
175  free (*pic);
176  *pic = NULL;
177  }
178 
179  ri.FS_FreeFile (pcx);
180 }

Referenced by Draw_GetPalette(), GL_FindImage(), and R_FindImage().

◆ R_AddSkySurface()

void R_AddSkySurface ( msurface_t *  fa)

Definition at line 485 of file gl_warp.c.

486 {
487  int i;
488  vec3_t verts[MAX_CLIP_VERTS];
489  glpoly_t *p;
490 
491  // calculate vertex values for sky box
492  for (p=fa->polys ; p ; p=p->next)
493  {
494  for (i=0 ; i<p->numverts ; i++)
495  {
496  VectorSubtract (p->verts[i], r_origin, verts[i]);
497  }
498  ClipSkyPolygon (p->numverts, verts[0], 0);
499  }
500 }

Referenced by R_RecursiveWorldNode().

◆ R_BeginFrame()

void R_BeginFrame ( float  camera_separation)

Definition at line 1099 of file r_main.c.

1100 {
1101  extern void Draw_BuildGammaTable( void );
1102 #ifdef REDBLUE
1103  SetStereoBuffer((camera_separation <= 0.0) ? 0 : 1);
1104 #endif
1105  /*
1106  ** rebuild the gamma correction palette if necessary
1107  */
1108  if ( vid_gamma->modified )
1109  {
1110  Draw_BuildGammaTable();
1111  R_GammaCorrectAndSetPalette( ( const unsigned char * ) d_8to24table );
1112 
1113  vid_gamma->modified = false;
1114  }
1115 
1116  while ( sw_mode->modified || vid_fullscreen->modified )
1117  {
1118  rserr_t err;
1119 
1120  /*
1121  ** if this returns rserr_invalid_fullscreen then it set the mode but not as a
1122  ** fullscreen mode, e.g. 320x200 on a system that doesn't support that res
1123  */
1124  if ( ( err = SWimp_SetMode( &vid.width, &vid.height, sw_mode->value, vid_fullscreen->value ) ) == rserr_ok )
1125  {
1126  R_InitGraphics( vid.width, vid.height );
1127 
1128  sw_state.prev_mode = sw_mode->value;
1129  vid_fullscreen->modified = false;
1130  sw_mode->modified = false;
1131  }
1132  else
1133  {
1134  if ( err == rserr_invalid_mode )
1135  {
1136  ri.Cvar_SetValue( "sw_mode", sw_state.prev_mode );
1137  ri.Con_Printf( PRINT_ALL, "ref_soft::R_BeginFrame() - could not set mode\n" );
1138  }
1139  else if ( err == rserr_invalid_fullscreen )
1140  {
1141  R_InitGraphics( vid.width, vid.height );
1142 
1143  ri.Cvar_SetValue( "vid_fullscreen", 0);
1144  ri.Con_Printf( PRINT_ALL, "ref_soft::R_BeginFrame() - fullscreen unavailable in this mode\n" );
1145  sw_state.prev_mode = sw_mode->value;
1146 // vid_fullscreen->modified = false;
1147 // sw_mode->modified = false;
1148  }
1149  else
1150  {
1151  ri.Sys_Error( ERR_FATAL, "ref_soft::R_BeginFrame() - catastrophic mode change failure\n" );
1152  }
1153  }
1154  }
1155 }

Referenced by GetRefAPI(), and R_Init().

◆ R_ClearSkyBox()

void R_ClearSkyBox ( void  )

Definition at line 508 of file gl_warp.c.

509 {
510  int i;
511 
512  for (i=0 ; i<6 ; i++)
513  {
514  skymins[0][i] = skymins[1][i] = 9999;
515  skymaxs[0][i] = skymaxs[1][i] = -9999;
516  }
517 }

Referenced by R_DrawWorld().

◆ R_CullBox()

qboolean R_CullBox ( vec3_t  mins,
vec3_t  maxs 
)

Definition at line 146 of file gl_rmain.c.

147 {
148  int i;
149 
150  if (r_nocull->value)
151  return false;
152 
153  for (i=0 ; i<4 ; i++)
154  if ( BOX_ON_PLANE_SIDE(mins, maxs, &frustum[i]) == 2)
155  return true;
156  return false;
157 }

Referenced by R_DrawBrushModel(), and R_RecursiveWorldNode().

◆ R_DrawAliasModel()

void R_DrawAliasModel ( entity_t *  e)

Definition at line 534 of file gl_mesh.c.

535 {
536  int i;
537  dmdl_t *paliashdr;
538  float an;
539  vec3_t bbox[8];
540  image_t *skin;
541 
542  if ( !( e->flags & RF_WEAPONMODEL ) )
543  {
544  if ( R_CullAliasModel( bbox, e ) )
545  return;
546  }
547 
548  if ( e->flags & RF_WEAPONMODEL )
549  {
550  if ( r_lefthand->value == 2 )
551  return;
552  }
553 
554  paliashdr = (dmdl_t *)currentmodel->extradata;
555 
556  //
557  // get lighting information
558  //
559  // PMM - rewrote, reordered to handle new shells & mixing
560  // PMM - 3.20 code .. replaced with original way of doing it to keep mod authors happy
561  //
562  if ( currententity->flags & ( RF_SHELL_HALF_DAM | RF_SHELL_GREEN | RF_SHELL_RED | RF_SHELL_BLUE | RF_SHELL_DOUBLE ) )
563  {
564  VectorClear (shadelight);
565  if (currententity->flags & RF_SHELL_HALF_DAM)
566  {
567  shadelight[0] = 0.56;
568  shadelight[1] = 0.59;
569  shadelight[2] = 0.45;
570  }
571  if ( currententity->flags & RF_SHELL_DOUBLE )
572  {
573  shadelight[0] = 0.9;
574  shadelight[1] = 0.7;
575  }
576  if ( currententity->flags & RF_SHELL_RED )
577  shadelight[0] = 1.0;
578  if ( currententity->flags & RF_SHELL_GREEN )
579  shadelight[1] = 1.0;
580  if ( currententity->flags & RF_SHELL_BLUE )
581  shadelight[2] = 1.0;
582  }
583 /*
584  // PMM -special case for godmode
585  if ( (currententity->flags & RF_SHELL_RED) &&
586  (currententity->flags & RF_SHELL_BLUE) &&
587  (currententity->flags & RF_SHELL_GREEN) )
588  {
589  for (i=0 ; i<3 ; i++)
590  shadelight[i] = 1.0;
591  }
592  else if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_BLUE | RF_SHELL_DOUBLE ) )
593  {
594  VectorClear (shadelight);
595 
596  if ( currententity->flags & RF_SHELL_RED )
597  {
598  shadelight[0] = 1.0;
599  if (currententity->flags & (RF_SHELL_BLUE|RF_SHELL_DOUBLE) )
600  shadelight[2] = 1.0;
601  }
602  else if ( currententity->flags & RF_SHELL_BLUE )
603  {
604  if ( currententity->flags & RF_SHELL_DOUBLE )
605  {
606  shadelight[1] = 1.0;
607  shadelight[2] = 1.0;
608  }
609  else
610  {
611  shadelight[2] = 1.0;
612  }
613  }
614  else if ( currententity->flags & RF_SHELL_DOUBLE )
615  {
616  shadelight[0] = 0.9;
617  shadelight[1] = 0.7;
618  }
619  }
620  else if ( currententity->flags & ( RF_SHELL_HALF_DAM | RF_SHELL_GREEN ) )
621  {
622  VectorClear (shadelight);
623  // PMM - new colors
624  if ( currententity->flags & RF_SHELL_HALF_DAM )
625  {
626  shadelight[0] = 0.56;
627  shadelight[1] = 0.59;
628  shadelight[2] = 0.45;
629  }
630  if ( currententity->flags & RF_SHELL_GREEN )
631  {
632  shadelight[1] = 1.0;
633  }
634  }
635  }
636  //PMM - ok, now flatten these down to range from 0 to 1.0.
637  // max_shell_val = max(shadelight[0], max(shadelight[1], shadelight[2]));
638  // if (max_shell_val > 0)
639  // {
640  // for (i=0; i<3; i++)
641  // {
642  // shadelight[i] = shadelight[i] / max_shell_val;
643  // }
644  // }
645  // pmm
646 */
647  else if ( currententity->flags & RF_FULLBRIGHT )
648  {
649  for (i=0 ; i<3 ; i++)
650  shadelight[i] = 1.0;
651  }
652  else
653  {
654  R_LightPoint (currententity->origin, shadelight);
655 
656  // player lighting hack for communication back to server
657  // big hack!
658  if ( currententity->flags & RF_WEAPONMODEL )
659  {
660  // pick the greatest component, which should be the same
661  // as the mono value returned by software
662  if (shadelight[0] > shadelight[1])
663  {
664  if (shadelight[0] > shadelight[2])
665  r_lightlevel->value = 150*shadelight[0];
666  else
667  r_lightlevel->value = 150*shadelight[2];
668  }
669  else
670  {
671  if (shadelight[1] > shadelight[2])
672  r_lightlevel->value = 150*shadelight[1];
673  else
674  r_lightlevel->value = 150*shadelight[2];
675  }
676 
677  }
678 
679  if ( gl_monolightmap->string[0] != '0' )
680  {
681  float s = shadelight[0];
682 
683  if ( s < shadelight[1] )
684  s = shadelight[1];
685  if ( s < shadelight[2] )
686  s = shadelight[2];
687 
688  shadelight[0] = s;
689  shadelight[1] = s;
690  shadelight[2] = s;
691  }
692  }
693 
694  if ( currententity->flags & RF_MINLIGHT )
695  {
696  for (i=0 ; i<3 ; i++)
697  if (shadelight[i] > 0.1)
698  break;
699  if (i == 3)
700  {
701  shadelight[0] = 0.1;
702  shadelight[1] = 0.1;
703  shadelight[2] = 0.1;
704  }
705  }
706 
707  if ( currententity->flags & RF_GLOW )
708  { // bonus items will pulse with time
709  float scale;
710  float min;
711 
712  scale = 0.1 * sin(r_newrefdef.time*7);
713  for (i=0 ; i<3 ; i++)
714  {
715  min = shadelight[i] * 0.8;
716  shadelight[i] += scale;
717  if (shadelight[i] < min)
718  shadelight[i] = min;
719  }
720  }
721 
722 // =================
723 // PGM ir goggles color override
724  if ( r_newrefdef.rdflags & RDF_IRGOGGLES && currententity->flags & RF_IR_VISIBLE)
725  {
726  shadelight[0] = 1.0;
727  shadelight[1] = 0.0;
728  shadelight[2] = 0.0;
729  }
730 // PGM
731 // =================
732 
733  shadedots = r_avertexnormal_dots[((int)(currententity->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)];
734 
735  an = currententity->angles[1]/180*M_PI;
736  shadevector[0] = cos(-an);
737  shadevector[1] = sin(-an);
738  shadevector[2] = 1;
739  VectorNormalize (shadevector);
740 
741  //
742  // locate the proper data
743  //
744 
745  c_alias_polys += paliashdr->num_tris;
746 
747  //
748  // draw all the triangles
749  //
750  if (currententity->flags & RF_DEPTHHACK) // hack the depth range to prevent view model from poking into walls
751  qglDepthRange (gldepthmin, gldepthmin + 0.3*(gldepthmax-gldepthmin));
752 
753  if ( ( currententity->flags & RF_WEAPONMODEL ) && ( r_lefthand->value == 1.0F ) )
754  {
755  extern void MYgluPerspective( GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar );
756 
757  qglMatrixMode( GL_PROJECTION );
758  qglPushMatrix();
759  qglLoadIdentity();
760  qglScalef( -1, 1, 1 );
761  MYgluPerspective( r_newrefdef.fov_y, ( float ) r_newrefdef.width / r_newrefdef.height, 4, 4096);
762  qglMatrixMode( GL_MODELVIEW );
763 
764  qglCullFace( GL_BACK );
765  }
766 
767  qglPushMatrix ();
768  e->angles[PITCH] = -e->angles[PITCH]; // sigh.
769  R_RotateForEntity (e);
770  e->angles[PITCH] = -e->angles[PITCH]; // sigh.
771 
772  // select skin
773  if (currententity->skin)
774  skin = currententity->skin; // custom player skin
775  else
776  {
777  if (currententity->skinnum >= MAX_MD2SKINS)
778  skin = currentmodel->skins[0];
779  else
780  {
781  skin = currentmodel->skins[currententity->skinnum];
782  if (!skin)
783  skin = currentmodel->skins[0];
784  }
785  }
786  if (!skin)
787  skin = r_notexture; // fallback...
788  GL_Bind(skin->texnum);
789 
790  // draw it
791 
792  qglShadeModel (GL_SMOOTH);
793 
794  GL_TexEnv( GL_MODULATE );
795  if ( currententity->flags & RF_TRANSLUCENT )
796  {
797  qglEnable (GL_BLEND);
798  }
799 
800 
801  if ( (currententity->frame >= paliashdr->num_frames)
802  || (currententity->frame < 0) )
803  {
804  ri.Con_Printf (PRINT_ALL, "R_DrawAliasModel %s: no such frame %d\n",
805  currentmodel->name, currententity->frame);
806  currententity->frame = 0;
807  currententity->oldframe = 0;
808  }
809 
810  if ( (currententity->oldframe >= paliashdr->num_frames)
811  || (currententity->oldframe < 0))
812  {
813  ri.Con_Printf (PRINT_ALL, "R_DrawAliasModel %s: no such oldframe %d\n",
814  currentmodel->name, currententity->oldframe);
815  currententity->frame = 0;
816  currententity->oldframe = 0;
817  }
818 
819  if ( !r_lerpmodels->value )
820  currententity->backlerp = 0;
821  GL_DrawAliasFrameLerp (paliashdr, currententity->backlerp);
822 
823  GL_TexEnv( GL_REPLACE );
824  qglShadeModel (GL_FLAT);
825 
826  qglPopMatrix ();
827 
828 #if 0
829  qglDisable( GL_CULL_FACE );
830  qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
831  qglDisable( GL_TEXTURE_2D );
832  qglBegin( GL_TRIANGLE_STRIP );
833  for ( i = 0; i < 8; i++ )
834  {
835  qglVertex3fv( bbox[i] );
836  }
837  qglEnd();
838  qglEnable( GL_TEXTURE_2D );
839  qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
840  qglEnable( GL_CULL_FACE );
841 #endif
842 
843  if ( ( currententity->flags & RF_WEAPONMODEL ) && ( r_lefthand->value == 1.0F ) )
844  {
845  qglMatrixMode( GL_PROJECTION );
846  qglPopMatrix();
847  qglMatrixMode( GL_MODELVIEW );
848  qglCullFace( GL_FRONT );
849  }
850 
851  if ( currententity->flags & RF_TRANSLUCENT )
852  {
853  qglDisable (GL_BLEND);
854  }
855 
856  if (currententity->flags & RF_DEPTHHACK)
857  qglDepthRange (gldepthmin, gldepthmax);
858 
859 //#if 1
860  if (gl_shadows->value &&
861  !(currententity->flags & (RF_TRANSLUCENT|RF_WEAPONMODEL|RF_NOSHADOW))) {
862  qglPushMatrix ();
863 
864  /* don't rotate shadows on ungodly axes */
865  qglTranslatef(e->origin[0], e->origin[1], e->origin[2]);
866  qglRotatef(e->angles[1], 0, 0, 1);
867 
868  qglDisable (GL_TEXTURE_2D);
869  qglEnable (GL_BLEND);
870  qglColor4f (0,0,0,0.5);
871  GL_DrawAliasShadow (paliashdr, currententity->frame );
872  qglEnable (GL_TEXTURE_2D);
873  qglDisable (GL_BLEND);
874  qglPopMatrix ();
875  }
876 //#endif
877  qglColor4f (1,1,1,1);
878 }

Referenced by R_DrawEntitiesOnList().

◆ R_DrawAlphaSurfaces()

void R_DrawAlphaSurfaces ( void  )

Definition at line 1192 of file r_poly.c.

1193 {
1194  msurface_t *s = r_alpha_surfaces;
1195 
1196  currentmodel = r_worldmodel;
1197 
1198  modelorg[0] = -r_origin[0];
1199  modelorg[1] = -r_origin[1];
1200  modelorg[2] = -r_origin[2];
1201 
1202  while ( s )
1203  {
1204  R_BuildPolygonFromSurface( s );
1205 
1206 //=======
1207 //PGM
1208 // if (s->texinfo->flags & SURF_TRANS66)
1209 // R_ClipAndDrawPoly( 0.60f, ( s->texinfo->flags & SURF_WARP) != 0, true );
1210 // else
1211 // R_ClipAndDrawPoly( 0.30f, ( s->texinfo->flags & SURF_WARP) != 0, true );
1212 
1213  // PGM - pass down all the texinfo flags, not just SURF_WARP.
1214  if (s->texinfo->flags & SURF_TRANS66)
1215  R_ClipAndDrawPoly( 0.60f, (s->texinfo->flags & (SURF_WARP|SURF_FLOWING)), true );
1216  else
1217  R_ClipAndDrawPoly( 0.30f, (s->texinfo->flags & (SURF_WARP|SURF_FLOWING)), true );
1218 //PGM
1219 //=======
1220 
1221  s = s->nextalphasurface;
1222  }
1223 
1224  r_alpha_surfaces = NULL;
1225 }

◆ R_DrawBeam()

void R_DrawBeam ( entity_t *  e)

Definition at line 1245 of file r_main.c.

1246 {
1247 #define NUM_BEAM_SEGS 6
1248 
1249  int i;
1250 
1251  vec3_t perpvec;
1252  vec3_t direction, normalized_direction;
1253  vec3_t start_points[NUM_BEAM_SEGS], end_points[NUM_BEAM_SEGS];
1254  vec3_t oldorigin, origin;
1255 
1256  oldorigin[0] = e->oldorigin[0];
1257  oldorigin[1] = e->oldorigin[1];
1258  oldorigin[2] = e->oldorigin[2];
1259 
1260  origin[0] = e->origin[0];
1261  origin[1] = e->origin[1];
1262  origin[2] = e->origin[2];
1263 
1264  normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
1265  normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
1266  normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];
1267 
1268  if ( VectorNormalize( normalized_direction ) == 0 )
1269  return;
1270 
1271  PerpendicularVector( perpvec, normalized_direction );
1272  VectorScale( perpvec, e->frame / 2, perpvec );
1273 
1274  for ( i = 0; i < NUM_BEAM_SEGS; i++ )
1275  {
1276  RotatePointAroundVector( start_points[i], normalized_direction, perpvec, (360.0/NUM_BEAM_SEGS)*i );
1277  VectorAdd( start_points[i], origin, start_points[i] );
1278  VectorAdd( start_points[i], direction, end_points[i] );
1279  }
1280 
1281  for ( i = 0; i < NUM_BEAM_SEGS; i++ )
1282  {
1283  R_IMFlatShadedQuad( start_points[i],
1284  end_points[i],
1285  end_points[(i+1)%NUM_BEAM_SEGS],
1286  start_points[(i+1)%NUM_BEAM_SEGS],
1287  e->skinnum & 0xFF,
1288  e->alpha );
1289  }
1290 }

Referenced by R_DrawEntitiesOnList().

◆ R_DrawBrushModel()

void R_DrawBrushModel ( entity_t *  e)

Definition at line 964 of file gl_rsurf.c.

965 {
966  vec3_t mins, maxs;
967  int i;
968  qboolean rotated;
969 
970  if (currentmodel->nummodelsurfaces == 0)
971  return;
972 
973  currententity = e;
974  gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
975 
976  if (e->angles[0] || e->angles[1] || e->angles[2])
977  {
978  rotated = true;
979  for (i=0 ; i<3 ; i++)
980  {
981  mins[i] = e->origin[i] - currentmodel->radius;
982  maxs[i] = e->origin[i] + currentmodel->radius;
983  }
984  }
985  else
986  {
987  rotated = false;
988  VectorAdd (e->origin, currentmodel->mins, mins);
989  VectorAdd (e->origin, currentmodel->maxs, maxs);
990  }
991 
992  if (R_CullBox (mins, maxs))
993  return;
994 
995  qglColor3f (1,1,1);
996  memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
997 
998  VectorSubtract (r_newrefdef.vieworg, e->origin, modelorg);
999  if (rotated)
1000  {
1001  vec3_t temp;
1002  vec3_t forward, right, up;
1003 
1004  VectorCopy (modelorg, temp);
1005  AngleVectors (e->angles, forward, right, up);
1006  modelorg[0] = DotProduct (temp, forward);
1007  modelorg[1] = -DotProduct (temp, right);
1008  modelorg[2] = DotProduct (temp, up);
1009  }
1010 
1011  qglPushMatrix ();
1012  e->angles[0] = -e->angles[0]; // stupid quake bug
1013  e->angles[2] = -e->angles[2]; // stupid quake bug
1014  R_RotateForEntity (e);
1015  e->angles[0] = -e->angles[0]; // stupid quake bug
1016  e->angles[2] = -e->angles[2]; // stupid quake bug
1017 
1018  GL_EnableMultitexture( true );
1019  GL_SelectTexture( QGL_TEXTURE0);
1020  GL_TexEnv( GL_REPLACE );
1021  GL_SelectTexture( QGL_TEXTURE1);
1022  GL_TexEnv( GL_MODULATE );
1023 
1024  R_DrawInlineBModel ();
1025  GL_EnableMultitexture( false );
1026 
1027  qglPopMatrix ();
1028 }

Referenced by R_DrawEntitiesOnList().

◆ R_DrawSkyBox()

void R_DrawSkyBox ( void  )

Definition at line 562 of file gl_warp.c.

563 {
564  int i;
565 
566 #if 0
567 qglEnable (GL_BLEND);
568 GL_TexEnv( GL_MODULATE );
569 qglColor4f (1,1,1,0.5);
570 qglDisable (GL_DEPTH_TEST);
571 #endif
572  if (skyrotate)
573  { // check for no sky at all
574  for (i=0 ; i<6 ; i++)
575  if (skymins[0][i] < skymaxs[0][i]
576  && skymins[1][i] < skymaxs[1][i])
577  break;
578  if (i == 6)
579  return; // nothing visible
580  }
581 
582 qglPushMatrix ();
583 qglTranslatef (r_origin[0], r_origin[1], r_origin[2]);
584 qglRotatef (r_newrefdef.time * skyrotate, skyaxis[0], skyaxis[1], skyaxis[2]);
585 
586  for (i=0 ; i<6 ; i++)
587  {
588  if (skyrotate)
589  { // hack, forces full sky to draw when rotating
590  skymins[0][i] = -1;
591  skymins[1][i] = -1;
592  skymaxs[0][i] = 1;
593  skymaxs[1][i] = 1;
594  }
595 
596  if (skymins[0][i] >= skymaxs[0][i]
597  || skymins[1][i] >= skymaxs[1][i])
598  continue;
599 
600  GL_Bind (sky_images[skytexorder[i]]->texnum);
601 
602  qglBegin (GL_QUADS);
603  MakeSkyVec (skymins[0][i], skymins[1][i], i);
604  MakeSkyVec (skymins[0][i], skymaxs[1][i], i);
605  MakeSkyVec (skymaxs[0][i], skymaxs[1][i], i);
606  MakeSkyVec (skymaxs[0][i], skymins[1][i], i);
607  qglEnd ();
608  }
609 qglPopMatrix ();
610 #if 0
611 glDisable (GL_BLEND);
612 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
613 glColor4f (1,1,1,0.5);
614 glEnable (GL_DEPTH_TEST);
615 #endif
616 }

Referenced by R_DrawWorld().

◆ R_DrawSpriteModel()

void R_DrawSpriteModel ( entity_t *  e)

Definition at line 184 of file gl_rmain.c.

185 {
186  float alpha = 1.0F;
187  vec3_t point;
188  dsprframe_t *frame;
189  float *up, *right;
190  dsprite_t *psprite;
191 
192  // don't even bother culling, because it's just a single
193  // polygon without a surface cache
194 
195  psprite = (dsprite_t *)currentmodel->extradata;
196 
197 #if 0
198  if (e->frame < 0 || e->frame >= psprite->numframes)
199  {
200  ri.Con_Printf (PRINT_ALL, "no such sprite frame %i\n", e->frame);
201  e->frame = 0;
202  }
203 #endif
204  e->frame %= psprite->numframes;
205 
206  frame = &psprite->frames[e->frame];
207 
208 #if 0
209  if (psprite->type == SPR_ORIENTED)
210  { // bullet marks on walls
211  vec3_t v_forward, v_right, v_up;
212 
213  AngleVectors (currententity->angles, v_forward, v_right, v_up);
214  up = v_up;
215  right = v_right;
216  }
217  else
218 #endif
219  { // normal sprite
220  up = vup;
221  right = vright;
222  }
223 
224  if ( e->flags & RF_TRANSLUCENT )
225  alpha = e->alpha;
226 
227  if ( alpha != 1.0F )
228  qglEnable( GL_BLEND );
229 
230  qglColor4f( 1, 1, 1, alpha );
231 
232  GL_Bind(currentmodel->skins[e->frame]->texnum);
233 
234  GL_TexEnv( GL_MODULATE );
235 
236  if ( alpha == 1.0 )
237  qglEnable (GL_ALPHA_TEST);
238  else
239  qglDisable( GL_ALPHA_TEST );
240 
241  qglBegin (GL_QUADS);
242 
243  qglTexCoord2f (0, 1);
244  VectorMA (e->origin, -frame->origin_y, up, point);
245  VectorMA (point, -frame->origin_x, right, point);
246  qglVertex3fv (point);
247 
248  qglTexCoord2f (0, 0);
249  VectorMA (e->origin, frame->height - frame->origin_y, up, point);
250  VectorMA (point, -frame->origin_x, right, point);
251  qglVertex3fv (point);
252 
253  qglTexCoord2f (1, 0);
254  VectorMA (e->origin, frame->height - frame->origin_y, up, point);
255  VectorMA (point, frame->width - frame->origin_x, right, point);
256  qglVertex3fv (point);
257 
258  qglTexCoord2f (1, 1);
259  VectorMA (e->origin, -frame->origin_y, up, point);
260  VectorMA (point, frame->width - frame->origin_x, right, point);
261  qglVertex3fv (point);
262 
263  qglEnd ();
264 
265  qglDisable (GL_ALPHA_TEST);
266  GL_TexEnv( GL_REPLACE );
267 
268  if ( alpha != 1.0F )
269  qglDisable( GL_BLEND );
270 
271  qglColor4f( 1, 1, 1, 1 );
272 }

Referenced by R_DrawEntitiesOnList().

◆ R_DrawWorld()

void R_DrawWorld ( void  )

Definition at line 1204 of file gl_rsurf.c.

1205 {
1206  entity_t ent;
1207 
1208  if (!r_drawworld->value)
1209  return;
1210 
1211  if ( r_newrefdef.rdflags & RDF_NOWORLDMODEL )
1212  return;
1213 
1214  currentmodel = r_worldmodel;
1215 
1216  VectorCopy (r_newrefdef.vieworg, modelorg);
1217 
1218  // auto cycle the world frame for texture animation
1219  memset (&ent, 0, sizeof(ent));
1220  ent.frame = (int)(r_newrefdef.time*2);
1221  currententity = &ent;
1222 
1223  gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
1224 
1225  qglColor3f (1,1,1);
1226  memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
1227  R_ClearSkyBox ();
1228 
1229  if ( qglMTexCoord2fSGIS )
1230  {
1231  GL_EnableMultitexture( true );
1232 
1233  GL_SelectTexture( QGL_TEXTURE0);
1234  GL_TexEnv( GL_REPLACE );
1235  GL_SelectTexture( QGL_TEXTURE1);
1236 
1237  if ( gl_lightmap->value )
1238  GL_TexEnv( GL_REPLACE );
1239  else
1240  GL_TexEnv( GL_MODULATE );
1241 
1242  R_RecursiveWorldNode (r_worldmodel->nodes);
1243 
1244  GL_EnableMultitexture( false );
1245  }
1246  else
1247  {
1248  R_RecursiveWorldNode (r_worldmodel->nodes);
1249  }
1250 
1251  /*
1252  ** theoretically nothing should happen in the next two functions
1253  ** if multitexture is enabled
1254  */
1255  DrawTextureChains ();
1256  R_BlendLightmaps ();
1257 
1258  R_DrawSkyBox ();
1259 
1260  R_DrawTriangleOutlines ();
1261 }

Referenced by R_RenderView().

◆ R_Init()

int R_Init ( void *  hinstance,
void *  hWnd 
)

Definition at line 300 of file r_main.c.

301 {
302  R_InitImages ();
303  Mod_Init ();
304  Draw_InitLocal ();
305  R_InitTextures ();
306 
307  R_InitTurb ();
308 
309  view_clipplanes[0].leftedge = true;
310  view_clipplanes[1].rightedge = true;
311  view_clipplanes[1].leftedge = view_clipplanes[2].leftedge =
312  view_clipplanes[3].leftedge = false;
313  view_clipplanes[0].rightedge = view_clipplanes[2].rightedge =
314  view_clipplanes[3].rightedge = false;
315 
316  r_refdef.xOrigin = XCENTERING;
317  r_refdef.yOrigin = YCENTERING;
318 
319 // TODO: collect 386-specific code in one place
320 #if id386
321  Sys_MakeCodeWriteable ((long)R_EdgeCodeStart,
322  (long)R_EdgeCodeEnd - (long)R_EdgeCodeStart);
323  Sys_SetFPCW (); // get bit masks for FPCW (FIXME: is this id386?)
324 #endif // id386
325 
326  r_aliasuvscale = 1.0;
327 
328  R_Register ();
329  Draw_GetPalette ();
330  if (SWimp_Init( hInstance, wndProc ) == false)
331  return -1;
332 
333  // create the window
334  R_BeginFrame( 0 );
335 
336  ri.Con_Printf (PRINT_ALL, "ref_soft version: "REF_VERSION"\n");
337 
338  return true;
339 }

Referenced by GetRefAPI().

◆ R_InitParticleTexture()

void R_InitParticleTexture ( void  )

Definition at line 41 of file gl_rmisc.c.

42 {
43  int x,y;
44  byte data[8][8][4];
45 
46  //
47  // particle texture
48  //
49  for (x=0 ; x<8 ; x++)
50  {
51  for (y=0 ; y<8 ; y++)
52  {
53  data[y][x][0] = 255;
54  data[y][x][1] = 255;
55  data[y][x][2] = 255;
56  data[y][x][3] = dottexture[x][y]*255;
57  }
58  }
59  r_particletexture = GL_LoadPic ("***particle***", (byte *)data, 8, 8, it_sprite, 32);
60 
61  //
62  // also use this for bad textures, but without alpha
63  //
64  for (x=0 ; x<8 ; x++)
65  {
66  for (y=0 ; y<8 ; y++)
67  {
68  data[y][x][0] = dottexture[x&3][y&3]*255;
69  data[y][x][1] = 0; // dottexture[x&3][y&3]*255;
70  data[y][x][2] = 0; //dottexture[x&3][y&3]*255;
71  data[y][x][3] = 255;
72  }
73  }
74  r_notexture = GL_LoadPic ("***r_notexture***", (byte *)data, 8, 8, it_wall, 32);
75 }

Referenced by R_Init().

◆ R_LightPoint()

void R_LightPoint ( vec3_t  p,
vec3_t  color 
)

Definition at line 224 of file r_light.c.

225 {
226  vec3_t end;
227  float r;
228  int lnum;
229  dlight_t *dl;
230  float light;
231  vec3_t dist;
232  float add;
233 
234  if (!r_worldmodel->lightdata)
235  {
236  color[0] = color[1] = color[2] = 1.0;
237  return;
238  }
239 
240  end[0] = p[0];
241  end[1] = p[1];
242  end[2] = p[2] - 2048;
243 
244  r = RecursiveLightPoint (r_worldmodel->nodes, p, end);
245 
246  if (r == -1)
247  {
248  VectorCopy (vec3_origin, color);
249  }
250  else
251  {
252  VectorCopy (pointcolor, color);
253  }
254 
255  //
256  // add dynamic lights
257  //
258  light = 0;
259  for (lnum=0 ; lnum<r_newrefdef.num_dlights ; lnum++)
260  {
261  dl = &r_newrefdef.dlights[lnum];
262  VectorSubtract (currententity->origin,
263  dl->origin,
264  dist);
265  add = dl->intensity - VectorLength(dist);
266  add *= (1.0/256);
267  if (add > 0)
268  {
269  VectorMA (color, add, dl->color, color);
270  }
271  }
272 }

Referenced by R_AliasSetupLighting(), R_DrawAliasModel(), R_DrawNullModel(), and R_SetLightLevel().

◆ R_MarkLeaves()

void R_MarkLeaves ( void  )

Definition at line 432 of file r_main.c.

433 {
434  byte *vis;
435  mnode_t *node;
436  int i;
437  mleaf_t *leaf;
438  int cluster;
439 
440  if (r_oldviewcluster == r_viewcluster && !r_novis->value && r_viewcluster != -1)
441  return;
442 
443  // development aid to let you run around and see exactly where
444  // the pvs ends
445  if (sw_lockpvs->value)
446  return;
447 
448  r_visframecount++;
449  r_oldviewcluster = r_viewcluster;
450 
451  if (r_novis->value || r_viewcluster == -1 || !r_worldmodel->vis)
452  {
453  // mark everything
454  for (i=0 ; i<r_worldmodel->numleafs ; i++)
455  r_worldmodel->leafs[i].visframe = r_visframecount;
456  for (i=0 ; i<r_worldmodel->numnodes ; i++)
457  r_worldmodel->nodes[i].visframe = r_visframecount;
458  return;
459  }
460 
461  vis = Mod_ClusterPVS (r_viewcluster, r_worldmodel);
462 
463  for (i=0,leaf=r_worldmodel->leafs ; i<r_worldmodel->numleafs ; i++, leaf++)
464  {
465  cluster = leaf->cluster;
466  if (cluster == -1)
467  continue;
468  if (vis[cluster>>3] & (1<<(cluster&7)))
469  {
470  node = (mnode_t *)leaf;
471  do
472  {
473  if (node->visframe == r_visframecount)
474  break;
475  node->visframe = r_visframecount;
476  node = node->parent;
477  } while (node);
478  }
479  }
480 
481 #if 0
482  for (i=0 ; i<r_worldmodel->vis->numclusters ; i++)
483  {
484  if (vis[i>>3] & (1<<(i&7)))
485  {
486  node = (mnode_t *)&r_worldmodel->leafs[i]; // FIXME: cluster
487  do
488  {
489  if (node->visframe == r_visframecount)
490  break;
491  node->visframe = r_visframecount;
492  node = node->parent;
493  } while (node);
494  }
495  }
496 #endif
497 }

Referenced by R_RenderFrame(), and R_RenderView().

◆ R_MarkLights()

void R_MarkLights ( dlight_t *  light,
int  bit,
mnode_t *  node 
)

Definition at line 40 of file r_light.c.

41 {
42  mplane_t *splitplane;
43  float dist;
44  msurface_t *surf;
45  int i;
46 
47  if (node->contents != -1)
48  return;
49 
50  splitplane = node->plane;
51  dist = DotProduct (light->origin, splitplane->normal) - splitplane->dist;
52 
53 //=====
54 //PGM
55  i=light->intensity;
56  if(i<0)
57  i=-i;
58 //PGM
59 //=====
60 
61  if (dist > i) // PGM (dist > light->intensity)
62  {
63  R_MarkLights (light, bit, node->children[0]);
64  return;
65  }
66  if (dist < -i) // PGM (dist < -light->intensity)
67  {
68  R_MarkLights (light, bit, node->children[1]);
69  return;
70  }
71 
72 // mark the polygons
73  surf = r_worldmodel->surfaces + node->firstsurface;
74  for (i=0 ; i<node->numsurfaces ; i++, surf++)
75  {
76  if (surf->dlightframe != r_dlightframecount)
77  {
78  surf->dlightbits = 0;
79  surf->dlightframe = r_dlightframecount;
80  }
81  surf->dlightbits |= bit;
82  }
83 
84  R_MarkLights (light, bit, node->children[0]);
85  R_MarkLights (light, bit, node->children[1]);
86 }

Referenced by R_DrawInlineBModel(), R_MarkLights(), and R_PushDlights().

◆ R_PushDlights()

void R_PushDlights ( void  )

Definition at line 164 of file gl_light.c.

165 {
166  int i;
167  dlight_t *l;
168 
169  if (gl_flashblend->value)
170  return;
171 
172  r_dlightframecount = r_framecount + 1; // because the count hasn't
173  // advanced yet for this frame
174  l = r_newrefdef.dlights;
175  for (i=0 ; i<r_newrefdef.num_dlights ; i++, l++)
176  R_MarkLights ( l, 1<<i, r_worldmodel->nodes );
177 }

◆ R_RegisterSkin()

struct image_s* R_RegisterSkin ( char *  name)

Definition at line 564 of file r_image.c.

565 {
566  return R_FindImage (name, it_skin);
567 }

◆ R_RenderBrushPoly()

void R_RenderBrushPoly ( msurface_t *  fa)

Definition at line 485 of file gl_rsurf.c.

486 {
487  int maps;
488  image_t *image;
489  qboolean is_dynamic = false;
490 
491  c_brush_polys++;
492 
493  image = R_TextureAnimation (fa->texinfo);
494 
495  if (fa->flags & SURF_DRAWTURB)
496  {
497  GL_Bind( image->texnum );
498 
499  // warp texture, no lightmaps
500  GL_TexEnv( GL_MODULATE );
501  qglColor4f( gl_state.inverse_intensity,
502  gl_state.inverse_intensity,
503  gl_state.inverse_intensity,
504  1.0F );
505  EmitWaterPolys (fa);
506  GL_TexEnv( GL_REPLACE );
507 
508  return;
509  }
510  else
511  {
512  GL_Bind( image->texnum );
513 
514  GL_TexEnv( GL_REPLACE );
515  }
516 
517 //======
518 //PGM
519  if(fa->texinfo->flags & SURF_FLOWING)
520  DrawGLFlowingPoly (fa);
521  else
522  DrawGLPoly (fa->polys);
523 //PGM
524 //======
525 
526  /*
527  ** check for lightmap modification
528  */
529  for ( maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++ )
530  {
531  if ( r_newrefdef.lightstyles[fa->styles[maps]].white != fa->cached_light[maps] )
532  goto dynamic;
533  }
534 
535  // dynamic this frame or dynamic previously
536  if ( ( fa->dlightframe == r_framecount ) )
537  {
538 dynamic:
539  if ( gl_dynamic->value )
540  {
541  if (!( fa->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP ) ) )
542  {
543  is_dynamic = true;
544  }
545  }
546  }
547 
548  if ( is_dynamic )
549  {
550  if ( ( fa->styles[maps] >= 32 || fa->styles[maps] == 0 ) && ( fa->dlightframe != r_framecount ) )
551  {
552  unsigned temp[34*34];
553  int smax, tmax;
554 
555  smax = (fa->extents[0]>>4)+1;
556  tmax = (fa->extents[1]>>4)+1;
557 
558  R_BuildLightMap( fa, (void *)temp, smax*4 );
559  R_SetCacheState( fa );
560 
561  GL_Bind( gl_state.lightmap_textures + fa->lightmaptexturenum );
562 
563  qglTexSubImage2D( GL_TEXTURE_2D, 0,
564  fa->light_s, fa->light_t,
565  smax, tmax,
566  GL_LIGHTMAP_FORMAT,
567  GL_UNSIGNED_BYTE, temp );
568 
569  fa->lightmapchain = gl_lms.lightmap_surfaces[fa->lightmaptexturenum];
570  gl_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa;
571  }
572  else
573  {
574  fa->lightmapchain = gl_lms.lightmap_surfaces[0];
575  gl_lms.lightmap_surfaces[0] = fa;
576  }
577  }
578  else
579  {
580  fa->lightmapchain = gl_lms.lightmap_surfaces[fa->lightmaptexturenum];
581  gl_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa;
582  }
583 }

Referenced by DrawTextureChains(), and R_DrawInlineBModel().

◆ R_RenderDlights()

void R_RenderDlights ( void  )

Definition at line 77 of file gl_light.c.

78 {
79  int i;
80  dlight_t *l;
81 
82  if (!gl_flashblend->value)
83  return;
84 
85  r_dlightframecount = r_framecount + 1; // because the count hasn't
86  // advanced yet for this frame
87  qglDepthMask (0);
88  qglDisable (GL_TEXTURE_2D);
89  qglShadeModel (GL_SMOOTH);
90  qglEnable (GL_BLEND);
91  qglBlendFunc (GL_ONE, GL_ONE);
92 
93  l = r_newrefdef.dlights;
94  for (i=0 ; i<r_newrefdef.num_dlights ; i++, l++)
95  R_RenderDlight (l);
96 
97  qglColor3f (1,1,1);
98  qglDisable (GL_BLEND);
99  qglEnable (GL_TEXTURE_2D);
100  qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
101  qglDepthMask (1);
102 }

Referenced by R_RenderView().

◆ R_RenderView()

void R_RenderView ( refdef_t *  fd)

Definition at line 820 of file gl_rmain.c.

821 {
822  if (r_norefresh->value)
823  return;
824 
825  r_newrefdef = *fd;
826 
827  if (!r_worldmodel && !( r_newrefdef.rdflags & RDF_NOWORLDMODEL ) )
828  ri.Sys_Error (ERR_DROP, "R_RenderView: NULL worldmodel");
829 
830  if (r_speeds->value)
831  {
832  c_brush_polys = 0;
833  c_alias_polys = 0;
834  }
835 
836  R_PushDlights ();
837 
838  if (gl_finish->value)
839  qglFinish ();
840 
841  R_SetupFrame ();
842 
843  R_SetFrustum ();
844 
845  R_SetupGL ();
846 
847  R_MarkLeaves (); // done here so we know if we're in water
848 
849  R_DrawWorld ();
850 
851  R_DrawEntitiesOnList ();
852 
853  R_RenderDlights ();
854 
855  R_DrawParticles ();
856 
857  R_DrawAlphaSurfaces ();
858 
859  R_Flash();
860 
861  if (r_speeds->value)
862  {
863  ri.Con_Printf (PRINT_ALL, "%4i wpoly %4i epoly %i tex %i lmaps\n",
864  c_brush_polys,
865  c_alias_polys,
866  c_visible_textures,
867  c_visible_lightmaps);
868  }
869 }

Referenced by R_RenderFrame().

◆ R_RotateForEntity()

void R_RotateForEntity ( entity_t *  e)

Definition at line 160 of file gl_rmain.c.

161 {
162  qglTranslatef (e->origin[0], e->origin[1], e->origin[2]);
163 
164  qglRotatef (e->angles[1], 0, 0, 1);
165  qglRotatef (-e->angles[0], 0, 1, 0);
166  qglRotatef (-e->angles[2], 1, 0, 0);
167 }

Referenced by R_DrawAliasModel(), R_DrawBrushModel(), and R_DrawNullModel().

◆ R_SetPalette()

void R_SetPalette ( const unsigned char *  palette)

Definition at line 1575 of file gl_rmain.c.

1576 {
1577  int i;
1578 
1579  byte *rp = ( byte * ) r_rawpalette;
1580 
1581  if ( palette )
1582  {
1583  for ( i = 0; i < 256; i++ )
1584  {
1585  rp[i*4+0] = palette[i*3+0];
1586  rp[i*4+1] = palette[i*3+1];
1587  rp[i*4+2] = palette[i*3+2];
1588  rp[i*4+3] = 0xff;
1589  }
1590  }
1591  else
1592  {
1593  for ( i = 0; i < 256; i++ )
1594  {
1595  rp[i*4+0] = LittleLong(d_8to24table[i]) & 0xff;
1596  rp[i*4+1] = ( LittleLong(d_8to24table[i]) >> 8 ) & 0xff;
1597  rp[i*4+2] = ( LittleLong(d_8to24table[i]) >> 16 ) & 0xff;
1598  rp[i*4+3] = 0xff;
1599  }
1600  }
1601  GL_SetTexturePalette( r_rawpalette );
1602 
1603  qglClearColor (0,0,0,0);
1604  qglClear (GL_COLOR_BUFFER_BIT);
1605  qglClearColor (1,0, 0.5 , 0.5);
1606 }

Referenced by GetRefAPI().

◆ R_Shutdown()

void R_Shutdown ( void  )

Definition at line 346 of file r_main.c.

347 {
348  // free z buffer
349  if (d_pzbuffer)
350  {
351  free (d_pzbuffer);
352  d_pzbuffer = NULL;
353  }
354  // free surface cache
355  if (sc_base)
356  {
357  D_FlushCaches ();
358  free (sc_base);
359  sc_base = NULL;
360  }
361 
362  // free colormap
363  if (vid.colormap)
364  {
365  free (vid.colormap);
366  vid.colormap = NULL;
367  }
368  R_UnRegister ();
369  Mod_FreeAll ();
370  R_ShutdownImages ();
371 
372  SWimp_Shutdown();
373 }

Referenced by GetRefAPI().

◆ R_SwapBuffers()

void R_SwapBuffers ( int  )

◆ R_TranslatePlayerSkin()

void R_TranslatePlayerSkin ( int  playernum)

◆ V_AddBlend()

void V_AddBlend ( float  r,
float  g,
float  b,
float  a,
float *  v_blend 
)

Referenced by R_RenderDlight().

◆ WaterWarpPolyVerts()

glpoly_t* WaterWarpPolyVerts ( glpoly_t *  p)

Variable Documentation

◆ c_alias_polys

int c_alias_polys

Definition at line 164 of file gl_local.h.

Referenced by R_DrawAliasModel().

◆ c_brush_polys

int c_brush_polys

Definition at line 49 of file gl_rmain.c.

Referenced by GL_RenderLightmappedPoly(), R_DrawAlphaSurfaces(), R_RenderBrushPoly(), R_RenderView(), and R_SetupFrame().

◆ c_visible_lightmaps

int c_visible_lightmaps

Definition at line 39 of file gl_rsurf.c.

Referenced by R_BlendLightmaps(), and R_RenderView().

◆ c_visible_textures

int c_visible_textures

Definition at line 40 of file gl_rsurf.c.

Referenced by DrawTextureChains(), and R_RenderView().

◆ currententity

entity_t* currententity

Definition at line 28 of file r_bsp.c.

Referenced by D_DrawSurfaces(), D_SolidSurf(), D_TurbulentSurf(), GL_DrawAliasFrameLerp(), GL_DrawAliasShadow(), GL_LerpVerts(), R_AliasCheckBBox(), R_AliasDrawModel(), R_AliasPreparePoints(), R_AliasSetupFrames(), R_AliasSetUpLerpData(), R_AliasSetupLighting(), R_AliasSetupSkin(), R_AliasSetUpTransform(), R_AliasTransformFinalVerts(), R_DrawAliasModel(), R_DrawBEntitiesOnList(), R_DrawBrushModel(), R_DrawEntitiesOnList(), R_DrawInlineBModel(), R_DrawNullModel(), R_DrawSprite(), R_DrawSpriteModel(), R_DrawWorld(), R_LightPoint(), R_PolysetDrawSpans8_Opaque(), R_RenderBmodelFace(), R_RenderFace(), R_RenderWorld(), R_RotateBmodel(), R_SetLightLevel(), and R_TextureAnimation().

◆ currentmodel

model_t* currentmodel

Definition at line 37 of file r_main.c.

Referenced by R_DrawBEntitiesOnList(), R_DrawEntitiesOnList(), and R_DrawSpriteModel().

◆ d_8to24table

unsigned d_8to24table[256]

Definition at line 27 of file r_main.c.

Referenced by Draw_GetPalette(), GL_Upload8(), R_BeginFrame(), R_CalcPalette(), R_CinematicSetPalette(), R_FloodFillSkin(), and R_InitGraphics().

◆ frustum

cplane_t frustum[4]

Definition at line 44 of file gl_rmain.c.

Referenced by R_CullAliasModel(), R_CullBox(), and R_SetFrustum().

◆ gl_3dlabs_broken

cvar_t* gl_3dlabs_broken

Definition at line 133 of file gl_rmain.c.

Referenced by R_Init(), and R_Register().

◆ gl_alpha_format

int gl_alpha_format

Definition at line 39 of file gl_image.c.

Referenced by GL_Upload32().

◆ gl_bitdepth

cvar_t* gl_bitdepth

Definition at line 104 of file gl_rmain.c.

Referenced by GLimp_BeginFrame(), GLimp_SetMode(), and R_Register().

◆ gl_clear

cvar_t* gl_clear

Definition at line 121 of file gl_rmain.c.

Referenced by R_Clear(), and R_Register().

◆ gl_config

glconfig_t gl_config

Definition at line 35 of file gl_rmain.c.

Referenced by Draw_Pic(), Draw_StretchPic(), Draw_StretchRaw(), Draw_TileClear(), GL_InitImages(), GL_Strings_f(), QGL_Init(), R_BeginFrame(), R_Init(), and R_SetMode().

◆ gl_cull

cvar_t* gl_cull

Definition at line 122 of file gl_rmain.c.

Referenced by R_Register(), and R_SetupGL().

◆ gl_drawbuffer

cvar_t* gl_drawbuffer

Definition at line 105 of file gl_rmain.c.

Referenced by GLimp_EndFrame(), R_BeginFrame(), and R_Register().

◆ gl_driver

cvar_t* gl_driver

Definition at line 106 of file gl_rmain.c.

Referenced by R_Init(), and R_Register().

◆ gl_dynamic

cvar_t* gl_dynamic

Definition at line 111 of file gl_rmain.c.

Referenced by GL_RenderLightmappedPoly(), R_BlendLightmaps(), R_Register(), and R_RenderBrushPoly().

◆ gl_ext_compiled_vertex_array

cvar_t* gl_ext_compiled_vertex_array

Definition at line 101 of file gl_rmain.c.

Referenced by R_Register().

◆ gl_ext_multitexture

cvar_t* gl_ext_multitexture

Definition at line 99 of file gl_rmain.c.

Referenced by R_Init(), and R_Register().

◆ gl_ext_palettedtexture

cvar_t* gl_ext_palettedtexture

Definition at line 98 of file gl_rmain.c.

Referenced by R_Init(), and R_Register().

◆ gl_ext_pointparameters

cvar_t* gl_ext_pointparameters

Definition at line 100 of file gl_rmain.c.

Referenced by R_DrawParticles(), R_Init(), and R_Register().

◆ gl_ext_swapinterval

cvar_t* gl_ext_swapinterval

Definition at line 97 of file gl_rmain.c.

Referenced by R_Register().

◆ gl_filter_max

int gl_filter_max

Definition at line 167 of file gl_local.h.

◆ gl_filter_min

int gl_filter_min

Definition at line 44 of file gl_image.c.

Referenced by GL_SetDefaultState(), GL_TextureMode(), and GL_Upload32().

◆ gl_finish

cvar_t* gl_finish

Definition at line 120 of file gl_rmain.c.

Referenced by R_Register(), and R_RenderView().

◆ gl_flashblend

cvar_t* gl_flashblend

Definition at line 124 of file gl_rmain.c.

Referenced by R_DrawInlineBModel(), R_PushDlights(), R_Register(), and R_RenderDlights().

◆ gl_lightmap

cvar_t* gl_lightmap

Definition at line 107 of file gl_rmain.c.

Referenced by R_BlendLightmaps(), R_DrawWorld(), and R_Register().

◆ gl_lightmap_format

int gl_lightmap_format

◆ gl_lightmaptype

cvar_t* gl_lightmaptype

◆ gl_lockpvs

cvar_t* gl_lockpvs

Definition at line 131 of file gl_rmain.c.

Referenced by R_MarkLeaves(), and R_Register().

◆ gl_log

cvar_t* gl_log

Definition at line 103 of file gl_rmain.c.

Referenced by R_BeginFrame(), and R_Register().

◆ gl_mode

cvar_t* gl_mode

Definition at line 110 of file gl_rmain.c.

Referenced by R_BeginFrame(), R_Register(), and R_SetMode().

◆ gl_modulate

cvar_t* gl_modulate

Definition at line 113 of file gl_rmain.c.

Referenced by R_BuildLightMap(), R_LightPoint(), R_Register(), and RecursiveLightPoint().

◆ gl_monolightmap

cvar_t* gl_monolightmap

Definition at line 112 of file gl_rmain.c.

Referenced by GL_BeginBuildingLightmaps(), R_BlendLightmaps(), R_BuildLightMap(), R_DrawAliasModel(), R_Init(), and R_Register().

◆ gl_nobind

cvar_t* gl_nobind

Definition at line 114 of file gl_rmain.c.

Referenced by GL_Bind(), and R_Register().

◆ gl_nosubimage

cvar_t* gl_nosubimage

Definition at line 85 of file gl_rmain.c.

Referenced by R_Register().

◆ gl_particle_att_a

cvar_t* gl_particle_att_a

Definition at line 93 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), and R_Register().

◆ gl_particle_att_b

cvar_t* gl_particle_att_b

Definition at line 94 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), and R_Register().

◆ gl_particle_att_c

cvar_t* gl_particle_att_c

Definition at line 95 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), and R_Register().

◆ gl_particle_max_size

cvar_t* gl_particle_max_size

Definition at line 91 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), and R_Register().

◆ gl_particle_min_size

cvar_t* gl_particle_min_size

Definition at line 90 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), and R_Register().

◆ gl_particle_size

cvar_t* gl_particle_size

Definition at line 92 of file gl_rmain.c.

Referenced by R_DrawParticles(), and R_Register().

◆ gl_picmip

cvar_t* gl_picmip

Definition at line 116 of file gl_rmain.c.

Referenced by R_Register().

◆ gl_playermip

cvar_t* gl_playermip

Definition at line 125 of file gl_rmain.c.

Referenced by R_Register().

◆ gl_poly

cvar_t* gl_poly

◆ gl_polyblend

cvar_t* gl_polyblend

Definition at line 123 of file gl_rmain.c.

Referenced by R_PolyBlend(), and R_Register().

◆ gl_round_down

cvar_t* gl_round_down

Definition at line 115 of file gl_rmain.c.

Referenced by GL_Upload32(), and R_Register().

◆ gl_saturatelighting

cvar_t* gl_saturatelighting

Definition at line 126 of file gl_rmain.c.

Referenced by R_BlendLightmaps(), and R_Register().

◆ gl_shadows

cvar_t* gl_shadows

Definition at line 108 of file gl_rmain.c.

Referenced by R_Clear(), R_DrawAliasModel(), and R_Register().

◆ gl_showtris

cvar_t* gl_showtris

Definition at line 118 of file gl_rmain.c.

Referenced by R_DrawTriangleOutlines(), and R_Register().

◆ gl_skymip

cvar_t* gl_skymip

Definition at line 117 of file gl_rmain.c.

Referenced by R_Register(), and R_SetSky().

◆ gl_solid_format

int gl_solid_format

Definition at line 38 of file gl_image.c.

Referenced by GL_Upload32().

◆ gl_state

glstate_t gl_state

Definition at line 36 of file gl_rmain.c.

Referenced by GL_BeginBuildingLightmaps(), GL_Bind(), GL_BuildPalettedTexture(), GL_InitImages(), GL_MBind(), GL_RenderLightmappedPoly(), GL_SelectTexture(), GL_TexEnv(), GL_UpdateSwapInterval(), GLimp_BeginFrame(), GLimp_InitGL(), GLimp_SetMode(), GLimp_Shutdown(), LM_UploadBlock(), MYgluPerspective(), R_BeginFrame(), R_BlendLightmaps(), R_DrawAlphaSurfaces(), R_DrawBrushModel(), R_DrawWorld(), R_Init(), R_RenderBrushPoly(), and R_SetMode().

◆ gl_stencilshadow

cvar_t* gl_stencilshadow

Definition at line 109 of file gl_rmain.c.

Referenced by GL_DrawAliasShadow(), R_Clear(), and R_Register().

◆ gl_swapinterval

cvar_t* gl_swapinterval

Definition at line 127 of file gl_rmain.c.

Referenced by GL_UpdateSwapInterval(), and R_Register().

◆ gl_tex_alpha_format

int gl_tex_alpha_format

Definition at line 42 of file gl_image.c.

Referenced by GL_BeginBuildingLightmaps(), GL_TextureAlphaMode(), and GL_Upload32().

◆ gl_tex_solid_format

int gl_tex_solid_format

Definition at line 41 of file gl_image.c.

Referenced by Draw_StretchRaw(), GL_BeginBuildingLightmaps(), GL_TextureSolidMode(), and GL_Upload32().

◆ gl_texsort

cvar_t* gl_texsort

◆ gl_texturealphamode

cvar_t* gl_texturealphamode

Definition at line 129 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), R_BeginFrame(), and R_Register().

◆ gl_texturemode

cvar_t* gl_texturemode

Definition at line 128 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), R_BeginFrame(), and R_Register().

◆ gl_texturesolidmode

cvar_t* gl_texturesolidmode

Definition at line 130 of file gl_rmain.c.

Referenced by GL_SetDefaultState(), R_BeginFrame(), and R_Register().

◆ gl_vertex_arrays

cvar_t* gl_vertex_arrays

Definition at line 88 of file gl_rmain.c.

Referenced by GL_DrawAliasFrameLerp(), and R_Register().

◆ gl_ztrick

cvar_t* gl_ztrick

Definition at line 119 of file gl_rmain.c.

Referenced by R_Clear(), and R_Register().

◆ gldepthmax

float gldepthmax

Definition at line 136 of file gl_local.h.

Referenced by R_DrawAliasModel().

◆ gldepthmin

float gldepthmin

Definition at line 33 of file gl_rmain.c.

Referenced by R_Clear(), and R_DrawAliasModel().

◆ gltextures

image_t gltextures[MAX_GLTEXTURES]

Definition at line 23 of file gl_image.c.

Referenced by DrawTextureChains(), GL_FindImage(), GL_FreeUnusedImages(), GL_ImageList_f(), GL_LoadPic(), GL_ShutdownImages(), and GL_TextureMode().

◆ intensity

cvar_t* intensity

Definition at line 30 of file gl_image.c.

Referenced by CL_AddPacketEntities(), CL_ColorFlash(), GL_InitImages(), R_MarkLights(), and V_AddLight().

◆ numgltextures

int numgltextures

Definition at line 24 of file gl_image.c.

Referenced by DrawTextureChains(), GL_FindImage(), GL_FreeUnusedImages(), GL_ImageList_f(), GL_LoadPic(), GL_ShutdownImages(), and GL_TextureMode().

◆ r_drawentities

cvar_t* r_drawentities

Definition at line 127 of file r_main.c.

Referenced by R_DrawBEntitiesOnList(), R_DrawEntitiesOnList(), R_Register(), and R_SetLightLevel().

◆ r_drawworld

cvar_t* r_drawworld

Definition at line 126 of file r_main.c.

Referenced by R_Register().

◆ r_framecount

int r_framecount

Definition at line 91 of file r_main.c.

Referenced by R_DrawBEntitiesOnList(), and R_SetupFrame().

◆ r_fullbright

cvar_t* r_fullbright

Definition at line 129 of file r_main.c.

Referenced by R_Register().

◆ r_lefthand

cvar_t* r_lefthand

Definition at line 111 of file r_main.c.

Referenced by R_Register().

◆ r_lerpmodels

cvar_t* r_lerpmodels

Definition at line 130 of file r_main.c.

Referenced by R_Register().

◆ r_lightlevel

cvar_t* r_lightlevel

Definition at line 134 of file r_main.c.

Referenced by R_Register(), and R_SetLightLevel().

◆ r_newrefdef

refdef_t r_newrefdef

Definition at line 36 of file r_main.c.

Referenced by R_CalcPalette(), R_DrawBEntitiesOnList(), R_DrawEntitiesOnList(), R_DrawParticles(), R_EdgeDrawing(), R_RenderFrame(), R_RenderView(), R_SetFrustum(), R_SetLightLevel(), R_SetupFrame(), and R_SetupGL().

◆ r_nocull

cvar_t* r_nocull

Definition at line 79 of file gl_rmain.c.

Referenced by R_CullBox(), and R_Register().

◆ r_norefresh

cvar_t* r_norefresh

Definition at line 73 of file gl_rmain.c.

Referenced by R_Register(), and R_RenderView().

◆ r_notexture

image_t* r_notexture

Definition at line 38 of file gl_rmain.c.

Referenced by GL_FreeUnusedImages(), GL_LoadWal(), Mod_LoadTexinfo(), R_DrawAliasModel(), R_InitParticleTexture(), and R_SetSky().

◆ r_novis

cvar_t* r_novis

Definition at line 131 of file r_main.c.

Referenced by R_MarkLeaves(), and R_Register().

◆ r_oldviewcluster

int r_oldviewcluster

Definition at line 181 of file gl_local.h.

◆ r_oldviewcluster2

int r_oldviewcluster2

Definition at line 181 of file gl_local.h.

Referenced by R_MarkLeaves().

◆ r_origin

vec3_t r_origin

Definition at line 69 of file r_main.c.

Referenced by GL_DrawParticles(), R_DrawBEntitiesOnList(), R_DrawEntitiesOnList(), R_SetFrustum(), and R_SetupFrame().

◆ r_particletexture

image_t* r_particletexture

Definition at line 39 of file gl_rmain.c.

Referenced by GL_DrawParticles(), GL_FreeUnusedImages(), and R_InitParticleTexture().

◆ r_speeds

cvar_t* r_speeds

Definition at line 133 of file r_main.c.

Referenced by R_Register(), R_RenderFrame(), and R_RenderView().

◆ r_viewcluster

int r_viewcluster

Definition at line 102 of file r_main.c.

Referenced by R_MarkLeaves(), R_NewMap(), and R_SetupFrame().

◆ r_viewcluster2

int r_viewcluster2

Definition at line 181 of file gl_local.h.

Referenced by R_MarkLeaves().

◆ r_visframecount

int r_visframecount

Definition at line 92 of file r_main.c.

Referenced by R_FindTopnode(), and R_MarkLeaves().

◆ r_world_matrix

float r_world_matrix[16]

Definition at line 63 of file gl_rmain.c.

Referenced by R_DrawAlphaSurfaces(), and R_SetupGL().

◆ r_worldmodel

model_t* r_worldmodel

Definition at line 39 of file r_main.c.

Referenced by R_FindTopnode(), R_MarkLeaves(), R_RenderFrame(), R_RenderView(), and R_SetupFrame().

◆ registration_sequence

int registration_sequence

Definition at line 44 of file r_model.c.

Referenced by GL_FindImage(), GL_FreeUnusedImages(), GL_InitImages(), GL_LoadPic(), R_BeginRegistration(), R_EndRegistration(), R_FindImage(), R_FreeUnusedImages(), R_InitImages(), R_LoadWal(), and R_RegisterModel().

◆ ri

refimport_t ri

Definition at line 25 of file r_main.c.

Referenced by Com_Printf(), Draw_GetPalette(), GetRefAPI(), R_BeginFrame(), R_DrawEntitiesOnList(), R_DrawSpriteModel(), R_Init(), R_Register(), R_RenderFrame(), R_RenderView(), R_SetMode(), R_Shutdown(), R_UnRegister(), and Sys_Error().

◆ vid

viddef_t vid

Definition at line 24 of file r_main.c.

Referenced by Draw_GetPalette(), R_BeginFrame(), R_CinematicSetPalette(), R_InitGraphics(), R_SetGL2D(), R_SetMode(), R_SetupFrame(), R_SetupGL(), and R_Shutdown().

◆ vid_fullscreen

cvar_t* vid_fullscreen

Definition at line 46 of file vid_dll.c.

Referenced by MainWndProc(), R_BeginFrame(), R_Register(), R_SetMode(), VID_CheckChanges(), and VID_Init().

◆ vid_gamma

cvar_t* vid_gamma

Definition at line 42 of file vid_dll.c.

Referenced by Draw_BuildGammaTable(), GL_InitImages(), QGL_Init(), R_BeginFrame(), R_Register(), and VID_Init().

◆ vpn

vec3_t vpn

Definition at line 67 of file r_main.c.

Referenced by GL_DrawParticles(), R_DrawBEntitiesOnList(), R_SetFrustum(), and R_SetupFrame().

◆ vright

vec3_t vright

Definition at line 68 of file r_main.c.

Referenced by GL_DrawParticles(), R_DrawBEntitiesOnList(), R_DrawSpriteModel(), R_SetFrustum(), and R_SetupFrame().

◆ vup

vec3_t vup

Definition at line 66 of file r_main.c.

Referenced by GL_DrawParticles(), R_DrawBEntitiesOnList(), R_DrawSpriteModel(), R_SetFrustum(), and R_SetupFrame().

GL_RENDERER_VOODOO
#define GL_RENDERER_VOODOO
Definition: gl_local.h:364
vid_fullscreen
cvar_t * vid_fullscreen
Definition: vid_dll.c:46
RF_TRANSLUCENT
#define RF_TRANSLUCENT
Definition: q_shared.h:618
logMapGrid2d
static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
Definition: qgl_win.c:1737
logEndList
static void APIENTRY logEndList(void)
Definition: qgl_win.c:1188
logGetMapiv
static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
Definition: qgl_win.c:1385
RF_NOSHADOW
#define RF_NOSHADOW
Definition: q_shared.h:626
logBitmap
static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
Definition: qgl_win.c:787
logRectsv
static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
Definition: qgl_win.c:2158
it_sprite
@ it_sprite
Definition: r_local.h:59
VID_CreateWindow
qboolean VID_CreateWindow(int width, int height, qboolean fullscreen)
Definition: glw_imp.c:64
GLimp_Shutdown
void GLimp_Shutdown(void)
Definition: glw_imp.c:302
logNormal3bv
static void APIENTRY logNormal3bv(const GLbyte *v)
Definition: qgl_win.c:1800
refdef_t::vieworg
float vieworg[3]
Definition: ref.h:124
logVertex4iv
static void APIENTRY logVertex4iv(const GLint *v)
Definition: qgl_win.c:2612
numgltextures
int numgltextures
Definition: gl_image.c:24
logClearDepth
static void APIENTRY logClearDepth(GLclampd depth)
Definition: qgl_win.c:829
logIndexsv
static void APIENTRY logIndexsv(const GLshort *c)
Definition: qgl_win.c:1558
rserr_t
rserr_t
Definition: r_local.h:97
sky_images
image_t * sky_images[6]
Definition: gl_warp.c:29
LoadTGA
void LoadTGA(char *name, byte **pic, int *width, int *height)
Definition: gl_image.c:550
RF_SHELL_RED
#define RF_SHELL_RED
Definition: q_shared.h:623
height
GLsizei height
Definition: qgl_win.c:69
logVertex4sv
static void APIENTRY logVertex4sv(const GLshort *v)
Definition: qgl_win.c:2622
currentmodel
model_t * currentmodel
Definition: r_main.c:37
r_framecount
int r_framecount
Definition: r_main.c:91
GL_LoadPic
image_t * GL_LoadPic(char *name, byte *pic, int width, int height, imagetype_t type)
Definition: r_image.c:420
entity_s::skin
struct image_s * skin
Definition: ref.h:75
logCopyPixels
static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
Definition: qgl_win.c:1050
GL_UpdateSwapInterval
void GL_UpdateSwapInterval(void)
Definition: gl_rmisc.c:232
msurface_s::styles
byte styles[MAXLIGHTMAPS]
Definition: r_model.h:115
c_brush_polys
int c_brush_polys
Definition: gl_rmain.c:49
glstate_t::stereo_enabled
qboolean stereo_enabled
Definition: gl_local.h:430
entity_s::origin
float origin[3]
Definition: ref.h:57
R_Register
void R_Register(void)
Definition: r_main.c:245
logTexCoord4d
static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Definition: qgl_win.c:2351
RF_IR_VISIBLE
#define RF_IR_VISIBLE
Definition: q_shared.h:629
logPixelMapfv
static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
Definition: qgl_win.c:1866
logTexCoord4i
static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
Definition: qgl_win.c:2371
logTexCoord4dv
static void APIENTRY logTexCoord4dv(const GLdouble *v)
Definition: qgl_win.c:2356
gl_particle_att_c
cvar_t * gl_particle_att_c
Definition: gl_rmain.c:95
R_InitImages
void R_InitImages(void)
Definition: r_image.c:607
logFlush
static void APIENTRY logFlush(void)
Definition: qgl_win.c:1271
logVertex2d
static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
Definition: qgl_win.c:2506
r_particletexture
image_t * r_particletexture
Definition: gl_rmain.c:39
logDisableClientState
static void APIENTRY logDisableClientState(GLenum array)
Definition: qgl_win.c:1122
logVertex2s
static void APIENTRY logVertex2s(GLshort x, GLshort y)
Definition: qgl_win.c:2537
r_novis
cvar_t * r_novis
Definition: r_main.c:131
LittleShort
short LittleShort(short l)
Definition: q_shared.c:946
model_s::vis
dvis_t * vis
Definition: r_model.h:229
logGetTexParameteriv
static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
Definition: qgl_win.c:1492
int
CONST PIXELFORMATDESCRIPTOR int
Definition: qgl_win.c:35
r_visframecount
int r_visframecount
Definition: r_main.c:92
logTexImage2D
static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
Definition: qgl_win.c:2457
logEvalMesh2
static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Definition: qgl_win.c:1243
RF_MINLIGHT
#define RF_MINLIGHT
Definition: q_shared.h:613
VectorSubtract
#define VectorSubtract(a, b, c)
Definition: q_shared.h:156
glw_state
glwstate_t glw_state
Definition: glw_imp.c:42
logEvalCoord1d
static void APIENTRY logEvalCoord1d(GLdouble u)
Definition: qgl_win.c:1194
Sys_SetFPCW
void Sys_SetFPCW(void)
Definition: rw_imp.c:437
R_ShutdownImages
void R_ShutdownImages(void)
Definition: r_image.c:617
RF_SHELL_HALF_DAM
#define RF_SHELL_HALF_DAM
Definition: q_shared.h:631
logPixelTransferi
static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
Definition: qgl_win.c:1899
logColor4dv
static void APIENTRY logColor4dv(const GLdouble *v)
Definition: qgl_win.c:968
image_s::th
float th
Definition: gl_local.h:103
logMultMatrixd
static void APIENTRY logMultMatrixd(const GLdouble *m)
Definition: qgl_win.c:1776
glwstate_t::hDC
HDC hDC
Definition: glw_win.h:32
logLightfv
static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
Definition: qgl_win.c:1635
logMapGrid1d
static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
Definition: qgl_win.c:1725
r_notexture
image_t * r_notexture
Definition: gl_rmain.c:38
c_visible_lightmaps
int c_visible_lightmaps
Definition: gl_rsurf.c:39
scrap_texels
byte scrap_texels[MAX_SCRAPS][BLOCK_WIDTH *BLOCK_HEIGHT]
Definition: gl_image.c:363
logTexParameterfv
static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
Definition: qgl_win.c:2469
Sys_MakeCodeWriteable
void Sys_MakeCodeWriteable(unsigned long startaddr, unsigned long length)
Definition: rw_imp.c:408
viddef_t::buffer
pixel_t * buffer
Definition: r_local.h:88
R_SetupFrame
void R_SetupFrame(void)
Definition: gl_rmain.c:613
r_oldviewcluster
int r_oldviewcluster
Definition: r_main.c:102
gl_shadows
cvar_t * gl_shadows
Definition: gl_rmain.c:108
logGetTexEnviv
static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
Definition: qgl_win.c:1445
MakeSkyVec
void MakeSkyVec(float s, float t, int axis)
Definition: gl_warp.c:520
logEvalCoord2d
static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
Definition: qgl_win.c:1217
logStencilOp
static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
Definition: qgl_win.c:2222
BOX_ON_PLANE_SIDE
#define BOX_ON_PLANE_SIDE(emins, emaxs, p)
Definition: q_shared.h:190
GL_SHARED_TEXTURE_PALETTE_EXT
#define GL_SHARED_TEXTURE_PALETTE_EXT
Definition: qgl.h:464
scrap_dirty
qboolean scrap_dirty
Definition: gl_image.c:364
logColor3i
static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
Definition: qgl_win.c:889
model_s::nummodelsurfaces
int nummodelsurfaces
Definition: r_model.h:196
logEvalCoord2fv
static void APIENTRY logEvalCoord2fv(const GLfloat *u)
Definition: qgl_win.c:1232
logRasterPos2i
static void APIENTRY logRasterPos2i(GLint x, GLint y)
Definition: qgl_win.c:2009
logEdgeFlagv
static void APIENTRY logEdgeFlagv(const GLboolean *flag)
Definition: qgl_win.c:1164
gl_state
glstate_t gl_state
Definition: gl_rmain.c:36
R_PushDlights
void R_PushDlights(model_t *model)
Definition: r_light.c:94
logColor3iv
static void APIENTRY logColor3iv(const GLint *v)
Definition: qgl_win.c:895
msurface_s::light_t
int light_t
Definition: gl_model.h:108
logVertex2sv
static void APIENTRY logVertex2sv(const GLshort *v)
Definition: qgl_win.c:2542
it_sprite
@ it_sprite
Definition: gl_local.h:88
loadmodel
model_t * loadmodel
Definition: r_model.c:27
logVertex3iv
static void APIENTRY logVertex3iv(const GLint *v)
Definition: qgl_win.c:2572
logClear
static void APIENTRY logClear(GLbitfield mask)
Definition: qgl_win.c:811
ri
refimport_t ri
Definition: r_main.c:25
pcx_t
Definition: qfiles.h:60
skyaxis
vec3_t skyaxis
Definition: gl_warp.c:28
Sys_Mkdir
void Sys_Mkdir(char *path)
Definition: q_shwin.c:135
logIndexPointer
static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
Definition: qgl_win.c:1510
RF_SHELL_GREEN
#define RF_SHELL_GREEN
Definition: q_shared.h:624
glstate_t::currenttextures
int currenttextures[2]
Definition: gl_local.h:426
logGetClipPlane
static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
Definition: qgl_win.c:1331
GL_TextureAlphaMode
void GL_TextureAlphaMode(char *string)
Definition: gl_image.c:254
PRINT_DEVELOPER
#define PRINT_DEVELOPER
Definition: qcommon.h:744
miptex_s
Definition: qfiles.h:198
logTexEnvfv
static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
Definition: qgl_win.c:2403
dllGetString
const GLubyte *APIENTRY * dllGetString(GLenum name)
GL_LoadWal
image_t * GL_LoadWal(char *name)
Definition: gl_image.c:1362
logLineStipple
static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
Definition: qgl_win.c:1653
logColor4d
static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
Definition: qgl_win.c:963
logColor3d
static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
Definition: qgl_win.c:865
logTexEnviv
static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
Definition: qgl_win.c:2414
v
GLdouble v
Definition: qgl_win.c:143
it_wall
@ it_wall
Definition: r_local.h:60
logLightiv
static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
Definition: qgl_win.c:1647
logGetString
static const GLubyte *APIENTRY logGetString(GLenum name)
Definition: qgl_win.c:1433
logMap1f
static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
Definition: qgl_win.c:1707
cvar_s::modified
qboolean modified
Definition: q_shared.h:323
zNear
GLdouble GLdouble GLdouble GLdouble zNear
Definition: qgl_win.c:159
dmdl_t::num_tris
int num_tris
Definition: qfiles.h:149
logRasterPos4fv
static void APIENTRY logRasterPos4fv(const GLfloat *v)
Definition: qgl_win.c:2084
gl_dynamic
cvar_t * gl_dynamic
Definition: gl_rmain.c:111
R_InitGraphics
void R_InitGraphics(int width, int height)
Definition: r_main.c:1066
gldepthmax
float gldepthmax
Definition: gl_local.h:136
glpoly_s::verts
float verts[4][VERTEXSIZE]
Definition: gl_model.h:92
modelorg
static vec3_t modelorg
Definition: gl_rsurf.c:25
logCopyTexSubImage2D
static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
Definition: qgl_win.c:1074
logEvalPoint2
static void APIENTRY logEvalPoint2(GLint i, GLint j)
Definition: qgl_win.c:1253
logRasterPos4s
static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
Definition: qgl_win.c:2099
dsprframe_t::height
int height
Definition: qfiles.h:176
d_8to24table
unsigned d_8to24table[256]
Definition: r_main.c:27
logDisable
static void APIENTRY logDisable(GLenum cap)
Definition: qgl_win.c:1116
logTexCoord2f
static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
Definition: qgl_win.c:2281
GL_TextureMode
void GL_TextureMode(char *string)
Definition: gl_image.c:217
logGetLightfv
static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
Definition: qgl_win.c:1361
logPushName
static void APIENTRY logPushName(GLuint name)
Definition: qgl_win.c:1981
qglGetString
const GLubyte *APIENTRY * qglGetString(GLenum name)
logMap2d
static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
Definition: qgl_win.c:1713
logColor3usv
static void APIENTRY logColor3usv(const GLushort *v)
Definition: qgl_win.c:945
gl_finish
cvar_t * gl_finish
Definition: gl_rmain.c:120
logIsTexture
static GLboolean APIENTRY logIsTexture(GLuint texture)
Definition: qgl_win.c:1598
logRects
static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
Definition: qgl_win.c:2153
logNormalPointer
static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
Definition: qgl_win.c:1849
logScalef
static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
Definition: qgl_win.c:2186
model_s::edges
medge_t * edges
Definition: r_model.h:211
glstate_t::currenttmu
int currenttmu
Definition: gl_local.h:427
rserr_t
rserr_t
Definition: gl_local.h:118
logRasterPos4dv
static void APIENTRY logRasterPos4dv(const GLdouble *v)
Definition: qgl_win.c:2074
logRasterPos4f
static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Definition: qgl_win.c:2079
R_LightPoint
void R_LightPoint(vec3_t p, vec3_t color)
Definition: r_light.c:224
logPushClientAttrib
static void APIENTRY logPushClientAttrib(GLbitfield mask)
Definition: qgl_win.c:1969
logRectd
static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
Definition: qgl_win.c:2120
logReadBuffer
static void APIENTRY logReadBuffer(GLenum mode)
Definition: qgl_win.c:2109
x2
GLdouble GLdouble x2
Definition: qgl_win.c:301
shadevector
vec3_t shadevector
Definition: gl_mesh.c:45
mnode_s::visframe
int visframe
Definition: r_model.h:127
vid
viddef_t vid
Definition: r_main.c:24
refimport_t::FS_LoadFile
int(* FS_LoadFile)(char *name, void **buf)
Definition: ref.h:235
VERTEXSIZE
#define VERTEXSIZE
Definition: gl_model.h:84
logGetTexGendv
static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
Definition: qgl_win.c:1451
refimport_t::Cvar_Get
cvar_t *(* Cvar_Get)(char *name, char *value, int flags)
Definition: ref.h:242
cvar_s::string
char * string
Definition: q_shared.h:320
logTexCoord1f
static void APIENTRY logTexCoord1f(GLfloat s)
Definition: qgl_win.c:2240
logDepthMask
static void APIENTRY logDepthMask(GLboolean flag)
Definition: qgl_win.c:1104
VectorScale
void VectorScale(vec3_t in, vec_t scale, vec3_t out)
Definition: q_shared.c:782
pcx_t::version
char version
Definition: qfiles.h:63
pcx_t::data
unsigned char data
Definition: qfiles.h:74
logViewport
static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
Definition: qgl_win.c:2632
logRasterPos3sv
static void APIENTRY logRasterPos3sv(const GLshort *v)
Definition: qgl_win.c:2064
logTexCoord2iv
static void APIENTRY logTexCoord2iv(const GLint *v)
Definition: qgl_win.c:2296
R_FindImage
image_t * R_FindImage(char *name, imagetype_t type)
Definition: r_image.c:497
qboolean
qboolean
Definition: q_shared.h:56
x
GLint GLenum GLint x
Definition: qgl_win.c:116
viddef_t::width
int width
Definition: vid.h:29
logRectfv
static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
Definition: qgl_win.c:2138
logTexCoord1fv
static void APIENTRY logTexCoord1fv(const GLfloat *v)
Definition: qgl_win.c:2245
logGenTextures
static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
Definition: qgl_win.c:1319
oldrefdef_t::xOrigin
float xOrigin
Definition: r_local.h:129
logCallLists
static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
Definition: qgl_win.c:805
entity_s::skinnum
int skinnum
Definition: ref.h:70
logTexCoord1i
static void APIENTRY logTexCoord1i(GLint s)
Definition: qgl_win.c:2250
VectorClear
#define VectorClear(a)
Definition: q_shared.h:159
i
int i
Definition: q_shared.c:305
msurface_s::numedges
int numedges
Definition: r_model.h:104
logRasterPos3dv
static void APIENTRY logRasterPos3dv(const GLdouble *v)
Definition: qgl_win.c:2034
modelorg
vec3_t modelorg
Definition: r_bsp.c:29
gl_alpha_modes
gltmode_t gl_alpha_modes[]
Definition: gl_image.c:187
logMap2f
static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
Definition: qgl_win.c:1719
msurface_s::dlightframe
int dlightframe
Definition: r_model.h:97
c_alias_polys
int c_alias_polys
Definition: gl_rmain.c:49
logNormal3iv
static void APIENTRY logNormal3iv(const GLint *v)
Definition: qgl_win.c:1834
gammatable
static unsigned char gammatable[256]
Definition: gl_image.c:28
gl_particle_att_a
cvar_t * gl_particle_att_a
Definition: gl_rmain.c:93
glwstate_t::log_fp
FILE * log_fp
Definition: glw_win.h:42
logIsList
static GLboolean APIENTRY logIsList(GLuint list)
Definition: qgl_win.c:1593
logGetMapfv
static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
Definition: qgl_win.c:1379
GL_DrawAliasShadow
void GL_DrawAliasShadow(dmdl_t *paliashdr, int posenum)
Definition: gl_mesh.c:310
logRectf
static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
Definition: qgl_win.c:2132
mleaf_s::visframe
int visframe
Definition: r_model.h:147
logTexCoord1sv
static void APIENTRY logTexCoord1sv(const GLshort *v)
Definition: qgl_win.c:2265
mnode_s::parent
struct mnode_s * parent
Definition: r_model.h:131
NUM_GL_ALPHA_MODES
#define NUM_GL_ALPHA_MODES
Definition: gl_image.c:196
sw_lockpvs
cvar_t * sw_lockpvs
Definition: r_main.c:140
logRasterPos3s
static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
Definition: qgl_win.c:2059
mnode_s
Definition: r_model.h:123
logLoadMatrixd
static void APIENTRY logLoadMatrixd(const GLdouble *m)
Definition: qgl_win.c:1677
logCopyTexImage2D
static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
Definition: qgl_win.c:1062
logGetMapdv
static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
Definition: qgl_win.c:1373
buffer
GLenum GLfloat * buffer
Definition: qgl_win.c:151
logRenderMode
static GLint APIENTRY logRenderMode(GLenum mode)
Definition: qgl_win.c:2163
r_drawworld
cvar_t * r_drawworld
Definition: r_main.c:126
glpoly_s::next
struct glpoly_s * next
Definition: gl_model.h:88
viddef_t::height
int height
Definition: vid.h:29
logVertex2i
static void APIENTRY logVertex2i(GLint x, GLint y)
Definition: qgl_win.c:2527
PITCH
#define PITCH
Definition: q_shared.h:65
r_aliasuvscale
float r_aliasuvscale
Definition: r_main.c:50
logGetTexImage
static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
Definition: qgl_win.c:1469
logRasterPos2sv
static void APIENTRY logRasterPos2sv(const GLshort *v)
Definition: qgl_win.c:2024
upload_width
int upload_width
Definition: gl_image.c:973
dlight_t::origin
vec3_t origin
Definition: ref.h:91
logRasterPos4d
static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Definition: qgl_win.c:2069
refimport_t::Cvar_Set
cvar_t *(* Cvar_Set)(char *name, char *value)
Definition: ref.h:243
pointcolor
vec3_t pointcolor
Definition: r_light.c:116
r_origin
vec3_t r_origin
Definition: r_main.c:69
logRasterPos2iv
static void APIENTRY logRasterPos2iv(const GLint *v)
Definition: qgl_win.c:2014
refdef_t::rdflags
int rdflags
Definition: ref.h:128
logTexCoord2s
static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
Definition: qgl_win.c:2301
logTexCoord4fv
static void APIENTRY logTexCoord4fv(const GLfloat *v)
Definition: qgl_win.c:2366
logRasterPos4iv
static void APIENTRY logRasterPos4iv(const GLint *v)
Definition: qgl_win.c:2094
GL_Upload32
qboolean GL_Upload32(unsigned *data, int width, int height, qboolean mipmap)
Definition: gl_image.c:976
SWimp_Shutdown
void SWimp_Shutdown(void)
Definition: rw_imp.c:359
logColorPointer
static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
Definition: qgl_win.c:1044
width
GLint GLsizei width
Definition: qgl_win.c:115
R_TextureAnimation
image_t * R_TextureAnimation(mtexinfo_t *tex)
Definition: gl_rsurf.c:83
logEvalCoord1dv
static void APIENTRY logEvalCoord1dv(const GLdouble *u)
Definition: qgl_win.c:1200
mnode_s::children
struct mnode_s * children[2]
Definition: r_model.h:135
logDrawElements
static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
Definition: qgl_win.c:1140
logPixelZoom
static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
Definition: qgl_win.c:1905
logMapGrid1f
static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
Definition: qgl_win.c:1731
entity_s::flags
int flags
Definition: ref.h:76
pcx_t::hres
unsigned short hres
Definition: qfiles.h:67
r_alpha_surfaces
msurface_t * r_alpha_surfaces
Definition: r_poly.c:45
logRasterPos4sv
static void APIENTRY logRasterPos4sv(const GLshort *v)
Definition: qgl_win.c:2104
logTexGenfv
static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
Definition: qgl_win.c:2437
vid_gamma
cvar_t * vid_gamma
Definition: r_main.c:137
M_PI
#define M_PI
Definition: q_shared.h:135
gl_nobind
cvar_t * gl_nobind
Definition: gl_rmain.c:114
image_s::registration_sequence
int registration_sequence
Definition: r_local.h:71
currententity
entity_t * currententity
Definition: r_bsp.c:28
logRasterPos3d
static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
Definition: qgl_win.c:2029
SURF_WARP
#define SURF_WARP
Definition: qfiles.h:372
logTexCoord4iv
static void APIENTRY logTexCoord4iv(const GLint *v)
Definition: qgl_win.c:2376
logArrayElement
static void APIENTRY logArrayElement(GLint i)
Definition: qgl_win.c:769
type
GLenum type
Definition: qgl_win.c:72
logRectiv
static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
Definition: qgl_win.c:2148
logFogi
static void APIENTRY logFogi(GLenum pname, GLint param)
Definition: qgl_win.c:1289
logIndexd
static void APIENTRY logIndexd(GLdouble c)
Definition: qgl_win.c:1516
logTexCoord1d
static void APIENTRY logTexCoord1d(GLdouble s)
Definition: qgl_win.c:2228
oldrefdef_t::yOrigin
float yOrigin
Definition: r_local.h:130
mplane_s::normal
vec3_t normal
Definition: r_model.h:59
logClearAccum
static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Definition: qgl_win.c:817
msurface_s::extents
short extents[2]
Definition: r_model.h:110
logTexCoord4sv
static void APIENTRY logTexCoord4sv(const GLshort *v)
Definition: qgl_win.c:2386
uploaded_paletted
qboolean uploaded_paletted
Definition: gl_image.c:974
logColor3ui
static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
Definition: qgl_win.c:927
logNewList
static void APIENTRY logNewList(GLuint list, GLenum mode)
Definition: qgl_win.c:1788
logBlendFunc
static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
Definition: qgl_win.c:793
logTexGenf
static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
Definition: qgl_win.c:2432
R_MarkLights
void R_MarkLights(dlight_t *light, int bit, mnode_t *node)
Definition: r_light.c:40
NUM_GL_SOLID_MODES
#define NUM_GL_SOLID_MODES
Definition: gl_image.c:210
logLightModeliv
static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
Definition: qgl_win.c:1623
glmode_t::minimize
int minimize
Definition: gl_image.c:167
logTexGeniv
static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
Definition: qgl_win.c:2447
intensity
cvar_t * intensity
Definition: gl_image.c:30
mleaf_s
Definition: r_model.h:143
R_MarkLights
void R_MarkLights(dlight_t *light, int bit, mnode_t *node)
Definition: gl_light.c:118
logColor4uiv
static void APIENTRY logColor4uiv(const GLuint *v)
Definition: qgl_win.c:1018
logDepthRange
static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
Definition: qgl_win.c:1110
r_avertexnormal_dots
float r_avertexnormal_dots[SHADEDOT_QUANT][256]
Definition: gl_mesh.c:50
SURF_TRANS66
#define SURF_TRANS66
Definition: qfiles.h:374
r_lefthand
cvar_t * r_lefthand
Definition: r_main.c:111
model_s::extradata
void * extradata
Definition: r_model.h:235
GL_TextureSolidMode
void GL_TextureSolidMode(char *string)
Definition: gl_image.c:278
logEvalCoord1f
static void APIENTRY logEvalCoord1f(GLfloat u)
Definition: qgl_win.c:1206
R_RenderDlight
void R_RenderDlight(dlight_t *light)
Definition: gl_light.c:36
logNormal3f
static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
Definition: qgl_win.c:1818
refimport_t::FS_FreeFile
void(* FS_FreeFile)(void *buf)
Definition: ref.h:236
r_worldmodel
model_t * r_worldmodel
Definition: gl_rmain.c:31
j
GLint j
Definition: qgl_win.c:150
logVertex3dv
static void APIENTRY logVertex3dv(const GLdouble *v)
Definition: qgl_win.c:2552
gl_solid_modes
gltmode_t gl_solid_modes[]
Definition: gl_image.c:198
imagetype_t
imagetype_t
Definition: gl_local.h:85
logScaled
static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
Definition: qgl_win.c:2180
Draw_GetPalette
void Draw_GetPalette(void)
Definition: r_main.c:1326
R_FloodFillSkin
void R_FloodFillSkin(byte *skin, int skinwidth, int skinheight)
Definition: gl_image.c:778
logTexCoord2fv
static void APIENTRY logTexCoord2fv(const GLfloat *v)
Definition: qgl_win.c:2286
gl_filter_min
int gl_filter_min
Definition: gl_image.c:44
logPolygonStipple
static void APIENTRY logPolygonStipple(const GLubyte *mask)
Definition: qgl_win.c:1928
r_norefresh
cvar_t * r_norefresh
Definition: gl_rmain.c:73
logTexCoord2i
static void APIENTRY logTexCoord2i(GLint s, GLint t)
Definition: qgl_win.c:2291
logPushAttrib
static void APIENTRY logPushAttrib(GLbitfield mask)
Definition: qgl_win.c:1963
it_pic
@ it_pic
Definition: gl_local.h:90
mvertex_t::position
vec3_t position
Definition: r_model.h:47
logPolygonOffset
static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
Definition: qgl_win.c:1923
logNormal3s
static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
Definition: qgl_win.c:1839
gl_texturemode
cvar_t * gl_texturemode
Definition: gl_rmain.c:128
gl_tex_alpha_format
int gl_tex_alpha_format
Definition: gl_image.c:42
logMatrixMode
static void APIENTRY logMatrixMode(GLenum mode)
Definition: qgl_win.c:1770
Mod_FreeAll
void Mod_FreeAll(void)
Definition: r_model.c:1250
refimport_t::Vid_GetModeInfo
qboolean(* Vid_GetModeInfo)(int *width, int *height, int mode)
Definition: ref.h:246
logCullFace
static void APIENTRY logCullFace(GLenum mode)
Definition: qgl_win.c:1080
logClearStencil
static void APIENTRY logClearStencil(GLint s)
Definition: qgl_win.c:841
logColor3dv
static void APIENTRY logColor3dv(const GLdouble *v)
Definition: qgl_win.c:871
r_dlightframecount
int r_dlightframecount
Definition: gl_light.c:24
skyrotate
float skyrotate
Definition: gl_warp.c:27
r_refdef
oldrefdef_t r_refdef
Definition: r_main.c:74
dsprite_t
Definition: qfiles.h:181
AngleVectors
void AngleVectors(vec3_t angles, vec3_t forward, vec3_t right, vec3_t up)
Definition: q_shared.c:93
glpoly_s::numverts
int numverts
Definition: gl_model.h:90
RF_WEAPONMODEL
#define RF_WEAPONMODEL
Definition: q_shared.h:615
logNormal3sv
static void APIENTRY logNormal3sv(const GLshort *v)
Definition: qgl_win.c:1844
logPixelStorei
static void APIENTRY logPixelStorei(GLenum pname, GLint param)
Definition: qgl_win.c:1888
gltextures
image_t gltextures[MAX_GLTEXTURES]
Definition: gl_image.c:23
logVertex4s
static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
Definition: qgl_win.c:2617
refimport_t::Con_Printf
void(* Con_Printf)(int print_level, char *str,...)
Definition: ref.h:228
PRINT_ALL
#define PRINT_ALL
Definition: qcommon.h:743
R_SetFrustum
void R_SetFrustum(void)
Definition: gl_rmain.c:566
logRasterPos3i
static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
Definition: qgl_win.c:2049
R_DrawInlineBModel
void R_DrawInlineBModel(void)
Definition: gl_rsurf.c:887
pcx_t::ymin
unsigned short ymin
Definition: qfiles.h:66
logRasterPos3iv
static void APIENTRY logRasterPos3iv(const GLint *v)
Definition: qgl_win.c:2054
gl_drawbuffer
cvar_t * gl_drawbuffer
Definition: gl_rmain.c:105
GL_EnableMultitexture
void GL_EnableMultitexture(qboolean enable)
Definition: gl_image.c:70
RDF_NOWORLDMODEL
#define RDF_NOWORLDMODEL
Definition: q_shared.h:646
mnode_s::plane
mplane_t * plane
Definition: r_model.h:134
logGenLists
static GLuint APIENTRY logGenLists(GLsizei range)
Definition: qgl_win.c:1313
logLightf
static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
Definition: qgl_win.c:1629
skymaxs
float skymaxs[2][6]
Definition: gl_warp.c:302
NUM_BEAM_SEGS
#define NUM_BEAM_SEGS
logTexCoord3dv
static void APIENTRY logTexCoord3dv(const GLdouble *v)
Definition: qgl_win.c:2316
logTexSubImage1D
static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
Definition: qgl_win.c:2484
TEXNUM_IMAGES
#define TEXNUM_IMAGES
Definition: gl_local.h:112
logScissor
static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
Definition: qgl_win.c:2192
logTexCoord3i
static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
Definition: qgl_win.c:2331
SHADEDOT_QUANT
#define SHADEDOT_QUANT
Definition: gl_mesh.c:49
image_s::scrap
qboolean scrap
Definition: gl_local.h:104
skin
cvar_t * skin
Definition: cl_main.c:95
D_FlushCaches
void D_FlushCaches(void)
Definition: r_surf.c:418
logCallList
static void APIENTRY logCallList(GLuint list)
Definition: qgl_win.c:799
logPopMatrix
static void APIENTRY logPopMatrix(void)
Definition: qgl_win.c:1945
Draw_InitLocal
void Draw_InitLocal(void)
Definition: r_draw.c:58
logPassThrough
static void APIENTRY logPassThrough(GLfloat token)
Definition: qgl_win.c:1860
logIndexf
static void APIENTRY logIndexf(GLfloat c)
Definition: qgl_win.c:1528
numleafs
int numleafs
Definition: cmodel.c:77
gl_texturealphamode
cvar_t * gl_texturealphamode
Definition: gl_rmain.c:129
logRasterPos4i
static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
Definition: qgl_win.c:2089
logLineWidth
static void APIENTRY logLineWidth(GLfloat width)
Definition: qgl_win.c:1659
it_pic
@ it_pic
Definition: r_local.h:61
shadedots
float * shadedots
Definition: gl_mesh.c:54
logHint
static void APIENTRY logHint(GLenum target, GLenum mode)
Definition: qgl_win.c:1498
R_BlendLightmaps
void R_BlendLightmaps(void)
Definition: gl_rsurf.c:323
entity_s::alpha
float alpha
Definition: ref.h:73
viddef_t::rowbytes
int rowbytes
Definition: r_local.h:91
logTexCoord3d
static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
Definition: qgl_win.c:2311
rserr_invalid_fullscreen
@ rserr_invalid_fullscreen
Definition: gl_local.h:122
vid_fullscreen
cvar_t * vid_fullscreen
Definition: r_main.c:136
r
GLdouble GLdouble r
Definition: qgl_win.c:336
gltmode_t::mode
int mode
Definition: gl_image.c:184
dvis_t::numclusters
int numclusters
Definition: qfiles.h:465
mplane_s::dist
float dist
Definition: r_model.h:60
LittleLong
int LittleLong(int l)
Definition: q_shared.c:948
R_BuildPolygonFromSurface
void R_BuildPolygonFromSurface(msurface_t *fa)
Definition: r_poly.c:1010
image_s::height
int height
Definition: r_local.h:69
logLoadMatrixf
static void APIENTRY logLoadMatrixf(const GLfloat *m)
Definition: qgl_win.c:1683
R_DrawTriangleOutlines
void R_DrawTriangleOutlines(void)
Definition: gl_rsurf.c:230
Draw_StretchPicImplementation
void Draw_StretchPicImplementation(int x, int y, int w, int h, image_t *pic)
Definition: r_draw.c:163
logVertex3fv
static void APIENTRY logVertex3fv(const GLfloat *v)
Definition: qgl_win.c:2562
r_lerpmodels
cvar_t * r_lerpmodels
Definition: r_main.c:130
logIndexs
static void APIENTRY logIndexs(GLshort c)
Definition: qgl_win.c:1552
HDC
HDC(WINAPI *qwglGetCurrentDC)(VOID)
R_InitTextures
void R_InitTextures(void)
Definition: r_main.c:196
logPrioritizeTextures
static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
Definition: qgl_win.c:1957
clipplane_s::leftedge
byte leftedge
Definition: r_local.h:354
refdef_t::num_dlights
int num_dlights
Definition: ref.h:137
logIndexiv
static void APIENTRY logIndexiv(const GLint *c)
Definition: qgl_win.c:1546
logColor4b
static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
Definition: qgl_win.c:951
R_ClearSkyBox
void R_ClearSkyBox(void)
Definition: gl_warp.c:508
clipplane_s::rightedge
byte rightedge
Definition: r_local.h:355
logEnable
static void APIENTRY logEnable(GLenum cap)
Definition: qgl_win.c:1170
intensitytable
static byte intensitytable[256]
Definition: gl_image.c:27
logTexGeni
static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
Definition: qgl_win.c:2442
logTexCoord3iv
static void APIENTRY logTexCoord3iv(const GLint *v)
Definition: qgl_win.c:2336
logFogf
static void APIENTRY logFogf(GLenum pname, GLfloat param)
Definition: qgl_win.c:1277
logCopyTexSubImage1D
static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
Definition: qgl_win.c:1068
logVertex4d
static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Definition: qgl_win.c:2587
logGetTexLevelParameterfv
static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
Definition: qgl_win.c:1474
forward
static vec3_t forward
Definition: p_view.c:29
logColor3b
static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
Definition: qgl_win.c:853
logVertex3f
static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
Definition: qgl_win.c:2557
particle_t::alpha
float alpha
Definition: ref.h:100
RF_DEPTHHACK
#define RF_DEPTHHACK
Definition: q_shared.h:617
R_GammaCorrectAndSetPalette
void R_GammaCorrectAndSetPalette(const unsigned char *palette)
Definition: r_main.c:1160
logDeleteTextures
static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
Definition: qgl_win.c:1092
rserr_invalid_mode
@ rserr_invalid_mode
Definition: r_local.h:102
PerpendicularVector
void PerpendicularVector(vec3_t dst, const vec3_t src)
Definition: q_shared.c:152
glwstate_t::hGLRC
HGLRC hGLRC
Definition: glw_win.h:34
VectorLength
vec_t VectorLength(vec3_t v)
Definition: q_shared.c:762
glwstate_t::hWnd
HWND hWnd
Definition: glw_win.h:33
logTexCoord2d
static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
Definition: qgl_win.c:2270
msurface_s::texinfo
mtexinfo_t * texinfo
Definition: r_model.h:112
GLuint
GLuint(APIENTRY *qglGenLists)(GLsizei range)
model_s::leafs
mleaf_t * leafs
Definition: r_model.h:205
logGetTexLevelParameteriv
static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
Definition: qgl_win.c:1480
logRasterPos3f
static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
Definition: qgl_win.c:2039
t
GLdouble t
Definition: qgl_win.c:328
model_s::nodes
mnode_t * nodes
Definition: r_model.h:215
RDF_IRGOGGLES
#define RDF_IRGOGGLES
Definition: q_shared.h:649
logColor4ui
static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
Definition: qgl_win.c:1013
Q_ftol
long Q_ftol(float f)
logSelectBuffer
static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
Definition: qgl_win.c:2198
model_s::mins
vec3_t mins
Definition: r_model.h:185
mleaf_s::cluster
int cluster
Definition: r_model.h:154
logDrawPixels
static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
Definition: qgl_win.c:1146
image_s::texnum
int texnum
Definition: gl_local.h:102
ri
refimport_t ri
Definition: gl_rmain.c:27
r_origin
vec3_t r_origin
Definition: gl_rmain.c:61
logColorMask
static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
Definition: qgl_win.c:1033
logMaterialf
static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
Definition: qgl_win.c:1747
refimport_t::Sys_Error
void(* Sys_Error)(int err_level, char *str,...)
Definition: ref.h:220
logGetPixelMapuiv
static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
Definition: qgl_win.c:1409
GL_Bind
void GL_Bind(int texnum)
Definition: gl_image.c:136
R_SetupGL
void R_SetupGL(void)
Definition: gl_rmain.c:700
entity_s::oldframe
int oldframe
Definition: ref.h:64
glwstate_t::hInstance
HINSTANCE hInstance
Definition: glw_win.h:29
logIndexi
static void APIENTRY logIndexi(GLint c)
Definition: qgl_win.c:1540
dlight_t::color
vec3_t color
Definition: ref.h:92
logFrontFace
static void APIENTRY logFrontFace(GLenum mode)
Definition: qgl_win.c:1301
logIndexfv
static void APIENTRY logIndexfv(const GLfloat *c)
Definition: qgl_win.c:1534
logRectdv
static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
Definition: qgl_win.c:2126
logTexParameterf
static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
Definition: qgl_win.c:2463
R_CullAliasModel
static qboolean R_CullAliasModel(vec3_t bbox[8], entity_t *e)
Definition: gl_mesh.c:388
logColor4sv
static void APIENTRY logColor4sv(const GLshort *v)
Definition: qgl_win.c:998
RF_SHELL_DOUBLE
#define RF_SHELL_DOUBLE
Definition: q_shared.h:630
glmode_t::maximize
int maximize
Definition: gl_image.c:167
SURF_FLOWING
#define SURF_FLOWING
Definition: qfiles.h:375
logPixelMapuiv
static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
Definition: qgl_win.c:1872
r_newrefdef
refdef_t r_newrefdef
Definition: r_main.c:36
DotProduct
#define DotProduct(x, y)
Definition: q_shared.h:155
SURF_TRANS33
#define SURF_TRANS33
Definition: qfiles.h:373
logColor4usv
static void APIENTRY logColor4usv(const GLushort *v)
Definition: qgl_win.c:1028
r_worldmodel
model_t * r_worldmodel
Definition: r_main.c:39
logTexCoord2sv
static void APIENTRY logTexCoord2sv(const GLshort *v)
Definition: qgl_win.c:2306
logMap1d
static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
Definition: qgl_win.c:1701
r_worldmodel
model_t * r_worldmodel
Definition: r_main.c:39
pcx_t::ymax
unsigned short ymax
Definition: qfiles.h:66
logPolygonMode
static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
Definition: qgl_win.c:1917
cvar_s::value
float value
Definition: q_shared.h:324
logVertex4dv
static void APIENTRY logVertex4dv(const GLdouble *v)
Definition: qgl_win.c:2592
entity_s::backlerp
float backlerp
Definition: ref.h:69
r_particletexture
image_t * r_particletexture
Definition: gl_rmain.c:39
logClearColor
static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Definition: qgl_win.c:823
GL_Upload8
qboolean GL_Upload8(byte *data, int width, int height, qboolean mipmap, qboolean is_sky)
Definition: gl_image.c:1185
logVertex4f
static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Definition: qgl_win.c:2597
logIsEnabled
static GLboolean APIENTRY logIsEnabled(GLenum cap)
Definition: qgl_win.c:1588
MAX_GLTEXTURES
#define MAX_GLTEXTURES
Definition: gl_local.h:114
MAX_OSPATH
#define MAX_OSPATH
Definition: q_shared.h:74
R_UnRegister
void R_UnRegister(void)
Definition: r_main.c:288
XCENTERING
#define XCENTERING
Definition: r_local.h:215
model_s::lightdata
byte * lightdata
Definition: r_model.h:231
R_ClipAndDrawPoly
void R_ClipAndDrawPoly(float alpha, int isturbulent, qboolean textured)
Definition: r_poly.c:898
gl_lightmap
cvar_t * gl_lightmap
Definition: gl_rmain.c:107
logColor4bv
static void APIENTRY logColor4bv(const GLbyte *v)
Definition: qgl_win.c:957
logLighti
static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
Definition: qgl_win.c:1641
image_s::type
imagetype_t type
Definition: r_local.h:68
Mod_Init
void Mod_Init(void)
Definition: r_model.c:78
logVertex3sv
static void APIENTRY logVertex3sv(const GLshort *v)
Definition: qgl_win.c:2582
logInitNames
static void APIENTRY logInitNames(void)
Definition: qgl_win.c:1576
it_skin
@ it_skin
Definition: gl_local.h:87
logTranslatef
static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
Definition: qgl_win.c:2500
logTexEnvf
static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
Definition: qgl_win.c:2397
refimport_t::FS_Gamedir
char *(* FS_Gamedir)(void)
Definition: ref.h:240
SURF_DRAWTURB
#define SURF_DRAWTURB
Definition: r_model.h:70
DrawGLFlowingPoly
void DrawGLFlowingPoly(msurface_t *fa)
Definition: gl_rsurf.c:202
VectorNormalize
vec_t VectorNormalize(vec3_t v)
Definition: q_shared.c:681
F
#define F(X, Y, Z)
Definition: md4.c:13
logDrawBuffer
static void APIENTRY logDrawBuffer(GLenum mode)
Definition: qgl_win.c:1134
pcx_t::encoding
char encoding
Definition: qfiles.h:64
gl_bitdepth
cvar_t * gl_bitdepth
Definition: gl_rmain.c:104
NULL
#define NULL
Definition: q_shared.h:60
logOrtho
static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
Definition: qgl_win.c:1854
logGetMaterialfv
static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
Definition: qgl_win.c:1391
logVertex2fv
static void APIENTRY logVertex2fv(const GLfloat *v)
Definition: qgl_win.c:2522
glwstate_t::allowdisplaydepthchange
qboolean allowdisplaydepthchange
Definition: glw_win.h:39
logColor4iv
static void APIENTRY logColor4iv(const GLint *v)
Definition: qgl_win.c:988
refdef_t::time
float time
Definition: ref.h:127
logTexCoord2dv
static void APIENTRY logTexCoord2dv(const GLdouble *v)
Definition: qgl_win.c:2276
r_viewcluster
int r_viewcluster
Definition: r_main.c:102
rserr_invalid_mode
@ rserr_invalid_mode
Definition: gl_local.h:123
SWimp_SetMode
rserr_t SWimp_SetMode(int *pwidth, int *pheight, int mode, qboolean fullscreen)
Definition: rw_imp.c:266
glstate_t::inverse_intensity
float inverse_intensity
Definition: gl_local.h:417
logClearIndex
static void APIENTRY logClearIndex(GLfloat c)
Definition: qgl_win.c:835
model_s::surfedges
int * surfedges
Definition: r_model.h:224
logDrawArrays
static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
Definition: qgl_win.c:1128
dottexture
byte dottexture[8][8]
Definition: gl_rmisc.c:29
logGetError
static GLenum APIENTRY logGetError(void)
Definition: qgl_win.c:1343
rserr_ok
@ rserr_ok
Definition: gl_local.h:120
gl_flashblend
cvar_t * gl_flashblend
Definition: gl_rmain.c:124
image_s::pixels
byte * pixels[4]
Definition: r_local.h:72
logGetLightiv
static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
Definition: qgl_win.c:1367
TURBSCALE
#define TURBSCALE
Definition: gl_warp.c:202
logColor4s
static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
Definition: qgl_win.c:993
logDepthFunc
static void APIENTRY logDepthFunc(GLenum func)
Definition: qgl_win.c:1098
image_s::width
int width
Definition: r_local.h:69
logTexCoord3s
static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
Definition: qgl_win.c:2341
logTexSubImage2D
static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
Definition: qgl_win.c:2489
RF_GLOW
#define RF_GLOW
Definition: q_shared.h:622
logColor3bv
static void APIENTRY logColor3bv(const GLbyte *v)
Definition: qgl_win.c:859
logRasterPos2f
static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
Definition: qgl_win.c:1999
modes
glmode_t modes[]
Definition: gl_image.c:170
GL_SetTexturePalette
void GL_SetTexturePalette(unsigned palette[256])
Definition: gl_image.c:47
logGetPixelMapfv
static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
Definition: qgl_win.c:1403
image_s::tl
float tl
Definition: gl_local.h:103
particle_t
Definition: ref.h:96
it_sky
@ it_sky
Definition: gl_local.h:91
pcx_t::palette_type
unsigned short palette_type
Definition: qfiles.h:72
upload_height
int upload_height
Definition: gl_image.c:973
alpha
GLfloat GLfloat GLfloat alpha
Definition: qgl_win.c:74
refdef_t::height
int height
Definition: ref.h:122
ClipSkyPolygon
void ClipSkyPolygon(int nump, vec3_t vecs, int stage)
Definition: gl_warp.c:389
image_s::name
char name[MAX_QPATH]
Definition: r_local.h:67
logRasterPos2s
static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
Definition: qgl_win.c:2019
logTexParameteri
static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
Definition: qgl_win.c:2474
image_s::transparent
qboolean transparent
Definition: r_local.h:70
logReadPixels
static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
Definition: qgl_win.c:2114
QGL_TEXTURE0
int QGL_TEXTURE0
Definition: gl_rmain.c:29
MAX_MD2SKINS
#define MAX_MD2SKINS
Definition: qfiles.h:92
logGetTexParameterfv
static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
Definition: qgl_win.c:1486
ERR_DROP
#define ERR_DROP
Definition: qcommon.h:736
MYgluPerspective
void MYgluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
Definition: gl_rmain.c:677
logPopAttrib
static void APIENTRY logPopAttrib(void)
Definition: qgl_win.c:1933
dsprite_t::frames
dsprframe_t frames[1]
Definition: qfiles.h:185
logEvalCoord1fv
static void APIENTRY logEvalCoord1fv(const GLfloat *u)
Definition: qgl_win.c:1212
RecursiveLightPoint
int RecursiveLightPoint(mnode_t *node, vec3_t start, vec3_t end)
Definition: r_light.c:120
Q_stricmp
int Q_stricmp(char *s1, char *s2)
Definition: q_shared.c:1192
it_skin
@ it_skin
Definition: r_local.h:58
logTexImage1D
static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
Definition: qgl_win.c:2452
logColor3ub
static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
Definition: qgl_win.c:913
GL_DrawAliasFrameLerp
void GL_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
Definition: gl_mesh.c:92
d_pzbuffer
short * d_pzbuffer
Definition: r_main.c:182
gl_filter_max
int gl_filter_max
Definition: gl_image.c:45
pcx_t::bits_per_pixel
char bits_per_pixel
Definition: qfiles.h:65
r_lightlevel
cvar_t * r_lightlevel
Definition: r_main.c:134
dsprframe_t::width
int width
Definition: qfiles.h:176
particle_t::origin
vec3_t origin
Definition: ref.h:98
logLightModelf
static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
Definition: qgl_win.c:1604
name
cvar_t * name
Definition: cl_main.c:94
logColor3f
static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
Definition: qgl_win.c:877
REF_VERSION
#define REF_VERSION
Definition: r_local.h:31
MAXLIGHTMAPS
#define MAXLIGHTMAPS
Definition: qfiles.h:409
R_DrawWorld
void R_DrawWorld(void)
Definition: gl_rsurf.c:1204
logPopName
static void APIENTRY logPopName(void)
Definition: qgl_win.c:1951
R_DrawSkyBox
void R_DrawSkyBox(void)
Definition: gl_warp.c:562
ERR_FATAL
#define ERR_FATAL
Definition: qcommon.h:735
QGL_TEXTURE1
int QGL_TEXTURE1
Definition: gl_rmain.c:29
msurface_s::flags
int flags
Definition: r_model.h:101
logFinish
static void APIENTRY logFinish(void)
Definition: qgl_win.c:1265
logEdgeFlag
static void APIENTRY logEdgeFlag(GLboolean flag)
Definition: qgl_win.c:1152
pcx_t::xmin
unsigned short xmin
Definition: qfiles.h:66
swstate_s::prev_mode
int prev_mode
Definition: r_local.h:820
VectorAdd
#define VectorAdd(a, b, c)
Definition: q_shared.h:157
model_s::maxs
vec3_t maxs
Definition: r_model.h:185
glconfig_t::renderer
int renderer
Definition: gl_local.h:406
model_s::radius
float radius
Definition: gl_model.h:189
logPointSize
static void APIENTRY logPointSize(GLfloat size)
Definition: qgl_win.c:1911
y
GLint y
Definition: qgl_win.c:115
logPixelTransferf
static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
Definition: qgl_win.c:1893
logColorMaterial
static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
Definition: qgl_win.c:1038
image_s::paletted
qboolean paletted
Definition: gl_local.h:107
logMateriali
static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
Definition: qgl_win.c:1758
sw_mode
cvar_t * sw_mode
Definition: r_main.c:119
logRasterPos2d
static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
Definition: qgl_win.c:1987
logColor3uiv
static void APIENTRY logColor3uiv(const GLuint *v)
Definition: qgl_win.c:933
R_IMFlatShadedQuad
void R_IMFlatShadedQuad(vec3_t a, vec3_t b, vec3_t c, vec3_t d, int color, float alpha)
Definition: r_poly.c:1230
msurface_s::polys
glpoly_t * polys
Definition: gl_model.h:111
logTexCoordPointer
static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
Definition: qgl_win.c:2391
R_Flash
void R_Flash(void)
Definition: gl_rmain.c:808
gl_lms
static gllightmapstate_t gl_lms
Definition: gl_rsurf.c:58
r_nocull
cvar_t * r_nocull
Definition: gl_rmain.c:79
GL_RENDERER_VOODOO2
#define GL_RENDERER_VOODOO2
Definition: gl_local.h:365
logTexGendv
static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
Definition: qgl_win.c:2426
entity_s::frame
int frame
Definition: ref.h:58
logNormal3dv
static void APIENTRY logNormal3dv(const GLdouble *v)
Definition: qgl_win.c:1812
gllightmapstate_t::lightmap_surfaces
msurface_t * lightmap_surfaces[MAX_LIGHTMAPS]
Definition: gl_rsurf.c:49
logCopyTexImage1D
static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
Definition: qgl_win.c:1056
logLoadName
static void APIENTRY logLoadName(GLuint name)
Definition: qgl_win.c:1689
logVertex3i
static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
Definition: qgl_win.c:2567
R_RecursiveWorldNode
void R_RecursiveWorldNode(mnode_t *node)
Definition: gl_rsurf.c:1043
logTranslated
static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
Definition: qgl_win.c:2494
zFar
GLclampd zFar
Definition: qgl_win.c:125
Draw_BuildGammaTable
void Draw_BuildGammaTable(void)
Definition: r_main.c:1217
VectorCopy
#define VectorCopy(a, b)
Definition: q_shared.h:158
currentmodel
model_t * currentmodel
Definition: gl_rmain.c:42
logGetBooleanv
static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
Definition: qgl_win.c:1325
R_EdgeCodeStart
void R_EdgeCodeStart(void)
r_turbsin
float r_turbsin[]
Definition: gl_warp.c:198
logNormal3fv
static void APIENTRY logNormal3fv(const GLfloat *v)
Definition: qgl_win.c:1824
model_s::skins
image_t * skins[MAX_MD2SKINS]
Definition: r_model.h:234
logRasterPos3fv
static void APIENTRY logRasterPos3fv(const GLfloat *v)
Definition: qgl_win.c:2044
gl_tex_solid_format
int gl_tex_solid_format
Definition: gl_image.c:41
gl_texturesolidmode
cvar_t * gl_texturesolidmode
Definition: gl_rmain.c:130
refdef_t::lightstyles
lightstyle_t * lightstyles
Definition: ref.h:132
warpface
msurface_t * warpface
Definition: gl_warp.c:31
glstate_t::hwgamma
qboolean hwgamma
Definition: gl_local.h:432
logColor3sv
static void APIENTRY logColor3sv(const GLshort *v)
Definition: qgl_win.c:907
logLoadIdentity
static void APIENTRY logLoadIdentity(void)
Definition: qgl_win.c:1671
R_InitTurb
void R_InitTurb(void)
Definition: r_main.c:231
logColor3ubv
static void APIENTRY logColor3ubv(const GLubyte *v)
Definition: qgl_win.c:919
logMaterialfv
static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
Definition: qgl_win.c:1752
sc_base
surfcache_t * sc_base
Definition: r_local.h:753
gl_particle_max_size
cvar_t * gl_particle_max_size
Definition: gl_rmain.c:91
image_s::upload_width
int upload_width
Definition: gl_local.h:99
d_8to24table
unsigned d_8to24table[256]
Definition: r_main.c:27
logTexCoord1iv
static void APIENTRY logTexCoord1iv(const GLint *v)
Definition: qgl_win.c:2255
vec3_origin
vec3_t vec3_origin
Definition: q_shared.c:24
R_RenderDlights
void R_RenderDlights(void)
Definition: gl_light.c:77
logLightModelfv
static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
Definition: qgl_win.c:1610
c_alias_polys
int c_alias_polys
Definition: gl_local.h:164
logPixelStoref
static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
Definition: qgl_win.c:1883
model_s::name
char name[MAX_QPATH]
Definition: r_model.h:173
R_CullBox
qboolean R_CullBox(vec3_t mins, vec3_t maxs)
Definition: gl_rmain.c:146
msurface_s::light_s
int light_s
Definition: gl_model.h:108
logNormal3b
static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
Definition: qgl_win.c:1794
image_s::sl
float sl
Definition: gl_local.h:103
skytexorder
int skytexorder[6]
Definition: gl_warp.c:561
logEvalMesh1
static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
Definition: qgl_win.c:1238
mnode_s::contents
int contents
Definition: r_model.h:126
mnode_s::firstsurface
unsigned short firstsurface
Definition: r_model.h:137
up
static vec3_t up
Definition: p_view.c:29
vid_gamma
cvar_t * vid_gamma
Definition: vid_dll.c:42
r_newrefdef
refdef_t r_newrefdef
Definition: gl_rmain.c:69
dsprite_t::numframes
int numframes
Definition: qfiles.h:184
logNormal3i
static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
Definition: qgl_win.c:1829
logTexCoord4s
static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
Definition: qgl_win.c:2381
EmitWaterPolys
void EmitWaterPolys(msurface_t *fa)
Definition: gl_warp.c:211
logColor3us
static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
Definition: qgl_win.c:939
rserr_ok
@ rserr_ok
Definition: r_local.h:99
r_speeds
cvar_t * r_speeds
Definition: gl_rmain.c:76
logLogicOp
static void APIENTRY logLogicOp(GLenum opcode)
Definition: qgl_win.c:1695
glstate_t::fullscreen
qboolean fullscreen
Definition: gl_local.h:418
dlight_t
Definition: ref.h:84
logColor4f
static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Definition: qgl_win.c:973
logIndexub
static void APIENTRY logIndexub(GLubyte c)
Definition: qgl_win.c:1564
dsprframe_t::origin_y
int origin_y
Definition: qfiles.h:177
SWimp_Init
int SWimp_Init(void *hInstance, void *wndProc)
Definition: rw_imp.c:118
logIndexubv
static void APIENTRY logIndexubv(const GLubyte *c)
Definition: qgl_win.c:1570
logGetFloatv
static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
Definition: qgl_win.c:1349
logNormal3d
static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
Definition: qgl_win.c:1806
entity_s
Definition: ref.h:49
view_clipplanes
clipplane_t view_clipplanes[4]
Definition: r_rast.c:38
logBindTexture
static void APIENTRY logBindTexture(GLenum target, GLuint texture)
Definition: qgl_win.c:781
WINDOW_CLASS_NAME
#define WINDOW_CLASS_NAME
Definition: glw_imp.c:62
OSR2_BUILD_NUMBER
#define OSR2_BUILD_NUMBER
gl_config
glconfig_t gl_config
Definition: gl_rmain.c:35
RF_FULLBRIGHT
#define RF_FULLBRIGHT
Definition: q_shared.h:616
GL_TexEnv
void GL_TexEnv(GLenum mode)
Definition: gl_image.c:125
logClipPlane
static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
Definition: qgl_win.c:847
model_s::surfaces
msurface_t * surfaces
Definition: r_model.h:221
currententity
entity_t * currententity
Definition: gl_rmain.c:41
vup
vec3_t vup
Definition: gl_rmain.c:58
shadelight
float shadelight[3]
Definition: gl_mesh.c:46
medge_t::v
unsigned short v[2]
Definition: r_model.h:79
logMultMatrixf
static void APIENTRY logMultMatrixf(const GLfloat *m)
Definition: qgl_win.c:1782
image_s::has_alpha
qboolean has_alpha
Definition: gl_local.h:105
c_visible_textures
int c_visible_textures
Definition: gl_rsurf.c:40
DrawTextureChains
void DrawTextureChains(void)
Definition: gl_rsurf.c:642
logEvalCoord2f
static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
Definition: qgl_win.c:1227
VectorMA
void VectorMA(vec3_t veca, float scale, vec3_t vecb, vec3_t vecc)
Definition: q_shared.c:719
logGetPixelMapusv
static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
Definition: qgl_win.c:1415
logRasterPos2dv
static void APIENTRY logRasterPos2dv(const GLdouble *v)
Definition: qgl_win.c:1993
gl_ext_palettedtexture
static cvar_t * gl_ext_palettedtexture
Definition: vid_menu.c:37
model_s::numleafs
int numleafs
Definition: r_model.h:204
logVertex3d
static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
Definition: qgl_win.c:2547
msurface_s::lightmaptexturenum
int lightmaptexturenum
Definition: gl_model.h:121
logIndexdv
static void APIENTRY logIndexdv(const GLdouble *c)
Definition: qgl_win.c:1522
pcx_t::manufacturer
char manufacturer
Definition: qfiles.h:62
logColor4fv
static void APIENTRY logColor4fv(const GLfloat *v)
Definition: qgl_win.c:978
r_rawpalette
unsigned r_rawpalette[256]
Definition: gl_rmain.c:1573
glwstate_t::wndproc
void * wndproc
Definition: glw_win.h:30
logStencilMask
static void APIENTRY logStencilMask(GLuint mask)
Definition: qgl_win.c:2216
logGetMaterialiv
static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
Definition: qgl_win.c:1397
r_dlightframecount
int r_dlightframecount
Definition: r_light.c:24
refdef_t::fov_y
float fov_y
Definition: ref.h:123
logRecti
static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
Definition: qgl_win.c:2143
particle_t::color
int color
Definition: ref.h:99
logTexCoord1s
static void APIENTRY logTexCoord1s(GLshort s)
Definition: qgl_win.c:2260
GL_LoadPic
image_t * GL_LoadPic(char *name, byte *pic, int width, int height, imagetype_t type, int bits)
Definition: gl_image.c:1255
R_DrawEntitiesOnList
void R_DrawEntitiesOnList(void)
Definition: gl_rmain.c:319
msurface_s
Definition: r_model.h:93
logVertex2iv
static void APIENTRY logVertex2iv(const GLint *v)
Definition: qgl_win.c:2532
logGetPolygonStipple
static void APIENTRY logGetPolygonStipple(GLubyte *mask)
Definition: qgl_win.c:1427
logVertex2f
static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
Definition: qgl_win.c:2517
logVertex4fv
static void APIENTRY logVertex4fv(const GLfloat *v)
Definition: qgl_win.c:2602
logGetDoublev
static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
Definition: qgl_win.c:1337
DrawGLPoly
void DrawGLPoly(glpoly_t *p)
Definition: gl_rsurf.c:180
mplane_s
Definition: r_model.h:57
pcx_t::vres
unsigned short vres
Definition: qfiles.h:67
dsprframe_t
Definition: qfiles.h:174
mtexinfo_s::flags
int flags
Definition: r_model.h:88
model_s::numnodes
int numnodes
Definition: r_model.h:213
it_wall
@ it_wall
Definition: gl_local.h:89
logTexCoord3f
static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
Definition: qgl_win.c:2321
R_EdgeCodeEnd
void R_EdgeCodeEnd(void)
logShadeModel
static void APIENTRY logShadeModel(GLenum mode)
Definition: qgl_win.c:2204
refdef_t::dlights
dlight_t * dlights
Definition: ref.h:138
glstate_t::lightmap_textures
int lightmap_textures
Definition: gl_local.h:424
R_RotateForEntity
void R_RotateForEntity(entity_t *e)
Definition: gl_rmain.c:160
logListBase
static void APIENTRY logListBase(GLuint base)
Definition: qgl_win.c:1665
logEvalCoord2dv
static void APIENTRY logEvalCoord2dv(const GLdouble *u)
Definition: qgl_win.c:1222
refdef_t::width
int width
Definition: ref.h:122
logMaterialiv
static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
Definition: qgl_win.c:1764
msurface_s::cached_light
float cached_light[MAXLIGHTMAPS]
Definition: gl_model.h:123
logGetTexGenfv
static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
Definition: qgl_win.c:1457
logColor4ub
static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
Definition: qgl_win.c:1003
logFrustum
static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
Definition: qgl_win.c:1307
texture
GLuint texture
Definition: qgl_win.c:68
ri
refimport_t ri
Definition: r_main.c:25
image_s::upload_height
int upload_height
Definition: gl_local.h:99
logVertex3s
static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
Definition: qgl_win.c:2577
R_DrawAlphaSurfaces
void R_DrawAlphaSurfaces(void)
Definition: r_poly.c:1192
logLightModeli
static void APIENTRY logLightModeli(GLenum pname, GLint param)
Definition: qgl_win.c:1616
Draw_FindPic
image_t * Draw_FindPic(char *name)
Definition: r_draw.c:35
RF_SHELL_BLUE
#define RF_SHELL_BLUE
Definition: q_shared.h:625
R_DrawParticles
void R_DrawParticles(void)
Definition: gl_rmain.c:470
lightstyle_t::white
float white
Definition: ref.h:117
dsprframe_t::origin_x
int origin_x
Definition: qfiles.h:177
SubdividePolygon
void SubdividePolygon(int numverts, float *verts)
Definition: gl_warp.c:54
logVertex2dv
static void APIENTRY logVertex2dv(const GLdouble *v)
Definition: qgl_win.c:2512
w
GLdouble GLdouble GLdouble w
Definition: qgl_win.c:291
logRasterPos2fv
static void APIENTRY logRasterPos2fv(const GLfloat *v)
Definition: qgl_win.c:2004
right
GLdouble right
Definition: qgl_win.c:159
logColor4us
static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
Definition: qgl_win.c:1023
registration_sequence
int registration_sequence
Definition: r_model.c:44
MAX_CLIP_VERTS
#define MAX_CLIP_VERTS
Definition: gl_warp.c:388
logAlphaFunc
static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
Definition: qgl_win.c:757
logVertex4i
static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
Definition: qgl_win.c:2607
refimport_t::Cvar_SetValue
void(* Cvar_SetValue)(char *name, float value)
Definition: ref.h:244
logTexParameteriv
static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
Definition: qgl_win.c:2479
image_s
Definition: r_local.h:65
sw_state
swstate_t sw_state
Definition: r_main.c:43
logInterleavedArrays
static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
Definition: qgl_win.c:1582
particles
cparticle_t particles[MAX_PARTICLES]
Definition: cl_fx.c:63
GL_LIGHTMAP_FORMAT
#define GL_LIGHTMAP_FORMAT
Definition: gl_rsurf.c:42
logColor3fv
static void APIENTRY logColor3fv(const GLfloat *v)
Definition: qgl_win.c:883
logPopClientAttrib
static void APIENTRY logPopClientAttrib(void)
Definition: qgl_win.c:1939
mode
GLenum mode
Definition: qgl_win.c:113
logStencilFunc
static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
Definition: qgl_win.c:2210
logAreTexturesResident
static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
Definition: qgl_win.c:763
msurface_s::dlightbits
int dlightbits
Definition: r_model.h:98
R_MarkLeaves
void R_MarkLeaves(void)
Definition: r_main.c:432
R_BuildLightMap
void R_BuildLightMap(msurface_t *surf, byte *dest, int stride)
Definition: gl_light.c:455
YCENTERING
#define YCENTERING
Definition: r_local.h:216
logEnableClientState
static void APIENTRY logEnableClientState(GLenum array)
Definition: qgl_win.c:1176
logTexCoord1dv
static void APIENTRY logTexCoord1dv(const GLdouble *v)
Definition: qgl_win.c:2234
viddef_t::colormap
pixel_t * colormap
Definition: r_local.h:89
pcx_t::xmax
unsigned short xmax
Definition: qfiles.h:66
R_SetCacheState
void R_SetCacheState(msurface_t *surf)
Definition: gl_light.c:437
logFeedbackBuffer
static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
Definition: qgl_win.c:1259
logGetIntegerv
static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
Definition: qgl_win.c:1355
mnode_s::numsurfaces
unsigned short numsurfaces
Definition: r_model.h:138
logTexEnvi
static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
Definition: qgl_win.c:2409
frustum
cplane_t frustum[4]
Definition: gl_rmain.c:44
logAccum
static void APIENTRY logAccum(GLenum op, GLfloat value)
Definition: qgl_win.c:751
model_s::vertexes
mvertex_t * vertexes
Definition: r_model.h:208
c_brush_polys
int c_brush_polys
Definition: gl_rmain.c:49
logFogiv
static void APIENTRY logFogiv(GLenum pname, const GLint *params)
Definition: qgl_win.c:1295
gldepthmin
float gldepthmin
Definition: gl_rmain.c:33
logGetPointerv
static void APIENTRY logGetPointerv(GLenum pname, GLvoid **params)
Definition: qgl_win.c:1421
rserr_unknown
@ rserr_unknown
Definition: gl_local.h:125
GL_SelectTexture
void GL_SelectTexture(GLenum texture)
Definition: gl_image.c:91
gl_particle_min_size
cvar_t * gl_particle_min_size
Definition: gl_rmain.c:90
logTexCoord3sv
static void APIENTRY logTexCoord3sv(const GLshort *v)
Definition: qgl_win.c:2346
Draw_GetPalette
int Draw_GetPalette(void)
Definition: gl_image.c:1509
msurface_s::nextalphasurface
struct msurface_s * nextalphasurface
Definition: r_model.h:118
logEnd
static void APIENTRY logEnd(void)
Definition: qgl_win.c:1182
Scrap_AllocBlock
int Scrap_AllocBlock(int w, int h, int *x, int *y)
Definition: gl_image.c:367
viddef_t::alphamap
pixel_t * alphamap
Definition: r_local.h:90
logFogfv
static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
Definition: qgl_win.c:1283
gl_swapinterval
cvar_t * gl_swapinterval
Definition: gl_rmain.c:127
msurface_s::lightmapchain
struct msurface_s * lightmapchain
Definition: gl_model.h:113
LoadPCX
void LoadPCX(char *filename, byte **pic, byte **palette, int *width, int *height)
Definition: gl_image.c:432
R_BeginFrame
void R_BeginFrame(float camera_separation)
Definition: r_main.c:1099
logIndexMask
static void APIENTRY logIndexMask(GLuint mask)
Definition: qgl_win.c:1504
logTexGend
static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
Definition: qgl_win.c:2420
NUM_GL_MODES
#define NUM_GL_MODES
Definition: gl_image.c:179
logRotatef
static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
Definition: qgl_win.c:2174
logColor3s
static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
Definition: qgl_win.c:901
Mod_ClusterPVS
byte * Mod_ClusterPVS(int cluster, model_t *model)
Definition: r_model.c:268
rserr_invalid_fullscreen
@ rserr_invalid_fullscreen
Definition: r_local.h:101
skymins
float skymins[2][6]
Definition: gl_warp.c:302
gl_monolightmap
cvar_t * gl_monolightmap
Definition: gl_rmain.c:112
entity_s::oldorigin
float oldorigin[3]
Definition: ref.h:63
dlight_t::intensity
float intensity
Definition: ref.h:93
TRANSPARENT_COLOR
#define TRANSPARENT_COLOR
Definition: asm_i386.h:78
vpn
vec3_t vpn
Definition: gl_rmain.c:59
logPixelMapusv
static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
Definition: qgl_win.c:1878
logDeleteLists
static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
Definition: qgl_win.c:1086
vec3_t
vec_t vec3_t[3]
Definition: q_shared.h:127
draw_chars
image_t * draw_chars
Definition: r_draw.c:26
logTexCoord3fv
static void APIENTRY logTexCoord3fv(const GLfloat *v)
Definition: qgl_win.c:2326
Com_sprintf
void Com_sprintf(char *dest, int size, char *fmt,...)
Definition: q_shared.c:1236
logColor4ubv
static void APIENTRY logColor4ubv(const GLubyte *v)
Definition: qgl_win.c:1008
logEvalPoint1
static void APIENTRY logEvalPoint1(GLint i)
Definition: qgl_win.c:1248
glstate_t::d_16to8table
unsigned char * d_16to8table
Definition: gl_local.h:422
dmdl_t
Definition: qfiles.h:137
entity_s::angles
float angles[3]
Definition: ref.h:52
gl_particle_att_b
cvar_t * gl_particle_att_b
Definition: gl_rmain.c:94
TEXNUM_SCRAPS
#define TEXNUM_SCRAPS
Definition: gl_local.h:111
logColor4i
static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
Definition: qgl_win.c:983
logEdgeFlagPointer
static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
Definition: qgl_win.c:1158
logGetTexEnvfv
static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
Definition: qgl_win.c:1439
logBegin
static void APIENTRY logBegin(GLenum mode)
Definition: qgl_win.c:775
BLOCK_WIDTH
#define BLOCK_WIDTH
Definition: gl_image.c:359
logRotated
static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
Definition: qgl_win.c:2168
LoadPCX
void LoadPCX(char *filename, byte **pic, byte **palette, int *width, int *height)
Definition: r_image.c:87
logPushMatrix
static void APIENTRY logPushMatrix(void)
Definition: qgl_win.c:1975
logGetTexGeniv
static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
Definition: qgl_win.c:1463
RotatePointAroundVector
void RotatePointAroundVector(vec3_t dst, const vec3_t dir, const vec3_t point, float degrees)
Definition: q_shared.c:32
logTexCoord4f
static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Definition: qgl_win.c:2361
dmdl_t::num_frames
int num_frames
Definition: qfiles.h:151
msurface_s::firstedge
int firstedge
Definition: r_model.h:103
SURF_SKY
#define SURF_SKY
Definition: qfiles.h:371
vright
vec3_t vright
Definition: gl_rmain.c:60
logVertexPointer
static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
Definition: qgl_win.c:2627
pcx_t::bytes_per_line
unsigned short bytes_per_line
Definition: qfiles.h:71
logMapGrid2f
static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
Definition: qgl_win.c:1742
image_s::sh
float sh
Definition: gl_local.h:103
it_sky
@ it_sky
Definition: r_local.h:62
glpoly_s
Definition: gl_model.h:86
vid
viddef_t vid
Definition: r_main.c:24