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