//-----------------------------------------------------------------------------
// Name: PixelFormatToString()
// Desc: Creates a string describing a pixel format.
// adapted from microsoft mssdk D3DIM Compress example
// PixelFormatToString()
//-----------------------------------------------------------------------------
VOID Image_DXTC::DecodePixelFormat( CHAR* strPixelFormat, DDPIXELFORMAT* pddpf )
{
switch( pddpf->dwFourCC )
{
case 0:
// This dds texture isn't compressed so write out ARGB format
sprintf( strPixelFormat, "ARGB-%d%d%d%d%s",
GetNumberOfBits( pddpf->dwRGBAlphaBitMask ),
GetNumberOfBits( pddpf->dwRBitMask ),
GetNumberOfBits( pddpf->dwGBitMask ),
GetNumberOfBits( pddpf->dwBBitMask ),
pddpf->dwBBitMask & DDPF_ALPHAPREMULT ? "-premul" : "" );
m_CompFormat = PF_ARGB;
break;
case MAKEFOURCC('D','X','T','1'):
strcpy( strPixelFormat, "DXT1" );
m_CompFormat = PF_DXT1;
break;
case MAKEFOURCC('D','X','T','2'):
strcpy( strPixelFormat, "DXT2" );
m_CompFormat = PF_DXT2;
break;
case MAKEFOURCC('D','X','T','3'):
strcpy( strPixelFormat, "DXT3" );
m_CompFormat = PF_DXT3;
break;
case MAKEFOURCC('D','X','T','4'):
strcpy( strPixelFormat, "DXT4" );
m_CompFormat = PF_DXT4;
break;
case MAKEFOURCC('D','X','T','5'):
strcpy( strPixelFormat, "DXT5" );
m_CompFormat = PF_DXT5;
break;
default:
strcpy( strPixelFormat, "Format Unknown");
m_CompFormat = PF_UNKNOWN;
break;
}
}
COLORREF APIENTRY NtGdiGetNearestColor(HDC hDC, COLORREF Color)
{
COLORREF nearest = CLR_INVALID;
PDC dc;
PPALETTE palGDI;
LONG RBits, GBits, BBits;
dc = DC_LockDc(hDC);
if (NULL != dc)
{
HPALETTE hpal = dc->dclevel.hpal;
palGDI = PALETTE_ShareLockPalette(hpal);
if (!palGDI)
{
DC_UnlockDc(dc);
return nearest;
}
if (palGDI->flFlags & PAL_INDEXED)
{
ULONG index;
index = PALETTE_ulGetNearestPaletteIndex(palGDI, Color);
nearest = PALETTE_ulGetRGBColorFromIndex(palGDI, index);
}
else if (palGDI->flFlags & PAL_RGB || palGDI->flFlags & PAL_BGR)
{
nearest = Color;
}
else if (palGDI->flFlags & PAL_BITFIELDS)
{
RBits = 8 - GetNumberOfBits(palGDI->RedMask);
GBits = 8 - GetNumberOfBits(palGDI->GreenMask);
BBits = 8 - GetNumberOfBits(palGDI->BlueMask);
nearest = RGB(
(GetRValue(Color) >> RBits) << RBits,
(GetGValue(Color) >> GBits) << GBits,
(GetBValue(Color) >> BBits) << BBits);
}
void LogEntry6::ResumeSyncSend(void)
{
if (!SyncSendPaused)
{
return;
}
SyncSendPaused = FALSE;
if (SyncNumber == CERROR)
{
return;
}
// We just unpaused and we're assigned a record number... tell everybody else all about ourselves.
for (r_slot R = 0; R < (r_slot) GetNumberOfBits(); R++)
{
SetRoomInPersonalHall(R, IsRoomInPersonalHall(R));
}
}
void LogEntry2::ResumeSyncSend(void)
{
if (!SyncSendPaused)
{
return;
}
SyncSendPaused = FALSE;
if (SyncNumber == CERROR)
{
return;
}
// We just unpaused and we're assigned a record number... tell everybody
// else all about ourselves.
for (g_slot G = 0; G < (g_slot) GetNumberOfBits(); G++)
{
SetInGroup(G, IsInGroup(G));
}
}
void BinkSetupVideo(void)
{
DDSURFACEDESC SurfaceDescription;
HRESULT ReturnCode;
UINT16 usRed, usGreen, usBlue;
HVSURFACE hVSurface;
GetVideoSurface( &hVSurface, FRAME_BUFFER );
lpBinkVideoPlayback2 = GetVideoSurfaceDDSurface( hVSurface );
ZEROMEM(SurfaceDescription);
SurfaceDescription.dwSize = sizeof (DDSURFACEDESC);
ReturnCode = IDirectDrawSurface2_GetSurfaceDesc ( lpBinkVideoPlayback2, &SurfaceDescription );
if (ReturnCode != DD_OK)
{
DirectXAttempt ( ReturnCode, __LINE__, __FILE__ );
return;
}
/*
usRed = (UINT16) SurfaceDescription.ddpfPixelFormat.dwRBitMask;
usGreen = (UINT16) SurfaceDescription.ddpfPixelFormat.dwGBitMask;
usBlue = (UINT16) SurfaceDescription.ddpfPixelFormat.dwBBitMask;
// SurfaceDescription.ddpfPixelFormat
if((usRed==0xf800) && (usGreen==0x07e0) && (usBlue==0x001f))
guiBinkPixelFormat = BINKSURFACE565;
else
guiBinkPixelFormat = BINKSURFACE555;
*/
//
// Get bit count for the RGB
//
usRed = GetNumberOfBits( SurfaceDescription.ddpfPixelFormat.dwRBitMask );
usGreen = GetNumberOfBits( SurfaceDescription.ddpfPixelFormat.dwGBitMask );
usBlue = GetNumberOfBits( SurfaceDescription.ddpfPixelFormat.dwBBitMask );
// 555
if( usRed == 5 && usGreen == 5 && usBlue == 5 )
{
guiBinkPixelFormat = BINKSURFACE555;
}
//565
else if( usRed == 5 && usGreen == 6 && usBlue == 5 )
{
guiBinkPixelFormat = BINKSURFACE565;
}
//655
else if( usRed == 6 && usGreen == 5 && usBlue == 5 )
{
guiBinkPixelFormat = BINKSURFACE655;
}
//dont know the format, wont get video
else
{
guiBinkPixelFormat = 0;
}
}
/*-----------------------------------------------------------------------------
Name : d3d_blt_texture
Description :
Inputs : tex - GL texture object
ddpf - pixelformat of texture surface (not needed with ONLY_GENERIC_BLITTERS)
Outputs : currently bound texture object's surface should contain a valid image
Return : TRUE (success) or FALSE (failure)
----------------------------------------------------------------------------*/
GLboolean d3d_blt_texture(gl_texture_object* tex, DDPIXELFORMAT* ddpf)
{
d3d_texobj* t3d = (d3d_texobj*)tex->DriverData;
GLubyte* data;
GLubyte* tempData;
GLsizei width, height, bytes;
GLboolean result;
#if !ONLY_GENERIC_BLITTERS
GLint bits = (GetNumberOfBits(ddpf->dwRGBAlphaBitMask) << 24) |
(GetNumberOfBits(ddpf->dwRBitMask) << 16) |
(GetNumberOfBits(ddpf->dwGBitMask) << 8) |
GetNumberOfBits(ddpf->dwBBitMask);
#endif
tempData = NULL;
if (t3d->width != 0 && t3d->height != 0)
{
//aspect-corrected texture
width = t3d->width;
height = t3d->height;
switch (tex->Format)
{
case GL_COLOR_INDEX:
bytes = 1;
break;
case GL_RGBA16:
bytes = 2;
break;
case GL_RGB:
case GL_RGBA:
bytes = 4;
break;
default:
return FALSE;
}
tempData = new GLubyte[bytes * width * height];
d3d_rescale_generic(bytes, tempData, width, height, tex->Data, tex->Width, tex->Height);
data = tempData;
}
else
{
//normal texture
width = tex->Width;
height = tex->Height;
data = tex->Data;
}
result = FALSE;
switch (tex->Format)
{
case GL_COLOR_INDEX:
result = d3d_blt_COLORINDEX(t3d->texSurface, data, width, height);
break;
case GL_RGB:
case GL_RGBA:
#if ONLY_GENERIC_BLITTERS
result = d3d_blt_RGBA_generic(t3d->texSurface, data, width, height);
#else
switch (bits)
{
case 0x00050605:
result = d3d_blt_RGBA_0565(t3d->texSurface, data, width, height);
break;
case 0x00050505:
result = d3d_blt_RGBA_0555(t3d->texSurface, data, width, height);
break;
case 0x04040404:
result = d3d_blt_RGBA_4444(t3d->texSurface, data, width, height);
break;
case 0x08080808:
result = d3d_blt_RGBA_8888(t3d->texSurface, data, width, height);
break;
default:
result = d3d_blt_RGBA_generic(t3d->texSurface, data, width, height);
}
#endif
break;
case GL_RGBA16:
#if ONLY_GENERIC_BLITTERS
result = d3d_blt_RGBA16_generic(t3d->texSurface, data, width, height);
#else
switch (bits)
{
case 0x04040404:
result = d3d_blt_RGBA16_4444(t3d->texSurface, data, width, height);
break;
case 0x08080808:
result = d3d_blt_RGBA16_8888(t3d->texSurface, data, width, height);
break;
default:
result = d3d_blt_RGBA16_generic(t3d->texSurface, data, width, height);
}
#endif
}
if (tempData != NULL)
{
delete [] tempData;
}
return result;
}
/*-----------------------------------------------------------------------------
Name : d3d_match_texture_formats
Description : tries to match GL texture formats to a D3D device's formats
Inputs : d3d - Direct3D context
Outputs : D3D->tex{internalFormat} point to approp DDPIXELFORMAT structure
Return : TRUE (success) or FALSE (failure)
----------------------------------------------------------------------------*/
GLboolean d3d_match_texture_formats(d3d_context* d3d)
{
DDPIXELFORMAT* ddpf;
GLenum formats[4] = {GL_COLOR_INDEX, GL_RGBA16, GL_RGBA, GL_RGB};
GLint f;
GLint bitMask, bits[4]; //bits = {r,g,b,a}
#if LOG_TEXTURE_FORMATS
FILE* out = fopen("d3dtex.dat", "wt");
if (out == NULL)
{
return GL_FALSE;
}
#endif
for (f = 0; f < 4; f++)
{
ddpf = NULL;
switch (formats[f])
{
case GL_COLOR_INDEX:
{
for (listpf::iterator i = texList.begin(); i != texList.end(); ++i)
{
if (II.dwFlags & DDPF_PALETTEINDEXED8)
{
ddpf = &II;
break;
}
}
}
break;
case GL_RGBA16:
{
for (listpf::iterator i = texList.begin(); i != texList.end(); ++i)
{
bits[0] = GetNumberOfBits(II.dwRBitMask);
bits[1] = GetNumberOfBits(II.dwGBitMask);
bits[2] = GetNumberOfBits(II.dwBBitMask);
bits[3] = GetNumberOfBits(II.dwRGBAlphaBitMask);
bitMask = (bits[3] << 24) | (bits[0] << 16) | (bits[1] << 8) | bits[2];
if (!SurfaceIsPaletted(II.dwFlags) &&
(II.dwRGBBitCount != 24))
{
if (ddpf == NULL)
{
//seed with anything with an alpha channel
if (bits[3] > 0)
{
ddpf = &II;
if (bitMask == 0x04040404)
{
//exact match
break;
}
}
}
else if (II.dwRGBBitCount > 8)
{
if (bitMask == 0x04040404)
{
//exact match
ddpf = &II;
break;
}
else if (bits[3] > GetNumberOfBits(ddpf->dwRGBAlphaBitMask))
{
if (bits[3] > 1)
{
//we prefer more than 1 bit of alpha
ddpf = &II;
}
else
{
if (bits[0] >= GetNumberOfBits(ddpf->dwRBitMask) &&
bits[1] >= GetNumberOfBits(ddpf->dwGBitMask) &&
bits[2] >= GetNumberOfBits(ddpf->dwBBitMask))
{
//more colour depth here
ddpf = &II;
}
}
}
}
}
}
}
break;
case GL_RGBA:
{
for (listpf::iterator i = texList.begin(); i != texList.end(); ++i)
{
bits[0] = GetNumberOfBits(II.dwRBitMask);
bits[1] = GetNumberOfBits(II.dwGBitMask);
bits[2] = GetNumberOfBits(II.dwBBitMask);
bits[3] = GetNumberOfBits(II.dwRGBAlphaBitMask);
bitMask = (bits[3] << 24) | (bits[0] << 16) | (bits[1] << 8) | bits[2];
if (!SurfaceIsPaletted(II.dwFlags) &&
(II.dwRGBBitCount > 8) &&
(II.dwRGBBitCount != 24))
{
if (ddpf == NULL)
{
//seed with anything with an alpha channel
if (bits[3] > 0)
{
ddpf = &II;
}
}
else
{
#if CONSERVE_MEMORY
if (bits[3] < GetNumberOfBits(ddpf->dwRGBAlphaBitMask) &&
bits[3] > 1)
{
//lowest number of bits > 1
ddpf = &II;
}
if (GetNumberOfBits(ddpf->dwRGBAlphaBitMask) == 1 &&
bits[3] > 1)
{
//if we've already got 1 bit alpha, try anything with more
ddpf = &II;
}
#else
if (II.dwRGBBitCount > ddpf->dwRGBBitCount)
{
if (bits[3] > 1)
{
ddpf = &II;
}
}
else if (II.dwRGBBitCount == ddpf->dwRGBBitCount)
{
if (GetNumberOfBits(ddpf->dwRGBAlphaBitMask) == 1 &&
bits[3] > 1)
{
//more than 1 alpha bit
ddpf = &II;
}
else if (bits[0] >= GetNumberOfBits(ddpf->dwRBitMask) &&
bits[1] >= GetNumberOfBits(ddpf->dwGBitMask) &&
bits[2] >= GetNumberOfBits(ddpf->dwBBitMask))
{
//more colour depth
ddpf = &II;
}
}
#endif
}
}
}
}
break;
case GL_RGB:
{
for (listpf::iterator i = texList.begin(); i != texList.end(); ++i)
{
bits[0] = GetNumberOfBits(II.dwRBitMask);
bits[1] = GetNumberOfBits(II.dwGBitMask);
bits[2] = GetNumberOfBits(II.dwBBitMask);
bits[3] = GetNumberOfBits(II.dwRGBAlphaBitMask);
bitMask = (bits[3] << 24) | (bits[0] << 16) | (bits[1] << 8) | bits[2];
if (!SurfaceIsPaletted(II.dwFlags) &&
(II.dwRGBBitCount > 8) &&
(II.dwRGBBitCount != 24))
{
if (ddpf == NULL)
{
//seed with anything
ddpf = &II;
}
else
{
if (bits[3] == 0)
{
//prefer no alpha channel
if (II.dwRGBBitCount == 16)
{
if (ddpf->dwRGBBitCount == II.dwRGBBitCount)
{
GLint sumOld, sumNew;
sumOld = sumNew = 0;
sumOld = GetNumberOfBits(ddpf->dwRBitMask) +
GetNumberOfBits(ddpf->dwGBitMask) +
GetNumberOfBits(ddpf->dwBBitMask);
sumNew = bits[0] + bits[1] + bits[2];
if (sumNew > sumOld)
{
//more colour depth, same byte size
ddpf = &II;
}
}
else
{
//not tracking a 16bit surface yet, we like this one
ddpf = &II;
}
}
#if CONSERVE_MEMORY
if (bits[0] < GetNumberOfBits(ddpf->dwRBitMask) &&
bits[1] < GetNumberOfBits(ddpf->dwGBitMask) &&
bits[2] < GetNumberOfBits(ddpf->dwBBitMask))
{
if (ddpf->dwRGBBitCount != 16)
{
//less colour depth, but leave our existing 16bit surface alone
ddpf = &II;
}
}
#else
if (bits[0] >= GetNumberOfBits(ddpf->dwRBitMask) &&
bits[1] >= GetNumberOfBits(ddpf->dwGBitMask) &&
bits[2] >= GetNumberOfBits(ddpf->dwBBitMask))
{
if (ddpf->dwRGBBitCount != 16)
{
//more colour depth, but still prefer 16bit
ddpf = &II;
}
}
#endif
}
else
{
if (GetNumberOfBits(ddpf->dwRGBAlphaBitMask) != 0)
{
//already using an alpha channel, so we don't mind so much
#if CONSERVE_MEMORY
if (bits[0] < GetNumberOfBits(ddpf->dwRBitMask) &&
bits[1] < GetNumberOfBits(ddpf->dwGBitMask) &&
bits[2] < GetNumberOfBits(ddpf->dwBBitMask))
{
//less colour depth
ddpf = &II;
}
#else
if (bits[0] >= GetNumberOfBits(ddpf->dwRBitMask) &&
bits[1] >= GetNumberOfBits(ddpf->dwGBitMask) &&
bits[2] >= GetNumberOfBits(ddpf->dwBBitMask))
{
//more colour depth
ddpf = &II;
}
#endif
}
}
}
}
}
}
}
if ((ddpf == NULL) && (f == 0))
{
d3d->texCOLORINDEX = NULL;
#if LOG_TEXTURE_FORMATS
fprintf(out, "colorindex NULL\n");
#endif
continue;
}
if (ddpf == NULL)
{
return GL_FALSE;
}
bitMask = (GetNumberOfBits(ddpf->dwRGBAlphaBitMask) << 24) |
(GetNumberOfBits(ddpf->dwRBitMask) << 16) |
(GetNumberOfBits(ddpf->dwGBitMask) << 8) |
GetNumberOfBits(ddpf->dwBBitMask);
switch (formats[f])
{
case GL_COLOR_INDEX:
d3d->texCOLORINDEX = ddpf;
#if LOG_TEXTURE_FORMATS
fprintf(out, "colorindex %x\n", bitMask);
#endif
break;
case GL_RGBA16:
d3d->texRGBA16 = ddpf;
#if LOG_TEXTURE_FORMATS
fprintf(out, "rgba16 %x\n", bitMask);
#endif
break;
case GL_RGBA:
#if LOG_TEXTURE_FORMATS
fprintf(out, "rgba %x\n", bitMask);
#endif
d3d->texRGBA = ddpf;
break;
case GL_RGB:
#if LOG_TEXTURE_FORMATS
fprintf(out, "rgb %x\n", bitMask);
#endif
d3d->texRGB = ddpf;
}
}
#if LOG_TEXTURE_FORMATS
fclose(out);
#endif
return GL_TRUE;
}
