libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-20 08:48:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a850eabf07
scummvm/engines/tony/gfxcore.cpp
Strangerke 94d3c8ebb2 TONY: Some more code formatting
2012-05-21 23:54:32 +02:00

1961 lines
39 KiB
C++
Raw Blame History

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
/*
* This code is based on original Tony Tough source code
*
* Copyright (c) 1997-2003 Nayma Software
*/
#include "tony/gfxengine.h"
#include "tony/mpal/mpalutils.h"
#include "tony/tony.h"
namespace Tony {
/****************************************************************************\
* RMGfxTask Methods
\****************************************************************************/
RMGfxTask::RMGfxTask() {
m_nPrior = 0;
m_nInList = 0;
}
int RMGfxTask::Priority() {
return m_nPrior;
}
void RMGfxTask::RemoveThis(CORO_PARAM, bool &result) {
result = true;
}
/****************************************************************************\
* RMGfxTaskSetPrior Methods
\****************************************************************************/
void RMGfxTaskSetPrior::SetPriority(int nPrior) {
m_nPrior = nPrior;
}
/****************************************************************************\
* RMGfxBuffer Methods
\****************************************************************************/
RMGfxBuffer::RMGfxBuffer() {
m_dimx = m_dimy = 0;
m_bUseDDraw = false;
m_origBuf = m_buf = NULL;
}
RMGfxBuffer::~RMGfxBuffer() {
Destroy();
}
void RMGfxBuffer::Create(int dimx, int dimy, int nBpp, bool bUseDDraw) {
// Destroy the buffer it is already exists
if (m_buf != NULL)
Destroy();
// Copy the parameters in the private members
m_dimx = dimx;
m_dimy = dimy;
m_bUseDDraw = bUseDDraw;
if (!m_bUseDDraw) {
// Allocate a buffer
m_origBuf = m_buf = new byte[m_dimx * m_dimy * nBpp / 8];
assert(m_buf != NULL);
Common::fill(m_origBuf, m_origBuf + m_dimx * m_dimy * nBpp / 8, 0);
}
}
void RMGfxBuffer::Destroy(void) {
if (!m_bUseDDraw) {
if (m_origBuf != NULL && m_origBuf == m_buf) {
delete[] m_origBuf;
m_origBuf = m_buf = NULL;
}
}
}
void RMGfxBuffer::Lock(void) {
if (m_bUseDDraw) {
// Manages acceleration
}
}
void RMGfxBuffer::Unlock(void) {
if (m_bUseDDraw) {
// Manages acceleration
}
}
void RMGfxBuffer::OffsetY(int nLines, int nBpp) {
m_buf += nLines * Dimx() * nBpp / 8;
}
RMGfxBuffer::operator byte *() {
return m_buf;
}
RMGfxBuffer::operator void *() {
return (void *)m_buf;
}
RMGfxBuffer::RMGfxBuffer(int dimx, int dimy, int nBpp, bool bUseDDraw) {
Create(dimx, dimy, nBpp, bUseDDraw);
}
/****************************************************************************\
* RMGfxSourceBuffer Methods
\****************************************************************************/
int RMGfxSourceBuffer::Init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
Create(dimx, dimy, Bpp());
CopyMemory(m_buf, buf, dimx * dimy * Bpp() / 8);
// Invokes the method for preparing the surface (inherited)
PrepareImage();
return dimx * dimy * Bpp() / 8;
}
void RMGfxSourceBuffer::Init(RMDataStream &ds, int dimx, int dimy, bool bLoadPalette) {
Create(dimx, dimy, Bpp());
ds.Read(m_buf, dimx * dimy * Bpp() / 8);
// Invokes the method for preparing the surface (inherited)
PrepareImage();
}
RMGfxSourceBuffer::~RMGfxSourceBuffer() {
}
void RMGfxSourceBuffer::PrepareImage(void) {
// Do nothing. Can be overloaded if necessary
}
bool RMGfxSourceBuffer::Clip2D(int &x1, int &y1, int &u, int &v, int &width, int &height, bool bUseSrc, RMGfxTargetBuffer *buf) {
int destw, desth;
destw = buf->Dimx();
desth = buf->Dimy();
if (!bUseSrc) {
u = v = 0;
width = m_dimx;
height = m_dimy;
}
if (x1 > destw - 1)
return false;
if (y1 > desth - 1)
return false;
if (x1 < 0) {
width += x1;
if (width < 0)
return false;
u -= x1;
x1 = 0;
}
if (y1 < 0) {
height += y1;
if (height < 0)
return false;
v -= y1;
y1 = 0;
}
if (x1 + width - 1 > destw - 1)
width = destw - x1;
if (y1 + height - 1 > desth - 1)
height = desth - y1;
return true;
}
/**
* Initialises a surface by resource Id
*
* @param resID Resource ID
* @param dimx Buffer X dimension
* @param dimy Buffer Y dimension
*/
int RMGfxSourceBuffer::Init(uint32 resID, int dimx, int dimy, bool bLoadPalette) {
return Init(RMRes(resID), dimx, dimy, bLoadPalette);
}
/****************************************************************************\
* RMGfxWoodyBuffer Methods
\****************************************************************************/
RMGfxWoodyBuffer::~RMGfxWoodyBuffer() {
}
void RMGfxWoodyBuffer::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
CORO_BEGIN_CONTEXT;
CORO_END_CONTEXT(_ctx);
CORO_BEGIN_CODE(_ctx);
// Draw the OT list
CORO_INVOKE_0(DrawOT);
// Draw itself into the target buffer
CORO_INVOKE_2(RMGfxSourceBuffer16::Draw, bigBuf, prim);
CORO_END_CODE;
}
RMGfxWoodyBuffer::RMGfxWoodyBuffer() {
}
RMGfxWoodyBuffer::RMGfxWoodyBuffer(int dimx, int dimy, bool bUseDDraw)
: RMGfxBuffer(dimx, dimy, 16, bUseDDraw) {
}
/****************************************************************************\
* RMGfxTargetBuffer Methods
\****************************************************************************/
RMGfxClearTask RMGfxTargetBuffer::taskClear;
RMGfxTargetBuffer::RMGfxTargetBuffer() {
otlist = NULL;
m_otSize = 0;
// csModifyingOT = g_system->createMutex();
}
RMGfxTargetBuffer::~RMGfxTargetBuffer() {
ClearOT();
// g_system->deleteMutex(csModifyingOT);
}
void RMGfxTargetBuffer::ClearOT(void) {
OTList *cur, *n;
// g_system->lockMutex(csModifyingOT);
cur = otlist;
while (cur != NULL) {
cur->prim->m_task->Unregister();
delete cur->prim;
n = cur->next;
delete cur;
cur = n;
}
otlist = NULL;
// g_system->unlockMutex(csModifyingOT);
}
void RMGfxTargetBuffer::DrawOT(CORO_PARAM) {
CORO_BEGIN_CONTEXT;
OTList *cur;
OTList *prev;
OTList *next;
RMGfxPrimitive *myprim;
bool result;
CORO_END_CONTEXT(_ctx);
CORO_BEGIN_CODE(_ctx);
_ctx->prev = NULL;
_ctx->cur = otlist;
// Lock the buffer to access it
Lock();
// g_system->lockMutex(csModifyingOT);
while (_ctx->cur != NULL) {
// Call the task Draw method, passing it a copy of the original
_ctx->myprim = _ctx->cur->prim->Duplicate();
CORO_INVOKE_2(_ctx->cur->prim->m_task->Draw, *this, _ctx->myprim);
delete _ctx->myprim;
// Check if it's time to remove the task from the OT list
CORO_INVOKE_1(_ctx->cur->prim->m_task->RemoveThis, _ctx->result);
if (_ctx->result) {
// De-register the task
_ctx->cur->prim->m_task->Unregister();
// Delete task, freeing the memory
delete _ctx->cur->prim;
_ctx->next = _ctx->cur->next;
delete _ctx->cur;
// If it was the first item, update the list head
if (_ctx->prev == NULL)
otlist = _ctx->next;
// Otherwise update the next pinter of the previous item
else
_ctx->prev->next = _ctx->next;
_ctx->cur = _ctx->next;
} else {
// Update the pointer to the previous item, and the current to the next
_ctx->prev = _ctx->cur;
_ctx->cur = _ctx->cur->next;
}
}
// g_system->unlockMutex(csModifyingOT);
//Unlock after writing
Unlock();
CORO_END_CODE;
}
void RMGfxTargetBuffer::AddPrim(RMGfxPrimitive *prim) {
int nPrior;
OTList *cur, *n;
// g_system->lockMutex(csModifyingOT);
// Warn of the OT listing
prim->m_task->Register();
// Check the priority
nPrior = prim->m_task->Priority();
n = new OTList(prim);
// Empty list
if (otlist == NULL) {
otlist = n;
otlist->next = NULL;
}
// Inclusion in the head
else if (nPrior < otlist->prim->m_task->Priority()) {
n->next = otlist;
otlist = n;
} else {
cur = otlist;
while (cur->next != NULL && nPrior > cur->next->prim->m_task->Priority())
cur = cur->next;
n->next = cur->next;
cur->next = n;
}
// g_system->unlockMutex(csModifyingOT);
}
void RMGfxTargetBuffer::AddClearTask(void) {
AddPrim(new RMGfxPrimitive(&taskClear));
}
/****************************************************************************\
* RMGfxSourceBufferPal Methods
\****************************************************************************/
RMGfxSourceBufferPal::~RMGfxSourceBufferPal() {
}
int RMGfxSourceBufferPal::LoadPaletteWA(const byte *buf, bool bSwapped) {
int i;
if (bSwapped)
for (i = 0; i < (1 << Bpp()); i++) {
m_pal[i * 3 + 0] = buf[i * 3 + 2];
m_pal[i * 3 + 1] = buf[i * 3 + 1];
m_pal[i * 3 + 2] = buf[i * 3 + 0];
}
else
CopyMemory(m_pal, buf, (1 << Bpp()) * 3);
PreparePalette();
return (1 << Bpp()) * 3;
}
int RMGfxSourceBufferPal::LoadPalette(const byte *buf) {
int i;
for (i = 0; i < 256; i++)
CopyMemory(m_pal + i * 3, buf + i * 4, 3);
PreparePalette();
return (1 << Bpp()) * 4;
}
void RMGfxSourceBufferPal::PreparePalette(void) {
int i;
for (i = 0; i < 256; i++) {
m_palFinal[i] = (((int)m_pal[i * 3 + 0] >> 3) << 10) |
(((int)m_pal[i * 3 + 1] >> 3) << 5) |
(((int)m_pal[i * 3 + 2] >> 3) << 0);
}
}
int RMGfxSourceBufferPal::Init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
int read;
// Load the RAW image
read = RMGfxSourceBuffer::Init(buf, dimx, dimy);
// Load the palette if necessary
if (bLoadPalette)
read += LoadPaletteWA(&buf[read]);
return read;
}
void RMGfxSourceBufferPal::Init(RMDataStream &ds, int dimx, int dimy, bool bLoadPalette) {
// Load the RAW image
RMGfxSourceBuffer::Init(ds, dimx, dimy);
// Load the palette if necessary
if (bLoadPalette) {
byte *suxpal = new byte[256 * 3];
ds.Read(suxpal, 256 * 3);
LoadPaletteWA(suxpal);
delete[] suxpal;
}
}
int RMGfxSourceBufferPal::LoadPalette(uint32 resID) {
return LoadPalette(RMRes(resID));
}
int RMGfxSourceBufferPal::LoadPaletteWA(uint32 resID, bool bSwapped) {
return LoadPaletteWA(RMRes(resID), bSwapped);
}
/****************************************************************************\
* RMGfxSourceBuffer4 Methods
\****************************************************************************/
void RMGfxSourceBuffer4::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
}
RMGfxSourceBuffer4::RMGfxSourceBuffer4(int dimx, int dimy, bool bUseDDraw)
: RMGfxBuffer(dimx, dimy, 4, bUseDDraw) {
SetPriority(0);
}
/**
* Returns the number of bits per pixel of the surface
*
* @returns Bit per pixel
*/
int RMGfxSourceBuffer4::Bpp() {
return 4;
}
void RMGfxSourceBuffer4::Create(int dimx, int dimy, bool bUseDDraw) {
RMGfxBuffer::Create(dimx, dimy, 4, bUseDDraw);
}
/****************************************************************************\
* RMGfxSourceBuffer8 Methods
\****************************************************************************/
RMGfxSourceBuffer8::~RMGfxSourceBuffer8() {
}
void RMGfxSourceBuffer8::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
int x, y, width, height, u, v;
int bufx = bigBuf.Dimx();
uint16 *buf = bigBuf;
byte *raw = m_buf;
// Destination buffer
RMRect dst;
if (prim->HaveDst())
dst = prim->Dst();
// Clipping
if (prim->HaveSrc()) {
u = prim->Src().x1;
v = prim->Src().y1;
width = prim->Src().Width();
height = prim->Src().Height();
}
if (!Clip2D(dst.x1, dst.y1, u, v, width, height, prim->HaveSrc(), &bigBuf))
return;
// Starting offset into the buffer
buf += dst.y1 * bufx + dst.x1;
// Normal step
if (m_bTrasp0) {
for (y = 0; y < height; y++) {
raw = m_buf + (y + v) * m_dimx + u;
for (x = 0; x < width; x++) {
if (*raw) *buf = m_palFinal[*raw];
buf++;
raw++;
}
buf += bufx - width;
}
} else {
for (y = 0; y < height; y++) {
raw = m_buf + (y + v) * m_dimx + u;
for (x = 0; x < width; x += 2) {
buf[0] = m_palFinal[raw[0]];
buf[1] = m_palFinal[raw[1]];
buf += 2;
raw += 2;
}
buf += bufx - width;
}
}
}
RMGfxSourceBuffer8::RMGfxSourceBuffer8(int dimx, int dimy, bool bUseDDraw)
: RMGfxBuffer(dimx, dimy, 8, bUseDDraw) {
SetPriority(0);
}
RMGfxSourceBuffer8::RMGfxSourceBuffer8(bool bTrasp0) {
m_bTrasp0 = bTrasp0;
}
/**
* Returns the number of bits per pixel of the surface
*
* @returns Bit per pixel
*/
int RMGfxSourceBuffer8::Bpp() {
return 8;
}
void RMGfxSourceBuffer8::Create(int dimx, int dimy, bool bUseDDraw) {
RMGfxBuffer::Create(dimx, dimy, 8, bUseDDraw);
}
#define GETRED(x) (((x) >> 10) & 0x1F)
#define GETGREEN(x) (((x) >> 5) & 0x1F)
#define GETBLUE(x) ((x) & 0x1F)
/****************************************************************************\
* RMGfxSourceBuffer8AB Methods
\****************************************************************************/
RMGfxSourceBuffer8AB::~RMGfxSourceBuffer8AB() {
}
int RMGfxSourceBuffer8AB::CalcTrasp(int fore, int back) {
int r, g, b;
r = (GETRED(fore) >> 2) + (GETRED(back) >> 1);
g = (GETGREEN(fore) >> 2) + (GETGREEN(back) >> 1);
b = (GETBLUE(fore) >> 2) + (GETBLUE(back) >> 1);
if (r > 0x1F) r = 0x1F;
if (g > 0x1F) g = 0x1F;
if (b > 0x1F) b = 0x1F;
return (r << 10) | (g << 5) | b;
}
void RMGfxSourceBuffer8AB::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
int x, y, width, height, u, v;
int bufx = bigBuf.Dimx();
uint16 *buf = bigBuf;
byte *raw = m_buf;
// Destination buffer
RMRect dst;
if (prim->HaveDst())
dst = prim->Dst();
// Clipping
if (prim->HaveSrc()) {
u = prim->Src().x1;
v = prim->Src().y1;
width = prim->Src().Width();
height = prim->Src().Height();
}
if (!Clip2D(dst.x1, dst.y1, u, v, width, height, prim->HaveSrc(), &bigBuf))
return;
// Starting offset into the buffer
buf += dst.y1 * bufx + dst.x1;
// Passaggio normale
if (m_bTrasp0) {
for (y = 0; y < height; y++) {
raw = m_buf + (y + v) * m_dimx + u;
for (x = 0; x < width; x++) {
if (*raw) *buf = CalcTrasp(m_palFinal[*raw], *buf);
buf++;
raw++;
}
buf += bufx - width;
}
} else {
for (y = 0; y < height; y++) {
raw = m_buf + (y + v) * m_dimx + u;
for (x = 0; x < width; x += 2) {
buf[0] = CalcTrasp(m_palFinal[raw[0]], buf[0]);
buf[1] = CalcTrasp(m_palFinal[raw[1]], buf[1]);
buf += 2;
raw += 2;
}
buf += bufx - width;
}
}
return;
}
/****************************************************************************\
* RMGfxSourceBuffer8RLE Methods
\****************************************************************************/
byte RMGfxSourceBuffer8RLE::MegaRLEBuf[512 * 1024];
void RMGfxSourceBuffer8RLE::SetAlphaBlendColor(int color) {
alphaBlendColor = color;
}
RMGfxSourceBuffer8RLE::RMGfxSourceBuffer8RLE() {
alphaBlendColor = -1;
bNeedRLECompress = true;
m_buf = NULL;
}
RMGfxSourceBuffer8RLE::~RMGfxSourceBuffer8RLE() {
if (m_buf != NULL) {
delete[] m_buf;
m_buf = NULL;
}
}
int RMGfxSourceBuffer8RLE::Init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
return RMGfxSourceBufferPal::Init(buf, dimx, dimy, bLoadPalette);
}
void RMGfxSourceBuffer8RLE::Init(RMDataStream &ds, int dimx, int dimy, bool bLoadPalette) {
if (bNeedRLECompress) {
RMGfxSourceBufferPal::Init(ds, dimx, dimy, bLoadPalette);
} else {
int size;
ds >> size;
m_buf = new byte[size];
ds.Read(m_buf, size);
m_dimx = dimx;
m_dimy = dimy;
}
}
void RMGfxSourceBuffer8RLE::PreparePalette(void) {
// Invoke the parent method
RMGfxSourceBuffer8::PreparePalette();
// Handle RGB alpha blending
if (alphaBlendColor != -1) {
alphaR = (m_palFinal[alphaBlendColor] >> 10) & 0x1F;
alphaG = (m_palFinal[alphaBlendColor] >> 5) & 0x1F;
alphaB = (m_palFinal[alphaBlendColor]) & 0x1F;
}
}
void RMGfxSourceBuffer8RLE::PrepareImage(void) {
// Invoke the parent method
RMGfxSourceBuffer::PrepareImage();
// Compress
CompressRLE();
}
void RMGfxSourceBuffer8RLE::SetAlreadyCompressed(void) {
bNeedRLECompress = false;
}
void RMGfxSourceBuffer8RLE::CompressRLE(void) {
int x, y;
byte *startline;
byte *cur;
byte curdata;
byte *src;
byte *startsrc;
int rep;
// Perform RLE compression for lines
cur = MegaRLEBuf;
src = m_buf;
for (y = 0; y < m_dimy; y++) {
// Save the beginning of the line
startline = cur;
// Leave space for the length of the line
cur += 2;
// It starts from the empty space
curdata = 0;
rep = 0;
startsrc = src;
for (x = 0; x < m_dimx;) {
if ((curdata == 0 && *src == 0) || (curdata == 1 && *src == alphaBlendColor)
|| (curdata == 2 && (*src != alphaBlendColor && *src != 0))) {
src++;
rep++;
x++;
} else {
if (curdata == 0) {
RLEWriteTrasp(cur, rep);
curdata++;
} else if (curdata == 1) {
RLEWriteAlphaBlend(cur, rep);
curdata++;
} else {
RLEWriteData(cur, rep, startsrc);
curdata = 0;
}
rep = 0;
startsrc = src;
}
}
// Pending data?
if (curdata == 1) {
RLEWriteAlphaBlend(cur, rep);
RLEWriteData(cur, 0, NULL);
}
if (curdata == 2) {
RLEWriteData(cur, rep, startsrc);
}
// End of line
RLEWriteEOL(cur);
// Write the length of the line
WRITE_LE_UINT16(startline, (uint16)(cur - startline));
}
// Delete the original image
delete[] m_buf;
// Copy the compressed image
x = cur - MegaRLEBuf;
m_buf = new byte[x];
Common::copy(MegaRLEBuf, MegaRLEBuf + x, m_buf);
}
void RMGfxSourceBuffer8RLE::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
int y;
byte *src;
uint16 *buf = bigBuf;
int x1, y1, u, v, width, height;
// Clipping
x1 = prim->Dst().x1;
y1 = prim->Dst().y1;
if (!Clip2D(x1, y1, u, v, width, height, false, &bigBuf))
return;
// Go forward through the RLE lines
src = m_buf;
for (y = 0; y < v; y++)
src += READ_LE_UINT16(src);
// Calculate the position in the destination buffer
buf += y1 * bigBuf.Dimx();
// Loop
if (prim->IsFlipped()) {
// Eliminate horizontal clipping
// width = m_dimx;
// x1=prim->Dst().x1;
// Clipping
u = m_dimx - (width + u);
x1 = (prim->Dst().x1 + m_dimx - 1) - u;
for (y = 0; y < height; y++) {
// Decompressione
RLEDecompressLineFlipped(buf + x1, src + 2, u, width);
// Next line
src += READ_LE_UINT16(src);
// Skip to the next line
buf += bigBuf.Dimx();
}
} else {
for (y = 0; y < height; y++) {
// Decompression
RLEDecompressLine(buf + x1, src + 2, u, width);
// Next line
src += READ_LE_UINT16(src);
// Skip to the next line
buf += bigBuf.Dimx();
}
}
}
/****************************************************************************\
* RMGfxSourceBuffer8RLEByte Methods
\****************************************************************************/
RMGfxSourceBuffer8RLEByte::~RMGfxSourceBuffer8RLEByte() {
}
void RMGfxSourceBuffer8RLEByte::RLEWriteTrasp(byte *&cur, int rep) {
assert(rep < 255);
*cur ++ = rep;
}
void RMGfxSourceBuffer8RLEByte::RLEWriteAlphaBlend(byte *&cur, int rep) {
assert(rep < 255);
*cur ++ = rep;
}
void RMGfxSourceBuffer8RLEByte::RLEWriteData(byte *&cur, int rep, byte *src) {
assert(rep < 256);
*cur ++ = rep;
if (rep > 0) {
CopyMemory(cur, src, rep);
cur += rep;
src += rep;
}
return;
}
void RMGfxSourceBuffer8RLEByte::RLEWriteEOL(byte *&cur) {
*cur ++ = 0xFF;
}
void RMGfxSourceBuffer8RLEByte::RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) {
int i, n;
int r, g, b;
if (nStartSkip == 0)
goto RLEByteDoTrasp;
while (1) {
assert(nStartSkip > 0);
// TRASP
n = *src++;
if (n == 0xFF)
return;
if (n >= nStartSkip) {
dst += n - nStartSkip;
nLength -= n - nStartSkip;
if (nLength > 0)
goto RLEByteDoAlpha;
else
return;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// ALPHA
n = *src++;
if (n >= nStartSkip) {
n -= nStartSkip;
goto RLEByteDoAlpha2;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// DATA
n = *src++;
if (n >= nStartSkip) {
src += nStartSkip;
n -= nStartSkip;
goto RLEByteDoCopy2;
}
nStartSkip -= n;
src += n;
}
while (1) {
RLEByteDoTrasp:
// Get the trasp of s**t
n = *src++;
// EOL?
if (n == 0xFF)
return;
dst += n;
nLength -= n;
if (nLength <= 0)
return;
RLEByteDoAlpha:
// Alpha
n = *src++;
RLEByteDoAlpha2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++) {
r = (*dst >> 10) & 0x1F;
g = (*dst >> 5) & 0x1F;
b = *dst & 0x1F;
r = (r >> 2) + (alphaR >> 1);
g = (g >> 2) + (alphaG >> 1);
b = (b >> 2) + (alphaB >> 1);
*dst ++ = (r << 10) | (g << 5) | b;
}
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
//RLEByteDoCopy:
// Copy the stuff
n = *src++;
RLEByteDoCopy2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++)
*dst ++ = m_palFinal[*src++];
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
}
}
void RMGfxSourceBuffer8RLEByte::RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength) {
int i, n;
int r, g, b;
if (nStartSkip == 0)
goto RLEByteFlippedDoTrasp;
while (1) {
assert(nStartSkip > 0);
// TRASP
n = *src++;
if (n == 0xFF)
return;
if (n >= nStartSkip) {
dst -= n - nStartSkip;
nLength -= n - nStartSkip;
if (nLength > 0)
goto RLEByteFlippedDoAlpha;
else
return;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// ALPHA
n = *src++;
if (n >= nStartSkip) {
n -= nStartSkip;
goto RLEByteFlippedDoAlpha2;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// DATA
n = *src++;
if (n >= nStartSkip) {
src += nStartSkip;
n -= nStartSkip;
goto RLEByteFlippedDoCopy2;
}
nStartSkip -= n;
src += n;
}
while (1) {
RLEByteFlippedDoTrasp:
// Get the trasp of s**t
n = *src++;
// EOL?
if (n == 0xFF)
return;
dst -= n;
nLength -= n;
if (nLength <= 0)
return;
RLEByteFlippedDoAlpha:
// Alpha
n = *src++;
RLEByteFlippedDoAlpha2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++) {
r = (*dst >> 10) & 0x1F;
g = (*dst >> 5) & 0x1F;
b = *dst & 0x1F;
r = (r >> 2) + (alphaR >> 1);
g = (g >> 2) + (alphaG >> 1);
b = (b >> 2) + (alphaB >> 1);
*dst-- = (r << 10) | (g << 5) | b;
}
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
//RLEByteFlippedDoCopy:
// Copy the data
n = *src++;
RLEByteFlippedDoCopy2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++)
*dst -- = m_palFinal[*src++];
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
}
}
/****************************************************************************\
* RMGfxSourceBuffer8RLEWord Methods
\****************************************************************************/
RMGfxSourceBuffer8RLEWord::~RMGfxSourceBuffer8RLEWord() {
}
void RMGfxSourceBuffer8RLEWord::RLEWriteTrasp(byte *&cur, int rep) {
WRITE_LE_UINT16(cur, rep);
cur += 2;
}
void RMGfxSourceBuffer8RLEWord::RLEWriteAlphaBlend(byte *&cur, int rep) {
WRITE_LE_UINT16(cur, rep);
cur += 2;
}
void RMGfxSourceBuffer8RLEWord::RLEWriteData(byte *&cur, int rep, byte *src) {
WRITE_LE_UINT16(cur, rep);
cur += 2;
if (rep > 0) {
CopyMemory(cur, src, rep);
cur += rep;
src += rep;
}
}
void RMGfxSourceBuffer8RLEWord::RLEWriteEOL(byte *&cur) {
*cur ++ = 0xFF;
*cur ++ = 0xFF;
}
void RMGfxSourceBuffer8RLEWord::RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) {
int i, n;
int r, g, b;
if (nStartSkip == 0)
goto RLEWordDoTrasp;
while (1) {
assert(nStartSkip > 0);
// TRASP
n = READ_LE_UINT16(src);
src += 2;
if (n == 0xFFFF)
return;
if (n >= nStartSkip) {
dst += n - nStartSkip;
nLength -= n - nStartSkip;
if (nLength > 0)
goto RLEWordDoAlpha;
else
return;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// ALPHA
n = READ_LE_UINT16(src);
src += 2;
if (n >= nStartSkip) {
n -= nStartSkip;
goto RLEWordDoAlpha2;
}
nStartSkip -= n;
// DATA
n = READ_LE_UINT16(src);
src += 2;
if (n >= nStartSkip) {
src += nStartSkip;
n -= nStartSkip;
goto RLEWordDoCopy2;
}
nStartSkip -= n;
src += n;
}
while (1) {
RLEWordDoTrasp:
// Get the trasp of s**t
n = READ_LE_UINT16(src);
src += 2;
// EOL?
if (n == 0xFFFF)
return;
dst += n;
nLength -= n;
if (nLength <= 0)
return;
RLEWordDoAlpha:
n = READ_LE_UINT16(src);
src += 2;
RLEWordDoAlpha2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++) {
r = (*dst >> 10) & 0x1F;
g = (*dst >> 5) & 0x1F;
b = *dst & 0x1F;
r = (r >> 2) + (alphaR >> 1);
g = (g >> 2) + (alphaG >> 1);
b = (b >> 2) + (alphaB >> 1);
*dst++ = (r << 10) | (g << 5) | b;
}
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
//RLEWordDoCopy:
// Copy the data
n = READ_LE_UINT16(src);
src += 2;
RLEWordDoCopy2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++)
*dst ++ = m_palFinal[*src++];
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
}
}
void RMGfxSourceBuffer8RLEWord::RLEDecompressLineFlipped(uint16 *dst, byte *src, int nStartSkip, int nLength) {
int i, n;
int r, g, b;
if (nStartSkip == 0)
goto RLEWordFlippedDoTrasp;
while (1) {
assert(nStartSkip > 0);
// TRASP
n = READ_LE_UINT16(src);
src += 2;
if (n == 0xFFFF)
return;
if (n >= nStartSkip) {
dst -= n - nStartSkip;
nLength -= n - nStartSkip;
if (nLength > 0)
goto RLEWordFlippedDoAlpha;
else
return;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// ALPHA
n = READ_LE_UINT16(src);
src += 2;
if (n >= nStartSkip) {
n -= nStartSkip;
goto RLEWordFlippedDoAlpha2;
}
nStartSkip -= n;
// DATA
n = READ_LE_UINT16(src);
src += 2;
if (n >= nStartSkip) {
src += nStartSkip;
n -= nStartSkip;
goto RLEWordFlippedDoCopy2;
}
nStartSkip -= n;
src += n;
}
while (1) {
RLEWordFlippedDoTrasp:
// Get the trasp of s**t
n = READ_LE_UINT16(src);
src += 2;
// EOL?
if (n == 0xFFFF)
return;
dst -= n;
nLength -= n;
if (nLength <= 0)
return;
RLEWordFlippedDoAlpha:
n = READ_LE_UINT16(src);
src += 2;
RLEWordFlippedDoAlpha2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++) {
r = (*dst >> 10) & 0x1F;
g = (*dst >> 5) & 0x1F;
b = *dst & 0x1F;
r = (r >> 2) + (alphaR >> 1);
g = (g >> 2) + (alphaG >> 1);
b = (b >> 2) + (alphaB >> 1);
*dst-- = (r << 10) | (g << 5) | b;
}
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
//RLEWordFlippedDoCopy:
// Copy the data
n = READ_LE_UINT16(src);
src += 2;
RLEWordFlippedDoCopy2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++)
*dst -- = m_palFinal[*src++];
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
}
}
/****************************************************************************\
* Metodi di RMGfxSourceBuffer8RLEWord
\****************************************************************************/
RMGfxSourceBuffer8RLEWordAB::~RMGfxSourceBuffer8RLEWordAB() {
}
void RMGfxSourceBuffer8RLEWordAB::RLEDecompressLine(uint16 *dst, byte *src, int nStartSkip, int nLength) {
int i, n;
int r, g, b, r2, g2, b2;
if (!GLOBALS.bCfgTransparence) {
RMGfxSourceBuffer8RLEWord::RLEDecompressLine(dst, src, nStartSkip, nLength);
return;
}
if (nStartSkip == 0)
goto RLEWordDoTrasp;
while (1) {
assert(nStartSkip > 0);
// TRASP
n = READ_LE_UINT16(src);
src += 2;
if (n == 0xFFFF)
return;
if (n >= nStartSkip) {
dst += n - nStartSkip;
nLength -= n - nStartSkip;
if (nLength > 0)
goto RLEWordDoAlpha;
else
return;
}
nStartSkip -= n;
assert(nStartSkip > 0);
// ALPHA
n = READ_LE_UINT16(src);
src += 2;
if (n >= nStartSkip) {
n -= nStartSkip;
goto RLEWordDoAlpha2;
}
nStartSkip -= n;
// DATA
n = READ_LE_UINT16(src);
src += 2;
if (n >= nStartSkip) {
src += nStartSkip;
n -= nStartSkip;
goto RLEWordDoCopy2;
}
nStartSkip -= n;
src += n;
}
while (1) {
RLEWordDoTrasp:
// Get the trasp of s**t
n = READ_LE_UINT16(src);
src += 2;
// EOL?
if (n == 0xFFFF)
return;
dst += n;
nLength -= n;
if (nLength <= 0)
return;
RLEWordDoAlpha:
n = READ_LE_UINT16(src);
src += 2;
RLEWordDoAlpha2:
if (n > nLength)
n = nLength;
// @@@ SHOULD NOT BE THERE !!!!!
for (i = 0; i < n; i++) {
r = (*dst >> 10) & 0x1F;
g = (*dst >> 5) & 0x1F;
b = *dst & 0x1F;
r = (r >> 2) + (alphaR >> 1);
g = (g >> 2) + (alphaG >> 1);
b = (b >> 2) + (alphaB >> 1);
*dst++ = (r << 10) | (g << 5) | b;
}
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
//RLEWordDoCopy:
// Copy the data
n = READ_LE_UINT16(src);
src += 2;
RLEWordDoCopy2:
if (n > nLength)
n = nLength;
for (i = 0; i < n; i++) {
r = (*dst >> 10) & 0x1F;
g = (*dst >> 5) & 0x1F;
b = *dst & 0x1F;
r2 = (m_palFinal[*src] >> 10) & 0x1F;
g2 = (m_palFinal[*src] >> 5) & 0x1F;
b2 = m_palFinal[*src] & 0x1F;
r = (r >> 1) + (r2 >> 1);
g = (g >> 1) + (g2 >> 1);
b = (b >> 1) + (b2 >> 1);
*dst ++ = (r << 10) | (g << 5) | b;
src++;
}
nLength -= n;
if (!nLength)
return;
assert(nLength > 0);
}
}
/****************************************************************************\
* Metodi di RMGfxSourceBuffer8AA
\****************************************************************************/
byte RMGfxSourceBuffer8AA::MegaAABuf[256 * 1024];
byte RMGfxSourceBuffer8AA::MegaAABuf2[64 * 1024];
void RMGfxSourceBuffer8AA::PrepareImage(void) {
// Invoke the parent method
RMGfxSourceBuffer::PrepareImage();
// Prepare the buffer for anti-aliasing
CalculateAA();
}
void RMGfxSourceBuffer8AA::CalculateAA(void) {
// I suck, you suck, he sucks, we suck, they all suck ---> ANTI ALIASING SUX!
// ************************************************************
int x, y;
byte *src, *srcaa;
/* First pass: fill the edges */
Common::fill(MegaAABuf, MegaAABuf + m_dimx * m_dimy, 0);
src = m_buf;
srcaa = MegaAABuf;
for (y = 0; y < m_dimy; y++) {
for (x = 0; x < m_dimx; x++) {
if (*src == 0) {
if ((y > 0 && src[-m_dimx] != 0) ||
(y < m_dimy - 1 && src[m_dimx] != 0) ||
(x > 0 && src[-1] != 0) ||
(x < m_dimx - 1 && src[1] != 0))
*srcaa = 1;
}
src++;
srcaa++;
}
}
src = m_buf;
srcaa = MegaAABuf;
for (y = 0; y < m_dimy; y++) {
for (x = 0; x < m_dimx; x++) {
if (*src != 0) {
if ((y > 0 && srcaa[-m_dimx] == 1) ||
(y < m_dimy - 1 && srcaa[m_dimx] == 1) ||
(x > 0 && srcaa[-1] == 1) ||
(x < m_dimx - 1 && srcaa[1] == 1))
*srcaa = 2;
}
src++;
srcaa++;
}
}
if (m_aabuf != NULL)
delete[] m_aabuf;
m_aabuf = new byte[m_dimx * m_dimy];
CopyMemory(m_aabuf, MegaAABuf, m_dimx * m_dimy);
}
RMGfxSourceBuffer8AA::RMGfxSourceBuffer8AA() : RMGfxSourceBuffer8() {
m_aabuf = NULL;
}
RMGfxSourceBuffer8AA::~RMGfxSourceBuffer8AA() {
if (m_aabuf != NULL)
delete[] m_aabuf;
}
void RMGfxSourceBuffer8AA::DrawAA(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
int x, y;
byte *src;
uint16 *mybuf;
uint16 *buf;
int x1, y1, u, v, width, height;
int r, g, b;
int step;
// Clip the sprite
x1 = prim->Dst().x1;
y1 = prim->Dst().y1;
if (!Clip2D(x1, y1, u, v, width, height, false, &bigBuf))
return;
// Go forward through the RLE lines
src = m_buf;
for (y = 0; y < v; y++)
src += READ_LE_UINT16(src);
// Eliminate horizontal clipping
if (prim->IsFlipped()) {
u = m_dimx - (width + u);
x1 = (prim->Dst().x1 + m_dimx - 1) - u;
}
// width = m_dimx;
// x1=prim->Dst().x1;
// Poisition into the destination buffer
buf = bigBuf;
buf += y1 * bigBuf.Dimx();
if (prim->IsFlipped())
step = -1;
else
step = 1;
// Loop
buf += bigBuf.Dimx(); // Skip the first line
for (y = 1; y < height - 1; y++) {
/*
if (prim->IsFlipped())
mybuf=&buf[x1+m_dimx-1];
else
*/
mybuf = &buf[x1];
for (x = 0; x < width; x++, mybuf += step)
if (m_aabuf[(y + v) * m_dimx + x + u] == 2 && x != 0 && x != width - 1) {
r = GETRED(mybuf[1]) + GETRED(mybuf[-1]) + GETRED(mybuf[-bigBuf.Dimx()]) + GETRED(mybuf[bigBuf.Dimx()]);
g = GETGREEN(mybuf[1]) + GETGREEN(mybuf[-1]) + GETGREEN(mybuf[-bigBuf.Dimx()]) + GETGREEN(mybuf[bigBuf.Dimx()]);
b = GETBLUE(mybuf[1]) + GETBLUE(mybuf[-1]) + GETBLUE(mybuf[-bigBuf.Dimx()]) + GETBLUE(mybuf[bigBuf.Dimx()]);
r += GETRED(mybuf[0]);
g += GETGREEN(mybuf[0]);
b += GETBLUE(mybuf[0]);
r /= 5;
g /= 5;
b /= 5;
if (r > 31) r = 31;
if (g > 31) g = 31;
if (b > 31) b = 31;
mybuf[0] = (r << 10) | (g << 5) | b;
}
// Skip to the next line
buf += bigBuf.Dimx();
}
// Position into the destination buffer
buf = bigBuf;
buf += y1 * bigBuf.Dimx();
// Looppone
buf += bigBuf.Dimx();
for (y = 1; y < height - 1; y++) {
/*
if (prim->IsFlipped())
mybuf=&buf[x1+m_dimx-1];
else
*/
mybuf = &buf[x1];
for (x = 0; x < width; x++, mybuf += step)
if (m_aabuf[(y + v) * m_dimx + x + u] == 1 && x != 0 && x != width - 1) {
r = GETRED(mybuf[1]) + GETRED(mybuf[-1]) + GETRED(mybuf[-bigBuf.Dimx()]) + GETRED(mybuf[bigBuf.Dimx()]);
g = GETGREEN(mybuf[1]) + GETGREEN(mybuf[-1]) + GETGREEN(mybuf[-bigBuf.Dimx()]) + GETGREEN(mybuf[bigBuf.Dimx()]);
b = GETBLUE(mybuf[1]) + GETBLUE(mybuf[-1]) + GETBLUE(mybuf[-bigBuf.Dimx()]) + GETBLUE(mybuf[bigBuf.Dimx()]);
r += GETRED(mybuf[0]) * 2;
g += GETGREEN(mybuf[0]) * 2;
b += GETBLUE(mybuf[0]) * 2;
r /= 6;
g /= 6;
b /= 6;
if (r > 31) r = 31;
if (g > 31) g = 31;
if (b > 31) b = 31;
mybuf[0] = (r << 10) | (g << 5) | b;
}
// Skippa alla linea successiva
buf += bigBuf.Dimx();
}
}
void RMGfxSourceBuffer8AA::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
CORO_BEGIN_CONTEXT;
CORO_END_CONTEXT(_ctx);
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_2(RMGfxSourceBuffer8::Draw, bigBuf, prim);
DrawAA(bigBuf, prim);
CORO_END_CODE;
}
/****************************************************************************\
* RMGfxSourceBuffer8RLEAA Methods
\****************************************************************************/
RMGfxSourceBuffer8RLEByteAA::~RMGfxSourceBuffer8RLEByteAA() {
}
void RMGfxSourceBuffer8RLEByteAA::PrepareImage(void) {
RMGfxSourceBuffer::PrepareImage();
CalculateAA();
CompressRLE();
}
void RMGfxSourceBuffer8RLEByteAA::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
CORO_BEGIN_CONTEXT;
CORO_END_CONTEXT(_ctx);
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_2(RMGfxSourceBuffer8RLE::Draw, bigBuf, prim);
if (GLOBALS.bCfgAntiAlias)
DrawAA(bigBuf, prim);
CORO_END_CODE;
}
int RMGfxSourceBuffer8RLEByteAA::Init(const byte *buf, int dimx, int dimy, bool bLoadPalette) {
return RMGfxSourceBuffer8RLE::Init(buf, dimx, dimy, bLoadPalette);
}
void RMGfxSourceBuffer8RLEByteAA::Init(RMDataStream &ds, int dimx, int dimy, bool bLoadPalette) {
RMGfxSourceBuffer8RLE::Init(ds, dimx, dimy, bLoadPalette);
if (!bNeedRLECompress) {
// Load the anti-aliasing mask
m_aabuf = new byte[dimx * dimy];
ds.Read(m_aabuf, dimx * dimy);
}
}
RMGfxSourceBuffer8RLEWordAA::~RMGfxSourceBuffer8RLEWordAA() {
}
void RMGfxSourceBuffer8RLEWordAA::PrepareImage(void) {
RMGfxSourceBuffer::PrepareImage();
CalculateAA();
CompressRLE();
}
void RMGfxSourceBuffer8RLEWordAA::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
CORO_BEGIN_CONTEXT;
CORO_END_CONTEXT(_ctx);
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_2(RMGfxSourceBuffer8RLE::Draw, bigBuf, prim);
if (GLOBALS.bCfgAntiAlias)
DrawAA(bigBuf, prim);
CORO_END_CODE;
}
int RMGfxSourceBuffer8RLEWordAA::Init(byte *buf, int dimx, int dimy, bool bLoadPalette) {
return RMGfxSourceBuffer8RLE::Init(buf, dimx, dimy, bLoadPalette);
}
void RMGfxSourceBuffer8RLEWordAA::Init(RMDataStream &ds, int dimx, int dimy, bool bLoadPalette) {
RMGfxSourceBuffer8RLE::Init(ds, dimx, dimy, bLoadPalette);
if (!bNeedRLECompress) {
// Load the anti-aliasing mask
m_aabuf = new byte[dimx * dimy];
ds.Read(m_aabuf, dimx * dimy);
}
}
/****************************************************************************\
* RMGfxSourceBuffer16 Methods
\****************************************************************************/
RMGfxSourceBuffer16::RMGfxSourceBuffer16(bool bTrasp0) {
m_bTrasp0 = bTrasp0;
}
RMGfxSourceBuffer16::~RMGfxSourceBuffer16() {
}
void RMGfxSourceBuffer16::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
int x, y;
uint16 *buf = bigBuf;
uint16 *raw = (uint16 *)m_buf;
int dimx, dimy;
int u, v;
int x1, y1;
dimx = m_dimx;
dimy = m_dimy;
u = 0;
v = 0;
x1 = 0;
y1 = 0;
if (prim->HaveSrc()) {
u = prim->Src().x1;
v = prim->Src().y1;
dimx = prim->Src().Width();
dimy = prim->Src().Height();
}
if (prim->HaveDst()) {
x1 = prim->Dst().x1;
y1 = prim->Dst().y1;
}
if (!Clip2D(x1, y1, u, v, dimx, dimy, true, &bigBuf))
return;
raw += v * m_dimx + u;
buf += y1 * bigBuf.Dimx() + x1;
if (m_bTrasp0) {
for (y = 0; y < dimy; y++) {
for (x = 0; x < dimx;) {
while (x < dimx && raw[x] == 0)
x++;
while (x < dimx && raw[x] != 0) {
buf[x] = raw[x];
x++;
}
}
raw += m_dimx;
buf += bigBuf.Dimx();
}
} else {
for (y = 0; y < dimy; y++) {
Common::copy(raw, raw + dimx, buf);
buf += bigBuf.Dimx();
raw += m_dimx;
}
}
}
void RMGfxSourceBuffer16::PrepareImage(void) {
// Colour space conversion if necessary!
int i;
uint16 *buf = (uint16 *)m_buf;
for (i = 0; i < m_dimx * m_dimy; i++)
WRITE_LE_UINT16(&buf[i], FROM_LE_16(buf[i]) & 0x7FFF);
}
RMGfxSourceBuffer16::RMGfxSourceBuffer16(int dimx, int dimy, bool bUseDDraw)
: RMGfxBuffer(dimx, dimy, 16, bUseDDraw) {
SetPriority(0);
}
/**
* Returns the number of bits per pixel of the surface
*
* @returns Bit per pixel
*/
int RMGfxSourceBuffer16::Bpp() {
return 16;
}
void RMGfxSourceBuffer16::Create(int dimx, int dimy, bool bUseDDraw) {
RMGfxBuffer::Create(dimx, dimy, 16, bUseDDraw);
}
/****************************************************************************\
* RMGfxBox Methods
\****************************************************************************/
void RMGfxBox::RemoveThis(CORO_PARAM, bool &result) {
result = true;
}
void RMGfxBox::SetColor(byte r, byte g, byte b) {
r >>= 3;
g >>= 3;
b >>= 3;
wFillColor = (r << 10) | (g << 5) | b;
}
void RMGfxBox::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
int i, j;
uint16 *buf = bigBuf;
RMRect rcDst;
// It takes the destination rectangle
rcDst = prim->Dst();
buf += rcDst.y1 * bigBuf.Dimx() + rcDst.x1;
// Loop through the pixels
for (j = 0; j < rcDst.Height(); j++) {
for (i = 0; i < rcDst.Width(); i++)
*buf ++ = wFillColor;
buf += bigBuf.Dimx() - rcDst.Width();
}
}
/****************************************************************************\
* RMGfxClearTask Methods
\****************************************************************************/
int RMGfxClearTask::Priority() {
// Maximum priority (must be done first)
return 1;
}
void RMGfxClearTask::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *) {
// Clean the target buffer
Common::fill((byte *)bigBuf, (byte *)bigBuf + (bigBuf.Dimx() * bigBuf.Dimy() * 2), 0x0);
}
void RMGfxClearTask::RemoveThis(CORO_PARAM, bool &result) {
// The task is fine to be removed
result = true;
}
} // End of namespace Tony
Reference in New Issue View Git Blame Copy Permalink