//-----------------------------------------------------------------------------
// Torque Game Engine
// Quake GL DirectX wrapper
//-----------------------------------------------------------------------------
#include "opengl2d3d/opengl2d3d.h"
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
#include "../engine/lightingSystem/sgD3DCompatibility.h"
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
#include <stdio.h>
#ifdef USEICECAP
#include <icapexp.h>
#endif
static Globals g;
static void dirtyArray();
GLAPI BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved )
{
hModule;
lpReserved;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
static void QuakeUpdateViewport()
{
D3DVIEWPORT7 vport;
g.m_d3ddev->GetViewport(&vport);
if(g.m_scissoring)
{
// Check whether viewport is completely within scissor rect
RECT scirect, vwprect, xrect;
scirect.left = g.m_scix;
scirect.top = g.m_sciy;
scirect.right = g.m_scix + g.m_sciw;
scirect.bottom = g.m_sciy + g.m_scih;
vwprect.left = g.m_vwx;
vwprect.top = g.m_vwy;
vwprect.right = g.m_vwx + g.m_vww;
vwprect.bottom = g.m_vwy + g.m_vwh;
if(IntersectRect(&xrect, &scirect, &vwprect))
{
if(EqualRect(&xrect, &vwprect))
{
goto updvwp;
}
}
else
{
goto updvwp;
}
// BUGBUG: if the viewport overlaps the scissor rect, then none of this works
vport.dwX = g.m_scix;
vport.dwY = g.m_winHeight - (g.m_sciy + g.m_scih);
vport.dwWidth = g.m_sciw;
vport.dwHeight = g.m_scih;
D3DVALUE dvClipX = (2.f * g.m_scix) / g.m_vww - 1.0f;
D3DVALUE dvClipY = (2.f * (g.m_sciy + g.m_scih)) / g.m_vwh - 1.0f;
D3DVALUE dvClipWidth = (2.f * g.m_sciw) / g.m_vww;
D3DVALUE dvClipHeight = (2.f * g.m_scih) / g.m_vwh;
D3DMATRIX c;
c._11 = 2.f / dvClipWidth;
c._21 = 0.f;
c._31 = 0.f;
c._41 = -1.f - 2.f * (dvClipX / dvClipWidth);
c._12 = 0.f;
c._22 = 2.f / dvClipHeight;
c._32 = 0.f;
c._42 = -1.f - 2.f * (dvClipY / dvClipHeight);
c._13 = 0.f;
c._23 = 0.f;
c._33 = 1.f;
c._43 = 0.f;
c._14 = 0.f;
c._24 = 0.f;
c._34 = 0.f;
c._44 = 1.f;
g.m_d3ddev->MultiplyTransform(D3DTRANSFORMSTATE_PROJECTION, &c);
}
else
{
updvwp:
vport.dwX = g.m_vwx;
vport.dwY = g.m_winHeight - (g.m_vwy + g.m_vwh);
vport.dwWidth = g.m_vww;
vport.dwHeight = g.m_vwh;
}
g.m_d3ddev->SetViewport(&vport);
g.m_updvwp = FALSE;
}
static void QuakeSetTexturingState()
{
if (g.m_updvwp)
QuakeUpdateViewport();
if (g.m_texturing == TRUE) {
if (g.m_texHandleValid == FALSE) {
TexInfo &ti = g.m_tex[g.m_curstagebinding[0]];
if (ti.m_dwStage != 0)
{
g.m_d3ddev->DeleteStateBlock(ti.m_block);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ADDRESSU,ti.m_addu);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ADDRESSV,ti.m_addv);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_MAGFILTER,ti.m_magmode);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_MINFILTER,ti.m_minmode);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_MIPFILTER,ti.m_mipmode);
g.m_d3ddev->SetTexture(0, ti.m_ddsurf);
g.m_d3ddev->EndStateBlock(&ti.m_block);
ti.m_dwStage = 0;
ti.m_capture = FALSE;
}
if (ti.m_capture)
{
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ADDRESSU,ti.m_addu);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ADDRESSV,ti.m_addv);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_MAGFILTER,ti.m_magmode);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_MINFILTER,ti.m_minmode);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_MIPFILTER,ti.m_mipmode);
g.m_d3ddev->SetTexture(0, ti.m_ddsurf);
g.m_d3ddev->CaptureStateBlock(ti.m_block);
ti.m_capture = FALSE;
}
else
g.m_d3ddev->ApplyStateBlock(ti.m_block);
switch (g.m_blendmode[0]) {
case GL_REPLACE:
switch (ti.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][1]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][0]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][0]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][1]);
break;
}
break;
case GL_MODULATE:
switch (ti.m_internalformat) {
case GL_ALPHA:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][8]);
break;
case GL_COLOR_INDEX8_EXT:
if (ti.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][3]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][2]);
break;
case GL_LUMINANCE:
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][2]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][3]);
break;
}
break;
case GL_DECAL:
switch (ti.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][5]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][4]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][4]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][5]);
break;
}
break;
case GL_BLEND:
switch (ti.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][7]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][6]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][6]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][7]);
break;
}
break;
case GL_COMBINE_EXT:
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
if(sgD3DCompatibility::sgCombineMode[0] == GL_MODULATE)
{
switch(ti.m_internalformat)
{
case GL_RGB4:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(sgD3DCompatibility::sgGetShader(
sgD3DCompatibility::sgstChannel0ModulateRGB));
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(sgD3DCompatibility::sgGetShader(
sgD3DCompatibility::sgstChannel0ModulateRGBA));
break;
}
}
else if(sgD3DCompatibility::sgCombineMode[0] == GL_INTERPOLATE_EXT)
{
g.m_d3ddev->ApplyStateBlock(sgD3DCompatibility::sgGetShader(
sgD3DCompatibility::sgstChannel0InterpolateRGB));
}
else
{
switch (ti.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[0][9]);
break;
}
}
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
break;
}
if (g.m_mtex != FALSE) {
TexInfo &ti2 = g.m_tex[g.m_curstagebinding[1]];
if (ti2.m_dwStage != 1)
{
g.m_d3ddev->DeleteStateBlock(ti2.m_block);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ADDRESSU,ti2.m_addu);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ADDRESSV,ti2.m_addv);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_MAGFILTER,ti2.m_magmode);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_MINFILTER,ti2.m_minmode);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_MIPFILTER,ti2.m_mipmode);
g.m_d3ddev->SetTexture(1, ti2.m_ddsurf);
g.m_d3ddev->EndStateBlock(&ti2.m_block);
ti2.m_dwStage = 1;
ti2.m_capture = FALSE;
}
if (ti2.m_capture)
{
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ADDRESSU,ti2.m_addu);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ADDRESSV,ti2.m_addv);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_MAGFILTER,ti2.m_magmode);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_MINFILTER,ti2.m_minmode);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_MIPFILTER,ti2.m_mipmode);
g.m_d3ddev->SetTexture(1, ti2.m_ddsurf);
g.m_d3ddev->CaptureStateBlock(ti2.m_block);
ti2.m_capture = FALSE;
}
else
g.m_d3ddev->ApplyStateBlock(ti2.m_block);
switch (g.m_blendmode[1]) {
case GL_REPLACE:
switch (ti2.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti2.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][1]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][0]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][0]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][1]);
break;
}
break;
case GL_MODULATE:
switch (ti2.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti2.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][3]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][2]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][2]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][3]);
break;
}
break;
case GL_DECAL:
switch (ti2.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti2.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][5]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][4]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][4]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][5]);
break;
}
break;
case GL_BLEND:
switch (ti2.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti2.m_rgbaindexed)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][7]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][6]);
break;
case GL_RGB5:
case GL_RGB5_A1:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][6]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][7]);
break;
}
break;
case GL_COMBINE_EXT:
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
if(sgD3DCompatibility::sgCombineMode[1] == GL_MODULATE)
{
switch(ti2.m_internalformat)
{
case GL_RGB5:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(sgD3DCompatibility::sgGetShader(
sgD3DCompatibility::sgstChannel1ModulateRGB));
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
g.m_d3ddev->ApplyStateBlock(sgD3DCompatibility::sgGetShader(
sgD3DCompatibility::sgstChannel1ModulateRGBA));
break;
}
}
else
{
switch (ti2.m_internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti2.m_rgbaindexed)
if (g.m_source2rgbext == GL_CONSTANT_EXT)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][8]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][10]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][9]);
break;
case GL_RGB5:
case GL_RGB:
case GL_RGB8:
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][9]);
break;
case GL_RGBA4:
case GL_RGBA:
case GL_RGBA8:
if (g.m_source2rgbext == GL_CONSTANT_EXT)
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][8]);
else
g.m_d3ddev->ApplyStateBlock(g.m_shaders[1][10]);
break;
}
}
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
break;
}
}
g.m_texHandleValid = TRUE;
}
if (g.m_texgen[0] && g.m_texgenmode[0] == GL_OBJECT_LINEAR)
{
if (g.m_inversedirty)
{
D3DMATRIX world;
float det;
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_WORLD, &world);
D3DXMatrixInverse((D3DXMATRIX *) &g.m_inverseworld,&det,(const D3DXMATRIX *) &world);
}
if ((g.m_inversedirty || g.m_objectdirty[0]) &&
g.m_texgen[0] && g.m_texgenmode[0] == GL_OBJECT_LINEAR)
{
D3DMATRIX object;
GLfloat *u = g.m_texgenplane[0][0];
GLfloat *v = g.m_texgenplane[0][1];
object._11 = u[0]; object._12 = v[0]; object._13 = 0; object._14 = 0;
object._21 = u[1]; object._22 = v[1]; object._23 = 0; object._24 = 0;
object._31 = u[2]; object._32 = v[2]; object._33 = 0; object._34 = 0;
object._41 = u[3]; object._42 = v[3]; object._43 = 0; object._44 = 0;
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0,&object);
g.m_d3ddev->MultiplyTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_curtexmatrix);
g.m_d3ddev->MultiplyTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_inverseworld);
if (g.m_objectdirty[0])
g.m_objectdirty[0] = FALSE;
}
if (g.m_inversedirty)
g.m_inversedirty = FALSE;
}
}
}
static void RawToCanon(DWORD dwFormat, DWORD dwWidth, DWORD dwHeight, const void *lpPixels, DWORD *lpdwCanon)
{
switch (dwFormat)
{
case GL_ALPHA:
case GL_LUMINANCE:
case GL_COLOR_INDEX8_EXT:
{
for (int i = 0, j = dwWidth*dwHeight; i < j; ++i)
{
DWORD t = ((UCHAR *) lpPixels)[i];
lpdwCanon[i] = (t << 24) | (t << 16) | (t << 8) | t;
}
}
break;
case GL_RGB5_A1:
{
USHORT *rgba = (USHORT *) lpPixels;
for (int i = 0, j = dwWidth * dwHeight; i < j; ++i)
lpdwCanon[i] = ((rgba[i] & 0xF800) >> 8) | 0x7 |
((rgba[i] & 0x07C0) << 5) | 0x700 |
((rgba[i] & 0x003E) << 18) | 0x70000;
}
break;
case GL_RGB5:
case GL_RGB:
{
UCHAR *rgb = (UCHAR *) lpPixels;
for (int i = 0, j = dwWidth * dwHeight, k = 0; i < j; ++i, k += 3)
lpdwCanon[i] = rgb[k] | (rgb[k+1] << 8) | (rgb[k+2] << 16);
}
break;
case GL_RGBA4:
case GL_RGBA:
memcpy(lpdwCanon, lpPixels, dwWidth * dwHeight * sizeof(DWORD));
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unsupported texture format: %x\n", dwFormat);
OutputDebugString(buf);
}
}
}
static void Resize(DWORD dwWidth, DWORD dwHeight, const DWORD *lpdwCanon,
DWORD dwNewWidth, DWORD dwNewHeight, DWORD *lpdwNewCanon)
{
DWORD i, j;
double rx = (double) dwWidth / (double) dwNewWidth;
double ry = (double) dwHeight / (double) dwNewHeight;
for (i = 0; i < dwNewHeight; ++i)
for (j = 0; j < dwNewWidth; ++j)
lpdwNewCanon[i * dwNewWidth + j] = lpdwCanon[((DWORD)(i * ry)) * dwWidth + (DWORD)(j * rx)];
}
static void ALPHATo8888(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
DWORD *lpPixels = (DWORD *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (DWORD *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = lpuchar[i] << 24;
}
static void ALPHATo4444(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = (lpuchar[i] & 0xF0) << 8;
}
static void ALPHATo8(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
UCHAR *lpPixels = (UCHAR *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels += lpddsd->lPitch)
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = lpuchar[i];
}
static void LUMINANCETo8888(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
DWORD *lpPixels = (DWORD *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (DWORD *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
{
DWORD t = lpuchar[i];
lpPixels[l] = t << 24 | t << 16 | t << 8 | t;
}
}
static void LUMINANCETo4444(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
{
DWORD t = lpuchar[i] & 0xF0;
lpPixels[l] = t << 8 | t << 4 | t | t >> 4;
}
}
static void LUMINANCETo8(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
UCHAR *lpPixels = (UCHAR *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels += lpddsd->lPitch)
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = lpuchar[i];
}
static void RGBCOLOR_INDEXTo8(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
UCHAR *lpPixels = (UCHAR *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = lpPixels + lpddsd->lPitch)
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = lpuchar[i];
}
static void RGBCOLOR_INDEXTo4444(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
WORD *lpPixels = (WORD *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (WORD *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = g.m_rgbapalette[lpuchar[i]];
}
static void CanonToRGBCOLOR_INDEXTo4444(LPRECT lprect, const DWORD *lpdwCanon, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
WORD *lpPixels = (WORD *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (WORD *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = g.m_rgbapalette[lpdwCanon[i] & 0xFF];
}
static void CanonTo8(LPRECT lprect, const DWORD *lpdwCanon, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
UCHAR *lpPixels = (UCHAR *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (UCHAR *) lpPixels + lpddsd->lPitch)
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = (UCHAR) (lpdwCanon[i] & 0xFF);
}
static void RGBTo565(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, i += 3, ++l)
lpPixels[l] = ((lpuchar[i] & 0xF8) << 8) | ((lpuchar[i+1] & 0xFC) << 3) | ((lpuchar[i+2] & 0xF8) >> 3);
}
static void RGBTo555(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, i += 3, ++l)
lpPixels[l] = ((lpuchar[i] & 0xF8) << 7) | ((lpuchar[i+1] & 0xF8) << 2) | ((lpuchar[i+2] & 0xF8) >> 3);
}
static void CanonTo565(LPRECT lprect, const DWORD *lpdwCanon, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT*)lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = (USHORT) (((lpdwCanon[i] & 0xF8) << 8) | ((lpdwCanon[i] & 0xFC00) >> 5) | ((lpdwCanon[i] & 0xF80000) >> 19));
}
static void RGB5To565(LPRECT lprect, const USHORT *lpushort, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = (lpushort[i] & 0xFFC0) | 0x20 | ((lpushort[i] & 0x3E) >> 1);
}
static void CanonTo555(LPRECT lprect, const DWORD *lpdwCanon, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = (USHORT) (((lpdwCanon[i] & 0xF8) << 7) | ((lpdwCanon[i] & 0xF800) >> 6) | ((lpdwCanon[i] & 0xF80000) >> 19));
}
static void RGB5To555(LPRECT lprect, const USHORT *lpushort, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT*)lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = lpushort[i] >> 1;
}
static void CanonTo4444(LPRECT lprect, const DWORD *lpdwCanon, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
USHORT *lpPixels = (USHORT *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (USHORT *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = (USHORT) (((lpdwCanon[i] & 0xF0) << 4) | ((lpdwCanon[i] & 0xF000) >> 8) | ((lpdwCanon[i] & 0xF00000) >> 20) | ((lpdwCanon[i] & 0xF0000000) >> 16));
}
static void CanonTo8888(LPRECT lprect, const DWORD *lpdwCanon, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
DWORD *lpPixels = (DWORD*)lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (DWORD *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, ++i, ++l)
lpPixels[l] = ((lpdwCanon[i] & 0xFF00FF00) | ((lpdwCanon[i] & 0xFF) << 16) | ((lpdwCanon[i] & 0xFF0000) >> 16));
}
static void RGBTo8888(LPRECT lprect, const UCHAR *lpuchar, LPDDSURFACEDESC2 lpddsd)
{
LONG i, j, k, l;
DWORD *lpPixels = (DWORD *) lpddsd->lpSurface;
for (k = lprect->top, i = 0; k < lprect->bottom; ++k, lpPixels = (DWORD *) ((UCHAR *) lpPixels + lpddsd->lPitch))
for (j = lprect->left, l = 0; j < lprect->right; ++j, i += 3, ++l)
lpPixels[l] = (lpuchar[i]) << 16 | (lpuchar[i+1] << 8) | lpuchar[i+2];
}
static void LoadSurface(LPDIRECTDRAWSURFACE7 lpDDS, DWORD dwFormat,
DWORD dwWidth, DWORD dwHeight, DWORD dwNewWidth, DWORD dwNewHeight,
const void *pixels)
{
DDSURFACEDESC2 ddsd;
HRESULT ddrval;
DWORD *lpdwCanon, *lpdwNewCanon;
RECT rect;
/*
* Lock the surface so it can be filled with the texture
*/
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddrval = lpDDS->Lock(NULL, &ddsd, DDLOCK_NOSYSLOCK | DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT | DDLOCK_WRITEONLY, NULL);
if (ddrval != DD_OK) {
lpDDS->Release();
OutputDebugString("Lock failed while loading surface\n");
return;
}
SetRect(&rect, 0, 0, ddsd.dwWidth, ddsd.dwHeight);
if (dwWidth == dwNewWidth && dwHeight == dwNewHeight)
{
switch (dwFormat)
{
case GL_ALPHA:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
ALPHATo8888(&rect,(const UCHAR *) pixels,&ddsd);
else
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF00)
ALPHATo4444(&rect,(const UCHAR *) pixels,&ddsd);
else
ALPHATo8(&rect,(const UCHAR *) pixels,&ddsd);
break;
case GL_LUMINANCE:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
LUMINANCETo8888(&rect,(const UCHAR *) pixels,&ddsd);
else
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF00)
LUMINANCETo4444(&rect,(const UCHAR *) pixels,&ddsd);
else
LUMINANCETo8(&rect,(const UCHAR *) pixels,&ddsd);
break;
case GL_COLOR_INDEX8_EXT:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF00)
RGBCOLOR_INDEXTo4444(&rect,(const UCHAR *) pixels, &ddsd);
else
RGBCOLOR_INDEXTo8(&rect,(const UCHAR *) pixels, &ddsd);
break;
case GL_RGB5:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
RGBTo565(&rect,(const UCHAR *) pixels,&ddsd);
else
RGBTo555(&rect,(const UCHAR *) pixels,&ddsd);
break;
case GL_RGB5_A1:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
RGB5To565(&rect,(const USHORT *) pixels,&ddsd);
else
RGB5To555(&rect,(const USHORT *) pixels,&ddsd);
break;
case GL_RGBA4:
CanonTo4444(&rect,(const DWORD *) pixels,&ddsd);
break;
case GL_RGB:
case GL_RGB8:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
RGBTo8888(&rect,(const UCHAR *) pixels,&ddsd);
else
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
RGBTo565(&rect,(const UCHAR *) pixels,&ddsd);
else
RGBTo555(&rect,(const UCHAR *) pixels,&ddsd);
break;
case GL_RGBA:
case GL_RGBA8:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
CanonTo8888(&rect,(const DWORD *) pixels,&ddsd);
else
CanonTo4444(&rect,(const DWORD *) pixels,&ddsd);
break;
}
}
else
{
/*
* Convert the GL texture into a canonical format (8888),
* so that we can cleanly do image ops (such as resize) without
* having to worry about the bit format.
*/
lpdwCanon = (DWORD *) malloc(dwWidth * dwHeight * sizeof(DWORD));
RawToCanon(dwFormat, dwWidth, dwHeight, pixels, lpdwCanon);
/* Now resize the canon image */
lpdwNewCanon = (DWORD *) malloc(dwNewWidth * dwNewHeight * sizeof(DWORD));
Resize(dwWidth, dwHeight, lpdwCanon, dwNewWidth, dwNewHeight, lpdwNewCanon);
free(lpdwCanon);
/* Copy the texture into the surface */
if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8)
CanonTo8(&rect, lpdwNewCanon, &ddsd);
else if (ddsd.ddpfPixelFormat.dwRGBAlphaBitMask == 0xF000)
if (dwFormat == GL_COLOR_INDEX8_EXT)
CanonToRGBCOLOR_INDEXTo4444(&rect, lpdwNewCanon, &ddsd);
else
CanonTo4444(&rect, lpdwNewCanon, &ddsd);
else if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
CanonTo565(&rect, lpdwNewCanon, &ddsd);
else if (ddsd.ddpfPixelFormat.dwRBitMask == 0x7C00)
CanonTo555(&rect, lpdwNewCanon, &ddsd);
else
CanonTo8888(&rect, lpdwNewCanon, &ddsd);
free(lpdwNewCanon);
}
/*
* unlock the surface
*/
lpDDS->Unlock(NULL);
}
static HRESULT LoadSubSurface(LPDIRECTDRAWSURFACE7 lpDDS, DWORD dwFormat,
DWORD dwWidth, DWORD dwHeight, const void *pixels,
LPRECT lpsubimage)
{
DDSURFACEDESC2 ddsd;
HRESULT ddrval;
DWORD *lpdwCanon, *lpdwNewCanon;
DWORD dwNewWidth=lpsubimage->right-lpsubimage->left;
DWORD dwNewHeight=lpsubimage->bottom-lpsubimage->top;
/*
* Lock the surface so it can be filled with the texture
*/
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddrval = lpDDS->Lock(lpsubimage, &ddsd, DDLOCK_NOSYSLOCK | DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT | DDLOCK_WRITEONLY, NULL);
if (ddrval != DD_OK) {
lpDDS->Release();
OutputDebugString("Lock failed while loading surface\n");
return ddrval;
}
if (dwWidth == dwNewWidth && dwHeight == dwNewHeight)
{
switch (dwFormat)
{
case GL_ALPHA:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
ALPHATo8888(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF00)
ALPHATo4444(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
ALPHATo8(lpsubimage,(const UCHAR *) pixels,&ddsd);
break;
case GL_LUMINANCE:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
LUMINANCETo8888(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF00)
LUMINANCETo4444(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
LUMINANCETo8(lpsubimage,(const UCHAR *) pixels,&ddsd);
break;
case GL_COLOR_INDEX8_EXT:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF00)
RGBCOLOR_INDEXTo4444(lpsubimage,(const UCHAR *) pixels, &ddsd);
else
RGBCOLOR_INDEXTo8(lpsubimage,(const UCHAR *) pixels, &ddsd);
break;
case GL_RGB5:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
RGBTo565(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
RGBTo555(lpsubimage,(const UCHAR *) pixels,&ddsd);
break;
case GL_RGB5_A1:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
RGB5To565(lpsubimage,(const USHORT *) pixels,&ddsd);
else
RGB5To555(lpsubimage,(const USHORT *) pixels,&ddsd);
break;
case GL_RGBA4:
CanonTo4444(lpsubimage,(const DWORD *) pixels,&ddsd);
break;
case GL_RGB:
case GL_RGB8:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
RGBTo8888(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
RGBTo565(lpsubimage,(const UCHAR *) pixels,&ddsd);
else
RGBTo555(lpsubimage,(const UCHAR *) pixels,&ddsd);
break;
case GL_RGBA:
case GL_RGBA8:
if (ddsd.ddpfPixelFormat.dwRBitMask == 0xFF0000)
CanonTo8888(lpsubimage,(const DWORD *) pixels,&ddsd);
else
CanonTo4444(lpsubimage,(const DWORD *) pixels,&ddsd);
break;
}
}
else
{
/*
* Convert the GL texture into a canonical format (8888),
* so that we can cleanly do image ops (such as resize) without
* having to worry about the bit format.
*/
lpdwCanon = (DWORD *) malloc(dwWidth * dwHeight * sizeof(DWORD));
RawToCanon(dwFormat, dwWidth, dwHeight, pixels, lpdwCanon);
/* Now resize the canon image */
lpdwNewCanon = (DWORD *) malloc(dwWidth * dwHeight * sizeof(DWORD));
Resize(dwWidth, dwHeight, lpdwCanon, dwNewWidth, dwNewHeight, lpdwNewCanon);
free(lpdwCanon);
/* Copy the texture into the surface */
if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8)
CanonTo8(lpsubimage,lpdwNewCanon,&ddsd);
else if (ddsd.ddpfPixelFormat.dwRGBAlphaBitMask == 0xF000)
if (dwFormat == GL_COLOR_INDEX8_EXT)
CanonToRGBCOLOR_INDEXTo4444(lpsubimage,lpdwNewCanon,&ddsd);
else
CanonTo4444(lpsubimage,lpdwNewCanon,&ddsd);
else if (ddsd.ddpfPixelFormat.dwRBitMask == 0xF800)
CanonTo565(lpsubimage,lpdwNewCanon,&ddsd);
else if (ddsd.ddpfPixelFormat.dwRBitMask == 0x7C00)
CanonTo555(lpsubimage, lpdwNewCanon, &ddsd);
else
CanonTo8888(lpsubimage, lpdwNewCanon, &ddsd);
free(lpdwNewCanon);
}
/*
* unlock the surface
*/
lpDDS->Unlock(NULL);
return DD_OK;
}
///////////////////////////// BEGIN API ENTRIES ///////////////////////////////////////////////////
GLAPI void GLAPIENTRY glActiveTextureARB(GLenum texture)
{
g.m_curtgt = texture == GL_TEXTURE0_ARB ? 0 : 1;
}
GLAPI void GLAPIENTRY glAlphaFunc (GLenum func, GLclampf ref)
{
int funcvalue = -1;
switch(func) {
case GL_NEVER:
funcvalue=D3DCMP_NEVER;
break;
case GL_LESS:
funcvalue=D3DCMP_LESS;
break;
case GL_EQUAL:
funcvalue=D3DCMP_EQUAL;
break;
case GL_LEQUAL:
funcvalue=D3DCMP_LESSEQUAL;
break;
case GL_GREATER:
funcvalue=D3DCMP_GREATER;
break;
case GL_NOTEQUAL:
funcvalue=D3DCMP_NOTEQUAL;
break;
case GL_GEQUAL:
funcvalue=D3DCMP_GREATEREQUAL;
break;
case GL_ALWAYS:
funcvalue=D3DCMP_ALWAYS;
break;
}
if (funcvalue >= 0) {
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ALPHAFUNC, funcvalue);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ALPHAREF, (D3DFIXED)(ref * 255.f));
}
}
GLAPI void GLAPIENTRY glArrayElement (GLint i)
{
if (g.m_usetexcoordary[0])
{
GLfloat *start0 = (GLfloat *) &((unsigned char *) g.m_texcoordary[0])[i*g.m_texcoordstride[0]];
g.m_tu = start0[0];
g.m_tv = start0[1];
}
if (g.m_usetexcoordary[1])
{
GLfloat *start1 = (GLfloat *) &((unsigned char *) g.m_texcoordary[1])[i*g.m_texcoordstride[1]];
g.m_tu2 = start1[0];
g.m_tv2 = start1[1];
}
if (g.m_usecolorary)
if (g.m_colortype == GL_UNSIGNED_BYTE)
{
#ifdef _X86_
_asm
{
mov ebx, g.m_colorary;
mov eax, i;
mov edx, g.m_colorstride;
mul edx;
cld;
mov esi, eax;
mov edx, 0x00FF00FF;
mov eax, [ebx + esi];
mov ecx, eax;
and eax, edx;
not edx;
rol eax, 16;
and ecx, edx;
or eax, ecx;
mov g.m_color, eax;
}
#else
GLubyte *start = &((GLubyte *) g.m_colorary)[i*g.m_colorstride];
g.m_color = RGBA_MAKE(start[0],start[1],start[2],start[3]);
#endif
}
else
{
GLfloat *start = (GLfloat *) &((unsigned char *) g.m_colorary)[i*g.m_colorstride];
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
mov ebx, start;
fld [ebx];
fld [ebx + 4];
fld [ebx + 8];
fld [ebx + 12];
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov g.m_color, eax;
}
#else
R = (unsigned int)(start[0] * two55);
G = (unsigned int)(start[1] * two55);
B = (unsigned int)(start[2] * two55);
A = (unsigned int)(start[3] * two55);
if (R > 255)
R = 255;
if (G > 255)
G = 255;
if (B > 255)
B = 255;
if (A > 255)
A = 255;
g.m_color = RGBA_MAKE(R, G, B, A);
#endif
}
if (g.m_usenormalary)
{
unsigned char *start = &((unsigned char *) g.m_normalary)[i*g.m_normalstride];
memcpy(&g.m_nx,start,sizeof(D3DVALUE)*3);
}
if (g.m_nfv[g.m_comp] + g.m_vcnt[g.m_comp] >= (VBUFSIZE - MAXVERTSPERPRIM))
{
if (g.m_prim == GL_TRIANGLES)
{
if (g.m_vcnt[g.m_comp] % 3 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if (g.m_prim == GL_QUADS)
{
if (g.m_vcnt[g.m_comp] % 4 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if(g.m_prim == GL_LINES)
{
if (g.m_vcnt[g.m_comp] % 2 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
}
if (g.m_vertarysize == 2)
{
#ifdef _X86_
_asm
{
mov eax, i;
mov edx, g.m_vertexstride;
mul edx;
cld;
mov esi, g.m_vertexary;
mov ecx, g.m_comp;
mov edi, g.m_verts;
add esi, eax;
mov eax, g.m_vcnt[ecx * 4];
lea edx, [eax + 1];
mov g.m_vcnt[ecx * 4], edx;
lea edx, [ecx * 8 + 28];
mul edx;
cld;
add edi, eax;
movsd;
movsd;
mov eax, 0;
movsd;
lea esi, g.m_nx;
lea ecx, [ecx * 2 + 4];
rep movsd;
}
#else
D3DVALUE *d3dv = &(((D3DVALUE*)g.m_verts)[g.m_vcnt[g.m_comp]++ * (g.m_comp * 2 + 7)]);
GLfloat *v = (GLfloat *) &((unsigned char *) g.m_vertexary)[i * g.m_vertexstride];
*(d3dv++) = v[0];
*(d3dv++) = v[1];
*(d3dv++) = 0.0;
memcpy(d3dv, &g.m_nx, sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + g.m_comp*sizeof(D3DVALUE)*2);
#endif
}
else
{
#ifdef _X86_
_asm
{
mov eax, i;
mov edx, g.m_vertexstride;
mul edx;
cld;
mov esi, g.m_vertexary;
mov ecx, g.m_comp;
mov edi, g.m_verts;
add esi, eax;
mov eax, g.m_vcnt[ecx * 4];
lea edx, [eax + 1];
mov g.m_vcnt[ecx * 4], edx;
lea edx, [ecx * 8 + 28];
mul edx;
cld;
add edi, eax;
movsd;
movsd;
movsd;
lea esi, g.m_nx;
lea ecx, [ecx * 2 + 4];
rep movsd;
}
#else
D3DVALUE *d3dv = &(((D3DVALUE*)g.m_verts)[g.m_vcnt[g.m_comp]++ * (g.m_comp * 2 + 7)]);
GLfloat *v = (GLfloat *) &((unsigned char *) g.m_vertexary)[i * g.m_vertexstride];
*(d3dv++) = v[0];
*(d3dv++) = v[1];
*(d3dv++) = v[2];
memcpy(d3dv, &g.m_nx, sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + g.m_comp*sizeof(D3DVALUE)*2);
#endif
}
}
GLAPI void GLAPIENTRY glBegin (GLenum mode)
{
g.m_prim = mode;
if(g.m_texturing)
{
if(g.m_mtex)
{
g.m_comp = 2;
g.m_vcnt[2] = 0;
if(g.m_nfv[2] > (VBUFSIZE - MAXVERTSPERPRIM)) // check if space available
{
g.m_mtvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[2] = 0;
}
else
{
g.m_mtvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeMTVertex*)g.m_verts)[g.m_nfv[2]]);
}
}
else
{
g.m_comp = 1;
g.m_vcnt[1] = 0;
if(g.m_nfv[1] > (VBUFSIZE - MAXVERTSPERPRIM)) // check if space available
{
g.m_tvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[1] = 0;
}
else
{
g.m_tvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeTVertex*)g.m_verts)[g.m_nfv[1]]);
}
}
}
else
{
g.m_comp = 0;
g.m_vcnt[0] = 0;
if(g.m_nfv[0] > (VBUFSIZE - MAXVERTSPERPRIM)) // check if space available
{
g.m_vbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[0] = 0;
}
else
{
g.m_vbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeVertex*)g.m_verts)[g.m_nfv[0]]);
}
}
QuakeSetTexturingState();
}
GLAPI void GLAPIENTRY glBindTexture (GLenum target, GLuint texture)
{
target;
g.m_curstagebinding[g.m_curtgt] = texture;
g.m_texHandleValid = FALSE;
}
GLAPI void GLAPIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor)
{
int svalue = -1, dvalue = -1;
switch(sfactor) {
case GL_ZERO:
svalue=D3DBLEND_ZERO;
break;
case GL_ONE:
svalue=D3DBLEND_ONE;
break;
case GL_DST_COLOR:
svalue=D3DBLEND_DESTCOLOR;
break;
case GL_ONE_MINUS_DST_COLOR:
svalue=D3DBLEND_INVDESTCOLOR;
break;
case GL_SRC_ALPHA:
svalue=D3DBLEND_SRCALPHA;
break;
case GL_ONE_MINUS_SRC_ALPHA:
svalue=D3DBLEND_INVSRCALPHA;
break;
case GL_DST_ALPHA:
svalue=D3DBLEND_DESTALPHA;
break;
case GL_ONE_MINUS_DST_ALPHA:
svalue=D3DBLEND_INVDESTALPHA;
break;
case GL_SRC_ALPHA_SATURATE:
svalue=D3DBLEND_SRCALPHASAT;
break;
}
switch(dfactor) {
case GL_ZERO:
dvalue=D3DBLEND_ZERO;
break;
case GL_ONE:
dvalue=D3DBLEND_ONE;
break;
case GL_SRC_COLOR:
dvalue=D3DBLEND_SRCCOLOR;
break;
case GL_ONE_MINUS_SRC_COLOR:
dvalue=D3DBLEND_INVSRCCOLOR;
break;
case GL_SRC_ALPHA:
dvalue=D3DBLEND_SRCALPHA;
break;
case GL_ONE_MINUS_SRC_ALPHA:
dvalue=D3DBLEND_INVSRCALPHA;
break;
case GL_DST_ALPHA:
dvalue=D3DBLEND_DESTALPHA;
break;
case GL_ONE_MINUS_DST_ALPHA:
dvalue=D3DBLEND_INVDESTALPHA;
break;
}
if (svalue >= 0) g.m_d3ddev->SetRenderState(D3DRENDERSTATE_SRCBLEND, (DWORD)svalue);
if (dvalue >= 0) g.m_d3ddev->SetRenderState(D3DRENDERSTATE_DESTBLEND, (DWORD)dvalue);
}
GLAPI void GLAPIENTRY glClear (GLbitfield mask)
{
DWORD flags = 0;
if (mask & GL_COLOR_BUFFER_BIT)
flags |= D3DCLEAR_TARGET;
if (mask & GL_DEPTH_BUFFER_BIT)
flags |= D3DCLEAR_ZBUFFER;
if (mask & GL_STENCIL_BUFFER_BIT)
flags |= D3DCLEAR_STENCIL;
if (g.m_updvwp)
QuakeUpdateViewport();
g.m_d3ddev->Clear(0, NULL, flags, g.m_clearColor, (D3DVALUE) g.m_clearDepth, 0);
}
GLAPI void GLAPIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
fld red;
fld green;
fld blue;
fld alpha;
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov g.m_clearColor, eax;
}
#else
R = (unsigned int)(red * two55);
G = (unsigned int)(green * two55);
B = (unsigned int)(blue * two55);
A = (unsigned int)(alpha * two55);
if(R > 255)
R = 255;
if(G > 255)
G = 255;
if(B > 255)
B = 255;
if(A > 255)
A = 255;
g.m_clearColor = RGBA_MAKE(R, G, B, A);
#endif
}
GLAPI void GLAPIENTRY glClearDepth (GLclampd depth)
{
g.m_clearDepth = depth;
}
GLAPI void GLAPIENTRY glClientActiveTextureARB(GLenum texture)
{
g.m_client_active_texture_arb = texture == GL_TEXTURE0_ARB ? 0 : 1;
}
GLAPI void GLAPIENTRY glClipPlane (GLenum plane, const GLdouble *equation)
{
plane;
equation;
}
GLAPI void GLAPIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue)
{
static float two55 = 255.f;
unsigned int R, G, B;
#ifdef _X86_
__asm {
fld red;
fld green;
fld blue;
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmulp st(3), st(0);
fistp B;
fistp G;
fistp R;
mov eax, B;
cmp eax, 255;
jle pt1;
mov eax, 255;
pt1: mov ebx, G;
cmp ebx, 255;
jle pt2;
mov ebx, 255;
pt2: mov ecx, R;
cmp ecx, 255;
jle pt3;
mov ecx, 255;
pt3: shl ebx, 8;
shl ecx, 16;
or eax, ebx;
or ecx, 0xFF000000;
or eax, ecx;
mov g.m_color, eax;
}
#else
R = (unsigned int)(red * two55);
G = (unsigned int)(green * two55);
B = (unsigned int)(blue * two55);
if(R > 255)
R = 255;
if(G > 255)
G = 255;
if(B > 255)
B = 255;
g.m_color = RGBA_MAKE(R, G, B, 255);
#endif
dirtyArray();
}
GLAPI void GLAPIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue)
{
g.m_color = RGBA_MAKE(red, green, blue, 255);
dirtyArray();
}
GLAPI void GLAPIENTRY glColor3ubv (const GLubyte *v)
{
g.m_color = RGBA_MAKE(v[0], v[1], v[2], 255);
dirtyArray();
}
GLAPI void GLAPIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
g.m_color = RGBA_MAKE(red, green, blue, alpha);
dirtyArray();
}
GLAPI void GLAPIENTRY glColor4ubv (const GLubyte *v)
{
#ifdef _X86_
_asm
{
mov ebx, v;
mov edx, 0x00FF00FF;
mov eax, [ebx];
mov ecx, eax;
and eax, edx;
not edx;
rol eax, 16;
and ecx, edx;
or eax, ecx;
mov g.m_color, eax;
}
#else
g.m_color = RGBA_MAKE(v[0], v[1], v[2], v[3]);
#endif
dirtyArray();
}
GLAPI void GLAPIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
fld red;
fld green;
fld blue;
fld alpha;
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov g.m_color, eax;
}
#else
R = (unsigned int)(red * two55);
G = (unsigned int)(green * two55);
B = (unsigned int)(blue * two55);
A = (unsigned int)(alpha * two55);
if(R > 255)
R = 255;
if(G > 255)
G = 255;
if(B > 255)
B = 255;
if(A > 255)
A = 255;
g.m_color = RGBA_MAKE(R, G, B, A);
#endif
dirtyArray();
}
GLAPI void GLAPIENTRY glColor4fv (const GLfloat *v)
{
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
mov ebx, v;
fld [ebx];
fld [ebx + 4];
fld [ebx + 8];
fld [ebx + 12];
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov g.m_color, eax;
}
#else
R = (unsigned int)(v[0] * two55);
G = (unsigned int)(v[1] * two55);
B = (unsigned int)(v[2] * two55);
A = (unsigned int)(v[3] * two55);
if(R > 255)
R = 255;
if(G > 255)
G = 255;
if(B > 255)
B = 255;
if(A > 255)
A = 255;
g.m_color = RGBA_MAKE(R, G, B, A);
#endif
dirtyArray();
}
GLAPI void GLAPIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
if (size == 4 && (type == GL_UNSIGNED_BYTE || type == GL_FLOAT))
{
if (stride)
g.m_colorstride = stride;
else
g.m_colorstride = (type == GL_UNSIGNED_BYTE) ? 4 : 16;
g.m_colortype = type;
g.m_colorary = pointer;
}
else
OutputDebugString("Color array not supported\n");
}
GLAPI void GLAPIENTRY glCullFace (GLenum mode)
{
g.m_cullMode = mode;
if(g.m_cullEnabled == TRUE){
DWORD statevalue;
if ((mode == GL_BACK && g.m_frontFace == GL_CCW) ||
(mode == GL_FRONT && g.m_frontFace == GL_CW))
statevalue=D3DCULL_CW;
else
statevalue=D3DCULL_CCW;
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_CULLMODE, statevalue);
}
}
GLAPI void GLAPIENTRY glGenTextures (GLsizei n, GLuint *textures)
{
GLListManip<GLuint> freeTextures(&g.m_freeTextures);
for (int i = 0; i < n; ++i)
{
textures[i] = freeTextures();
freeTextures.remove();
}
}
GLAPI void GLAPIENTRY glDeleteTextures (GLsizei n, const GLuint *textures)
{
GLListManip<GLuint> freeTextures(&g.m_freeTextures);
for(int i = 0; i < n; ++i) {
TexInfo &ti = g.m_tex[textures[i]];
if(ti.m_ddsurf != 0) {
ti.m_ddsurf->Release();
ti.m_ddsurf = 0;
}
if(ti.m_block != 0)
{
g.m_d3ddev->DeleteStateBlock(ti.m_block);
ti.m_block = 0;
}
ti.m_capture = FALSE;
ti.m_dwStage = 0;
ti.m_minmode = D3DTFN_POINT;
ti.m_magmode = D3DTFG_LINEAR;
ti.m_mipmode = D3DTFP_LINEAR;
ti.m_addu = D3DTADDRESS_WRAP;
ti.m_addv = D3DTADDRESS_WRAP;
ti.m_rgbaindexed = FALSE;
if (ti.m_palette)
{
ti.m_palette->Release();
ti.m_palette = 0;
}
freeTextures.insert(textures[i]);
}
}
GLAPI void GLAPIENTRY glDepthFunc (GLenum func)
{
int state = -1;
switch(func) {
case GL_NEVER:
state=D3DCMP_NEVER;
break;
case GL_LESS:
state=D3DCMP_LESS;
break;
case GL_EQUAL:
state=D3DCMP_EQUAL;
break;
case GL_LEQUAL:
state=D3DCMP_LESSEQUAL;
break;
case GL_GREATER:
state=D3DCMP_GREATER;
break;
case GL_NOTEQUAL:
state=D3DCMP_NOTEQUAL;
break;
case GL_GEQUAL:
state=D3DCMP_GREATEREQUAL;
break;
case GL_ALWAYS:
state=D3DCMP_ALWAYS;
break;
}
if(state >= 0)
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZFUNC, state);
}
GLAPI void GLAPIENTRY glDepthMask (GLboolean flag)
{
if(flag == 0)
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, FALSE);
else
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, TRUE);
}
GLAPI void GLAPIENTRY glDepthRange (GLclampd zNear, GLclampd zFar)
{
if(zFar == zNear)
{
zFar += .001;
zNear -= .001;
}
if(zNear < 0.)
zNear = 0.;
if(zNear > 1.)
zNear = 1.;
if(zFar < 0.)
zFar = 0.;
if(zFar > 1.)
zFar = 1.;
D3DVIEWPORT7 vport;
g.m_d3ddev->GetViewport(&vport);
vport.dvMinZ = (D3DVALUE)zNear;
vport.dvMaxZ = (D3DVALUE)zFar;
g.m_d3ddev->SetViewport(&vport);
}
GLAPI void GLAPIENTRY glEnd (void)
{
if (g.m_texturing)
{
if (g.m_mtex)
{
if (g.m_vcnt[2] && g.m_prim == GL_LINE_LOOP)
{
D3DVALUE *d3dv = (D3DVALUE *) g.m_verts;
memcpy(&g.m_nx,&d3dv[3],sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + sizeof(D3DVALUE)*4);
glVertex3fv(d3dv);
}
g.m_mtvbuf->Unlock();
if(g.m_vcnt[2] == 0)
return;
unsigned i;
switch(g.m_prim)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_mtvbuf, g.m_nfv[2], g.m_vcnt[2], 0);
g.m_nfv[2] += g.m_vcnt[2];
break;
case GL_LINE_LOOP:
case GL_LINE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINESTRIP, g.m_mtvbuf, g.m_nfv[2], g.m_vcnt[2], 0);
g.m_nfv[2] += g.m_vcnt[2];
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_mtvbuf, g.m_nfv[2], g.m_vcnt[2], 0);
g.m_nfv[2] += g.m_vcnt[2];
break;
case GL_TRIANGLE_STRIP:
case GL_QUAD_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_mtvbuf, g.m_nfv[2], g.m_vcnt[2], 0);
g.m_nfv[2] += g.m_vcnt[2];
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvbuf, g.m_nfv[2], g.m_vcnt[2], 0);
g.m_nfv[2] += g.m_vcnt[2];
break;
case GL_QUADS:
for(i = 0; i < g.m_vcnt[2]; i += 4)
{
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvbuf, g.m_nfv[2], 4, 0);
g.m_nfv[2] += 4;
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",g.m_prim);
OutputDebugString(buf);
}
}
}
else
{
if (g.m_vcnt[1] && g.m_prim == GL_LINE_LOOP)
{
D3DVALUE *d3dv = (D3DVALUE *) g.m_verts;
memcpy(&g.m_nx,&d3dv[3],sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + sizeof(D3DVALUE)*2);
glVertex3fv(d3dv);
}
g.m_tvbuf->Unlock();
if(g.m_vcnt[1] == 0)
return;
unsigned i;
switch(g.m_prim)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_tvbuf, g.m_nfv[1], g.m_vcnt[1], 0);
g.m_nfv[1] += g.m_vcnt[1];
break;
case GL_LINE_LOOP:
case GL_LINE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINESTRIP, g.m_tvbuf, g.m_nfv[1], g.m_vcnt[1], 0);
g.m_nfv[1] += g.m_vcnt[1];
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_tvbuf, g.m_nfv[1], g.m_vcnt[1], 0);
g.m_nfv[1] += g.m_vcnt[1];
break;
case GL_TRIANGLE_STRIP:
case GL_QUAD_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_tvbuf, g.m_nfv[1], g.m_vcnt[1], 0);
g.m_nfv[1] += g.m_vcnt[1];
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvbuf, g.m_nfv[1], g.m_vcnt[1], 0);
g.m_nfv[1] += g.m_vcnt[1];
break;
case GL_QUADS:
for(i = 0; i < g.m_vcnt[1]; i += 4)
{
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvbuf, g.m_nfv[1], 4, 0);
g.m_nfv[1] += 4;
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",g.m_prim);
OutputDebugString(buf);
}
}
}
}
else
{
if (g.m_vcnt[0] && g.m_prim == GL_LINE_LOOP)
{
D3DVALUE *d3dv = (D3DVALUE *) g.m_verts;
memcpy(&g.m_nx,&d3dv[3],sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR));
glVertex3fv(d3dv);
}
g.m_vbuf->Unlock();
if(g.m_vcnt[0] == 0)
return;
unsigned i;
switch(g.m_prim)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_vbuf, g.m_nfv[0], g.m_vcnt[0], 0);
g.m_nfv[0] += g.m_vcnt[0];
break;
case GL_LINE_LOOP:
case GL_LINE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINESTRIP, g.m_vbuf, g.m_nfv[0], g.m_vcnt[0], 0);
g.m_nfv[0] += g.m_vcnt[0];
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_vbuf, g.m_nfv[0], g.m_vcnt[0], 0);
g.m_nfv[0] += g.m_vcnt[0];
break;
case GL_TRIANGLE_STRIP:
case GL_QUAD_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_vbuf, g.m_nfv[0], g.m_vcnt[0], 0);
g.m_nfv[0] += g.m_vcnt[0];
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vbuf, g.m_nfv[0], g.m_vcnt[0], 0);
g.m_nfv[0] += g.m_vcnt[0];
break;
case GL_QUADS:
for(i = 0; i < g.m_vcnt[0]; i += 4)
{
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vbuf, g.m_nfv[0], 4, 0);
g.m_nfv[0] += 4;
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",g.m_prim);
OutputDebugString(buf);
}
}
}
}
static void processVB(unsigned vcount)
{
DWORD vop = D3DVOP_CLIP | D3DVOP_TRANSFORM;
if (g.m_lighting)
vop |= D3DVOP_LIGHT;
if (g.m_useVBuffer != -1)
{
BufferInfo &binfo = g.m_vbuffers[g.m_useVBuffer];
g.m_mtvtgt->ProcessVertices(vop,0,vcount,binfo.buf,binfo.nfv,g.m_d3ddev,0);
}
else if (g.m_usefogary)
{
g.m_fmtvbuf->Unlock();
g.m_fmtvtgt->ProcessVertices(vop,0,vcount,g.m_fmtvbuf,g.m_nfv[3],g.m_d3ddev,0);
}
else if (g.m_texturing)
{
if (g.m_mtex)
{
g.m_mtvbuf->Unlock();
g.m_mtvtgt->ProcessVertices(vop,0,vcount,g.m_mtvbuf,g.m_nfv[2],g.m_d3ddev,0);
}
else
{
g.m_tvbuf->Unlock();
g.m_tvtgt->ProcessVertices(vop,0,vcount,g.m_tvbuf,g.m_nfv[1],g.m_d3ddev,0);
}
}
else
{
g.m_vbuf->Unlock();
g.m_vtgt->ProcessVertices(vop,0,vcount,g.m_vbuf,g.m_nfv[0],g.m_d3ddev,0);
}
}
static void fillVB(BOOL process, unsigned min, unsigned vcount)
{
GLsizei i;
if (g.m_usefogary)
{
g.m_comp = 2;
if (g.m_lckcount != 0)
g.m_incdex = 3;
if (g.m_nfv[3] > (VBUFSIZE - vcount)) // check if space available
{
g.m_fmtvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[3] = 0;
}
else
{
g.m_fmtvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeFMTVertex*)g.m_verts)[g.m_nfv[3]]);
}
}
else if (g.m_texturing)
{
if (g.m_mtex)
{
g.m_comp = 2;
if (g.m_lckcount != 0)
g.m_incdex = 2;
if (g.m_nfv[2] > (VBUFSIZE - vcount)) // check if space available
{
g.m_mtvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[2] = 0;
}
else
{
g.m_mtvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeMTVertex*)g.m_verts)[g.m_nfv[2]]);
}
}
else
{
g.m_comp = 1;
if (g.m_lckcount != 0)
g.m_incdex = 1;
if (g.m_nfv[1] > (VBUFSIZE - vcount)) // check if space available
{
g.m_tvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[1] = 0;
}
else
{
g.m_tvbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeTVertex*)g.m_verts)[g.m_nfv[1]]);
}
}
}
else
{
g.m_comp = 0;
if (g.m_lckcount != 0)
g.m_incdex = 0;
if (g.m_nfv[0] > (VBUFSIZE - vcount)) // check if space available
{
g.m_vbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &g.m_verts, 0);
g.m_nfv[0] = 0;
}
else
{
g.m_vbuf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &g.m_verts, 0);
g.m_verts = &(((QuakeVertex*)g.m_verts)[g.m_nfv[0]]);
}
}
unsigned dstride = 7 + g.m_usefogary + g.m_comp*2;
if (g.m_texturing)
{
if (g.m_usetexcoordary[0])
{
#ifdef false // _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_texcoordstride;
mul ebx;
mov esi, g.m_texcoordary;
lea esi, [eax + esi];
mov ebx, g.m_usefogary;
add ebx, 7;
shl ebx, 2;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_texcoordstride;
sub ebx, 8;
mov edx, dstride;
shl edx, 2;
sub edx, 8;
cld;
lp0: lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp0;
}
#else
unsigned char *tex0 = &((unsigned char *) g.m_texcoordary[0])[min*g.m_texcoordstride[0]];
D3DVALUE *data = (D3DVALUE *) g.m_verts+7 + g.m_usefogary;
for (i = 0; i < vcount; ++i)
{
memcpy(data,tex0,2*sizeof(GLfloat));
tex0 += g.m_texcoordstride[0];
data += dstride;
}
#endif
}
if (g.m_mtex && g.m_usetexcoordary[1])
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_texcoordstride+4;
mul ebx;
mov esi, g.m_texcoordary+4;
lea esi, [eax + esi];
mov ebx, g.m_usefogary;
add ebx, 9;
shl ebx, 2;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_texcoordstride+4;
sub ebx, 8;
mov edx, dstride;
shl edx, 2;
sub edx, 8;
cld;
lp1: lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp1;
}
#else
unsigned char *tex1 = &((unsigned char *) g.m_texcoordary[1])[min*g.m_texcoordstride[1]];
D3DVALUE *data = (D3DVALUE *) g.m_verts+9 + g.m_usefogary;
for (i = 0; i < vcount; ++i)
{
memcpy(data,tex1,2*sizeof(GLfloat));
tex1 += g.m_texcoordstride[1];
data += dstride;
}
#endif
}
}
if (g.m_usenormalary)
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_normalstride;
mul ebx;
mov esi, g.m_normalary;
lea esi, [eax + esi];
mov ebx, 12;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_normalstride;
sub ebx, 12;
mov edx, dstride;
shl edx, 2;
sub edx, 12;
cld;
lp2: lodsd;
stosd;
lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp2;
}
#else
unsigned char *nml = &((unsigned char *) g.m_normalary)[min*g.m_normalstride];
D3DVALUE *data = (D3DVALUE *) g.m_verts+3;
for (i = 0; i < vcount; ++i)
{
memcpy(data,nml,3*sizeof(GLfloat));
nml += g.m_normalstride;
data += dstride;
}
#endif
}
if (g.m_usecolorary)
{
if (g.m_colortype == GL_UNSIGNED_BYTE)
{
#ifdef _X86_
unsigned int esstride = g.m_colorstride - 4;
unsigned int edstride = (dstride-1) * 4;
_asm
{
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_colorstride;
mul ebx;
mov esi, g.m_colorary;
lea esi, [eax + esi];
mov ebx, 24;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov edx, 0x00FF00FF;
cld;
lp3: lodsd;
mov ebx, eax;
and eax, edx;
not edx;
rol eax, 16;
and ebx, edx;
not edx;
or eax, ebx;
stosd;
mov eax, esstride;
lea esi, [eax + esi];
mov ebx, edstride;
lea edi, [ebx + edi];
loop lp3;
}
#else
GLubyte *clr = &((GLubyte *) g.m_colorary)[min*g.m_colorstride];
D3DCOLOR *data = (D3DCOLOR *) g.m_verts+6;
for (i = 0; i < vcount; i++)
{
data[0] = RGBA_MAKE(clr[0],clr[1],clr[2],clr[3]);
clr += g.m_colorstride;
data += dstride;
}
#endif
}
else
{
GLubyte *clr = &((GLubyte *) g.m_colorary)[min*g.m_colorstride];
D3DCOLOR *data = (D3DCOLOR *) g.m_verts+6;
for (i = 0; i < vcount; ++i)
{
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
mov ebx, clr;
fld [ebx];
fld [ebx + 4];
fld [ebx + 8];
fld [ebx + 12];
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt0;
mov edx, 255;
pt0: mov eax, B;
cmp eax, 255;
jle pt1;
mov eax, 255;
pt1: mov ebx, G;
cmp ebx, 255;
jle pt2;
mov ebx, 255;
pt2: mov ecx, R;
cmp ecx, 255;
jle pt3;
mov ecx, 255;
pt3: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov edi, data;
stosd;
}
#else
GLfloat *fclr = (GLfloat *) clr;
R = (unsigned int)(fclr[0] * two55);
G = (unsigned int)(fclr[1] * two55);
B = (unsigned int)(fclr[2] * two55);
A = (unsigned int)(fclr[3] * two55);
if (R > 255)
R = 255;
if (G > 255)
G = 255;
if (B > 255)
B = 255;
if (A > 255)
A = 255;
data[0] = RGBA_MAKE(R, G, B, A);
#endif
clr += g.m_colorstride;
data += dstride;
}
}
}
else
{
#ifdef _X86_
_asm
{
mov ecx, vcount;
mov ebx, 24;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, dstride;
shl ebx, 2;
sub ebx, 4;
mov eax, g.m_color;
cld;
lp4: stosd;
lea edi, [ebx + edi];
loop lp4;
}
#else
D3DCOLOR *data = (D3DCOLOR *) g.m_verts+6;
for (i = 0; i < vcount; ++i)
{
*data = g.m_color;
data += dstride;
}
#endif
}
if (g.m_usefogary)
{
static float two55 = 255.f;
unsigned int A;
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_fogstride;
mul ebx;
mov esi, g.m_fogary;
lea esi, [eax + esi];
mov ebx, 28;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_fogstride;
mov edx, dstride;
shl edx, 2;
sub edx, 4;
cld;
lp5: fld [esi];
fld two55;
fmulp st(1), st(0);
fistp A;
mov eax, 255;
sub eax, A;
cmp eax, 0;
jge pt4;
mov eax, 0;
pt4: shl eax, 24;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp5;
}
#else
unsigned char *fog = &((unsigned char *) g.m_fogary)[min*g.m_fogstride];
D3DCOLOR *data = (D3DCOLOR *) g.m_verts+7;
for (i = 0; i < vcount; ++i)
{
A = (unsigned int) (((GLfloat *) fog)[0] * two55);
if (A > 255)
A = 255;
data[0] = (255-A) << 24;
fog += g.m_fogstride;
data += dstride;
}
#endif
}
if (g.m_vertarysize == 2)
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_vertexstride;
mul ebx;
mov esi, g.m_vertexary;
lea esi, [eax + esi];
mov edi, g.m_verts;
mov ebx, g.m_vertexstride;
sub ebx, 8;
mov edx, dstride;
shl edx, 2;
sub edx, 12;
cld;
lp6: lodsd;
stosd;
lodsd;
stosd;
mov eax, 0;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp6;
}
#else
unsigned char *vtx = &((unsigned char *) g.m_vertexary)[min*g.m_vertexstride];
D3DVALUE *data = (D3DVALUE *) g.m_verts;
for (i = 0; i < vcount; ++i)
{
memcpy(data,vtx,2*sizeof(GLfloat));
data[2] = 0.0;
vtx += g.m_vertexstride;
data += dstride;
}
#endif
}
else
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_vertexstride;
mul ebx;
mov esi, g.m_vertexary;
lea esi, [eax + esi];
mov edi, g.m_verts;
mov ebx, g.m_vertexstride;
sub ebx, 12;
mov edx, dstride;
shl edx, 2;
sub edx, 12;
cld;
lp7: lodsd;
stosd;
lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp7;
}
#else
unsigned char *vtx = &((unsigned char *) g.m_vertexary)[min*g.m_vertexstride];
D3DVALUE *data = (D3DVALUE *) g.m_verts;
for (i = 0; i < vcount; ++i)
{
memcpy(data,vtx,3*sizeof(GLfloat));
vtx += g.m_vertexstride;
data += dstride;
}
#endif
}
if (process)
processVB(vcount);
g.m_tgtdirty = FALSE;
}
static void fillVB_NC(unsigned min, unsigned vcount)
{
BufferInfo &binfo = g.m_vbuffers[g.m_useVBuffer];
if (binfo.format != GL_V12MTNVFMT_EXT)
{
OutputDebugString("Wrapper: We shouldn't be here without a color per vertex\n");
return;
}
g.m_verts = &(((V12MTNVertex *) binfo.verts)[binfo.nfv]);
unsigned dstride = 10;
if (g.m_texturing)
{
if (g.m_usetexcoordary[0])
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_texcoordstride;
mul ebx;
mov esi, g.m_texcoordary;
lea esi, [eax + esi];
mov ebx, g.m_usefogary;
add ebx, 6;
shl ebx, 2;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_texcoordstride;
sub ebx, 8;
mov edx, dstride;
shl edx, 2;
sub edx, 8;
cld;
lp0: lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp0;
}
#else
unsigned char *tex0 = &((unsigned char *) g.m_texcoordary[0])[min*g.m_texcoordstride[0]];
D3DVALUE *data = (D3DVALUE *) g.m_verts+6;
for (i = 0; i < vcount; ++i)
{
memcpy(data,tex0,2*sizeof(GLfloat));
tex0 += g.m_texcoordstride[0];
data += dstride;
}
#endif
}
if (g.m_mtex && g.m_usetexcoordary[1])
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_texcoordstride+4;
mul ebx;
mov esi, g.m_texcoordary+4;
lea esi, [eax + esi];
mov ebx, g.m_usefogary;
add ebx, 8;
shl ebx, 2;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_texcoordstride+4;
sub ebx, 8;
mov edx, dstride;
shl edx, 2;
sub edx, 8;
cld;
lp1: lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp1;
}
#else
unsigned char *tex1 = &((unsigned char *) g.m_texcoordary[1])[min*g.m_texcoordstride[1]];
D3DVALUE *data = (D3DVALUE *) g.m_verts+8;
for (i = 0; i < vcount; ++i)
{
memcpy(data,tex1,2*sizeof(GLfloat));
tex1 += g.m_texcoordstride[1];
data += dstride;
}
#endif
}
}
if (g.m_usenormalary)
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_normalstride;
mul ebx;
mov esi, g.m_normalary;
lea esi, [eax + esi];
mov ebx, 12;
mov edi, g.m_verts;
lea edi, [ebx + edi];
mov ebx, g.m_normalstride;
sub ebx, 12;
mov edx, dstride;
shl edx, 2;
sub edx, 12;
cld;
lp2: lodsd;
stosd;
lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp2;
}
#else
unsigned char *nml = &((unsigned char *) g.m_normalary)[min*g.m_normalstride];
D3DVALUE *data = (D3DVALUE *) g.m_verts+3;
for (i = 0; i < vcount; ++i)
{
memcpy(data,nml,3*sizeof(GLfloat));
nml += g.m_normalstride;
data += dstride;
}
#endif
}
if (g.m_vertarysize == 2)
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_vertexstride;
mul ebx;
mov esi, g.m_vertexary;
lea esi, [eax + esi];
mov edi, g.m_verts;
mov ebx, g.m_vertexstride;
sub ebx, 8;
mov edx, dstride;
shl edx, 2;
sub edx, 12;
cld;
lp6: lodsd;
stosd;
lodsd;
stosd;
mov eax, 0;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp6;
}
#else
unsigned char *vtx = &((unsigned char *) g.m_vertexary)[min*g.m_vertexstride];
D3DVALUE *data = (D3DVALUE *) g.m_verts;
for (i = 0; i < vcount; ++i)
{
memcpy(data,vtx,2*sizeof(GLfloat));
data[2] = 0.0;
vtx += g.m_vertexstride;
data += dstride;
}
#endif
}
else
{
#ifdef _X86_
_asm {
mov ecx, vcount;
mov eax, min;
mov ebx, g.m_vertexstride;
mul ebx;
mov esi, g.m_vertexary;
lea esi, [eax + esi];
mov edi, g.m_verts;
mov ebx, g.m_vertexstride;
sub ebx, 12;
mov edx, dstride;
shl edx, 2;
sub edx, 12;
cld;
lp7: lodsd;
stosd;
lodsd;
stosd;
lodsd;
stosd;
lea esi, [ebx + esi];
lea edi, [edx + edi];
loop lp7;
}
#else
unsigned char *vtx = &((unsigned char *) g.m_vertexary)[min*g.m_vertexstride];
D3DVALUE *data = (D3DVALUE *) g.m_verts;
for (i = 0; i < vcount; ++i)
{
memcpy(data,vtx,3*sizeof(GLfloat));
vtx += g.m_vertexstride;
data += dstride;
}
#endif
}
}
GLAPI void GLAPIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
{
if (count == 0)
return;
if (count > g.m_numIndices)
{
g.m_numIndices = count;
delete [] g.m_wIndices;
g.m_wIndices = new WORD[g.m_numIndices];
}
unsigned min, max, vcount;
GLsizei i;
if (g.m_lckcount != 0)
{
switch (type)
{
case GL_UNSIGNED_BYTE:
for (i = 0; i < count; ++i)
g.m_wIndices[i] = (WORD) ((unsigned char*) indices)[i];
break;
case GL_UNSIGNED_SHORT:
for (i = 0; i < count; ++i)
g.m_wIndices[i] = (WORD) ((unsigned short*) indices)[i];
break;
case GL_UNSIGNED_INT:
for (i = 0; i < count; ++i)
g.m_wIndices[i] = (WORD) ((unsigned *) indices)[i];
break;
}
min = g.m_lckfirst;
max = g.m_lckfirst+g.m_lckcount - 1;
vcount = g.m_lckcount;
}
else
{
min = 65535;
max = 0;
switch (type)
{
case GL_UNSIGNED_BYTE:
for (i = 0; i < count; ++i)
{
unsigned t = ((unsigned char *) indices)[i];
if (t < min)
min = t;
if (t > max)
max = t;
}
for (i = 0; i < count; ++i)
g.m_wIndices[i] = (WORD) (((unsigned char*) indices)[i] - min);
break;
case GL_UNSIGNED_SHORT:
for (i = 0; i < count; ++i)
{
unsigned t = ((unsigned short *) indices)[i];
if (t < min)
min = t;
if (t > max)
max = t;
}
for (i = 0; i < count; ++i)
g.m_wIndices[i] = (WORD) (((unsigned short *) indices)[i] - min);
break;
case GL_UNSIGNED_INT:
for (i = 0; i < count; ++i)
{
unsigned t = ((unsigned int *) indices)[i];
if (t < min)
min = t;
if (t > max)
max = t;
}
for (i = 0; i < count; ++i)
g.m_wIndices[i] = (WORD) (((unsigned int *) indices)[i] - min);
break;
}
vcount = max-min + 1;
}
BOOL textrans = (g.m_dd.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) || g.m_usefogary ||
(g.m_texgen[0] && g.m_texgenmode[0] == GL_OBJECT_LINEAR) ||
(g.m_texgen[1] && g.m_texgenmode[1] == GL_SPHERE_MAP);
BOOL unlock = false;
QuakeSetTexturingState();
if (g.m_useVBuffer != -1)
{
if (g.m_lckcount && !textrans && g.m_tgtdirty)
{
processVB(vcount);
g.m_tgtdirty = false;
}
}
else if (g.m_lckcount == 0 || (g.m_tgtdirty && textrans))
{
fillVB(false,min,vcount);
unlock = true;
}
else if (g.m_tgtdirty)
fillVB(true,min,vcount);
if (g.m_useVBuffer != -1)
{
BufferInfo &binfo = g.m_vbuffers[g.m_useVBuffer];
if (g.m_lckcount && !textrans)
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvtgt, 0, vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
else
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, binfo.buf, binfo.nfv, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, binfo.buf, binfo.nfv, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, binfo.buf, binfo.nfv, vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, binfo.buf, binfo.nfv, vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, binfo.buf, binfo.nfv, vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
{
if (binfo.preserve)
{
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_AMBIENTMATERIALSOURCE, D3DMCS_COLOR1);
}
binfo.nfv += vcount;
g.m_useVBuffer = -1;
}
}
else if (g.m_lckcount != 0 && !textrans)
{
if (g.m_usefogary)
{
if (mode == GL_TRIANGLES)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_fmtvtgt, 0, vcount, g.m_wIndices, count, 0);
else
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
else if (g.m_texturing)
{
if (g.m_mtex)
{
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvtgt, 0, vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
}
else
{
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_tvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_tvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_tvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvtgt, 0, vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
}
}
else
{
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_vtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_vtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_vtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vtgt, 0, vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vtgt, 0, vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
}
}
else
{
if (g.m_usefogary)
{
if (unlock)
g.m_fmtvbuf->Unlock();
if (mode == GL_TRIANGLES)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_fmtvbuf, g.m_nfv[3], vcount, g.m_wIndices, count, 0);
else
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
if (g.m_lckcount == 0)
g.m_nfv[3] += vcount;
}
else if (g.m_texturing)
{
if (g.m_mtex)
{
if (unlock)
g.m_mtvbuf->Unlock();
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_mtvbuf, g.m_nfv[2], vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_mtvbuf, g.m_nfv[2], vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_mtvbuf, g.m_nfv[2], vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvbuf, g.m_nfv[2], vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvbuf, g.m_nfv[2], vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
g.m_nfv[2] += vcount;
}
else
{
if (unlock)
g.m_tvbuf->Unlock();
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_tvbuf, g.m_nfv[1], vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_tvbuf, g.m_nfv[1], vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_tvbuf, g.m_nfv[1], vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvbuf, g.m_nfv[1], vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvbuf, g.m_nfv[1], vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
g.m_nfv[1] += vcount;
}
}
else
{
if (unlock)
g.m_vbuf->Unlock();
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_LINELIST, g.m_vbuf, g.m_nfv[0], vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, g.m_vbuf, g.m_nfv[0], vcount, g.m_wIndices, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_vbuf, g.m_nfv[0], vcount, g.m_wIndices, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vbuf, g.m_nfv[0], vcount, g.m_wIndices, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawIndexedPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vbuf, g.m_nfv[0], vcount, &g.m_wIndices[i], 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
g.m_nfv[0] += vcount;
}
}
}
GLAPI void GLAPIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height)
{
g.m_vwx = x;
g.m_vwy = y;
g.m_vww = width;
g.m_vwh = height;
g.m_updvwp = TRUE;
}
GLAPI void GLAPIENTRY glLineWidth (GLfloat width)
{
width;
}
GLAPI void GLAPIENTRY glLoadIdentity (void)
{
D3DMATRIX unity;
unity._11 = 1.0f; unity._12 = 0.0f; unity._13 = 0.0f; unity._14 = 0.0f;
unity._21 = 0.0f; unity._22 = 1.0f; unity._23 = 0.0f; unity._24 = 0.0f;
unity._31 = 0.0f; unity._32 = 0.0f; unity._33 = 1.0f; unity._34 = 0.0f;
unity._41 = 0.0f; unity._42 = 0.0f; unity._43 = 0.0f; unity._44 = 1.0f;
g.m_d3ddev->SetTransform(g.m_matrixMode, &unity);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
else if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_TEXTURE0, &g.m_curtexmatrix);
g.m_objectdirty[0] = TRUE;
}
}
GLAPI void GLAPIENTRY glMatrixMode (GLenum mode)
{
if (mode == GL_MODELVIEW)
g.m_matrixMode = D3DTRANSFORMSTATE_WORLD;
else if (mode == GL_PROJECTION)
g.m_matrixMode = D3DTRANSFORMSTATE_PROJECTION;
else
g.m_matrixMode = D3DTRANSFORMSTATE_TEXTURE0;
}
GLAPI void GLAPIENTRY glDisable (GLenum cap)
{
switch(cap)
{
case GL_DEPTH_TEST:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZENABLE, FALSE);
break;
case GL_CULL_FACE:
g.m_cullEnabled = FALSE;
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE);
break;
case GL_FOG:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGENABLE, FALSE);
break;
case GL_BLEND:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
break;
case GL_CLIP_PLANE0:
case GL_CLIP_PLANE1:
case GL_CLIP_PLANE2:
case GL_CLIP_PLANE3:
case GL_CLIP_PLANE4:
case GL_CLIP_PLANE5:
break;
case GL_POLYGON_OFFSET_FILL:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZBIAS, 0);
break;
case GL_STENCIL_TEST:
break;
case GL_SCISSOR_TEST:
g.m_scissoring = FALSE;
glViewport(g.m_vwx, g.m_vwy, g.m_vww, g.m_vwh);
break;
case GL_TEXTURE_2D:
if (g.m_curtgt == 0)
{
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_DISABLE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
g.m_texturing = FALSE;
}
else
{
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_DISABLE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
g.m_mtex = FALSE;
}
g.m_texHandleValid = FALSE;
dirtyArray();
break;
case GL_ALPHA_TEST:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, FALSE);
break;
case GL_LIGHTING:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_LIGHTING, FALSE);
g.m_lighting = FALSE;
dirtyArray();
break;
case GL_TEXTURE_GEN_S:
case GL_TEXTURE_GEN_T:
g.m_texgen[g.m_curtgt] = FALSE;
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXCOORDINDEX,
g.m_curtgt);
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
dirtyArray();
break;
case GL_LIGHT0:
case GL_LIGHT1:
case GL_LIGHT2:
case GL_LIGHT3:
case GL_LIGHT4:
case GL_LIGHT5:
case GL_LIGHT6:
case GL_LIGHT7:
g.m_d3ddev->LightEnable(cap-GL_LIGHT0, FALSE);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: glDisable on this cap not supported: %x\n", cap);
OutputDebugString(buf);
}
}
}
GLAPI void GLAPIENTRY glDisableClientState (GLenum array)
{
switch(array)
{
case GL_COLOR_ARRAY:
g.m_usecolorary = FALSE;
break;
case GL_TEXTURE_COORD_ARRAY:
g.m_usetexcoordary[g.m_client_active_texture_arb] = FALSE;
break;
case GL_VERTEX_ARRAY:
g.m_usevertexary = FALSE;
break;
case GL_NORMAL_ARRAY:
g.m_usenormalary = FALSE;
break;
case GL_FOG_COORDINATE_ARRAY_EXT:
g.m_usefogary = FALSE;
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Array not supported: %x\n", array);
OutputDebugString(buf);
}
}
dirtyArray();
}
GLAPI void GLAPIENTRY glDrawBuffer (GLenum mode)
{
mode;
}
GLAPI void GLAPIENTRY glEnable (GLenum cap)
{
switch (cap) {
case GL_DEPTH_TEST:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZENABLE, TRUE);
break;
case GL_CULL_FACE:
g.m_cullEnabled = TRUE;
if ((g.m_cullMode == GL_BACK && g.m_frontFace == GL_CCW) ||
(g.m_cullMode == GL_FRONT && g.m_frontFace == GL_CW))
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_CW);
else
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_CCW);
break;
case GL_FOG:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGENABLE, TRUE);
break;
case GL_BLEND:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE);
break;
case GL_CLIP_PLANE0:
case GL_CLIP_PLANE1:
case GL_CLIP_PLANE2:
case GL_CLIP_PLANE3:
case GL_CLIP_PLANE4:
case GL_CLIP_PLANE5:
break;
case GL_POLYGON_OFFSET_FILL:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ZBIAS, g.m_zbias*2);
break;
case GL_SCISSOR_TEST:
g.m_scissoring = TRUE;
g.m_updvwp = TRUE;
break;
case GL_TEXTURE_2D:
if (g.m_curtgt == 0)
g.m_texturing = TRUE;
else
g.m_mtex = TRUE;
g.m_texHandleValid = FALSE;
dirtyArray();
break;
case GL_ALPHA_TEST:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, TRUE);
break;
case GL_LIGHTING:
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_LIGHTING, TRUE);
g.m_lighting = TRUE;
dirtyArray();
break;
case GL_TEXTURE_GEN_S:
case GL_TEXTURE_GEN_T:
g.m_texgen[g.m_curtgt] = TRUE;
if (g.m_texgenmode[g.m_curtgt] == GL_OBJECT_LINEAR)
{
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXCOORDINDEX,
g.m_curtgt | D3DTSS_TCI_CAMERASPACEPOSITION);
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
}
else
{
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXCOORDINDEX,
g.m_curtgt | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
}
g.m_texcoordary[g.m_curtgt] = NULL;
g.m_texcoordstride[g.m_curtgt] = 0;
dirtyArray();
break;
case GL_LIGHT0:
case GL_LIGHT1:
case GL_LIGHT2:
case GL_LIGHT3:
case GL_LIGHT4:
case GL_LIGHT5:
case GL_LIGHT6:
case GL_LIGHT7:
g.m_d3ddev->LightEnable(cap-GL_LIGHT0, TRUE);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: glEnable on this cap not supported: %x\n",cap);
OutputDebugString(buf);
}
}
}
GLAPI void GLAPIENTRY glEnableClientState (GLenum array)
{
switch (array)
{
case GL_COLOR_ARRAY:
g.m_usecolorary = TRUE;
break;
case GL_TEXTURE_COORD_ARRAY:
g.m_usetexcoordary[g.m_client_active_texture_arb] = TRUE;
break;
case GL_VERTEX_ARRAY:
g.m_usevertexary = TRUE;
break;
case GL_NORMAL_ARRAY:
g.m_usenormalary = TRUE;
break;
case GL_FOG_COORDINATE_ARRAY_EXT:
g.m_usefogary = TRUE;
break;
default:
OutputDebugString("Wrapper: Array not supported\n");
}
dirtyArray();
}
GLAPI void GLAPIENTRY glFogf (GLenum pname, GLfloat param)
{
FLOAT start, end;
switch (pname)
{
case GL_FOG_START:
start = param;
//g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGTABLESTART, *(DWORD*)(&start));
break;
case GL_FOG_END:
end = param;
//g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGTABLEEND, *(DWORD*)(&end));
break;
default:
OutputDebugString("Wrapper: Fog pname not supported\n");
}
}
GLAPI void GLAPIENTRY glFogfv (GLenum pname, const GLfloat *params)
{
if (pname == GL_FOG_COLOR)
{
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
mov ebx, params;
fld [ebx];
fld [ebx + 4];
fld [ebx + 8];
fld [ebx + 12];
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov g.m_fogcolor, eax;
}
#else
R = (unsigned int) (params[0] * two55);
G = (unsigned int) (params[1] * two55);
B = (unsigned int) (params[2] * two55);
A = (unsigned int) (params[3] * two55);
if (R > 255)
R = 255;
if (G > 255)
G = 255;
if (B > 255)
B = 255;
if (A > 255)
A = 255;
g.m_fogcolor = RGBA_MAKE(R, G, B, A);
#endif
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGCOLOR, g.m_fogcolor);
}
else
OutputDebugString("Wrapper: Fog pname not supported\n");
}
GLAPI void GLAPIENTRY glFogi (GLenum pname, GLint param)
{
switch(pname)
{
case GL_FOG_COORDINATE_SOURCE_EXT:
break;
case GL_FOG_MODE:
switch (param)
{
case GL_LINEAR:
//g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_LINEAR);
break;
case GL_EXP:
//g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_EXP);
break;
case GL_EXP2:
//g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_EXP2);
break;
}
break;
default:
OutputDebugString("Wrapper: Fog pname not supported\n");
}
}
GLAPI void GLAPIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
D3DMATRIX f;
f._11 = (D3DVALUE)((2.0 * zNear) / (right - left));
f._21 = 0.f;
f._31 = (D3DVALUE)((right + left) / (right - left));
f._41 = 0.f;
f._12 = 0.f;
f._22 = (D3DVALUE)((2.0 * zNear) / (top - bottom));
f._32 = (D3DVALUE)((top + bottom) / (top - bottom));
f._42 = 0.f;
f._13 = 0.f;
f._23 = 0.f;
f._33 = (D3DVALUE)(-zFar / (zFar - zNear));
//f._33 = (D3DVALUE)(-(zFar+zNear)/(zFar-zNear));
f._43 = (D3DVALUE)(-(zFar * zNear) / (zFar - zNear));
//f._43 = (D3DVALUE)(-(2.0 * zFar * zNear)/(zFar - zNear));
f._14 = 0.f;
f._24 = 0.f;
f._34 = -1.f;
f._44 = 0.f;
g.m_d3ddev->MultiplyTransform(g.m_matrixMode, &f);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
}
GLAPI GLenum GLAPIENTRY glGetError (void)
{
return GL_NO_ERROR;
}
GLAPI void GLAPIENTRY glGetDoublev (GLenum pname, GLdouble *params)
{
switch (pname) {
case GL_MODELVIEW_MATRIX:
{
D3DMATRIX tmp;
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_WORLD, &tmp);
for (unsigned char i = 0; i < 16; ++i)
params[i] = ((GLfloat *) &tmp)[i];
}
break;
case GL_PROJECTION_MATRIX:
{
D3DMATRIX tmp;
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_PROJECTION, &tmp);
for (unsigned char i = 0; i < 16; ++i)
params[i] = ((GLfloat *) &tmp)[i];
}
break;
default:
OutputDebugString("Wrapper: Unimplemented GetDoublev query\n");
}
}
GLAPI void GLAPIENTRY glGetFloatv (GLenum pname, GLfloat *params)
{
switch (pname) {
case GL_MODELVIEW_MATRIX:
{
D3DMATRIX tmp;
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_WORLD, &tmp);
memcpy(params,&tmp,16*sizeof(GLfloat));
}
break;
case GL_PROJECTION_MATRIX:
{
D3DMATRIX tmp;
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_PROJECTION, &tmp);
memcpy(params,&tmp,16*sizeof(GLfloat));
}
break;
case GL_TEXTURE_MATRIX:
memcpy(params,&g.m_curtexmatrix,16*sizeof(GLfloat));
break;
case GL_FOG_COLOR:
params[0] = (GLfloat) ((g.m_fogcolor >> 16) & 255)/255.0;
params[1] = (GLfloat) ((g.m_fogcolor >> 8) & 255)/255.0;
params[2] = (GLfloat) (g.m_fogcolor & 255)/255.0;
params[3] = (GLfloat) ((g.m_fogcolor >> 24) & 255)/255.0;
break;
case GL_COLOR_CLEAR_VALUE:
params[0] = (GLfloat) ((g.m_clearColor >> 16) & 255)/255.0;
params[1] = (GLfloat) ((g.m_clearColor >> 8) & 255)/255.0;
params[2] = (GLfloat) (g.m_clearColor & 255)/255.0;
params[3] = (GLfloat) ((g.m_clearColor >> 24) & 255)/255.0;
break;
default:
OutputDebugString("Wrapper: Unimplemented GetFloatv query\n");
}
}
GLAPI void GLAPIENTRY glGetIntegerv (GLenum pname, GLint *params)
{
switch(pname)
{
case GL_MAX_TEXTURE_SIZE:
*params = (g.m_dd.dwMaxTextureWidth >= g.m_dd.dwMaxTextureHeight) ? g.m_dd.dwMaxTextureWidth : g.m_dd.dwMaxTextureHeight;
break;
case GL_MAX_TEXTURE_UNITS_ARB:
*params = g.m_usemtex ? 2 : 1;
break;
case GL_MODELVIEW_STACK_DEPTH:
*params = g.m_matrixStack[0].length() + 1;
break;
case GL_PROJECTION_STACK_DEPTH:
*params = g.m_matrixStack[1].length() + 1;
break;
case GL_TEXTURE_STACK_DEPTH:
*params = g.m_matrixStack[2].length() + 1;
break;
case GL_MAX_LIGHTS:
*params = 8;
break;
default:
OutputDebugString("Wrapper: Unimplemented GetIntegerv query\n");
}
}
GLAPI const GLubyte* GLAPIENTRY glGetString (GLenum name)
{
switch(name) {
case GL_VENDOR:
return (const GLubyte*)"Microsoft Corp.";
case GL_RENDERER:
return (const GLubyte*)"Direct3D";
case GL_VERSION:
return (const GLubyte*)"1.1";
case GL_EXTENSIONS:
if (g.m_colortable != FALSE)
if (g.m_usemtex != FALSE)
return (const GLubyte*)"GL_ARB_multitexture GL_EXT_compiled_vertex_array GL_SGIS_multitexture GL_EXT_fog_coord GL_EXT_texture_env_combine GL_EXT_paletted_texture GL_EXT_vertex_buffer";
else
return (const GLubyte*)"GL_EXT_compiled_vertex_array GL_EXT_fog_coord GL_EXT_paletted_texture";
else
if (g.m_usemtex != FALSE)
return (const GLubyte*)"GL_ARB_multitexture GL_EXT_compiled_vertex_array GL_SGIS_multitexture GL_EXT_fog_coord GL_EXT_texture_env_combine GL_EXT_vertex_buffer";
else
return (const GLubyte*)"GL_EXT_compiled_vertex_array GL_EXT_fog_coord";
default:
OutputDebugString("Wrapper: Unimplemented GetString query\n");
}
return (const GLubyte*)"";
}
GLAPI void GLAPIENTRY glLoadMatrixf (const GLfloat *m)
{
if (g.m_matrixMode == D3DTRANSFORMSTATE_PROJECTION)
{
D3DMATRIX f = *((LPD3DMATRIX) m);
f._13 = (((LPD3DMATRIX) m)->_13 + ((LPD3DMATRIX) m)->_14) * 0.5f;
f._23 = (((LPD3DMATRIX) m)->_23 + ((LPD3DMATRIX) m)->_24) * 0.5f;
f._33 = (((LPD3DMATRIX) m)->_33 + ((LPD3DMATRIX) m)->_34) * 0.5f;
f._43 = (((LPD3DMATRIX) m)->_43 + ((LPD3DMATRIX) m)->_44) * 0.5f;
g.m_d3ddev->SetTransform(g.m_matrixMode, &f);
}
else
{
g.m_d3ddev->SetTransform(g.m_matrixMode, (LPD3DMATRIX) m);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
else if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_TEXTURE0, &g.m_curtexmatrix);
g.m_objectdirty[0] = TRUE;
}
}
}
GLAPI void GLAPIENTRY glLockArraysEXT(GLint first, GLsizei count)
{
g.m_lckfirst = first;
g.m_lckcount = count;
g.m_tgtdirty = TRUE;
}
GLAPI void GLAPIENTRY glMTexCoord2fSGIS(GLenum target, GLfloat s, GLfloat t)
{
if(target == GL_TEXTURE0_SGIS) {
g.m_tu = s;
g.m_tv = t;
}
else {
g.m_tu2 = s;
g.m_tv2 = t;
}
}
GLAPI void GLAPIENTRY glMultiTexCoord2fARB (GLenum texture, GLfloat s, GLfloat t)
{
if(texture == GL_TEXTURE0_ARB)
{
g.m_tu = s;
g.m_tv = t;
}
else
{
g.m_tu2 = s;
g.m_tv2 = t;
}
}
GLAPI void GLAPIENTRY glMultiTexCoord2fvARB (GLenum texture, GLfloat *v)
{
texture;
v;
#ifdef DODPFS
DPF("glMultiTexCoord2fvARB");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
D3DMATRIX f;
left += 0.5;
right += 0.5;
top += 0.5;
bottom += 0.5;
f._11 = (D3DVALUE) (2.0 / (right - left));
f._21 = 0.f;
f._31 = 0.f;
f._41 = (D3DVALUE) (-(right + left) / (right - left));
f._12 = 0.f;
f._22 = (D3DVALUE) (2.0 / (top - bottom));
f._32 = 0.f;
f._42 = (D3DVALUE) (-(top + bottom) / (top - bottom));
f._13 = 0.f;
f._23 = 0.f;
f._33 = (D3DVALUE) (-1.0 / (zFar - zNear));
f._43 = (D3DVALUE) (-zNear / (zFar - zNear));
f._14 = 0.f;
f._24 = 0.f;
f._34 = 0.f;
f._44 = 1.f;
g.m_d3ddev->MultiplyTransform(g.m_matrixMode, &f);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
}
GLAPI void GLAPIENTRY glPolygonMode (GLenum face, GLenum mode)
{
face;
int statevalue=-1;
switch(mode) {
case GL_POINT:
statevalue=D3DFILL_POINT;
break;
case GL_LINE:
statevalue=D3DFILL_WIREFRAME;
break;
case GL_FILL:
statevalue=D3DFILL_SOLID;
break;
}
if(statevalue >= 0) {
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_FILLMODE, (DWORD)statevalue);
}
}
GLAPI void GLAPIENTRY glPolygonOffset (GLfloat factor, GLfloat units)
{
factor;
float val = -units;
if((val > 0.0) && (val < 1.0))
val = 1.0;
g.m_zbias = (DWORD) val;
}
GLAPI void GLAPIENTRY glPopMatrix (void)
{
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
{
GLListManip<D3DMATRIX> m(&g.m_matrixStack[0]);
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_WORLD, &(m()));
m.remove();
g.m_inversedirty = TRUE;
}
else if (g.m_matrixMode == D3DTRANSFORMSTATE_PROJECTION)
{
GLListManip<D3DMATRIX> m(&g.m_matrixStack[1]);
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_PROJECTION, &(m()));
m.remove();
}
else
{
GLListManip<D3DMATRIX> m(&g.m_matrixStack[2]);
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0, &(m()));
g.m_curtexmatrix = m();
g.m_objectdirty[0] = TRUE;
m.remove();
//if (g.m_matrixStack[2].length() == 0 && !g.m_texgen[0])
//g.m_d3ddev->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
}
}
GLAPI void GLAPIENTRY glPushMatrix (void)
{
if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
//if (g.m_matrixStack[2].length() == 0 && !g.m_texgen[0])
//g.m_d3ddev->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
g.m_matrixStack[2].prepend(g.m_curtexmatrix);
}
else
{
D3DMATRIX m;
g.m_d3ddev->GetTransform(g.m_matrixMode, &m);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_matrixStack[0].prepend(m);
else
g.m_matrixStack[1].prepend(m);
}
}
GLAPI void GLAPIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
static double PI = 4. * atan(1.);
D3DMATRIX f;
double ra = angle * PI / 180.f;
float ca = (float) cos(ra);
float sa = (float) sin(ra);
if (x == 1.f)
{
f._11 = 1.f; f._21 = 0.f; f._31 = 0.f; f._41 = 0.f;
f._12 = 0.f; f._22 = ca; f._32 = -sa; f._42 = 0.f;
f._13 = 0.f; f._23 = sa; f._33 = ca; f._43 = 0.f;
f._14 = 0.f; f._24 = 0.f; f._34 = 0.f; f._44 = 1.f;
}
else if (y == 1.f)
{
f._11 = ca; f._21 = 0.f; f._31 = sa; f._41 = 0.f;
f._12 = 0.f; f._22 = 1.f; f._32 = 0.f; f._42 = 0.f;
f._13 = -sa; f._23 = 0.f; f._33 = ca; f._43 = 0.f;
f._14 = 0.f; f._24 = 0.f; f._34 = 0.f; f._44 = 1.f;
}
else if (z == 1.f)
{
f._11 = ca; f._21 = -sa; f._31 = 0.f; f._41 = 0.f;
f._12 = sa; f._22 = ca; f._32 = 0.f; f._42 = 0.f;
f._13 = 0.f; f._23 = 0.f; f._33 = 1.f; f._43 = 0.f;
f._14 = 0.f; f._24 = 0.f; f._34 = 0.f; f._44 = 1.f;
}
else
return;
if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_curtexmatrix);
g.m_d3ddev->MultiplyTransform(g.m_matrixMode, &f);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
else if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_TEXTURE0, &g.m_curtexmatrix);
g.m_objectdirty[0] = TRUE;
}
}
GLAPI void GLAPIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z)
{
D3DMATRIX f;
f._11 = x; f._21 = 0.f; f._31 = 0.f; f._41 = 0.f;
f._12 = 0.f; f._22 = y; f._32 = 0.f; f._42 = 0.f;
f._13 = 0.f; f._23 = 0.f; f._33 = z; f._43 = 0.f;
f._14 = 0.f; f._24 = 0.f; f._34 = 0.f; f._44 = 1.f;
if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_curtexmatrix);
g.m_d3ddev->MultiplyTransform(g.m_matrixMode, &f);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
else if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_TEXTURE0, &g.m_curtexmatrix);
g.m_objectdirty[0] = TRUE;
}
}
GLAPI void GLAPIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height)
{
g.m_scix = x;
g.m_sciy = y;
g.m_sciw = width;
g.m_scih = height;
g.m_updvwp = TRUE;
}
GLAPI void GLAPIENTRY glSelectTextureSGIS(GLenum target)
{
g.m_curtgt = target == GL_TEXTURE0_SGIS ? 0 : 1;
}
GLAPI void GLAPIENTRY glShadeModel (GLenum mode)
{
if(mode == GL_SMOOTH)
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_SHADEMODE, D3DSHADE_GOURAUD);
else
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_SHADEMODE, D3DSHADE_FLAT);
}
GLAPI void GLAPIENTRY glTexCoord2f (GLfloat s, GLfloat t)
{
g.m_tu = s;
g.m_tv = t;
}
GLAPI void GLAPIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
if (size == 2 && type == GL_FLOAT)
{
g.m_texcoordary[g.m_client_active_texture_arb] = (GLfloat *) pointer;
if (stride)
g.m_texcoordstride[g.m_client_active_texture_arb] = stride;
else
g.m_texcoordstride[g.m_client_active_texture_arb] = 8;
}
else
{
char buf[128];
sprintf(buf,"Wrapper: TexCoord array not supported (size: %d type: %x stride: %d)\n",
size, type, stride);
OutputDebugString(buf);
}
}
GLAPI void GLAPIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param)
{
target;
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
if(((int)param) == GL_CONSTANT_EXT)
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_TEXTUREFACTOR, g.m_envcolor);
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
switch (pname)
{
case GL_TEXTURE_ENV_MODE:
{
g.m_blendmode[g.m_curtgt] = (int) param;
g.m_texHandleValid = FALSE;
}
break;
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
case GL_COMBINE_RGB_EXT:
{
sgD3DCompatibility::sgCombineMode[g.m_curtgt] = (int)param;
}
break;
case GL_RGB_SCALE_EXT:
{
sgD3DCompatibility::sgScale[g.m_curtgt] = (int)param;
}
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
case GL_SOURCE0_RGB_EXT:
case GL_OPERAND0_RGB_EXT:
case GL_SOURCE1_RGB_EXT:
case GL_OPERAND1_RGB_EXT:
break;
case GL_SOURCE2_RGB_EXT:
if ((int) param == GL_CONSTANT_EXT)
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_TEXTUREFACTOR, g.m_envcolor);
g.m_source2rgbext = (int) param;
break;
case GL_OPERAND2_RGB_EXT:
case GL_COMBINE_ALPHA_EXT:
break;
case GL_SOURCE0_ALPHA_EXT:
if ((int) param == GL_CONSTANT_EXT)
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_TEXTUREFACTOR, g.m_envcolor);
case GL_OPERAND0_ALPHA_EXT:
break;
case GL_TEXTURE_ENV_COLOR:
OutputDebugString("Wrapper: GL_TEXTURE_ENV_COLOR not implemented\n");
break;
}
}
GLAPI void GLAPIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param)
{
glTexEnvf(target,pname,(GLfloat) param);
}
GLAPI void GLAPIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei glwidth, GLsizei glheight, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
target;
border;
format;
type;
DWORD width, height;
TexInfo &ti = g.m_tex[g.m_curstagebinding[g.m_curtgt]];
/* See if texture needs to be subsampled */
if (g.m_subsample)
if (level == 0)
if (glwidth > 256 || glheight > 256)
if (glwidth > glheight) {
width = 256;
height = (glheight * 256) / glwidth;
}
else {
height = 256;
width = (glwidth * 256) / glheight;
}
else {
width = glwidth;
height = glheight;
}
else // mip-map levels need to be resampled too!
if (ti.m_width != ti.m_oldwidth ||
ti.m_height != ti.m_oldheight)
{
width = (float) glwidth * (float) ti.m_width/(float) ti.m_oldwidth;
height = (float) glheight * (float) ti.m_height/(float) ti.m_oldheight;
if (!width || !height)
return;
}
else
{
width = glwidth;
height = glheight;
}
else {
width = glwidth;
height = glheight;
}
/* See if texture needs to be square */
if (g.m_makeSquare)
if (height > width)
width = height;
else
height = width;
if (level == 0) {
LPDIRECTDRAWSURFACE7 ddsurf;
D3DX_SURFACEFORMAT fmt;
switch(internalformat) {
case GL_COLOR_INDEX8_EXT:
if (ti.m_rgbaindexed)
fmt = g.m_ddFourBitAlphaSurfFormat;
else
fmt = D3DX_SF_PALETTE8;
break;
case GL_LUMINANCE:
fmt = g.m_ddLuminanceSurfFormat;
break;
case GL_RGB5:
case GL_RGB5_A1:
fmt = g.m_ddFiveBitSurfFormat;
break;
case GL_RGBA4:
fmt = g.m_ddFourBitAlphaSurfFormat;
break;
case GL_RGB:
case GL_RGB8:
fmt = g.m_ddEightBitSurfFormat;
break;
case GL_RGBA:
case GL_RGBA8:
fmt = g.m_ddEightBitAlphaSurfFormat;
break;
case GL_ALPHA:
fmt = g.m_ddAlphaSurfFormat;
break;
default:
OutputDebugString("Wrapper: Unimplemented internalformat\n");
break;
}
if (fmt == D3DX_SF_PALETTE8)
{
DDSURFACEDESC2 ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
ddsd.dwHeight = height;
ddsd.dwWidth = width;
ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
// Set the bit depth for an 8-bit surface, but DO NOT
// specify any RGB mask values. The masks must be zero
// for a palettized surface.
ddsd.ddpfPixelFormat.dwRGBBitCount = 8;
HRESULT ddrval = g.m_dddev->CreateSurface(&ddsd,&ddsurf,NULL);
if (ddrval != DD_OK)
{
OutputDebugString("Wrapper: CreateSurface failed\n");
return;
}
ddrval = ddsurf->SetPalette(ti.m_palette);
if (ddrval != DD_OK)
{
OutputDebugString("Wrapper: SetPalette failed\n");
return;
}
}
else
{
DWORD flags = D3DX_TEXTURE_NOMIPMAP;
HRESULT ddrval = D3DXCreateTexture(g.m_d3ddev,
&flags,
(DWORD*)&width, (DWORD*)&height, &fmt,
NULL, // Palette
&ddsurf,
NULL);
if (ddrval != DD_OK)
{
OutputDebugString("Wrapper: CreateTexture failed\n");
return;
}
}
LoadSurface(ddsurf, internalformat, glwidth, glheight, width, height, (const DWORD*)pixels);
if (ti.m_ddsurf != 0)
ti.m_ddsurf->Release();
ti.m_dwStage = g.m_curtgt;
ti.m_fmt = fmt;
ti.m_internalformat = internalformat;
ti.m_width = width;
ti.m_height = height;
ti.m_ddsurf = ddsurf;
ti.m_oldwidth = glwidth;
ti.m_oldheight = glheight;
if (ti.m_block == 0)
{
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (g.m_curtgt, D3DTSS_ADDRESSU,ti.m_addu);
g.m_d3ddev->SetTextureStageState (g.m_curtgt, D3DTSS_ADDRESSV,ti.m_addv);
g.m_d3ddev->SetTextureStageState (g.m_curtgt, D3DTSS_MAGFILTER,ti.m_magmode);
g.m_d3ddev->SetTextureStageState (g.m_curtgt, D3DTSS_MINFILTER,ti.m_minmode);
g.m_d3ddev->SetTextureStageState (g.m_curtgt, D3DTSS_MIPFILTER,ti.m_mipmode);
g.m_d3ddev->SetTexture(g.m_curtgt, ti.m_ddsurf);
g.m_d3ddev->EndStateBlock(&ti.m_block);
ti.m_capture = FALSE;
}
else
ti.m_capture = TRUE;
}
else if (level == 1 && g.m_usemipmap) { // oops, a mipmap
LPDIRECTDRAWSURFACE7 ddsurf;
if (ti.m_fmt == D3DX_SF_PALETTE8)
{
DDSURFACEDESC2 ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP | DDSCAPS_COMPLEX;
ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
ddsd.dwHeight = ti.m_height;
ddsd.dwWidth = ti.m_width;
ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
// Set the bit depth for an 8-bit surface, but DO NOT
// specify any RGB mask values. The masks must be zero
// for a palettized surface.
ddsd.ddpfPixelFormat.dwRGBBitCount = 8;
HRESULT ddrval = g.m_dddev->CreateSurface(&ddsd,&ddsurf,NULL);
if (ddrval != DD_OK)
{
OutputDebugString("Wrapper: CreateSurface failed\n");
return;
}
ddrval = ddsurf->SetPalette(ti.m_palette);
if (ddrval != DD_OK)
{
OutputDebugString("Wrapper: SetPalette failed\n");
return;
}
}
else
{
DWORD flags = 0;
HRESULT ddrval = D3DXCreateTexture(g.m_d3ddev,
&flags,
(DWORD *) &ti.m_width, (DWORD *) &ti.m_height, &ti.m_fmt,
NULL, // Palette
&ddsurf,
NULL);
if (ddrval != DD_OK) {
OutputDebugString("Wrapper: CreateSurface for texture failed\n");
return;
}
}
ddsurf->Blt(NULL, ti.m_ddsurf, NULL, DDBLT_WAIT, NULL);
ti.m_ddsurf->Release();
ti.m_ddsurf = ddsurf;
DDSURFACEDESC2 ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
LPDIRECTDRAWSURFACE7 lpDDSTmp;
ti.m_ddsurf->GetAttachedSurface(&ddsd.ddsCaps, &lpDDSTmp);
LoadSurface(lpDDSTmp, internalformat, glwidth, glheight, width, height, (const DWORD*)pixels);
lpDDSTmp->Release();
ti.m_capture = TRUE;
}
else if (g.m_usemipmap) {
LPDIRECTDRAWSURFACE7 ddsurf = ti.m_ddsurf;
ddsurf->AddRef();
for (int i = 0; i < level; ++i) {
DDSURFACEDESC2 ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
LPDIRECTDRAWSURFACE7 lpDDSTmp;
HRESULT ddrval = ddsurf->GetAttachedSurface(&ddsd.ddsCaps, &lpDDSTmp);
ddsurf->Release();
if (ddrval == DDERR_NOTFOUND)
return;
ddsurf = lpDDSTmp;
}
LoadSurface(ddsurf, internalformat, glwidth, glheight, width, height, (const DWORD*)pixels);
ddsurf->Release();
}
g.m_texHandleValid = FALSE;
}
GLAPI void GLAPIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
target;
format;
type;
TexInfo &ti = g.m_tex[g.m_curstagebinding[g.m_curtgt]];
LPDIRECTDRAWSURFACE7 ddsurf = ti.m_ddsurf;
RECT subimage;
if (!ddsurf)
{
// We haven't got a surface -- so just do a glTexImage2D
// NOTE: this won't work for a mip-mapped texture
glTexImage2D(target,level,format,width,height,0,format,type,pixels);
return;
}
for(int i = 0; i < level; ++i) {
DDSURFACEDESC2 ddsd;
HRESULT ddrval;
memset(&ddsd.ddsCaps, 0, sizeof(ddsd.ddsCaps));
ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
LPDIRECTDRAWSURFACE7 lpDDSTmp;
ddrval = ddsurf->GetAttachedSurface(&ddsd.ddsCaps, &lpDDSTmp);
if (ddrval == DDERR_NOTFOUND)
return;
ddsurf = lpDDSTmp;
ddsurf->Release();
}
GLsizei newWidth = width;
GLsizei newHeight = height;
if (ti.m_width != ti.m_oldwidth || ti.m_height != ti.m_oldheight)
{
newWidth = (float) width * (float) ti.m_width/(float) ti.m_oldwidth;
newHeight = (float) height * (float) ti.m_height/(float) ti.m_oldheight;
if (!newWidth || !newHeight)
return;
xoffset = (float) xoffset * (float) ti.m_width/(float) ti.m_oldwidth;
yoffset = (float) yoffset * (float) ti.m_height/(float) ti.m_oldheight;
}
SetRect(&subimage, xoffset, yoffset, newWidth + xoffset, newHeight + yoffset);
if (DD_OK != LoadSubSurface(ddsurf, ti.m_internalformat, width, height, (const DWORD*)pixels, &subimage)) {
OutputDebugString("Wrapper: LoadSubSurface Failure.\n");
return;
}
}
GLAPI void GLAPIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param)
{
target;
switch(pname) {
case GL_TEXTURE_MIN_FILTER:
switch((int)param) {
case GL_NEAREST:
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_minmode = D3DTFN_POINT;
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_mipmode = D3DTFP_NONE;
break;
case GL_LINEAR:
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_minmode = D3DTFN_LINEAR;
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_mipmode = D3DTFP_NONE;
break;
case GL_NEAREST_MIPMAP_NEAREST:
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_minmode = D3DTFN_POINT;
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_mipmode = D3DTFP_POINT;
break;
case GL_NEAREST_MIPMAP_LINEAR:
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_minmode = D3DTFN_POINT;
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_mipmode = D3DTFP_LINEAR;
break;
case GL_LINEAR_MIPMAP_NEAREST:
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_minmode = D3DTFN_LINEAR;
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_mipmode = D3DTFP_POINT;
break;
case GL_LINEAR_MIPMAP_LINEAR:
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_minmode = D3DTFN_LINEAR;
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_mipmode = D3DTFP_LINEAR;
break;
}
break;
case GL_TEXTURE_MAG_FILTER:
if((int)param == GL_NEAREST)
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_magmode = D3DTFG_POINT;
else
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_magmode = D3DTFG_LINEAR;
break;
case GL_TEXTURE_WRAP_S:
if((int)param == GL_CLAMP)
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_addu = D3DTADDRESS_CLAMP;
else
//GL_REPEAT falls here
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_addu = D3DTADDRESS_WRAP;
break;
case GL_TEXTURE_WRAP_T:
if((int)param == GL_CLAMP)
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_addv = D3DTADDRESS_CLAMP;
else
//GL_REPEAT falls here
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_addv = D3DTADDRESS_WRAP;
break;
}
g.m_tex[g.m_curstagebinding[g.m_curtgt]].m_capture = TRUE;
g.m_texHandleValid = FALSE;
}
GLAPI void GLAPIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param)
{
glTexParameterf(target,pname,(GLfloat) param);
}
GLAPI void GLAPIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z)
{
D3DMATRIX f;
f._11 = 1.f; f._21 = 0.f; f._31 = 0.f; f._41 = x;
f._12 = 0.f; f._22 = 1.f; f._32 = 0.f; f._42 = y;
f._13 = 0.f; f._23 = 0.f; f._33 = 1.f; f._43 = z;
f._14 = 0.f; f._24 = 0.f; f._34 = 0.f; f._44 = 1.f;
if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_curtexmatrix);
g.m_d3ddev->MultiplyTransform(g.m_matrixMode, &f);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
else if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_TEXTURE0, &g.m_curtexmatrix);
g.m_objectdirty[0] = TRUE;
}
}
static void dirtyArray()
{
if (g.m_incdex > -1)
{
g.m_nfv[g.m_incdex] += g.m_lckcount;
g.m_incdex = -1;
}
g.m_tgtdirty = TRUE;
}
GLAPI void GLAPIENTRY glUnlockArraysEXT()
{
if (g.m_useVBuffer != -1)
{
BufferInfo &binfo = g.m_vbuffers[g.m_useVBuffer];
if (binfo.preserve)
{
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_AMBIENTMATERIALSOURCE, D3DMCS_COLOR1);
}
binfo.nfv += g.m_lckcount;
g.m_useVBuffer = -1;
}
else if (g.m_incdex > -1)
{
g.m_nfv[g.m_incdex] += g.m_lckcount;
g.m_incdex = -1;
}
g.m_lckfirst = 0;
g.m_lckcount = 0;
}
GLAPI void GLAPIENTRY glVertex2f (GLfloat x, GLfloat y)
{
y;
if (g.m_nfv[g.m_comp] + g.m_vcnt[g.m_comp] >= (VBUFSIZE - MAXVERTSPERPRIM))
{
if (g.m_prim == GL_TRIANGLES)
{
if (g.m_vcnt[g.m_comp] % 3 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if (g.m_prim == GL_QUADS)
{
if (g.m_vcnt[g.m_comp] % 4 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if (g.m_prim == GL_LINES)
{
if (g.m_vcnt[g.m_comp] % 2 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
}
#ifdef _X86_
__asm
{
mov ecx, g.m_comp;
mov edi, g.m_verts;
lea esi, x;
mov eax, g.m_vcnt[ecx * 4];
lea edx, [eax + 1];
mov g.m_vcnt[ecx * 4], edx;
lea edx, [ecx * 8 + 28];
mul edx;
cld;
add edi, eax;
xor eax, eax;
movsd;
movsd;
stosd;
lea esi, g.m_nx;
lea ecx, [ecx * 2 + 4];
rep movsd;
}
#else
D3DVALUE *d3dv = &(((D3DVALUE*)g.m_verts)[g.m_vcnt[g.m_comp]++ * (g.m_comp * 2 + 7)]);
*(d3dv++) = x;
*(d3dv++) = y;
*(d3dv++) = 0.f;
memcpy(d3dv, &g.m_nx, (sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + g.m_comp*sizeof(D3DVALUE)*2));
#endif
}
GLAPI void GLAPIENTRY glVertex2i (GLint x, GLint y)
{
glVertex2f((GLfloat) x, (GLfloat) y);
}
GLAPI void GLAPIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z)
{
y;
z;
if (g.m_nfv[g.m_comp] + g.m_vcnt[g.m_comp] >= (VBUFSIZE - MAXVERTSPERPRIM))
{
if (g.m_prim == GL_TRIANGLES)
{
if (g.m_vcnt[g.m_comp] % 3 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if(g.m_prim == GL_QUADS)
{
if (g.m_vcnt[g.m_comp] % 4 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if (g.m_prim == GL_LINES)
{
if (g.m_vcnt[g.m_comp] % 2 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
}
#ifdef _X86_
__asm
{
mov ecx, g.m_comp;
mov edi, g.m_verts;
lea esi, x;
mov eax, g.m_vcnt[ecx * 4];
lea edx, [eax + 1];
mov g.m_vcnt[ecx * 4], edx;
lea edx, [ecx * 8 + 28];
mul edx;
cld;
add edi, eax;
movsd;
movsd;
movsd;
lea esi, g.m_nx;
lea ecx, [ecx * 2 + 4];
rep movsd;
}
#else
D3DVALUE *d3dv = &(((D3DVALUE*)g.m_verts)[g.m_vcnt[g.m_comp]++ * (g.m_comp * 2 + 7)]);
*(d3dv++) = x;
*(d3dv++) = y;
*(d3dv++) = z;
memcpy(d3dv, &g.m_nx, (sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + g.m_comp*sizeof(D3DVALUE)*2));
#endif
}
GLAPI void GLAPIENTRY glVertex2fv (const GLfloat *v)
{
if(g.m_nfv[g.m_comp] + g.m_vcnt[g.m_comp] >= (VBUFSIZE - MAXVERTSPERPRIM))
{
if(g.m_prim == GL_TRIANGLES)
{
if(g.m_vcnt[g.m_comp] % 3 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if(g.m_prim == GL_QUADS)
{
if(g.m_vcnt[g.m_comp] % 4 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if(g.m_prim == GL_LINES)
{
if(g.m_vcnt[g.m_comp] % 2 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
}
#ifdef _X86_
__asm
{
mov ecx, g.m_comp;
mov edi, g.m_verts;
mov esi, v;
mov eax, g.m_vcnt[ecx * 4];
lea edx, [eax + 1];
mov g.m_vcnt[ecx * 4], edx;
lea edx, [ecx * 8 + 28];
mul edx;
cld;
add edi, eax;
xor eax, eax;
movsd;
movsd;
stosd;
lea esi, g.m_nx;
lea ecx, [ecx * 2 + 4];
rep movsd;
}
#else
D3DVALUE *d3dv = &(((D3DVALUE*)g.m_verts)[g.m_vcnt[g.m_comp]++ * (g.m_comp * 2 + 7)]);
*(d3dv++) = *(v++);
*(d3dv++) = *(v++);
*(d3dv++) = 0.f;
memcpy(d3dv, &g.m_nx, (sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + g.m_comp*sizeof(D3DVALUE)*2));
#endif
}
GLAPI void GLAPIENTRY glVertex3fv (const GLfloat *v)
{
if(g.m_nfv[g.m_comp] + g.m_vcnt[g.m_comp] >= (VBUFSIZE - MAXVERTSPERPRIM))
{
if(g.m_prim == GL_TRIANGLES)
{
if(g.m_vcnt[g.m_comp] % 3 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if(g.m_prim == GL_QUADS)
{
if(g.m_vcnt[g.m_comp] % 4 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
else if(g.m_prim == GL_LINES)
{
if(g.m_vcnt[g.m_comp] % 2 == 0)
{
glEnd();
glBegin(g.m_prim);
}
}
}
#ifdef _X86_
__asm
{
mov ecx, g.m_comp;
mov edi, g.m_verts;
mov esi, v;
mov eax, g.m_vcnt[ecx * 4];
lea edx, [eax + 1];
mov g.m_vcnt[ecx * 4], edx;
lea edx, [ecx * 8 + 28];
mul edx;
cld;
add edi, eax;
movsd;
movsd;
movsd;
lea esi, g.m_nx;
lea ecx, [ecx * 2 + 4];
rep movsd;
}
#else
D3DVALUE *d3dv = &(((D3DVALUE*)g.m_verts)[g.m_vcnt[g.m_comp]++ * (g.m_comp * 2 + 7)]);
*(d3dv++) = *(v++);
*(d3dv++) = *(v++);
*(d3dv++) = *(v++);
memcpy(d3dv, &g.m_nx, (sizeof(D3DVALUE)*3 + sizeof(D3DCOLOR) + g.m_comp*sizeof(D3DVALUE)*2));
#endif
}
GLAPI void GLAPIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
if (size == 3 && type == GL_FLOAT)
{
g.m_vertexary = (GLfloat *) pointer;
g.m_vertarysize = 3;
if (stride)
g.m_vertexstride = stride;
else
g.m_vertexstride = 12;
}
else if (size == 2 && type == GL_FLOAT)
{
g.m_vertexary = (GLfloat *) pointer;
g.m_vertarysize = 2;
if (stride)
g.m_vertexstride = stride;
else
g.m_vertexstride = 8;
}
else
{
char buf[128];
sprintf(buf,"Wrapper: Vertex array not supported (size: %d type: %x stride: %d)\n",
size, type, stride);
OutputDebugString(buf);
}
}
GLAPI void GLAPIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2)
{
glBegin(GL_POLYGON);
glVertex2f((GLfloat) x1, (GLfloat) y1);
glVertex2f((GLfloat) x2, (GLfloat) y1);
glVertex2f((GLfloat) x2, (GLfloat) y2);
glVertex2f((GLfloat) x1, (GLfloat) y2);
glEnd();
}
GLAPI void GLAPIENTRY glMultMatrixf (const GLfloat *m)
{
if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_curtexmatrix);
g.m_d3ddev->MultiplyTransform(g.m_matrixMode, (LPD3DMATRIX) m);
if (g.m_matrixMode == D3DTRANSFORMSTATE_WORLD)
g.m_inversedirty = TRUE;
else if (g.m_matrixMode == D3DTRANSFORMSTATE_TEXTURE0)
{
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_TEXTURE0, &g.m_curtexmatrix);
g.m_objectdirty[0] = TRUE;
}
}
GLAPI GLboolean GLAPIENTRY glIsEnabled (GLenum cap)
{
DWORD enabled;
switch (cap)
{
case GL_BLEND:
g.m_d3ddev->GetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, &enabled);
break;
case GL_TEXTURE_2D:
if (g.m_curtgt == 0)
enabled = g.m_texturing;
else
enabled = g.m_mtex;
break;
case GL_TEXTURE_COORD_ARRAY:
enabled = g.m_usetexcoordary[g.m_client_active_texture_arb];
break;
case GL_COLOR_ARRAY:
enabled = g.m_usecolorary;
break;
case GL_VERTEX_ARRAY:
enabled = g.m_usevertexary;
break;
case GL_NORMAL_ARRAY:
enabled = g.m_usenormalary;
break;
case GL_FOG_COORDINATE_ARRAY_EXT:
enabled = g.m_usefogary;
break;
case GL_LIGHTING:
enabled = g.m_lighting;
break;
case GL_CULL_FACE:
enabled = g.m_cullEnabled;
break;
case GL_LIGHT0:
case GL_LIGHT1:
case GL_LIGHT2:
case GL_LIGHT3:
case GL_LIGHT4:
case GL_LIGHT5:
case GL_LIGHT6:
case GL_LIGHT7:
{
BOOL lightOn;
g.m_d3ddev->GetLightEnable(cap-GL_LIGHT0,&lightOn);
enabled = lightOn;
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: unsupported glIsEnabled query: %x", cap);
OutputDebugString(buf);
enabled = false;
}
break;
}
return enabled;
}
GLAPI void GLAPIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params)
{
target;
if (pname == GL_TEXTURE_ENV_MODE)
*params = g.m_blendmode[g.m_curtgt];
else
OutputDebugString("Wrapper: GL_TEXTURE_ENV_COLOR not implemented\n");
}
GLAPI void GLAPIENTRY glFrontFace (GLenum mode)
{
g.m_frontFace = mode;
if (g.m_cullEnabled == TRUE)
{
DWORD statevalue;
if ((g.m_cullMode == GL_BACK && mode == GL_CCW) ||
(g.m_cullMode == GL_FRONT && mode == GL_CW))
statevalue=D3DCULL_CW;
else
statevalue=D3DCULL_CCW;
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_CULLMODE, statevalue);
}
}
GLAPI void GLAPIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param)
{
coord;
pname;
g.m_texgenmode[g.m_curtgt] = param;
if (g.m_texgen[g.m_curtgt] && param == GL_OBJECT_LINEAR)
{
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXCOORDINDEX,
g.m_curtgt | D3DTSS_TCI_CAMERASPACEPOSITION);
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
}
else
{
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXCOORDINDEX,
g.m_curtgt | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
g.m_d3ddev->SetTextureStageState(g.m_curtgt, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
}
}
GLAPI void GLAPIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params)
{
pname;
switch (coord)
{
case GL_S:
memcpy(g.m_texgenplane[g.m_curtgt][0],params,sizeof(GLfloat)*4);
g.m_objectdirty[g.m_curtgt] = TRUE;
break;
case GL_T:
memcpy(g.m_texgenplane[g.m_curtgt][1],params,sizeof(GLfloat)*4);
g.m_objectdirty[g.m_curtgt] = TRUE;
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: TexGen coordinate unsupported: %x\n", coord);
OutputDebugString(buf);
}
break;
}
}
GLAPI void GLAPIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count)
{
if (count == 0)
return;
unsigned i;
BOOL textrans = (g.m_dd.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) ||
(g.m_texgen[0] && g.m_texgenmode[0] == GL_OBJECT_LINEAR) ||
(g.m_texgen[1] && g.m_texgenmode[1] == GL_SPHERE_MAP);
BOOL unlock = g.m_lckcount == 0 || g.m_tgtdirty;
QuakeSetTexturingState();
if (g.m_lckcount == 0)
fillVB(false,first,count);
else
if (g.m_tgtdirty)
if (textrans)
fillVB(false,g.m_lckfirst,g.m_lckcount);
else
fillVB(true,g.m_lckfirst,g.m_lckcount);
if (g.m_lckcount != 0 && !textrans)
{
if (g.m_usefogary)
{
if (mode == GL_TRIANGLES)
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_fmtvtgt, first, count, 0);
else
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
else if (g.m_texturing)
{
if (g.m_mtex)
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_mtvtgt, first, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_mtvtgt, first, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_mtvtgt, first, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvtgt, first, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvtgt, first+i, 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
else
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_tvtgt, first, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_tvtgt, first, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_tvtgt, first, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvtgt, first, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvtgt, first+i, 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
}
else
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_vtgt, first, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_vtgt, first, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_vtgt, first, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vtgt, first, count, 0);
break;
case GL_QUADS:
for (i = 0; i < count; i += 4)
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vtgt, first+i, 4, 0);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
}
else
{
GLint foffset;
if (g.m_lckcount == 0)
foffset = 0;
else
foffset = first;
if (g.m_usefogary)
{
if (unlock)
g.m_fmtvbuf->Unlock();
if (mode == GL_TRIANGLES)
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_fmtvbuf, g.m_nfv[3]+foffset, count, 0);
else
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
if (g.m_lckcount == 0)
g.m_nfv[3] += count;
}
else if (g.m_texturing)
{
if (g.m_mtex)
{
if (unlock)
g.m_mtvbuf->Unlock();
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_mtvbuf, g.m_nfv[2]+foffset, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_mtvbuf, g.m_nfv[2]+foffset, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_mtvbuf, g.m_nfv[2]+foffset, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvbuf, g.m_nfv[2]+foffset, count, 0);
break;
case GL_QUADS:
{
unsigned vindex = g.m_nfv[2];
for (i = 0; i < count; i += 4)
{
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_mtvbuf, vindex+foffset, 4, 0);
vindex += 4;
}
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
g.m_nfv[2] += count;
}
else
{
if (unlock)
g.m_tvbuf->Unlock();
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_tvbuf, g.m_nfv[1]+foffset, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_tvbuf, g.m_nfv[1]+foffset, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_tvbuf, g.m_nfv[1]+foffset, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvbuf, g.m_nfv[1]+foffset, count, 0);
break;
case GL_QUADS:
{
unsigned vindex = g.m_nfv[1];
for (i = 0; i < count; i += 4)
{
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_tvbuf, vindex+foffset, 4, 0);
vindex += 4;
}
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
g.m_nfv[1] += count;
}
}
else
{
if (unlock)
g.m_vbuf->Unlock();
switch (mode)
{
case GL_LINES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_LINELIST, g.m_vbuf, g.m_nfv[0]+foffset, count, 0);
break;
case GL_TRIANGLES:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLELIST, g.m_vbuf, g.m_nfv[0]+foffset, count, 0);
break;
case GL_TRIANGLE_STRIP:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLESTRIP, g.m_vbuf, g.m_nfv[0]+foffset, count, 0);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vbuf, g.m_nfv[0]+foffset, count, 0);
break;
case GL_QUADS:
{
unsigned vindex = g.m_nfv[0];
for (i = 0; i < count; i += 4)
{
g.m_d3ddev->DrawPrimitiveVB(D3DPT_TRIANGLEFAN, g.m_vbuf, vindex+foffset, 4, 0);
vindex += 4;
}
}
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Unimplemented primitive type: %x\n",mode);
OutputDebugString(buf);
}
}
if (g.m_lckcount == 0)
g.m_nfv[0] += count;
}
}
}
GLAPI void GLAPIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)
{
target;
pname;
params;
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
mov ebx, params;
fld [ebx];
fld [ebx + 4];
fld [ebx + 8];
fld [ebx + 12];
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov g.m_envcolor, eax;
}
#else
R = (unsigned int) (params[0] * two55);
G = (unsigned int) (params[1] * two55);
B = (unsigned int) (params[2] * two55);
A = (unsigned int) (params[3] * two55);
if (R > 255)
R = 255;
if (G > 255)
G = 255;
if (B > 255)
B = 255;
if (A > 255)
A = 255;
g.m_envcolor = RGBA_MAKE(R, G, B, A);
#endif
}
GLAPI void GLAPIENTRY glTexCoord2fv (const GLfloat *v)
{
g.m_tu = v[0];
g.m_tv = v[1];
}
GLAPI void GLAPIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
{
type;
if (stride)
g.m_normalstride = stride;
else
g.m_normalstride = 12;
g.m_normalary = (const GLfloat *) pointer;
}
GLAPI void GLAPIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
{
face;
pname;
params;
switch (pname)
{
case GL_SPECULAR:
case GL_EMISSION:
// TSShow tool uses these
break;
case GL_AMBIENT:
memcpy(&g.m_material.ambient,params,sizeof(GLfloat)*4);
break;
case GL_DIFFUSE:
memcpy(&g.m_material.diffuse,params,sizeof(GLfloat)*4);
break;
case GL_AMBIENT_AND_DIFFUSE:
memcpy(&g.m_material.ambient,params,sizeof(GLfloat)*4);
memcpy(&g.m_material.diffuse,params,sizeof(GLfloat)*4);
break;
default:
{
char buf[64];
sprintf(buf,"Wrapper: Materialfv pname not supported: %x\n", pname);
OutputDebugString(buf);
}
break;
}
g.m_d3ddev->SetMaterial(&g.m_material);
}
GLAPI void GLAPIENTRY glLightf (GLenum light, GLenum pname, GLfloat param)
{
GLenum i = light - GL_LIGHT0;
switch (pname)
{
case GL_SPOT_CUTOFF:
if (param >= 180.0)
{
g.m_lights[i].dltType = (g.m_lights[i].dltType == D3DLIGHT_DIRECTIONAL) ? D3DLIGHT_DIRECTIONAL : D3DLIGHT_POINT;
g.m_lights[i].dvTheta = g.m_lights[i].dvPhi = M_PI/2.0;
}
else
{
g.m_lights[i].dltType = (g.m_lights[i].dltType == D3DLIGHT_DIRECTIONAL) ? D3DLIGHT_DIRECTIONAL : D3DLIGHT_SPOT;
g.m_lights[i].dvTheta = g.m_lights[i].dvPhi = mDegToRad(param*2.0);
}
break;
case GL_CONSTANT_ATTENUATION:
g.m_lights[i].dvAttenuation0 = param;
break;
case GL_LINEAR_ATTENUATION:
g.m_lights[i].dvAttenuation1 = param;
break;
case GL_QUADRATIC_ATTENUATION:
g.m_lights[i].dvAttenuation2 = param;
break;
}
g.m_d3ddev->SetLight(i,&g.m_lights[i]);
}
GLAPI void GLAPIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params)
{
GLenum i = light - GL_LIGHT0;
switch (pname)
{
case GL_POSITION:
{
D3DXMATRIX world;
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_WORLD, (D3DMATRIX *) &world);
if (params[3] == 0.0)
{
D3DXVECTOR4 mdir(params), wdir;
g.m_lights[i].dltType = D3DLIGHT_DIRECTIONAL;
// HACK: why this works I'll never understand
// I thought you would transform the light's direction
// by the inverse of the current modelview...but that
// doesn't work. What the hell?!?!?
D3DXVec4Transform(&wdir,&mdir,&world);
g.m_lights[i].dvDirection.x = -wdir.x;
g.m_lights[i].dvDirection.y = -wdir.y;
g.m_lights[i].dvDirection.z = -wdir.z;
}
else
{
D3DXVECTOR4 mpos(params), wpos;
g.m_lights[i].dltType = (g.m_lights[i].dvPhi == M_2PI) ? D3DLIGHT_POINT : D3DLIGHT_SPOT;
D3DXVec4Transform(&wpos,&mpos,&world);
memcpy(&g.m_lights[i].dvPosition,wpos,sizeof(GLfloat)*3);
}
}
break;
case GL_SPOT_DIRECTION:
{
D3DXMATRIX world;
D3DXVECTOR4 mdir(params), wdir;
// HACK: why this works I'll never understand
// I thought you would transform the light's direction
// by the inverse of the current modelview...but that
// doesn't work. What the hell?!?!?
g.m_d3ddev->GetTransform(D3DTRANSFORMSTATE_WORLD, (D3DMATRIX *) &world);
D3DXVec4Transform(&wdir,&mdir,&world);
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
g.m_lights[i].dvDirection.x = wdir.x;
g.m_lights[i].dvDirection.y = wdir.y;
g.m_lights[i].dvDirection.z = wdir.z;
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
}
break;
case GL_DIFFUSE:
memcpy(&g.m_lights[i].dcvDiffuse,params,sizeof(GLfloat)*3);
break;
case GL_AMBIENT:
memcpy(&g.m_lights[i].dcvAmbient,params,sizeof(GLfloat)*3);
break;
case GL_SPECULAR:
memcpy(&g.m_lights[i].dcvSpecular,params,sizeof(GLfloat)*3);
break;
}
g.m_d3ddev->SetLight(i,&g.m_lights[i]);
}
GLAPI void GLAPIENTRY glLightModelfv (GLenum pname, const GLfloat *params)
{
if (pname == GL_LIGHT_MODEL_AMBIENT)
{
DWORD ambient;
static float two55 = 255.f;
unsigned int R, G, B, A;
#ifdef _X86_
__asm {
mov ebx, params;
fld [ebx];
fld [ebx + 4];
fld [ebx + 8];
fld [ebx + 12];
fld two55;
fmul st(1), st(0);
fmul st(2), st(0);
fmul st(3), st(0);
fmulp st(4), st(0);
fistp A;
fistp B;
fistp G;
fistp R;
mov edx, A;
cmp edx, 255;
jle pt1;
mov edx, 255;
pt1: mov eax, B;
cmp eax, 255;
jle pt2;
mov eax, 255;
pt2: mov ebx, G;
cmp ebx, 255;
jle pt3;
mov ebx, 255;
pt3: mov ecx, R;
cmp ecx, 255;
jle pt4;
mov ecx, 255;
pt4: shl ebx, 8;
shl ecx, 16;
shl edx, 24;
or eax, ebx;
or ecx, edx;
or eax, ecx;
mov ambient, eax;
}
#else
R = (unsigned int) (params[0] * two55);
G = (unsigned int) (params[1] * two55);
B = (unsigned int) (params[2] * two55);
A = (unsigned int) (params[3] * two55);
if (R > 255)
R = 255;
if (G > 255)
G = 255;
if (B > 255)
B = 255;
if (A > 255)
A = 255;
ambient = RGBA_MAKE(R, G, B, A);
#endif
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_AMBIENT, ambient);
}
else
{
char buf[64];
sprintf(buf,"Wrapper: Unsupported LightModelfv pname: %x\n", pname);
OutputDebugString(buf);
}
}
GLAPI void GLAPIENTRY glFogCoordPointerEXT(GLenum type, GLsizei stride, void *pointer)
{
if (type == GL_FLOAT)
{
if (stride)
g.m_fogstride = stride;
else
g.m_fogstride = 4;
g.m_fogary = (GLfloat *) pointer;
}
else
OutputDebugString("Wrapper: Unsupported FogCoordPointerEXT array type\n");
}
GLAPI void GLAPIENTRY glPointSize (GLfloat size)
{
size;
}
GLAPI void GLAPIENTRY glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* data)
{
target;
width;
format;
type;
TexInfo &ti = g.m_tex[g.m_curstagebinding[0]];
if (internalFormat == GL_RGB || internalFormat == GL_RGB8)
{
UCHAR *rgb = (UCHAR *) data;
for (int i = 0; i < 256; ++i)
{
g.m_paletteentries[i].peRed = *(rgb++);
g.m_paletteentries[i].peGreen = *(rgb++);
g.m_paletteentries[i].peBlue = *(rgb++);
rgb++;
}
if (!ti.m_palette)
{
HRESULT hr = g.m_dddev->CreatePalette( DDPCAPS_8BIT|DDPCAPS_ALLOW256, g.m_paletteentries, &ti.m_palette, NULL );
if ( FAILED(hr) )
{
OutputDebugString("Wrapper: CreatePalette failed\n");
return;
}
}
ti.m_palette->SetEntries(0,0,256,g.m_paletteentries);
ti.m_rgbaindexed = false;
}
else
{
UCHAR *rgba = (UCHAR *) data;
WORD *rgba4 = g.m_rgbapalette;
for (int i = 0; i < 256; ++i, rgba += 4)
*(rgba4++) = ((rgba[3] & 0xF0) << 8) | ((rgba[0] & 0xF0) << 4) | (rgba[1] & 0xF0) | ((rgba[2] & 0xF0) >> 4);
ti.m_rgbaindexed = true;
}
}
GLAPI void GLAPIENTRY glReadBuffer (GLenum mode)
{
if (mode != GL_FRONT)
OutputDebugString("Wrapper: Unsupported glReadBuffer mode\n");
}
GLAPI void GLAPIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{
x;
y;
width;
height;
format;
type;
pixels;
HRESULT hr;
DDSURFACEDESC2 mddsd2, vddsd2;
LPDIRECTDRAWSURFACE7 lpDDS;
vddsd2.dwSize = sizeof(DDSURFACEDESC2);
g.m_pD3DX->GetPrimary()->GetSurfaceDesc(&vddsd2);
int bpp = vddsd2.ddpfPixelFormat.dwRGBBitCount/8;
char *temp = new char[width*bpp*height];
// Initialize the surface description.
ZeroMemory(&mddsd2, sizeof(DDSURFACEDESC2));
mddsd2.dwSize = sizeof(DDSURFACEDESC2);
mddsd2.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_LPSURFACE |
DDSD_PITCH | DDSD_PIXELFORMAT | DDSD_CAPS;
mddsd2.dwWidth = width;
mddsd2.dwHeight = height;
mddsd2.lPitch = (LONG) width*bpp;
mddsd2.lpSurface = temp;
mddsd2.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
memcpy(&mddsd2.ddpfPixelFormat,&vddsd2.ddpfPixelFormat,sizeof(DDPIXELFORMAT));
RECT src;
GetWindowRect(g.m_hwnd,&src);
int xadj = ((src.right-src.left)-width)/2;
int yadj = (src.bottom-src.top)-height;
src.left += xadj;
src.right -= xadj;
src.top += (yadj-xadj);
src.bottom -= xadj;
// Create the surface
hr = g.m_dddev->CreateSurface(&mddsd2, &lpDDS, NULL);
if (FAILED(hr))
{
OutputDebugString("Wrapper: Couldn't create surface for glReadPixels blit\n");
delete [] temp;
return;
}
hr = lpDDS->BltFast(0,0,g.m_pD3DX->GetPrimary(),&src,DDBLTFAST_WAIT | DDBLTFAST_NOCOLORKEY);
lpDDS->Release();
switch (bpp)
{
case 2:
{
WORD *spixels = (WORD *) temp;
for (int y = 1; y <= height; ++y)
{
char *dpixels = (char *) pixels + ((height-y)*width*3);
for (int x = 0; x < width; ++x)
{
*(dpixels++) = (*spixels & 0xF800) >> 8;
*(dpixels++) = (*spixels & 0x7E0) >> 3;
*(dpixels++) = (*spixels & 0x1F) << 3;
spixels++;
}
}
}
break;
case 3:
{
char *spixels = temp;
// I'm guessing on this one that little/big endian shouldn't make no difference
for (int y = 1; y <= height; ++y)
{
char *dpixels = (char *) pixels + ((height-y)*width*3);
memcpy(dpixels,spixels,width*3);
spixels += width*3;
}
}
break;
case 4:
{
DWORD *spixels = (DWORD *) temp;
for (int y = 1; y <= height; ++y)
{
char *dpixels = (char *) pixels + ((height-y)*width*3);
for (int x = 0; x < width; ++x)
{
*(dpixels++) = (*spixels & 0xFF0000) >> 16;
*(dpixels++) = (*spixels & 0xFF00) >> 8;
*(dpixels++) = *spixels & 0xFF;
spixels++;
}
}
}
break;
}
delete [] temp;
}
GLAPI void GLAPIENTRY glPixelStorei (GLenum pname, GLint param)
{
pname;
param;
}
GLAPI GLboolean GLAPIENTRY glAvailableVertexBufferEXT()
{
return (!g.m_lowVidMemory && g.m_freeVBuffers.length());
}
GLAPI GLint GLAPIENTRY glAllocateVertexBufferEXT(GLsizei size, GLint format, GLboolean preserve)
{
if (g.m_lowVidMemory || !g.m_freeVBuffers.length())
{
OutputDebugString("Wrapper: Out of vertex buffers\n");
return -1;
}
GLListManip<GLuint> freeVBuffers(&g.m_freeVBuffers);
GLint handle = freeVBuffers();
BufferInfo &binfo = g.m_vbuffers[handle];
D3DVERTEXBUFFERDESC vbufdesc;
vbufdesc.dwSize = sizeof(D3DVERTEXBUFFERDESC);
vbufdesc.dwNumVertices = size;
if (g.m_dd.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
vbufdesc.dwCaps = D3DVBCAPS_WRITEONLY;
else
vbufdesc.dwCaps = D3DVBCAPS_SYSTEMMEMORY;
switch (format)
{
case GL_V12MTVFMT_EXT:
vbufdesc.dwFVF = V12MTVFMT;
break;
case GL_V12MTNVFMT_EXT:
vbufdesc.dwFVF = V12MTNVFMT;
break;
case GL_V12FTVFMT_EXT:
vbufdesc.dwFVF = V12FTVFMT;
break;
case GL_V12FMTVFMT_EXT:
vbufdesc.dwFVF = V12FMTVFMT;
break;
}
if (size == 0)
binfo.buf = 0;
else
{
HRESULT hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &binfo.buf, 0);
if (FAILED(hr))
{
OutputDebugString("Wrapper: Low video memory\n");
g.m_lowVidMemory = TRUE;
return -1;
}
}
binfo.size = size;
binfo.format = format;
binfo.preserve = preserve;
freeVBuffers.remove();
return handle;
}
GLAPI void* GLAPIENTRY glLockVertexBufferEXT(GLint handle, GLsizei size)
{
BufferInfo &binfo = g.m_vbuffers[handle];
if (!binfo.buf)
return NULL;
if (binfo.preserve)
{
binfo.buf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY, &binfo.verts, 0);
binfo.nfv = 0;
}
else
if (binfo.nfv > (binfo.size - size)) // check if space available
{
binfo.buf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_OKTOSWAP, &binfo.verts, 0);
binfo.nfv = 0;
}
else
{
binfo.buf->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_NOOVERWRITE, &binfo.verts, 0);
switch (binfo.format)
{
case GL_V12MTVFMT_EXT:
binfo.verts = &(((V12MTVertex *) binfo.verts)[binfo.nfv]);
break;
case GL_V12MTNVFMT_EXT:
binfo.verts = &(((V12MTNVertex *) binfo.verts)[binfo.nfv]);
break;
case GL_V12FTVFMT_EXT:
binfo.verts = &(((V12FTVertex *) binfo.verts)[binfo.nfv]);
break;
case GL_V12FMTVFMT_EXT:
binfo.verts = &(((V12FMTVertex *) binfo.verts)[binfo.nfv]);
break;
}
}
return binfo.verts;
}
GLAPI void GLAPIENTRY glUnlockVertexBufferEXT(GLint handle)
{
BufferInfo &binfo = g.m_vbuffers[handle];
if (binfo.buf)
{
binfo.buf->Unlock();
binfo.verts = 0;
}
}
GLAPI void GLAPIENTRY glSetVertexBufferEXT(GLint handle)
{
BufferInfo &binfo = g.m_vbuffers[handle];
if (binfo.preserve)
{
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
}
g.m_useVBuffer = handle;
}
GLAPI void GLAPIENTRY glOffsetVertexBufferEXT(GLint handle, GLuint offset)
{
BufferInfo &binfo = g.m_vbuffers[handle];
binfo.nfv = offset;
}
GLAPI void GLAPIENTRY glFillVertexBufferEXT(GLint handle, GLint first, GLsizei count)
{
BufferInfo &binfo = g.m_vbuffers[handle];
g.m_useVBuffer = handle;
fillVB_NC(first, count);
g.m_useVBuffer = -1;
binfo.nfv += count;
}
GLAPI void GLAPIENTRY glFreeVertexBufferEXT(GLint handle)
{
GLListManip<GLuint> freeVBuffers(&g.m_freeVBuffers);
BufferInfo &binfo = g.m_vbuffers[handle];
binfo.size = 0;
binfo.format = 0;
binfo.preserve = FALSE;
binfo.nfv = 0;
if (binfo.buf)
{
binfo.buf->Release();
binfo.buf = 0;
}
if (binfo.verts)
OutputDebugString("Wrapper: Locked vertex buffer being freed\n");
freeVBuffers.insert(handle);
if (g.m_lowVidMemory)
{
OutputDebugString("Wrapper: Video memory made available\n");
g.m_lowVidMemory = FALSE;
}
}
GLAPI void GLAPIENTRY glFinish (void)
{
g.m_d3ddev->BeginScene();
}
GLAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd)
{
hdc;
ppfd;
return 1;
}
static LRESULT CALLBACK MyMsgHandler(
HWND hwnd, // handle to window
UINT uMsg, // message identifier
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
if (uMsg == WM_SIZE)
{
g.m_winWidth = LOWORD(lParam);
g.m_winHeight = HIWORD(lParam);
}
return CallWindowProc(g.m_wndproc, hwnd, uMsg, wParam, lParam);
}
GLAPI HGLRC GLAPIENTRY wd3dCreateContext(HDC hdc)
{
g.m_hdc = hdc;
g.m_hwnd = WindowFromDC(g.m_hdc);
RECT rect;
BOOLEAN found = FALSE;
DWORD texfmts = 0;
GetClientRect(g.m_hwnd, &rect);
g.m_winWidth = (USHORT)rect.right;
g.m_winHeight = (USHORT)rect.bottom;
g.m_vwx = rect.left;
g.m_vwy = rect.top;
g.m_vww = rect.right - rect.left;
g.m_vwh = rect.bottom - rect.top;
HRESULT hr = D3DXInitialize();
if (FAILED(hr))
{
return 0;
}
DWORD DeviceType = D3DX_DEFAULT;
// Check registry key to see if we need to do software emulation
HKEY hKey;
if(ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_QUAKE, &hKey)) {
DWORD dwType;
DWORD dwValue;
DWORD dwSize = 4;
if (ERROR_SUCCESS == RegQueryValueEx( hKey, "Emulation", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
dwType == REG_DWORD &&
dwValue != 0) {
DeviceType = D3DX_HWLEVEL_2D;
}
RegCloseKey( hKey );
}
D3DX_VIDMODEDESC VidMode;
hr = D3DXGetCurrentVideoMode(DeviceType, &VidMode);
if (FAILED(hr))
goto fail1d;
// See if the window is full screen
if ((DWORD) rect.right == VidMode.width && (DWORD) rect.bottom == VidMode.height)
// We are full screen
hr = D3DXCreateContextEx(DeviceType, D3DX_CONTEXT_FULLSCREEN, g.m_hwnd, g.m_hwnd,
VidMode.bpp, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
VidMode.width, VidMode.height, VidMode.refreshRate, &g.m_pD3DX);
else
hr = D3DXCreateContext(DeviceType, 0, g.m_hwnd, D3DX_DEFAULT, D3DX_DEFAULT, &g.m_pD3DX);
if (FAILED(hr))
goto fail1d;
// Keep a copy of the D3D device
g.m_d3ddev = g.m_pD3DX->GetD3DDevice();
if (g.m_d3ddev == NULL)
goto fail1c;
// Keep a copy of the DD device
g.m_dddev = g.m_pD3DX->GetDD();
if (g.m_dddev == NULL)
goto fail1b;
// Get a D3D ptr to create the vertex buffer.
g.m_pD3D = g.m_pD3DX->GetD3D();
if (g.m_pD3D == NULL)
goto fail1a;
hr = g.m_d3ddev->GetCaps(&g.m_dd);
if (FAILED(hr))
goto fail1;
// Check registry key to see if we need to turn off mipmapping
if(ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_QUAKE, &hKey)) {
DWORD dwType;
DWORD dwValue;
DWORD dwSize = 4;
if (ERROR_SUCCESS == RegQueryValueEx( hKey, "DisableMipMap", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
dwType == REG_DWORD &&
dwValue != 0) {
g.m_usemipmap = FALSE;
OutputDebugString("Wrapper: Mipmapping disabled\n");
}
else {
g.m_usemipmap = TRUE;
}
RegCloseKey( hKey );
}
else {
g.m_usemipmap = TRUE;
}
// Enumerate texture formats and find the right ones to use
texfmts = D3DXGetMaxSurfaceFormats(DeviceType, NULL, D3DX_SC_COLORTEXTURE);
// Look for a four bit alpha surface
found = FALSE;
DWORD i;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &g.m_ddFourBitAlphaSurfFormat);
if( FAILED(hr) )
goto fail1;
if(g.m_ddFourBitAlphaSurfFormat == D3DX_SF_A4R4G4B4)
{
found = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: Unable to find 4444 texture.\n");
goto fail1;
}
// Look for a eight bit alpha surface
found = FALSE;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &g.m_ddEightBitAlphaSurfFormat);
if( FAILED(hr) )
goto fail1;
if(g.m_ddEightBitAlphaSurfFormat == D3DX_SF_A8R8G8B8)
{
found = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: Not using 8888 texture\n");
g.m_ddEightBitAlphaSurfFormat = g.m_ddFourBitAlphaSurfFormat;
}
// Look for a surface
found = FALSE;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &g.m_ddFiveBitSurfFormat);
if( FAILED(hr) )
goto fail1;
if(g.m_ddFiveBitSurfFormat == D3DX_SF_R5G5B5 || g.m_ddFiveBitSurfFormat == D3DX_SF_R5G6B5)
{
found = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: Unable to find 555 or 565 texture.\n");
goto fail1;
}
// Look for a 8-bit surface
found = FALSE;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &g.m_ddEightBitSurfFormat);
if( FAILED(hr) )
goto fail1;
if(g.m_ddEightBitSurfFormat == D3DX_SF_X8R8G8B8)
{
found = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: Not using 888 texture\n");
if (g.m_ddEightBitAlphaSurfFormat == D3DX_SF_A8R8G8B8)
g.m_ddEightBitSurfFormat = g.m_ddEightBitAlphaSurfFormat;
else
g.m_ddEightBitSurfFormat = g.m_ddFiveBitSurfFormat;
}
// Look for a luminance surface
found = FALSE;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &g.m_ddLuminanceSurfFormat);
if( FAILED(hr) )
goto fail1;
if(g.m_ddLuminanceSurfFormat == D3DX_SF_L8)
{
found = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: Not using luminance texture\n");
g.m_ddLuminanceSurfFormat = g.m_ddEightBitAlphaSurfFormat;
}
// Look for an alpha surface
found = FALSE;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &g.m_ddAlphaSurfFormat);
if( FAILED(hr) )
goto fail1;
if(g.m_ddAlphaSurfFormat == D3DX_SF_A8)
{
found = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: Not using alpha texture\n");
g.m_ddAlphaSurfFormat = g.m_ddEightBitAlphaSurfFormat;
}
// Look for a palettized surface
D3DX_SURFACEFORMAT tmpformat;
found = FALSE;
for(i = 0; i < texfmts; ++i)
{
hr = D3DXGetSurfaceFormat(DeviceType, NULL, D3DX_SC_COLORTEXTURE, i, &tmpformat);
if( FAILED(hr) )
goto fail1;
if(tmpformat == D3DX_SF_PALETTE8)
{
found = TRUE;
g.m_colortable = TRUE;
break;
}
}
if ( found == FALSE )
{
OutputDebugString("Wrapper: No palette textures -- no GL_EXT_paletted_texture\n");
g.m_colortable = FALSE;
}
// Do misc init stuff
if(g.m_dd.dwMaxTextureWidth < 512 || g.m_dd.dwMaxTextureHeight < 512) {
g.m_subsample = TRUE;
OutputDebugString("Wrapper: Subsampling textures to 256 x 256\n");
}
else
g.m_subsample = FALSE;
if(g.m_dd.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_SQUAREONLY) {
g.m_makeSquare = TRUE;
OutputDebugString("Wrapper: Forcing all textures to be square\n");
}
else
g.m_makeSquare = FALSE;
if(g.m_dd.wMaxSimultaneousTextures > 1) {
g.m_usemtex = TRUE;
OutputDebugString("Wrapper: Multitexturing enabled\n");
}
else {
g.m_usemtex = FALSE;
OutputDebugString("Wrapper: Multitexturing not available with this driver\n");
}
if(!(g.m_dd.dpcTriCaps.dwTextureFilterCaps & D3DPTFILTERCAPS_LINEARMIPLINEAR) &&
!(g.m_dd.dpcTriCaps.dwTextureFilterCaps & D3DPTFILTERCAPS_LINEARMIPNEAREST) &&
!(g.m_dd.dpcTriCaps.dwTextureFilterCaps & D3DPTFILTERCAPS_MIPLINEAR) &&
!(g.m_dd.dpcTriCaps.dwTextureFilterCaps & D3DPTFILTERCAPS_MIPNEAREST)) {
g.m_usemipmap = FALSE;
OutputDebugString("Wrapper: Mipmapping disabled\n");
}
if (!(g.m_dd.dwVertexProcessingCaps & D3DVTXPCAPS_DIRECTIONALLIGHTS))
{
g.m_usedirectional = FALSE;
OutputDebugString("Wrapper: Directional lights disabled\n");
}
else
g.m_usedirectional = TRUE;
if(ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_QUAKE, &hKey)) {
DWORD dwType;
DWORD dwValue;
DWORD dwSize = 4;
if (ERROR_SUCCESS == RegQueryValueEx( hKey, "DoFlip", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
dwType == REG_DWORD &&
dwValue != 0) {
g.m_doFlip = TRUE;
}
else {
g.m_doFlip = FALSE;
}
RegCloseKey( hKey );
}
else {
g.m_doFlip = FALSE;
}
// Create vertex buffers
D3DVERTEXBUFFERDESC vbufdesc;
vbufdesc.dwSize = sizeof(D3DVERTEXBUFFERDESC);
vbufdesc.dwNumVertices = VBUFSIZE;
vbufdesc.dwCaps = D3DVBCAPS_WRITEONLY;
if (!(g.m_dd.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
vbufdesc.dwCaps = D3DVBCAPS_SYSTEMMEMORY;
vbufdesc.dwFVF = QUAKEFMTVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_fmtvbuf, 0);
if( FAILED(hr) )
goto fail1;
vbufdesc.dwFVF = QUAKEMTVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_mtvbuf, 0);
if ( FAILED(hr) )
goto fail2;
vbufdesc.dwFVF = QUAKETVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_tvbuf, 0);
if ( FAILED(hr) )
goto fail3;
vbufdesc.dwFVF = QUAKEVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_vbuf, 0);
if ( FAILED(hr) )
goto fail4;
if (!(g.m_dd.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
{
vbufdesc.dwFVF = QUAKETRFMTVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_fmtvtgt, 0);
if( FAILED(hr) )
goto fail5;
vbufdesc.dwFVF = QUAKETRMTVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_mtvtgt, 0);
if ( FAILED(hr) )
goto fail6;
vbufdesc.dwFVF = QUAKETRTVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_tvtgt, 0);
if ( FAILED(hr) )
goto fail7;
vbufdesc.dwFVF = QUAKETRVFMT;
hr = g.m_pD3D->CreateVertexBuffer(&vbufdesc, &g.m_vtgt, 0);
if ( FAILED(hr) )
goto fail8;
}
goto success;
fail8:
g.m_tvtgt->Release();
fail7:
g.m_mtvtgt->Release();
fail6:
g.m_fmtvtgt->Release();
fail5:
g.m_vbuf->Release();
fail4:
g.m_tvbuf->Release();
fail3:
g.m_mtvbuf->Release();
fail2:
g.m_fmtvbuf->Release();
fail1:
g.m_pD3D->Release();
fail1a:
g.m_dddev->Release();
fail1b:
g.m_d3ddev->Release();
fail1c:
g.m_pD3DX->Release();
fail1d:
D3DXUninitialize();
return 0;
success:
// Some more init stuff
g.m_cullMode = GL_BACK;
g.m_cullEnabled = FALSE;
g.m_texHandleValid = FALSE;
g.m_texturing = FALSE;
g.m_updvwp = TRUE;
g.m_blendmode[0] = GL_MODULATE;
g.m_blendmode[1] = GL_MODULATE;
g.m_nfv[0] = g.m_nfv[1] = g.m_nfv[2] = g.m_nfv[3] = 0;
g.m_curtgt = 0;
g.m_client_active_texture_arb = 0;
g.m_nx = 0.0;
g.m_ny = 0.0;
g.m_nz = 1.0;
g.m_color = 0xFFFFFFFF;
g.m_tu = g.m_tv = g.m_tu2 = g.m_tv2 = 0.f;
g.m_clearColor = 0;
g.m_clearDepth = 1.f;
g.m_usecolorary = FALSE;
g.m_usetexcoordary[0] = FALSE;
g.m_usetexcoordary[1] = FALSE;
g.m_usevertexary = FALSE;
g.m_scix = 0;
g.m_sciy = 0;
g.m_sciw = g.m_winWidth;
g.m_scih = g.m_winHeight;
g.m_lckfirst = 0;
g.m_lckcount = 0;
g.m_numIndices = 1024;
g.m_wIndices = new WORD[g.m_numIndices];
g.m_frontFace = GL_CCW;
g.m_usenormalary = FALSE;
g.m_normalstride = 0;
g.m_texcoordstride[0] = 0;
g.m_texcoordstride[1] = 0;
g.m_texgen[0] = FALSE;
g.m_texgen[1] = FALSE;
g.m_texgenmode[0] = GL_EYE_LINEAR;
g.m_texgenmode[0] = GL_EYE_LINEAR;
g.m_texgenplane[0][0][0] = 1.0;
g.m_texgenplane[0][0][1] = 0.0;
g.m_texgenplane[0][0][2] = 0.0;
g.m_texgenplane[0][0][3] = 0.0;
g.m_texgenplane[0][1][0] = 0.0;
g.m_texgenplane[0][1][1] = 1.0;
g.m_texgenplane[0][1][2] = 0.0;
g.m_texgenplane[0][1][3] = 0.0;
g.m_texgenplane[1][0][0] = 1.0;
g.m_texgenplane[1][0][1] = 0.0;
g.m_texgenplane[1][0][2] = 0.0;
g.m_texgenplane[1][0][3] = 0.0;
g.m_texgenplane[1][1][0] = 0.0;
g.m_texgenplane[1][1][1] = 1.0;
g.m_texgenplane[1][1][2] = 0.0;
g.m_texgenplane[1][1][3] = 0.0;
g.m_inversedirty = TRUE;
g.m_objectdirty[0] = TRUE;
g.m_objectdirty[1] = TRUE;
g.m_envcolor = 0;
g.m_colorstride = 0;
g.m_colortype = GL_FLOAT;
g.m_zbias = 0;
g.m_fogcolor = 0;
g.m_usefogary = FALSE;
g.m_fogstride = 0;
g.m_tgtdirty = TRUE;
g.m_lighting = FALSE;
g.m_incdex = -1;
g.m_source2rgbext = GL_CONSTANT_EXT;
g.m_vertarysize = 0;
g.m_useVBuffer = -1;
g.m_lowVidMemory = FALSE;
// Initialize the structure.
ZeroMemory(g.m_lights, sizeof(D3DLIGHT7));
// Set up for a white point light.
g.m_lights[0].dltType = D3DLIGHT_DIRECTIONAL;
g.m_lights[0].dcvDiffuse.r = 1.0f;
g.m_lights[0].dcvDiffuse.g = 1.0f;
g.m_lights[0].dcvDiffuse.b = 1.0f;
g.m_lights[0].dcvAmbient.r = 0.0f;
g.m_lights[0].dcvAmbient.g = 0.0f;
g.m_lights[0].dcvAmbient.b = 0.0f;
g.m_lights[0].dcvSpecular.r = 1.0f;
g.m_lights[0].dcvSpecular.g = 1.0f;
g.m_lights[0].dcvSpecular.b = 1.0f;
// Position it high in the scene, and behind the viewer.
// (Remember, these coordinates are in world space, so
// the "viewer" could be anywhere in world space, too.
// For the purposes of this example, assume the viewer
// is at the origin of world space.)
g.m_lights[0].dvPosition.x = 0.0f;
g.m_lights[0].dvPosition.y = 0.0f;
g.m_lights[0].dvPosition.z = 1.0f;
g.m_lights[0].dvDirection.x = 0.0f;
g.m_lights[0].dvDirection.y = 0.0f;
g.m_lights[0].dvDirection.z = -1.0f;
// Don't attenuate.
g.m_lights[0].dvAttenuation0 = 1.0f;
g.m_lights[0].dvRange = D3DLIGHT_RANGE_MAX;
g.m_lights[0].dvTheta = g.m_lights[0].dvPhi = M_PI/4.0;
g.m_lights[0].dvFalloff = 1.0;
g.m_lights[0].dvRange = D3DLIGHT_RANGE_MAX;
for (i = 1; i < 8; ++i)
{
D3DLIGHT7 &d3dLight = g.m_lights[i];
// Initialize the structure.
ZeroMemory(&d3dLight, sizeof(D3DLIGHT7));
// Set up for a white point light.
d3dLight.dltType = D3DLIGHT_DIRECTIONAL;
d3dLight.dcvDiffuse.r = 0.0f;
d3dLight.dcvDiffuse.g = 0.0f;
d3dLight.dcvDiffuse.b = 0.0f;
d3dLight.dcvAmbient.r = 0.0f;
d3dLight.dcvAmbient.g = 0.0f;
d3dLight.dcvAmbient.b = 0.0f;
d3dLight.dcvSpecular.r = 0.0f;
d3dLight.dcvSpecular.g = 0.0f;
d3dLight.dcvSpecular.b = 0.0f;
// Position it high in the scene, and behind the viewer.
// (Remember, these coordinates are in world space, so
// the "viewer" could be anywhere in world space, too.
// For the purposes of this example, assume the viewer
// is at the origin of world space.)
d3dLight.dvPosition.x = 0.0f;
d3dLight.dvPosition.y = 0.0f;
d3dLight.dvPosition.z = 1.0f;
d3dLight.dvDirection.x = 0.0f;
d3dLight.dvDirection.y = 0.0f;
d3dLight.dvDirection.z = -1.0f;
// Don't attenuate.
d3dLight.dvAttenuation0 = 1.0f;
d3dLight.dvRange = D3DLIGHT_RANGE_MAX;
d3dLight.dvTheta = d3dLight.dvPhi = M_PI/2.0;
d3dLight.dvFalloff = 1.0;
d3dLight.dvRange = D3DLIGHT_RANGE_MAX;
}
ZeroMemory(g.m_paletteentries,256*sizeof(PALETTEENTRY));
ZeroMemory(g.m_rgbapalette,256*sizeof(WORD));
g.m_curtexmatrix._11 = 1.0f; g.m_curtexmatrix._12 = 0.0f; g.m_curtexmatrix._13 = 0.0f; g.m_curtexmatrix._14 = 0.0f;
g.m_curtexmatrix._21 = 0.0f; g.m_curtexmatrix._22 = 1.0f; g.m_curtexmatrix._23 = 0.0f; g.m_curtexmatrix._24 = 0.0f;
g.m_curtexmatrix._31 = 0.0f; g.m_curtexmatrix._32 = 0.0f; g.m_curtexmatrix._33 = 1.0f; g.m_curtexmatrix._34 = 0.0f;
g.m_curtexmatrix._41 = 0.0f; g.m_curtexmatrix._42 = 0.0f; g.m_curtexmatrix._43 = 0.0f; g.m_curtexmatrix._44 = 1.0f;
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE0,&g.m_curtexmatrix);
D3DMATRIX sphere;
sphere._11 = 0.5; sphere._12 = 0.0; sphere._13 = 0.0; sphere._14 = 0.0;
sphere._21 = 0.0; sphere._22 = 0.5; sphere._23 = 0.0; sphere._24 = 0.0;
sphere._31 = 0.0; sphere._32 = 0.0; sphere._33 = 0.0; sphere._34 = 0.0;
sphere._41 = 0.5; sphere._42 = 0.5; sphere._43 = 0.0; sphere._44 = 0.0;
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_TEXTURE1,&sphere);
g.m_material.ambient.r = 0.2;
g.m_material.ambient.g = 0.2;
g.m_material.ambient.b = 0.2;
g.m_material.ambient.a = 1.0;
g.m_material.diffuse.r = 0.8;
g.m_material.diffuse.g = 0.8;
g.m_material.diffuse.b = 0.8;
g.m_material.diffuse.a = 1.0;
g.m_material.specular.r = 0.0;
g.m_material.specular.g = 0.0;
g.m_material.specular.b = 0.0;
g.m_material.specular.a = 1.0;
g.m_material.emissive.r = 0.0;
g.m_material.emissive.g = 0.0;
g.m_material.emissive.b = 0.0;
g.m_material.emissive.a = 1.0;
g.m_material.power = 0.0;
g.m_d3ddev->SetMaterial(&g.m_material);
GLListManip<GLuint> freeTextures(&g.m_freeTextures);
for (i = 0; i < MAXGLTEXHANDLES; ++i) {
g.m_tex[i].m_ddsurf = 0;
g.m_tex[i].m_block = 0;
g.m_tex[i].m_capture = FALSE;
g.m_tex[i].m_dwStage = 0;
g.m_tex[i].m_minmode = D3DTFN_POINT;
g.m_tex[i].m_magmode = D3DTFG_LINEAR;
g.m_tex[i].m_mipmode = D3DTFP_LINEAR;
g.m_tex[i].m_addu = D3DTADDRESS_WRAP;
g.m_tex[i].m_addv = D3DTADDRESS_WRAP;
g.m_tex[i].m_rgbaindexed = FALSE;
g.m_tex[i].m_palette = 0;
if (i)
freeTextures.insert(i);
}
GLListManip<GLuint> freeVBuffers(&g.m_freeVBuffers);
for (i = 0; i < MAX_VBUFFERS; ++i)
{
g.m_vbuffers[i].size = 0;
g.m_vbuffers[i].format = 0;
g.m_vbuffers[i].preserve = FALSE;
g.m_vbuffers[i].nfv = 0;
g.m_vbuffers[i].buf = 0;
g.m_vbuffers[i].verts = 0;
freeVBuffers.insert(i);
}
D3DMATRIX unity;
unity._11 = 1.0f; unity._12 = 0.0f; unity._13 = 0.0f; unity._14 = 0.0f;
unity._21 = 0.0f; unity._22 = 1.0f; unity._23 = 0.0f; unity._24 = 0.0f;
unity._31 = 0.0f; unity._32 = 0.0f; unity._33 = 1.0f; unity._34 = 0.0f;
unity._41 = 0.0f; unity._42 = 0.0f; unity._43 = 0.0f; unity._44 = 1.0f;
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_VIEW, &unity);
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_WORLD, &unity);
g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_PROJECTION, &unity);
g.m_curtex[0] = NULL;
g.m_curtex[1] = NULL;
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_TEXTUREPERSPECTIVE, TRUE);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_SPECULARENABLE, FALSE);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_DITHERENABLE, TRUE);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_CLIPPING, TRUE);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_LIGHTING, FALSE);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_AMBIENT, 0x32323219);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_AMBIENTMATERIALSOURCE, D3DMCS_COLOR1);
g.m_d3ddev->SetRenderState(D3DRENDERSTATE_EXTENTS, FALSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_TEXCOORDINDEX,0);
if(g.m_usemtex == TRUE)
g.m_d3ddev->SetTextureStageState (1, D3DTSS_TEXCOORDINDEX,1);
// Create shaders
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][0]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][1]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_MODULATE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][2]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_MODULATE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][3]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][4]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_BLENDTEXTUREALPHA);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][5]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_MODULATE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][6]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_MODULATE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][7]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][8]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR);
g.m_d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
g.m_d3ddev->EndStateBlock(&g.m_shaders[0][9]);
if(g.m_usemtex)
{
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][0]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][1]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_MODULATE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][2]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_MODULATE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][3]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][4]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_BLENDTEXTUREALPHA);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][5]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_MODULATE);
// following stage state to speedup software rasterizer
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][6]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_MODULATE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][7]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_BLENDFACTORALPHA);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][8]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_BLENDCURRENTALPHA);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][9]);
g.m_d3ddev->BeginStateBlock();
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLORARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_COLOROP, D3DTOP_BLENDTEXTUREALPHA);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
g.m_d3ddev->SetTextureStageState (1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
g.m_d3ddev->EndStateBlock(&g.m_shaders[1][10]);
}
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
sgD3DCompatibility::sgInitShaders(g.m_d3ddev);
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
// Hook into message loop
//
// Disabled because we're not using it and alt-tabbing causes a crash (still hooked
// up when the DLL unloads
//
//g.m_wndproc = (WNDPROC)SetWindowLong(g.m_hwnd, GWL_WNDPROC, (LONG)MyMsgHandler);
// Start a scene
g.m_d3ddev->BeginScene();
return (HGLRC)1;
}
GLAPI BOOL GLAPIENTRY wd3dDeleteContext(HGLRC hglrc)
{
hglrc;
g.m_d3ddev->EndScene();
//SetWindowLong(g.m_hwnd, GWL_WNDPROC, (LONG)g.m_wndproc);
int i;
for(i = 0; i < MAXGLTEXHANDLES; ++i){
if(g.m_tex[i].m_ddsurf != 0) {
g.m_tex[i].m_ddsurf->Release();
g.m_tex[i].m_ddsurf = 0;
if(g.m_tex[i].m_block != 0)
{
g.m_d3ddev->DeleteStateBlock(g.m_tex[i].m_block);
g.m_tex[i].m_block = 0;
}
g.m_tex[i].m_capture = FALSE;
g.m_tex[i].m_rgbaindexed = FALSE;
if (g.m_tex[i].m_palette)
{
g.m_tex[i].m_palette->Release();
g.m_tex[i].m_palette = 0;
}
}
}
GLListManip<GLuint> freeTextures(&g.m_freeTextures);
while (g.m_freeTextures.length())
freeTextures.remove();
GLListManip<GLuint> freeVBuffers(&g.m_freeVBuffers);
while (g.m_freeVBuffers.length())
freeVBuffers.remove();
for (i = 0; i < 10; ++i)
g.m_d3ddev->DeleteStateBlock(g.m_shaders[0][i]);
if (g.m_usemtex)
for (i = 0; i < 11; ++i)
g.m_d3ddev->DeleteStateBlock(g.m_shaders[1][i]);
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
sgD3DCompatibility::sgDeleteShaders(g.m_d3ddev);
//-----------------------------------------------
// Lighting Pack code block
//-----------------------------------------------
if (!(g.m_dd.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
{
g.m_vtgt->Release();
g.m_vtgt = 0;
g.m_tvtgt->Release();
g.m_tvtgt = 0;
g.m_mtvtgt->Release();
g.m_mtvtgt = 0;
g.m_fmtvtgt->Release();
g.m_fmtvtgt = 0;
}
g.m_vbuf->Release();
g.m_vbuf = 0;
g.m_tvbuf->Release();
g.m_tvbuf = 0;
g.m_mtvbuf->Release();
g.m_mtvbuf = 0;
g.m_fmtvbuf->Release();
g.m_fmtvbuf = 0;
g.m_pD3D->Release();
g.m_pD3D = 0;
g.m_dddev->Release();
g.m_dddev = 0;
g.m_d3ddev->Release();
g.m_d3ddev = 0;
g.m_pD3DX->Release();
g.m_pD3DX = 0;
D3DXUninitialize();
delete [] g.m_wIndices;
g.m_wIndices = 0;
return TRUE;
}
GLAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc, INT iPixelFormat, UINT nBytes, PIXELFORMATDESCRIPTOR *ppfd)
{
hdc;
iPixelFormat;
nBytes;
HRESULT hr = D3DXInitialize();
if (FAILED(hr))
return 0;
D3DX_VIDMODEDESC VidMode;
hr = D3DXGetCurrentVideoMode(D3DX_DEFAULT, &VidMode);
if (FAILED(hr))
{
D3DXUninitialize();
return 0;
}
D3DXUninitialize();
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
ppfd->nVersion = 1;
ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED;
ppfd->iPixelType = PFD_TYPE_RGBA;
ppfd->cColorBits = (unsigned char)VidMode.bpp;
ppfd->cAccumBits = 0;
ppfd->cAccumRedBits = 0;
ppfd->cAccumGreenBits = 0;
ppfd->cAccumBlueBits = 0;
ppfd->cAccumAlphaBits = 0;
ppfd->cStencilBits = 0;
ppfd->cAuxBuffers = 0;
ppfd->iLayerType = 0;
ppfd->bReserved = 0;
ppfd->dwLayerMask = 0;
ppfd->dwVisibleMask = 0;
ppfd->dwDamageMask = 0;
if(VidMode.bpp == 16)
{
ppfd->cRedBits = 5;
ppfd->cRedShift = 11;
ppfd->cGreenBits = 6;
ppfd->cGreenShift = 5;
ppfd->cBlueBits = 5;
ppfd->cBlueShift = 0;
ppfd->cAlphaBits = 0;
ppfd->cAlphaShift = 0;
ppfd->cDepthBits = 16;
}
else if(VidMode.bpp == 24 || VidMode.bpp == 32)
{
ppfd->cRedBits = 8;
ppfd->cRedShift = 16;
ppfd->cGreenBits = 8;
ppfd->cGreenShift = 8;
ppfd->cBlueBits = 8;
ppfd->cBlueShift = 0;
ppfd->cAlphaBits = 0;
ppfd->cAlphaShift = 0;
ppfd->cDepthBits = 32;
}
else
{
return 0;
}
return 1;
}
GLAPI HGLRC GLAPIENTRY wd3dGetCurrentContext(VOID)
{
return (HGLRC)1;
}
GLAPI HDC GLAPIENTRY wd3dGetCurrentDC(VOID)
{
return g.m_hdc;
}
GLAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)
{
hdc;
return 1;
}
GLAPI PROC GLAPIENTRY wd3dGetProcAddress(LPCSTR str)
{
if(strcmp(str, "glMTexCoord2fSGIS") == 0)
return (PROC) glMTexCoord2fSGIS;
else if(strcmp(str, "glSelectTextureSGIS") == 0)
return (PROC) glSelectTextureSGIS;
else if(strcmp(str, "glActiveTextureARB") == 0)
return (PROC) glActiveTextureARB;
else if(strcmp(str, "glClientActiveTextureARB") == 0)
return (PROC) glClientActiveTextureARB;
else if(strcmp(str, "glMultiTexCoord2fARB") == 0)
return (PROC) glMultiTexCoord2fARB;
else if(strcmp(str, "glMultiTexCoord2fvARB") == 0)
return (PROC) glMultiTexCoord2fvARB;
else if(strcmp(str, "glLockArraysEXT") == 0)
return (PROC) glLockArraysEXT;
else if(strcmp(str, "glUnlockArraysEXT") == 0)
return (PROC) glUnlockArraysEXT;
else if(strcmp(str, "glFogCoordfEXT") == 0)
return (PROC) glFogCoordfEXT;
else if(strcmp(str, "glFogCoordPointerEXT") == 0)
return (PROC) glFogCoordPointerEXT;
else if(strcmp(str, "glColorTableEXT") == 0)
return (PROC) glColorTableEXT;
else if(strcmp(str, "glAvailableVertexBufferEXT") == 0)
return (PROC) glAvailableVertexBufferEXT;
else if(strcmp(str, "glAllocateVertexBufferEXT") == 0)
return (PROC) glAllocateVertexBufferEXT;
else if(strcmp(str, "glLockVertexBufferEXT") == 0)
return (PROC) glLockVertexBufferEXT;
else if(strcmp(str, "glUnlockVertexBufferEXT") == 0)
return (PROC) glUnlockVertexBufferEXT;
else if(strcmp(str, "glSetVertexBufferEXT") == 0)
return (PROC) glSetVertexBufferEXT;
else if(strcmp(str, "glOffsetVertexBufferEXT") == 0)
return (PROC) glOffsetVertexBufferEXT;
else if(strcmp(str, "glFillVertexBufferEXT") == 0)
return (PROC) glFillVertexBufferEXT;
else if(strcmp(str, "glFreeVertexBufferEXT") == 0)
return (PROC) glFreeVertexBufferEXT;
else
{
OutputDebugString("Wrapper: Unimplemented function ");
OutputDebugString(str);
OutputDebugString("\n");
}
return NULL;
}
GLAPI BOOL GLAPIENTRY wd3dMakeCurrent(HDC hdc, HGLRC hglrc)
{
hdc;
hglrc;
return TRUE;
}
GLAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc, int iPixelFormat, CONST PIXELFORMATDESCRIPTOR *ppfd)
{
hdc;
iPixelFormat;
ppfd;
return TRUE;
}
GLAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)
{
hdc;
#ifdef USEICECAP
static unsigned nframes = 0;
++nframes;
if(nframes == 1000)
{
OutputDebugString("Started profiling\n");
StartCAP();
}
if(nframes == 1500)
{
StopCAP();
OutputDebugString("stopped profiling\n");
}
#endif
g.m_d3ddev->EndScene();
while (g.m_pD3DX->UpdateFrame(g.m_doFlip ? 0 : D3DX_UPDATE_NOVSYNC) == DDERR_SURFACEBUSY) {}
return TRUE;
}
//////////////////////////////////////////// NOT USED by QuakeGL ///////////////////////////////////////////////////////
#define DODPFS
static void DPF(char *str)
{
OutputDebugString(str);
OutputDebugString("\n");
}
GLAPI void GLAPIENTRY glAccum (GLenum op, GLfloat value)
{
op;
value;
#ifdef DODPFS
DPF("glAccum");
#endif //DODPFS
}
GLAPI GLboolean GLAPIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences)
{
n;
textures;
residences;
GLboolean dummy = FALSE;
#ifdef DODPFS
DPF("glAreTexturesResident");
#endif //DODPFS
return dummy;
}
GLAPI void GLAPIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
{
width;
height;
xorig;
yorig;
xmove;
ymove;
bitmap;
#ifdef DODPFS
DPF("glBitmap");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCallList (GLuint list)
{
list;
#ifdef DODPFS
DPF("glCallList");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCallLists (GLsizei n, GLenum type, const GLvoid *lists)
{
n;
type;
lists;
#ifdef DODPFS
DPF("glCallLists");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glClearAccum");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glClearIndex (GLfloat c)
{
c;
#ifdef DODPFS
DPF("glClearIndex");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glClearStencil (GLint s)
{
s;
#ifdef DODPFS
DPF("glClearStencil");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue)
{
red;
green;
blue;
#ifdef DODPFS
DPF("glColor3b");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3bv (const GLbyte *v)
{
v;
#ifdef DODPFS
DPF("glColor3bv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue)
{
red;
green;
blue;
#ifdef DODPFS
DPF("glColor3d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glColor3dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glColor3fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3i (GLint red, GLint green, GLint blue)
{
unsigned int R, G, B;
R = (unsigned int)(red);
G = (unsigned int)(green);
B = (unsigned int)(blue);
if(R > 255)
R = 255;
if(G > 255)
G = 255;
if(B > 255)
B = 255;
g.m_color = RGBA_MAKE(R, G, B, 255);
}
GLAPI void GLAPIENTRY glColor3iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glColor3iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3s (GLshort red, GLshort green, GLshort blue)
{
red;
green;
blue;
#ifdef DODPFS
DPF("glColor3s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glColor3sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue)
{
red;
green;
blue;
#ifdef DODPFS
DPF("glColor3ui");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3uiv (const GLuint *v)
{
v;
#ifdef DODPFS
DPF("glColor3uiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3us (GLushort red, GLushort green, GLushort blue)
{
red;
green;
blue;
#ifdef DODPFS
DPF("glColor3us");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor3usv (const GLushort *v)
{
v;
#ifdef DODPFS
DPF("glColor3usv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColor4b");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4bv (const GLbyte *v)
{
v;
#ifdef DODPFS
DPF("glColor4bv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColor4d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glColor4dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColor4i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glColor4iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColor4s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glColor4sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColor4ui");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4uiv (const GLuint *v)
{
v;
#ifdef DODPFS
DPF("glColor4uiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColor4us");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColor4usv (const GLushort *v)
{
v;
#ifdef DODPFS
DPF("glColor4usv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
red;
green;
blue;
alpha;
#ifdef DODPFS
DPF("glColorMask");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glColorMaterial (GLenum face, GLenum mode)
{
face;
mode;
#ifdef DODPFS
DPF("glColorMaterial");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
x;
y;
width;
height;
type;
#ifdef DODPFS
DPF("glCopyPixels");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
{
target;
level;
internalFormat;
x;
y;
width;
border;
#ifdef DODPFS
DPF("glCopyTexImage1D");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
target;
level;
internalFormat;
x;
y;
width;
height;
border;
#ifdef DODPFS
DPF("glCopyTexImage2D");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
target;
level;
xoffset;
x;
y;
width;
#ifdef DODPFS
DPF("glCopyTexSubImage1D");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
target;
level;
xoffset;
yoffset;
x;
y;
width;
height;
#ifdef DODPFS
DPF("glCopyTexSubImage2D");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glDeleteLists (GLuint list, GLsizei range)
{
list;
range;
#ifdef DODPFS
DPF("glDeleteLists");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
width;
height;
format;
type;
pixels;
#ifdef DODPFS
DPF("glDrawPixels");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEdgeFlag (GLboolean flag)
{
flag;
#ifdef DODPFS
DPF("glEdgeFlag");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer)
{
stride;
pointer;
#ifdef DODPFS
DPF("glEdgeFlagPointer");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEdgeFlagv (const GLboolean *flag)
{
flag;
#ifdef DODPFS
DPF("glEdgeFlagv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEndList (void)
{
#ifdef DODPFS
DPF("glEndList");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord1d (GLdouble u)
{
u;
#ifdef DODPFS
DPF("glEvalCoord1d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord1dv (const GLdouble *u)
{
u;
#ifdef DODPFS
DPF("glEvalCoord1dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord1f (GLfloat u)
{
u;
#ifdef DODPFS
DPF("glEvalCoord1f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord1fv (const GLfloat *u)
{
u;
#ifdef DODPFS
DPF("glEvalCoord1fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord2d (GLdouble u, GLdouble v)
{
u;
v;
#ifdef DODPFS
DPF("glEvalCoord2d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord2dv (const GLdouble *u)
{
u;
#ifdef DODPFS
DPF("glEvalCoord2dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord2f (GLfloat u, GLfloat v)
{
u;
v;
#ifdef DODPFS
DPF("glEvalCoord2f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalCoord2fv (const GLfloat *u)
{
u;
#ifdef DODPFS
DPF("glEvalCoord2fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2)
{
mode;
i1;
i2;
#ifdef DODPFS
DPF("glEvalMesh1");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
mode;
i1;
i2;
j1;
j2;
#ifdef DODPFS
DPF("glEvalMesh2");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalPoint1 (GLint i)
{
i;
#ifdef DODPFS
DPF("glEvalPoint1");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glEvalPoint2 (GLint i, GLint j)
{
i;
j;
#ifdef DODPFS
DPF("glEvalPoint2");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)
{
size;
type;
buffer;
#ifdef DODPFS
DPF("glFeedbackBuffer");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glFlush (void)
{
#ifdef DODPFS
DPF("glFlush");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glFogiv (GLenum pname, const GLint *params)
{
pname;
params;
#ifdef DODPFS
DPF("glFogiv");
#endif //DODPFS
}
GLAPI GLuint GLAPIENTRY glGenLists (GLsizei range)
{
range;
GLuint dummy = 0;
#ifdef DODPFS
DPF("glGenLists");
#endif //DODPFS
return dummy;
}
GLAPI void GLAPIENTRY glGetBooleanv (GLenum pname, GLboolean *params)
{
pname;
params;
#ifdef DODPFS
DPF("glGetBooleanv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetClipPlane (GLenum plane, GLdouble *equation)
{
plane;
equation;
#ifdef DODPFS
DPF("glGetClipPlane");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params)
{
light;
pname;
params;
#ifdef DODPFS
DPF("glGetLightfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params)
{
light;
pname;
params;
#ifdef DODPFS
DPF("glGetLightiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v)
{
target;
query;
v;
#ifdef DODPFS
DPF("glGetMapdv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v)
{
target;
query;
v;
#ifdef DODPFS
DPF("glGetMapfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v)
{
target;
query;
v;
#ifdef DODPFS
DPF("glGetMapiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)
{
face;
pname;
params;
#ifdef DODPFS
DPF("glGetMaterialfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params)
{
face;
pname;
params;
#ifdef DODPFS
DPF("glGetMaterialiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetPixelMapfv (GLenum map, GLfloat *values)
{
map;
values;
#ifdef DODPFS
DPF("glGetPixelMapfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetPixelMapuiv (GLenum map, GLuint *values)
{
map;
values;
#ifdef DODPFS
DPF("glGetPixelMapuiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetPixelMapusv (GLenum map, GLushort *values)
{
map;
values;
#ifdef DODPFS
DPF("glGetPixelMapusv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetPointerv (GLenum pname, GLvoid* *params)
{
pname;
params;
#ifdef DODPFS
DPF("glGetPointerv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetPolygonStipple (GLubyte *mask)
{
mask;
#ifdef DODPFS
DPF("glGetPolygonStipple");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params)
{
target;
pname;
params;
#ifdef DODPFS
DPF("glGetTexEnvfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params)
{
coord;
pname;
params;
#ifdef DODPFS
DPF("glGetTexGendv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params)
{
coord;
pname;
params;
#ifdef DODPFS
DPF("glGetTexGenfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params)
{
coord;
pname;
params;
#ifdef DODPFS
DPF("glGetTexGeniv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
{
target;
level;
format;
type;
pixels;
#ifdef DODPFS
DPF("glGetTexImage");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
{
target;
level;
pname;
params;
#ifdef DODPFS
DPF("glGetTexLevelParameterfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
{
target;
level;
pname;
params;
#ifdef DODPFS
DPF("glGetTexLevelParameteriv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)
{
target;
pname;
params;
#ifdef DODPFS
DPF("glGetTexParameterfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
{
target;
pname;
params;
#ifdef DODPFS
DPF("glGetTexParameteriv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glHint (GLenum target, GLenum mode)
{
target;
mode;
#ifdef DODPFS
//DPF("glHint(%X, %X)",target,mode);
DPF("glHint");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexMask (GLuint mask)
{
mask;
#ifdef DODPFS
DPF("glIndexMask");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
{
type;
stride;
pointer;
#ifdef DODPFS
DPF("glIndexPointer");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexd (GLdouble c)
{
c;
#ifdef DODPFS
DPF("glIndexd");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexdv (const GLdouble *c)
{
c;
#ifdef DODPFS
DPF("glIndexdv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexf (GLfloat c)
{
c;
#ifdef DODPFS
DPF("glIndexf");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexfv (const GLfloat *c)
{
c;
#ifdef DODPFS
DPF("glIndexfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexi (GLint c)
{
c;
#ifdef DODPFS
DPF("glIndexi");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexiv (const GLint *c)
{
c;
#ifdef DODPFS
DPF("glIndexiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexs (GLshort c)
{
c;
#ifdef DODPFS
DPF("glIndexs");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexsv (const GLshort *c)
{
c;
#ifdef DODPFS
DPF("glIndexsv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexub (GLubyte c)
{
c;
#ifdef DODPFS
DPF("glIndexub");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glIndexubv (const GLubyte *c)
{
c;
#ifdef DODPFS
DPF("glIndexubv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glInitNames (void)
{
#ifdef DODPFS
DPF("glInitNames");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer)
{
format;
stride;
pointer;
#ifdef DODPFS
DPF("glInterleavedArrays");
#endif //DODPFS
}
GLAPI GLboolean GLAPIENTRY glIsList (GLuint list)
{
list;
GLboolean dummy = FALSE;
#ifdef DODPFS
DPF("glIsList");
#endif //DODPFS
return dummy;
}
GLAPI GLboolean GLAPIENTRY glIsTexture (GLuint texture)
{
texture;
GLboolean dummy = FALSE;
#ifdef DODPFS
DPF("glIsTexture");
#endif //DODPFS
return dummy;
}
GLAPI void GLAPIENTRY glLightModelf (GLenum pname, GLfloat param)
{
pname;
param;
#ifdef DODPFS
DPF("glLightModelf");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLightModeli (GLenum pname, GLint param)
{
pname;
param;
#ifdef DODPFS
DPF("glLightModeli");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLightModeliv (GLenum pname, const GLint *params)
{
pname;
params;
#ifdef DODPFS
DPF("glLightModeliv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLighti (GLenum light, GLenum pname, GLint param)
{
light;
pname;
param;
#ifdef DODPFS
DPF("glLighti");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params)
{
light;
pname;
params;
#ifdef DODPFS
DPF("glLightiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLineStipple (GLint factor, GLushort pattern)
{
factor;
pattern;
#ifdef DODPFS
DPF("glLineStipple");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glListBase (GLuint base)
{
base;
#ifdef DODPFS
DPF("glListBase");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLoadMatrixd (const GLdouble *m)
{
m;
#ifdef DODPFS
DPF("glLoadMatrixd");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLoadName (GLuint name)
{
name;
#ifdef DODPFS
DPF("glLoadName");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glLogicOp (GLenum opcode)
{
opcode;
#ifdef DODPFS
DPF("glLogicOp");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
target;
u1;
u2;
stride;
order;
points;
#ifdef DODPFS
DPF("glMap1d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
target;
u1;
u2;
stride;
order;
points;
#ifdef DODPFS
DPF("glMap1f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
{
target;
u1;
u2;
ustride;
uorder;
v1;
v2;
vstride;
vorder;
points;
#ifdef DODPFS
DPF("glMap2d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
{
target;
u1;
u2;
ustride;
uorder;
v1;
v2;
vstride;
vorder;
points;
#ifdef DODPFS
DPF("glMap2f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2)
{
un;
u1;
u2;
#ifdef DODPFS
DPF("glMapGrid1d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2)
{
un;
u1;
u2;
#ifdef DODPFS
DPF("glMapGrid1f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
un;
u1;
u2;
vn;
v1;
v2;
#ifdef DODPFS
DPF("glMapGrid2d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
un;
u1;
u2;
vn;
v1;
v2;
#ifdef DODPFS
DPF("glMapGrid2f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param)
{
face;
pname;
param;
#ifdef DODPFS
DPF("glMaterialf");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMateriali (GLenum face, GLenum pname, GLint param)
{
face;
pname;
param;
#ifdef DODPFS
DPF("glMateriali");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params)
{
face;
pname;
params;
#ifdef DODPFS
DPF("glMaterialiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glMultMatrixd (const GLdouble *m)
{
m;
#ifdef DODPFS
DPF("glMultMatrixd");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNewList (GLuint list, GLenum mode)
{
list;
mode;
#ifdef DODPFS
DPF("glNewList");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz)
{
nx;
ny;
nz;
#ifdef DODPFS
DPF("glNormal3b");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3bv (const GLbyte *v)
{
v;
#ifdef DODPFS
DPF("glNormal3bv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
{
nx;
ny;
nz;
#ifdef DODPFS
DPF("glNormal3d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glNormal3dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)
{
nx;
ny;
nz;
#ifdef DODPFS
DPF("glNormal3f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glNormal3fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3i (GLint nx, GLint ny, GLint nz)
{
nx;
ny;
nz;
#ifdef DODPFS
DPF("glNormal3i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glNormal3iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz)
{
nx;
ny;
nz;
#ifdef DODPFS
DPF("glNormal3s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glNormal3sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glNormal3sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPassThrough (GLfloat token)
{
token;
#ifdef DODPFS
DPF("glPassThrough");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values)
{
map;
mapsize;
values;
#ifdef DODPFS
DPF("glPixelMapfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values)
{
map;
mapsize;
values;
#ifdef DODPFS
DPF("glPixelMapuiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values)
{
map;
mapsize;
values;
#ifdef DODPFS
DPF("glPixelMapusv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelStoref (GLenum pname, GLfloat param)
{
pname;
param;
#ifdef DODPFS
DPF("glPixelStoref");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelTransferf (GLenum pname, GLfloat param)
{
pname;
param;
#ifdef DODPFS
DPF("glPixelTransferf");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelTransferi (GLenum pname, GLint param)
{
pname;
param;
#ifdef DODPFS
DPF("glPixelTransferi");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor)
{
xfactor;
yfactor;
#ifdef DODPFS
DPF("glPixelZoom");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPolygonStipple (const GLubyte *mask)
{
mask;
#ifdef DODPFS
DPF("glPolygonStipple");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPopAttrib (void)
{
#ifdef DODPFS
DPF("glPopAttrib");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPopClientAttrib (void)
{
#ifdef DODPFS
DPF("glPopClientAttrib");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPopName (void)
{
#ifdef DODPFS
DPF("glPopName");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)
{
n;
textures;
priorities;
#ifdef DODPFS
DPF("glPrioritizeTextures");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPushAttrib (GLbitfield mask)
{
mask;
#ifdef DODPFS
DPF("glPushAttrib");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPushClientAttrib (GLbitfield mask)
{
mask;
#ifdef DODPFS
DPF("glPushClientAttrib");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glPushName (GLuint name)
{
name;
#ifdef DODPFS
DPF("glPushName");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2d (GLdouble x, GLdouble y)
{
x;
y;
#ifdef DODPFS
DPF("glRasterPos2d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos2dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2f (GLfloat x, GLfloat y)
{
x;
y;
#ifdef DODPFS
DPF("glRasterPos2f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos2fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2i (GLint x, GLint y)
{
x;
y;
#ifdef DODPFS
DPF("glRasterPos2i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos2iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2s (GLshort x, GLshort y)
{
x;
y;
#ifdef DODPFS
DPF("glRasterPos2s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos2sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos2sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glRasterPos3d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos3dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glRasterPos3f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos3fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3i (GLint x, GLint y, GLint z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glRasterPos3i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos3iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glRasterPos3s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos3sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos3sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glRasterPos4d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos4dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glRasterPos4f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos4fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glRasterPos4i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos4iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glRasterPos4s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRasterPos4sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glRasterPos4sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
x1;
y1;
x2;
y2;
#ifdef DODPFS
DPF("glRectd");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2)
{
v1;
v2;
#ifdef DODPFS
DPF("glRectdv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
x1;
y1;
x2;
y2;
#ifdef DODPFS
DPF("glRectf");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2)
{
v1;
v2;
#ifdef DODPFS
DPF("glRectfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRectiv (const GLint *v1, const GLint *v2)
{
v1;
v2;
#ifdef DODPFS
DPF("glRectiv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
x1;
y1;
x2;
y2;
#ifdef DODPFS
DPF("glRects");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glRectsv (const GLshort *v1, const GLshort *v2)
{
v1;
v2;
#ifdef DODPFS
DPF("glRectsv");
#endif //DODPFS
}
GLAPI GLint GLAPIENTRY glRenderMode (GLenum mode)
{
mode;
GLint dummy = 0;
#ifdef DODPFS
DPF("glRenderMode");
#endif //DODPFS
return dummy;
}
GLAPI void GLAPIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
angle;
x;
y;
z;
#ifdef DODPFS
DPF("glRotated");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glScaled");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glSelectBuffer (GLsizei size, GLuint *buffer)
{
size;
buffer;
#ifdef DODPFS
DPF("glSelectBuffer");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask)
{
func;
ref;
mask;
#ifdef DODPFS
DPF("glStencilFunc");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glStencilMask (GLuint mask)
{
mask;
#ifdef DODPFS
DPF("glStencilMask");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
{
fail;
zfail;
zpass;
#ifdef DODPFS
DPF("glStencilOp");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1d (GLdouble s)
{
s;
#ifdef DODPFS
DPF("glTexCoord1d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord1dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1f (GLfloat s)
{
s;
#ifdef DODPFS
DPF("glTexCoord1f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord1fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1i (GLint s)
{
s;
#ifdef DODPFS
DPF("glTexCoord1i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord1iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1s (GLshort s)
{
s;
#ifdef DODPFS
DPF("glTexCoord1s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord1sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord1sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord2d (GLdouble s, GLdouble t)
{
s;
t;
#ifdef DODPFS
DPF("glTexCoord2d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord2dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord2dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord2i (GLint s, GLint t)
{
s;
t;
#ifdef DODPFS
DPF("glTexCoord2i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord2iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord2iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord2s (GLshort s, GLshort t)
{
s;
t;
#ifdef DODPFS
DPF("glTexCoord2s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord2sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord2sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
{
s;
t;
r;
#ifdef DODPFS
DPF("glTexCoord3d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord3dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
{
s;
t;
r;
#ifdef DODPFS
DPF("glTexCoord3f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord3fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3i (GLint s, GLint t, GLint r)
{
s;
t;
r;
#ifdef DODPFS
DPF("glTexCoord3i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord3iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r)
{
s;
t;
r;
#ifdef DODPFS
DPF("glTexCoord3s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord3sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord3sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
s;
t;
r;
q;
#ifdef DODPFS
DPF("glTexCoord4d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord4dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
s;
t;
r;
q;
#ifdef DODPFS
DPF("glTexCoord4f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord4fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q)
{
s;
t;
r;
q;
#ifdef DODPFS
DPF("glTexCoord4i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord4iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
{
s;
t;
r;
q;
#ifdef DODPFS
DPF("glTexCoord4s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexCoord4sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glTexCoord4sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params)
{
target;
pname;
params;
#ifdef DODPFS
DPF("glTexEnviv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param)
{
coord;
pname;
param;
#ifdef DODPFS
DPF("glTexGend");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params)
{
coord;
pname;
params;
#ifdef DODPFS
DPF("glTexGendv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param)
{
coord;
pname;
param;
#ifdef DODPFS
DPF("glTexGenf");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params)
{
coord;
pname;
params;
#ifdef DODPFS
DPF("glTexGeniv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
target;
level;
internalformat;
width;
border;
format;
type;
pixels;
#ifdef DODPFS
DPF("glTexImage1D");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)
{
target;
pname;
params;
#ifdef DODPFS
DPF("glTexParameterfv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params)
{
target;
pname;
params;
#ifdef DODPFS
DPF("glTexParameteriv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
{
target;
level;
xoffset;
width;
format;
type;
pixels;
#ifdef DODPFS
DPF("glTexSubImage1D");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glTranslated");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex2d (GLdouble x, GLdouble y)
{
x;
y;
#ifdef DODPFS
DPF("glVertex2d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex2dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glVertex2dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex2iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glVertex2iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex2s (GLshort x, GLshort y)
{
x;
y;
#ifdef DODPFS
DPF("glVertex2s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex2sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glVertex2sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glVertex3d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex3dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glVertex3dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex3i (GLint x, GLint y, GLint z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glVertex3i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex3iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glVertex3iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex3s (GLshort x, GLshort y, GLshort z)
{
x;
y;
z;
#ifdef DODPFS
DPF("glVertex3s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex3sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glVertex3sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glVertex4d");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4dv (const GLdouble *v)
{
v;
#ifdef DODPFS
DPF("glVertex4dv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glVertex4f");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4fv (const GLfloat *v)
{
v;
#ifdef DODPFS
DPF("glVertex4fv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glVertex4i");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4iv (const GLint *v)
{
v;
#ifdef DODPFS
DPF("glVertex4iv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)
{
x;
y;
z;
w;
#ifdef DODPFS
DPF("glVertex4s");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glVertex4sv (const GLshort *v)
{
v;
#ifdef DODPFS
DPF("glVertex4sv");
#endif //DODPFS
}
GLAPI void GLAPIENTRY glFogCoordfEXT (GLfloat f)
{
f;
#ifdef DODPFS
DPF("glFogCoordfEXT");
#endif //DODPFS
}
GLAPI BOOL GLAPIENTRY wd3dCopyContext(HGLRC src, HGLRC dst, UINT mask)
{
src;
dst;
mask;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglCopyContext");
#endif //DODPFS
return dummy;
}
GLAPI HGLRC GLAPIENTRY wd3dCreateLayerContext(HDC hdc, int iLayerPlane)
{
hdc;
iLayerPlane;
HGLRC dummy = NULL;
#ifdef DODPFS
DPF("wglCreateLayerContext");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dDescribeLayerPlane(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd)
{
hdc;
iPixelFormat;
iLayerPlane;
nBytes;
plpd;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglDescribeLayerPlane");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wglGetDefaultProcAddress()
{
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglGetDefaultProcAddress");
#endif //DODPFS
return dummy;
}
GLAPI int GLAPIENTRY wd3dGetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF *pcr)
{
hdc;
iLayerPlane;
iStart;
cEntries;
pcr;
int dummy = 0;
#ifdef DODPFS
DPF("wglGetLayerPaletteEntries");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dRealizeLayerPalette(HDC hdc, int iLayerPlane, BOOL bRealize)
{
hdc;
iLayerPlane;
bRealize;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglRealizeLayerPalette");
#endif //DODPFS
return dummy;
}
GLAPI int GLAPIENTRY wd3dSetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, CONST COLORREF *pcr)
{
hdc;
iLayerPlane;
iStart;
cEntries;
pcr;
int dummy = 0;
#ifdef DODPFS
DPF("wglSetLayerPaletteEntries");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dShareLists(HGLRC hglrc1, HGLRC hglrc2)
{
hglrc1;
hglrc2;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglShareLists");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dSwapLayerBuffers(HDC hdc, UINT fuPlanes)
{
hdc;
fuPlanes;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglSwapLayerBuffers");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listbase)
{
hdc;
first;
count;
listbase;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglUseFontBitmapsA");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dUseFontBitmapsW()
{
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglUseFontBitmapsW");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dUseFontOutlinesA(HDC hdc, DWORD first, DWORD count, DWORD listBase, float deviation, float extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
{
hdc;
first;
count;
listBase;
deviation;
extrusion;
format;
lpgmf;
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglUseFontOutlinesA");
#endif //DODPFS
return dummy;
}
GLAPI BOOL GLAPIENTRY wd3dUseFontOutlinesW()
{
BOOL dummy = FALSE;
#ifdef DODPFS
DPF("wglUseFontOutlinesW");
#endif //DODPFS
return dummy;
}