//----------------------------------------------------------------------------- // 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 #ifdef USEICECAP #include #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 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 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 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 m(&g.m_matrixStack[1]); g.m_d3ddev->SetTransform(D3DTRANSFORMSTATE_PROJECTION, &(m())); m.remove(); } else { GLListManip 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 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 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 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 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 freeTextures(&g.m_freeTextures); while (g.m_freeTextures.length()) freeTextures.remove(); GLListManip 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; }