{

Data = NULL;

DataWidth = 0;

DataHeight = 0;

PixelSize = 0;

// FileName is pre-initialised by its constructor.

CString* _FileName,

CPlatform* _PlatformRef)

{

FILE* FH;

char* TempDataBuffer;

if ( (_GraphicsObject)

&& (_FileName)

&& (_FileName->GetStringLength() > 0))

{

CString ImagePath;

if (_PlatformRef)

ImagePath = _PlatformRef->GetPath(EP_ImageData);

ImagePath += _FileName;

ImagePath += ".cbd";

// Load the data, etc.

FH = FOPEN(ImagePath.GetString(), "rb");

if (FH)

{

fread(&ImageInfo, sizeof(ImageInfo), 1, FH);

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 2;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 11) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 3;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 10) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

int R, G, B;

R = (ImageInfo.TransparentKey >> 16 ) & 0xFF;

G = (ImageInfo.TransparentKey >> 8 ) & 0xFF;

B = (ImageInfo.TransparentKey ) & 0xFF;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

R = R >> 5;

G = G >> 5;

B = B >> 6;

// Update for palettized display

ImageInfo.TransparentKey = (R << 5) + (G << 2) + B;

}

else

{

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

ImageInfo.TransparentKey = _GraphicsObject->Match8BitPalette(InColour);//GetNearestPaletteIndex(_GraphicsObject->GetPalette(), InColour);

}

}

// Read header

TGAHeader header;

fread(&header, sizeof(header), 1, FH);

// Store width and height info

DataWidth = header.mSizeX;

DataHeight = header.mSizeY;

int TotalCount;

fread(&TotalCount, sizeof(TotalCount), 1, FH);

// Read data into buffer, before processing.

TempDataBuffer = new char[TotalCount * 4];

if (TempDataBuffer)

{

fread(TempDataBuffer, TotalCount * 4, 1, FH);

fclose(FH);

Data = NULL;

switch (_GraphicsObject->GetDisplay()->cBPP)

{

case 8:

Data = new char[DataWidth * DataHeight * 1];

PixelSize = 1;

break;

case 16:

Data = new char[DataWidth * DataHeight * 2];

PixelSize = 2;

break;

case 24:

case 32:

Data = new char[DataWidth * DataHeight * 4]; // The data is stored in the format xRGB, reguardless of whether the screen is 24 or 32 bit.

PixelSize = 4;

break;

default:

Data = NULL;

PixelSize = 0;

return false;

}

if (Data)

{

// Right, got source and destination buffers.

// Time to process data.

char* Source = TempDataBuffer;

//Source += (DataHeight - 1) * DataWidth * 3;

char* Dest = Data;

unsigned char R, G, B;

unsigned char Count;

EMachine MType;

int ReadIn = 0;

if (_GraphicsObject->GetPlatform())

MType = _GraphicsObject->GetPlatform()->GetMachineType();

else

return false;

for (int Index = TotalCount; Index--;)

{

// Read pixel.

Count = *Source; Source++;

R = *Source; Source++;

G = *Source; Source++;

B = *Source; Source++;

ReadIn += Count;

int Loop;

// Process pixels.

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

R = (R >> 3);

G = (G >> 3);

B = (B >> 3);

WORD Value = (R << 10) + (G << 5) + B;

for (Loop = Count; Loop--;)

{

*(WORD*)Dest = Value;

Dest += sizeof(WORD);

}

}

else if(_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

// 565 is in the format RRRRRxGGGGGBBBBB - (This

// information was not provided with the

// documentation, but is in an article on Microsoft's

// website). - Unless, of course, you don't stick

// to that format and use another one, such as

// Casio. They use RRRRRGGGGGGBBBBB. (Which is what

// you would expect, but counter to what Microsoft

// say on their website. God know which is correct.

R = (R >> 3);

G = (G >> 2); // Don't really care about the lowest bit too much.

B = (B >> 3);

WORD Value = (R << 11) + (G << 5) + B;

for (Loop = Count; Loop--;)

{

*(WORD*)Dest = Value;

Dest += sizeof(WORD);

}

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect888)

{

DWORD Value = (R << 16) + (G << 8) + B;

for (Loop = Count; Loop--;)

{

*(DWORD*)Dest = Value;

Dest += sizeof(DWORD);

}

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

// Direct 8 bit mode.

R = (R >> 5);

G = (G >> 5);

B = (B >> 6);

unsigned char Value = (R << 5) + (G << 2) + B;

for (Loop = Count; Loop--;)

{

*Dest = Value;

Dest++;

}

}

else

{

// Palettized 8 bit mode.

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

UINT mapcol = _GraphicsObject->Match8BitPalette(InColour);

//if (mapcol != CLR_INVALID)

{

for (Loop = Count; Loop--;)

{

*(unsigned char*)Dest = mapcol;

Dest++;

}

}

/*else

}

}

else

{

// This display mode is currently not supported.

return false;

}

}

SAFELY_DELETE_ARRAY(TempDataBuffer);

ErrorCode = OBJECT_NO_ERROR;

ASSERT(ReadIn == (DataWidth * DataHeight));

return true;

}

SAFELY_DELETE_ARRAY(TempDataBuffer);

}

else

{

fclose(FH);

}

}

else

{

ODS("Failed to load image: ");

ODCSN((&ImagePath));

}

}

ErrorCode = GetLastError();

return false;

FILE* _FH,

int _DataLength,

int _ImageWidth,

bool _DataHasMask)

{

char* TempBuffer;

char* Index;

LONGLONG Plane[4];

int i, j;

unsigned char R, G, B;

char* Dest;

int StripSize;

int StripWidth;

if (_DataHasMask)

StripWidth = 5;

else

StripWidth = 4;

// These comments only apply to 32 pixel wide images

// File format looks like this... (as far as i can see...).

// Long block of data.

// 4 bytes for mask (4 * 8 = 32 - 32 pixels).

// 4 bytes for plane0

// 4 bytes for plane1

// 4 bytes for plane2

// 4 bytes for plane3

// Repeat until data runs out. (i.e. _DataLength -= (5 * 4);)

SAFELY_DELETE_ARRAY(Data);

if ( (_GraphicsObject)

&& (_FH)

&& ( (_ImageWidth == 64)

|| (_ImageWidth == 32)

|| (_ImageWidth == 16)

|| (_ImageWidth == 8))

)

{

// StripSize is the number of bytes per plane,

// per horizontal line of the sprite.

StripSize = (_ImageWidth >> 3);

TempBuffer = new char[_DataLength];

if (!TempBuffer)

return false;

DataWidth = _ImageWidth;

DataHeight = _DataLength / (StripSize * StripWidth);

// Create end buffer.

Data = NULL;

switch (_GraphicsObject->GetDisplay()->cBPP)

{

case 8:

Data = new char[DataWidth * DataHeight * 1];

PixelSize = 1;

break;

case 16:

Data = new char[DataWidth * DataHeight * 2];

PixelSize = 2;

break;

case 24:

case 32:

Data = new char[DataWidth * DataHeight * 4]; // The data is stored in the format xRGB, reguardless of whether the screen is 24 or 32 bit.

PixelSize = 4;

ImageInfo.TransparentKey = (0xFF << 16) + 0xFF; // Magenta

break;

default:

Data = NULL;

PixelSize = 0;

return false;

}

// Hmmm, this file format uses masks, which doesn't

// fit my way of doing things - could change the

// graphics data on loading (i.e. convert the mask

// bit to a mask colour...) (This is not implemented).

// Magenta (or colours very close to it) are always

// going to be transparent

ImageInfo.TransparentKey = MASK_COLOUR;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 2;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 11) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 3;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 10) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

int R, G, B;

R = (ImageInfo.TransparentKey >> 16 ) & 0xFF;

G = (ImageInfo.TransparentKey >> 8 ) & 0xFF;

B = (ImageInfo.TransparentKey ) & 0xFF;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

R = R >> 5;

G = G >> 5;

B = B >> 6;

// Update for palettized display

ImageInfo.TransparentKey = (R << 5) + (G << 2) + B;

}

else

{

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

ImageInfo.TransparentKey = _GraphicsObject->Match8BitPalette(InColour);//GetNearestPaletteIndex(_GraphicsObject->GetPalette(), InColour);

}

}

if (!Data)

return false;

// Load the data, etc.

if (fread(TempBuffer, _DataLength, 1, _FH) != 1)

return false;

// ----

Dest = Data;

Index = TempBuffer;

while (_DataLength >= (StripSize * StripWidth))

{

LONGLONG Mask = 0;

if (_DataHasMask)

{

for (i = 0; i < StripSize; i++)

{

Mask = (Mask << 8) | *(unsigned char*)Index;

Index++;

}

}

for (i = 0; i < 4; i++) // Data is in 4 planes

{

Plane[i] = 0;

for (j = 0; j < StripSize; j++) // Count across the image width.

{

Plane[i] = ((Plane[i] << 8) | (*(unsigned char*)Index));

Index++;

}

}

// We now have 32 pixels worth of data, in four planes (16 bit colour).

// Need to map from plane colour to direct mode colour.

// Now loop through extracting / mapping plane info.

for (i = _ImageWidth; i--;)

{

bool MaskBit = (Mask >> i) & 0x01;

DWORD Colour;

if (!MaskBit)

{

int PaletteIndex = ( (((Plane[3] >> i) & 0x01) << 3)

| (((Plane[2] >> i) & 0x01) << 2)

| (((Plane[1] >> i) & 0x01) << 1)

| (((Plane[0] >> i) & 0x01) << 0)

);

// Now map the PaletteIndex to a colour, via the palette.

Colour = _GraphicsObject->PopulousToPal(PaletteIndex);

}

else

Colour = MASK_COLOUR; // Mask by colour.

// Read pixel.

R = (Colour >> 16) & 0xFF;

G = (Colour >> 8) & 0xFF;

B = Colour & 0xFF;

// Process pixels.

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

R = (R >> 3);

G = (G >> 3);

B = (B >> 3);

WORD Value = (R << 10) + (G << 5) + B;

*(WORD*)Dest = Value;

Dest += sizeof(WORD);

}

else if(_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

R = (R >> 3);

G = (G >> 3);

B = (B >> 3);

WORD Value = (R << 11) + (G << 6) + B;

*(WORD*)Dest = Value;

Dest += sizeof(WORD);

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect888)

{

DWORD Value = (R << 16) + (G << 8) + B;

*(DWORD*)Dest = Value;

Dest += sizeof(DWORD);

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

// Direct 8 bit mode.

R = (R >> 5);

G = (G >> 5);

B = (B >> 6);

unsigned char Value = (R << 5) + (G << 2) + B;

*Dest = Value;

Dest++;

}

else

{

// Palettized 8 bit mode.

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

UINT mapcol = _GraphicsObject->Match8BitPalette(InColour);

//if (mapcol != CLR_INVALID)

{

*(unsigned char*)Dest = mapcol;

Dest++;

}

}

}

else

{

// This display mode is currently not supported.

return false;

}

}

// Increment / decrement counters

//DataHeight++;

_DataLength -= (StripSize * StripWidth);

}

return true;

}

return false;

FILE* _FH,

int _DataLength)

{

char* TempBuffer;

char* Index;

LONGLONG Plane[4];

int i, j;

unsigned char R, G, B;

char* Dest;

int StripSize;

int StripWidth;

StripWidth = 5;

int ImageWidth = 32;

SAFELY_DELETE_ARRAY(Data);

if ( (_GraphicsObject)

&& (_FH))

{

// StripSize is the number of bytes per plane,

// per horizontal line of the sprite.

StripSize = (ImageWidth >> 4);

TempBuffer = new char[_DataLength];

if (!TempBuffer)

return false;

DataWidth = ImageWidth;

DataHeight = _DataLength / (StripSize * StripWidth);

// Create end buffer.

Data = NULL;

switch (_GraphicsObject->GetDisplay()->cBPP)

{

case 8:

Data = new char[DataWidth * DataHeight * 1];

PixelSize = 1;

break;

case 16:

Data = new char[DataWidth * DataHeight * 2];

PixelSize = 2;

break;

case 24:

case 32:

Data = new char[DataWidth * DataHeight * 4]; // The data is stored in the format xRGB, reguardless of whether the screen is 24 or 32 bit.

PixelSize = 4;

ImageInfo.TransparentKey = (0xFF << 16) + 0xFF; // Magenta

break;

default:

Data = NULL;

PixelSize = 0;

return false;

}

// Hmmm, this file format uses masks, which doesn't

// fit my way of doing things - could change the

// graphics data on loading (i.e. convert the mask

// bit to a mask colour...) (This is not implemented).

// Magenta (or colours very close to it) are always

// going to be transparent

ImageInfo.TransparentKey = MASK_COLOUR;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 2;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 11) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 3;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 10) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

int R, G, B;

R = (ImageInfo.TransparentKey >> 16 ) & 0xFF;

G = (ImageInfo.TransparentKey >> 8 ) & 0xFF;

B = (ImageInfo.TransparentKey ) & 0xFF;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

R = R >> 5;

G = G >> 5;

B = B >> 6;

// Update for palettized display

ImageInfo.TransparentKey = (R << 5) + (G << 2) + B;

}

else

{

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

ImageInfo.TransparentKey = _GraphicsObject->Match8BitPalette(InColour);//GetNearestPaletteIndex(_GraphicsObject->GetPalette(), InColour);

}

}

if (!Data)

return false;

// Load the data, etc.

if (fread(TempBuffer, _DataLength, 1, _FH) != 1)

return false;

// ----

Dest = Data;

Index = TempBuffer;

while (_DataLength >= ((StripSize * StripWidth)))

{

// ODS("Processing Sprite32 chuck at offset ");

// ODIN((int)(Index - TempBuffer));

// Sleep(1);

LONGLONG Mask = 0;

for (i = 0; i < StripSize; i++)

{

Mask = (Mask << 8) | *(unsigned char*)Index;

Index++;

}

/*

// We now have 32 pixels worth of data, in four planes (16 bit colour).

// Need to map from plane colour to direct mode colour.

// Now loop through extracting / mapping plane info.

for (i = ImageWidth >> 1; i--;)

{

bool MaskBit = (Mask >> i) & 0x01;

DWORD Colour;

if ((i > 0) && !((i + 1) % 8))

{

for (j = 0; j < 4; j++)

{

Plane[j] = (*(unsigned char*)Index);

Index++;

}

}

/*

if (!MaskBit)

{

int pia = (i % 8);

int piaa[4];

piaa[0] = Plane[0] >> pia;

piaa[1] = Plane[1] >> pia;

piaa[2] = Plane[2] >> pia;

piaa[3] = Plane[3] >> pia;

int PaletteIndex = ( ((piaa[3] & 0x01) << 3)

| ((piaa[2] & 0x01) << 2)

| ((piaa[1] & 0x01) << 1)

| ((piaa[0] & 0x01) << 0)

) /*Plane[0] & 0x0F*/;

// Now map the PaletteIndex to a colour, via the palette.

Colour = _GraphicsObject->PopulousToPal(PaletteIndex);

}

else

Colour = MASK_COLOUR; // Mask by colour.

// Read pixel.

R = (Colour >> 16) & 0xFF;

G = (Colour >> 8) & 0xFF;

B = Colour & 0xFF;

// Process pixels.

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

R = (R >> 3);

G = (G >> 3);

B = (B >> 3);

WORD Value = (R << 10) + (G << 5) + B;

*(WORD*)Dest = Value;

Dest += sizeof(WORD);

}

else if(_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

R = (R >> 3);

G = (G >> 3);

B = (B >> 3);

WORD Value = (R << 11) + (G << 6) + B;

*(WORD*)Dest = Value;

Dest += sizeof(WORD);

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect888)

{

DWORD Value = (R << 16) + (G << 8) + B;

*(DWORD*)Dest = Value;

Dest += sizeof(DWORD);

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

// Direct 8 bit mode.

R = (R >> 5);

G = (G >> 5);

B = (B >> 6);

unsigned char Value = (R << 5) + (G << 2) + B;

*Dest = Value;

Dest++;

}

else

{

// Palettized 8 bit mode.

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

UINT mapcol = _GraphicsObject->Match8BitPalette(InColour);

//if (mapcol != CLR_INVALID)

{

*(unsigned char*)Dest = mapcol;

Dest++;

}

}

}

else

{

// This display mode is currently not supported.

return false;

}

}

// Increment / decrement counters

//DataHeight++;

_DataLength -= (StripSize * StripWidth);

}

return true;

}

return false;

FILE* _FH,

int _DataLength,

int _ImageWidth,

int _ColourDepth)

{

char* TempBuffer;

char* Index;

int i;

unsigned char R, G, B;

char* Dest;

int DataRemaining;

// These comments only apply to 32 pixel wide images

// File format looks like this... (as far as i can see...).

// Long block of data.

// 4 bytes for plane0

// 4 bytes for plane1

// 4 bytes for plane2

// 4 bytes for plane3

// Repeat until data runs out. (i.e. _DataLength -= (4 * 4);)

SAFELY_DELETE_ARRAY(Data);

if ( (_ColourDepth != 16)

&& (_ColourDepth != 256))

return false;

if ( (_GraphicsObject)

&& (_FH))

{

DataWidth = _ImageWidth;

DataHeight = (_DataLength / _ImageWidth) * 2;

DataRemaining = _DataLength;

TempBuffer = new char[DataRemaining];

if (!TempBuffer)

return false;

// Create end buffer.

Data = NULL;

switch (_GraphicsObject->GetDisplay()->cBPP)

{

case 8:

Data = new char[DataWidth * DataHeight * 1];

PixelSize = 1;

break;

case 16:

Data = new char[DataWidth * DataHeight * 2];

PixelSize = 2;

break;

case 24:

case 32:

Data = new char[DataWidth * DataHeight * 4]; // The data is stored in the format xRGB, reguardless of whether the screen is 24 or 32 bit.

PixelSize = 4;

break;

default:

Data = NULL;

PixelSize = 0;

return false;

}

if (!Data)

return false;

// Load the data, etc.

if (fread(TempBuffer, DataRemaining, 1, _FH) != 1)

return false;

ImageInfo.TransparentKey = MASK_COLOUR;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect565)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 2;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 11) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

int R, G, B;

R = ((ImageInfo.TransparentKey >> 16) & 0xFF) >> 3;

G = ((ImageInfo.TransparentKey >> 8 ) & 0xFF) >> 3;

B = ((ImageInfo.TransparentKey ) & 0xFF) >> 3;

ImageInfo.TransparentKey = (R << 10) + (G << 5) + B;

}

else if (_GraphicsObject->GetDisplay()->cBPP == 8)

{

int R, G, B;

R = (ImageInfo.TransparentKey >> 16 ) & 0xFF;

G = (ImageInfo.TransparentKey >> 8 ) & 0xFF;

B = (ImageInfo.TransparentKey ) & 0xFF;

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect)

{

R = R >> 5;

G = G >> 5;

B = B >> 6;

// Update for palettized display

ImageInfo.TransparentKey = (R << 5) + (G << 2) + B;

}

else

{

COLORREF InColour;

InColour = (B << 16) + (G << 8) + R;

// Making the assumption that the palette is a maximum of 256 entries!!!

ImageInfo.TransparentKey = _GraphicsObject->Match8BitPalette(InColour);//GetNearestPaletteIndex(_GraphicsObject->GetPalette(), InColour);

}

}

// ----

Dest = Data;

Index = TempBuffer;

int iii;

iii = 1 + ((_ColourDepth == 16)?1:0);

while (DataRemaining >= 1)

{

unsigned char TwoPixelColour = *(unsigned char*)Index;

Index++;

for (i = iii; i--;)

{

int PaletteIndex;

if (_ColourDepth == 16)

{

if (i)

PaletteIndex = TwoPixelColour & 0x0F;

else

PaletteIndex = (TwoPixelColour & 0xF0) >> 4;

}

else

{

PaletteIndex = (TwoPixelColour & 0x0F);// - ((TwoPixelColour & 0xF0) >> 4);

}

// Now map the PaletteIndex to a colour, via the palette.

DWORD Colour = _GraphicsObject->PopulousToPal(PaletteIndex);

// Read pixel.

R = (Colour >> 16) & 0xFF;

G = (Colour >> 8) & 0xFF;

B = Colour & 0xFF;

// Process pixels.

if (_GraphicsObject->GetDisplay()->ffFormat & kfDirect555)

{

R = (R >> 3);