//+----------------------------------------------------------------------------- //| Loads an uncompressed blp //+----------------------------------------------------------------------------- bool BLP::LoadUncompressed(BLP_HEADER& Header, const BUFFER& SourceBuffer, BUFFER& TargetBuffer) { static const int PALETTE_SIZE = 256; BLP_RGBA const* Palette = reinterpret_cast<BLP_RGBA const*>(SourceBuffer.GetData(sizeof(BLP_HEADER))); BLP_PIXEL const* SourcePixel = reinterpret_cast<BLP_PIXEL const*>(SourceBuffer.GetData(Header.Offset[0])); int Size = Header.Width * Header.Height; TargetBuffer.Resize(Size * 4); BLP_RGBA* TargetPixel = reinterpret_cast<BLP_RGBA*>(TargetBuffer.GetData()); switch(Header.PictureType) { case 3: case 4: for (int i = 0; i < Size; i++) { TargetPixel[i] = Palette[SourcePixel[i].Index]; } for (int i = 0; i < Size; i++) { TargetPixel[i].Alpha = SourcePixel[Size + i].Index; } break; case 5: for (int i = 0; i < Size; i++) { TargetPixel[i] = Palette[SourcePixel[i].Index]; TargetPixel[i].Alpha = 255 - TargetPixel[i].Alpha; } break; default: LOG("Unable to load blp file, unknown picture type!"); return false; } return true; }
//+----------------------------------------------------------------------------- //| Loads a compressed blp texture //+----------------------------------------------------------------------------- BOOL TEXTURE_LOADER_BLP::LoadCompressed(TEXTURE& Texture, BLP_HEADER& Header, BUFFER& Buffer) { BUFFER TempBuffer; BUFFER TempBuffer2; DWORD JpegHeaderSize; std::memcpy(reinterpret_cast<CHAR*>(&JpegHeaderSize), &Buffer[sizeof(BLP_HEADER)], sizeof(DWORD)); if(!TempBuffer2.Resize(Header.Size[0] + JpegHeaderSize)) { Error.SetMessage("Unable to load \"" + CurrentFileName + "\", buffer resizing failed!"); return FALSE; } std::memcpy(&TempBuffer2[0], &Buffer[sizeof(BLP_HEADER) + sizeof(DWORD)], JpegHeaderSize); std::memcpy(&TempBuffer2[JpegHeaderSize], &Buffer[Header.Offset[0]], Header.Size[0]); if (!Jpeg.Read(TempBuffer2, TempBuffer)) { Error.SetMessage("Unable to load \"" + CurrentFileName + "\", BLP reading failed!"); return FALSE; } GLuint TextureId; glGenTextures(1, &TextureId); glBindTexture(GL_TEXTURE_2D, TextureId); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Header.Width, Header.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, TempBuffer.GetData()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenerateMipmap(GL_TEXTURE_2D); Texture.TextureId = TextureId; return TRUE; }
//+----------------------------------------------------------------------------- //| Reads BLP data //+----------------------------------------------------------------------------- bool BLP::Read(const BUFFER& SourceBuffer, BUFFER& TargetBuffer, int* Width, int* Height) { BLP_HEADER Header; memcpy(reinterpret_cast<char*>(&Header), SourceBuffer.GetData(), sizeof(BLP_HEADER)); if (Header.MagicNumber != '1PLB') { LOG("The file is not a BLP file!"); return false; } switch(Header.Compression) { case 0: { if(!LoadCompressed(Header, SourceBuffer, TargetBuffer)) return false; break; } case 1: { if(!LoadUncompressed(Header, SourceBuffer, TargetBuffer)) return false; break; } default: { LOG("Unable to load blp file, unknown compression method!"); return false; } } if(Width != NULL) (*Width) = Header.Width; if(Height != NULL) (*Height) = Header.Height; return true; }
DWORD LoadFileData( LPTSTR lpFilename, BUFFER& buf ){ DWORD dwRet = 0; CReadOnlyFile file(lpFilename); if( file.IsOpen() ){ DWORD dwSize = file.GetFileSize(); if( dwSize > 0 ) { buf.resize( dwSize ); if( file.Read(&buf.at(0), dwSize) == dwSize ){ dwRet = dwSize; } } file.Close(); return dwRet; } return dwRet; }
void DumpFile( LPTSTR lpFilename ){ BUFFER buf; if( LoadFileData(lpFilename, buf) ) { m_wndList.DeleteAllItems(); TString str; int item = 0; unsigned idx = 0; unsigned siz = buf.size(); while( idx < siz ) { int loop = 16; if( int(siz - idx) < 16 ){ loop = int(siz - idx); } str.Format(_T("%08X"), idx); m_wndList.InsertItem(item, (LPTSTR)str); for( int i=0; i<loop; i++ ){ str.Format(_T("%02X"), buf.at(idx+i)); m_wndList.SetItem(item, i+1, (LPTSTR)str); } str.clear(); for( int i=0; i<loop; i++ ){ if( ::isgraph(int(buf.at(idx+i))) ) str.AppendFormat(_T("%c"), buf.at(idx+i)); else str.AppendFormat(_T(" ")); } m_wndList.SetItem(item, 17, (LPTSTR)str); idx += 16; item += 1; } } }
//+----------------------------------------------------------------------------- //| Loads a compressed blp //+----------------------------------------------------------------------------- bool BLP::LoadCompressed(BLP_HEADER& Header, const BUFFER& SourceBuffer, BUFFER& TargetBuffer) { BUFFER TempBuffer; uint32_t JpegHeaderSize; memcpy(reinterpret_cast<char*>(&JpegHeaderSize), SourceBuffer.GetData(sizeof(BLP_HEADER)), sizeof(uint32_t)); TempBuffer.Resize(Header.Size[0] + JpegHeaderSize); memcpy(TempBuffer.GetData(0), SourceBuffer.GetData(sizeof(BLP_HEADER) + sizeof(uint32_t)), JpegHeaderSize); memcpy(TempBuffer.GetData(JpegHeaderSize), SourceBuffer.GetData(Header.Offset[0]), Header.Size[0]); int Width; int Height; if (!Jpeg.Read(TempBuffer, TargetBuffer, &Width, &Height)) { LOG("Unable to load blp file, BLP reading failed!"); return false; } return true; }
BYTE* At( int idx ){ return &m_buf.at( idx ); }
int Size( void ) const { return m_buf.size(); }
void Set( const CBuffer& buf ){ m_buf.resize( buf.m_buf.size() ); memcpy( &m_buf.at(0), &buf.m_buf.at(0), buf.m_buf.size() ); }
void Set( const BYTE* pBuf, int size ){ m_buf.resize( size ); memcpy( &m_buf.at(0), pBuf, size ); }
CBuffer( int nSize ) { m_buf.resize( nSize ); }
void* addXModel(zoneInfo_t* info, const char* name, char* data, size_t dataLen) { if (data == NULL) return NULL; if(dataLen == 0) { XModel * model = (XModel*)data; short* boneNames = new short[model->numBones]; for(int i=0; i<model->numBones; i++) { boneNames[i] = addScriptString(info, SL_ConvertToString(model->boneNames[i])); } model->boneNames = boneNames; for(int i=0; i<model->numSurfaces; i++) { // allow material overriding void* file; void* asset; if(int len = FS_ReadFile(va("zonebuilder/materials/%s.txt", model->materials[i]->name), &file) > 0) { asset = addMaterial(info, model->materials[i]->name, (char*)file, len); FS_FreeFile(file); } else { asset = addMaterial(info, model->materials[i]->name, (char*)model->materials[i], 0); } addAsset(info, ASSET_TYPE_MATERIAL, model->materials[i]->name, asset); } return data; } // copy stuff over XModel * base = (XModel*)DB_FindXAssetHeader(ASSET_TYPE_XMODEL, "viewmodel_mp5k"); XModel * asset = new XModel; memcpy(asset, base, sizeof(XModel)); asset->lods[0].surfaces = new XModelSurfaces; memcpy(asset->lods[0].surfaces, base->lods[0].surfaces, sizeof(XModelSurfaces)); XModelSurfaces * surf = asset->lods[0].surfaces; surf->name = new char[strlen(name) + 6]; sprintf((char*)surf->name, "%s_surf", name); BUFFER * buf = new BUFFER(data, dataLen); asset->name = new char[128]; buf->readstr(asset->name, 128); buf->read(&asset->numBones, 4, 1); buf->read(&asset->numSubBones, 4, 1); buf->read(&asset->numSurfaces, 4, 1); surf->numSurfaces = asset->numSurfaces; asset->lods[0].numSurfs = surf->numSurfaces; asset->boneNames = new short[asset->numBones]; for(int i=0; i<asset->numBones; i++) { char bone[64]; buf->readstr(bone, 64); asset->boneNames[i] = addScriptString(info, bone); } // allocate stuff and load it if(asset->numBones - asset->numSubBones) { asset->parentList = new char[asset->numBones - asset->numSubBones]; asset->tagAngles = new XModelAngle[asset->numBones - asset->numSubBones]; asset->tagPositions = new XModelTagPos[asset->numBones - asset->numSubBones]; buf->read(asset->parentList, sizeof(char), asset->numBones - asset->numSubBones); buf->read(asset->tagAngles, sizeof(XModelAngle), asset->numBones - asset->numSubBones); buf->read(asset->tagPositions, sizeof(XModelTagPos), asset->numBones - asset->numSubBones); } if(asset->numBones) { asset->partClassification = new char[asset->numBones]; asset->animMatrix = new char[32 * asset->numBones]; buf->read(asset->partClassification, sizeof(char), asset->numBones); buf->read(asset->animMatrix, 32, asset->numBones); } surf->surfaces = new XSurface[surf->numSurfaces]; memset(surf->surfaces, 0, sizeof(XSurface) * surf->numSurfaces); for(int i=0; i<surf->numSurfaces; i++) { XSurface* s = &surf->surfaces[i]; buf->read(&s->numVertices, 4, 1); buf->read(&s->numPrimitives, 4, 1); buf->read(&s->blendNum1, 4, 1); buf->read(&s->blendNum2, 4, 1); buf->read(&s->blendNum3, 4, 1); buf->read(&s->blendNum4, 4, 1); int blendCount = (s->blendNum4 * 7) + (s->blendNum3 * 5) + (s->blendNum2 * 3) + s->blendNum1; if(blendCount) { s->blendInfo = new char[blendCount * 2]; buf->read(s->blendInfo, 2, blendCount); } else { s->blendInfo = NULL; } s->vertexBuffer = new GfxPackedVertex[s->numVertices]; buf->read(s->vertexBuffer, 32, s->numVertices); int ct = 0; buf->read(&ct, 4, 1); if(ct) { buf->read(&s->numCT, 4, 1); s->ct = new XSurfaceCT[s->numCT]; for(int j=0; j<s->numCT; j++) { XSurfaceCT* ct = &s->ct[j]; buf->read(&ct->pad, 4, 1); buf->read(&ct->pad2, 4, 1); ct->entry = new XSurfaceCTEntry; buf->read(ct->entry, 24, 1); buf->read(&ct->entry->numNode, 4, 1); buf->read(&ct->entry->numLeaf, 4, 1); if(ct->entry->numNode) { ct->entry->node = new char[ct->entry->numNode * 16]; buf->read(ct->entry->node, 16, ct->entry->numNode); } else { ct->entry->node = NULL; } if(ct->entry->numLeaf) { ct->entry->leaf = new short[ct->entry->numLeaf]; buf->read(ct->entry->leaf, 2, ct->entry->numLeaf); } else { ct->entry->node = NULL; } } } else { s->ct = NULL; s->numCT = 0; } s->indexBuffer = new Face[s->numPrimitives]; buf->read(s->indexBuffer, sizeof(Face), s->numPrimitives); } asset->materials = new Material*[asset->numSurfaces]; // read the material stuff and load a material if we need it for(int i=0; i<asset->numSurfaces; i++) { char matName[64] = { 0 }; char techName[64] = { 0 }; char matFileName[78] = { 0 }; buf->readstr(matName, 50); buf->readstr(techName, 64); char* filename = matName; // asset is already in db... dont re-add it if (containsAsset(info, ASSET_TYPE_MATERIAL, matName) > 0) { asset->materials[i] = (Material*)getAsset(info, ASSET_TYPE_MATERIAL, matName); continue; } if(!strncmp("mc/", matName, 3)) filename = matName + 3; _snprintf(matFileName, sizeof(matFileName), "materials/%s.txt", filename); void* matBuf; int len = FS_ReadFile(matFileName, &matBuf); if(len > 0) { asset->materials[i] = (Material*)addMaterial(info, matName, (char*)matBuf, len); FS_FreeFile(matBuf); } else { asset->materials[i] = (Material*)DB_FindXAssetHeader(ASSET_TYPE_MATERIAL, matName); addMaterial(info, matName, (char*)asset->materials[i], 0); } addAsset(info, ASSET_TYPE_MATERIAL, matName, asset->materials[i]); } int test = 0; buf->read(&test, 4, 1); if(test) Com_Error(false, "Cause NTA said so!"); buf->read(&test, 4, 1); if(!test) Com_Error(false, "Cause NTA said so!"); asset->unknowns = new char[asset->numBones * 28]; buf->read(asset->unknowns, 28, asset->numBones); return asset; }
void addMaterial(zoneInfo_t* info, const char* name, char* data, size_t dataLen) { if(parseMatFile(data, dataLen) < 0) return; // load up the techset char techsetfname [128]; _snprintf(techsetfname, 128, "techsets/%s.techset", techsetName); loadAsset(info, ASSET_TYPE_TECHSET, techsetfname, techsetName); int asset = addAsset(info, ASSET_TYPE_MATERIAL, name, NULL, 0); BUFFER* buf = new BUFFER(4096); Material* mat = new Material; memset(mat, 0, sizeof(Material)); mat->name = (char*)0xFFFFFFFF; if(materialUsage == MATERIAL_USAGE_UI) { mat->flags = 0x2F; mat->animationX = 1; mat->animationY = 1; mat->unknown2 = 0xFFFFFFFF; mat->unknown3 = 0xFFFFFF00; memset(mat->unknown4, 0xFF, sizeof(mat->unknown4)); mat->numMaps = materialMapCount; mat->stateMapCount = 1; mat->unknown6 = 3; mat->unknown7 = 4; } // null dem pointers! mat->techniqueSet = (MaterialTechniqueSet*)0x0;//0xFFFFFFFF; mat->maps = (MaterialTextureDef*)0xFFFFFFFF; mat->stateMap = (void*)0xFFFFFFFF; buf->write(mat, sizeof(Material), 1); buf->write((void*)name, strlen(name) + 1, 1); // techset int assetPatchTo = containsAsset(info, ASSET_TYPE_TECHSET, techsetName); addFixup(info, asset, 80, assetPatchTo); // maps for(int i=0; i<materialMapCount; i++) { MaterialTextureDef* tex = new MaterialTextureDef; memset(tex, 0, sizeof(MaterialTextureDef)); tex->firstCharacter = materialMaps[i][0]; tex->secondLastCharacter = materialMaps[i][strlen(materialMaps[i])]; tex->typeHash = R_HashString(materialMaps[i]); tex->image = (GfxImage*)0xFFFFFFFF; tex->textureType = 0xE2; buf->write(tex, sizeof(MaterialTextureDef), 1); GfxImage* img = new GfxImage; memset(img, 0, sizeof(GfxImage)); img->depth = 1; img->textureType = 3; // 2d texture img->textureType2 = 3; img->texture = (GfxImageLoadDef*)0xFFFFFFFF; img->name = (char*)0xFFFFFFFF; img->width = iwiHeaders[i].xsize; img->height = iwiHeaders[i].ysize; buf->write(img, sizeof(GfxImage), 1); buf->write((void*)materialTextureNames[i], strlen(materialTextureNames[i]) + 1, 1); GfxImageLoadDef * def = new GfxImageLoadDef; memset(def, 0, sizeof(GfxImageLoadDef)); int format = 0; switch(iwiHeaders[i].format) { case IWI_ARGB: format = 21; break; case IWI_RGB8: format = 20; break; case IWI_DXT1: format = 0x31545844; break; case IWI_DXT3: format = 0x33545844; break; case IWI_DXT5: format = 0x35545844; break; } def->format = format; def->mipLevels = 1; buf->write(def, sizeof(GfxImageLoadDef), 1); } // unknown 8 goes here whenever we use it // statemap if(materialUsage == MATERIAL_USAGE_UI) { char statemap[] = {0x65, 0x51, 0x12, 0x18, 0x02, 0x00, 0x0E, 0xE0 }; buf->write(statemap, 8, 1); } buf->resize(-1); // fix the data setAssetData(info, asset, buf->data(), buf->getsize()); }
BYTE* GetData( void ){ return &(m_buf.at( 0 )); }
//+----------------------------------------------------------------------------- //| Writes BLP data //+----------------------------------------------------------------------------- bool BLP::Write(const BUFFER& SourceBuffer, BUFFER& TargetBuffer, int Width, int Height, int Quality) { int32_t i; int32_t X; int32_t Y; int32_t Size; int32_t Index; int32_t BufferIndex; int32_t TotalSize; int32_t NrOfMipMaps; int32_t TextureSize; int32_t CurrentWidth; int32_t CurrentHeight; int32_t CurrentOffset; BUFFER TempBuffer; BLP_HEADER Header; const unsigned char* Pointer; uint32_t JpegHeaderSize; std::stringstream Stream; std::vector<BUFFER> MipMapBufferList; JpegHeaderSize = 4; MipMapBufferList.resize(MAX_NR_OF_BLP_MIP_MAPS); Header.Compression = 0; Header.Flags = 8; Header.Width = Width; Header.Height = Height; Header.PictureType = 4; Header.PictureSubType = 1; NrOfMipMaps = 0; Size = std::max(Header.Width, Header.Height); while (Size >= 1) { Size /= 2; NrOfMipMaps++; } if (NrOfMipMaps > MAX_NR_OF_BLP_MIP_MAPS) { NrOfMipMaps = MAX_NR_OF_BLP_MIP_MAPS; } if (NrOfMipMaps < 1) { return FALSE; } CurrentWidth = Header.Width; CurrentHeight = Header.Height; CurrentOffset = sizeof(BLP_HEADER) + sizeof(uint32_t) + JpegHeaderSize; for (i = 0; i < NrOfMipMaps; i++) { TempBuffer.Resize(CurrentWidth * CurrentHeight * 4); Index = 0; BufferIndex = 0; Pointer = reinterpret_cast<const unsigned char*>(SourceBuffer.GetData()); for (Y = 0; Y < static_cast<int32_t>(CurrentHeight); Y++) { for (X = 0; X < static_cast<int32_t>(CurrentWidth); X++) { TempBuffer[BufferIndex++] = Pointer[Index++]; TempBuffer[BufferIndex++] = Pointer[Index++]; TempBuffer[BufferIndex++] = Pointer[Index++]; TempBuffer[BufferIndex++] = Pointer[Index++]; } } if (!Jpeg.Write(TempBuffer, MipMapBufferList[i], CurrentWidth, CurrentHeight, Quality)) { return FALSE; } TextureSize = MipMapBufferList[i].GetSize(); Header.Offset[i] = CurrentOffset; Header.Size[i] = TextureSize - JpegHeaderSize; CurrentWidth /= 2; CurrentHeight /= 2; CurrentOffset += Header.Size[i]; if (CurrentWidth < 1) CurrentWidth = 1; if (CurrentHeight < 1) CurrentHeight = 1; } TotalSize = sizeof(BLP_HEADER) + sizeof(uint32_t) + JpegHeaderSize; for (i = 0; i < NrOfMipMaps; i++) { if (MipMapBufferList[i].GetSize() <= 0) break; TotalSize += Header.Size[i]; } TargetBuffer.Resize(TotalSize); CurrentOffset = 0; memcpy(&TargetBuffer[CurrentOffset], &Header, sizeof(BLP_HEADER)); CurrentOffset += sizeof(BLP_HEADER); memcpy(&TargetBuffer[CurrentOffset], &JpegHeaderSize, sizeof(uint32_t)); CurrentOffset += sizeof(uint32_t); Size = Header.Size[0] + JpegHeaderSize; memcpy(&TargetBuffer[CurrentOffset], &((MipMapBufferList[0])[0]), Size); CurrentOffset += Size; for (i = 1; i < NrOfMipMaps; i++) { if (MipMapBufferList[i].GetSize() <= 0) break; memcpy(&TargetBuffer[CurrentOffset], &((MipMapBufferList[i])[JpegHeaderSize]), Header.Size[i]); CurrentOffset += Header.Size[i]; } return true; }
static unsigned int __recv (SOCKET *self) { /* Initialize */ BUFFER *ff = NULL; int rcvd = 0; int rd = 0; socket_t *sock = self->data; char msg[(const int)sock->bufsz]; unsigned int ws = sock->bufsz - 1; #if 1 #define CC "child" #define SS "server" #define CL "client" char c = sock->_class; fprintf(stderr, "tcp socket buffer: %p (%s)\n", \ ff, (c=='c') ? CL : (c=='d') ? CC : SS); #endif /* Create a new fresh buffer (clean this up...) */ if (!(ff = NEW(buffer)(binary, 0))) return errstat(0, "Failed to create buffer for socket data."); #if 1 fprintf(stderr, "Current size: %d\n", ff->size(ff)); fprintf(stderr, "tcp socket buffer is now: %p (%s)\n", \ ff, (c=='c') ? CL : (c=='d') ? CC : SS); #endif sock->buffer = ff; /* Use a buffer and connection here */ switch (sock->connection_type) { case SOCK_STREAM: /* If it's -1, die. If it's less than buffer, die */ while (1) { rcvd = recv(sock->fd, &msg, ws, 0); rd += rcvd; vvprintf("rcvd %d bytes so far\n", rd); #if 0 int c = 0; for (c=0;c<(ws > rcvd ? rcvd : ws); c++) fprintf(stderr, "'%c' ", msg[c]); #endif /* Error occurred, free or reset the buffer and die */ if (rcvd == -1) return errsys("recv() error occurred"); /* End of message reached before end of buffer */ else if (rcvd < ws) { ff->append(ff, msg, rcvd); vvprintf("Finally rcvd %d bytes.", rd); vvprintf("Current buffer size: %d\n", ff->contents(ff)->size); return SUCCESS; } /* Write the entire buffer otherwise */ ff->append(ff, msg, ws); } #if 0 case SOCK_DGRAM: rcvd = recvfrom(sock->fd, msg, ws, 0, NULL, NULL); //sock->cliaddr, &sock->cliaddrlen); if (rcvd == -1) return 0; msg[rcvd] = 0; fprintf(stderr, "udp recv'd bytes: %d\n", rcvd); fprintf(stderr, "%s\n", msg); while (1) { rcvd = recvfrom(sock->fd, msg, ws, 0, NULL, NULL); fprintf(stderr, "udp recv'd bytes: %d\n", rcvd); fprintf(stderr, "%s\n", msg); if (rcvd == -1) return 0; // return false and sock->error = errno; if (rcvd < ws) break; } return 1; #endif default: fprintf(stderr, "%s\n", "Got unknown socket option."); return 0; } return SUCCESS; }
//+----------------------------------------------------------------------------- //| Loads an uncompressed blp texture //+----------------------------------------------------------------------------- BOOL TEXTURE_LOADER_BLP::LoadUncompressed(TEXTURE &Texture, BLP_HEADER &Header, BUFFER &Buffer) { INT Size; BUFFER TempBuffer; CONST INT PALETTE_SIZE = 256; BLP_RGBA Palette[PALETTE_SIZE]; BLP_RGBA* TargetPixel; std::memcpy(reinterpret_cast<CHAR*>(Palette), &Buffer[sizeof(BLP_HEADER)], (PALETTE_SIZE * 4)); Size = Header.Width * Header.Height; if (!TempBuffer.Resize(Size * 4)) { Error.SetMessage("Unable to load \"" + CurrentFileName + "\", buffer resizing failed!"); return FALSE; } switch (Header.PictureType) { case 3: case 4: { BLP_PIXEL* SourcePixel; SourcePixel = reinterpret_cast<BLP_PIXEL*>(&Buffer[sizeof(BLP_HEADER) + (PALETTE_SIZE * 4)]); TargetPixel = reinterpret_cast<BLP_RGBA*>(&TempBuffer[0]); for (INT i=0; i<Size; i++) { TargetPixel[i].Red = Palette[SourcePixel[i].Index].Red; TargetPixel[i].Green = Palette[SourcePixel[i].Index].Green; TargetPixel[i].Blue = Palette[SourcePixel[i].Index].Blue; } for (INT i=0; i<Size; i++) { TargetPixel[i].Alpha = SourcePixel[Size + i].Index; } break; } case 5: { BLP_PIXEL* SourcePixel; SourcePixel = reinterpret_cast<BLP_PIXEL*>(&Buffer[sizeof(BLP_HEADER) + (PALETTE_SIZE * 4)]); TargetPixel = reinterpret_cast<BLP_RGBA*>(&TempBuffer[0]); for (INT i=0; i<Size; i++) { TargetPixel[i].Red = Palette[SourcePixel[i].Index].Red; TargetPixel[i].Green = Palette[SourcePixel[i].Index].Green; TargetPixel[i].Blue = Palette[SourcePixel[i].Index].Blue; TargetPixel[i].Alpha = 255 - Palette[SourcePixel[i].Index].Alpha; } break; } default: { Error.SetMessage("Unable to load \"" + CurrentFileName + "\", unknown picture type!"); return FALSE; } } return TRUE; }