mirror of
https://github.com/isledecomp/isle-portable.git
synced 2024-11-27 01:45:37 -05:00
377 lines
9 KiB
C++
377 lines
9 KiB
C++
#include "mxbitmap.h"
|
|
#include "decomp.h"
|
|
|
|
DECOMP_SIZE_ASSERT(MxBitmap, 0x20);
|
|
DECOMP_SIZE_ASSERT(MxBITMAPINFO, 0x428);
|
|
|
|
// Bitmap header magic string "BM" (42 4d)
|
|
// Sources: https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapfileheader, DirectX Complete (1998)
|
|
// GLOBAL: LEGO1 0x10102184
|
|
MxU16 g_bitmapSignature = TWOCC('B', 'M');
|
|
|
|
// OFFSET: LEGO1 0x100bc980
|
|
MxBitmap::MxBitmap()
|
|
{
|
|
this->m_info = NULL;
|
|
this->m_bmiHeader = NULL;
|
|
this->m_paletteData = NULL;
|
|
this->m_data = NULL;
|
|
this->m_isHighColor = FALSE;
|
|
this->m_palette = NULL;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bca10
|
|
MxBitmap::~MxBitmap()
|
|
{
|
|
if (this->m_info)
|
|
delete m_info;
|
|
if (this->m_data)
|
|
delete m_data;
|
|
if (this->m_palette)
|
|
delete m_palette;
|
|
}
|
|
|
|
// Bit mask trick to round up to the nearest multiple of four.
|
|
// Pixel data may be stored with padding.
|
|
// https://learn.microsoft.com/en-us/windows/win32/medfound/image-stride
|
|
inline MxLong AlignToFourByte(MxLong p_value)
|
|
{
|
|
return (p_value + 3) & -4;
|
|
}
|
|
|
|
// Same as the one from legoutil.h, but flipped the other way
|
|
// TODO: While it's not outside the realm of possibility that they
|
|
// reimplemented Abs for only this file, that seems odd, right?
|
|
inline MxLong _Abs(MxLong p_value)
|
|
{
|
|
return p_value > 0 ? p_value : -p_value;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bcc40
|
|
MxResult MxBitmap::ImportBitmap(MxBitmap *p_bitmap)
|
|
{
|
|
MxResult result = FAILURE;
|
|
|
|
this->m_info = new MxBITMAPINFO;
|
|
if(this->m_info) {
|
|
MxLong height = _Abs(p_bitmap->m_bmiHeader->biHeight);
|
|
this->m_data = new MxU8[AlignToFourByte(p_bitmap->m_bmiHeader->biWidth) * height];
|
|
if(this->m_data) {
|
|
memcpy(this->m_info, p_bitmap->m_info, sizeof(*this->m_info));
|
|
height = _Abs(p_bitmap->m_bmiHeader->biHeight);
|
|
memcpy(this->m_data, p_bitmap->m_data, AlignToFourByte(p_bitmap->m_bmiHeader->biWidth) * height);
|
|
|
|
result = SUCCESS;
|
|
this->m_bmiHeader = &this->m_info->bmiHeader;
|
|
this->m_paletteData = this->m_info->bmiColors;
|
|
}
|
|
}
|
|
|
|
if (result != SUCCESS) {
|
|
if (this->m_info) {
|
|
delete this->m_info;
|
|
this->m_info = NULL;
|
|
}
|
|
|
|
if (this->m_data) {
|
|
delete this->m_data;
|
|
this->m_data = NULL;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bcba0
|
|
MxResult MxBitmap::ImportBitmapInfo(MxBITMAPINFO *p_info)
|
|
{
|
|
MxResult result = FAILURE;
|
|
MxLong width = p_info->bmiHeader.biWidth;
|
|
MxLong height = p_info->bmiHeader.biHeight;
|
|
MxLong size = AlignToFourByte(width) * height;
|
|
|
|
this->m_info = new MxBITMAPINFO;
|
|
if (this->m_info) {
|
|
this->m_data = new MxU8[size];
|
|
if(this->m_data) {
|
|
memcpy(this->m_info, p_info, sizeof(*this->m_info));
|
|
this->m_bmiHeader = &this->m_info->bmiHeader;
|
|
this->m_paletteData = this->m_info->bmiColors;
|
|
result = SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (result != SUCCESS) {
|
|
if (this->m_info) {
|
|
delete this->m_info;
|
|
this->m_info = NULL;
|
|
}
|
|
|
|
if (this->m_data) {
|
|
delete this->m_data;
|
|
this->m_data = NULL;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// OFFSET: LEGO1 0x100bd450
|
|
MxResult MxBitmap::ImportColorsToPalette(RGBQUAD* p_rgbquad, MxPalette* p_palette)
|
|
{
|
|
MxResult ret = FAILURE;
|
|
PALETTEENTRY entries[256];
|
|
|
|
if (p_palette) {
|
|
if (p_palette->GetEntries(entries))
|
|
return ret;
|
|
} else {
|
|
MxPalette local_pal;
|
|
if (local_pal.GetEntries(entries))
|
|
return ret;
|
|
}
|
|
|
|
for (MxS32 i = 0; i < 256; i++) {
|
|
p_rgbquad[i].rgbRed = entries[i].peRed;
|
|
p_rgbquad[i].rgbGreen = entries[i].peGreen;
|
|
p_rgbquad[i].rgbBlue = entries[i].peBlue;
|
|
p_rgbquad[i].rgbReserved = 0;
|
|
}
|
|
|
|
ret = SUCCESS;
|
|
return ret;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bcaa0
|
|
MxResult MxBitmap::SetSize(MxS32 p_width, MxS32 p_height, MxPalette *p_palette, MxBool p_isHighColor)
|
|
{
|
|
MxResult ret = FAILURE;
|
|
MxLong size = AlignToFourByte(p_width) * p_height;
|
|
|
|
m_info = new MxBITMAPINFO;
|
|
if (m_info) {
|
|
m_data = new MxU8[size];
|
|
if (m_data) {
|
|
m_bmiHeader = &m_info->bmiHeader;
|
|
m_paletteData = m_info->bmiColors;
|
|
memset(&m_info->bmiHeader, 0, sizeof(m_info->bmiHeader));
|
|
|
|
m_bmiHeader->biSize = sizeof(*m_bmiHeader); // should be 40 bytes
|
|
m_bmiHeader->biWidth = p_width;
|
|
m_bmiHeader->biHeight = p_height;
|
|
m_bmiHeader->biPlanes = 1;
|
|
m_bmiHeader->biBitCount = 8;
|
|
m_bmiHeader->biCompression = 0;
|
|
m_bmiHeader->biSizeImage = size;
|
|
|
|
if (!ImportColorsToPalette(m_paletteData, p_palette)) {
|
|
if (!SetBitDepth(p_isHighColor)) {
|
|
ret = SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret) {
|
|
if (m_info) {
|
|
delete m_info;
|
|
m_info = NULL;
|
|
}
|
|
|
|
if (m_data) {
|
|
delete[] m_data;
|
|
m_data = NULL;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bcd60
|
|
MxResult MxBitmap::LoadFile(HANDLE p_handle)
|
|
{
|
|
MxResult result = FAILURE;
|
|
DWORD bytesRead;
|
|
BITMAPFILEHEADER hdr;
|
|
|
|
BOOL ret = ReadFile(p_handle, &hdr, sizeof(hdr), &bytesRead, NULL);
|
|
if (ret && (hdr.bfType == g_bitmapSignature)) {
|
|
this->m_info = new MxBITMAPINFO;
|
|
if (this->m_info) {
|
|
ret = ReadFile(p_handle, this->m_info, sizeof(*this->m_info), &bytesRead, NULL);
|
|
if (ret && (this->m_info->bmiHeader.biBitCount == 8)) {
|
|
MxLong size = hdr.bfSize - (sizeof(MxBITMAPINFO) + sizeof(BITMAPFILEHEADER));
|
|
this->m_data = new MxU8[size];
|
|
if (this->m_data) {
|
|
ret = ReadFile(p_handle, this->m_data, size, &bytesRead, NULL);
|
|
if (ret) {
|
|
this->m_bmiHeader = &this->m_info->bmiHeader;
|
|
this->m_paletteData = this->m_info->bmiColors;
|
|
if (this->m_info->bmiHeader.biSizeImage == 0) {
|
|
MxLong height = _Abs(this->m_info->bmiHeader.biHeight);
|
|
this->m_info->bmiHeader.biSizeImage = AlignToFourByte(this->m_info->bmiHeader.biWidth) * height;
|
|
}
|
|
result = SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result != SUCCESS) {
|
|
if (this->m_info) {
|
|
delete this->m_info;
|
|
this->m_info = NULL;
|
|
}
|
|
|
|
if (this->m_data) {
|
|
delete this->m_data;
|
|
this->m_data = NULL;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bcd10
|
|
MxLong MxBitmap::Read(const char *p_filename)
|
|
{
|
|
MxResult result = FAILURE;
|
|
HANDLE handle = CreateFileA(
|
|
p_filename,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if (handle != INVALID_HANDLE_VALUE && !LoadFile(handle))
|
|
result = SUCCESS;
|
|
|
|
if (handle)
|
|
CloseHandle(handle);
|
|
|
|
return result;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x1004e0d0
|
|
int MxBitmap::vtable28(int)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bce70 STUB
|
|
void MxBitmap::vtable2c(int, int, int, int, int, int, int)
|
|
{
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bd020 STUB
|
|
void MxBitmap::vtable30(int, int, int, int, int, int, int)
|
|
{
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bd1c0
|
|
MxPalette *MxBitmap::CreatePalette()
|
|
{
|
|
MxBool success = FALSE;
|
|
MxPalette *palette = NULL;
|
|
|
|
switch (this->m_isHighColor) {
|
|
case FALSE:
|
|
palette = new MxPalette(this->m_paletteData);
|
|
if (palette)
|
|
success = TRUE;
|
|
break;
|
|
|
|
case TRUE:
|
|
palette = this->m_palette->Clone();
|
|
if (palette)
|
|
success = TRUE;
|
|
break;
|
|
}
|
|
|
|
if (!success && palette) {
|
|
delete palette;
|
|
palette = NULL;
|
|
}
|
|
|
|
return palette;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bd280
|
|
void MxBitmap::ImportPalette(MxPalette* p_palette)
|
|
{
|
|
// Odd to use a switch on a boolean, but it matches.
|
|
switch (this->m_isHighColor) {
|
|
case FALSE:
|
|
ImportColorsToPalette(this->m_paletteData, p_palette);
|
|
break;
|
|
|
|
case TRUE:
|
|
if (this->m_palette) {
|
|
delete this->m_palette;
|
|
}
|
|
this->m_palette = p_palette->Clone();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bd2d0
|
|
MxResult MxBitmap::SetBitDepth(MxBool p_isHighColor)
|
|
{
|
|
MxResult ret = FAILURE;
|
|
MxPalette *pal = NULL;
|
|
|
|
if (m_isHighColor == p_isHighColor) {
|
|
// no change: do nothing.
|
|
ret = SUCCESS;
|
|
} else {
|
|
switch (p_isHighColor) {
|
|
case FALSE:
|
|
ImportColorsToPalette(m_paletteData, m_palette);
|
|
if (m_palette)
|
|
delete m_palette;
|
|
|
|
m_palette = NULL;
|
|
break;
|
|
|
|
case TRUE:
|
|
pal = NULL;
|
|
pal = new MxPalette(m_paletteData);
|
|
if (pal) {
|
|
m_palette = pal;
|
|
|
|
// TODO: what is this? zeroing out top half of palette?
|
|
MxU16 *buf = (MxU16*)m_paletteData;
|
|
for (MxU16 i = 0; i < 256; i++) {
|
|
buf[i] = i;
|
|
}
|
|
|
|
m_isHighColor = p_isHighColor;
|
|
ret = SUCCESS;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we were unsuccessful overall but did manage to alloc
|
|
// the MxPalette, free it.
|
|
if (ret && pal)
|
|
delete pal;
|
|
|
|
return ret;
|
|
}
|
|
|
|
// OFFSET: LEGO1 0x100bd3e0
|
|
MxResult MxBitmap::StretchBits(HDC p_hdc, MxS32 p_xSrc, MxS32 p_ySrc, MxS32 p_xDest, MxS32 p_yDest, MxS32 p_destWidth, MxS32 p_destHeight)
|
|
{
|
|
// Compression fix?
|
|
if ((this->m_bmiHeader->biCompression != 16) && (0 < this->m_bmiHeader->biHeight)) {
|
|
p_ySrc = (this->m_bmiHeader->biHeight - p_destHeight) - p_ySrc;
|
|
}
|
|
|
|
return StretchDIBits(p_hdc, p_xDest, p_yDest, p_destWidth, p_destHeight, p_xSrc, p_ySrc, p_destWidth, p_destHeight, this->m_data, (BITMAPINFO*)this->m_info, this->m_isHighColor, SRCCOPY);
|
|
}
|