yquake2/yquake2remaster
0
0
Fork 0
mirror of https://github.com/yquake2/yquake2remaster.git synced 2025-03-25 04:11:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rename all qgl* functions top their OpenGL counterparts

Browse source 
This removes the need to define the old qgl function names to the
official OpenGL names. The OpenGL functions are now called directly
without any abstraction.
This commit is contained in:
Yamagi Burmeister 2013-07-27 08:44:07 +02:00
parent 9150bdc9ec
commit ad52c5c888
12 changed files with 477 additions and 812 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CHANGELOG
View file

@ -1,8 +1,8 @@
Quake II 5.11 to 5.20
- Integrate the refresher into the client and
remove QGL. This means that ref_gl.so is gone
and libGL is now linked every other lib. (by
Alejandro Ricoveri)
and libGL is now linked like every other lib.
(by Alejandro Ricoveri)
Quake II 5.10 to 5.11
- A lot of bugfixes.

335
src/backends/generic/header/qgl.h
View file

@ -96,341 +96,6 @@
#define GL_OPERAND7_ALPHA_EXT 0x859F
#endif
#define qglAccum glAccum
#define qglAlphaFunc glAlphaFunc
#define qglAreTexturesResident glAreTexturesResident
#define qglArrayElement glArrayElement
#define qglBegin glBegin
#define qglBindTexture glBindTexture
#define qglBitmap glBitmap
#define qglBlendFunc glBlendFunc
#define qglCallList glCallList
#define qglCallLists glCallLists
#define qglClear glClear
#define qglClearAccum glClearAccum
#define qglClearColor glClearColor
#define qglClearDepth glClearDepth
#define qglClearIndex glClearIndex
#define qglClearStencil glClearStencil
#define qglClipPlane glClipPlane
#define qglColor3b glColor3b
#define qglColor3bv glColor3bv
#define qglColor3d glColor3d
#define qglColor3dv glColor3dv
#define qglColor3f glColor3f
#define qglColor3fv glColor3fv
#define qglColor3i glColor3i
#define qglColor3iv glColor3iv
#define qglColor3s glColor3s
#define qglColor3sv glColor3sv
#define qglColor3ub glColor3ub
#define qglColor3ubv glColor3ubv
#define qglColor3ui glColor3ui
#define qglColor3uiv glColor3uiv
#define qglColor3us glColor3us
#define qglColor3usv glColor3usv
#define qglColor4b glColor4b
#define qglColor4bv glColor4bv
#define qglColor4d glColor4d
#define qglColor4dv glColor4dv
#define qglColor4f glColor4f
#define qglColor4fv glColor4fv
#define qglColor4i glColor4i
#define qglColor4iv glColor4iv
#define qglColor4s glColor4s
#define qglColor4sv glColor4sv
#define qglColor4ub glColor4ub
#define qglColor4ubv glColor4ubv
#define qglColor4ui glColor4ui
#define qglColor4uiv glColor4uiv
#define qglColor4us glColor4us
#define qglColor4usv glColor4usv
#define qglColorMask glColorMask
#define qglColorMaterial glColorMaterial
#define qglColorPointer glColorPointer
#define qglCopyPixels glCopyPixels
#define qglCopyTexImage1D glCopyTexImage1D
#define qglCopyTexImage2D glCopyTexImage2D
#define qglCopyTexSubImage1D glCopyTexSubImage1D
#define qglCopyTexSubImage2D glCopyTexSubImage2D
#define qglCullFace glCullFace
#define qglDeleteLists glDeleteLists
#define qglDeleteTextures glDeleteTextures
#define qglDepthFunc glDepthFunc
#define qglDepthMask glDepthMask
#define qglDepthRange glDepthRange
#define qglDisable glDisable
#define qglDisableClientState glDisableClientState
#define qglDrawArrays glDrawArrays
#define qglDrawBuffer glDrawBuffer
#define qglDrawElements glDrawElements
#define qglDrawPixels glDrawPixels
#define qglEdgeFlag glEdgeFlag
#define qglEdgeFlagPointer glEdgeFlagPointer
#define qglEdgeFlagv glEdgeFlagv
#define qglEnable glEnable
#define qglEnableClientState glEnableClientState
#define qglEnd glEnd
#define qglEndList glEndList
#define qglEvalCoord1d glEvalCoord1d
#define qglEvalCoord1dv glEvalCoord1dv
#define qglEvalCoord1f glEvalCoord1f
#define qglEvalCoord1fv glEvalCoord1fv
#define qglEvalCoord2d glEvalCoord2d
#define qglEvalCoord2dv glEvalCoord2dv
#define qglEvalCoord2f glEvalCoord2f
#define qglEvalCoord2fv glEvalCoord2fv
#define qglEvalMesh1 glEvalMesh1
#define qglEvalMesh2 glEvalMesh2
#define qglEvalPoint1 glEvalPoint1
#define qglEvalPoint2 glEvalPoint2
#define qglFeedbackBuffer glFeedbackBuffer
#define qglFinish glFinish
#define qglFlush glFlush
#define qglFogf glFogf
#define qglFogfv glFogfv
#define qglFogi glFogi
#define qglFogiv glFogiv
#define qglFrontFace glFrontFace
#define qglFrustum glFrustum
#define qglGenLists glGenLists
#define qglGenTextures glGenTextures
#define qglGetBooleanv glGetBooleanv
#define qglGetClipPlane glGetClipPlane
#define qglGetDoublev glGetDoublev
#define qglGetError glGetError
#define qglGetFloatv glGetFloatv
#define qglGetIntegerv glGetIntegerv
#define qglGetLightfv glGetLightfv
#define qglGetLightiv glGetLightiv
#define qglGetMapdv glGetMapdv
#define qglGetMapfv glGetMapfv
#define qglGetMapiv glGetMapiv
#define qglGetMaterialfv glGetMaterialfv
#define qglGetMaterialiv glGetMaterialiv
#define qglGetPixelMapfv glGetPixelMapfv
#define qglGetPixelMapuiv glGetPixelMapuiv
#define qglGetPixelMapusv glGetPixelMapusv
#define qglGetPointerv glGetPointerv
#define qglGetPolygonStipple glGetPolygonStipple
#define qglGetString glGetString
#define qglGetTexGendv glGetTexGendv
#define qglGetTexGenfv glGetTexGenfv
#define qglGetTexGeniv glGetTexGeniv
#define qglGetTexImage glGetTexImage
#define qglGetTexLevelParameterfv glGetTexLevelParameterfv
#define qglGetTexLevelParameteriv glGetTexLevelParameteriv
#define qglGetTexParameterfv glGetTexParameterfv
#define qglGetTexParameteriv glGetTexParameteriv
#define qglHint glHint
#define qglIndexMask glIndexMask
#define qglIndexPointer glIndexPointer
#define qglIndexd glIndexd
#define qglIndexdv glIndexdv
#define qglIndexf glIndexf
#define qglIndexfv glIndexfv
#define qglIndexi glIndexi
#define qglIndexiv glIndexiv
#define qglIndexs glIndexs
#define qglIndexsv glIndexsv
#define qglIndexub glIndexub
#define qglIndexubv glIndexubv
#define qglInitNames glInitNames
#define qglInterleavedArrays glInterleavedArrays
#define qglIsEnabled glIsEnabled
#define qglIsList glIsList
#define qglIsTexture glIsTexture
#define qglLightModelf glLightModelf
#define qglLightModelfv glLightModelfv
#define qglLightModeli glLightModeli
#define qglLightModeliv glLightModeliv
#define qglLightf glLightf
#define qglLightfv glLightfv
#define qglLighti glLighti
#define qglLightiv glLightiv
#define qglLineStipple glLineStipple
#define qglLineWidth glLineWidth
#define qglListBase glListBase
#define qglLoadIdentity glLoadIdentity
#define qglLoadMatrixd glLoadMatrixd
#define qglLoadMatrixf glLoadMatrixf
#define qglLoadName glLoadName
#define qglLogicOp glLogicOp
#define qglMap1d glMap1d
#define qglMap1f glMap1f
#define qglMap2d glMap2d
#define qglMap2f glMap2f
#define qglMapGrid1d glMapGrid1d
#define qglMapGrid1f glMapGrid1f
#define qglMapGrid2d glMapGrid2d
#define qglMapGrid2f glMapGrid2f
#define qglMaterialf glMaterialf
#define qglMaterialfv glMaterialfv
#define qglMateriali glMateriali
#define qglMaterialiv glMaterialiv
#define qglMatrixMode glMatrixMode
#define qglMultMatrixd glMultMatrixd
#define qglMultMatrixf glMultMatrixf
#define qglNewList glNewList
#define qglNormal3b glNormal3b
#define qglNormal3bv glNormal3bv
#define qglNormal3d glNormal3d
#define qglNormal3dv glNormal3dv
#define qglNormal3f glNormal3f
#define qglNormal3fv glNormal3fv
#define qglNormal3i glNormal3i
#define qglNormal3iv glNormal3iv
#define qglNormal3s glNormal3s
#define qglNormal3sv glNormal3sv
#define qglNormalPointer glNormalPointer
#define qglOrtho glOrtho
#define qglPassThrough glPassThrough
#define qglPixelMapfv glPixelMapfv
#define qglPixelMapuiv glPixelMapuiv
#define qglPixelMapusv glPixelMapusv
#define qglPixelStoref glPixelStoref
#define qglPixelStorei glPixelStorei
#define qglPixelTransferf glPixelTransferf
#define qglPixelTransferi glPixelTransferi
#define qglPixelZoom glPixelZoom
#define qglPointSize glPointSize
#define qglPolygonMode glPolygonMode
#define qglPolygonOffset glPolygonOffset
#define qglPolygonStipple glPolygonStipple
#define qglPopAttrib glPopAttrib
#define qglPopClientAttrib glPopClientAttrib
#define qglPopMatrix glPopMatrix
#define qglPopName glPopName
#define qglPrioritizeTextures glPrioritizeTextures
#define qglPushAttrib glPushAttrib
#define qglPushClientAttrib glPushClientAttrib
#define qglPushMatrix glPushMatrix
#define qglPushName glPushName
#define qglRasterPos2d glRasterPos2d
#define qglRasterPos2dv glRasterPos2dv
#define qglRasterPos2f glRasterPos2f
#define qglRasterPos2fv glRasterPos2fv
#define qglRasterPos2i glRasterPos2i
#define qglRasterPos2iv glRasterPos2iv
#define qglRasterPos2s glRasterPos2s
#define qglRasterPos2sv glRasterPos2sv
#define qglRasterPos3d glRasterPos3d
#define qglRasterPos3dv glRasterPos3dv
#define qglRasterPos3f glRasterPos3f
#define qglRasterPos3fv glRasterPos3fv
#define qglRasterPos3i glRasterPos3i
#define qglRasterPos3iv glRasterPos3iv
#define qglRasterPos3s glRasterPos3s
#define qglRasterPos3sv glRasterPos3sv
#define qglRasterPos4d glRasterPos4d
#define qglRasterPos4dv glRasterPos4dv
#define qglRasterPos4f glRasterPos4f
#define qglRasterPos4fv glRasterPos4fv
#define qglRasterPos4i glRasterPos4i
#define qglRasterPos4iv glRasterPos4iv
#define qglRasterPos4s glRasterPos4s
#define qglRasterPos4sv glRasterPos4sv
#define qglReadBuffer glReadBuffer
#define qglReadPixels glReadPixels
#define qglRectd glRectd
#define qglRectdv glRectdv
#define qglRectf glRectf
#define qglRectfv glRectfv
#define qglRecti glRecti
#define qglRectiv glRectiv
#define qglRects glRects
#define qglRectsv glRectsv
#define qglRenderMode glRenderMode
#define qglRotated glRotated
#define qglRotatef glRotatef
#define qglScaled glScaled
#define qglScalef glScalef
#define qglScissor glScissor
#define qglSelectBuffer glSelectBuffer
#define qglShadeModel glShadeModel
#define qglStencilFunc glStencilFunc
#define qglStencilMask glStencilMask
#define qglStencilOp glStencilOp
#define qglTexCoord1d glTexCoord1d
#define qglTexCoord1dv glTexCoord1dv
#define qglTexCoord1f glTexCoord1f
#define qglTexCoord1fv glTexCoord1fv
#define qglTexCoord1i glTexCoord1i
#define qglTexCoord1iv glTexCoord1iv
#define qglTexCoord1s glTexCoord1s
#define qglTexCoord1sv glTexCoord1sv
#define qglTexCoord2d glTexCoord2d
#define qglTexCoord2dv glTexCoord2dv
#define qglTexCoord2f glTexCoord2f
#define qglTexCoord2fv glTexCoord2fv
#define qglTexCoord2i glTexCoord2i
#define qglTexCoord2iv glTexCoord2iv
#define qglTexCoord2s glTexCoord2s
#define qglTexCoord2sv glTexCoord2sv
#define qglTexCoord3d glTexCoord3d
#define qglTexCoord3dv glTexCoord3dv
#define qglTexCoord3f glTexCoord3f
#define qglTexCoord3fv glTexCoord3fv
#define qglTexCoord3i glTexCoord3i
#define qglTexCoord3iv glTexCoord3iv
#define qglTexCoord3s glTexCoord3s
#define qglTexCoord3sv glTexCoord3sv
#define qglTexCoord4d glTexCoord4d
#define qglTexCoord4dv glTexCoord4dv
#define qglTexCoord4f glTexCoord4f
#define qglTexCoord4fv glTexCoord4fv
#define qglTexCoord4i glTexCoord4i
#define qglTexCoord4iv glTexCoord4iv
#define qglTexCoord4s glTexCoord4s
#define qglTexCoord4sv glTexCoord4sv
#define qglTexCoordPointer glTexCoordPointer
#define qglTexEnvf glTexEnvf
#define qglTexEnvfv glTexEnvfv
#define qglTexEnvi glTexEnvi
#define qglTexEnviv glTexEnviv
#define qglTexGend glTexGend
#define qglTexGendv glTexGendv
#define qglTexGenf glTexGenf
#define qglTexGenfv glTexGenfv
#define qglTexGeni glTexGeni
#define qglTexGeniv glTexGeniv
#define qglTexImage1D glTexImage1D
#define qglTexImage2D glTexImage2D
#define qglTexParameterf glTexParameterf
#define qglTexParameterfv glTexParameterfv
#define qglTexParameteri glTexParameteri
#define qglTexParameteriv glTexParameteriv
#define qglTexSubImage1D glTexSubImage1D
#define qglTexSubImage2D glTexSubImage2D
#define qglTranslated glTranslated
#define qglTranslatef glTranslatef
#define qglVertex2d glVertex2d
#define qglVertex2dv glVertex2dv
#define qglVertex2f glVertex2f
#define qglVertex2fv glVertex2fv
#define qglVertex2i glVertex2i
#define qglVertex2iv glVertex2iv
#define qglVertex2s glVertex2s
#define qglVertex2sv glVertex2sv
#define qglVertex3d glVertex3d
#define qglVertex3dv glVertex3dv
#define qglVertex3f glVertex3f
#define qglVertex3fv glVertex3fv
#define qglVertex3i glVertex3i
#define qglVertex3iv glVertex3iv
#define qglVertex3s glVertex3s
#define qglVertex3sv glVertex3sv
#define qglVertex4d glVertex4d
#define qglVertex4dv glVertex4dv
#define qglVertex4f glVertex4f
#define qglVertex4fv glVertex4fv
#define qglVertex4i glVertex4i
#define qglVertex4iv glVertex4iv
#define qglVertex4s glVertex4s
#define qglVertex4sv glVertex4sv
#define qglVertexPointer glVertexPointer
#define qglViewport glViewport
/* QGL main functions */
/*

4
src/backends/sdl/refresh.c
View file

@ -366,8 +366,8 @@ GLimp_Shutdown(void)
areas. */
if (SDL_WasInit(SDL_INIT_VIDEO))
{
qglClearColor(0.0, 0.0, 0.0, 0.0);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLimp_EndFrame();
}

156
src/client/refresh/r_draw.c
View file

@ -39,8 +39,8 @@ Draw_InitLocal(void)
/* load console characters (don't bilerp characters) */
draw_chars = R_FindImage("pics/conchars.pcx", it_pic);
R_Bind(draw_chars->texnum);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
/*
@ -75,16 +75,16 @@ Draw_Char(int x, int y, int num)
R_Bind(draw_chars->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(fcol, frow);
qglVertex2f(x, y);
qglTexCoord2f(fcol + size, frow);
qglVertex2f(x + 8, y);
qglTexCoord2f(fcol + size, frow + size);
qglVertex2f(x + 8, y + 8);
qglTexCoord2f(fcol, frow + size);
qglVertex2f(x, y + 8);
qglEnd();
glBegin(GL_QUADS);
glTexCoord2f(fcol, frow);
glVertex2f(x, y);
glTexCoord2f(fcol + size, frow);
glVertex2f(x + 8, y);
glTexCoord2f(fcol + size, frow + size);
glVertex2f(x + 8, y + 8);
glTexCoord2f(fcol, frow + size);
glVertex2f(x, y + 8);
glEnd();
}
image_t *
@ -142,16 +142,16 @@ Draw_StretchPic(int x, int y, int w, int h, char *pic)
}
R_Bind(gl->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(gl->sl, gl->tl);
qglVertex2f(x, y);
qglTexCoord2f(gl->sh, gl->tl);
qglVertex2f(x + w, y);
qglTexCoord2f(gl->sh, gl->th);
qglVertex2f(x + w, y + h);
qglTexCoord2f(gl->sl, gl->th);
qglVertex2f(x, y + h);
qglEnd();
glBegin(GL_QUADS);
glTexCoord2f(gl->sl, gl->tl);
glVertex2f(x, y);
glTexCoord2f(gl->sh, gl->tl);
glVertex2f(x + w, y);
glTexCoord2f(gl->sh, gl->th);
glVertex2f(x + w, y + h);
glTexCoord2f(gl->sl, gl->th);
glVertex2f(x, y + h);
glEnd();
}
void
@ -173,16 +173,16 @@ Draw_Pic(int x, int y, char *pic)
}
R_Bind(gl->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(gl->sl, gl->tl);
qglVertex2f(x, y);
qglTexCoord2f(gl->sh, gl->tl);
qglVertex2f(x + gl->width, y);
qglTexCoord2f(gl->sh, gl->th);
qglVertex2f(x + gl->width, y + gl->height);
qglTexCoord2f(gl->sl, gl->th);
qglVertex2f(x, y + gl->height);
qglEnd();
glBegin(GL_QUADS);
glTexCoord2f(gl->sl, gl->tl);
glVertex2f(x, y);
glTexCoord2f(gl->sh, gl->tl);
glVertex2f(x + gl->width, y);
glTexCoord2f(gl->sh, gl->th);
glVertex2f(x + gl->width, y + gl->height);
glTexCoord2f(gl->sl, gl->th);
glVertex2f(x, y + gl->height);
glEnd();
}
/*
@ -204,16 +204,16 @@ Draw_TileClear(int x, int y, int w, int h, char *pic)
}
R_Bind(image->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(x / 64.0, y / 64.0);
qglVertex2f(x, y);
qglTexCoord2f((x + w) / 64.0, y / 64.0);
qglVertex2f(x + w, y);
qglTexCoord2f((x + w) / 64.0, (y + h) / 64.0);
qglVertex2f(x + w, y + h);
qglTexCoord2f(x / 64.0, (y + h) / 64.0);
qglVertex2f(x, y + h);
qglEnd();
glBegin(GL_QUADS);
glTexCoord2f(x / 64.0, y / 64.0);
glVertex2f(x, y);
glTexCoord2f((x + w) / 64.0, y / 64.0);
glVertex2f(x + w, y);
glTexCoord2f((x + w) / 64.0, (y + h) / 64.0);
glVertex2f(x + w, y + h);
glTexCoord2f(x / 64.0, (y + h) / 64.0);
glVertex2f(x, y + h);
glEnd();
}
/*
@ -233,41 +233,41 @@ Draw_Fill(int x, int y, int w, int h, int c)
VID_Error(ERR_FATAL, "Draw_Fill: bad color");
}
qglDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_2D);
color.c = d_8to24table[c];
qglColor3f(color.v[0] / 255.0, color.v[1] / 255.0,
glColor3f(color.v[0] / 255.0, color.v[1] / 255.0,
color.v[2] / 255.0);
qglBegin(GL_QUADS);
glBegin(GL_QUADS);
qglVertex2f(x, y);
qglVertex2f(x + w, y);
qglVertex2f(x + w, y + h);
qglVertex2f(x, y + h);
glVertex2f(x, y);
glVertex2f(x + w, y);
glVertex2f(x + w, y + h);
glVertex2f(x, y + h);
qglEnd();
qglColor3f(1, 1, 1);
qglEnable(GL_TEXTURE_2D);
glEnd();
glColor3f(1, 1, 1);
glEnable(GL_TEXTURE_2D);
}
void
Draw_FadeScreen(void)
{
qglEnable(GL_BLEND);
qglDisable(GL_TEXTURE_2D);
qglColor4f(0, 0, 0, 0.8);
qglBegin(GL_QUADS);
glEnable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glColor4f(0, 0, 0, 0.8);
glBegin(GL_QUADS);
qglVertex2f(0, 0);
qglVertex2f(vid.width, 0);
qglVertex2f(vid.width, vid.height);
qglVertex2f(0, vid.height);
glVertex2f(0, 0);
glVertex2f(vid.width, 0);
glVertex2f(vid.width, vid.height);
glVertex2f(0, vid.height);
qglEnd();
qglColor4f(1, 1, 1, 1);
qglEnable(GL_TEXTURE_2D);
qglDisable(GL_BLEND);
glEnd();
glColor4f(1, 1, 1, 1);
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
}
void
@ -322,7 +322,7 @@ Draw_StretchRaw(int x, int y, int w, int h, int cols, int rows, byte *data)
}
}
qglTexImage2D(GL_TEXTURE_2D, 0, gl_tex_solid_format,
glTexImage2D(GL_TEXTURE_2D, 0, gl_tex_solid_format,
256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE,
image32);
}
@ -351,7 +351,7 @@ Draw_StretchRaw(int x, int y, int w, int h, int cols, int rows, byte *data)
}
}
qglTexImage2D(GL_TEXTURE_2D,
glTexImage2D(GL_TEXTURE_2D,
0,
GL_COLOR_INDEX8_EXT,
256, 256,
@ -361,19 +361,19 @@ Draw_StretchRaw(int x, int y, int w, int h, int cols, int rows, byte *data)
image8);
}
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglBegin(GL_QUADS);
qglTexCoord2f(1.0 / 512.0, 1.0 / 512.0);
qglVertex2f(x, y);
qglTexCoord2f(511.0 / 512.0, 1.0 / 512.0);
qglVertex2f(x + w, y);
qglTexCoord2f(511.0 / 512.0, t);
qglVertex2f(x + w, y + h);
qglTexCoord2f(1.0 / 512.0, t);
qglVertex2f(x, y + h);
qglEnd();
glBegin(GL_QUADS);
glTexCoord2f(1.0 / 512.0, 1.0 / 512.0);
glVertex2f(x, y);
glTexCoord2f(511.0 / 512.0, 1.0 / 512.0);
glVertex2f(x + w, y);
glTexCoord2f(511.0 / 512.0, t);
glVertex2f(x + w, y + h);
glTexCoord2f(1.0 / 512.0, t);
glVertex2f(x, y + h);
glEnd();
}
int

46
src/client/refresh/r_image.c
View file

@ -159,13 +159,13 @@ R_EnableMultitexture(qboolean enable)
if (enable)
{
R_SelectTexture(QGL_TEXTURE1);
qglEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_2D);
R_TexEnv(GL_REPLACE);
}
else
{
R_SelectTexture(QGL_TEXTURE1);
qglDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_2D);
R_TexEnv(GL_REPLACE);
}
@ -217,7 +217,7 @@ R_TexEnv(GLenum mode)
if (mode != lastmodes[gl_state.currenttmu])
{
qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode);
lastmodes[gl_state.currenttmu] = mode;
}
}
@ -238,7 +238,7 @@ R_Bind(int texnum)
}
gl_state.currenttextures[gl_state.currenttmu] = texnum;
qglBindTexture(GL_TEXTURE_2D, texnum);
glBindTexture(GL_TEXTURE_2D, texnum);
}
void
@ -306,15 +306,15 @@ R_TextureMode(char *string)
if ((glt->type != it_pic) && (glt->type != it_sky))
{
R_Bind(glt->texnum);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
gl_filter_min);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
gl_filter_max);
/* Set anisotropic filter if supported and enabled */
if (gl_config.anisotropic && gl_anisotropic->value)
{
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
gl_anisotropic->value);
}
}
@ -731,13 +731,13 @@ R_Upload32(unsigned *data, int width, int height, qboolean mipmap)
uploaded_paletted = true;
R_BuildPalettedTexture(paletted_texture, (unsigned char *)data,
scaled_width, scaled_height);
qglTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
scaled_width, scaled_height, 0, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, paletted_texture);
}
else
{
qglTexImage2D(GL_TEXTURE_2D, 0, comp, scaled_width,
glTexImage2D(GL_TEXTURE_2D, 0, comp, scaled_width,
scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
data);
}
@ -761,13 +761,13 @@ R_Upload32(unsigned *data, int width, int height, qboolean mipmap)
uploaded_paletted = true;
R_BuildPalettedTexture(paletted_texture, (unsigned char *)scaled,
scaled_width, scaled_height);
qglTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
scaled_width, scaled_height, 0, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, paletted_texture);
}
else
{
qglTexImage2D(GL_TEXTURE_2D, 0, comp, scaled_width,
glTexImage2D(GL_TEXTURE_2D, 0, comp, scaled_width,
scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
scaled);
}
@ -802,13 +802,13 @@ R_Upload32(unsigned *data, int width, int height, qboolean mipmap)
uploaded_paletted = true;
R_BuildPalettedTexture(paletted_texture, (unsigned char *)scaled,
scaled_width, scaled_height);
qglTexImage2D(GL_TEXTURE_2D, miplevel, GL_COLOR_INDEX8_EXT,
glTexImage2D(GL_TEXTURE_2D, miplevel, GL_COLOR_INDEX8_EXT,
scaled_width, scaled_height, 0, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, paletted_texture);
}
else
{
qglTexImage2D(GL_TEXTURE_2D, miplevel, comp, scaled_width,
glTexImage2D(GL_TEXTURE_2D, miplevel, comp, scaled_width,
scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
}
}
@ -818,18 +818,18 @@ done:
if (mipmap)
{
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
}
else
{
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
}
if (mipmap && gl_config.anisotropic && gl_anisotropic->value)
{
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
gl_anisotropic->value);
}
@ -855,12 +855,12 @@ R_Upload8(byte *data, int width, int height, qboolean mipmap, qboolean is_sky)
if (qglColorTableEXT && gl_ext_palettedtexture->value && is_sky)
{
qglTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
width, height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE,
data);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
return false; /* SBF: FIXME - what is the correct return value? */
}
@ -1274,7 +1274,7 @@ R_FreeUnusedImages(void)
}
/* free it */
qglDeleteTextures(1, (GLuint *)&image->texnum);
glDeleteTextures(1, (GLuint *)&image->texnum);
memset(image, 0, sizeof(*image));
}
}
@ -1362,7 +1362,7 @@ R_ShutdownImages(void)
}
/* free it */
qglDeleteTextures(1, (GLuint *)&image->texnum);
glDeleteTextures(1, (GLuint *)&image->texnum);
memset(image, 0, sizeof(*image));
}
}

32
src/client/refresh/r_light.c
View file

@ -46,8 +46,8 @@ R_RenderDlight(dlight_t *light)
VectorSubtract(light->origin, r_origin, v);
qglBegin(GL_TRIANGLE_FAN);
qglColor3f(light->color[0] * 0.2, light->color[1] * 0.2,
glBegin(GL_TRIANGLE_FAN);
glColor3f(light->color[0] * 0.2, light->color[1] * 0.2,
light->color[2] * 0.2);
for (i = 0; i < 3; i++)
@ -55,8 +55,8 @@ R_RenderDlight(dlight_t *light)
v[i] = light->origin[i] - vpn[i] * rad;
}
qglVertex3fv(v);
qglColor3f(0, 0, 0);
glVertex3fv(v);
glColor3f(0, 0, 0);
for (i = 16; i >= 0; i--)
{
@ -68,10 +68,10 @@ R_RenderDlight(dlight_t *light)
+ vup[j] * sin(a) * rad;
}
qglVertex3fv(v);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
void
@ -88,11 +88,11 @@ R_RenderDlights(void)
/* because the count hasn't advanced yet for this frame */
r_dlightframecount = r_framecount + 1;
qglDepthMask(0);
qglDisable(GL_TEXTURE_2D);
qglShadeModel(GL_SMOOTH);
qglEnable(GL_BLEND);
qglBlendFunc(GL_ONE, GL_ONE);
glDepthMask(0);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
l = r_newrefdef.dlights;
@ -101,11 +101,11 @@ R_RenderDlights(void)
R_RenderDlight(l);
}
qglColor3f(1, 1, 1);
qglDisable(GL_BLEND);
qglEnable(GL_TEXTURE_2D);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglDepthMask(1);
glColor3f(1, 1, 1);
glDisable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(1);
}
void

14
src/client/refresh/r_lightmap.c
View file

@ -53,8 +53,8 @@ LM_UploadBlock(qboolean dynamic)
}
R_Bind(gl_state.lightmap_textures + texture);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (dynamic)
{
@ -68,13 +68,13 @@ LM_UploadBlock(qboolean dynamic)
}
}
qglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, BLOCK_WIDTH,
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, BLOCK_WIDTH,
height, GL_LIGHTMAP_FORMAT, GL_UNSIGNED_BYTE,
gl_lms.lightmap_buffer);
}
else
{
qglTexImage2D(GL_TEXTURE_2D, 0, gl_lms.internal_format,
glTexImage2D(GL_TEXTURE_2D, 0, gl_lms.internal_format,
BLOCK_WIDTH, BLOCK_HEIGHT, 0, GL_LIGHTMAP_FORMAT,
GL_UNSIGNED_BYTE, gl_lms.lightmap_buffer);
@ -277,9 +277,9 @@ LM_BeginBuildingLightmaps(model_t *m)
/* initialize the dynamic lightmap texture */
R_Bind(gl_state.lightmap_textures + 0);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglTexImage2D(GL_TEXTURE_2D, 0, gl_lms.internal_format,
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, gl_lms.internal_format,
BLOCK_WIDTH, BLOCK_HEIGHT, 0, GL_LIGHTMAP_FORMAT,
GL_UNSIGNED_BYTE, dummy);
}

328
src/client/refresh/r_main.c
View file

@ -173,11 +173,11 @@ R_CullBox(vec3_t mins, vec3_t maxs)
void
R_RotateForEntity(entity_t *e)
{
qglTranslatef(e->origin[0], e->origin[1], e->origin[2]);
glTranslatef(e->origin[0], e->origin[1], e->origin[2]);
qglRotatef(e->angles[1], 0, 0, 1);
qglRotatef(-e->angles[0], 0, 1, 0);
qglRotatef(-e->angles[2], 1, 0, 0);
glRotatef(e->angles[1], 0, 0, 1);
glRotatef(-e->angles[0], 0, 1, 0);
glRotatef(-e->angles[2], 1, 0, 0);
}
void
@ -207,10 +207,10 @@ R_DrawSpriteModel(entity_t *e)
if (alpha != 1.0F)
{
qglEnable(GL_BLEND);
glEnable(GL_BLEND);
}
qglColor4f(1, 1, 1, alpha);
glColor4f(1, 1, 1, alpha);
R_Bind(currentmodel->skins[e->frame]->texnum);
@ -218,46 +218,46 @@ R_DrawSpriteModel(entity_t *e)
if (alpha == 1.0)
{
qglEnable(GL_ALPHA_TEST);
glEnable(GL_ALPHA_TEST);
}
else
{
qglDisable(GL_ALPHA_TEST);
glDisable(GL_ALPHA_TEST);
}
qglBegin(GL_QUADS);
glBegin(GL_QUADS);
qglTexCoord2f(0, 1);
glTexCoord2f(0, 1);
VectorMA(e->origin, -frame->origin_y, up, point);
VectorMA(point, -frame->origin_x, right, point);
qglVertex3fv(point);
glVertex3fv(point);
qglTexCoord2f(0, 0);
glTexCoord2f(0, 0);
VectorMA(e->origin, frame->height - frame->origin_y, up, point);
VectorMA(point, -frame->origin_x, right, point);
qglVertex3fv(point);
glVertex3fv(point);
qglTexCoord2f(1, 0);
glTexCoord2f(1, 0);
VectorMA(e->origin, frame->height - frame->origin_y, up, point);
VectorMA(point, frame->width - frame->origin_x, right, point);
qglVertex3fv(point);
glVertex3fv(point);
qglTexCoord2f(1, 1);
glTexCoord2f(1, 1);
VectorMA(e->origin, -frame->origin_y, up, point);
VectorMA(point, frame->width - frame->origin_x, right, point);
qglVertex3fv(point);
glVertex3fv(point);
qglEnd();
glEnd();
qglDisable(GL_ALPHA_TEST);
glDisable(GL_ALPHA_TEST);
R_TexEnv(GL_REPLACE);
if (alpha != 1.0F)
{
qglDisable(GL_BLEND);
glDisable(GL_BLEND);
}
qglColor4f(1, 1, 1, 1);
glColor4f(1, 1, 1, 1);
}
void
@ -275,35 +275,35 @@ R_DrawNullModel(void)
R_LightPoint(currententity->origin, shadelight);
}
qglPushMatrix();
glPushMatrix();
R_RotateForEntity(currententity);
qglDisable(GL_TEXTURE_2D);
qglColor3fv(shadelight);
glDisable(GL_TEXTURE_2D);
glColor3fv(shadelight);
qglBegin(GL_TRIANGLE_FAN);
qglVertex3f(0, 0, -16);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0, 0, -16);
for (i = 0; i <= 4; i++)
{
qglVertex3f(16 * cos(i * M_PI / 2), 16 * sin(i * M_PI / 2), 0);
glVertex3f(16 * cos(i * M_PI / 2), 16 * sin(i * M_PI / 2), 0);
}
qglEnd();
glEnd();
qglBegin(GL_TRIANGLE_FAN);
qglVertex3f(0, 0, 16);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0, 0, 16);
for (i = 4; i >= 0; i--)
{
qglVertex3f(16 * cos(i * M_PI / 2), 16 * sin(i * M_PI / 2), 0);
glVertex3f(16 * cos(i * M_PI / 2), 16 * sin(i * M_PI / 2), 0);
}
qglEnd();
glEnd();
qglColor3f(1, 1, 1);
qglPopMatrix();
qglEnable(GL_TEXTURE_2D);
glColor3f(1, 1, 1);
glPopMatrix();
glEnable(GL_TEXTURE_2D);
}
void
@ -361,7 +361,7 @@ R_DrawEntitiesOnList(void)
/* draw transparent entities
we could sort these if it ever
becomes a problem... */
qglDepthMask(0);
glDepthMask(0);
for (i = 0; i < r_newrefdef.num_entities; i++)
{
@ -404,7 +404,7 @@ R_DrawEntitiesOnList(void)
}
}
qglDepthMask(1); /* back to writing */
glDepthMask(1); /* back to writing */
}
void
@ -418,10 +418,10 @@ R_DrawParticles2(int num_particles, const particle_t particles[],
byte color[4];
R_Bind(r_particletexture->texnum);
qglDepthMask(GL_FALSE); /* no z buffering */
qglEnable(GL_BLEND);
glDepthMask(GL_FALSE); /* no z buffering */
glEnable(GL_BLEND);
R_TexEnv(GL_MODULATE);
qglBegin(GL_TRIANGLES);
glBegin(GL_TRIANGLES);
VectorScale(vup, 1.5, up);
VectorScale(vright, 1.5, right);
@ -445,26 +445,26 @@ R_DrawParticles2(int num_particles, const particle_t particles[],
*(int *)color = colortable[p->color];
color[3] = p->alpha * 255;
qglColor4ubv(color);
glColor4ubv(color);
qglTexCoord2f(0.0625, 0.0625);
qglVertex3fv(p->origin);
glTexCoord2f(0.0625, 0.0625);
glVertex3fv(p->origin);
qglTexCoord2f(1.0625, 0.0625);
qglVertex3f(p->origin[0] + up[0] * scale,
glTexCoord2f(1.0625, 0.0625);
glVertex3f(p->origin[0] + up[0] * scale,
p->origin[1] + up[1] * scale,
p->origin[2] + up[2] * scale);
qglTexCoord2f(0.0625, 1.0625);
qglVertex3f(p->origin[0] + right[0] * scale,
glTexCoord2f(0.0625, 1.0625);
glVertex3f(p->origin[0] + right[0] * scale,
p->origin[1] + right[1] * scale,
p->origin[2] + right[2] * scale);
}
qglEnd();
qglDisable(GL_BLEND);
qglColor4f(1, 1, 1, 1);
qglDepthMask(1); /* back to normal Z buffering */
glEnd();
glDisable(GL_BLEND);
glColor4f(1, 1, 1, 1);
glDepthMask(1); /* back to normal Z buffering */
R_TexEnv(GL_REPLACE);
}
@ -477,13 +477,13 @@ R_DrawParticles(void)
unsigned char color[4];
const particle_t *p;
qglDepthMask(GL_FALSE);
qglEnable(GL_BLEND);
qglDisable(GL_TEXTURE_2D);
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
qglPointSize(LittleFloat(gl_particle_size->value));
glPointSize(LittleFloat(gl_particle_size->value));
qglBegin(GL_POINTS);
glBegin(GL_POINTS);
for (i = 0, p = r_newrefdef.particles;
i < r_newrefdef.num_particles;
@ -491,16 +491,16 @@ R_DrawParticles(void)
{
*(int *)color = d_8to24table[p->color & 0xFF];
color[3] = p->alpha * 255;
qglColor4ubv(color);
qglVertex3fv(p->origin);
glColor4ubv(color);
glVertex3fv(p->origin);
}
qglEnd();
glEnd();
qglDisable(GL_BLEND);
qglColor4f(1.0F, 1.0F, 1.0F, 1.0F);
qglDepthMask(GL_TRUE);
qglEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
glDepthMask(GL_TRUE);
glEnable(GL_TEXTURE_2D);
}
else
{
@ -522,31 +522,31 @@ R_PolyBlend(void)
return;
}
qglDisable(GL_ALPHA_TEST);
qglEnable(GL_BLEND);
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_2D);
qglLoadIdentity();
glLoadIdentity();
qglRotatef(-90, 1, 0, 0); /* put Z going up */
qglRotatef(90, 0, 0, 1); /* put Z going up */
glRotatef(-90, 1, 0, 0); /* put Z going up */
glRotatef(90, 0, 0, 1); /* put Z going up */
qglColor4fv(v_blend);
glColor4fv(v_blend);
qglBegin(GL_QUADS);
glBegin(GL_QUADS);
qglVertex3f(10, 100, 100);
qglVertex3f(10, -100, 100);
qglVertex3f(10, -100, -100);
qglVertex3f(10, 100, -100);
qglEnd();
glVertex3f(10, 100, 100);
glVertex3f(10, -100, 100);
glVertex3f(10, -100, -100);
glVertex3f(10, 100, -100);
glEnd();
qglDisable(GL_BLEND);
qglEnable(GL_TEXTURE_2D);
qglEnable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glEnable(GL_ALPHA_TEST);
qglColor4f(1, 1, 1, 1);
glColor4f(1, 1, 1, 1);
}
int
@ -659,14 +659,14 @@ R_SetupFrame(void)
/* clear out the portion of the screen that the NOWORLDMODEL defines */
if (r_newrefdef.rdflags & RDF_NOWORLDMODEL)
{
qglEnable(GL_SCISSOR_TEST);
qglClearColor(0.3, 0.3, 0.3, 1);
qglScissor(r_newrefdef.x,
glEnable(GL_SCISSOR_TEST);
glClearColor(0.3, 0.3, 0.3, 1);
glScissor(r_newrefdef.x,
vid.height - r_newrefdef.height - r_newrefdef.y,
r_newrefdef.width, r_newrefdef.height);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
qglClearColor(1, 0, 0.5, 0.5);
qglDisable(GL_SCISSOR_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(1, 0, 0.5, 0.5);
glDisable(GL_SCISSOR_TEST);
}
}
@ -685,7 +685,7 @@ R_MYgluPerspective(GLdouble fovy, GLdouble aspect,
xmin += -(2 * gl_state.camera_separation) / zNear;
xmax += -(2 * gl_state.camera_separation) / zNear;
qglFrustum(xmin, xmax, ymin, ymax, zNear, zFar);
glFrustum(xmin, xmax, ymin, ymax, zNear, zFar);
}
void
@ -704,12 +704,12 @@ R_SetupGL(void)
w = x2 - x;
h = y - y2;
qglViewport(x, y2, w, h);
glViewport(x, y2, w, h);
/* set up projection matrix */
screenaspect = (float)r_newrefdef.width / r_newrefdef.height;
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (gl_farsee->value == 0)
{
@ -720,34 +720,34 @@ R_SetupGL(void)
R_MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 8192);
}
qglCullFace(GL_FRONT);
glCullFace(GL_FRONT);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
qglRotatef(-90, 1, 0, 0); /* put Z going up */
qglRotatef(90, 0, 0, 1); /* put Z going up */
qglRotatef(-r_newrefdef.viewangles[2], 1, 0, 0);
qglRotatef(-r_newrefdef.viewangles[0], 0, 1, 0);
qglRotatef(-r_newrefdef.viewangles[1], 0, 0, 1);
qglTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1],
glRotatef(-90, 1, 0, 0); /* put Z going up */
glRotatef(90, 0, 0, 1); /* put Z going up */
glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0);
glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0);
glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1);
glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1],
-r_newrefdef.vieworg[2]);
qglGetFloatv(GL_MODELVIEW_MATRIX, r_world_matrix);
glGetFloatv(GL_MODELVIEW_MATRIX, r_world_matrix);
/* set drawing parms */
if (gl_cull->value)
{
qglEnable(GL_CULL_FACE);
glEnable(GL_CULL_FACE);
}
else
{
qglDisable(GL_CULL_FACE);
glDisable(GL_CULL_FACE);
}
qglDisable(GL_BLEND);
qglDisable(GL_ALPHA_TEST);
qglEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glEnable(GL_DEPTH_TEST);
}
void
@ -759,7 +759,7 @@ R_Clear(void)
if (gl_clear->value)
{
qglClear(GL_COLOR_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT);
}
trickframe++;
@ -768,50 +768,50 @@ R_Clear(void)
{
gldepthmin = 0;
gldepthmax = 0.49999;
qglDepthFunc(GL_LEQUAL);
glDepthFunc(GL_LEQUAL);
}
else
{
gldepthmin = 1;
gldepthmax = 0.5;
qglDepthFunc(GL_GEQUAL);
glDepthFunc(GL_GEQUAL);
}
}
else
{
if (gl_clear->value)
{
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
else
{
qglClear(GL_DEPTH_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
}
gldepthmin = 0;
gldepthmax = 1;
qglDepthFunc(GL_LEQUAL);
glDepthFunc(GL_LEQUAL);
}
qglDepthRange(gldepthmin, gldepthmax);
glDepthRange(gldepthmin, gldepthmax);
if (gl_zfix->value)
{
if (gldepthmax > gldepthmin)
{
qglPolygonOffset(0.05, 1);
glPolygonOffset(0.05, 1);
}
else
{
qglPolygonOffset(-0.05, -1);
glPolygonOffset(-0.05, -1);
}
}
/* stencilbuffer shadows */
if (gl_shadows->value && have_stencil && gl_stencilshadow->value)
{
qglClearStencil(1);
qglClear(GL_STENCIL_BUFFER_BIT);
glClearStencil(1);
glClear(GL_STENCIL_BUFFER_BIT);
}
}
@ -849,7 +849,7 @@ R_RenderView(refdef_t *fd)
if (gl_finish->value)
{
qglFinish();
glFinish();
}
R_SetupFrame();
@ -884,17 +884,17 @@ void
R_SetGL2D(void)
{
/* set 2D virtual screen size */
qglViewport(0, 0, vid.width, vid.height);
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglOrtho(0, vid.width, vid.height, 0, -99999, 99999);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_CULL_FACE);
qglDisable(GL_BLEND);
qglEnable(GL_ALPHA_TEST);
qglColor4f(1, 1, 1, 1);
glViewport(0, 0, vid.width, vid.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, vid.width, vid.height, 0, -99999, 99999);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
glColor4f(1, 1, 1, 1);
}
void
@ -1148,13 +1148,13 @@ R_Init(void *hinstance, void *hWnd)
/* get our various GL strings */
VID_Printf(PRINT_ALL, "\nOpenGL setting:\n", gl_config.vendor_string);
gl_config.vendor_string = (char *)qglGetString(GL_VENDOR);
gl_config.vendor_string = (char *)glGetString(GL_VENDOR);
VID_Printf(PRINT_ALL, "GL_VENDOR: %s\n", gl_config.vendor_string);
gl_config.renderer_string = (char *)qglGetString(GL_RENDERER);
gl_config.renderer_string = (char *)glGetString(GL_RENDERER);
VID_Printf(PRINT_ALL, "GL_RENDERER: %s\n", gl_config.renderer_string);
gl_config.version_string = (char *)qglGetString(GL_VERSION);
gl_config.version_string = (char *)glGetString(GL_VERSION);
VID_Printf(PRINT_ALL, "GL_VERSION: %s\n", gl_config.version_string);
gl_config.extensions_string = (char *)qglGetString(GL_EXTENSIONS);
gl_config.extensions_string = (char *)glGetString(GL_EXTENSIONS);
VID_Printf(PRINT_ALL, "GL_EXTENSIONS: %s\n", gl_config.extensions_string);
Q_strlcpy(renderer_buffer, gl_config.renderer_string, sizeof(renderer_buffer));
@ -1274,7 +1274,7 @@ R_Init(void *hinstance, void *hWnd)
{
VID_Printf(PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic\n");
gl_config.anisotropic = true;
qglGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_config.max_anisotropy);
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_config.max_anisotropy);
Cvar_SetValue("gl_anisotropic_avail", gl_config.max_anisotropy);
}
else
@ -1331,7 +1331,7 @@ R_Init(void *hinstance, void *hWnd)
R_InitParticleTexture();
Draw_InitLocal();
err = qglGetError();
err = glGetError();
if (err != GL_NO_ERROR)
{
@ -1384,17 +1384,17 @@ R_BeginFrame(float camera_separation)
}
/* go into 2D mode */
qglViewport(0, 0, vid.width, vid.height);
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglOrtho(0, vid.width, vid.height, 0, -99999, 99999);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_CULL_FACE);
qglDisable(GL_BLEND);
qglEnable(GL_ALPHA_TEST);
qglColor4f(1, 1, 1, 1);
glViewport(0, 0, vid.width, vid.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, vid.width, vid.height, 0, -99999, 99999);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
glColor4f(1, 1, 1, 1);
/* draw buffer stuff */
if (gl_drawbuffer->modified)
@ -1405,11 +1405,11 @@ R_BeginFrame(float camera_separation)
{
if (Q_stricmp(gl_drawbuffer->string, "GL_FRONT") == 0)
{
qglDrawBuffer(GL_FRONT);
glDrawBuffer(GL_FRONT);
}
else
{
qglDrawBuffer(GL_BACK);
glDrawBuffer(GL_BACK);
}
}
}
@ -1467,9 +1467,9 @@ R_SetPalette(const unsigned char *palette)
R_SetTexturePalette(r_rawpalette);
qglClearColor(0, 0, 0, 0);
qglClear(GL_COLOR_BUFFER_BIT);
qglClearColor(1, 0, 0.5, 0.5);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(1, 0, 0.5, 0.5);
}
/* R_DrawBeam */
@ -1512,9 +1512,9 @@ R_DrawBeam(entity_t *e)
VectorAdd(start_points[i], direction, end_points[i]);
}
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_BLEND);
qglDepthMask(GL_FALSE);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
r = (LittleLong(d_8to24table[e->skinnum & 0xFF])) & 0xFF;
g = (LittleLong(d_8to24table[e->skinnum & 0xFF]) >> 8) & 0xFF;
@ -1524,23 +1524,23 @@ R_DrawBeam(entity_t *e)
g *= 1 / 255.0F;
b *= 1 / 255.0F;
qglColor4f(r, g, b, e->alpha);
glColor4f(r, g, b, e->alpha);
qglBegin(GL_TRIANGLE_STRIP);
glBegin(GL_TRIANGLE_STRIP);
for (i = 0; i < NUM_BEAM_SEGS; i++)
{
qglVertex3fv(start_points[i]);
qglVertex3fv(end_points[i]);
qglVertex3fv(start_points[(i + 1) % NUM_BEAM_SEGS]);
qglVertex3fv(end_points[(i + 1) % NUM_BEAM_SEGS]);
glVertex3fv(start_points[i]);
glVertex3fv(end_points[i]);
glVertex3fv(start_points[(i + 1) % NUM_BEAM_SEGS]);
glVertex3fv(end_points[(i + 1) % NUM_BEAM_SEGS]);
}
qglEnd();
glEnd();
qglEnable(GL_TEXTURE_2D);
qglDisable(GL_BLEND);
qglDepthMask(GL_TRUE);
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
}
/*void

114
src/client/refresh/r_mesh.c
View file

@ -123,7 +123,7 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
(RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE | RF_SHELL_DOUBLE |
RF_SHELL_HALF_DAM))
{
qglDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_2D);
}
frontlerp = 1.0 - backlerp;
@ -157,19 +157,19 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
{
float colorArray[MAX_VERTS * 4];
qglEnableClientState(GL_VERTEX_ARRAY);
qglVertexPointer(3, GL_FLOAT, 16, s_lerped);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 16, s_lerped);
if (currententity->flags &
(RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE |
RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM))
{
qglColor4f(shadelight[0], shadelight[1], shadelight[2], alpha);
glColor4f(shadelight[0], shadelight[1], shadelight[2], alpha);
}
else
{
qglEnableClientState(GL_COLOR_ARRAY);
qglColorPointer(3, GL_FLOAT, 0, colorArray);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(3, GL_FLOAT, 0, colorArray);
/* pre light everything */
for (i = 0; i < paliashdr->num_xyz; i++)
@ -200,11 +200,11 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
if (count < 0)
{
count = -count;
qglBegin(GL_TRIANGLE_FAN);
glBegin(GL_TRIANGLE_FAN);
}
else
{
qglBegin(GL_TRIANGLE_STRIP);
glBegin(GL_TRIANGLE_STRIP);
}
if (currententity->flags &
@ -217,7 +217,7 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
index_xyz = order[2];
order += 3;
qglVertex3fv(s_lerped[index_xyz]);
glVertex3fv(s_lerped[index_xyz]);
}
while (--count);
}
@ -226,17 +226,17 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
do
{
/* texture coordinates come from the draw list */
qglTexCoord2f(((float *)order)[0], ((float *)order)[1]);
glTexCoord2f(((float *)order)[0], ((float *)order)[1]);
index_xyz = order[2];
order += 3;
qglArrayElement(index_xyz);
glArrayElement(index_xyz);
}
while (--count);
}
qglEnd();
glEnd();
}
if (qglUnlockArraysEXT != 0)
@ -259,11 +259,11 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
if (count < 0)
{
count = -count;
qglBegin(GL_TRIANGLE_FAN);
glBegin(GL_TRIANGLE_FAN);
}
else
{
qglBegin(GL_TRIANGLE_STRIP);
glBegin(GL_TRIANGLE_STRIP);
}
if (currententity->flags &
@ -274,9 +274,9 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
index_xyz = order[2];
order += 3;
qglColor4f(shadelight[0], shadelight[1],
glColor4f(shadelight[0], shadelight[1],
shadelight[2], alpha);
qglVertex3fv(s_lerped[index_xyz]);
glVertex3fv(s_lerped[index_xyz]);
}
while (--count);
}
@ -285,21 +285,21 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
do
{
/* texture coordinates come from the draw list */
qglTexCoord2f(((float *)order)[0], ((float *)order)[1]);
glTexCoord2f(((float *)order)[0], ((float *)order)[1]);
index_xyz = order[2];
order += 3;
/* normals and vertexes come from the frame list */
l = shadedots[verts[index_xyz].lightnormalindex];
qglColor4f(l * shadelight[0], l * shadelight[1],
glColor4f(l * shadelight[0], l * shadelight[1],
l * shadelight[2], alpha);
qglVertex3fv(s_lerped[index_xyz]);
glVertex3fv(s_lerped[index_xyz]);
}
while (--count);
}
qglEnd();
glEnd();
}
}
@ -307,7 +307,7 @@ R_DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
(RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE |
RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM))
{
qglEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_2D);
}
}
@ -326,9 +326,9 @@ R_DrawAliasShadow(dmdl_t *paliashdr, int posenum)
/* stencilbuffer shadows */
if (have_stencil && gl_stencilshadow->value)
{
qglEnable(GL_STENCIL_TEST);
qglStencilFunc(GL_EQUAL, 1, 2);
qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_EQUAL, 1, 2);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
}
while (1)
@ -344,11 +344,11 @@ R_DrawAliasShadow(dmdl_t *paliashdr, int posenum)
if (count < 0)
{
count = -count;
qglBegin(GL_TRIANGLE_FAN);
glBegin(GL_TRIANGLE_FAN);
}
else
{
qglBegin(GL_TRIANGLE_STRIP);
glBegin(GL_TRIANGLE_STRIP);
}
do
@ -359,19 +359,19 @@ R_DrawAliasShadow(dmdl_t *paliashdr, int posenum)
point[0] -= shadevector[0] * (point[2] + lheight);
point[1] -= shadevector[1] * (point[2] + lheight);
point[2] = height;
qglVertex3fv(point);
glVertex3fv(point);
order += 3;
}
while (--count);
qglEnd();
glEnd();
}
/* stencilbuffer shadows */
if (have_stencil && gl_stencilshadow->value)
{
qglDisable(GL_STENCIL_TEST);
glDisable(GL_STENCIL_TEST);
}
}
@ -693,7 +693,7 @@ R_DrawAliasModel(entity_t *e)
if (currententity->flags & RF_DEPTHHACK)
{
/* hack the depth range to prevent view model from poking into walls */
qglDepthRange(gldepthmin, gldepthmin + 0.3 * (gldepthmax - gldepthmin));
glDepthRange(gldepthmin, gldepthmin + 0.3 * (gldepthmax - gldepthmin));
}
if ((currententity->flags & RF_WEAPONMODEL) && (gl_lefthand->value == 1.0F))
@ -701,19 +701,19 @@ R_DrawAliasModel(entity_t *e)
extern void R_MYgluPerspective(GLdouble fovy, GLdouble aspect,
GLdouble zNear, GLdouble zFar);
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglScalef(-1, 1, 1);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glScalef(-1, 1, 1);
R_MYgluPerspective(r_newrefdef.fov_y,
(float)r_newrefdef.width / r_newrefdef.height,
4, 4096);
qglMatrixMode(GL_MODELVIEW);
glMatrixMode(GL_MODELVIEW);
qglCullFace(GL_BACK);
glCullFace(GL_BACK);
}
qglPushMatrix();
glPushMatrix();
e->angles[PITCH] = -e->angles[PITCH];
R_RotateForEntity(e);
e->angles[PITCH] = -e->angles[PITCH];
@ -748,13 +748,13 @@ R_DrawAliasModel(entity_t *e)
R_Bind(skin->texnum);
/* draw it */
qglShadeModel(GL_SMOOTH);
glShadeModel(GL_SMOOTH);
R_TexEnv(GL_MODULATE);
if (currententity->flags & RF_TRANSLUCENT)
{
qglEnable(GL_BLEND);
glEnable(GL_BLEND);
}
if ((currententity->frame >= paliashdr->num_frames) ||
@ -783,46 +783,46 @@ R_DrawAliasModel(entity_t *e)
R_DrawAliasFrameLerp(paliashdr, currententity->backlerp);
R_TexEnv(GL_REPLACE);
qglShadeModel(GL_FLAT);
glShadeModel(GL_FLAT);
qglPopMatrix();
glPopMatrix();
if ((currententity->flags & RF_WEAPONMODEL) && (gl_lefthand->value == 1.0F))
{
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglCullFace(GL_FRONT);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glCullFace(GL_FRONT);
}
if (currententity->flags & RF_TRANSLUCENT)
{
qglDisable(GL_BLEND);
glDisable(GL_BLEND);
}
if (currententity->flags & RF_DEPTHHACK)
{
qglDepthRange(gldepthmin, gldepthmax);
glDepthRange(gldepthmin, gldepthmax);
}
if (gl_shadows->value &&
!(currententity->flags & (RF_TRANSLUCENT | RF_WEAPONMODEL | RF_NOSHADOW)))
{
qglPushMatrix();
glPushMatrix();
/* don't rotate shadows on ungodly axes */
qglTranslatef(e->origin[0], e->origin[1], e->origin[2]);
qglRotatef(e->angles[1], 0, 0, 1);
glTranslatef(e->origin[0], e->origin[1], e->origin[2]);
glRotatef(e->angles[1], 0, 0, 1);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_BLEND);
qglColor4f(0, 0, 0, 0.5);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glColor4f(0, 0, 0, 0.5);
R_DrawAliasShadow(paliashdr, currententity->frame);
qglEnable(GL_TEXTURE_2D);
qglDisable(GL_BLEND);
qglPopMatrix();
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glPopMatrix();
}
qglColor4f(1, 1, 1, 1);
glColor4f(1, 1, 1, 1);
}

38
src/client/refresh/r_misc.c
View file

@ -130,7 +130,7 @@ R_ScreenShot(void)
buffer[15] = vid.height >> 8;
buffer[16] = 24; /* pixel size */
qglReadPixels(0, 0, vid.width, vid.height, GL_RGB,
glReadPixels(0, 0, vid.width, vid.height, GL_RGB,
GL_UNSIGNED_BYTE, buffer + 18);
/* swap rgb to bgr */
@ -163,33 +163,33 @@ R_Strings(void)
void
R_SetDefaultState(void)
{
qglClearColor(1, 0, 0.5, 0.5);
qglCullFace(GL_FRONT);
qglEnable(GL_TEXTURE_2D);
glClearColor(1, 0, 0.5, 0.5);
glCullFace(GL_FRONT);
glEnable(GL_TEXTURE_2D);
qglEnable(GL_ALPHA_TEST);
qglAlphaFunc(GL_GREATER, 0.666);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.666);
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_CULL_FACE);
qglDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
qglColor4f(1, 1, 1, 1);
glColor4f(1, 1, 1, 1);
qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
qglShadeModel(GL_FLAT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glShadeModel(GL_FLAT);
R_TextureMode(gl_texturemode->string);
R_TextureAlphaMode(gl_texturealphamode->string);
R_TextureSolidMode(gl_texturesolidmode->string);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
R_TexEnv(GL_REPLACE);
@ -205,7 +205,7 @@ R_SetDefaultState(void)
drivers, especially the crappy Mesa3D backends like
i915.so. That the points are squares and not circles
is not a problem by Quake II! */
qglEnable(GL_POINT_SMOOTH);
glEnable(GL_POINT_SMOOTH);
qglPointParameterfEXT(GL_POINT_SIZE_MIN_EXT,
gl_particle_min_size->value);
qglPointParameterfEXT(GL_POINT_SIZE_MAX_EXT,
@ -215,7 +215,7 @@ R_SetDefaultState(void)
if (qglColorTableEXT && gl_ext_palettedtexture->value)
{
qglEnable(GL_SHARED_TEXTURE_PALETTE_EXT);
glEnable(GL_SHARED_TEXTURE_PALETTE_EXT);
R_SetTexturePalette(d_8to24table);
}

194
src/client/refresh/r_surf.c
View file

@ -71,16 +71,16 @@ R_DrawGLPoly(glpoly_t *p)
int i;
float *v;
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
v = p->verts[0];
for (i = 0; i < p->numverts; i++, v += VERTEXSIZE)
{
qglTexCoord2f(v[3], v[4]);
qglVertex3fv(v);
glTexCoord2f(v[3], v[4]);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
void
@ -100,16 +100,16 @@ R_DrawGLFlowingPoly(msurface_t *fa)
scroll = -64.0;
}
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
v = p->verts[0];
for (i = 0; i < p->numverts; i++, v += VERTEXSIZE)
{
qglTexCoord2f((v[3] + scroll), v[4]);
qglVertex3fv(v);
glTexCoord2f((v[3] + scroll), v[4]);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
void
@ -123,9 +123,9 @@ R_DrawTriangleOutlines(void)
return;
}
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_DEPTH_TEST);
qglColor4f(1, 1, 1, 1);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glColor4f(1, 1, 1, 1);
for (i = 0; i < MAX_LIGHTMAPS; i++)
{
@ -141,19 +141,19 @@ R_DrawTriangleOutlines(void)
{
for (j = 2; j < p->numverts; j++)
{
qglBegin(GL_LINE_STRIP);
qglVertex3fv(p->verts[0]);
qglVertex3fv(p->verts[j - 1]);
qglVertex3fv(p->verts[j]);
qglVertex3fv(p->verts[0]);
qglEnd();
glBegin(GL_LINE_STRIP);
glVertex3fv(p->verts[0]);
glVertex3fv(p->verts[j - 1]);
glVertex3fv(p->verts[j]);
glVertex3fv(p->verts[0]);
glEnd();
}
}
}
}
qglEnable(GL_DEPTH_TEST);
qglEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
}
void
@ -174,15 +174,15 @@ R_DrawGLPolyChain(glpoly_t *p, float soffset, float toffset)
return;
}
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
for (j = 0; j < p->numverts; j++, v += VERTEXSIZE)
{
qglTexCoord2f(v[5], v[6]);
qglVertex3fv(v);
glTexCoord2f(v[5], v[6]);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
else
@ -192,16 +192,16 @@ R_DrawGLPolyChain(glpoly_t *p, float soffset, float toffset)
float *v;
int j;
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
v = p->verts[0];
for (j = 0; j < p->numverts; j++, v += VERTEXSIZE)
{
qglTexCoord2f(v[5] - soffset, v[6] - toffset);
qglVertex3fv(v);
glTexCoord2f(v[5] - soffset, v[6] - toffset);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
}
@ -228,21 +228,21 @@ R_BlendLightmaps(void)
}
/* don't bother writing Z */
qglDepthMask(0);
glDepthMask(0);
/* set the appropriate blending mode unless
we're only looking at the lightmaps. */
if (!gl_lightmap->value)
{
qglEnable(GL_BLEND);
glEnable(GL_BLEND);
if (gl_saturatelighting->value)
{
qglBlendFunc(GL_ONE, GL_ONE);
glBlendFunc(GL_ONE, GL_ONE);
}
else
{
qglBlendFunc(GL_ZERO, GL_SRC_COLOR);
glBlendFunc(GL_ZERO, GL_SRC_COLOR);
}
}
@ -366,9 +366,9 @@ R_BlendLightmaps(void)
}
/* restore state */
qglDisable(GL_BLEND);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglDepthMask(1);
glDisable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(1);
}
void
@ -388,7 +388,7 @@ R_RenderBrushPoly(msurface_t *fa)
/* warp texture, no lightmaps */
R_TexEnv(GL_MODULATE);
qglColor4f(gl_state.inverse_intensity, gl_state.inverse_intensity,
glColor4f(gl_state.inverse_intensity, gl_state.inverse_intensity,
gl_state.inverse_intensity, 1.0F);
R_EmitWaterPolys(fa);
R_TexEnv(GL_REPLACE);
@ -454,7 +454,7 @@ R_RenderBrushPoly(msurface_t *fa)
R_Bind(gl_state.lightmap_textures + fa->lightmaptexturenum);
qglTexSubImage2D(GL_TEXTURE_2D, 0, fa->light_s, fa->light_t,
glTexSubImage2D(GL_TEXTURE_2D, 0, fa->light_s, fa->light_t,
smax, tmax, GL_LIGHTMAP_FORMAT, GL_UNSIGNED_BYTE, temp);
fa->lightmapchain = gl_lms.lightmap_surfaces[fa->lightmaptexturenum];
@ -485,9 +485,9 @@ R_DrawAlphaSurfaces(void)
float intens;
/* go back to the world matrix */
qglLoadMatrixf(r_world_matrix);
glLoadMatrixf(r_world_matrix);
qglEnable(GL_BLEND);
glEnable(GL_BLEND);
R_TexEnv(GL_MODULATE);
/* the textures are prescaled up for a better
@ -501,15 +501,15 @@ R_DrawAlphaSurfaces(void)
if (s->texinfo->flags & SURF_TRANS33)
{
qglColor4f(intens, intens, intens, 0.33);
glColor4f(intens, intens, intens, 0.33);
}
else if (s->texinfo->flags & SURF_TRANS66)
{
qglColor4f(intens, intens, intens, 0.66);
glColor4f(intens, intens, intens, 0.66);
}
else
{
qglColor4f(intens, intens, intens, 1);
glColor4f(intens, intens, intens, 1);
}
if (s->flags & SURF_DRAWTURB)
@ -527,8 +527,8 @@ R_DrawAlphaSurfaces(void)
}
R_TexEnv(GL_REPLACE);
qglColor4f(1, 1, 1, 1);
qglDisable(GL_BLEND);
glColor4f(1, 1, 1, 1);
glDisable(GL_BLEND);
r_alpha_surfaces = NULL;
}
@ -677,7 +677,7 @@ R_RenderLightmappedPoly(msurface_t *surf)
lmtex = surf->lightmaptexturenum;
qglTexSubImage2D(GL_TEXTURE_2D, 0, surf->light_s, surf->light_t,
glTexSubImage2D(GL_TEXTURE_2D, 0, surf->light_s, surf->light_t,
smax, tmax, GL_LIGHTMAP_FORMAT, GL_UNSIGNED_BYTE, temp);
}
else
@ -691,7 +691,7 @@ R_RenderLightmappedPoly(msurface_t *surf)
lmtex = 0;
qglTexSubImage2D(GL_TEXTURE_2D, 0, surf->light_s, surf->light_t,
glTexSubImage2D(GL_TEXTURE_2D, 0, surf->light_s, surf->light_t,
smax, tmax, GL_LIGHTMAP_FORMAT, GL_UNSIGNED_BYTE, temp);
}
@ -715,16 +715,16 @@ R_RenderLightmappedPoly(msurface_t *surf)
for (p = surf->polys; p; p = p->chain)
{
v = p->verts[0];
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
for (i = 0; i < nv; i++, v += VERTEXSIZE)
{
qglMTexCoord2fSGIS(QGL_TEXTURE0, (v[3] + scroll), v[4]);
qglMTexCoord2fSGIS(QGL_TEXTURE1, v[5], v[6]);
qglVertex3fv(v);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
else
@ -732,16 +732,16 @@ R_RenderLightmappedPoly(msurface_t *surf)
for (p = surf->polys; p; p = p->chain)
{
v = p->verts[0];
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
for (i = 0; i < nv; i++, v += VERTEXSIZE)
{
qglMTexCoord2fSGIS(QGL_TEXTURE0, v[3], v[4]);
qglMTexCoord2fSGIS(QGL_TEXTURE1, v[5], v[6]);
qglVertex3fv(v);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
}
@ -766,16 +766,16 @@ R_RenderLightmappedPoly(msurface_t *surf)
for (p = surf->polys; p; p = p->chain)
{
v = p->verts[0];
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
for (i = 0; i < nv; i++, v += VERTEXSIZE)
{
qglMTexCoord2fSGIS(QGL_TEXTURE0, (v[3] + scroll), v[4]);
qglMTexCoord2fSGIS(QGL_TEXTURE1, v[5], v[6]);
qglVertex3fv(v);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
else
@ -783,16 +783,16 @@ R_RenderLightmappedPoly(msurface_t *surf)
for (p = surf->polys; p; p = p->chain)
{
v = p->verts[0];
qglBegin(GL_POLYGON);
glBegin(GL_POLYGON);
for (i = 0; i < nv; i++, v += VERTEXSIZE)
{
qglMTexCoord2fSGIS(QGL_TEXTURE0, v[3], v[4]);
qglMTexCoord2fSGIS(QGL_TEXTURE1, v[5], v[6]);
qglVertex3fv(v);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
}
@ -823,8 +823,8 @@ R_DrawInlineBModel(void)
if (currententity->flags & RF_TRANSLUCENT)
{
qglEnable(GL_BLEND);
qglColor4f(1, 1, 1, 0.25);
glEnable(GL_BLEND);
glColor4f(1, 1, 1, 0.25);
R_TexEnv(GL_MODULATE);
}
@ -868,8 +868,8 @@ R_DrawInlineBModel(void)
}
else
{
qglDisable(GL_BLEND);
qglColor4f(1, 1, 1, 1);
glDisable(GL_BLEND);
glColor4f(1, 1, 1, 1);
R_TexEnv(GL_REPLACE);
}
}
@ -913,10 +913,10 @@ R_DrawBrushModel(entity_t *e)
if (gl_zfix->value)
{
qglEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_POLYGON_OFFSET_FILL);
}
qglColor3f(1, 1, 1);
glColor3f(1, 1, 1);
memset(gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
VectorSubtract(r_newrefdef.vieworg, e->origin, modelorg);
@ -933,7 +933,7 @@ R_DrawBrushModel(entity_t *e)
modelorg[2] = DotProduct(temp, up);
}
qglPushMatrix();
glPushMatrix();
e->angles[0] = -e->angles[0];
e->angles[2] = -e->angles[2];
R_RotateForEntity(e);
@ -962,33 +962,33 @@ R_DrawBrushModel(entity_t *e)
else
{
R_TexEnv(GL_COMBINE_EXT);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
R_SelectTexture(GL_TEXTURE1);
R_TexEnv(GL_COMBINE_EXT);
if (gl_lightmap->value)
{
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
}
else
{
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_PREVIOUS_EXT);
}
if (gl_overbrightbits->value)
{
qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,
glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,
gl_overbrightbits->value);
}
}
@ -996,11 +996,11 @@ R_DrawBrushModel(entity_t *e)
R_DrawInlineBModel();
R_EnableMultitexture(false);
qglPopMatrix();
glPopMatrix();
if (gl_zfix->value)
{
qglDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_POLYGON_OFFSET_FILL);
}
}
@ -1165,7 +1165,7 @@ R_DrawWorld(void)
gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
qglColor3f(1, 1, 1);
glColor3f(1, 1, 1);
memset(gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
R_ClearSkyBox();
@ -1194,33 +1194,33 @@ R_DrawWorld(void)
else
{
R_TexEnv(GL_COMBINE_EXT);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
R_SelectTexture(GL_TEXTURE1);
R_TexEnv(GL_COMBINE_EXT);
if (gl_lightmap->value)
{
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
}
else
{
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);
qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_PREVIOUS_EXT);
}
if (gl_overbrightbits->value)
{
qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, gl_overbrightbits->value);
glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, gl_overbrightbits->value);
}
}

24
src/client/refresh/r_warp.c
View file

@ -297,7 +297,7 @@ R_EmitWaterPolys(msurface_t *fa)
{
p = bp;
qglBegin(GL_TRIANGLE_FAN);
glBegin(GL_TRIANGLE_FAN);
for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE)
{
@ -311,11 +311,11 @@ R_EmitWaterPolys(msurface_t *fa)
t = ot + r_turbsin[(int)((os * 0.125 + rdt) * TURBSCALE) & 255];
t *= (1.0 / 64);
qglTexCoord2f(s, t);
qglVertex3fv(v);
glTexCoord2f(s, t);
glVertex3fv(v);
}
qglEnd();
glEnd();
}
}
@ -634,8 +634,8 @@ R_MakeSkyVec(float s, float t, int axis)
}
t = 1.0 - t;
qglTexCoord2f(s, t);
qglVertex3fv(v);
glTexCoord2f(s, t);
glVertex3fv(v);
}
void
@ -660,9 +660,9 @@ R_DrawSkyBox(void)
}
}
qglPushMatrix();
qglTranslatef(r_origin[0], r_origin[1], r_origin[2]);
qglRotatef(r_newrefdef.time * skyrotate, skyaxis[0], skyaxis[1], skyaxis[2]);
glPushMatrix();
glTranslatef(r_origin[0], r_origin[1], r_origin[2]);
glRotatef(r_newrefdef.time * skyrotate, skyaxis[0], skyaxis[1], skyaxis[2]);
for (i = 0; i < 6; i++)
{
@ -682,15 +682,15 @@ R_DrawSkyBox(void)
R_Bind(sky_images[skytexorder[i]]->texnum);
qglBegin(GL_QUADS);
glBegin(GL_QUADS);
R_MakeSkyVec(skymins[0][i], skymins[1][i], i);
R_MakeSkyVec(skymins[0][i], skymaxs[1][i], i);
R_MakeSkyVec(skymaxs[0][i], skymaxs[1][i], i);
R_MakeSkyVec(skymaxs[0][i], skymins[1][i], i);
qglEnd();
glEnd();
}
qglPopMatrix();
glPopMatrix();
}
void