//----------------------------------------------------------------------------- // 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; }