6680 lines
191 KiB
C++
6680 lines
191 KiB
C++
|
|
/*
|
|
* UNPUBLISHED -- Rights reserved under the copyright laws of the
|
|
* United States. Use of a copyright notice is precautionary only and
|
|
* does not imply publication or disclosure.
|
|
*
|
|
* THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION
|
|
* OF VICARIOUS VISIONS, INC. ANY DUPLICATION, MODIFICATION,
|
|
* DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR
|
|
* EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
|
|
*/
|
|
|
|
// leave this as first line for PCH reasons...
|
|
//
|
|
#include "../server/exe_headers.h"
|
|
|
|
|
|
/*
|
|
** QGL_WIN.C
|
|
**
|
|
** This file implements the operating system binding of GL to QGL function
|
|
** pointers. When doing a port of Quake3 you must implement the following
|
|
** two functions:
|
|
**
|
|
** QGL_Init() - loads libraries, assigns function pointers, etc.
|
|
** QGL_Shutdown() - unloads libraries, NULLs function pointers
|
|
*/
|
|
#include <float.h>
|
|
#include "../renderer/tr_local.h"
|
|
#include "glw_win_dx8.h"
|
|
#include "win_local.h"
|
|
|
|
#ifdef _XBOX
|
|
#include <xgraphics.h>
|
|
//#include "win_flareeffect.h"
|
|
#include "win_lighteffects.h"
|
|
#include "win_highdynamicrange.h"
|
|
|
|
#ifndef FINAL_BUILD
|
|
#include <d3d8perf.h>
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#include <vector>
|
|
|
|
extern void Z_SetNewDeleteTemporary(bool);
|
|
|
|
#define GLW_USE_TRI_STRIPS 1
|
|
|
|
#ifdef _XBOX
|
|
#define GLW_MAX_DRAW_PACKET_SIZE 2040
|
|
#else
|
|
#define GLW_MAX_DRAW_PACKET_SIZE (SHADER_MAX_VERTEXES*12)
|
|
#endif
|
|
|
|
#define MEMORY_PROFILE 1
|
|
|
|
int texMemSize = 0;
|
|
|
|
#if MEMORY_PROFILE
|
|
|
|
static int getTexMemSize(IDirect3DTexture8* mipmap)
|
|
{
|
|
int levels = mipmap->GetLevelCount();
|
|
int size = 0;
|
|
while (levels--)
|
|
{
|
|
D3DSURFACE_DESC desc;
|
|
mipmap->GetLevelDesc(levels, &desc);
|
|
size += desc.Size;
|
|
}
|
|
return size;
|
|
}
|
|
#endif
|
|
|
|
void QGL_EnableLogging( qboolean enable );
|
|
|
|
void ( * qglAccum )(GLenum op, GLfloat value);
|
|
void ( * qglAlphaFunc )(GLenum func, GLclampf ref);
|
|
GLboolean ( * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
|
|
void ( * qglArrayElement )(GLint i);
|
|
void ( * qglBegin )(GLenum mode);
|
|
void ( * qglBeginEXT )(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1);//, GLint tex2, GLint tex3);
|
|
GLboolean ( * qglBeginFrame )(void);
|
|
void ( * qglBeginShadow )(void);
|
|
void ( * qglBindTexture )(GLenum target, GLuint texture);
|
|
void ( * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
|
|
void ( * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
|
|
void ( * qglCallList )(GLuint lnum);
|
|
void ( * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
|
|
void ( * qglClear )(GLbitfield mask);
|
|
void ( * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
|
|
void ( * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
|
|
void ( * qglClearDepth )(GLclampd depth);
|
|
void ( * qglClearIndex )(GLfloat c);
|
|
void ( * qglClearStencil )(GLint s);
|
|
void ( * qglClipPlane )(GLenum plane, const GLdouble *equation);
|
|
void ( * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
|
|
void ( * qglColor3bv )(const GLbyte *v);
|
|
void ( * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
|
|
void ( * qglColor3dv )(const GLdouble *v);
|
|
void ( * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
|
|
void ( * qglColor3fv )(const GLfloat *v);
|
|
void ( * qglColor3i )(GLint red, GLint green, GLint blue);
|
|
void ( * qglColor3iv )(const GLint *v);
|
|
void ( * qglColor3s )(GLshort red, GLshort green, GLshort blue);
|
|
void ( * qglColor3sv )(const GLshort *v);
|
|
void ( * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
|
|
void ( * qglColor3ubv )(const GLubyte *v);
|
|
void ( * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
|
|
void ( * qglColor3uiv )(const GLuint *v);
|
|
void ( * qglColor3us )(GLushort red, GLushort green, GLushort blue);
|
|
void ( * qglColor3usv )(const GLushort *v);
|
|
void ( * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
|
|
void ( * qglColor4bv )(const GLbyte *v);
|
|
void ( * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
|
|
void ( * qglColor4dv )(const GLdouble *v);
|
|
void ( * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
|
|
void ( * qglColor4fv )(const GLfloat *v);
|
|
void ( * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
|
|
void ( * qglColor4iv )(const GLint *v);
|
|
void ( * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
|
|
void ( * qglColor4sv )(const GLshort *v);
|
|
void ( * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
|
|
void ( * qglColor4ubv )(const GLubyte *v);
|
|
void ( * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
|
|
void ( * qglColor4uiv )(const GLuint *v);
|
|
void ( * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
|
|
void ( * qglColor4usv )(const GLushort *v);
|
|
void ( * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
|
|
void ( * qglColorMaterial )(GLenum face, GLenum mode);
|
|
void ( * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
void ( * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
|
|
void ( * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
|
|
void ( * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
|
|
void ( * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
|
|
void ( * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
|
|
void ( * qglCullFace )(GLenum mode);
|
|
void ( * qglDeleteLists )(GLuint lnum, GLsizei range);
|
|
void ( * qglDeleteTextures )(GLsizei n, const GLuint *textures);
|
|
void ( * qglDepthFunc )(GLenum func);
|
|
void ( * qglDepthMask )(GLboolean flag);
|
|
void ( * qglDepthRange )(GLclampd zNear, GLclampd zFar);
|
|
void ( * qglDisable )(GLenum cap);
|
|
void ( * qglDisableClientState )(GLenum array);
|
|
void ( * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
|
|
void ( * qglDrawBuffer )(GLenum mode);
|
|
void ( * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
|
|
void ( * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
|
|
void ( * qglEdgeFlag )(GLboolean flag);
|
|
void ( * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
|
|
void ( * qglEdgeFlagv )(const GLboolean *flag);
|
|
void ( * qglEnable )(GLenum cap);
|
|
void ( * qglEnableClientState )(GLenum array);
|
|
void ( * qglEnd )(void);
|
|
void ( * qglEndFrame )(void);
|
|
void ( * qglEndShadow )(void);
|
|
void ( * qglEndList )(void);
|
|
void ( * qglEvalCoord1d )(GLdouble u);
|
|
void ( * qglEvalCoord1dv )(const GLdouble *u);
|
|
void ( * qglEvalCoord1f )(GLfloat u);
|
|
void ( * qglEvalCoord1fv )(const GLfloat *u);
|
|
void ( * qglEvalCoord2d )(GLdouble u, GLdouble v);
|
|
void ( * qglEvalCoord2dv )(const GLdouble *u);
|
|
void ( * qglEvalCoord2f )(GLfloat u, GLfloat v);
|
|
void ( * qglEvalCoord2fv )(const GLfloat *u);
|
|
void ( * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
|
|
void ( * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
|
|
void ( * qglEvalPoint1 )(GLint i);
|
|
void ( * qglEvalPoint2 )(GLint i, GLint j);
|
|
void ( * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
|
|
void ( * qglFinish )(void);
|
|
void ( * qglFlush )(void);
|
|
void ( * qglFlushShadow )(void);
|
|
void ( * qglFogf )(GLenum pname, GLfloat param);
|
|
void ( * qglFogfv )(GLenum pname, const GLfloat *params);
|
|
void ( * qglFogi )(GLenum pname, GLint param);
|
|
void ( * qglFogiv )(GLenum pname, const GLint *params);
|
|
void ( * qglFrontFace )(GLenum mode);
|
|
void ( * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
|
|
GLuint ( * qglGenLists )(GLsizei range);
|
|
void ( * qglGenTextures )(GLsizei n, GLuint *textures);
|
|
void ( * qglGetBooleanv )(GLenum pname, GLboolean *params);
|
|
void ( * qglGetClipPlane )(GLenum plane, GLdouble *equation);
|
|
void ( * qglGetDoublev )(GLenum pname, GLdouble *params);
|
|
GLenum ( * qglGetError )(void);
|
|
void ( * qglGetFloatv )(GLenum pname, GLfloat *params);
|
|
void ( * qglGetIntegerv )(GLenum pname, GLint *params);
|
|
void ( * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
|
|
void ( * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
|
|
void ( * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
|
|
void ( * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
|
|
void ( * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
|
|
void ( * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
|
|
void ( * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
|
|
void ( * qglGetPixelMapfv )(GLenum gmap, GLfloat *values);
|
|
void ( * qglGetPixelMapuiv )(GLenum gmap, GLuint *values);
|
|
void ( * qglGetPixelMapusv )(GLenum gmap, GLushort *values);
|
|
void ( * qglGetPointerv )(GLenum pname, GLvoid* *params);
|
|
void ( * qglGetPolygonStipple )(GLubyte *mask);
|
|
const GLubyte * ( * qglGetString )(GLenum name);
|
|
void ( * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
|
|
void ( * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
|
|
void ( * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
|
|
void ( * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
|
|
void ( * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
|
|
void ( * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
|
|
void ( * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
|
|
void ( * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
|
|
void ( * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
|
|
void ( * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
|
|
void ( * qglHint )(GLenum target, GLenum mode);
|
|
void ( * qglIndexedTriToStrip )(GLsizei count, const GLushort *indices);
|
|
void ( * qglIndexMask )(GLuint mask);
|
|
void ( * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
void ( * qglIndexd )(GLdouble c);
|
|
void ( * qglIndexdv )(const GLdouble *c);
|
|
void ( * qglIndexf )(GLfloat c);
|
|
void ( * qglIndexfv )(const GLfloat *c);
|
|
void ( * qglIndexi )(GLint c);
|
|
void ( * qglIndexiv )(const GLint *c);
|
|
void ( * qglIndexs )(GLshort c);
|
|
void ( * qglIndexsv )(const GLshort *c);
|
|
void ( * qglIndexub )(GLubyte c);
|
|
void ( * qglIndexubv )(const GLubyte *c);
|
|
void ( * qglInitNames )(void);
|
|
void ( * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
|
|
GLboolean ( * qglIsEnabled )(GLenum cap);
|
|
GLboolean ( * qglIsList )(GLuint lnum);
|
|
GLboolean ( * qglIsTexture )(GLuint texture);
|
|
void ( * qglLightModelf )(GLenum pname, GLfloat param);
|
|
void ( * qglLightModelfv )(GLenum pname, const GLfloat *params);
|
|
void ( * qglLightModeli )(GLenum pname, GLint param);
|
|
void ( * qglLightModeliv )(GLenum pname, const GLint *params);
|
|
void ( * qglLightf )(GLenum light, GLenum pname, GLfloat param);
|
|
void ( * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
|
|
void ( * qglLighti )(GLenum light, GLenum pname, GLint param);
|
|
void ( * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
|
|
void ( * qglLineStipple )(GLint factor, GLushort pattern);
|
|
void ( * qglLineWidth )(GLfloat width);
|
|
void ( * qglListBase )(GLuint base);
|
|
void ( * qglLoadIdentity )(void);
|
|
void ( * qglLoadMatrixd )(const GLdouble *m);
|
|
void ( * qglLoadMatrixf )(const GLfloat *m);
|
|
void ( * qglLoadName )(GLuint name);
|
|
void ( * qglLogicOp )(GLenum opcode);
|
|
void ( * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
|
|
void ( * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
|
|
void ( * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
|
|
void ( * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
|
|
void ( * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
|
|
void ( * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
|
|
void ( * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
|
|
void ( * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
|
|
void ( * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
|
|
void ( * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
|
|
void ( * qglMateriali )(GLenum face, GLenum pname, GLint param);
|
|
void ( * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
|
|
void ( * qglMatrixMode )(GLenum mode);
|
|
void ( * qglMultMatrixd )(const GLdouble *m);
|
|
void ( * qglMultMatrixf )(const GLfloat *m);
|
|
void ( * qglNewList )(GLuint lnum, GLenum mode);
|
|
void ( * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
|
|
void ( * qglNormal3bv )(const GLbyte *v);
|
|
void ( * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
|
|
void ( * qglNormal3dv )(const GLdouble *v);
|
|
void ( * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
|
|
void ( * qglNormal3fv )(const GLfloat *v);
|
|
void ( * qglNormal3i )(GLint nx, GLint ny, GLint nz);
|
|
void ( * qglNormal3iv )(const GLint *v);
|
|
void ( * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
|
|
void ( * qglNormal3sv )(const GLshort *v);
|
|
void ( * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
void ( * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
|
|
void ( * qglPassThrough )(GLfloat token);
|
|
void ( * qglPixelMapfv )(GLenum gmap, GLsizei mapsize, const GLfloat *values);
|
|
void ( * qglPixelMapuiv )(GLenum gmap, GLsizei mapsize, const GLuint *values);
|
|
void ( * qglPixelMapusv )(GLenum gmap, GLsizei mapsize, const GLushort *values);
|
|
void ( * qglPixelStoref )(GLenum pname, GLfloat param);
|
|
void ( * qglPixelStorei )(GLenum pname, GLint param);
|
|
void ( * qglPixelTransferf )(GLenum pname, GLfloat param);
|
|
void ( * qglPixelTransferi )(GLenum pname, GLint param);
|
|
void ( * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
|
|
void ( * qglPointSize )(GLfloat size);
|
|
void ( * qglPolygonMode )(GLenum face, GLenum mode);
|
|
void ( * qglPolygonOffset )(GLfloat factor, GLfloat units);
|
|
void ( * qglPolygonStipple )(const GLubyte *mask);
|
|
void ( * qglPopAttrib )(void);
|
|
void ( * qglPopClientAttrib )(void);
|
|
void ( * qglPopMatrix )(void);
|
|
void ( * qglPopName )(void);
|
|
void ( * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
|
|
void ( * qglPushAttrib )(GLbitfield mask);
|
|
void ( * qglPushClientAttrib )(GLbitfield mask);
|
|
void ( * qglPushMatrix )(void);
|
|
void ( * qglPushName )(GLuint name);
|
|
void ( * qglRasterPos2d )(GLdouble x, GLdouble y);
|
|
void ( * qglRasterPos2dv )(const GLdouble *v);
|
|
void ( * qglRasterPos2f )(GLfloat x, GLfloat y);
|
|
void ( * qglRasterPos2fv )(const GLfloat *v);
|
|
void ( * qglRasterPos2i )(GLint x, GLint y);
|
|
void ( * qglRasterPos2iv )(const GLint *v);
|
|
void ( * qglRasterPos2s )(GLshort x, GLshort y);
|
|
void ( * qglRasterPos2sv )(const GLshort *v);
|
|
void ( * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
|
|
void ( * qglRasterPos3dv )(const GLdouble *v);
|
|
void ( * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
|
|
void ( * qglRasterPos3fv )(const GLfloat *v);
|
|
void ( * qglRasterPos3i )(GLint x, GLint y, GLint z);
|
|
void ( * qglRasterPos3iv )(const GLint *v);
|
|
void ( * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
|
|
void ( * qglRasterPos3sv )(const GLshort *v);
|
|
void ( * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
|
|
void ( * qglRasterPos4dv )(const GLdouble *v);
|
|
void ( * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
|
void ( * qglRasterPos4fv )(const GLfloat *v);
|
|
void ( * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
|
|
void ( * qglRasterPos4iv )(const GLint *v);
|
|
void ( * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
|
|
void ( * qglRasterPos4sv )(const GLshort *v);
|
|
void ( * qglReadBuffer )(GLenum mode);
|
|
//void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels);
|
|
void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
|
|
void ( * qglCopyBackBufferToTexEXT ) (float width, float height, float u1, float v1, float u2, float v2);
|
|
void ( * qglCopyBackBufferToTex ) (void);
|
|
void ( * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
|
|
void ( * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
|
|
void ( * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
|
|
void ( * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
|
|
void ( * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
|
|
void ( * qglRectiv )(const GLint *v1, const GLint *v2);
|
|
void ( * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
|
|
void ( * qglRectsv )(const GLshort *v1, const GLshort *v2);
|
|
GLint ( * qglRenderMode )(GLenum mode);
|
|
void ( * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
|
|
void ( * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
|
|
void ( * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
|
|
void ( * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
|
|
void ( * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
|
|
void ( * qglSelectBuffer )(GLsizei size, GLuint *buffer);
|
|
void ( * qglShadeModel )(GLenum mode);
|
|
void ( * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
|
|
void ( * qglStencilMask )(GLuint mask);
|
|
void ( * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
|
|
void ( * qglTexCoord1d )(GLdouble s);
|
|
void ( * qglTexCoord1dv )(const GLdouble *v);
|
|
void ( * qglTexCoord1f )(GLfloat s);
|
|
void ( * qglTexCoord1fv )(const GLfloat *v);
|
|
void ( * qglTexCoord1i )(GLint s);
|
|
void ( * qglTexCoord1iv )(const GLint *v);
|
|
void ( * qglTexCoord1s )(GLshort s);
|
|
void ( * qglTexCoord1sv )(const GLshort *v);
|
|
void ( * qglTexCoord2d )(GLdouble s, GLdouble t);
|
|
void ( * qglTexCoord2dv )(const GLdouble *v);
|
|
void ( * qglTexCoord2f )(GLfloat s, GLfloat t);
|
|
void ( * qglTexCoord2fv )(const GLfloat *v);
|
|
void ( * qglTexCoord2i )(GLint s, GLint t);
|
|
void ( * qglTexCoord2iv )(const GLint *v);
|
|
void ( * qglTexCoord2s )(GLshort s, GLshort t);
|
|
void ( * qglTexCoord2sv )(const GLshort *v);
|
|
void ( * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
|
|
void ( * qglTexCoord3dv )(const GLdouble *v);
|
|
void ( * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
|
|
void ( * qglTexCoord3fv )(const GLfloat *v);
|
|
void ( * qglTexCoord3i )(GLint s, GLint t, GLint r);
|
|
void ( * qglTexCoord3iv )(const GLint *v);
|
|
void ( * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
|
|
void ( * qglTexCoord3sv )(const GLshort *v);
|
|
void ( * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
|
|
void ( * qglTexCoord4dv )(const GLdouble *v);
|
|
void ( * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
|
|
void ( * qglTexCoord4fv )(const GLfloat *v);
|
|
void ( * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
|
|
void ( * qglTexCoord4iv )(const GLint *v);
|
|
void ( * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
|
|
void ( * qglTexCoord4sv )(const GLshort *v);
|
|
void ( * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
void ( * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
|
|
void ( * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
|
|
void ( * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
|
|
void ( * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
|
|
void ( * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
|
|
void ( * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
|
|
void ( * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
|
|
void ( * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
|
|
void ( * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
|
|
void ( * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
|
|
void ( * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
|
|
void ( * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
|
|
void ( * qglTexImage2DEXT )(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
|
|
void ( * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
|
|
void ( * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
|
|
void ( * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
|
|
void ( * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
|
|
void ( * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
|
|
void ( * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
|
|
void ( * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
|
|
void ( * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
|
|
void ( * qglVertex2d )(GLdouble x, GLdouble y);
|
|
void ( * qglVertex2dv )(const GLdouble *v);
|
|
void ( * qglVertex2f )(GLfloat x, GLfloat y);
|
|
void ( * qglVertex2fv )(const GLfloat *v);
|
|
void ( * qglVertex2i )(GLint x, GLint y);
|
|
void ( * qglVertex2iv )(const GLint *v);
|
|
void ( * qglVertex2s )(GLshort x, GLshort y);
|
|
void ( * qglVertex2sv )(const GLshort *v);
|
|
void ( * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
|
|
void ( * qglVertex3dv )(const GLdouble *v);
|
|
void ( * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
|
|
void ( * qglVertex3fv )(const GLfloat *v);
|
|
void ( * qglVertex3i )(GLint x, GLint y, GLint z);
|
|
void ( * qglVertex3iv )(const GLint *v);
|
|
void ( * qglVertex3s )(GLshort x, GLshort y, GLshort z);
|
|
void ( * qglVertex3sv )(const GLshort *v);
|
|
void ( * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
|
|
void ( * qglVertex4dv )(const GLdouble *v);
|
|
void ( * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
|
void ( * qglVertex4fv )(const GLfloat *v);
|
|
void ( * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
|
|
void ( * qglVertex4iv )(const GLint *v);
|
|
void ( * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
|
|
void ( * qglVertex4sv )(const GLshort *v);
|
|
void ( * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
void ( * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
|
|
|
|
#if 0
|
|
void ( * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
|
|
void ( * qglActiveTextureARB )( GLenum texture );
|
|
void ( * qglClientActiveTextureARB )( GLenum texture );
|
|
#endif
|
|
|
|
|
|
#ifdef _WINDOWS
|
|
static bool surfaceToBMP(LPDIRECT3DDEVICE8 pd3dDevice, LPDIRECT3DSURFACE8 lpSurface, const char *fname)
|
|
{
|
|
DWORD outpixel;
|
|
BITMAPFILEHEADER fh;
|
|
BITMAPINFOHEADER bi;
|
|
int outbyte, BufferIndex, width, height, pitch;
|
|
char *WriteBuffer;
|
|
FILE *file;
|
|
HRESULT Error;
|
|
IDirect3DSurface8 *pTempSurf = NULL;
|
|
|
|
// Get the surface description first
|
|
D3DSURFACE_DESC ddsd;
|
|
D3DLOCKED_RECT lrSurf;
|
|
|
|
Error = lpSurface->GetDesc(&ddsd);
|
|
// This writes out 32 bit values, so whatever surface format we were passed in,
|
|
// copy it into a 32 bit surface
|
|
Error = pd3dDevice->CreateImageSurface(ddsd.Width, ddsd.Height, D3DFMT_A8R8G8B8, &pTempSurf);
|
|
|
|
Error = D3DXLoadSurfaceFromSurface(pTempSurf, NULL, NULL, lpSurface, NULL, NULL, D3DX_DEFAULT, 0);
|
|
|
|
file = fopen(fname, "wb");
|
|
if(!file)
|
|
return FALSE;
|
|
|
|
Error = pTempSurf->LockRect(&lrSurf, NULL, 0);
|
|
|
|
BufferIndex = 0;
|
|
width = ddsd.Width;
|
|
height = ddsd.Height;
|
|
pitch = lrSurf.Pitch;
|
|
WriteBuffer = new char[width * height * 3];
|
|
|
|
// Setup the file headers
|
|
((char*)&(fh.bfType))[0] = 'B';
|
|
((char*)&(fh.bfType))[1] = 'M';
|
|
fh.bfSize = (long)(sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER) + width * height * 3);
|
|
fh.bfReserved1 = 0;
|
|
fh.bfReserved2 = 0;
|
|
fh.bfOffBits = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
|
|
bi.biSize = sizeof(BITMAPINFOHEADER);
|
|
bi.biWidth = width;
|
|
bi.biHeight = height;
|
|
bi.biPlanes = 1;
|
|
bi.biBitCount = 24;
|
|
bi.biCompression = BI_RGB;
|
|
bi.biSizeImage = 0;
|
|
bi.biXPelsPerMeter = 10000;
|
|
bi.biYPelsPerMeter = 10000;
|
|
bi.biClrUsed = 0;
|
|
bi.biClrImportant = 0;
|
|
|
|
fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, file);
|
|
fwrite(&bi, sizeof(BITMAPINFOHEADER), 1, file);
|
|
|
|
char *Bitmap_in = (char*)lrSurf.pBits;
|
|
|
|
for(int y = height - 1; y >= 0; y--)
|
|
{
|
|
for(int x = 0; x < width; x++)
|
|
{
|
|
outpixel = *((DWORD *)(Bitmap_in + x * 4 + y * pitch)); //Load a word
|
|
|
|
//Load up the Blue component and output it
|
|
outbyte = (((outpixel)&0x000000ff));//blue
|
|
WriteBuffer [BufferIndex++] = outbyte;
|
|
|
|
//Load up the green component and output it
|
|
outbyte = (((outpixel>>8)&0x000000ff));
|
|
WriteBuffer [BufferIndex++] = outbyte;
|
|
|
|
//Load up the red component and output it
|
|
outbyte = (((outpixel>>16)&0x000000ff));
|
|
WriteBuffer [BufferIndex++] = outbyte;
|
|
}
|
|
}
|
|
|
|
//At this point the buffer should be full, so just write it out
|
|
fwrite(WriteBuffer, BufferIndex, 1, file);
|
|
|
|
//Now unlock the surface and we're done
|
|
pTempSurf->UnlockRect();
|
|
pTempSurf->Release();
|
|
|
|
fclose(file);
|
|
|
|
delete [] WriteBuffer;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
=================
|
|
_fixupScreenCoords
|
|
|
|
Clamp coords to screen dimensions and fix Y direction.
|
|
=================
|
|
*/
|
|
static void _fixupScreenCoords(GLint& x, GLint& y, GLsizei& width, GLsizei& height)
|
|
{
|
|
if (x < 0) x = 0;
|
|
else if (x > glConfig.vidWidth) x = glConfig.vidWidth;
|
|
if (y < 0)
|
|
{
|
|
|
|
#ifdef _XBOX
|
|
height += y;
|
|
#endif
|
|
y = 0;
|
|
}
|
|
else if (y > glConfig.vidHeight) y = glConfig.vidHeight;
|
|
|
|
if (width < 0) width = 0;
|
|
#ifdef _XBOX
|
|
else if (x + width > glConfig.vidWidth) width = glConfig.vidWidth - x;
|
|
#endif
|
|
// else if (x + width > glConfig.vidWidth) width = glConfig.vidWidth - x;
|
|
if (height < 0) height = 0;
|
|
else if (y + height > glConfig.vidHeight) height = glConfig.vidHeight - y;
|
|
|
|
// GL and DX disagree on the direction of Y
|
|
y = glConfig.vidHeight - (y + height);
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_convertCompare
|
|
|
|
Convert GL compare function to DX function.
|
|
=================
|
|
*/
|
|
static D3DCMPFUNC _convertCompare(GLenum func)
|
|
{
|
|
switch (func)
|
|
{
|
|
case GL_NEVER: return D3DCMP_NEVER;
|
|
case GL_LESS: return D3DCMP_LESS;
|
|
case GL_EQUAL: return D3DCMP_EQUAL;
|
|
case GL_LEQUAL: return D3DCMP_LESSEQUAL;
|
|
case GL_GREATER: return D3DCMP_GREATER;
|
|
case GL_NOTEQUAL: return D3DCMP_NOTEQUAL;
|
|
case GL_GEQUAL: return D3DCMP_GREATEREQUAL;
|
|
default: case GL_ALWAYS: return D3DCMP_ALWAYS;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_convertBlendFactor
|
|
|
|
Convert GL blend mode to DX blend mode.
|
|
=================
|
|
*/
|
|
static D3DBLEND _convertBlendFactor(GLenum factor)
|
|
{
|
|
switch (factor)
|
|
{
|
|
case GL_ZERO: return D3DBLEND_ZERO;
|
|
default: case GL_ONE: return D3DBLEND_ONE;
|
|
case GL_SRC_COLOR: return D3DBLEND_SRCCOLOR;
|
|
case GL_ONE_MINUS_SRC_COLOR: return D3DBLEND_INVSRCCOLOR;
|
|
case GL_SRC_ALPHA: return D3DBLEND_SRCALPHA;
|
|
case GL_ONE_MINUS_SRC_ALPHA: return D3DBLEND_INVSRCALPHA;
|
|
case GL_DST_COLOR: return D3DBLEND_DESTCOLOR;
|
|
case GL_ONE_MINUS_DST_COLOR: return D3DBLEND_INVDESTCOLOR;
|
|
case GL_DST_ALPHA: return D3DBLEND_DESTALPHA;
|
|
case GL_ONE_MINUS_DST_ALPHA: return D3DBLEND_INVDESTALPHA;
|
|
case GL_SRC_ALPHA_SATURATE: return D3DBLEND_SRCALPHASAT;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_convertPrimMode
|
|
|
|
Convert GL primitive mode to DX primitive mode.
|
|
=================
|
|
*/
|
|
static D3DPRIMITIVETYPE _convertPrimMode(GLenum mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case GL_POINTS: return D3DPT_POINTLIST;
|
|
case GL_LINES: return D3DPT_LINELIST;
|
|
case GL_LINE_STRIP: return D3DPT_LINESTRIP;
|
|
case GL_TRIANGLES: return D3DPT_TRIANGLELIST;
|
|
case GL_TRIANGLE_STRIP: return D3DPT_TRIANGLESTRIP;
|
|
case GL_TRIANGLE_FAN: return D3DPT_TRIANGLEFAN;
|
|
#ifdef _XBOX
|
|
case GL_QUADS: return D3DPT_QUADLIST;
|
|
case GL_QUAD_STRIP: return D3DPT_QUADSTRIP;
|
|
#else
|
|
case GL_QUADS: return D3DPT_TRIANGLELIST;
|
|
case GL_QUAD_STRIP: return D3DPT_TRIANGLESTRIP;
|
|
#endif
|
|
case GL_POLYGON: return D3DPT_TRIANGLEFAN;
|
|
default: assert(0); return D3DPT_TRIANGLEFAN;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_updateDrawStride
|
|
|
|
Update the stride of the draw array based on
|
|
the number of vertex attributes. The stride
|
|
is in DWORDs.
|
|
=================
|
|
*/
|
|
static void _updateDrawStride(GLint normal, GLint tex0, GLint tex1)
|
|
{
|
|
glw_state->drawStride = 4;
|
|
if (normal) glw_state->drawStride += 3;
|
|
if (tex0) glw_state->drawStride += 2;
|
|
if (tex1) glw_state->drawStride += 2;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_updateShader
|
|
|
|
Set the vertex shader based on the number
|
|
of texture coordinates.
|
|
=================
|
|
*/
|
|
static void _updateShader(bool normal, bool tex0, bool tex1)//, bool tex2, bool tex3)
|
|
{
|
|
DWORD mask = D3DFVF_XYZ;
|
|
if (normal) mask |= D3DFVF_NORMAL;
|
|
mask |= D3DFVF_DIFFUSE;
|
|
if (tex0 && !tex1) mask |= D3DFVF_TEX1;
|
|
else if (tex1) mask |= D3DFVF_TEX2;
|
|
|
|
// if (mask != glw_state->shaderMask)
|
|
// {
|
|
glw_state->device->SetVertexShader(mask);
|
|
glw_state->shaderMask = mask;
|
|
// }
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_getCurrentTexture
|
|
|
|
Get the texture information for the currently
|
|
bound texture at a stage.
|
|
=================
|
|
*/
|
|
static glwstate_t::TextureInfo* _getCurrentTexture(int stage)
|
|
{
|
|
glwstate_t::texturexlat_t::iterator i = glw_state->textureXlat.find(
|
|
glw_state->currentTexture[stage]);
|
|
|
|
if (i == glw_state->textureXlat.end()) return NULL;
|
|
else return &i->second;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_updateTextures
|
|
|
|
Setup texture stages with color operations, filters
|
|
and wrapping modes as needed.
|
|
=================
|
|
*/
|
|
static void _updateTextures(void)
|
|
{
|
|
for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
|
|
{
|
|
if (glw_state->textureStageDirty[t])
|
|
{
|
|
glw_state->textureStageDirty[t] = false;
|
|
|
|
if (glw_state->textureStageEnable[t] && glw_state->currentTexture[t])
|
|
{
|
|
glwstate_t::TextureInfo* info = _getCurrentTexture(t);
|
|
if (!info) continue;
|
|
|
|
glw_state->device->SetTexture(t, info->mipmap);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_COLOROP, glw_state->textureEnv[t]);
|
|
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_COLORARG1,
|
|
D3DTA_TEXTURE);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_COLORARG2,
|
|
D3DTA_CURRENT);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAOP,
|
|
glw_state->textureEnv[t]);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAARG1,
|
|
D3DTA_TEXTURE);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAARG2,
|
|
D3DTA_CURRENT);
|
|
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_MAXANISOTROPY,
|
|
info->anisotropy);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_MINFILTER,
|
|
info->minFilter);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_MIPFILTER,
|
|
info->mipFilter);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_MAGFILTER,
|
|
info->magFilter);
|
|
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_ADDRESSU,
|
|
info->wrapU);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_ADDRESSV,
|
|
info->wrapV);
|
|
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t);
|
|
|
|
glw_state->device->SetTextureStageState( t, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
|
|
|
|
/*if(tess.shader)
|
|
{
|
|
if(tess.currentPass < tess.shader->numUnfoggedPasses)
|
|
{
|
|
if(tess.shader->stages[tess.currentPass].isEnvironment)
|
|
{
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
else
|
|
{
|
|
glw_state->device->SetTexture(t, NULL);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
|
glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
|
|
}
|
|
}
|
|
//else
|
|
//{
|
|
// // Hard-wired check for turning on hardware environment mapping
|
|
// if( glw_state->textureStageEnable[t] &&
|
|
// glw_state->currentTexture[t] &&
|
|
// tess.shader &&
|
|
// tess.currentPass < tess.shader->numUnfoggedPasses &&
|
|
// tess.shader->stages[tess.currentPass].isEnvironment)
|
|
// {
|
|
// glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_updateMatrices
|
|
|
|
Set the current projection and view transforms to
|
|
the matrices at the top of the relevant stacks.
|
|
=================
|
|
*/
|
|
static void _updateMatrices(void)
|
|
{
|
|
if(glw_state->matricesDirty[glwstate_t::MatrixMode_Projection])
|
|
{
|
|
glw_state->device->SetTransform(D3DTS_PROJECTION,
|
|
glw_state->matrixStack[glwstate_t::MatrixMode_Projection]->GetTop());
|
|
|
|
glw_state->matricesDirty[glwstate_t::MatrixMode_Projection] = false;
|
|
}
|
|
|
|
if(glw_state->matricesDirty[glwstate_t::MatrixMode_Model])
|
|
{
|
|
glw_state->device->SetTransform(D3DTS_VIEW,
|
|
glw_state->matrixStack[glwstate_t::MatrixMode_Model]->GetTop());
|
|
|
|
glw_state->matricesDirty[glwstate_t::MatrixMode_Model] = false;
|
|
}
|
|
|
|
if(glw_state->matricesDirty[glwstate_t::MatrixMode_Texture0])
|
|
{
|
|
glw_state->device->SetTransform(D3DTS_TEXTURE0,
|
|
glw_state->matrixStack[glwstate_t::MatrixMode_Texture0]->GetTop());
|
|
|
|
glw_state->matricesDirty[glwstate_t::MatrixMode_Texture0] = false;
|
|
}
|
|
|
|
if(glw_state->matricesDirty[glwstate_t::MatrixMode_Texture1])
|
|
{
|
|
glw_state->device->SetTransform(D3DTS_TEXTURE1,
|
|
glw_state->matrixStack[glwstate_t::MatrixMode_Texture1]->GetTop());
|
|
|
|
glw_state->matricesDirty[glwstate_t::MatrixMode_Texture1] = false;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_getMaxVerts
|
|
|
|
Calculate the maximum number of verts to draw
|
|
given a total number to draw, stride and max
|
|
packet size.
|
|
=================
|
|
*/
|
|
static int _getMaxVerts(void)
|
|
{
|
|
int max = glw_state->totalVertices;
|
|
if (max > GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride)
|
|
{
|
|
max = GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride;
|
|
}
|
|
return max;
|
|
}
|
|
|
|
static int _getMaxIndices(void)
|
|
{
|
|
int max = glw_state->totalIndices;
|
|
if(max > 1022)
|
|
max = 1022;
|
|
|
|
return max;
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
/*
|
|
=================
|
|
_restartDrawPacket
|
|
|
|
Encode a new draw packet header into the draw array.
|
|
=================
|
|
*/
|
|
inline static DWORD* _restartDrawPacket(DWORD* packet, int verts)
|
|
{
|
|
packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
|
|
packet[1] = glw_state->primitiveMode;
|
|
packet[2] = D3DPUSH_ENCODE(
|
|
D3DPUSH_NOINCREMENT_FLAG|D3DPUSH_INLINE_ARRAY,
|
|
glw_state->drawStride * verts);
|
|
return packet + 3;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
_terminateDrawPacket
|
|
|
|
Finish up the last draw packet.
|
|
=================
|
|
*/
|
|
inline static DWORD* _terminateDrawPacket(DWORD* packet)
|
|
{
|
|
packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
|
|
packet[1] = 0;
|
|
return packet + 2;
|
|
}
|
|
|
|
#define CMD_DRAW_INDEX_BATCH 0x1800
|
|
inline static DWORD* _restartIndexPacket(DWORD* packet, int numIndices)
|
|
{
|
|
packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
|
|
packet[1] = glw_state->primitiveMode;
|
|
packet[2] = D3DPUSH_ENCODE( D3DPUSH_NOINCREMENT_FLAG | CMD_DRAW_INDEX_BATCH, numIndices / 2 );
|
|
return packet + 3;
|
|
}
|
|
|
|
inline static DWORD* _terminateIndexPacket(DWORD* packet)
|
|
{
|
|
packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
|
|
packet[1] = 0;
|
|
return packet + 2;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
_handleDrawOverflow
|
|
|
|
Prevent a draw packet from getting too
|
|
big for the hardware by restarting it as needed.
|
|
=================
|
|
*/
|
|
static void _handleDrawOverflow(void)
|
|
{
|
|
if (glw_state->numVertices >= glw_state->maxVertices)
|
|
{
|
|
glw_state->drawArray += glw_state->numVertices *
|
|
glw_state->drawStride;
|
|
|
|
glw_state->totalVertices -= glw_state->numVertices;
|
|
glw_state->maxVertices = _getMaxVerts();
|
|
glw_state->numVertices = 0;
|
|
|
|
glw_state->drawArray = _restartDrawPacket(
|
|
glw_state->drawArray, glw_state->maxVertices);
|
|
}
|
|
}
|
|
#else _XBOX
|
|
inline static DWORD* _restartDrawPacket(DWORD* packet, int verts)
|
|
{
|
|
return packet;
|
|
}
|
|
|
|
inline static DWORD* _terminateDrawPacket(DWORD* packet)
|
|
{
|
|
return packet;
|
|
}
|
|
|
|
static void _handleDrawOverflow(void)
|
|
{
|
|
}
|
|
#endif _XBOX
|
|
|
|
|
|
/*
|
|
=================
|
|
_vertexElement
|
|
|
|
Copy position information from the source vertex
|
|
array into a draw array.
|
|
=================
|
|
*/
|
|
#define _vertexElement(push, i) \
|
|
{ \
|
|
DWORD* vert = (DWORD*)((BYTE*)glw_state->vertexPointer + \
|
|
(i) * glw_state->vertexStride); \
|
|
(push)[0] = vert[0]; \
|
|
(push)[1] = vert[1]; \
|
|
(push)[2] = vert[2]; \
|
|
}
|
|
|
|
/*
|
|
=================
|
|
_colorElement
|
|
|
|
Copy color information from the source color
|
|
array into a draw array.
|
|
=================
|
|
*/
|
|
#define _colorElement(push, i) \
|
|
{ \
|
|
DWORD col = *(DWORD*)((BYTE*)glw_state->colorPointer + \
|
|
(i) * glw_state->colorStride); \
|
|
(push)[0] = \
|
|
((col & 0xFF000000) >> 0) | \
|
|
((col & 0x00FF0000) >> 16) | \
|
|
((col & 0x0000FF00) << 0) | \
|
|
((col & 0x000000FF) << 16); \
|
|
}
|
|
|
|
/*
|
|
=================
|
|
_texCoordElement
|
|
|
|
Copy tex coord information from the source tex coord
|
|
array into a draw array.
|
|
=================
|
|
*/
|
|
#define _texCoordElement(push, i, t) \
|
|
{ \
|
|
DWORD* tc = (DWORD*)((BYTE*)glw_state->texCoordPointer[t] + \
|
|
(i) * glw_state->texCoordStride[t]); \
|
|
(push)[0] = tc[0]; \
|
|
(push)[1] = tc[1]; \
|
|
}
|
|
|
|
/*
|
|
=================
|
|
_normalElement
|
|
|
|
Copy normal information from the source normal
|
|
array into a draw array
|
|
=================
|
|
*/
|
|
#define _normalElement(push, i) \
|
|
{ \
|
|
DWORD* norm = (DWORD*)((BYTE*)glw_state->normalPointer + \
|
|
(i) * glw_state->normalStride); \
|
|
(push)[0] = norm[0]; \
|
|
(push)[1] = norm[1]; \
|
|
(push)[2] = norm[2]; \
|
|
}
|
|
|
|
|
|
#define _tangentElement(push, i) \
|
|
{ \
|
|
DWORD* tang = (DWORD*)((BYTE*)&tess.tangent[i]); \
|
|
(push)[0] = tang[0]; \
|
|
(push)[1] = tang[1]; \
|
|
(push)[2] = tang[2]; \
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=========================================================
|
|
FAST INDEXED GEOMETRY DRAW LOOPS
|
|
|
|
Used by core draw routines to quickly copy
|
|
geometry from various source arrays to main
|
|
draw array.
|
|
=========================================================
|
|
*/
|
|
static void _drawElementsV(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
push[3] = glw_state->currentColor;
|
|
push += 4;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVN(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
push[6] = glw_state->currentColor;
|
|
push += 7;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVC(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_colorElement(&push[3], indices[i]);
|
|
push += 4;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVCN(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
_colorElement(&push[6], indices[i]);
|
|
push += 7;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVCT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_colorElement(&push[3], indices[i]);
|
|
_texCoordElement(&push[4], indices[i], 0);
|
|
push += 6;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVCNT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
_colorElement(&push[6], indices[i]);
|
|
_texCoordElement(&push[7], indices[i], 0);
|
|
push += 9;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVCTT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_colorElement(&push[3], indices[i]);
|
|
_texCoordElement(&push[4], indices[i], 0);
|
|
_texCoordElement(&push[6], indices[i], 1);
|
|
push += 8;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVCNTT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
_colorElement(&push[6], indices[i]);
|
|
_texCoordElement(&push[7], indices[i], 0);
|
|
_texCoordElement(&push[9], indices[i], 1);
|
|
push += 11;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
push[3] = glw_state->currentColor;
|
|
_texCoordElement(&push[4], indices[i], 0);
|
|
push += 6;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVNT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
push[6] = glw_state->currentColor;
|
|
_texCoordElement(&push[7], indices[i], 0);
|
|
push += 9;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVTT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
push[3] = glw_state->currentColor;
|
|
_texCoordElement(&push[4], indices[i], 0);
|
|
_texCoordElement(&push[6], indices[i], 1);
|
|
push += 8;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsVNTT(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
push[6] = glw_state->currentColor;
|
|
_texCoordElement(&push[7], indices[i], 0);
|
|
_texCoordElement(&push[9], indices[i], 1);
|
|
push += 11;
|
|
}
|
|
}
|
|
|
|
|
|
static void _drawElementsLightShader(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
_texCoordElement(&push[6], indices[i], 0);
|
|
_tangentElement(&push[8], indices[i]);
|
|
push += 11;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsBumpShader(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
_texCoordElement(&push[6], indices[i], 0);
|
|
_texCoordElement(&push[8], indices[i], 1);
|
|
_tangentElement(&push[10], indices[i]);
|
|
push += 13;
|
|
}
|
|
}
|
|
|
|
static void _drawElementsEnvShader(GLsizei count, const GLushort* indices)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
_vertexElement(&push[0], indices[i]);
|
|
_normalElement(&push[3], indices[i]);
|
|
push += 6;
|
|
}
|
|
}
|
|
|
|
typedef void(*drawelemfunc_t)(GLsizei, const GLushort*);
|
|
static drawelemfunc_t _drawElementFuncTable[12] =
|
|
{
|
|
_drawElementsV,
|
|
_drawElementsVN,
|
|
_drawElementsVT,
|
|
_drawElementsVNT,
|
|
_drawElementsVTT,
|
|
_drawElementsVNTT,
|
|
_drawElementsVC,
|
|
_drawElementsVCN,
|
|
_drawElementsVCT,
|
|
_drawElementsVCNT,
|
|
_drawElementsVCTT,
|
|
_drawElementsVCNTT,
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
=========================================================
|
|
FAST GEOMETRY DRAW LOOPS
|
|
|
|
Used by core draw routines to quickly copy
|
|
geometry from various source arrays to main
|
|
draw array.
|
|
=========================================================
|
|
*/
|
|
static void _drawArraysV(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
push[3] = glw_state->currentColor;
|
|
push += 4;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVN(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_normalElement(&push[3], i);
|
|
push[6] = glw_state->currentColor;
|
|
push += 7;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVC(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_colorElement(&push[3], i);
|
|
push += 4;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVCN(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_normalElement(&push[3], i);
|
|
_colorElement(&push[6], i);
|
|
push += 7;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVCT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_colorElement(&push[3], i);
|
|
_texCoordElement(&push[4], i, 0);
|
|
push += 6;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVCNT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_normalElement(&push[3], i);
|
|
_colorElement(&push[6], i);
|
|
_texCoordElement(&push[7], i, 0);
|
|
push += 9;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVCTT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_colorElement(&push[3], i);
|
|
_texCoordElement(&push[4], i, 0);
|
|
_texCoordElement(&push[6], i, 1);
|
|
push += 8;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVCNTT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_normalElement(&push[3], i);
|
|
_colorElement(&push[6], i);
|
|
_texCoordElement(&push[7], i, 0);
|
|
_texCoordElement(&push[9], i, 1);
|
|
push += 11;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
push[3] = glw_state->currentColor;
|
|
_texCoordElement(&push[4], i, 0);
|
|
push += 6;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVNT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_normalElement(&push[3], i);
|
|
push[6] = glw_state->currentColor;
|
|
_texCoordElement(&push[7], i, 0);
|
|
push += 9;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVTT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
push[3] = glw_state->currentColor;
|
|
_texCoordElement(&push[4], i, 0);
|
|
_texCoordElement(&push[6], i, 1);
|
|
push += 8;
|
|
}
|
|
}
|
|
|
|
static void _drawArraysVNTT(GLsizei first, GLsizei last)
|
|
{
|
|
DWORD* push = glw_state->drawArray;
|
|
for (int i = first; i < last; ++i)
|
|
{
|
|
_vertexElement(&push[0], i);
|
|
_normalElement(&push[3], i);
|
|
push[6] = glw_state->currentColor;
|
|
_texCoordElement(&push[7], i, 0);
|
|
_texCoordElement(&push[9], i, 1);
|
|
push += 11;
|
|
}
|
|
}
|
|
|
|
typedef void(*drawarrayfunc_t)(GLsizei, GLsizei);
|
|
static drawarrayfunc_t _drawArrayFuncTable[12] =
|
|
{
|
|
_drawArraysV,
|
|
_drawArraysVN,
|
|
_drawArraysVT,
|
|
_drawArraysVNT,
|
|
_drawArraysVTT,
|
|
_drawArraysVNTT,
|
|
_drawArraysVC,
|
|
_drawArraysVCN,
|
|
_drawArraysVCT,
|
|
_drawArraysVCNT,
|
|
_drawArraysVCTT,
|
|
_drawArraysVCNTT,
|
|
};
|
|
|
|
|
|
/*
|
|
=================
|
|
_getDrawFunc
|
|
|
|
Figure which drawing function we need based on
|
|
what vertex components we have. Use the returned
|
|
integer to index the draw function tables.
|
|
=================
|
|
*/
|
|
static int _getDrawFunc(void)
|
|
{
|
|
int func = 0;
|
|
if (glw_state->colorArrayState) func += 6;
|
|
if (glw_state->texCoordArrayState[0]) func += 2;
|
|
if (glw_state->texCoordArrayState[1]) func += 2;
|
|
if (glw_state->normalArrayState) ++func;
|
|
return func;
|
|
}
|
|
|
|
|
|
static void dllAccum(GLenum op, GLfloat value)
|
|
{
|
|
assert(false);
|
|
}
|
|
|
|
static void dllAlphaFunc(GLenum func, GLclampf ref)
|
|
{
|
|
D3DCMPFUNC f = _convertCompare(func);
|
|
glw_state->device->SetRenderState(D3DRS_ALPHAFUNC, f);
|
|
glw_state->device->SetRenderState(D3DRS_ALPHAREF, (DWORD)(ref * 255.));
|
|
}
|
|
|
|
GLboolean dllAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
|
|
{
|
|
assert(false);
|
|
return 1;
|
|
}
|
|
|
|
static void dllArrayElement(GLint i)
|
|
{
|
|
assert(glw_state->inDrawBlock);
|
|
|
|
_handleDrawOverflow();
|
|
|
|
DWORD* push = &glw_state->drawArray[glw_state->numVertices *
|
|
glw_state->drawStride];
|
|
|
|
_vertexElement(push, i);
|
|
push += 3;
|
|
|
|
if (glw_state->colorArrayState)
|
|
{
|
|
_colorElement(push, i);
|
|
++push;
|
|
}
|
|
else
|
|
{
|
|
*push++ = glw_state->currentColor;
|
|
}
|
|
|
|
for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
|
|
{
|
|
if (glw_state->texCoordArrayState[t])
|
|
{
|
|
_texCoordElement(push, i, t);
|
|
push += 2;
|
|
}
|
|
}
|
|
|
|
++glw_state->numVertices;
|
|
}
|
|
|
|
// EXTENSION: Begin a drawing block with at verts vertices
|
|
static void dllBeginEXT(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1)//, GLint tex2, GLint tex3)
|
|
{
|
|
assert(!glw_state->inDrawBlock);
|
|
|
|
// start the draw block
|
|
glw_state->inDrawBlock = true;
|
|
glw_state->primitiveMode = _convertPrimMode(mode);
|
|
|
|
// update DX with any pending state changes
|
|
_updateDrawStride(normals, tex0, tex1);//, tex2, tex3);
|
|
_updateShader(normals, tex0, tex1);//, tex2, tex3);
|
|
_updateTextures();
|
|
_updateMatrices();
|
|
|
|
// set vertex counters
|
|
glw_state->numVertices = 0;
|
|
glw_state->totalVertices = verts;
|
|
glw_state->maxVertices = _getMaxVerts();
|
|
|
|
#ifdef _XBOX
|
|
// open a draw packet
|
|
//int num_packets = ((verts * glw_state->drawStride) / GLW_MAX_DRAW_PACKET_SIZE) + 1;
|
|
int num_packets;
|
|
if(glw_state->maxVertices == 0) {
|
|
num_packets = 1;
|
|
} else {
|
|
num_packets = (verts / glw_state->maxVertices) + (!!(verts % glw_state->maxVertices));
|
|
}
|
|
int cmd_size = num_packets * 3;
|
|
int vert_size = glw_state->drawStride * verts;
|
|
|
|
glw_state->device->BeginPush(vert_size + cmd_size + 2,
|
|
&glw_state->drawArray);
|
|
|
|
glw_state->drawArray = _restartDrawPacket(
|
|
glw_state->drawArray, glw_state->maxVertices);
|
|
#endif
|
|
}
|
|
|
|
static void dllBegin(GLenum mode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
// EXTENSION: Start a new drawing frame
|
|
GLboolean dllBeginFrame(void)
|
|
{
|
|
GLboolean result = glw_state->device->BeginScene() == D3D_OK;
|
|
return result;
|
|
}
|
|
|
|
// EXTENSION: Begin shadow draw mode
|
|
static void dllBeginShadow(void)
|
|
{
|
|
//Intentionally left blank
|
|
}
|
|
|
|
static void dllBindTexture(GLenum target, GLuint texture)
|
|
{
|
|
assert(target == GL_TEXTURE_2D);
|
|
|
|
if (glw_state->currentTexture[glw_state->serverTU] != texture)
|
|
{
|
|
glw_state->currentTexture[glw_state->serverTU] = texture;
|
|
glw_state->textureStageDirty[glw_state->serverTU] = true;
|
|
}
|
|
}
|
|
|
|
static void dllBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
|
|
{
|
|
assert(false);
|
|
}
|
|
|
|
static void dllBlendFunc(GLenum sfactor, GLenum dfactor)
|
|
{
|
|
D3DBLEND s = _convertBlendFactor(sfactor);
|
|
D3DBLEND d = _convertBlendFactor(dfactor);
|
|
|
|
glw_state->device->SetRenderState(D3DRS_SRCBLEND, s);
|
|
glw_state->device->SetRenderState(D3DRS_DESTBLEND, d);
|
|
}
|
|
|
|
static void dllCallList(GLuint lnum)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllCallLists(GLsizei n, GLenum type, const GLvoid *lists)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllClear(GLbitfield mask)
|
|
{
|
|
DWORD m = 0;
|
|
|
|
if (mask & GL_COLOR_BUFFER_BIT) m |= D3DCLEAR_TARGET;
|
|
if (mask & GL_STENCIL_BUFFER_BIT) m |= D3DCLEAR_STENCIL;
|
|
|
|
#ifdef _XBOX
|
|
// Clearing stencil when clearing depth buffer
|
|
// is faster on Xbox than just clearing depth alone.
|
|
if (mask & GL_DEPTH_BUFFER_BIT) m |= D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL;
|
|
#else
|
|
if (mask & GL_DEPTH_BUFFER_BIT) m |= D3DCLEAR_ZBUFFER;
|
|
#endif
|
|
|
|
glw_state->device->Clear(0, NULL, m, glw_state->clearColor,
|
|
glw_state->clearDepth, glw_state->clearStencil);
|
|
}
|
|
|
|
static void dllClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
|
|
{
|
|
glw_state->clearColor = D3DCOLOR_COLORVALUE(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllClearDepth(GLclampd depth)
|
|
{
|
|
glw_state->clearDepth = depth;
|
|
}
|
|
|
|
static void dllClearIndex(GLfloat c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllClearStencil(GLint s)
|
|
{
|
|
glw_state->clearStencil = s;
|
|
}
|
|
|
|
static void dllClipPlane(GLenum plane, const GLdouble *equation)
|
|
{
|
|
//FIXME
|
|
}
|
|
|
|
static void setIntColor(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
|
|
{
|
|
glw_state->currentColor = D3DCOLOR_RGBA(red, green, blue, alpha);
|
|
}
|
|
|
|
static void setFloatColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
glw_state->currentColor = D3DCOLOR_COLORVALUE(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor3b(GLbyte red, GLbyte green, GLbyte blue)
|
|
{
|
|
setIntColor(red, green, blue, 127);
|
|
}
|
|
|
|
static void dllColor3bv(const GLbyte *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], 127);
|
|
}
|
|
|
|
static void dllColor3d(GLdouble red, GLdouble green, GLdouble blue)
|
|
{
|
|
setFloatColor(red, green, blue, 1.f);
|
|
}
|
|
|
|
static void dllColor3dv(const GLdouble *v)
|
|
{
|
|
setFloatColor(v[0], v[1], v[2], 1.f);
|
|
}
|
|
|
|
static void dllColor3f(GLfloat red, GLfloat green, GLfloat blue)
|
|
{
|
|
setFloatColor(red, green, blue, 1.f);
|
|
}
|
|
|
|
static void dllColor3fv(const GLfloat *v)
|
|
{
|
|
setFloatColor(v[0], v[1], v[2], 1.f);
|
|
}
|
|
|
|
static void dllColor3i(GLint red, GLint green, GLint blue)
|
|
{
|
|
setIntColor(red, green, blue, 127);
|
|
}
|
|
|
|
static void dllColor3iv(const GLint *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], 127);
|
|
}
|
|
|
|
static void dllColor3s(GLshort red, GLshort green, GLshort blue)
|
|
{
|
|
setIntColor(red, green, blue, 127);
|
|
}
|
|
|
|
static void dllColor3sv(const GLshort *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], 127);
|
|
}
|
|
|
|
static void dllColor3ub(GLubyte red, GLubyte green, GLubyte blue)
|
|
{
|
|
setIntColor(red, green, blue, 127);
|
|
}
|
|
|
|
static void dllColor3ubv(const GLubyte *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], 127);
|
|
}
|
|
|
|
static void dllColor3ui(GLuint red, GLuint green, GLuint blue)
|
|
{
|
|
setIntColor(red, green, blue, 127);
|
|
}
|
|
|
|
static void dllColor3uiv(const GLuint *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], 127);
|
|
}
|
|
|
|
static void dllColor3us(GLushort red, GLushort green, GLushort blue)
|
|
{
|
|
setIntColor(red, green, blue, 127);
|
|
}
|
|
|
|
static void dllColor3usv(const GLushort *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], 127);
|
|
}
|
|
|
|
static void dllColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
|
|
{
|
|
setIntColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4bv(const GLbyte *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
|
|
{
|
|
setFloatColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4dv(const GLdouble *v)
|
|
{
|
|
setFloatColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
setFloatColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4fv(const GLfloat *v)
|
|
{
|
|
setFloatColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4i(GLint red, GLint green, GLint blue, GLint alpha)
|
|
{
|
|
setIntColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4iv(const GLint *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
|
|
{
|
|
setIntColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4sv(const GLshort *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
|
|
{
|
|
setIntColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4ubv(const GLubyte *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
|
|
{
|
|
setIntColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4uiv(const GLuint *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
|
|
{
|
|
setIntColor(red, green, blue, alpha);
|
|
}
|
|
|
|
static void dllColor4usv(const GLushort *v)
|
|
{
|
|
setIntColor(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
static void dllColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
|
|
{
|
|
DWORD m = 0;
|
|
if (red) m |= D3DCOLORWRITEENABLE_RED;
|
|
if (green) m |= D3DCOLORWRITEENABLE_GREEN;
|
|
if (blue) m |= D3DCOLORWRITEENABLE_BLUE;
|
|
if (alpha) m |= D3DCOLORWRITEENABLE_ALPHA;
|
|
glw_state->device->SetRenderState(D3DRS_COLORWRITEENABLE, m);
|
|
}
|
|
|
|
static void dllColorMaterial(GLenum face, GLenum mode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(!glw_state->inDrawBlock);
|
|
assert(size == 4 && type == GL_UNSIGNED_BYTE);
|
|
|
|
stride = (stride == 0) ? sizeof(GLint) : stride;
|
|
|
|
glw_state->colorPointer = pointer;
|
|
glw_state->colorStride = stride;
|
|
}
|
|
|
|
static void dllCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
/**********
|
|
copies a portion of the backbuffer to the current texture.
|
|
the current texture must be a linear format texture, if
|
|
a swizzled texture format is needed, use
|
|
dllCopyBackBufferToTexEXT
|
|
**********/
|
|
static void dllCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
|
|
{
|
|
// check to make sure everything passed in is supported
|
|
assert((target == GL_TEXTURE_2D) && (level == 0) && (border == 0));
|
|
|
|
// locals
|
|
RECT rSrc;
|
|
POINT ptUpperLeft;
|
|
LPDIRECT3DSURFACE8 tSurf;
|
|
LPDIRECT3DSURFACE8 backbuffer;
|
|
glwstate_t::TextureInfo* tex;
|
|
HRESULT res;
|
|
|
|
// get the current texture
|
|
tex = _getCurrentTexture(glw_state->serverTU);
|
|
if (tex == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// set up the source rectangle
|
|
rSrc.left = x;
|
|
rSrc.right = x + width;
|
|
rSrc.top = (480 - y) - height;
|
|
rSrc.bottom = (480 - y);
|
|
|
|
// set up the target point
|
|
ptUpperLeft.x = 0;
|
|
ptUpperLeft.y = 0;
|
|
|
|
// attach the current texture to a surface
|
|
tex->mipmap->GetSurfaceLevel(0, &tSurf);
|
|
|
|
// attach the back buffer to a surface
|
|
res = glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
|
|
|
|
// copy the data
|
|
res = glw_state->device->CopyRects(backbuffer, &rSrc, 0, tSurf, &ptUpperLeft);
|
|
|
|
// release surfaces
|
|
tSurf->Release();
|
|
backbuffer->Release();
|
|
}
|
|
|
|
static void dllCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllCullFace(GLenum mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
default: case GL_BACK: glw_state->cullMode = D3DCULL_CW; break;
|
|
case GL_FRONT: glw_state->cullMode = D3DCULL_CCW; break;
|
|
}
|
|
|
|
glw_state->device->SetRenderState(D3DRS_CULLMODE, glw_state->cullMode);
|
|
}
|
|
|
|
static void dllDeleteLists(GLuint lnum, GLsizei range)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllDeleteTextures(GLsizei n, const GLuint *textures)
|
|
{
|
|
for (int t = 0; t < n; ++t)
|
|
{
|
|
glwstate_t::texturexlat_t::iterator i =
|
|
glw_state->textureXlat.find(textures[t]);
|
|
|
|
if (i != glw_state->textureXlat.end())
|
|
{
|
|
#if MEMORY_PROFILE
|
|
texMemSize -= getTexMemSize(i->second.mipmap);
|
|
#endif
|
|
i->second.mipmap->Release();
|
|
glw_state->textureXlat.erase(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void dllDepthFunc(GLenum func)
|
|
{
|
|
D3DCMPFUNC f = _convertCompare(func);
|
|
glw_state->device->SetRenderState(D3DRS_ZFUNC, f);
|
|
}
|
|
|
|
static void dllDepthMask(GLboolean flag)
|
|
{
|
|
glw_state->device->SetRenderState(D3DRS_ZWRITEENABLE, flag);
|
|
}
|
|
|
|
static void dllDepthRange(GLclampd zNear, GLclampd zFar)
|
|
{
|
|
glw_state->viewport.MinZ = zNear;
|
|
glw_state->viewport.MaxZ = zFar;
|
|
glw_state->device->SetViewport(&glw_state->viewport);
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
static void setPresent(bool vsync)
|
|
{
|
|
//extern void ShowOSMemory();
|
|
//ShowOSMemory();
|
|
|
|
D3DPRESENT_PARAMETERS pp;
|
|
pp.BackBufferWidth = glConfig.vidWidth;
|
|
pp.BackBufferHeight = glConfig.vidHeight;
|
|
pp.BackBufferFormat = D3DFMT_X8R8G8B8;
|
|
pp.BackBufferCount = 1;
|
|
pp.MultiSampleType = D3DMULTISAMPLE_NONE; //D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_LINEAR;
|
|
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
|
|
pp.hDeviceWindow = 0;
|
|
pp.Windowed = FALSE;
|
|
pp.EnableAutoDepthStencil = TRUE;
|
|
pp.AutoDepthStencilFormat = D3DFMT_D24S8;
|
|
pp.Flags = 0;
|
|
pp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
|
|
pp.FullScreen_PresentationInterval =
|
|
vsync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE;
|
|
pp.BufferSurfaces[0] = pp.BufferSurfaces[1] = pp.BufferSurfaces[2] = 0;
|
|
pp.DepthStencilSurface = 0;
|
|
glw_state->device->PersistDisplay();
|
|
glw_state->device->Reset(&pp);
|
|
|
|
//ShowOSMemory();
|
|
}
|
|
#endif
|
|
|
|
static void setCap(GLenum cap, bool flag)
|
|
{
|
|
switch (cap)
|
|
{
|
|
case GL_ALPHA_TEST: glw_state->device->SetRenderState(D3DRS_ALPHATESTENABLE, flag); break;
|
|
case GL_BLEND: glw_state->device->SetRenderState(D3DRS_ALPHABLENDENABLE, flag); break;
|
|
case GL_CULL_FACE:
|
|
glw_state->cullEnable = flag;
|
|
glw_state->device->SetRenderState(D3DRS_CULLMODE,
|
|
flag ? glw_state->cullMode : D3DCULL_NONE);
|
|
break;
|
|
case GL_DEPTH_TEST: glw_state->device->SetRenderState(D3DRS_ZENABLE, flag); break;
|
|
case GL_LIGHTING: glw_state->device->SetRenderState(D3DRS_LIGHTING, flag); break;
|
|
#ifdef _XBOX
|
|
case GL_POLYGON_OFFSET_POINT:
|
|
glw_state->device->SetRenderState(D3DRS_POINTOFFSETENABLE, flag);
|
|
break;
|
|
case GL_POLYGON_OFFSET_LINE:
|
|
glw_state->device->SetRenderState(D3DRS_WIREFRAMEOFFSETENABLE, flag);
|
|
break;
|
|
case GL_POLYGON_OFFSET_FILL:
|
|
glw_state->device->SetRenderState(D3DRS_SOLIDOFFSETENABLE, flag);
|
|
break;
|
|
case GL_SCISSOR_TEST:
|
|
glw_state->scissorEnable = flag;
|
|
glw_state->device->SetScissors(flag ? 1 : 0, FALSE, &glw_state->scissorBox);
|
|
break;
|
|
#endif
|
|
case GL_STENCIL_TEST: glw_state->device->SetRenderState(D3DRS_STENCILENABLE, flag); break;
|
|
case GL_TEXTURE_2D:
|
|
glw_state->textureStageEnable[glw_state->serverTU] = flag;
|
|
glw_state->textureStageDirty[glw_state->serverTU] = true;
|
|
break;
|
|
case GL_FOG:
|
|
glw_state->device->SetRenderState(D3DRS_FOGENABLE, flag);
|
|
break;
|
|
#ifdef _XBOX
|
|
case GL_VSYNC:
|
|
setPresent(flag);
|
|
break;
|
|
#endif
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
static void dllDisable(GLenum cap)
|
|
{
|
|
setCap(cap, false);
|
|
}
|
|
|
|
static void setArrayState(GLenum cap, bool state)
|
|
{
|
|
switch (cap)
|
|
{
|
|
case GL_COLOR_ARRAY: glw_state->colorArrayState = state; break;
|
|
case GL_TEXTURE_COORD_ARRAY: glw_state->texCoordArrayState[glw_state->clientTU] = state; break;
|
|
case GL_VERTEX_ARRAY: glw_state->vertexArrayState = state; break;
|
|
case GL_NORMAL_ARRAY: glw_state->normalArrayState = state; break;
|
|
}
|
|
}
|
|
|
|
static void dllDisableClientState(GLenum array)
|
|
{
|
|
assert(!glw_state->inDrawBlock);
|
|
setArrayState(array, false);
|
|
}
|
|
|
|
#ifdef _WINDOWS
|
|
static void _convertQuadsToTris(GLint first, GLsizei count)
|
|
{
|
|
glw_state->vertexPointerBack = glw_state->vertexPointer;
|
|
glw_state->normalPointerBack = glw_state->normalPointer;
|
|
glw_state->colorPointerBack = glw_state->colorPointer;
|
|
glw_state->texCoordPointerBack[0] = glw_state->texCoordPointer[0];
|
|
glw_state->texCoordPointerBack[1] = glw_state->texCoordPointer[1];
|
|
|
|
{
|
|
glw_state->vertexPointer =
|
|
Z_Malloc(count * glw_state->vertexStride * 3 / 2,
|
|
TAG_TEMP_WORKSPACE, qfalse);
|
|
for (int i = 0; i < count; i += 4)
|
|
{
|
|
int stride = glw_state->vertexStride / sizeof(float);
|
|
float* dst = (float*)glw_state->vertexPointer + (i * 3 / 2) * stride;
|
|
const float* src = (const float*)glw_state->vertexPointerBack +
|
|
(first + i) * stride;
|
|
|
|
for (int j = 0; j < 3; ++j)
|
|
{
|
|
dst[0 * stride + j] = src[0 * stride + j];
|
|
dst[1 * stride + j] = src[1 * stride + j];
|
|
dst[2 * stride + j] = src[2 * stride + j];
|
|
dst[3 * stride + j] = src[0 * stride + j];
|
|
dst[4 * stride + j] = src[2 * stride + j];
|
|
dst[5 * stride + j] = src[3 * stride + j];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (glw_state->normalArrayState)
|
|
{
|
|
glw_state->normalPointer =
|
|
Z_Malloc(count * glw_state->normalStride * 3 / 2,
|
|
TAG_TEMP_WORKSPACE, qfalse);
|
|
|
|
for (int i = 0; i < count; i += 4)
|
|
{
|
|
int stride = glw_state->normalStride / sizeof(float);
|
|
float* dst = (float*)glw_state->normalPointer + (i * 3 / 2) * stride;
|
|
const float* src = (const float*)glw_state->normalPointerBack +
|
|
(first + i) * stride;
|
|
|
|
for (int j = 0; j < 3; ++j)
|
|
{
|
|
dst[0 * stride + j] = src[0 * stride + j];
|
|
dst[1 * stride + j] = src[1 * stride + j];
|
|
dst[2 * stride + j] = src[2 * stride + j];
|
|
dst[3 * stride + j] = src[0 * stride + j];
|
|
dst[4 * stride + j] = src[2 * stride + j];
|
|
dst[5 * stride + j] = src[3 * stride + j];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (glw_state->colorArrayState)
|
|
{
|
|
glw_state->colorPointer =
|
|
Z_Malloc(count * glw_state->colorStride * 3 / 2,
|
|
TAG_TEMP_WORKSPACE, qfalse);
|
|
|
|
for (int i = 0; i < count; i += 4)
|
|
{
|
|
int stride = glw_state->colorStride / sizeof(DWORD);
|
|
DWORD* dst = (DWORD*)glw_state->colorPointer + (i * 3 / 2) * stride;
|
|
const DWORD* src = (const DWORD*)glw_state->colorPointerBack +
|
|
(first + i) * stride;
|
|
|
|
dst[0 * stride] = src[0 * stride];
|
|
dst[1 * stride] = src[1 * stride];
|
|
dst[2 * stride] = src[2 * stride];
|
|
dst[3 * stride] = src[0 * stride];
|
|
dst[4 * stride] = src[2 * stride];
|
|
dst[5 * stride] = src[3 * stride];
|
|
}
|
|
}
|
|
|
|
for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
|
|
{
|
|
if (glw_state->texCoordArrayState[t])
|
|
{
|
|
glw_state->texCoordPointer[t] =
|
|
Z_Malloc(count * glw_state->texCoordStride[t] * 3 / 2,
|
|
TAG_TEMP_WORKSPACE, qfalse);
|
|
|
|
for (int i = 0; i < count; i += 4)
|
|
{
|
|
int stride = glw_state->texCoordStride[t] / sizeof(float);
|
|
float* dst = (float*)glw_state->texCoordPointer[t] + (i * 3 / 2) * stride;
|
|
const float* src = (const float*)glw_state->texCoordPointerBack[t] +
|
|
(first + i) * stride;
|
|
|
|
for (int j = 0; j < 2; ++j)
|
|
{
|
|
dst[0 * stride + j] = src[0 * stride + j];
|
|
dst[1 * stride + j] = src[1 * stride + j];
|
|
dst[2 * stride + j] = src[2 * stride + j];
|
|
dst[3 * stride + j] = src[0 * stride + j];
|
|
dst[4 * stride + j] = src[2 * stride + j];
|
|
dst[5 * stride + j] = src[3 * stride + j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void _cleanupQuadsToTris(void)
|
|
{
|
|
Z_Free(const_cast<void*>(glw_state->vertexPointer));
|
|
glw_state->vertexPointer = glw_state->vertexPointerBack;
|
|
|
|
if (glw_state->normalArrayState)
|
|
{
|
|
Z_Free(const_cast<void*>(glw_state->normalPointer));
|
|
glw_state->normalPointer = glw_state->normalPointerBack;
|
|
}
|
|
|
|
if (glw_state->colorArrayState)
|
|
{
|
|
Z_Free(const_cast<void*>(glw_state->colorPointer));
|
|
glw_state->colorPointer = glw_state->colorPointerBack;
|
|
}
|
|
|
|
for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
|
|
{
|
|
if (glw_state->texCoordArrayState[t])
|
|
{
|
|
Z_Free(const_cast<void*>(glw_state->texCoordPointer[t]));
|
|
glw_state->texCoordPointer[t] = glw_state->texCoordPointerBack[t];
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// NOTE: This is a core draw routine. It should be fast.
|
|
static void dllDrawArrays(GLenum mode, GLint first, GLsizei count)
|
|
{
|
|
#ifdef _WINDOWS
|
|
if (mode == GL_QUADS)
|
|
{
|
|
_convertQuadsToTris(first, count);
|
|
count = count * 3 / 2;
|
|
first = 0;
|
|
}
|
|
#endif
|
|
|
|
// start the draw mode
|
|
qglBeginEXT(mode, count, glw_state->colorArrayState ? count : 0,
|
|
glw_state->normalArrayState ? count : 0,
|
|
glw_state->texCoordArrayState[0] ? count : 0,
|
|
glw_state->texCoordArrayState[1] ? count : 0);
|
|
|
|
// get the draw function we need
|
|
drawarrayfunc_t func = _drawArrayFuncTable[_getDrawFunc()];
|
|
|
|
#ifndef _XBOX
|
|
DWORD* base = glw_state->drawArray;
|
|
#endif
|
|
|
|
int inc = glw_state->maxVertices;
|
|
// loop taking care not to draw too much at a time
|
|
for (int start = first; ; start += inc)//glw_state->maxVertices)
|
|
{
|
|
// draw glw_state->maxVertices amount of geometry
|
|
func(start, start + glw_state->maxVertices);
|
|
|
|
// are we done yet?
|
|
glw_state->totalVertices -= glw_state->maxVertices;
|
|
if (glw_state->totalVertices <= 0)
|
|
{
|
|
glw_state->numVertices = glw_state->maxVertices;
|
|
break;
|
|
}
|
|
|
|
// ready for another cycle
|
|
glw_state->drawArray += glw_state->maxVertices *
|
|
glw_state->drawStride;
|
|
glw_state->maxVertices = _getMaxVerts();
|
|
|
|
glw_state->drawArray = _restartDrawPacket(
|
|
glw_state->drawArray, glw_state->maxVertices);
|
|
}
|
|
|
|
#ifndef _XBOX
|
|
glw_state->drawArray = base;
|
|
#endif
|
|
|
|
#ifdef _WINDOWS
|
|
if (mode == GL_QUADS)
|
|
{
|
|
_cleanupQuadsToTris();
|
|
}
|
|
#endif
|
|
|
|
// finish up the draw
|
|
qglEnd();
|
|
}
|
|
|
|
static void dllDrawBuffer(GLenum mode)
|
|
{
|
|
//FIXME
|
|
}
|
|
|
|
|
|
static void PushIndices(GLsizei count, const GLushort *indices)
|
|
{
|
|
// open the index packet
|
|
// can only send 2047 indices thru at a time
|
|
// BUT, Microsoft recommends 511 pairs at a time (?)
|
|
int num_packets, numpairs, cnt;
|
|
bool singleindex = false;
|
|
|
|
numpairs = count / 2;
|
|
|
|
if(numpairs <= 511)
|
|
{
|
|
num_packets = 1;
|
|
|
|
if(glw_state->maxIndices % 2)
|
|
{
|
|
glw_state->maxIndices -= 1;
|
|
singleindex = true;
|
|
}
|
|
} else
|
|
{
|
|
num_packets = (count / glw_state->maxIndices) + (!!(count % glw_state->maxIndices));
|
|
}
|
|
|
|
glw_state->drawArray = _restartIndexPacket(glw_state->drawArray, glw_state->maxIndices);
|
|
|
|
int inc = glw_state->maxIndices;
|
|
for (int start = 0; ; start += inc)
|
|
{
|
|
for(int i = start; i < start + glw_state->maxIndices; i += 2)
|
|
{
|
|
*glw_state->drawArray++ = (DWORD)(((WORD)indices[i + 1] << 16) + (WORD)indices[i]);
|
|
}
|
|
// are we done yet?
|
|
glw_state->totalIndices -= glw_state->maxIndices;
|
|
if (glw_state->totalIndices <= 1)
|
|
{
|
|
glw_state->numIndices = glw_state->maxIndices;
|
|
break;
|
|
}
|
|
|
|
// ready for another cycle
|
|
//glw_state->drawArray += glw_state->maxVertices * glw_state->drawStride;
|
|
glw_state->maxIndices = _getMaxIndices();
|
|
|
|
if(glw_state->maxIndices % 2)
|
|
{
|
|
glw_state->maxIndices -= 1;
|
|
singleindex = true;
|
|
}
|
|
|
|
glw_state->drawArray = _restartIndexPacket(glw_state->drawArray, glw_state->maxIndices);
|
|
}
|
|
|
|
#define CMD_DRAW_INDEX_LAST 0x1808
|
|
if(singleindex)
|
|
{
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_DRAW_INDEX_LAST, 1);
|
|
*glw_state->drawArray++ = indices[count - 1];
|
|
}
|
|
}
|
|
|
|
// NOTE: This is a core draw routine. It should be fast.
|
|
static void dllDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
|
|
{
|
|
int normals, tex0, tex1, num_streams = 2;
|
|
|
|
assert(type == GL_UNSIGNED_SHORT);
|
|
|
|
normals = glw_state->normalArrayState ? tess.numVertexes : 0;
|
|
tex0 = glw_state->texCoordArrayState[0] ? tess.numVertexes : 0;
|
|
tex1 = glw_state->texCoordArrayState[1] ? tess.numVertexes : 0;
|
|
|
|
num_streams += ((normals > 0) + (tex0 > 0) + (tex1 > 0));
|
|
|
|
// start the draw block
|
|
glw_state->inDrawBlock = true;
|
|
glw_state->primitiveMode = _convertPrimMode(mode);
|
|
|
|
// update DX with any pending state changes
|
|
_updateDrawStride(normals, tex0, tex1);
|
|
_updateShader(normals, tex0, tex1);
|
|
_updateTextures();
|
|
_updateMatrices();
|
|
|
|
glw_state->drawStride += normals ? 2 : 1;
|
|
|
|
glw_state->numIndices = 0;
|
|
glw_state->totalIndices = count;
|
|
glw_state->maxIndices = _getMaxIndices();
|
|
|
|
glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);
|
|
|
|
int vert_size = glw_state->drawStride * tess.numVertexes;
|
|
int index_size = count / 2;
|
|
|
|
glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
|
|
|
|
glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
|
|
|
|
DWORD *jumpaddress = 0, *stream = 0;
|
|
|
|
// Determine where the end of the vertex data is gonna be,
|
|
// that's where we're going to jump to
|
|
jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
|
|
|
|
// Write the jump address
|
|
*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
|
|
|
|
// Set up our own fake vertex buffer
|
|
stream = glw_state->drawArray;
|
|
|
|
memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
if(normals)
|
|
{
|
|
memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
}
|
|
|
|
if(glw_state->colorArrayState)
|
|
{
|
|
memcpy(glw_state->drawArray, tess.svars.colors, sizeof(D3DCOLOR) * tess.numVertexes);
|
|
}
|
|
else
|
|
{
|
|
for( int v = 0; v < tess.numVertexes; ++v )
|
|
glw_state->drawArray[v] = glw_state->currentColor;
|
|
}
|
|
glw_state->drawArray += tess.numVertexes;
|
|
|
|
if(tex0)
|
|
{
|
|
memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 2;
|
|
}
|
|
|
|
if(tex1)
|
|
{
|
|
memcpy(glw_state->drawArray, tess.svars.texcoords[1], sizeof(vec2_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 2;
|
|
}
|
|
|
|
// Write the vertex shader
|
|
#define CMD_STREAM_STRIDEANDTYPE0 0x1760
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
|
|
*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
|
|
|
|
if(1)
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
if(normals)
|
|
{
|
|
*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
|
|
}
|
|
else
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
*glw_state->drawArray++ = (4 << 8) | D3DVSDT_D3DCOLOR;
|
|
|
|
for(int i = 0; i < 5; i++)
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
if(tex0)
|
|
{
|
|
*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
|
|
}
|
|
else
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
if(tex1)
|
|
{
|
|
*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
|
|
}
|
|
else
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
for(i = 0; i < 5; i++)
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
// Write the indicator to our vertex stream
|
|
#define CMD_VERTEXSTREAM_XYZ 0x1720
|
|
#define CMD_VERTEXSTREAM_NORMAL 0x1728
|
|
#define CMD_VERTEXSTREAM_COLOR 0x172c
|
|
#define CMD_VERTEXSTREAM_TEX0 0x1744
|
|
#define CMD_VERTEXSTREAM_TEX1 0x1748
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_XYZ, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;//3;
|
|
|
|
if(normals)
|
|
{
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_NORMAL, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;//3;
|
|
}
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_COLOR, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes;//1;
|
|
|
|
if(tex0)
|
|
{
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_TEX0, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 2;//2;
|
|
}
|
|
|
|
if(tex1)
|
|
{
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_TEX1, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
}
|
|
|
|
// Send thru the index data
|
|
PushIndices(count, (GLushort*)indices);
|
|
|
|
// finish up the draw
|
|
glw_state->inDrawBlock = false;
|
|
|
|
DWORD* push = _terminateIndexPacket(glw_state->drawArray);
|
|
|
|
glw_state->device->EndPush(push);
|
|
}
|
|
|
|
static void dllDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEdgeFlag(GLboolean flag)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEdgeFlagv(const GLboolean *flag)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEnable(GLenum cap)
|
|
{
|
|
setCap(cap, true);
|
|
}
|
|
|
|
static void dllEnableClientState(GLenum array)
|
|
{
|
|
assert(!glw_state->inDrawBlock);
|
|
setArrayState(array, true);
|
|
}
|
|
|
|
static void dllEnd(void)
|
|
{
|
|
assert(glw_state->inDrawBlock);
|
|
glw_state->inDrawBlock = false;
|
|
#ifdef _XBOX
|
|
// on Xbox, just close the draw packet
|
|
DWORD* push = _terminateDrawPacket(
|
|
&glw_state->drawArray[glw_state->numVertices *
|
|
glw_state->drawStride]);
|
|
|
|
glw_state->device->EndPush(push);
|
|
#else
|
|
// on the PC, use DrawPrimitiveUp (a little slow)
|
|
int num = 0;
|
|
switch (glw_state->primitiveMode)
|
|
{
|
|
case D3DPT_POINTLIST: num = glw_state->numVertices; break;
|
|
case D3DPT_LINELIST: num = glw_state->numVertices / 2; break;
|
|
case D3DPT_LINESTRIP: num = glw_state->numVertices - 1; break;
|
|
case D3DPT_TRIANGLELIST: num = glw_state->numVertices / 3; break;
|
|
case D3DPT_TRIANGLESTRIP: num = glw_state->numVertices - 2; break;
|
|
case D3DPT_TRIANGLEFAN: num = glw_state->numVertices - 2; break;
|
|
}
|
|
|
|
glw_state->device->DrawPrimitiveUP(
|
|
glw_state->primitiveMode, num,
|
|
glw_state->drawArray, glw_state->drawStride * sizeof(DWORD));
|
|
#endif
|
|
}
|
|
|
|
// EXTENSION: End drawing for a frame
|
|
static void dllEndFrame(void)
|
|
{
|
|
assert(!glw_state->inDrawBlock);
|
|
|
|
// the blend state can get reset by Present()...
|
|
GLboolean blend = qglIsEnabled(GL_BLEND);
|
|
|
|
glw_state->device->EndScene();
|
|
|
|
qglViewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
|
|
glw_state->device->Present(NULL, NULL, NULL, NULL);
|
|
|
|
// restore the pre-Present state
|
|
if (blend) qglEnable(GL_BLEND);
|
|
else qglDisable(GL_BLEND);
|
|
}
|
|
|
|
// EXTENSION: End shadow draw mode
|
|
static void dllEndShadow(void)
|
|
{
|
|
//Intentionally left blank
|
|
}
|
|
|
|
static void dllEndList(void)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord1d(GLdouble u)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord1dv(const GLdouble *u)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord1f(GLfloat u)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord1fv(const GLfloat *u)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord2d(GLdouble u, GLdouble v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord2dv(const GLdouble *u)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord2f(GLfloat u, GLfloat v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalCoord2fv(const GLfloat *u)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalMesh1(GLenum mode, GLint i1, GLint i2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalPoint1(GLint i)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllEvalPoint2(GLint i, GLint j)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllFinish(void)
|
|
{
|
|
#ifdef _XBOX
|
|
glw_state->device->BlockUntilIdle();
|
|
#endif
|
|
}
|
|
|
|
static void dllFlush(void)
|
|
{
|
|
#ifdef _XBOX
|
|
glw_state->device->BlockUntilIdle();
|
|
#endif
|
|
}
|
|
|
|
// EXTENSION: Draw the shadow
|
|
static void dllFlushShadow(void)
|
|
{
|
|
//Intentionally left blank
|
|
}
|
|
|
|
static D3DFOGMODE _convertFogMode(GLint param)
|
|
{
|
|
switch(param)
|
|
{
|
|
case GL_LINEAR: return D3DFOG_LINEAR; break;
|
|
case GL_EXP: return D3DFOG_EXP; break;
|
|
case GL_EXP2: return D3DFOG_EXP2; break;
|
|
}
|
|
|
|
return D3DFOG_NONE;
|
|
}
|
|
|
|
static void dllFogf(GLenum pname, GLfloat param)
|
|
{
|
|
assert(pname == GL_FOG_DENSITY || pname == GL_FOG_START || pname == GL_FOG_END);
|
|
|
|
switch(pname)
|
|
{
|
|
case GL_FOG_DENSITY: glw_state->device->SetRenderState( D3DRS_FOGDENSITY, *(DWORD*)¶m ); break;
|
|
case GL_FOG_START: glw_state->device->SetRenderState( D3DRS_FOGSTART, *(DWORD*)¶m ); break;
|
|
case GL_FOG_END: glw_state->device->SetRenderState( D3DRS_FOGEND, *(DWORD*)¶m ); break;
|
|
}
|
|
}
|
|
|
|
static void dllFogfv(GLenum pname, const GLfloat *params)
|
|
{
|
|
assert(pname == GL_FOG_COLOR);
|
|
|
|
D3DCOLOR color = D3DCOLOR_ARGB(0x00,
|
|
(int)(params[0] * 255.0f),
|
|
(int)(params[1] * 255.0f),
|
|
(int)(params[2] * 255.0f));
|
|
|
|
glw_state->device->SetRenderState( D3DRS_FOGCOLOR, color );
|
|
}
|
|
|
|
static void dllFogi(GLenum pname, GLint param)
|
|
{
|
|
assert(pname == GL_FOG_MODE);
|
|
|
|
glw_state->device->SetRenderState( D3DRS_FOGTABLEMODE, _convertFogMode(param) );
|
|
}
|
|
|
|
static void dllFogiv(GLenum pname, const GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllFrontFace(GLenum mode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
D3DXMATRIX m;
|
|
D3DXMatrixPerspectiveOffCenterRH(&m, left, right, bottom, top, zNear, zFar);
|
|
glw_state->matrixStack[glw_state->matrixMode]->MultMatrix(&m);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
GLuint dllGenLists(GLsizei range)
|
|
{
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
static void dllGenTextures(GLsizei n, GLuint *textures)
|
|
{
|
|
for (int i = 0; i < n; ++i)
|
|
{
|
|
textures[i] = glw_state->textureBindNum++;
|
|
}
|
|
}
|
|
|
|
// Implemented only the states we use.
|
|
template <typename T>
|
|
static void _getState(GLenum pname, T *params)
|
|
{
|
|
switch (pname)
|
|
{
|
|
case GL_CULL_FACE: params[0] = (T)glw_state->cullEnable; break;
|
|
case GL_MAX_TEXTURE_SIZE: params[0] = (T)512; break;
|
|
case GL_MAX_ACTIVE_TEXTURES_ARB: params[0] = GLW_MAX_TEXTURE_STAGES; break;
|
|
default:
|
|
assert(0);
|
|
params[0] = (T)0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void dllGetBooleanv(GLenum pname, GLboolean *params)
|
|
{
|
|
_getState(pname, params);
|
|
}
|
|
|
|
static void dllGetClipPlane(GLenum plane, GLdouble *equation)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetDoublev(GLenum pname, GLdouble *params)
|
|
{
|
|
_getState(pname, params);
|
|
}
|
|
|
|
GLenum dllGetError(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void dllGetFloatv(GLenum pname, GLfloat *params)
|
|
{
|
|
_getState(pname, params);
|
|
}
|
|
|
|
static void dllGetIntegerv(GLenum pname, GLint *params)
|
|
{
|
|
_getState(pname, params);
|
|
}
|
|
|
|
static void dllGetLightfv(GLenum light, GLenum pname, GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetLightiv(GLenum light, GLenum pname, GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetMapdv(GLenum target, GLenum query, GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetMapfv(GLenum target, GLenum query, GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetMapiv(GLenum target, GLenum query, GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetMaterialiv(GLenum face, GLenum pname, GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetPixelMapfv(GLenum map, GLfloat *values)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetPixelMapuiv(GLenum map, GLuint *values)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetPixelMapusv(GLenum map, GLushort *values)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetPointerv(GLenum pname, GLvoid* *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetPolygonStipple(GLubyte *mask)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
const GLubyte * dllGetString(GLenum name)
|
|
{
|
|
switch (name)
|
|
{
|
|
case GL_VENDOR: return (const unsigned char*)"Vicarious Visions";
|
|
case GL_RENDERER: return (const unsigned char*)"Optimized DX8/OpenGL Layer";
|
|
case GL_VERSION: return (const unsigned char*)"0.1";
|
|
case GL_EXTENSIONS:
|
|
return (const unsigned char*)
|
|
"EXT_texture_env_add GL_ARB_multitexture EXT_texture_filter_anisotropic";
|
|
default: return (const unsigned char*)"";
|
|
}
|
|
}
|
|
|
|
static void dllGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexEnviv(GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllHint(GLenum target, GLenum mode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
// Convert an triangle index array (indices) to a
|
|
// triangle strip index array (dest) with primitive
|
|
// length array.
|
|
static void buildStrips(GLuint* len, GLsizei* num_lens, GLushort* dest, GLsizei* num_indices, const GLushort* src)
|
|
{
|
|
GLushort last[3];
|
|
|
|
// prime the strip
|
|
GLsizei cur_index = 0;
|
|
dest[cur_index++] = src[0];
|
|
dest[cur_index++] = src[1];
|
|
dest[cur_index++] = src[2];
|
|
GLuint cur_length = 3;
|
|
GLsizei num_strips = 0;
|
|
|
|
GLuint max_length = GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride;
|
|
|
|
last[0] = src[0];
|
|
last[1] = src[1];
|
|
last[2] = src[2];
|
|
|
|
qboolean even = qfalse;
|
|
|
|
for ( GLsizei i = 3; i < *num_indices; i += 3 )
|
|
{
|
|
// odd numbered triangle in potential strip
|
|
if ( !even )
|
|
{
|
|
// check previous triangle to see if we're continuing a strip
|
|
if ( ( src[i+0] == last[2] ) && ( src[i+1] == last[1] ) &&
|
|
cur_length < max_length )
|
|
{
|
|
++cur_length;
|
|
dest[cur_index++] = src[i+2];
|
|
even = qtrue;
|
|
}
|
|
// otherwise we're done with this strip so finish it and start
|
|
// a new one
|
|
else
|
|
{
|
|
len[num_strips++] = cur_length;
|
|
cur_length = 3;
|
|
|
|
dest[cur_index++] = src[i+0];
|
|
dest[cur_index++] = src[i+1];
|
|
dest[cur_index++] = src[i+2];
|
|
|
|
even = qfalse;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// check previous triangle to see if we're continuing a strip
|
|
if ( ( last[2] == src[i+1] ) && ( last[0] == src[i+0] ) &&
|
|
cur_length < max_length )
|
|
{
|
|
++cur_length;
|
|
dest[cur_index++] = src[i+2];
|
|
even = qfalse;
|
|
}
|
|
// otherwise we're done with this strip so finish it and start
|
|
// a new one
|
|
else
|
|
{
|
|
len[num_strips++] = cur_length;
|
|
cur_length = 3;
|
|
|
|
dest[cur_index++] = src[i+0];
|
|
dest[cur_index++] = src[i+1];
|
|
dest[cur_index++] = src[i+2];
|
|
|
|
even = qfalse;
|
|
}
|
|
}
|
|
|
|
// cache the last three vertices
|
|
last[0] = src[i+0];
|
|
last[1] = src[i+1];
|
|
last[2] = src[i+2];
|
|
}
|
|
|
|
len[num_strips++] = cur_length;
|
|
*num_lens = num_strips;
|
|
*num_indices = cur_index;
|
|
|
|
assert(num_strips <= GLW_MAX_STRIPS);
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
void renderObject_Light()
|
|
{
|
|
int i;
|
|
|
|
// start the draw mode
|
|
assert(!glw_state->inDrawBlock);
|
|
|
|
glw_state->inDrawBlock = true;
|
|
glw_state->primitiveMode = D3DPT_TRIANGLELIST;
|
|
|
|
glw_state->drawStride = 14;
|
|
|
|
glw_state->numIndices = 0;
|
|
glw_state->totalIndices = tess.numIndexes;
|
|
glw_state->maxIndices = _getMaxIndices();
|
|
|
|
glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);
|
|
|
|
int vert_size = glw_state->drawStride * tess.numVertexes;
|
|
int index_size = tess.numIndexes / 2;
|
|
|
|
glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
|
|
|
|
glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
|
|
|
|
DWORD *jumpaddress = 0, *stream = 0;
|
|
|
|
// Determine where the end of the vertex data is gonna be,
|
|
// that's where we're going to jump to
|
|
jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
|
|
|
|
// Write the jump address
|
|
*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
|
|
|
|
// Set up our own fake vertex buffer
|
|
stream = glw_state->drawArray;
|
|
|
|
memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 2;
|
|
|
|
memcpy(glw_state->drawArray, tess.tangent, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
// Write the vertex shader
|
|
#define CMD_STREAM_STRIDEANDTYPE0 0x1760
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
|
|
|
|
// Position
|
|
*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
|
|
|
|
// Normal
|
|
*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
|
|
|
|
// Tex Coord
|
|
*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
|
|
|
|
// Tangent
|
|
*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
|
|
|
|
for(i = 0; i < 12; i++)
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
// Write the indicator to our vertex stream
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1720, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1724, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1728, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 2;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x172c, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
// Send thru the index data
|
|
PushIndices(tess.numIndexes, (GLushort*)tess.indexes);
|
|
|
|
// finish up the draw
|
|
glw_state->inDrawBlock = false;
|
|
|
|
DWORD* push = _terminateIndexPacket(glw_state->drawArray);
|
|
|
|
glw_state->device->EndPush(push);
|
|
}
|
|
|
|
void renderObject_Bump()
|
|
{
|
|
// start the draw mode
|
|
assert(!glw_state->inDrawBlock);
|
|
|
|
glw_state->inDrawBlock = true;
|
|
glw_state->primitiveMode = D3DPT_TRIANGLELIST;
|
|
|
|
glw_state->drawStride = 16;
|
|
|
|
glw_state->numIndices = 0;
|
|
glw_state->totalIndices = tess.numIndexes;
|
|
glw_state->maxIndices = _getMaxIndices();
|
|
|
|
glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);
|
|
|
|
int vert_size = glw_state->drawStride * tess.numVertexes;
|
|
int index_size = tess.numIndexes / 2;
|
|
|
|
glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
|
|
|
|
glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
|
|
|
|
DWORD *jumpaddress = 0, *stream = 0;
|
|
|
|
// Determine where the end of the vertex data is gonna be,
|
|
// that's where we're going to jump to
|
|
jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
|
|
|
|
// Write the jump address
|
|
*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
|
|
|
|
// Set up our own fake vertex buffer
|
|
stream = glw_state->drawArray;
|
|
|
|
memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 2;
|
|
|
|
memcpy(glw_state->drawArray, tess.svars.texcoords[1], sizeof(vec2_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 2;
|
|
|
|
memcpy(glw_state->drawArray, tess.tangent, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
// Write the vertex shader
|
|
#define CMD_STREAM_STRIDEANDTYPE0 0x1760
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
|
|
|
|
// Position
|
|
*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
|
|
|
|
// Normal
|
|
*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
|
|
|
|
// Tex Coord 0
|
|
*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
|
|
|
|
// Tex Coord 1
|
|
*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
|
|
|
|
// Tangent
|
|
*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
|
|
|
|
for(int i = 0; i < 11; i++)
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
// Write the indicator to our vertex stream
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1720, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1724, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1728, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 2;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x172c, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 2;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1730, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
// Send thru the index data
|
|
PushIndices(tess.numIndexes, (GLushort*)tess.indexes);
|
|
|
|
// finish up the draw
|
|
glw_state->inDrawBlock = false;
|
|
|
|
DWORD* push = _terminateIndexPacket(glw_state->drawArray);
|
|
|
|
glw_state->device->EndPush(push);
|
|
}
|
|
|
|
void renderObject_Env()
|
|
{
|
|
// start the draw mode
|
|
assert(!glw_state->inDrawBlock);
|
|
|
|
glw_state->inDrawBlock = true;
|
|
glw_state->primitiveMode = D3DPT_TRIANGLELIST;
|
|
|
|
glw_state->drawStride = 9;
|
|
_updateTextures();
|
|
|
|
glw_state->numIndices = 0;
|
|
glw_state->totalIndices = tess.numIndexes;
|
|
glw_state->maxIndices = _getMaxIndices();
|
|
|
|
glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);
|
|
|
|
int vert_size = glw_state->drawStride * tess.numVertexes;
|
|
int index_size = tess.numIndexes / 2;
|
|
|
|
glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
|
|
|
|
glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
|
|
|
|
DWORD *jumpaddress = 0, *stream = 0;
|
|
|
|
// Determine where the end of the vertex data is gonna be,
|
|
// that's where we're going to jump to
|
|
jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
|
|
|
|
// Write the jump address
|
|
*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
|
|
|
|
// Set up our own fake vertex buffer
|
|
stream = glw_state->drawArray;
|
|
|
|
memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes * 4;
|
|
|
|
memcpy(glw_state->drawArray, tess.svars.colors, sizeof(D3DCOLOR) * tess.numVertexes);
|
|
glw_state->drawArray += tess.numVertexes;
|
|
|
|
// Write the vertex shader
|
|
#define CMD_STREAM_STRIDEANDTYPE0 0x1760
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
|
|
|
|
// Position
|
|
*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
|
|
|
|
// Normal
|
|
*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
|
|
|
|
// Color
|
|
*glw_state->drawArray++ = (4 << 8) | D3DVSDT_D3DCOLOR;
|
|
|
|
for(int i = 0; i < 13; i++)
|
|
{
|
|
*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
|
|
}
|
|
|
|
// Write the indicator to our vertex stream
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1720, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1724, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes * 4;
|
|
|
|
*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1728, 1);
|
|
*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
|
|
stream += tess.numVertexes;
|
|
|
|
// Send thru the index data
|
|
PushIndices(tess.numIndexes, (GLushort*)tess.indexes);
|
|
|
|
// finish up the draw
|
|
glw_state->inDrawBlock = false;
|
|
|
|
DWORD* push = _terminateIndexPacket(glw_state->drawArray);
|
|
|
|
glw_state->device->EndPush(push);
|
|
}
|
|
#endif
|
|
|
|
// EXTENSION: Take an array of triangle indices and draw
|
|
// the appropriate triangle strips. Virtually ALL geometry
|
|
// is drawn with this function so it better be fast.
|
|
static void dllIndexedTriToStrip(GLsizei count, const GLushort *indices)
|
|
{
|
|
#ifndef _XBOX
|
|
#ifdef GLW_USE_TRI_STRIPS
|
|
|
|
// update the render state
|
|
_updateDrawStride(glw_state->normalArrayState,
|
|
glw_state->texCoordArrayState[0] ? count : 0,
|
|
glw_state->texCoordArrayState[1] ? count : 0);
|
|
_updateShader(glw_state->normalArrayState,
|
|
glw_state->texCoordArrayState[0],
|
|
glw_state->texCoordArrayState[1]);
|
|
_updateTextures();
|
|
_updateMatrices();
|
|
|
|
// convert triangles to strips -- guarantees that
|
|
// no strip exceeds the max draw packet size
|
|
if(tess.currentPass == 0)
|
|
{
|
|
buildStrips(glw_state->strip_lengths,
|
|
&glw_state->num_strip_lengths, glw_state->strip_dest, &count, indices);
|
|
}
|
|
|
|
// Yeah, its a hack, but I gotta do this so bumpmapping
|
|
// doesnt go all crazy on the 'force speed' effect and
|
|
// 'disintegration' effect
|
|
if(tess.shader &&
|
|
tess.shader->isBumpMap &&
|
|
(backEnd.currentEntity->e.renderfx &
|
|
// VVFIXME : This is probably wrong. It looks like RF_ALPHA_FADE is renamed
|
|
// RF_RGB_TINT in MP. Substitute?
|
|
#ifndef _JK2MP
|
|
(RF_ALPHA_FADE | RF_DISINTEGRATE1 | RF_DISINTEGRATE2)))
|
|
#else
|
|
(RF_DISINTEGRATE1 | RF_DISINTEGRATE2)))
|
|
#endif
|
|
{
|
|
if(tess.currentPass != 2)
|
|
return;
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
glw_state->primitiveMode = D3DPT_TRIANGLESTRIP;
|
|
|
|
// get the necessary draw function
|
|
drawelemfunc_t func = _drawElementFuncTable[_getDrawFunc()];
|
|
int stride = glw_state->drawStride;
|
|
|
|
int index = 0;
|
|
for (int l = 0; l < glw_state->num_strip_lengths; ++l)
|
|
{
|
|
int cur_len = glw_state->strip_lengths[l];
|
|
|
|
// start a draw packet
|
|
DWORD* push;
|
|
glw_state->device->BeginPush(stride * cur_len + 5, &push);
|
|
push = _restartDrawPacket(push, cur_len);
|
|
|
|
// draw the geometry
|
|
glw_state->drawArray = push;
|
|
func(cur_len, &glw_state->strip_dest[index]);
|
|
index += cur_len;
|
|
|
|
// finish the draw packet
|
|
push = _terminateDrawPacket(&push[stride * cur_len]);
|
|
glw_state->device->EndPush(push);
|
|
}
|
|
#else _XBOX
|
|
// simplified render on the PC
|
|
int index = 0;
|
|
for (int l = 0; l < glw_state->num_strip_lengths; ++l)
|
|
{
|
|
dllDrawElements(GL_TRIANGLE_STRIP, glw_state->strip_lengths[l],
|
|
GL_UNSIGNED_SHORT, &glw_state->strip_dest[index]);
|
|
index += glw_state->strip_lengths[l];
|
|
}
|
|
#endif _XBOX
|
|
|
|
#else GLW_USE_TRI_STRIPS
|
|
// just render simple triangles
|
|
dllDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, indices);
|
|
#endif GLW_USE_TRI_STRIPS
|
|
#endif
|
|
}
|
|
|
|
static void dllIndexMask(GLuint mask)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexd(GLdouble c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexdv(const GLdouble *c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexf(GLfloat c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexfv(const GLfloat *c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexi(GLint c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexiv(const GLint *c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexs(GLshort c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexsv(const GLshort *c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexub(GLubyte c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllIndexubv(const GLubyte *c)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllInitNames(void)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
GLboolean dllIsEnabled(GLenum cap)
|
|
{
|
|
DWORD flag;
|
|
switch (cap)
|
|
{
|
|
case GL_ALPHA_TEST: glw_state->device->GetRenderState(D3DRS_ALPHATESTENABLE, &flag); break;
|
|
case GL_BLEND: glw_state->device->GetRenderState(D3DRS_ALPHABLENDENABLE, &flag); break;
|
|
case GL_CULL_FACE: return glw_state->cullEnable;
|
|
case GL_DEPTH_TEST: glw_state->device->GetRenderState(D3DRS_ZENABLE, &flag); break;
|
|
case GL_FOG: glw_state->device->GetRenderState(D3DRS_FOGENABLE, &flag); break;
|
|
case GL_LIGHTING: glw_state->device->GetRenderState(D3DRS_LIGHTING, &flag); break;
|
|
#ifdef _XBOX
|
|
case GL_POLYGON_OFFSET_FILL: glw_state->device->GetRenderState(D3DRS_SOLIDOFFSETENABLE, &flag); break;
|
|
#else
|
|
case GL_POLYGON_OFFSET_FILL: return FALSE;
|
|
#endif
|
|
case GL_SCISSOR_TEST: return glw_state->scissorEnable;
|
|
case GL_STENCIL_TEST: glw_state->device->GetRenderState(D3DRS_STENCILENABLE, &flag); break;
|
|
case GL_TEXTURE_2D: return glw_state->textureStageEnable[glw_state->serverTU];
|
|
default: return FALSE;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
GLboolean dllIsList(GLuint lnum)
|
|
{
|
|
assert(0);
|
|
return 1;
|
|
}
|
|
|
|
GLboolean dllIsTexture(GLuint texture)
|
|
{
|
|
assert(0);
|
|
return 1;
|
|
}
|
|
|
|
static void dllLightModelf(GLenum pname, GLfloat param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLightModelfv(GLenum pname, const GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLightModeli(GLenum pname, GLint param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLightModeliv(GLenum pname, const GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLightf(GLenum light, GLenum pname, GLfloat param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLightfv(GLenum light, GLenum pname, const GLfloat *params)
|
|
{
|
|
switch(pname)
|
|
{
|
|
case GL_AMBIENT:
|
|
{
|
|
glw_state->dirLight.Ambient.r = params[0] / 255.0f;
|
|
glw_state->dirLight.Ambient.g = params[1] / 255.0f;
|
|
glw_state->dirLight.Ambient.b = params[2] / 255.0f;
|
|
}
|
|
break;
|
|
|
|
case GL_DIFFUSE:
|
|
{
|
|
glw_state->dirLight.Diffuse.r = params[0] / 255.0f;
|
|
glw_state->dirLight.Diffuse.g = params[1] / 255.0f;
|
|
glw_state->dirLight.Diffuse.b = params[2] / 255.0f;
|
|
}
|
|
break;
|
|
|
|
case GL_SPECULAR:
|
|
{
|
|
glw_state->dirLight.Specular.r = params[0] / 255.0f;
|
|
glw_state->dirLight.Specular.g = params[1] / 255.0f;
|
|
glw_state->dirLight.Specular.b = params[2] / 255.0f;
|
|
}
|
|
break;
|
|
case GL_POSITION:
|
|
{
|
|
glw_state->dirLight.Position.x = params[0];
|
|
glw_state->dirLight.Position.y = params[1];
|
|
glw_state->dirLight.Position.z = params[2];
|
|
}
|
|
break;
|
|
|
|
case GL_SPOT_DIRECTION:
|
|
{
|
|
glw_state->dirLight.Direction.x = -params[0];
|
|
glw_state->dirLight.Direction.y = -params[1];
|
|
glw_state->dirLight.Direction.z = -params[2];
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
break;
|
|
}
|
|
|
|
glw_state->device->SetLight(light, &glw_state->dirLight);
|
|
glw_state->device->LightEnable(light, TRUE);
|
|
}
|
|
|
|
static void dllLighti(GLenum light, GLenum pname, GLint param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLightiv(GLenum light, GLenum pname, const GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLineStipple(GLint factor, GLushort pattern)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLineWidth(GLfloat width)
|
|
{
|
|
// assert(0);
|
|
}
|
|
|
|
static void dllListBase(GLuint base)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLoadIdentity(void)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->LoadIdentity();
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllLoadMatrixd(const GLdouble *m)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLoadMatrixf(const GLfloat *m)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->LoadMatrix((D3DXMATRIX*)m);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllLoadName(GLuint name)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllLogicOp(GLenum opcode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMaterialf(GLenum face, GLenum pname, GLfloat param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
|
|
{
|
|
switch(pname)
|
|
{
|
|
case GL_AMBIENT:
|
|
glw_state->mtrl.Ambient.r = params[0] / 255.0f;
|
|
glw_state->mtrl.Ambient.g = params[1] / 255.0f;
|
|
glw_state->mtrl.Ambient.b = params[2] / 255.0f;
|
|
glw_state->mtrl.Ambient.a = params[3] / 255.0f;
|
|
break;
|
|
|
|
case GL_DIFFUSE:
|
|
glw_state->mtrl.Diffuse.r = params[0] / 255.0f;
|
|
glw_state->mtrl.Diffuse.g = params[1] / 255.0f;
|
|
glw_state->mtrl.Diffuse.b = params[2] / 255.0f;
|
|
glw_state->mtrl.Diffuse.a = params[3] / 255.0f;
|
|
break;
|
|
|
|
case GL_SPECULAR:
|
|
glw_state->mtrl.Specular.r = params[0] / 255.0f;
|
|
glw_state->mtrl.Specular.g = params[1] / 255.0f;
|
|
glw_state->mtrl.Specular.b = params[2] / 255.0f;
|
|
glw_state->mtrl.Specular.a = params[3] / 255.0f;
|
|
break;
|
|
|
|
case GL_EMISSION:
|
|
glw_state->mtrl.Emissive.r = params[0] / 255.0f;
|
|
glw_state->mtrl.Emissive.g = params[1] / 255.0f;
|
|
glw_state->mtrl.Emissive.b = params[2] / 255.0f;
|
|
glw_state->mtrl.Emissive.a = params[3] / 255.0f;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
break;
|
|
}
|
|
|
|
glw_state->device->SetMaterial(&glw_state->mtrl);
|
|
}
|
|
|
|
static void dllMateriali(GLenum face, GLenum pname, GLint param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMaterialiv(GLenum face, GLenum pname, const GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMatrixMode(GLenum mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case GL_MODELVIEW: glw_state->matrixMode = glwstate_t::MatrixMode_Model; break;
|
|
case GL_PROJECTION: glw_state->matrixMode = glwstate_t::MatrixMode_Projection; break;
|
|
#ifdef _XBOX
|
|
case GL_TEXTURE0: glw_state->matrixMode = glwstate_t::MatrixMode_Texture0; break;
|
|
case GL_TEXTURE1: glw_state->matrixMode = glwstate_t::MatrixMode_Texture1; break;
|
|
#endif
|
|
default: assert(false); break;
|
|
}
|
|
}
|
|
|
|
static void dllMultMatrixd(const GLdouble *m)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllMultMatrixf(const GLfloat *m)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->MultMatrixLocal((D3DXMATRIX*)m);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllNewList(GLuint lnum, GLenum mode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void setNormal(float x, float y, float z)
|
|
{
|
|
assert(glw_state->inDrawBlock);
|
|
|
|
_handleDrawOverflow();
|
|
|
|
DWORD* push = &glw_state->drawArray[glw_state->numVertices * glw_state->drawStride + 4];
|
|
push[0] = *((DWORD*)&x);
|
|
push[1] = *((DWORD*)&y);
|
|
push[2] = *((DWORD*)&z);
|
|
push[3] = glw_state->currentColor;
|
|
}
|
|
static void dllNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3bv(const GLbyte *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
|
|
{
|
|
setNormal(nx, ny, nz);
|
|
}
|
|
|
|
static void dllNormal3fv(const GLfloat *v)
|
|
{
|
|
setNormal(v[0], v[1], v[2]);
|
|
}
|
|
|
|
static void dllNormal3i(GLint nx, GLint ny, GLint nz)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3s(GLshort nx, GLshort ny, GLshort nz)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormal3sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(type == GL_FLOAT);
|
|
|
|
stride = (stride == 0) ? (sizeof(GLfloat) * 3) : stride;
|
|
|
|
glw_state->normalPointer = pointer;
|
|
glw_state->normalStride = stride;
|
|
}
|
|
|
|
static void dllOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
D3DXMATRIX m;
|
|
D3DXMatrixOrthoOffCenterRH(&m, left, right, top, bottom, zNear, zFar);
|
|
glw_state->matrixStack[glw_state->matrixMode]->MultMatrix(&m);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllPassThrough(GLfloat token)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelStoref(GLenum pname, GLfloat param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelStorei(GLenum pname, GLint param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelTransferf(GLenum pname, GLfloat param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelTransferi(GLenum pname, GLint param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPixelZoom(GLfloat xfactor, GLfloat yfactor)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPointSize(GLfloat size)
|
|
{
|
|
glw_state->device->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
|
|
glw_state->device->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&size));
|
|
}
|
|
|
|
static void dllPolygonMode(GLenum face, GLenum mode)
|
|
{
|
|
D3DFILLMODE m;
|
|
switch (mode)
|
|
{
|
|
case GL_POINT: m = D3DFILL_POINT; break;
|
|
case GL_LINE: m = D3DFILL_WIREFRAME; break;
|
|
case GL_FILL: m = D3DFILL_SOLID; break;
|
|
default: assert(0); break;
|
|
}
|
|
|
|
switch (face)
|
|
{
|
|
case GL_FRONT:
|
|
glw_state->device->SetRenderState(D3DRS_FILLMODE, m);
|
|
break;
|
|
case GL_BACK:
|
|
#ifdef _XBOX
|
|
glw_state->device->SetRenderState(D3DRS_BACKFILLMODE, m);
|
|
#endif
|
|
break;
|
|
case GL_FRONT_AND_BACK:
|
|
glw_state->device->SetRenderState(D3DRS_FILLMODE, m);
|
|
#ifdef _XBOX
|
|
glw_state->device->SetRenderState(D3DRS_BACKFILLMODE, m);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void dllPolygonOffset(GLfloat factor, GLfloat units)
|
|
{
|
|
#ifdef _XBOX
|
|
glw_state->device->SetRenderState(D3DRS_POLYGONOFFSETZOFFSET, *((DWORD*)&factor));
|
|
glw_state->device->SetRenderState(D3DRS_POLYGONOFFSETZSLOPESCALE, *((DWORD*)&units));
|
|
#endif
|
|
}
|
|
|
|
static void dllPolygonStipple(const GLubyte *mask)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPopAttrib(void)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPopClientAttrib(void)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPopMatrix(void)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->Pop();
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllPopName(void)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPushAttrib(GLbitfield mask)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPushClientAttrib(GLbitfield mask)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllPushMatrix(void)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->Push();
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllPushName(GLuint name)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2d(GLdouble x, GLdouble y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2f(GLfloat x, GLfloat y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2fv(const GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2i(GLint x, GLint y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2s(GLshort x, GLshort y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos2sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3fv(const GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3i(GLint x, GLint y, GLint z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos3sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4fv(const GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRasterPos4sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllReadBuffer(GLenum mode)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
//static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels)
|
|
static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
return;
|
|
|
|
/*
|
|
// assert((format == GL_LIN_RGB8) && (type == GL_UNSIGNED_BYTE));
|
|
|
|
// create a temporary storage surface
|
|
IDirect3DSurface8 *target;
|
|
glw_state->device->CreateImageSurface(twidth, theight, D3DFMT_A8R8G8B8, &target);
|
|
|
|
// get a pointer to the back buffer
|
|
IDirect3DSurface8* screen;
|
|
glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &screen);
|
|
|
|
// copy the back buffer into a surface of the appropriate size and format
|
|
RECT r;
|
|
r.left = x;
|
|
r.top = y;
|
|
r.right = x + width;
|
|
r.bottom = y + height;
|
|
D3DXLoadSurfaceFromSurface(target, NULL, NULL, screen, NULL, &r, D3DX_DEFAULT, 0);
|
|
screen->Release();
|
|
|
|
// lock the target surface
|
|
D3DLOCKED_RECT lock;
|
|
target->LockRect(&lock, NULL, D3DLOCK_READONLY);
|
|
|
|
// copy the pixel data
|
|
for (int y = 0; y < theight; ++y)
|
|
{
|
|
memcpy((char*)pixels + twidth * y * 4,
|
|
(char*)lock.pBits + lock.Pitch * y,
|
|
twidth * 4);
|
|
}
|
|
|
|
// all done
|
|
target->UnlockRect();
|
|
target->Release();
|
|
*/
|
|
|
|
/*
|
|
// create target storage surface
|
|
IDirect3DSurface8 *target;
|
|
glw_state->device->CreateImageSurface(twidth, theight, D3DFMT_A8R8G8B8, &target);
|
|
|
|
// get a pointer to the back buffer
|
|
IDirect3DSurface8* back;
|
|
glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &back);
|
|
|
|
D3DSURFACE_DESC ddsd;
|
|
back->GetDesc(&ddsd);
|
|
int bpp = XGBytesPerPixelFromFormat(ddsd.Format);
|
|
|
|
// create surface to hold screen data
|
|
// (512x512 is exactly big enough to hold the screen but we
|
|
// need to save some memory so I'm going to clip the edges)
|
|
IDirect3DSurface8 *screen;
|
|
glw_state->device->CreateImageSurface(512, 512, ddsd.Format, &screen);
|
|
|
|
// copy back buffer to non-tiled screen surface
|
|
RECT r;
|
|
r.left = 64;
|
|
r.top = 0;
|
|
r.right = 576;
|
|
r.bottom = 480;
|
|
POINT ul = {0, 0};
|
|
glw_state->device->CopyRects(back, &r, 1, screen, &ul);
|
|
back->Release();
|
|
|
|
// deswizzle the screen
|
|
D3DLOCKED_RECT lock;
|
|
screen->LockRect(&lock, NULL, D3DLOCK_READONLY);
|
|
void* deswizzled = Z_Malloc(512*512*bpp, TAG_TEMP_WORKSPACE, qfalse, 16);
|
|
XGUnswizzleRect(lock.pBits, 512, 512, NULL, deswizzled, 0, NULL, bpp);
|
|
screen->UnlockRect();
|
|
screen->Release();
|
|
|
|
// copy the screen into a surface of the appropriate size and format
|
|
r.left = 0;
|
|
r.top = 0;
|
|
r.right = 512;
|
|
r.bottom = 480;
|
|
D3DXLoadSurfaceFromMemory(target, NULL, NULL, deswizzled, ddsd.Format,
|
|
512*bpp, NULL, &r, D3DX_DEFAULT, 0);
|
|
Z_Free(deswizzled);
|
|
|
|
// lock the target surface
|
|
target->LockRect(&lock, NULL, D3DLOCK_READONLY);
|
|
|
|
// copy the pixel data
|
|
for (int y = 0; y < theight; ++y)
|
|
{
|
|
memcpy((char*)pixels + twidth * y * 4,
|
|
(char*)lock.pBits + lock.Pitch * y,
|
|
twidth * 4);
|
|
}
|
|
|
|
// all done
|
|
target->UnlockRect();
|
|
target->Release();
|
|
*/
|
|
}
|
|
/**********
|
|
dllCopyBackBufferToTex
|
|
Does a direct copy of the backbuffer to the current texture. The current texture
|
|
must be linear, and it must be 640 x 480 in size. If a more complex copy is
|
|
needed, use dllCopyBackBufferToTexEXT.
|
|
**********/
|
|
static void dllCopyBackBufferToTex()
|
|
{
|
|
glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
|
|
if (info == NULL) return;
|
|
|
|
LPDIRECT3DSURFACE8 surf;
|
|
LPDIRECT3DSURFACE8 backbuffer;
|
|
|
|
info->mipmap->GetSurfaceLevel(0, &surf);
|
|
glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
|
|
|
|
glw_state->device->CopyRects(backbuffer, NULL, 0, surf, NULL);
|
|
|
|
surf->Release();
|
|
backbuffer->Release();
|
|
}
|
|
|
|
/**********
|
|
dllCopyBackBufferToTexEXT
|
|
Copies a portion of the backbuffer to a texture
|
|
If the destination is a DXT1 texture, then the buffer will be compressed
|
|
width - width of the backbuffer polygon rendered to the destination texture
|
|
height - height of the backbuffer polygon rendered to the destination texture
|
|
u,v - describes the potion of the backbuffer to be copied in screen coords
|
|
**********/
|
|
static void dllCopyBackBufferToTexEXT(float width, float height, float u1, float v1, float u2, float v2)
|
|
{
|
|
glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
|
|
if (info == NULL) return;
|
|
|
|
struct QUAD { D3DXVECTOR4 p; FLOAT tu,tv;} q[4];
|
|
q[0].p = D3DXVECTOR4( 0.0f, 0.0f, 1.0f, 1.0f );
|
|
q[0].tu = u1; q[0].tv = v1;
|
|
q[1].p = D3DXVECTOR4( width, 0.0f, 1.0f, 1.0f );
|
|
q[1].tu = u2; q[1].tv = v1;
|
|
q[2].p = D3DXVECTOR4( 0.0f, height , 1.0f, 1.0f );
|
|
q[2].tu = u1; q[2].tv = v2;
|
|
q[3].p = D3DXVECTOR4( width, height, 1.0f, 1.0f );
|
|
q[3].tu = u2; q[3].tv = v2;
|
|
|
|
|
|
LPDIRECT3DSURFACE8 pSurface;
|
|
LPDIRECT3DSURFACE8 pBackBuffer;
|
|
LPDIRECT3DSURFACE8 pStencilBuffer;
|
|
D3DSURFACE_DESC desc;
|
|
D3DBaseTexture* pTexStage0;
|
|
D3DBaseTexture* pTexStage1;
|
|
D3DBaseTexture* pTexStage2;
|
|
D3DBaseTexture* pTexStage3;
|
|
D3DTexture* pRenderTex;
|
|
int w = 0;
|
|
int h = 0;
|
|
|
|
DWORD srcblend, destblend, alphablend, alphatest, zwrite, zenable, vShader, pShader;
|
|
DWORD colorop, colorarg1, addressu, addressv, minfilter, magfilter, colorwriteenable;
|
|
|
|
// save the current state
|
|
glw_state->device->GetRenderState( D3DRS_SRCBLEND, &srcblend );
|
|
glw_state->device->GetRenderState( D3DRS_DESTBLEND, &destblend );
|
|
glw_state->device->GetRenderState( D3DRS_ALPHABLENDENABLE, &alphablend );
|
|
glw_state->device->GetRenderState( D3DRS_ALPHATESTENABLE, &alphatest );
|
|
glw_state->device->GetRenderState( D3DRS_ZWRITEENABLE, &zwrite );
|
|
glw_state->device->GetRenderState( D3DRS_ZENABLE, &zenable );
|
|
glw_state->device->GetRenderState( D3DRS_COLORWRITEENABLE, &colorwriteenable);
|
|
glw_state->device->GetVertexShader( &vShader );
|
|
glw_state->device->GetPixelShader( &pShader );
|
|
glw_state->device->GetTexture(0,&pTexStage0);
|
|
glw_state->device->GetTexture(1,&pTexStage1);
|
|
glw_state->device->GetTexture(2,&pTexStage2);
|
|
glw_state->device->GetTexture(3,&pTexStage3);
|
|
glw_state->device->GetTextureStageState(0, D3DTSS_COLOROP, &colorop);
|
|
glw_state->device->GetTextureStageState(0, D3DTSS_COLORARG1, &colorarg1);
|
|
glw_state->device->GetTextureStageState(0, D3DTSS_ADDRESSU, &addressu);
|
|
glw_state->device->GetTextureStageState(0, D3DTSS_ADDRESSV, &addressv);
|
|
glw_state->device->GetTextureStageState(0, D3DTSS_MINFILTER, &minfilter);
|
|
glw_state->device->GetTextureStageState(0, D3DTSS_MAGFILTER, &magfilter);
|
|
|
|
// get the buffers
|
|
glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
|
|
glw_state->device->GetDepthStencilSurface(&pStencilBuffer);
|
|
|
|
// get a surface desc
|
|
info->mipmap->GetLevelDesc(0, &desc);
|
|
|
|
// check to see if the texture needs to be resized
|
|
if( desc.Width != width || desc.Height != height)
|
|
{
|
|
int refCount;
|
|
refCount = info->mipmap->Release();
|
|
|
|
// Had to remove this. Multiple characters using force push in one
|
|
// frame triggers the assert. Things clean up by the end of the frame.
|
|
// assert(refCount == 0);
|
|
|
|
glw_state->device->CreateTexture( width,
|
|
height,
|
|
1,
|
|
0,
|
|
desc.Format,
|
|
0,
|
|
&info->mipmap );
|
|
}
|
|
|
|
// check to see if we want a compressed output texture
|
|
if( desc.Format == D3DFMT_DXT1)
|
|
{
|
|
|
|
w = desc.Width;
|
|
h = desc.Height;
|
|
|
|
// create a new texture to use as a render target
|
|
glw_state->device->CreateTexture( w,
|
|
h,
|
|
1,
|
|
0,
|
|
D3DFMT_LIN_X8R8G8B8,
|
|
0,
|
|
&pRenderTex );
|
|
}
|
|
else
|
|
{
|
|
pRenderTex = info->mipmap;
|
|
|
|
}
|
|
|
|
// make our current surface a render target
|
|
pRenderTex->GetSurfaceLevel(0, &pSurface);
|
|
glw_state->device->SetRenderTarget( pSurface, NULL );
|
|
|
|
// set texture 0 to the back buffer data
|
|
glw_state->device->SetTexture(0,(LPDIRECT3DTEXTURE8)pBackBuffer);
|
|
|
|
// clear the other texture stages
|
|
glw_state->device->SetTexture(1, NULL);
|
|
glw_state->device->SetTexture(2, NULL);
|
|
glw_state->device->SetTexture(3, NULL);
|
|
|
|
// set the texture 0 state
|
|
glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
|
glw_state->device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
|
glw_state->device->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
|
|
glw_state->device->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
|
|
glw_state->device->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
|
|
glw_state->device->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
|
|
|
|
// set the render state
|
|
glw_state->device->SetRenderState( D3DRS_ZENABLE, FALSE );
|
|
glw_state->device->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
|
|
glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
|
glw_state->device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
|
glw_state->device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCALPHA | D3DBLEND_INVSRCALPHA );
|
|
glw_state->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALL);
|
|
|
|
// set our vertex shader and draw the backbuffer to the texture
|
|
glw_state->device->SetVertexShader( D3DFVF_XYZRHW|D3DFVF_TEX1 );
|
|
glw_state->device->SetPixelShader( NULL );
|
|
glw_state->device->Clear(NULL,NULL,D3DCLEAR_TARGET,D3DCOLOR_COLORVALUE(1.0f, 1.0f, 1.0f, 1.0f), 1.0f, 0);
|
|
glw_state->device->DrawPrimitiveUP( D3DPT_QUADSTRIP, 1, q, sizeof(QUAD) );
|
|
|
|
// now that everything is rendered, check again to see
|
|
// if we want a compressed texture
|
|
if( desc.Format == D3DFMT_DXT1)
|
|
{
|
|
LPDIRECT3DTEXTURE8 pSrcTex;
|
|
LPDIRECT3DTEXTURE8 pDstTex;
|
|
D3DLOCKED_RECT srcLock;
|
|
D3DLOCKED_RECT dstLock;
|
|
|
|
pSrcTex = pRenderTex;
|
|
pDstTex = info->mipmap;
|
|
|
|
// lock our textures
|
|
pSrcTex->LockRect(0, &srcLock, NULL, 0);
|
|
pDstTex->LockRect(0, &dstLock, NULL, 0);
|
|
|
|
// compress the texture
|
|
XGCompressRect( dstLock.pBits,
|
|
D3DFMT_DXT1,
|
|
dstLock.Pitch,
|
|
w,
|
|
h,
|
|
srcLock.pBits,
|
|
D3DFMT_LIN_X8R8G8B8,
|
|
srcLock.Pitch,
|
|
1,
|
|
0 );
|
|
|
|
// unlock
|
|
pSrcTex->UnlockRect(0);
|
|
pDstTex->UnlockRect(0);
|
|
|
|
// release the render texture
|
|
pRenderTex->Release();
|
|
}
|
|
|
|
// return our state
|
|
glw_state->device->SetRenderState( D3DRS_SRCBLEND, srcblend );
|
|
glw_state->device->SetRenderState( D3DRS_DESTBLEND, destblend );
|
|
glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, alphablend );
|
|
glw_state->device->SetRenderState( D3DRS_ALPHATESTENABLE, alphatest );
|
|
glw_state->device->SetRenderState( D3DRS_ZWRITEENABLE, zwrite );
|
|
glw_state->device->SetRenderState( D3DRS_ZENABLE, zenable );
|
|
glw_state->device->SetRenderState( D3DRS_COLORWRITEENABLE, colorwriteenable);
|
|
|
|
glw_state->device->SetTexture(0,pTexStage0);
|
|
glw_state->device->SetTexture(1,pTexStage1);
|
|
glw_state->device->SetTexture(2,pTexStage2);
|
|
glw_state->device->SetTexture(3,pTexStage3);
|
|
glw_state->device->SetTextureStageState(0, D3DTSS_COLOROP, colorop);
|
|
glw_state->device->SetTextureStageState(0, D3DTSS_COLORARG1, colorarg1);
|
|
glw_state->device->SetTextureStageState(0, D3DTSS_ADDRESSU, addressu);
|
|
glw_state->device->SetTextureStageState(0, D3DTSS_ADDRESSV, addressv);
|
|
glw_state->device->SetTextureStageState(0, D3DTSS_MINFILTER, minfilter);
|
|
glw_state->device->SetTextureStageState(0, D3DTSS_MAGFILTER, magfilter);
|
|
|
|
glw_state->device->SetVertexShader( vShader );
|
|
glw_state->device->SetPixelShader( pShader );
|
|
|
|
glw_state->device->SetRenderTarget( pBackBuffer, pStencilBuffer );
|
|
|
|
// release our surfaces/textures
|
|
if(pTexStage0)
|
|
pTexStage0->Release();
|
|
|
|
if(pTexStage1)
|
|
pTexStage1->Release();
|
|
|
|
if(pTexStage2)
|
|
pTexStage2->Release();
|
|
|
|
if(pTexStage3)
|
|
pTexStage3->Release();
|
|
|
|
pSurface->Release();
|
|
pBackBuffer->Release();
|
|
pStencilBuffer->Release();
|
|
}
|
|
|
|
static void dllRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRectdv(const GLdouble *v1, const GLdouble *v2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRectfv(const GLfloat *v1, const GLfloat *v2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRecti(GLint x1, GLint y1, GLint x2, GLint y2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRectiv(const GLint *v1, const GLint *v2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRectsv(const GLshort *v1, const GLshort *v2)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
GLint dllRenderMode(GLenum mode)
|
|
{
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
static void dllRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
D3DXVECTOR3 v(x, y, z);
|
|
glw_state->matrixStack[glw_state->matrixMode]->RotateAxisLocal(&v, angle);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllScaled(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllScalef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->Scale(x, y, z);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void dllScissor(GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
#ifdef _XBOX
|
|
_fixupScreenCoords(x, y, width, height);
|
|
|
|
glw_state->scissorBox.x1 = x;
|
|
glw_state->scissorBox.y1 = y;
|
|
glw_state->scissorBox.x2 = x + width;
|
|
glw_state->scissorBox.y2 = y + height;
|
|
|
|
if (glw_state->scissorEnable)
|
|
{
|
|
glw_state->device->SetScissors(1, FALSE, &glw_state->scissorBox);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void dllSelectBuffer(GLsizei size, GLuint *buffer)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllShadeModel(GLenum mode)
|
|
{
|
|
D3DSHADEMODE m;
|
|
switch (mode)
|
|
{
|
|
case GL_FLAT: m = D3DSHADE_FLAT; break;
|
|
case GL_SMOOTH: default: m = D3DSHADE_GOURAUD; break;
|
|
}
|
|
|
|
glw_state->device->SetRenderState(D3DRS_SHADEMODE, m);
|
|
}
|
|
|
|
static void dllStencilFunc(GLenum func, GLint ref, GLuint mask)
|
|
{
|
|
D3DCMPFUNC f = _convertCompare(func);
|
|
|
|
glw_state->device->SetRenderState(D3DRS_STENCILFUNC, f);
|
|
glw_state->device->SetRenderState(D3DRS_STENCILREF, ref);
|
|
glw_state->device->SetRenderState(D3DRS_STENCILMASK, mask);
|
|
}
|
|
|
|
static void dllStencilMask(GLuint mask)
|
|
{
|
|
glw_state->device->SetRenderState(D3DRS_STENCILWRITEMASK, mask);
|
|
}
|
|
|
|
static D3DSTENCILOP _convertStencilOp(GLenum op)
|
|
{
|
|
switch (op)
|
|
{
|
|
default: case GL_KEEP: return D3DSTENCILOP_KEEP;
|
|
case GL_ZERO: return D3DSTENCILOP_ZERO;
|
|
case GL_REPLACE: return D3DSTENCILOP_REPLACE;
|
|
case GL_INCR: return D3DSTENCILOP_INCR;
|
|
case GL_DECR: return D3DSTENCILOP_DECR;
|
|
case GL_INVERT: return D3DSTENCILOP_INVERT;
|
|
}
|
|
}
|
|
|
|
static void dllStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
|
|
{
|
|
D3DSTENCILOP f = _convertStencilOp(fail);
|
|
D3DSTENCILOP zf = _convertStencilOp(zfail);
|
|
D3DSTENCILOP zp = _convertStencilOp(zpass);
|
|
|
|
glw_state->device->SetRenderState(D3DRS_STENCILFAIL, f);
|
|
glw_state->device->SetRenderState(D3DRS_STENCILZFAIL, zf);
|
|
glw_state->device->SetRenderState(D3DRS_STENCILPASS, zp);
|
|
}
|
|
|
|
static void dllTexCoord1d(GLdouble s)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1f(GLfloat s)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1fv(const GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1i(GLint s)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1s(GLshort s)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord1sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void setTexCoord(float s, float t)
|
|
{
|
|
assert(glw_state->inDrawBlock);
|
|
|
|
_handleDrawOverflow();
|
|
|
|
int off = 0;
|
|
if(glw_state->normalArrayState)
|
|
off = 3;
|
|
|
|
DWORD* push = &glw_state->drawArray[
|
|
glw_state->numVertices * glw_state->drawStride +
|
|
4 + off + glw_state->serverTU * 2];
|
|
|
|
*push++ = *((DWORD*)&s);
|
|
*push++ = *((DWORD*)&t);
|
|
}
|
|
|
|
static void dllTexCoord2d(GLdouble s, GLdouble t)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord2dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord2f(GLfloat s, GLfloat t)
|
|
{
|
|
setTexCoord(s, t);
|
|
}
|
|
|
|
static void dllTexCoord2fv(const GLfloat *v)
|
|
{
|
|
setTexCoord(v[0], v[1]);
|
|
}
|
|
|
|
static void dllTexCoord2i(GLint s, GLint t)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord2iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord2s(GLshort s, GLshort t)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord2sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3fv(const GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3i(GLint s, GLint t, GLint r)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3s(GLshort s, GLshort t, GLshort r)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord3sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4fv(const GLfloat *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4i(GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoord4sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(size == 2 && type == GL_FLOAT);
|
|
|
|
stride = (stride == 0) ? (sizeof(GLfloat) * 2) : stride;
|
|
|
|
glw_state->texCoordPointer[glw_state->clientTU] = pointer;
|
|
glw_state->texCoordStride[glw_state->clientTU] = stride;
|
|
}
|
|
|
|
static void dllTexEnvf(GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
qglTexEnvi(target, pname, (GLint)param);
|
|
}
|
|
|
|
static void dllTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexEnvi(GLenum target, GLenum pname, GLint param)
|
|
{
|
|
assert(target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_MODE);
|
|
|
|
/*glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
|
|
if (!info) return;*/
|
|
|
|
D3DTEXTUREOP env;
|
|
switch (param)
|
|
{
|
|
case GL_MODULATE: default: env = D3DTOP_MODULATE; break;
|
|
case GL_REPLACE: env = D3DTOP_SELECTARG1; break;
|
|
// MATT! - I use GL_DECAL as the bumpmapping state
|
|
case GL_DECAL: env = D3DTOP_DOTPRODUCT3; break;
|
|
case GL_ADD: env = D3DTOP_ADD; break;
|
|
case GL_NONE: env = D3DTOP_DISABLE; break;
|
|
}
|
|
|
|
if (glw_state->textureEnv[glw_state->serverTU] != env)
|
|
{
|
|
glw_state->textureEnv[glw_state->serverTU] = env;
|
|
glw_state->textureStageDirty[glw_state->serverTU] = true;
|
|
}
|
|
}
|
|
|
|
static void dllTexEnviv(GLenum target, GLenum pname, const GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexGend(GLenum coord, GLenum pname, GLdouble param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexGenf(GLenum coord, GLenum pname, GLfloat param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexGeni(GLenum coord, GLenum pname, GLint param)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexGeniv(GLenum coord, GLenum pname, const GLint *params)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void _d3d_check(HRESULT err, const char* func)
|
|
{
|
|
if (err != D3D_OK)
|
|
{
|
|
MEMORYSTATUS status;
|
|
GlobalMemoryStatus(&status);
|
|
Sys_Print(va("%s returned %d! Memfree=%d\n", func, err, status.dwAvailPhys));
|
|
}
|
|
}
|
|
|
|
static void _texImageDDS(glwstate_t::TextureInfo* info, GLint numlevels, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels)
|
|
{
|
|
_d3d_check(D3DXCreateTextureFromFileInMemoryEx(glw_state->device,
|
|
pixels,
|
|
Z_Size(const_cast<void*>(pixels)),
|
|
width,
|
|
height,
|
|
numlevels,
|
|
0,
|
|
D3DFMT_UNKNOWN,
|
|
D3DPOOL_MANAGED,
|
|
D3DX_DEFAULT,
|
|
D3DX_DEFAULT,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&info->mipmap),
|
|
"D3DXCreateTextureFromFileInMemoryEx");
|
|
}
|
|
|
|
static void _texImageRGBA(glwstate_t::TextureInfo* info, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels)
|
|
{
|
|
IDirect3DSurface8 *pSurf = NULL;
|
|
D3DFORMAT f;
|
|
float bpp;
|
|
int pitch;
|
|
RECT srcRect;
|
|
|
|
srcRect.top = 0;
|
|
srcRect.left = 0;
|
|
srcRect.right = width;
|
|
srcRect.bottom = height;
|
|
|
|
switch(format)
|
|
{
|
|
case GL_RGB:
|
|
f = D3DFMT_X8R8G8B8;
|
|
bpp = 3;
|
|
break;
|
|
|
|
case GL_RGBA:
|
|
f = D3DFMT_A8R8G8B8;
|
|
bpp = 4;
|
|
break;
|
|
|
|
case GL_LIN_RGBA:
|
|
f = D3DFMT_LIN_A8R8G8B8;
|
|
bpp = 4;
|
|
break;
|
|
|
|
case GL_LIN_RGB:
|
|
f = D3DFMT_LIN_X8R8G8B8;
|
|
bpp = 4;
|
|
break;
|
|
|
|
case GL_LIN_RGB8:
|
|
f = D3DFMT_LIN_X8R8G8B8;
|
|
bpp = 4;
|
|
break;
|
|
|
|
case GL_RGB8:
|
|
f = D3DFMT_X8R8G8B8;
|
|
bpp = 4;
|
|
break;
|
|
|
|
case GL_RGB_SWIZZLE_EXT:
|
|
f = D3DFMT_R5G6B5;
|
|
bpp = 2;
|
|
break;
|
|
|
|
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
|
|
f = D3DFMT_DXT1;
|
|
bpp = 0.5;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
|
|
_d3d_check(glw_state->device->CreateImageSurface(width, height, f, &pSurf),
|
|
"CreateImageSurface");
|
|
|
|
pitch = (int)((float)width * bpp);
|
|
|
|
_d3d_check(D3DXLoadSurfaceFromMemory(pSurf,
|
|
NULL,
|
|
NULL,
|
|
(LPCVOID)pixels,
|
|
f,
|
|
pitch,
|
|
NULL,
|
|
&srcRect,
|
|
D3DX_FILTER_NONE,
|
|
0),
|
|
"D3DXLoadSurfaceFromMemory");
|
|
|
|
switch(internalformat)
|
|
{
|
|
case GL_RGB5:
|
|
case GL_RGB4_S3TC:
|
|
f = D3DFMT_R5G6B5;
|
|
break;
|
|
|
|
case GL_RGBA4:
|
|
f = D3DFMT_A4R4G4B4;
|
|
break;
|
|
|
|
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
|
|
f = D3DFMT_DXT1;
|
|
break;
|
|
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
|
|
f = D3DFMT_DXT5;
|
|
break;
|
|
|
|
case GL_RGB8:
|
|
case 3:
|
|
f = D3DFMT_X8R8G8B8;
|
|
break;
|
|
|
|
case GL_LIN_RGBA8:
|
|
f = D3DFMT_LIN_A8R8G8B8;
|
|
break;
|
|
case GL_LIN_RGB8:
|
|
f = D3DFMT_LIN_X8R8G8B8;
|
|
break;
|
|
|
|
case GL_RGBA8:
|
|
case 4:
|
|
f = D3DFMT_A8R8G8B8;
|
|
break;
|
|
case GL_RGB:
|
|
f = D3DFMT_X8R8G8B8;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
|
|
_d3d_check(D3DXCreateTexture(glw_state->device,
|
|
width,
|
|
height,
|
|
numlevels,
|
|
0,
|
|
f,
|
|
D3DPOOL_MANAGED,
|
|
&info->mipmap),
|
|
"D3DXCreateTexture");
|
|
|
|
LPDIRECT3DSURFACE8 txtSurf;
|
|
_d3d_check(info->mipmap->GetSurfaceLevel(0, &txtSurf),
|
|
"GetSurfaceLevel");
|
|
|
|
_d3d_check(D3DXLoadSurfaceFromSurface(txtSurf, NULL, NULL,
|
|
pSurf, NULL, NULL, D3DX_DEFAULT, 0),
|
|
"D3DXLoadSurfaceFromSurface");
|
|
|
|
txtSurf->Release();
|
|
pSurf->Release();
|
|
|
|
if(numlevels > 1)
|
|
{
|
|
_d3d_check(D3DXFilterTexture(info->mipmap,
|
|
NULL,
|
|
D3DX_DEFAULT,
|
|
D3DX_DEFAULT),
|
|
"D3DXFilterTexture");
|
|
}
|
|
}
|
|
|
|
// EXTENSION: glTexImage2D plus "numlevels" number of mipmaps
|
|
static void dllTexImage2DEXT(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
assert(target == GL_TEXTURE_2D && border == 0 && type == GL_UNSIGNED_BYTE);
|
|
|
|
// In Direct3D, setting 0 for number of mipmap
|
|
// levels means create the whole chain....
|
|
/*if(numlevels == 0)
|
|
numlevels = 1;*/
|
|
|
|
glwstate_t::TextureInfo* info;
|
|
|
|
glwstate_t::texturexlat_t::iterator current =
|
|
glw_state->textureXlat.find(
|
|
glw_state->currentTexture[glw_state->serverTU]);
|
|
|
|
// If we already have a texture bound to this ID, remove it.
|
|
if (current != glw_state->textureXlat.end())
|
|
{
|
|
info = ¤t->second;
|
|
info->mipmap->Release();
|
|
}
|
|
// Otherwise, initialize it.
|
|
else
|
|
{
|
|
info = &glw_state->textureXlat[
|
|
glw_state->currentTexture[glw_state->serverTU]];
|
|
|
|
info->minFilter = D3DTEXF_NONE;
|
|
info->mipFilter = D3DTEXF_NONE;
|
|
info->magFilter = D3DTEXF_NONE;
|
|
info->anisotropy = 1.f;
|
|
info->wrapU = D3DTADDRESS_CLAMP;
|
|
info->wrapV = D3DTADDRESS_CLAMP;
|
|
|
|
glw_state->textureStageDirty[glw_state->serverTU] = true;
|
|
}
|
|
|
|
// force any DX allocs to temp memory
|
|
Z_SetNewDeleteTemporary(true);
|
|
|
|
if (format == GL_DDS1_EXT ||
|
|
format == GL_DDS5_EXT ||
|
|
format == GL_DDS_RGB16_EXT ||
|
|
format == GL_DDS_RGBA32_EXT)
|
|
{
|
|
_texImageDDS(info, numlevels, width, height, format, pixels);
|
|
}
|
|
else
|
|
{
|
|
_texImageRGBA(info, numlevels,
|
|
internalformat, width, height,
|
|
format, pixels);
|
|
}
|
|
|
|
// Done DX calls to new and delete
|
|
Z_SetNewDeleteTemporary(false);
|
|
|
|
#if MEMORY_PROFILE
|
|
texMemSize += getTexMemSize(info->mipmap);
|
|
#endif
|
|
}
|
|
|
|
static void dllTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
dllTexImage2DEXT(target, level, 1, internalformat, width, height, border, format, type, pixels);
|
|
}
|
|
|
|
static void dllTexParameteri(GLenum target, GLenum pname, GLint param)
|
|
{
|
|
assert(target == GL_TEXTURE_2D);
|
|
|
|
if (glw_state->currentTexture[glw_state->serverTU] == 0) return;
|
|
|
|
glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
|
|
if (!info) return;
|
|
|
|
glw_state->textureStageDirty[glw_state->serverTU] = true;
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_TEXTURE_MIN_FILTER:
|
|
switch (param)
|
|
{
|
|
case GL_NEAREST:
|
|
info->minFilter = D3DTEXF_POINT;
|
|
info->mipFilter = D3DTEXF_NONE;
|
|
break;
|
|
case GL_LINEAR:
|
|
info->minFilter = D3DTEXF_LINEAR;
|
|
info->mipFilter = D3DTEXF_NONE;
|
|
break;
|
|
case GL_NEAREST_MIPMAP_NEAREST:
|
|
info->minFilter = D3DTEXF_POINT;
|
|
info->mipFilter = D3DTEXF_POINT;
|
|
break;
|
|
case GL_LINEAR_MIPMAP_NEAREST:
|
|
info->minFilter = D3DTEXF_LINEAR;
|
|
info->mipFilter = D3DTEXF_POINT;
|
|
break;
|
|
case GL_NEAREST_MIPMAP_LINEAR:
|
|
info->minFilter = D3DTEXF_POINT;
|
|
info->mipFilter = D3DTEXF_LINEAR;
|
|
break;
|
|
case GL_LINEAR_MIPMAP_LINEAR:
|
|
info->minFilter = D3DTEXF_LINEAR;
|
|
info->mipFilter = D3DTEXF_LINEAR;
|
|
break;
|
|
}
|
|
info->anisotropy = 1.f;
|
|
break;
|
|
case GL_TEXTURE_MAG_FILTER:
|
|
switch (param)
|
|
{
|
|
case GL_NEAREST:
|
|
info->magFilter = D3DTEXF_POINT;
|
|
break;
|
|
case GL_LINEAR:
|
|
info->magFilter = D3DTEXF_LINEAR;
|
|
break;
|
|
}
|
|
info->anisotropy = 1.f;
|
|
break;
|
|
case GL_TEXTURE_WRAP_S:
|
|
switch (param)
|
|
{
|
|
case GL_REPEAT: info->wrapU = D3DTADDRESS_WRAP; break;
|
|
case GL_CLAMP: info->wrapU = D3DTADDRESS_CLAMP; break;
|
|
}
|
|
break;
|
|
case GL_TEXTURE_WRAP_T:
|
|
switch (param)
|
|
{
|
|
case GL_REPEAT: info->wrapV = D3DTADDRESS_WRAP; break;
|
|
case GL_CLAMP: info->wrapV = D3DTADDRESS_CLAMP; break;
|
|
}
|
|
break;
|
|
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
|
|
info->anisotropy = (float)param;
|
|
info->minFilter = D3DTEXF_ANISOTROPIC;
|
|
info->magFilter = D3DTEXF_ANISOTROPIC;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void dllTexParameterf(GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
dllTexParameteri(target, pname, param);
|
|
}
|
|
|
|
static void dllTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
// Intentionally left blank
|
|
}
|
|
|
|
static void dllTexParameteriv(GLenum target, GLenum pname, const GLint *params)
|
|
{
|
|
// Intentionally left blank
|
|
}
|
|
|
|
static void dllTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
assert(target == GL_TEXTURE_2D && level == 0 && type == GL_UNSIGNED_BYTE);
|
|
|
|
glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
|
|
if (info == NULL) return;
|
|
|
|
RECT sr;
|
|
sr.top = 0;
|
|
sr.left = 0;
|
|
sr.right = width;
|
|
sr.bottom = height;
|
|
|
|
RECT dr;
|
|
dr.top = xoffset;
|
|
dr.left = yoffset;
|
|
dr.right = xoffset + width;
|
|
dr.bottom = yoffset + height;
|
|
|
|
Z_SetNewDeleteTemporary(true);
|
|
|
|
LPDIRECT3DSURFACE8 surf;
|
|
info->mipmap->GetSurfaceLevel(0, &surf);
|
|
|
|
// We use the supplied format to handle pixel data correctly, the way OGL would
|
|
D3DFORMAT srcFormat;
|
|
switch(format)
|
|
{
|
|
case GL_RGB:
|
|
srcFormat = D3DFMT_LIN_X8R8G8B8;
|
|
break;
|
|
|
|
case GL_RGBA:
|
|
srcFormat = D3DFMT_LIN_A8R8G8B8;
|
|
break;
|
|
|
|
default:
|
|
assert(0 && "Unsupported format in dllTexSubImage2D");
|
|
return;
|
|
}
|
|
|
|
D3DXLoadSurfaceFromMemory(surf, NULL, &dr, pixels,
|
|
srcFormat, width * 4, NULL, &sr, D3DX_DEFAULT, 0);
|
|
|
|
surf->Release();
|
|
|
|
Z_SetNewDeleteTemporary(false);
|
|
}
|
|
|
|
static void dllTranslated(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllTranslatef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
glw_state->matrixStack[glw_state->matrixMode]->TranslateLocal(x, y, z);
|
|
glw_state->matricesDirty[glw_state->matrixMode] = true;
|
|
}
|
|
|
|
static void setVertex(float x, float y, float z)
|
|
{
|
|
assert(glw_state->inDrawBlock);
|
|
|
|
_handleDrawOverflow();
|
|
|
|
DWORD* push = &glw_state->drawArray[glw_state->numVertices * glw_state->drawStride];
|
|
push[0] = *((DWORD*)&x);
|
|
push[1] = *((DWORD*)&y);
|
|
push[2] = *((DWORD*)&z);
|
|
push[3] = glw_state->currentColor;
|
|
|
|
++glw_state->numVertices;
|
|
}
|
|
|
|
static void dllVertex2d(GLdouble x, GLdouble y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex2dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex2f(GLfloat x, GLfloat y)
|
|
{
|
|
setVertex(x, y, 0.f);
|
|
}
|
|
|
|
static void dllVertex2fv(const GLfloat *v)
|
|
{
|
|
setVertex(v[0], v[1], 0.f);
|
|
}
|
|
|
|
static void dllVertex2i(GLint x, GLint y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex2iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex2s(GLshort x, GLshort y)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex2sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex3dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
setVertex(x, y, z);
|
|
}
|
|
|
|
static void dllVertex3fv(const GLfloat *v)
|
|
{
|
|
setVertex(v[0], v[1], v[2]);
|
|
}
|
|
|
|
static void dllVertex3i(GLint x, GLint y, GLint z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex3iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex3sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex4dv(const GLdouble *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
setVertex(x, y, z);
|
|
}
|
|
|
|
static void dllVertex4fv(const GLfloat *v)
|
|
{
|
|
setVertex(v[0], v[1], v[2]);
|
|
}
|
|
|
|
static void dllVertex4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex4iv(const GLint *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertex4sv(const GLshort *v)
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static void dllVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
assert(size == 3 && type == GL_FLOAT);
|
|
|
|
stride = (stride == 0) ? (sizeof(GLfloat) * 3) : stride;
|
|
|
|
glw_state->vertexPointer = pointer;
|
|
glw_state->vertexStride = stride;
|
|
}
|
|
|
|
static void dllViewport(GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
_fixupScreenCoords(x, y, width, height);
|
|
|
|
glw_state->viewport.X = x;
|
|
glw_state->viewport.Y = y;
|
|
glw_state->viewport.Width = width;
|
|
glw_state->viewport.Height = height;
|
|
glw_state->device->SetViewport(&glw_state->viewport);
|
|
}
|
|
|
|
|
|
static void dllMultiTexCoord2fARB(GLenum texture, GLfloat s, GLfloat t)
|
|
{
|
|
assert(glw_state->inDrawBlock);
|
|
|
|
_handleDrawOverflow();
|
|
|
|
DWORD* push = &glw_state->drawArray[
|
|
glw_state->numVertices * glw_state->drawStride +
|
|
4 + (texture - GL_TEXTURE0_ARB) * 2];
|
|
|
|
*push++ = *((DWORD*)&s);
|
|
*push++ = *((DWORD*)&t);
|
|
}
|
|
|
|
static void dllActiveTextureARB(GLenum texture)
|
|
{
|
|
assert(GLW_MAX_TEXTURE_STAGES > texture - GL_TEXTURE0_ARB);
|
|
glw_state->serverTU = texture - GL_TEXTURE0_ARB;
|
|
}
|
|
|
|
static void dllClientActiveTextureARB(GLenum texture)
|
|
{
|
|
assert(GLW_MAX_TEXTURE_STAGES > texture - GL_TEXTURE0_ARB);
|
|
glw_state->clientTU = texture - GL_TEXTURE0_ARB;
|
|
}
|
|
|
|
|
|
/*
|
|
** QGL_Shutdown
|
|
**
|
|
** Unloads the specified DLL then nulls out all the proc pointers. This
|
|
** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).
|
|
*/
|
|
void QGL_Shutdown( void )
|
|
{
|
|
VID_Printf( PRINT_ALL, "...shutting down QGL\n" );
|
|
|
|
qglAccum = NULL;
|
|
qglAlphaFunc = NULL;
|
|
qglAreTexturesResident = NULL;
|
|
qglArrayElement = NULL;
|
|
qglBegin = NULL;
|
|
qglBeginEXT = NULL;
|
|
qglBeginFrame = NULL;
|
|
qglBeginShadow = NULL;
|
|
qglBindTexture = NULL;
|
|
qglBitmap = NULL;
|
|
qglBlendFunc = NULL;
|
|
qglCallList = NULL;
|
|
qglCallLists = NULL;
|
|
qglClear = NULL;
|
|
qglClearAccum = NULL;
|
|
qglClearColor = NULL;
|
|
qglClearDepth = NULL;
|
|
qglClearIndex = NULL;
|
|
qglClearStencil = NULL;
|
|
qglClipPlane = NULL;
|
|
qglColor3b = NULL;
|
|
qglColor3bv = NULL;
|
|
qglColor3d = NULL;
|
|
qglColor3dv = NULL;
|
|
qglColor3f = NULL;
|
|
qglColor3fv = NULL;
|
|
qglColor3i = NULL;
|
|
qglColor3iv = NULL;
|
|
qglColor3s = NULL;
|
|
qglColor3sv = NULL;
|
|
qglColor3ub = NULL;
|
|
qglColor3ubv = NULL;
|
|
qglColor3ui = NULL;
|
|
qglColor3uiv = NULL;
|
|
qglColor3us = NULL;
|
|
qglColor3usv = NULL;
|
|
qglColor4b = NULL;
|
|
qglColor4bv = NULL;
|
|
qglColor4d = NULL;
|
|
qglColor4dv = NULL;
|
|
qglColor4f = NULL;
|
|
qglColor4fv = NULL;
|
|
qglColor4i = NULL;
|
|
qglColor4iv = NULL;
|
|
qglColor4s = NULL;
|
|
qglColor4sv = NULL;
|
|
qglColor4ub = NULL;
|
|
qglColor4ubv = NULL;
|
|
qglColor4ui = NULL;
|
|
qglColor4uiv = NULL;
|
|
qglColor4us = NULL;
|
|
qglColor4usv = NULL;
|
|
qglColorMask = NULL;
|
|
qglColorMaterial = NULL;
|
|
qglColorPointer = NULL;
|
|
qglCopyPixels = NULL;
|
|
qglCopyTexImage1D = NULL;
|
|
qglCopyTexImage2D = NULL;
|
|
qglCopyTexSubImage1D = NULL;
|
|
qglCopyTexSubImage2D = NULL;
|
|
qglCullFace = NULL;
|
|
qglDeleteLists = NULL;
|
|
qglDeleteTextures = NULL;
|
|
qglDepthFunc = NULL;
|
|
qglDepthMask = NULL;
|
|
qglDepthRange = NULL;
|
|
qglDisable = NULL;
|
|
qglDisableClientState = NULL;
|
|
qglDrawArrays = NULL;
|
|
qglDrawBuffer = NULL;
|
|
qglDrawElements = NULL;
|
|
qglDrawPixels = NULL;
|
|
qglEdgeFlag = NULL;
|
|
qglEdgeFlagPointer = NULL;
|
|
qglEdgeFlagv = NULL;
|
|
qglEnable = NULL;
|
|
qglEnableClientState = NULL;
|
|
qglEnd = NULL;
|
|
qglEndFrame = NULL;
|
|
qglEndShadow = NULL;
|
|
qglEndList = NULL;
|
|
qglEvalCoord1d = NULL;
|
|
qglEvalCoord1dv = NULL;
|
|
qglEvalCoord1f = NULL;
|
|
qglEvalCoord1fv = NULL;
|
|
qglEvalCoord2d = NULL;
|
|
qglEvalCoord2dv = NULL;
|
|
qglEvalCoord2f = NULL;
|
|
qglEvalCoord2fv = NULL;
|
|
qglEvalMesh1 = NULL;
|
|
qglEvalMesh2 = NULL;
|
|
qglEvalPoint1 = NULL;
|
|
qglEvalPoint2 = NULL;
|
|
qglFeedbackBuffer = NULL;
|
|
qglFinish = NULL;
|
|
qglFlush = NULL;
|
|
qglFlushShadow = NULL;
|
|
qglFogf = NULL;
|
|
qglFogfv = NULL;
|
|
qglFogi = NULL;
|
|
qglFogiv = NULL;
|
|
qglFrontFace = NULL;
|
|
qglFrustum = NULL;
|
|
qglGenLists = NULL;
|
|
qglGenTextures = NULL;
|
|
qglGetBooleanv = NULL;
|
|
qglGetClipPlane = NULL;
|
|
qglGetDoublev = NULL;
|
|
qglGetError = NULL;
|
|
qglGetFloatv = NULL;
|
|
qglGetIntegerv = NULL;
|
|
qglGetLightfv = NULL;
|
|
qglGetLightiv = NULL;
|
|
qglGetMapdv = NULL;
|
|
qglGetMapfv = NULL;
|
|
qglGetMapiv = NULL;
|
|
qglGetMaterialfv = NULL;
|
|
qglGetMaterialiv = NULL;
|
|
qglGetPixelMapfv = NULL;
|
|
qglGetPixelMapuiv = NULL;
|
|
qglGetPixelMapusv = NULL;
|
|
qglGetPointerv = NULL;
|
|
qglGetPolygonStipple = NULL;
|
|
qglGetString = NULL;
|
|
qglGetTexEnvfv = NULL;
|
|
qglGetTexEnviv = NULL;
|
|
qglGetTexGendv = NULL;
|
|
qglGetTexGenfv = NULL;
|
|
qglGetTexGeniv = NULL;
|
|
qglGetTexImage = NULL;
|
|
qglGetTexLevelParameterfv = NULL;
|
|
qglGetTexLevelParameteriv = NULL;
|
|
qglGetTexParameterfv = NULL;
|
|
qglGetTexParameteriv = NULL;
|
|
qglHint = NULL;
|
|
qglIndexedTriToStrip = NULL;
|
|
qglIndexMask = NULL;
|
|
qglIndexPointer = NULL;
|
|
qglIndexd = NULL;
|
|
qglIndexdv = NULL;
|
|
qglIndexf = NULL;
|
|
qglIndexfv = NULL;
|
|
qglIndexi = NULL;
|
|
qglIndexiv = NULL;
|
|
qglIndexs = NULL;
|
|
qglIndexsv = NULL;
|
|
qglIndexub = NULL;
|
|
qglIndexubv = NULL;
|
|
qglInitNames = NULL;
|
|
qglInterleavedArrays = NULL;
|
|
qglIsEnabled = NULL;
|
|
qglIsList = NULL;
|
|
qglIsTexture = NULL;
|
|
qglLightModelf = NULL;
|
|
qglLightModelfv = NULL;
|
|
qglLightModeli = NULL;
|
|
qglLightModeliv = NULL;
|
|
qglLightf = NULL;
|
|
qglLightfv = NULL;
|
|
qglLighti = NULL;
|
|
qglLightiv = NULL;
|
|
qglLineStipple = NULL;
|
|
qglLineWidth = NULL;
|
|
qglListBase = NULL;
|
|
qglLoadIdentity = NULL;
|
|
qglLoadMatrixd = NULL;
|
|
qglLoadMatrixf = NULL;
|
|
qglLoadName = NULL;
|
|
qglLogicOp = NULL;
|
|
qglMap1d = NULL;
|
|
qglMap1f = NULL;
|
|
qglMap2d = NULL;
|
|
qglMap2f = NULL;
|
|
qglMapGrid1d = NULL;
|
|
qglMapGrid1f = NULL;
|
|
qglMapGrid2d = NULL;
|
|
qglMapGrid2f = NULL;
|
|
qglMaterialf = NULL;
|
|
qglMaterialfv = NULL;
|
|
qglMateriali = NULL;
|
|
qglMaterialiv = NULL;
|
|
qglMatrixMode = NULL;
|
|
qglMultMatrixd = NULL;
|
|
qglMultMatrixf = NULL;
|
|
qglNewList = NULL;
|
|
qglNormal3b = NULL;
|
|
qglNormal3bv = NULL;
|
|
qglNormal3d = NULL;
|
|
qglNormal3dv = NULL;
|
|
qglNormal3f = NULL;
|
|
qglNormal3fv = NULL;
|
|
qglNormal3i = NULL;
|
|
qglNormal3iv = NULL;
|
|
qglNormal3s = NULL;
|
|
qglNormal3sv = NULL;
|
|
qglNormalPointer = NULL;
|
|
qglOrtho = NULL;
|
|
qglPassThrough = NULL;
|
|
qglPixelMapfv = NULL;
|
|
qglPixelMapuiv = NULL;
|
|
qglPixelMapusv = NULL;
|
|
qglPixelStoref = NULL;
|
|
qglPixelStorei = NULL;
|
|
qglPixelTransferf = NULL;
|
|
qglPixelTransferi = NULL;
|
|
qglPixelZoom = NULL;
|
|
qglPointSize = NULL;
|
|
qglPolygonMode = NULL;
|
|
qglPolygonOffset = NULL;
|
|
qglPolygonStipple = NULL;
|
|
qglPopAttrib = NULL;
|
|
qglPopClientAttrib = NULL;
|
|
qglPopMatrix = NULL;
|
|
qglPopName = NULL;
|
|
qglPrioritizeTextures = NULL;
|
|
qglPushAttrib = NULL;
|
|
qglPushClientAttrib = NULL;
|
|
qglPushMatrix = NULL;
|
|
qglPushName = NULL;
|
|
qglRasterPos2d = NULL;
|
|
qglRasterPos2dv = NULL;
|
|
qglRasterPos2f = NULL;
|
|
qglRasterPos2fv = NULL;
|
|
qglRasterPos2i = NULL;
|
|
qglRasterPos2iv = NULL;
|
|
qglRasterPos2s = NULL;
|
|
qglRasterPos2sv = NULL;
|
|
qglRasterPos3d = NULL;
|
|
qglRasterPos3dv = NULL;
|
|
qglRasterPos3f = NULL;
|
|
qglRasterPos3fv = NULL;
|
|
qglRasterPos3i = NULL;
|
|
qglRasterPos3iv = NULL;
|
|
qglRasterPos3s = NULL;
|
|
qglRasterPos3sv = NULL;
|
|
qglRasterPos4d = NULL;
|
|
qglRasterPos4dv = NULL;
|
|
qglRasterPos4f = NULL;
|
|
qglRasterPos4fv = NULL;
|
|
qglRasterPos4i = NULL;
|
|
qglRasterPos4iv = NULL;
|
|
qglRasterPos4s = NULL;
|
|
qglRasterPos4sv = NULL;
|
|
qglReadBuffer = NULL;
|
|
qglReadPixels = NULL;
|
|
qglRectd = NULL;
|
|
qglRectdv = NULL;
|
|
qglRectf = NULL;
|
|
qglRectfv = NULL;
|
|
qglRecti = NULL;
|
|
qglRectiv = NULL;
|
|
qglRects = NULL;
|
|
qglRectsv = NULL;
|
|
qglRenderMode = NULL;
|
|
qglRotated = NULL;
|
|
qglRotatef = NULL;
|
|
qglScaled = NULL;
|
|
qglScalef = NULL;
|
|
qglScissor = NULL;
|
|
qglSelectBuffer = NULL;
|
|
qglShadeModel = NULL;
|
|
qglStencilFunc = NULL;
|
|
qglStencilMask = NULL;
|
|
qglStencilOp = NULL;
|
|
qglTexCoord1d = NULL;
|
|
qglTexCoord1dv = NULL;
|
|
qglTexCoord1f = NULL;
|
|
qglTexCoord1fv = NULL;
|
|
qglTexCoord1i = NULL;
|
|
qglTexCoord1iv = NULL;
|
|
qglTexCoord1s = NULL;
|
|
qglTexCoord1sv = NULL;
|
|
qglTexCoord2d = NULL;
|
|
qglTexCoord2dv = NULL;
|
|
qglTexCoord2f = NULL;
|
|
qglTexCoord2fv = NULL;
|
|
qglTexCoord2i = NULL;
|
|
qglTexCoord2iv = NULL;
|
|
qglTexCoord2s = NULL;
|
|
qglTexCoord2sv = NULL;
|
|
qglTexCoord3d = NULL;
|
|
qglTexCoord3dv = NULL;
|
|
qglTexCoord3f = NULL;
|
|
qglTexCoord3fv = NULL;
|
|
qglTexCoord3i = NULL;
|
|
qglTexCoord3iv = NULL;
|
|
qglTexCoord3s = NULL;
|
|
qglTexCoord3sv = NULL;
|
|
qglTexCoord4d = NULL;
|
|
qglTexCoord4dv = NULL;
|
|
qglTexCoord4f = NULL;
|
|
qglTexCoord4fv = NULL;
|
|
qglTexCoord4i = NULL;
|
|
qglTexCoord4iv = NULL;
|
|
qglTexCoord4s = NULL;
|
|
qglTexCoord4sv = NULL;
|
|
qglTexCoordPointer = NULL;
|
|
qglTexEnvf = NULL;
|
|
qglTexEnvfv = NULL;
|
|
qglTexEnvi = NULL;
|
|
qglTexEnviv = NULL;
|
|
qglTexGend = NULL;
|
|
qglTexGendv = NULL;
|
|
qglTexGenf = NULL;
|
|
qglTexGenfv = NULL;
|
|
qglTexGeni = NULL;
|
|
qglTexGeniv = NULL;
|
|
qglTexImage1D = NULL;
|
|
qglTexImage2D = NULL;
|
|
qglTexImage2DEXT = NULL;
|
|
qglTexParameterf = NULL;
|
|
qglTexParameterfv = NULL;
|
|
qglTexParameteri = NULL;
|
|
qglTexParameteriv = NULL;
|
|
qglTexSubImage1D = NULL;
|
|
qglTexSubImage2D = NULL;
|
|
qglTranslated = NULL;
|
|
qglTranslatef = NULL;
|
|
qglVertex2d = NULL;
|
|
qglVertex2dv = NULL;
|
|
qglVertex2f = NULL;
|
|
qglVertex2fv = NULL;
|
|
qglVertex2i = NULL;
|
|
qglVertex2iv = NULL;
|
|
qglVertex2s = NULL;
|
|
qglVertex2sv = NULL;
|
|
qglVertex3d = NULL;
|
|
qglVertex3dv = NULL;
|
|
qglVertex3f = NULL;
|
|
qglVertex3fv = NULL;
|
|
qglVertex3i = NULL;
|
|
qglVertex3iv = NULL;
|
|
qglVertex3s = NULL;
|
|
qglVertex3sv = NULL;
|
|
qglVertex4d = NULL;
|
|
qglVertex4dv = NULL;
|
|
qglVertex4f = NULL;
|
|
qglVertex4fv = NULL;
|
|
qglVertex4i = NULL;
|
|
qglVertex4iv = NULL;
|
|
qglVertex4s = NULL;
|
|
qglVertex4sv = NULL;
|
|
qglVertexPointer = NULL;
|
|
qglViewport = NULL;
|
|
|
|
qglActiveTextureARB = NULL;
|
|
qglClientActiveTextureARB = NULL;
|
|
qglMultiTexCoord2fARB = NULL;
|
|
}
|
|
|
|
/*
|
|
** QGL_Init
|
|
**
|
|
** This is responsible for binding our qgl function pointers to
|
|
** the appropriate GL stuff. In Windows this means doing a
|
|
** LoadLibrary and a bunch of calls to GetProcAddress. On other
|
|
** operating systems we need to do the right thing, whatever that
|
|
** might be.
|
|
*/
|
|
qboolean QGL_Init( const char *dllname )
|
|
{
|
|
qglAccum = dllAccum;
|
|
qglAlphaFunc = dllAlphaFunc;
|
|
qglAreTexturesResident = dllAreTexturesResident;
|
|
qglArrayElement = dllArrayElement;
|
|
qglBegin = dllBegin;
|
|
qglBeginEXT = dllBeginEXT;
|
|
qglBeginFrame = dllBeginFrame;
|
|
qglBeginShadow = dllBeginShadow;
|
|
qglBindTexture = dllBindTexture;
|
|
qglBitmap = dllBitmap;
|
|
qglBlendFunc = dllBlendFunc;
|
|
qglCallList = dllCallList;
|
|
qglCallLists = dllCallLists;
|
|
qglClear = dllClear;
|
|
qglClearAccum = dllClearAccum;
|
|
qglClearColor = dllClearColor;
|
|
qglClearDepth = dllClearDepth;
|
|
qglClearIndex = dllClearIndex;
|
|
qglClearStencil = dllClearStencil;
|
|
qglClipPlane = dllClipPlane;
|
|
qglColor3b = dllColor3b;
|
|
qglColor3bv = dllColor3bv;
|
|
qglColor3d = dllColor3d;
|
|
qglColor3dv = dllColor3dv;
|
|
qglColor3f = dllColor3f;
|
|
qglColor3fv = dllColor3fv;
|
|
qglColor3i = dllColor3i;
|
|
qglColor3iv = dllColor3iv;
|
|
qglColor3s = dllColor3s;
|
|
qglColor3sv = dllColor3sv;
|
|
qglColor3ub = dllColor3ub;
|
|
qglColor3ubv = dllColor3ubv;
|
|
qglColor3ui = dllColor3ui;
|
|
qglColor3uiv = dllColor3uiv;
|
|
qglColor3us = dllColor3us;
|
|
qglColor3usv = dllColor3usv;
|
|
qglColor4b = dllColor4b;
|
|
qglColor4bv = dllColor4bv;
|
|
qglColor4d = dllColor4d;
|
|
qglColor4dv = dllColor4dv;
|
|
qglColor4f = dllColor4f;
|
|
qglColor4fv = dllColor4fv;
|
|
qglColor4i = dllColor4i;
|
|
qglColor4iv = dllColor4iv;
|
|
qglColor4s = dllColor4s;
|
|
qglColor4sv = dllColor4sv;
|
|
qglColor4ub = dllColor4ub;
|
|
qglColor4ubv = dllColor4ubv;
|
|
qglColor4ui = dllColor4ui;
|
|
qglColor4uiv = dllColor4uiv;
|
|
qglColor4us = dllColor4us;
|
|
qglColor4usv = dllColor4usv;
|
|
qglColorMask = dllColorMask;
|
|
qglColorMaterial = dllColorMaterial;
|
|
qglColorPointer = dllColorPointer;
|
|
qglCopyPixels = dllCopyPixels;
|
|
qglCopyTexImage1D = dllCopyTexImage1D;
|
|
qglCopyTexImage2D = dllCopyTexImage2D;
|
|
qglCopyTexSubImage1D = dllCopyTexSubImage1D;
|
|
qglCopyTexSubImage2D = dllCopyTexSubImage2D;
|
|
qglCullFace = dllCullFace;
|
|
qglDeleteLists = dllDeleteLists;
|
|
qglDeleteTextures = dllDeleteTextures;
|
|
qglDepthFunc = dllDepthFunc;
|
|
qglDepthMask = dllDepthMask;
|
|
qglDepthRange = dllDepthRange;
|
|
qglDisable = dllDisable;
|
|
qglDisableClientState = dllDisableClientState;
|
|
qglDrawArrays = dllDrawArrays;
|
|
qglDrawBuffer = dllDrawBuffer;
|
|
qglDrawElements = dllDrawElements;
|
|
qglDrawPixels = dllDrawPixels;
|
|
qglEdgeFlag = dllEdgeFlag;
|
|
qglEdgeFlagPointer = dllEdgeFlagPointer;
|
|
qglEdgeFlagv = dllEdgeFlagv;
|
|
qglEnable = dllEnable ;
|
|
qglEnableClientState = dllEnableClientState ;
|
|
qglEnd = dllEnd ;
|
|
qglEndFrame = dllEndFrame ;
|
|
qglEndShadow = dllEndShadow ;
|
|
qglEndList = dllEndList ;
|
|
qglEvalCoord1d = dllEvalCoord1d ;
|
|
qglEvalCoord1dv = dllEvalCoord1dv ;
|
|
qglEvalCoord1f = dllEvalCoord1f ;
|
|
qglEvalCoord1fv = dllEvalCoord1fv ;
|
|
qglEvalCoord2d = dllEvalCoord2d ;
|
|
qglEvalCoord2dv = dllEvalCoord2dv ;
|
|
qglEvalCoord2f = dllEvalCoord2f ;
|
|
qglEvalCoord2fv = dllEvalCoord2fv ;
|
|
qglEvalMesh1 = dllEvalMesh1 ;
|
|
qglEvalMesh2 = dllEvalMesh2 ;
|
|
qglEvalPoint1 = dllEvalPoint1 ;
|
|
qglEvalPoint2 = dllEvalPoint2 ;
|
|
qglFeedbackBuffer = dllFeedbackBuffer ;
|
|
qglFinish = dllFinish ;
|
|
qglFlush = dllFlush ;
|
|
qglFlushShadow = dllFlushShadow ;
|
|
qglFogf = dllFogf ;
|
|
qglFogfv = dllFogfv ;
|
|
qglFogi = dllFogi ;
|
|
qglFogiv = dllFogiv ;
|
|
qglFrontFace = dllFrontFace ;
|
|
qglFrustum = dllFrustum ;
|
|
qglGenLists = dllGenLists ;
|
|
qglGenTextures = dllGenTextures ;
|
|
qglGetBooleanv = dllGetBooleanv ;
|
|
qglGetClipPlane = dllGetClipPlane ;
|
|
qglGetDoublev = dllGetDoublev ;
|
|
qglGetError = dllGetError ;
|
|
qglGetFloatv = dllGetFloatv ;
|
|
qglGetIntegerv = dllGetIntegerv ;
|
|
qglGetLightfv = dllGetLightfv ;
|
|
qglGetLightiv = dllGetLightiv ;
|
|
qglGetMapdv = dllGetMapdv ;
|
|
qglGetMapfv = dllGetMapfv ;
|
|
qglGetMapiv = dllGetMapiv ;
|
|
qglGetMaterialfv = dllGetMaterialfv ;
|
|
qglGetMaterialiv = dllGetMaterialiv ;
|
|
qglGetPixelMapfv = dllGetPixelMapfv ;
|
|
qglGetPixelMapuiv = dllGetPixelMapuiv ;
|
|
qglGetPixelMapusv = dllGetPixelMapusv ;
|
|
qglGetPointerv = dllGetPointerv ;
|
|
qglGetPolygonStipple = dllGetPolygonStipple ;
|
|
qglGetString = dllGetString ;
|
|
qglGetTexEnvfv = dllGetTexEnvfv ;
|
|
qglGetTexEnviv = dllGetTexEnviv ;
|
|
qglGetTexGendv = dllGetTexGendv ;
|
|
qglGetTexGenfv = dllGetTexGenfv ;
|
|
qglGetTexGeniv = dllGetTexGeniv ;
|
|
qglGetTexImage = dllGetTexImage ;
|
|
// qglGetTexLevelParameterfv = dllGetTexLevelParameterfv ;
|
|
// qglGetTexLevelParameteriv = dllGetTexLevelParameteriv ;
|
|
qglGetTexParameterfv = dllGetTexParameterfv ;
|
|
qglGetTexParameteriv = dllGetTexParameteriv ;
|
|
qglHint = dllHint ;
|
|
qglIndexedTriToStrip = dllIndexedTriToStrip ;
|
|
qglIndexMask = dllIndexMask ;
|
|
qglIndexPointer = dllIndexPointer ;
|
|
qglIndexd = dllIndexd ;
|
|
qglIndexdv = dllIndexdv ;
|
|
qglIndexf = dllIndexf ;
|
|
qglIndexfv = dllIndexfv ;
|
|
qglIndexi = dllIndexi ;
|
|
qglIndexiv = dllIndexiv ;
|
|
qglIndexs = dllIndexs ;
|
|
qglIndexsv = dllIndexsv ;
|
|
qglIndexub = dllIndexub ;
|
|
qglIndexubv = dllIndexubv ;
|
|
qglInitNames = dllInitNames ;
|
|
qglInterleavedArrays = dllInterleavedArrays ;
|
|
qglIsEnabled = dllIsEnabled ;
|
|
qglIsList = dllIsList ;
|
|
qglIsTexture = dllIsTexture ;
|
|
qglLightModelf = dllLightModelf ;
|
|
qglLightModelfv = dllLightModelfv ;
|
|
qglLightModeli = dllLightModeli ;
|
|
qglLightModeliv = dllLightModeliv ;
|
|
qglLightf = dllLightf ;
|
|
qglLightfv = dllLightfv ;
|
|
qglLighti = dllLighti ;
|
|
qglLightiv = dllLightiv ;
|
|
qglLineStipple = dllLineStipple ;
|
|
qglLineWidth = dllLineWidth ;
|
|
qglListBase = dllListBase ;
|
|
qglLoadIdentity = dllLoadIdentity ;
|
|
qglLoadMatrixd = dllLoadMatrixd ;
|
|
qglLoadMatrixf = dllLoadMatrixf ;
|
|
qglLoadName = dllLoadName ;
|
|
qglLogicOp = dllLogicOp ;
|
|
qglMap1d = dllMap1d ;
|
|
qglMap1f = dllMap1f ;
|
|
qglMap2d = dllMap2d ;
|
|
qglMap2f = dllMap2f ;
|
|
qglMapGrid1d = dllMapGrid1d ;
|
|
qglMapGrid1f = dllMapGrid1f ;
|
|
qglMapGrid2d = dllMapGrid2d ;
|
|
qglMapGrid2f = dllMapGrid2f ;
|
|
qglMaterialf = dllMaterialf ;
|
|
qglMaterialfv = dllMaterialfv ;
|
|
qglMateriali = dllMateriali ;
|
|
qglMaterialiv = dllMaterialiv ;
|
|
qglMatrixMode = dllMatrixMode ;
|
|
qglMultMatrixd = dllMultMatrixd ;
|
|
qglMultMatrixf = dllMultMatrixf ;
|
|
qglNewList = dllNewList ;
|
|
qglNormal3b = dllNormal3b ;
|
|
qglNormal3bv = dllNormal3bv ;
|
|
qglNormal3d = dllNormal3d ;
|
|
qglNormal3dv = dllNormal3dv ;
|
|
qglNormal3f = dllNormal3f ;
|
|
qglNormal3fv = dllNormal3fv ;
|
|
qglNormal3i = dllNormal3i ;
|
|
qglNormal3iv = dllNormal3iv ;
|
|
qglNormal3s = dllNormal3s ;
|
|
qglNormal3sv = dllNormal3sv ;
|
|
qglNormalPointer = dllNormalPointer ;
|
|
qglOrtho = dllOrtho ;
|
|
qglPassThrough = dllPassThrough ;
|
|
qglPixelMapfv = dllPixelMapfv ;
|
|
qglPixelMapuiv = dllPixelMapuiv ;
|
|
qglPixelMapusv = dllPixelMapusv ;
|
|
qglPixelStoref = dllPixelStoref ;
|
|
qglPixelStorei = dllPixelStorei ;
|
|
qglPixelTransferf = dllPixelTransferf ;
|
|
qglPixelTransferi = dllPixelTransferi ;
|
|
qglPixelZoom = dllPixelZoom ;
|
|
qglPointSize = dllPointSize ;
|
|
qglPolygonMode = dllPolygonMode ;
|
|
qglPolygonOffset = dllPolygonOffset ;
|
|
qglPolygonStipple = dllPolygonStipple ;
|
|
qglPopAttrib = dllPopAttrib ;
|
|
qglPopClientAttrib = dllPopClientAttrib ;
|
|
qglPopMatrix = dllPopMatrix ;
|
|
qglPopName = dllPopName ;
|
|
qglPrioritizeTextures = dllPrioritizeTextures ;
|
|
qglPushAttrib = dllPushAttrib ;
|
|
qglPushClientAttrib = dllPushClientAttrib ;
|
|
qglPushMatrix = dllPushMatrix ;
|
|
qglPushName = dllPushName ;
|
|
qglRasterPos2d = dllRasterPos2d ;
|
|
qglRasterPos2dv = dllRasterPos2dv ;
|
|
qglRasterPos2f = dllRasterPos2f ;
|
|
qglRasterPos2fv = dllRasterPos2fv ;
|
|
qglRasterPos2i = dllRasterPos2i ;
|
|
qglRasterPos2iv = dllRasterPos2iv ;
|
|
qglRasterPos2s = dllRasterPos2s ;
|
|
qglRasterPos2sv = dllRasterPos2sv ;
|
|
qglRasterPos3d = dllRasterPos3d ;
|
|
qglRasterPos3dv = dllRasterPos3dv ;
|
|
qglRasterPos3f = dllRasterPos3f ;
|
|
qglRasterPos3fv = dllRasterPos3fv ;
|
|
qglRasterPos3i = dllRasterPos3i ;
|
|
qglRasterPos3iv = dllRasterPos3iv ;
|
|
qglRasterPos3s = dllRasterPos3s ;
|
|
qglRasterPos3sv = dllRasterPos3sv ;
|
|
qglRasterPos4d = dllRasterPos4d ;
|
|
qglRasterPos4dv = dllRasterPos4dv ;
|
|
qglRasterPos4f = dllRasterPos4f ;
|
|
qglRasterPos4fv = dllRasterPos4fv ;
|
|
qglRasterPos4i = dllRasterPos4i ;
|
|
qglRasterPos4iv = dllRasterPos4iv ;
|
|
qglRasterPos4s = dllRasterPos4s ;
|
|
qglRasterPos4sv = dllRasterPos4sv ;
|
|
qglReadBuffer = dllReadBuffer ;
|
|
qglReadPixels = dllReadPixels ;
|
|
qglCopyBackBufferToTexEXT = dllCopyBackBufferToTexEXT ;
|
|
qglCopyBackBufferToTex = dllCopyBackBufferToTex ;
|
|
qglRectd = dllRectd ;
|
|
qglRectdv = dllRectdv ;
|
|
qglRectf = dllRectf ;
|
|
qglRectfv = dllRectfv ;
|
|
qglRecti = dllRecti ;
|
|
qglRectiv = dllRectiv ;
|
|
qglRects = dllRects ;
|
|
qglRectsv = dllRectsv ;
|
|
qglRenderMode = dllRenderMode ;
|
|
qglRotated = dllRotated ;
|
|
qglRotatef = dllRotatef ;
|
|
qglScaled = dllScaled ;
|
|
qglScalef = dllScalef ;
|
|
qglScissor = dllScissor ;
|
|
qglSelectBuffer = dllSelectBuffer ;
|
|
qglShadeModel = dllShadeModel ;
|
|
qglStencilFunc = dllStencilFunc ;
|
|
qglStencilMask = dllStencilMask ;
|
|
qglStencilOp = dllStencilOp ;
|
|
qglTexCoord1d = dllTexCoord1d ;
|
|
qglTexCoord1dv = dllTexCoord1dv ;
|
|
qglTexCoord1f = dllTexCoord1f ;
|
|
qglTexCoord1fv = dllTexCoord1fv ;
|
|
qglTexCoord1i = dllTexCoord1i ;
|
|
qglTexCoord1iv = dllTexCoord1iv ;
|
|
qglTexCoord1s = dllTexCoord1s ;
|
|
qglTexCoord1sv = dllTexCoord1sv ;
|
|
qglTexCoord2d = dllTexCoord2d ;
|
|
qglTexCoord2dv = dllTexCoord2dv ;
|
|
qglTexCoord2f = dllTexCoord2f ;
|
|
qglTexCoord2fv = dllTexCoord2fv ;
|
|
qglTexCoord2i = dllTexCoord2i ;
|
|
qglTexCoord2iv = dllTexCoord2iv ;
|
|
qglTexCoord2s = dllTexCoord2s ;
|
|
qglTexCoord2sv = dllTexCoord2sv ;
|
|
qglTexCoord3d = dllTexCoord3d ;
|
|
qglTexCoord3dv = dllTexCoord3dv ;
|
|
qglTexCoord3f = dllTexCoord3f ;
|
|
qglTexCoord3fv = dllTexCoord3fv ;
|
|
qglTexCoord3i = dllTexCoord3i ;
|
|
qglTexCoord3iv = dllTexCoord3iv ;
|
|
qglTexCoord3s = dllTexCoord3s ;
|
|
qglTexCoord3sv = dllTexCoord3sv ;
|
|
qglTexCoord4d = dllTexCoord4d ;
|
|
qglTexCoord4dv = dllTexCoord4dv ;
|
|
qglTexCoord4f = dllTexCoord4f ;
|
|
qglTexCoord4fv = dllTexCoord4fv ;
|
|
qglTexCoord4i = dllTexCoord4i ;
|
|
qglTexCoord4iv = dllTexCoord4iv ;
|
|
qglTexCoord4s = dllTexCoord4s ;
|
|
qglTexCoord4sv = dllTexCoord4sv ;
|
|
qglTexCoordPointer = dllTexCoordPointer ;
|
|
qglTexEnvf = dllTexEnvf ;
|
|
qglTexEnvfv = dllTexEnvfv ;
|
|
qglTexEnvi = dllTexEnvi ;
|
|
qglTexEnviv = dllTexEnviv ;
|
|
qglTexGend = dllTexGend ;
|
|
qglTexGendv = dllTexGendv ;
|
|
qglTexGenf = dllTexGenf ;
|
|
qglTexGenfv = dllTexGenfv ;
|
|
qglTexGeni = dllTexGeni ;
|
|
qglTexGeniv = dllTexGeniv ;
|
|
qglTexImage1D = dllTexImage1D ;
|
|
qglTexImage2D = dllTexImage2D ;
|
|
qglTexImage2DEXT = dllTexImage2DEXT ;
|
|
qglTexParameterf = dllTexParameterf ;
|
|
qglTexParameterfv = dllTexParameterfv ;
|
|
qglTexParameteri = dllTexParameteri ;
|
|
qglTexParameteriv = dllTexParameteriv ;
|
|
qglTexSubImage1D = dllTexSubImage1D ;
|
|
qglTexSubImage2D = dllTexSubImage2D ;
|
|
qglTranslated = dllTranslated ;
|
|
qglTranslatef = dllTranslatef ;
|
|
qglVertex2d = dllVertex2d ;
|
|
qglVertex2dv = dllVertex2dv ;
|
|
qglVertex2f = dllVertex2f ;
|
|
qglVertex2fv = dllVertex2fv ;
|
|
qglVertex2i = dllVertex2i ;
|
|
qglVertex2iv = dllVertex2iv ;
|
|
qglVertex2s = dllVertex2s ;
|
|
qglVertex2sv = dllVertex2sv ;
|
|
qglVertex3d = dllVertex3d ;
|
|
qglVertex3dv = dllVertex3dv ;
|
|
qglVertex3f = dllVertex3f ;
|
|
qglVertex3fv = dllVertex3fv ;
|
|
qglVertex3i = dllVertex3i ;
|
|
qglVertex3iv = dllVertex3iv ;
|
|
qglVertex3s = dllVertex3s ;
|
|
qglVertex3sv = dllVertex3sv ;
|
|
qglVertex4d = dllVertex4d ;
|
|
qglVertex4dv = dllVertex4dv ;
|
|
qglVertex4f = dllVertex4f ;
|
|
qglVertex4fv = dllVertex4fv ;
|
|
qglVertex4i = dllVertex4i ;
|
|
qglVertex4iv = dllVertex4iv ;
|
|
qglVertex4s = dllVertex4s ;
|
|
qglVertex4sv = dllVertex4sv ;
|
|
qglVertexPointer = dllVertexPointer ;
|
|
qglViewport = dllViewport ;
|
|
|
|
qglActiveTextureARB = dllActiveTextureARB ;
|
|
qglClientActiveTextureARB = dllClientActiveTextureARB ;
|
|
qglMultiTexCoord2fARB = dllMultiTexCoord2fARB ;
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
void QGL_EnableLogging( qboolean enable )
|
|
{
|
|
}
|
|
|
|
// Extra functions bound to d3d_ commands for controlling crazy D3D performance things
|
|
#ifndef FINAL_BUILD
|
|
|
|
// D3D_AutoPerfData controls automatic display of performance information:
|
|
// framerate, push buffer data, etc... Usage:
|
|
// d3d_autoperf - Toggle on and off
|
|
// d3d_autoperf n - Set display frequency in ms (default 5000)
|
|
static void D3D_AutoPerfData_f( void )
|
|
{
|
|
static DWORD sdwInterval = 5000;
|
|
static bool sbEnabled = false;
|
|
|
|
int numArgs = Cmd_Argc();
|
|
|
|
if (numArgs > 2)
|
|
{
|
|
Com_Printf("D3D_AutoPerfData_f: Too many arguments.\n");
|
|
}
|
|
else if (numArgs <= 1)
|
|
{
|
|
sbEnabled = !sbEnabled;
|
|
D3DPERF_SetShowFrameRateInterval(sbEnabled ? sdwInterval : 0);
|
|
}
|
|
else // numArgs == 2 -> Exactly one real argument
|
|
{
|
|
int new_interval = atoi(Cmd_Argv(1));
|
|
|
|
if (!new_interval)
|
|
{
|
|
// Fancy way to turn it off, don't change stored interval
|
|
sbEnabled = false;
|
|
}
|
|
else
|
|
{
|
|
// Force it on
|
|
sdwInterval = new_interval;
|
|
sbEnabled = true;
|
|
}
|
|
D3DPERF_SetShowFrameRateInterval(sbEnabled ? sdwInterval : 0);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
extern void GLimp_SetGamma(float);
|
|
|
|
|
|
static void _createWindow(int width, int height, int colorbits, qboolean cdsFullscreen)
|
|
{
|
|
glConfig.colorBits = colorbits;
|
|
|
|
if ( r_depthbits->integer == 0 ) {
|
|
if ( colorbits > 16 ) {
|
|
glConfig.depthBits = 24;
|
|
} else {
|
|
glConfig.depthBits = 16;
|
|
}
|
|
} else {
|
|
glConfig.depthBits = r_depthbits->integer;
|
|
}
|
|
|
|
glConfig.stencilBits = r_stencilbits->integer;
|
|
if ( glConfig.depthBits < 24 )
|
|
{
|
|
glConfig.stencilBits = 0;
|
|
}
|
|
|
|
glConfig.displayFrequency = 75;
|
|
glConfig.stereoEnabled = qfalse;
|
|
|
|
// VVFIXME : This is surely wrong.
|
|
glConfig.vidHeight = height;
|
|
glConfig.vidWidth = width;
|
|
|
|
}
|
|
|
|
enum VideoModes
|
|
{
|
|
VM_480i = 0,
|
|
VM_480p,
|
|
VM_720p,
|
|
VM_1080i
|
|
};
|
|
|
|
|
|
void GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen)
|
|
{
|
|
glw_state = new glwstate_t;
|
|
int mode = VM_480i;
|
|
|
|
glw_state->isWidescreen = false;
|
|
if( XGetVideoFlags() & XC_VIDEO_FLAGS_WIDESCREEN )
|
|
{
|
|
glw_state->isWidescreen = true;
|
|
|
|
if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_480p )
|
|
{
|
|
width = 720;
|
|
height = 480;
|
|
mode = VM_480p;
|
|
}
|
|
|
|
/*if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_720p )
|
|
{
|
|
width = 1280;
|
|
height = 720;
|
|
mode = VM_720p;
|
|
}
|
|
|
|
if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_1080i )
|
|
{
|
|
width = 1920;
|
|
height = 1080;
|
|
mode = VM_1080i;
|
|
}*/
|
|
}
|
|
|
|
_createWindow(width, height, colorbits, cdsFullscreen);
|
|
|
|
glw_state->matrixMode = glwstate_t::MatrixMode_Model;
|
|
glw_state->inDrawBlock = false;
|
|
|
|
glw_state->serverTU = 0;
|
|
glw_state->clientTU = 0;
|
|
|
|
glw_state->colorArrayState = false;
|
|
glw_state->vertexArrayState = false;
|
|
glw_state->normalArrayState = false;
|
|
|
|
glw_state->cullEnable = true;
|
|
glw_state->cullMode = D3DCULL_CCW;
|
|
|
|
glw_state->scissorEnable = false;
|
|
glw_state->scissorBox.x1 = 0;
|
|
glw_state->scissorBox.y1 = 0;
|
|
glw_state->scissorBox.x2 = glConfig.vidWidth;
|
|
glw_state->scissorBox.y2 = glConfig.vidHeight;
|
|
|
|
glw_state->shaderMask = 0;
|
|
|
|
glw_state->clearColor = D3DCOLOR_RGBA(255, 255, 255, 255);
|
|
glw_state->clearDepth = 1.f;
|
|
glw_state->clearStencil = 0;
|
|
|
|
glw_state->currentColor = D3DCOLOR_RGBA(255, 255, 255, 255);
|
|
|
|
glw_state->viewport.MinZ = 0.f;
|
|
glw_state->viewport.MaxZ = 1.f;
|
|
|
|
for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
|
|
{
|
|
glw_state->textureEnv[t] = D3DTOP_MODULATE;
|
|
glw_state->texCoordArrayState[t] = false;
|
|
glw_state->currentTexture[t] = 0;
|
|
glw_state->textureStageDirty[t] = false;
|
|
}
|
|
|
|
glw_state->textureBindNum = 1;
|
|
|
|
D3DPRESENT_PARAMETERS present;
|
|
present.BackBufferWidth = width;
|
|
present.BackBufferHeight = height;
|
|
present.BackBufferFormat = D3DFMT_A8R8G8B8;
|
|
present.BackBufferCount = 1;
|
|
present.MultiSampleType = D3DMULTISAMPLE_NONE;
|
|
present.SwapEffect = D3DSWAPEFFECT_DISCARD;
|
|
present.hDeviceWindow = 0;
|
|
present.Windowed = FALSE;
|
|
present.EnableAutoDepthStencil = TRUE;
|
|
present.AutoDepthStencilFormat = D3DFMT_LIN_D24S8;
|
|
present.Flags = 0;
|
|
if( glw_state->isWidescreen )
|
|
{
|
|
present.Flags = D3DPRESENTFLAG_WIDESCREEN;
|
|
extern void CGCam_SetWidescreen(qboolean widescreen);
|
|
if(mode == VM_480p)
|
|
{
|
|
present.Flags |= D3DPRESENTFLAG_PROGRESSIVE;
|
|
}
|
|
//else if(mode == VM_720p)
|
|
//{
|
|
// present.Flags |= D3DPRESENTFLAG_PROGRESSIVE;
|
|
//}
|
|
//else if(mode == VM_1080i)
|
|
//{
|
|
// present.Flags |= D3DPRESENTFLAG_INTERLACED; // | D3DPRESENTFLAG_FIELD;
|
|
//}
|
|
|
|
|
|
present.Flags |= D3DPRESENTFLAG_WIDESCREEN;
|
|
CGCam_SetWidescreen(qtrue);
|
|
}
|
|
|
|
present.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
|
|
present.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
|
|
present.BufferSurfaces[0] = NULL;
|
|
present.BufferSurfaces[1] = NULL;
|
|
present.BufferSurfaces[2] = NULL;
|
|
present.DepthStencilSurface = NULL;
|
|
|
|
if (IDirect3D8::CreateDevice(D3DADAPTER_DEFAULT,
|
|
D3DDEVTYPE_HAL,
|
|
NULL,
|
|
D3DCREATE_HARDWARE_VERTEXPROCESSING,
|
|
&present,
|
|
&glw_state->device) != D3D_OK)
|
|
{
|
|
Com_Printf("Failed to create device. That's bad.\n");
|
|
}
|
|
// qglEnable(GL_VSYNC);
|
|
|
|
for (int m = 0; m < glwstate_t::Num_MatrixModes; ++m)
|
|
{
|
|
D3DXCreateMatrixStack(0, &glw_state->matrixStack[m]);
|
|
glw_state->matrixStack[m]->LoadIdentity();
|
|
glw_state->matricesDirty[m] = false;
|
|
}
|
|
|
|
// VVFIXME: Hack - turn off lighting
|
|
dllDisable(GL_LIGHTING);
|
|
|
|
// Set a material (for lighting)
|
|
memset( &glw_state->mtrl, 0, sizeof(D3DMATERIAL8) );
|
|
glw_state->mtrl.Diffuse.r = glw_state->mtrl.Ambient.r = 1.0f;
|
|
glw_state->mtrl.Diffuse.g = glw_state->mtrl.Ambient.g = 1.0f;
|
|
glw_state->mtrl.Diffuse.b = glw_state->mtrl.Ambient.b = 1.0f;
|
|
glw_state->mtrl.Diffuse.a = glw_state->mtrl.Ambient.a = 1.0f;
|
|
glw_state->device->SetMaterial( &glw_state->mtrl );
|
|
// Gamma hack
|
|
GLimp_SetGamma(1.3f);
|
|
|
|
// Set up our directional light (used for diffuse lighting)
|
|
memset(&glw_state->dirLight, 0, sizeof(D3DLIGHT8));
|
|
|
|
// Set up a white point light.
|
|
glw_state->dirLight.Type = D3DLIGHT_DIRECTIONAL;
|
|
glw_state->dirLight.Diffuse.r = 1.0f;
|
|
glw_state->dirLight.Diffuse.g = 1.0f;
|
|
glw_state->dirLight.Diffuse.b = 1.0f;
|
|
glw_state->dirLight.Direction.x = 1.0f;
|
|
glw_state->dirLight.Direction.y = 0.0f;
|
|
glw_state->dirLight.Direction.z = 0.0f;
|
|
|
|
// Don't attenuate.
|
|
glw_state->dirLight.Attenuation0 = 1.0f;
|
|
glw_state->dirLight.Range = 1000.0f;
|
|
|
|
//glw_state->drawArray = new DWORD[SHADER_MAX_VERTEXES * 12];
|
|
glw_state->drawArray = NULL;
|
|
|
|
#ifdef _XBOX
|
|
#ifdef VV_LIGHTING
|
|
// glw_state->flareEffect = new FlareEffect;
|
|
// glw_state->flareEffect->Initialize();
|
|
glw_state->lightEffects = new LightEffects;
|
|
#endif // VV_LIGHTING
|
|
HDREffect.Initialize();
|
|
#endif
|
|
|
|
#ifndef FINAL_BUILD
|
|
Cmd_AddCommand("d3d_autoperf", D3D_AutoPerfData_f);
|
|
#endif
|
|
}
|
|
|
|
void GLW_Shutdown(void)
|
|
{
|
|
#ifdef _XBOX
|
|
#ifdef VV_LIGHTING
|
|
delete glw_state->lightEffects;
|
|
#endif
|
|
#endif
|
|
|
|
for (int m = 0; m < glwstate_t::Num_MatrixModes; ++m)
|
|
{
|
|
glw_state->matrixStack[m]->Release();
|
|
}
|
|
|
|
glw_state->device->Release();
|
|
|
|
#ifdef _XBOX
|
|
// delete glw_state->flareEffect;
|
|
#endif
|
|
|
|
delete glw_state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compressed Screen Shot code for the save game system
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define CSS_IMAGE_HDR_SIZE 2048
|
|
#define CSS_IMAGE_WH 256
|
|
#define CSS_IMAGE_DATA_SIZE ((CSS_IMAGE_WH * CSS_IMAGE_WH) / 2 )
|
|
|
|
struct XprImageHeader
|
|
{
|
|
XPR_HEADER xpr; // Standard XPR struct
|
|
IDirect3DTexture8 txt; // Standard D3D texture struct
|
|
DWORD dwEndOfHeader; // 0xFFFFFFFF
|
|
};
|
|
|
|
struct XprImage
|
|
{
|
|
XprImageHeader hdr;
|
|
CHAR strPad[ CSS_IMAGE_HDR_SIZE - sizeof( XprImageHeader ) ];
|
|
BYTE pBits[ CSS_IMAGE_DATA_SIZE ]; // data bits
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SaveCompressedScreenshot
|
|
// Saves a copy of the backbuffer to a .xbx file specified by filename
|
|
//-----------------------------------------------------------------------------
|
|
void SaveCompressedScreenshot(const char* filename)
|
|
{
|
|
LPDIRECT3DSURFACE8 screenShot = 0;
|
|
HRESULT res;
|
|
glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &screenShot);
|
|
|
|
// Copy over the screen shot to the new image that is CSS_IMAGE_WH x CSS_IMAGE_WH
|
|
LPDIRECT3DSURFACE8 compressedSaveGameImage = 0;
|
|
glw_state->device->CreateImageSurface( CSS_IMAGE_WH, CSS_IMAGE_WH, D3DFMT_DXT1, &compressedSaveGameImage );
|
|
D3DXLoadSurfaceFromSurface( compressedSaveGameImage, NULL, NULL, screenShot, NULL, NULL, D3DX_DEFAULT, D3DCOLOR( 0 ) );
|
|
|
|
// Free the big screenshot 640x480x4?
|
|
if ( screenShot )
|
|
screenShot->Release();
|
|
|
|
// Write out the saveimage to the utility drive
|
|
res = XGWriteSurfaceOrTextureToXPR( compressedSaveGameImage, filename, TRUE );
|
|
|
|
// Free the compressed CSS_IMAGE_WH x CSS_IMAGE_WH image
|
|
if ( compressedSaveGameImage )
|
|
compressedSaveGameImage->Release();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// LoadCompressedScreenshot
|
|
// Loads a .xbx screenshot file and replaces the current texture
|
|
//-----------------------------------------------------------------------------
|
|
BOOL LoadCompressedScreenshot(const char* filename)
|
|
{
|
|
// get the current texture
|
|
glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
|
|
if (info == NULL) return FALSE;
|
|
|
|
// locals
|
|
LPDIRECT3DTEXTURE8 lpThumbTex;
|
|
XprImageHeader XprHeader;
|
|
DWORD dwBytesRead;
|
|
BOOL bSuccess;
|
|
|
|
// See if the image file for this saved game exists
|
|
HANDLE hFile = CreateFile( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING,0, NULL );
|
|
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
DWORD err = GetLastError();
|
|
|
|
// If there was a problem, we might want to load the default image for TRC
|
|
// TCR C4-18 Saved Game Representative Image
|
|
// No specific image found; see if the default save image exists
|
|
/*
|
|
hFile = CreateFile( "u:\\default_screen.xbx", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
m_bIsValidImage = FALSE;
|
|
return FALSE;
|
|
}
|
|
*/
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Read the image header from disk
|
|
bSuccess = ReadFile( hFile, &XprHeader, sizeof( XprImageHeader ), &dwBytesRead, NULL );
|
|
|
|
// Validate the image
|
|
bSuccess &= dwBytesRead == sizeof( XprImageHeader ) &&
|
|
XprHeader.xpr.dwMagic == XPR_MAGIC_VALUE &&
|
|
XprHeader.xpr.dwTotalSize == CSS_IMAGE_HDR_SIZE + CSS_IMAGE_DATA_SIZE &&
|
|
XprHeader.xpr.dwHeaderSize == CSS_IMAGE_HDR_SIZE &&
|
|
XprHeader.dwEndOfHeader == 0xFFFFFFFF;
|
|
|
|
// If image looks good, store the bits in a texture
|
|
if( bSuccess )
|
|
{
|
|
HRESULT hr;
|
|
hr = glw_state->device->CreateTexture( CSS_IMAGE_WH,
|
|
CSS_IMAGE_WH,
|
|
1,
|
|
0,
|
|
D3DFMT_DXT1,
|
|
D3DPOOL(),
|
|
&lpThumbTex );
|
|
bSuccess = SUCCEEDED(hr);
|
|
|
|
if( bSuccess )
|
|
{
|
|
D3DLOCKED_RECT lr;
|
|
lpThumbTex->LockRect( 0, &lr, NULL, D3DLOCK_READONLY );
|
|
|
|
// Copy the bits from the file to the texture
|
|
SetFilePointer( hFile, CSS_IMAGE_HDR_SIZE, NULL, FILE_BEGIN );
|
|
bSuccess = ReadFile( hFile, lr.pBits, CSS_IMAGE_DATA_SIZE, &dwBytesRead, NULL );
|
|
bSuccess &= ( dwBytesRead == CSS_IMAGE_DATA_SIZE );
|
|
lpThumbTex->UnlockRect( 0 );
|
|
|
|
// If everything was ok, then set the texture ptrs
|
|
DWORD refcount;
|
|
if( bSuccess )
|
|
{
|
|
refcount = info->mipmap->Release();
|
|
|
|
assert(refcount == 0);
|
|
|
|
info->mipmap = lpThumbTex;
|
|
info->mipmap->AddRef();
|
|
|
|
refcount = lpThumbTex->Release();
|
|
|
|
assert(refcount == 1);
|
|
}
|
|
else
|
|
{
|
|
refcount = lpThumbTex->Release();
|
|
|
|
assert(refcount == 0);
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle( hFile );
|
|
return bSuccess;
|
|
}
|
|
|
|
bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader )
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Open the vertex shader file
|
|
HANDLE hFile;
|
|
DWORD dwNumBytesRead;
|
|
hFile = CreateFile( strFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL );
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
return false;
|
|
|
|
// Allocate memory to read the vertex shader file
|
|
DWORD dwSize = GetFileSize(hFile, NULL);
|
|
BYTE* pData = new BYTE[dwSize+4];
|
|
if( NULL == pData )
|
|
{
|
|
CloseHandle( hFile );
|
|
return false;
|
|
}
|
|
ZeroMemory( pData, dwSize+4 );
|
|
|
|
// Read the pre-compiled vertex shader microcode
|
|
ReadFile(hFile, pData, dwSize, &dwNumBytesRead, 0);
|
|
|
|
// Create the vertex shader
|
|
hr = glw_state->device->CreateVertexShader( pdwVertexDecl, (const DWORD*)pData,
|
|
pdwVertexShader, 0 );
|
|
|
|
// Cleanup and return
|
|
CloseHandle( hFile );
|
|
delete [] pData;
|
|
|
|
if(hr == S_OK)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader )
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Open the pixel shader file
|
|
HANDLE hFile;
|
|
DWORD dwNumBytesRead;
|
|
hFile = CreateFile( strFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL );
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
return false;
|
|
|
|
// Load the pre-compiled pixel shader microcode
|
|
D3DPIXELSHADERDEF_FILE psdf;
|
|
ReadFile( hFile, &psdf, sizeof(D3DPIXELSHADERDEF_FILE), &dwNumBytesRead, NULL );
|
|
|
|
// Make sure the pixel shader is valid
|
|
if( psdf.FileID != D3DPIXELSHADERDEF_FILE_ID )
|
|
{
|
|
CloseHandle( hFile );
|
|
return false;
|
|
}
|
|
|
|
// Create the pixel shader
|
|
if( FAILED( hr = glw_state->device->CreatePixelShader( &(psdf.Psd), pdwPixelShader ) ) )
|
|
{
|
|
CloseHandle( hFile );
|
|
return false;
|
|
}
|
|
|
|
// Cleanup
|
|
CloseHandle( hFile );
|
|
|
|
return true;
|
|
}
|