libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-05-13 17:46:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Dumped most of the remaining "driver" code into a new "Display" class. This

Browse Source 
touches a lot of the code, of course, and adds yet another global variable
(temporarily, I hope), but everything still seems to work.

Knock on wood.

svn-id: r10806
This commit is contained in:
Torbjörn Andersson 2003-10-15 06:40:31 +00:00
parent f74a0c18aa
commit 8b42d65a7e
31 changed files with 949 additions and 1142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sword2/anims.cpp
View File

@ -776,14 +776,14 @@ int32 FN_play_sequence(int32 *params) {
// now clear the screen in case the Sequence was quitted (using ESC)
// rather than fading down to black
EraseBackBuffer();
g_display->clearScene();
// zero the entire palette in case we're about to fade up!
_palEntry pal[256];
memset(pal, 0, 256 * sizeof(_palEntry));
BS2_SetPalette(0, 256, (uint8 *) pal, RDPAL_INSTANT);
g_display->setPalette(0, 256, (uint8 *) pal, RDPAL_INSTANT);
debug(5, "FN_play_sequence FINISHED");

129
sword2/build_display.cpp
View File

@ -108,7 +108,6 @@ void Send_fore_par1_frames(void);
// ---------------------------------------------------------------------------
void Build_display(void) {
bool end;
#ifdef _SWORD2_DEBUG
uint8 pal[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0 };
#endif
@ -133,25 +132,21 @@ void Build_display(void) {
// there is a valid screen to run
if (!console_status && this_screen.background_layer_id) {
// set the scroll position
SetScrollTarget(this_screen.scroll_offset_x, this_screen.scroll_offset_y);
g_display->setScrollTarget(this_screen.scroll_offset_x, this_screen.scroll_offset_y);
// increment the mouse frame
AnimateMouse();
g_display->animateMouse();
StartRenderCycle();
g_display->startRenderCycle();
while (1) {
// START OF RENDER CYCLE
// ---------------------------------------------------
// clear the back buffer, before building up the new
// screen from the back forwards
// FIXME: I'm not convinced that this is needed. Isn't
// the whole screen redrawn each time?
// EraseBackBuffer();
// g_display->clearScene();
// ---------------------------------------------------
// first background parallax + related anims
// open the screen resource
@ -159,7 +154,7 @@ void Build_display(void) {
screenLayerTable = (_multiScreenHeader *) ((uint8 *) file + sizeof(_standardHeader));
if (screenLayerTable->bg_parallax[0]) {
RenderParallax(FetchBackgroundParallaxLayer(file, 0), 0);
g_display->renderParallax(FetchBackgroundParallaxLayer(file, 0), 0);
// release the screen resource before cacheing
// the sprites
res_man.close(this_screen.background_layer_id);
@ -169,7 +164,6 @@ void Build_display(void) {
res_man.close(this_screen.background_layer_id);
}
// ---------------------------------------------------
// second background parallax + related anims
// open the screen resource
@ -177,7 +171,7 @@ void Build_display(void) {
screenLayerTable = (_multiScreenHeader *) ((uint8 *) file + sizeof(_standardHeader));
if (screenLayerTable->bg_parallax[1]) {
RenderParallax(FetchBackgroundParallaxLayer(file, 1), 1);
g_display->renderParallax(FetchBackgroundParallaxLayer(file, 1), 1);
// release the screen resource before cacheing
// the sprites
res_man.close(this_screen.background_layer_id);
@ -187,16 +181,14 @@ void Build_display(void) {
res_man.close(this_screen.background_layer_id);
}
// ---------------------------------------------------
// normal backround layer (just the one!)
// open the screen resource
file = res_man.open(this_screen.background_layer_id);
RenderParallax(FetchBackgroundLayer(file), 2);
g_display->renderParallax(FetchBackgroundLayer(file), 2);
// release the screen resource
res_man.close(this_screen.background_layer_id);
// ---------------------------------------------------
// sprites & layers
Send_back_frames(); // background sprites
@ -204,7 +196,6 @@ void Build_display(void) {
Send_sort_frames(); // sorted sprites & layers
Send_fore_frames(); // foreground sprites
// ---------------------------------------------------
// first foreground parallax + related anims
// open the screen resource
@ -212,7 +203,7 @@ void Build_display(void) {
screenLayerTable = (_multiScreenHeader *) ((uint8 *) file + sizeof(_standardHeader));
if (screenLayerTable->fg_parallax[0]) {
RenderParallax(FetchForegroundParallaxLayer(file, 0), 3);
g_display->renderParallax(FetchForegroundParallaxLayer(file, 0), 3);
// release the screen resource before cacheing
// the sprites
res_man.close(this_screen.background_layer_id);
@ -222,7 +213,6 @@ void Build_display(void) {
res_man.close(this_screen.background_layer_id);
}
//----------------------------------------------------
// second foreground parallax + related anims
// open the screen resource
@ -230,7 +220,7 @@ void Build_display(void) {
screenLayerTable = (_multiScreenHeader *) ((uint8 *) file + sizeof(_standardHeader));
if (screenLayerTable->fg_parallax[1]) {
RenderParallax(FetchForegroundParallaxLayer(file, 1), 4);
g_display->renderParallax(FetchForegroundParallaxLayer(file, 1), 4);
// release the screen resource before cacheing
// the sprites
res_man.close(this_screen.background_layer_id);
@ -240,29 +230,24 @@ void Build_display(void) {
res_man.close(this_screen.background_layer_id);
}
// ---------------------------------------------------
// walkgrid, mouse & player markers & mouse area
// rectangle
Draw_debug_graphics();
// ---------------------------------------------------
// text blocks
// speech blocks and headup debug text
fontRenderer.printTextBlocs();
// ---------------------------------------------------
// menu bar & icons
ProcessMenu();
g_display->processMenu();
// ---------------------------------------------------
// ready - blit to screen
ServiceWindows();
g_display->updateDisplay();
//----------------------------------------------------
// update our fps reading
frameCount++;
@ -273,20 +258,16 @@ void Build_display(void) {
cycleTime = SVM_timeGetTime() + 1000;
}
// ---------------------------------------------------
// check if we've got time to render the screen again
// Check if we've got time to render the screen again
// this cycle (so drivers can smooth out the scrolling
// in between normal game cycles)
EndRenderCycle(&end);
// if we haven't got time to render again this cycle,
//
// If we haven't got time to render again this cycle,
// drop out of 'render cycle' while-loop
if (end)
break;
// ---------------------------------------------------
} // END OF RENDER CYCLE
if (g_display->endRenderCycle())
break;
}
}
#ifdef _SWORD2_DEBUG
else if (console_status) {
@ -302,13 +283,13 @@ void Build_display(void) {
spriteInfo.data = console_sprite->ad;
spriteInfo.colourTable = 0;
rv = DrawSprite(&spriteInfo);
rv = g_display->drawSprite(&spriteInfo);
if (rv)
error("Driver Error %.8x (drawing console)", rv);
} else{
StartConsole();
// force the palette
BS2_SetPalette(0, 3, pal, RDPAL_INSTANT);
g_display->setPalette(0, 3, pal, RDPAL_INSTANT);
Print_to_console("no valid screen?");
}
#endif
@ -329,24 +310,24 @@ void DisplayMsg(uint8 *text, int time) {
warning("DisplayMsg: %s", (char *) text);
if (GetFadeStatus() != RDFADE_BLACK) {
FadeDown((float) 0.75);
WaitForFade();
if (g_display->getFadeStatus() != RDFADE_BLACK) {
g_display->fadeDown();
g_display->waitForFade();
}
Set_mouse(0);
Set_luggage(0);
CloseMenuImmediately();
EraseBackBuffer();
g_display->closeMenuImmediately();
g_display->clearScene();
text_spr = fontRenderer.makeTextSprite(text, 640, 187, g_sword2->_speechFontId);
frame = (_frameHeader *) text_spr->ad;
spriteInfo.x = screenWide / 2 - frame->width / 2;
spriteInfo.x = g_display->_screenWide / 2 - frame->width / 2;
if (!time)
spriteInfo.y = screenDeep / 2 - frame->height / 2 - RDMENU_MENUDEEP;
spriteInfo.y = g_display->_screenDeep / 2 - frame->height / 2 - RDMENU_MENUDEEP;
else
spriteInfo.y = 400 - frame->height;
spriteInfo.w = frame->width;
@ -359,33 +340,34 @@ void DisplayMsg(uint8 *text, int time) {
spriteInfo.data = text_spr->ad + sizeof(_frameHeader);
spriteInfo.colourTable = 0;
rv = DrawSprite(&spriteInfo);
rv = g_display->drawSprite(&spriteInfo);
if (rv)
error("Driver Error %.8x (in DisplayMsg)", rv);
memcpy((char *) oldPal, (char *) palCopy, 256 * sizeof(_palEntry));
memcpy((char *) oldPal, (char *) g_display->_palCopy, 256 * sizeof(_palEntry));
memset(pal, 0, 256 * sizeof(_palEntry));
pal[187].red = 255;
pal[187].green = 255;
pal[187].blue = 255;
BS2_SetPalette(0, 256, (uint8 *) pal, RDPAL_FADE);
g_display->setPalette(0, 256, (uint8 *) pal, RDPAL_FADE);
FadeUp((float) 0.75);
g_display->fadeUp();
memory.freeMemory(text_spr);
WaitForFade();
g_display->waitForFade();
uint32 targetTime = SVM_timeGetTime() + (time * 1000);
rv = DrawSprite(&spriteInfo); // Keep the message there even when the user task swaps.
// Keep the message there even when the user task swaps.
rv = g_display->drawSprite(&spriteInfo);
if (rv)
error("Driver Error %.8x (in DisplayMsg)", rv);
sleepUntil(targetTime);
BS2_SetPalette(0, 256, (uint8 *) oldPal, RDPAL_FADE);
g_display->setPalette(0, 256, (uint8 *) oldPal, RDPAL_FADE);
}
// ---------------------------------------------------------------------------
@ -394,13 +376,13 @@ void DisplayMsg(uint8 *text, int time) {
//
void RemoveMsg(void) {
FadeDown((float) 0.75);
g_display->fadeDown();
WaitForFade();
g_display->waitForFade();
EraseBackBuffer();
g_display->clearScene();
// FadeUp((float) 0.75);
// g_display->fadeUp();
// removed by JEL (08oct97) to prevent "eye" smacker corruption when
// restarting game from CD2 and also to prevent palette flicker when
// restoring game to a different CD since the "insert CD" message uses
@ -516,7 +498,7 @@ void Process_layer(uint32 layer_number) {
#endif
//------------------------------------------
rv = DrawSprite(&spriteInfo);
rv = g_display->drawSprite(&spriteInfo);
if (rv)
error("Driver Error %.8x in Process_layer(%d)", rv, layer_number);
@ -559,7 +541,7 @@ void Process_image(buildit *build_unit) {
// but the same compression can be decompressed using the
// RLE256 routines!
// NOTE: If this restriction refers to DrawSprite(), I don't
// NOTE: If this restriction refers to drawSprite(), I don't
// think we have it any more. But I'm not sure.
if (build_unit->scale || anim_head->blend || build_unit->shadingFlag)
@ -649,7 +631,7 @@ void Process_image(buildit *build_unit) {
// }
// #endif
rv = DrawSprite(&spriteInfo);
rv = g_display->drawSprite(&spriteInfo);
if (rv)
error("Driver Error %.8x with sprite %s (%d) in Process_image",
rv, FetchObjectName(build_unit->anim_resource),
@ -933,14 +915,14 @@ void Start_new_palette(void) {
// if the screen is still fading down then wait for black - could
// happen when everythings cached into a large memory model
WaitForFade();
g_display->waitForFade();
// open the screen file
screenFile = res_man.open(this_screen.background_layer_id);
UpdatePaletteMatchTable((uint8 *) FetchPaletteMatchTable(screenFile));
g_display->updatePaletteMatchTable((uint8 *) FetchPaletteMatchTable(screenFile));
BS2_SetPalette(0, 256, FetchPalette(screenFile), RDPAL_FADE);
g_display->setPalette(0, 256, FetchPalette(screenFile), RDPAL_FADE);
// indicating that it's a screen palette
lastPaletteRes = 0;
@ -949,8 +931,7 @@ void Start_new_palette(void) {
res_man.close(this_screen.background_layer_id);
// start fade up
// FadeUp((float) 1.75);
FadeUp((float) 0.75);
g_display->fadeUp();
// reset
this_screen.new_palette = 0;
@ -980,17 +961,17 @@ int32 FN_fade_down(int32 *params) {
// NONE means up! can only be called when screen is fully faded up -
// multiple calls wont have strange effects
if (GetFadeStatus() == RDFADE_NONE)
FadeDown((float) 0.75);
if (g_display->getFadeStatus() == RDFADE_NONE)
g_display->fadeDown();
return IR_CONT;
}
int32 FN_fade_up(int32 *params) {
WaitForFade();
g_display->waitForFade();
if (GetFadeStatus() == RDFADE_BLACK)
FadeUp((float) 0.75);
if (g_display->getFadeStatus() == RDFADE_BLACK)
g_display->fadeUp();
return IR_CONT;
}
@ -1076,9 +1057,9 @@ void SetFullPalette(int32 palRes) {
file[3] = 0;
// not yet in separate palette files
// UpdatePaletteMatchTable(file + (256 * 4));
// g_display->updatePaletteMatchTable(file + (256 * 4));
BS2_SetPalette(0, 256, file, RDPAL_INSTANT);
g_display->setPalette(0, 256, file, RDPAL_INSTANT);
if (palRes != CONTROL_PANEL_PALETTE) { // (James 03sep97)
// indicating that it's a separate palette resource
@ -1092,9 +1073,9 @@ void SetFullPalette(int32 palRes) {
if (this_screen.background_layer_id) {
// open the screen file
file = res_man.open(this_screen.background_layer_id);
UpdatePaletteMatchTable((uint8 *) FetchPaletteMatchTable(file));
g_display->updatePaletteMatchTable((uint8 *) FetchPaletteMatchTable(file));
BS2_SetPalette(0, 256, FetchPalette(file), RDPAL_INSTANT);
g_display->setPalette(0, 256, FetchPalette(file), RDPAL_INSTANT);
// indicating that it's a screen palette
lastPaletteRes = 0;
@ -1115,7 +1096,7 @@ int32 FN_change_shadows(int32 *params) {
// if last screen was using a shading mask (see below)
if (this_screen.mask_flag) {
rv = CloseLightMask();
rv = g_display->closeLightMask();
if (rv)
error("Driver Error %.8x [%s line %u]", rv);

14
sword2/console.cpp
View File

@ -164,7 +164,7 @@ void Init_console(void) {
con_width = screenWide; //max across
// Force a palatte for the console.
BS2_SetPalette(CON_PEN, 1, white, RDPAL_INSTANT);
g_display->setPalette(CON_PEN, 1, white, RDPAL_INSTANT);
console_sprite = memory.alloc(con_width * (CON_lines * con_chr_height), MEM_float, UID_con_sprite);
@ -213,7 +213,7 @@ uint32 Tconsole(uint32 mode) {
StartConsole();
while (1) {
ServiceWindows();
g_display->updateDisplay();
if (breakOut)
break;
@ -460,7 +460,7 @@ uint32 Parse_user_input(void) {
case 18: // S (same as START)
Con_start(&input[1][0]);
// force the palette
BS2_SetPalette(187, 1, pal, RDPAL_INSTANT);
g_display->setPalette(187, 1, pal, RDPAL_INSTANT);
return 0;
case 9: // INFO
displayDebugText = 1 - displayDebugText;
@ -729,7 +729,7 @@ void Con_help(void) {
Build_display();
do {
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
ReadKey(&c);
@ -803,8 +803,8 @@ void Con_fatal_error(const char *format, ...) {
char buf[150];
uint8 white[4] = { 255, 255, 255, 0 };
// set text colour in case screen is faded down! (James 05mar97)
BS2_SetPalette(CON_PEN, 1, white, RDPAL_INSTANT);
// set text colour in case screen is faded down!
g_display->setPalette(CON_PEN, 1, white, RDPAL_INSTANT);
va_start(arg_ptr,format);
_vsnprintf(buf, 150, format, arg_ptr);
@ -912,7 +912,7 @@ void Con_list_savegames(void) {
Build_display();
do {
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
ReadKey(&c);

70
sword2/controls.cpp
View File

@ -74,7 +74,7 @@ public:
sprite.data = (uint8 *) (head + 1);
sprite.w = head->width;
sprite.h = head->height;
CreateSurface(&sprite, &_glyph[i]._data);
g_display->createSurface(&sprite, &_glyph[i]._data);
_glyph[i]._width = head->width;
_glyph[i]._height = head->height;
}
@ -84,7 +84,7 @@ public:
~FontRendererGui() {
for (int i = 0; i < SIZE_OF_CHAR_SET; i++)
DeleteSurface(_glyph[i]._data);
g_display->deleteSurface(_glyph[i]._data);
}
void fetchText(int textId, char *buf) {
@ -143,7 +143,7 @@ void FontRendererGui::drawText(char *text, int x, int y, int alignment) {
sprite.w = _glyph[text[i] - 32]._width;
sprite.h = _glyph[text[i] - 32]._height;
DrawSurface(&sprite, _glyph[text[i] - 32]._data);
g_display->drawSurface(&sprite, _glyph[text[i] - 32]._data);
sprite.x += (_glyph[(int) text[i] - 32]._width - CHARACTER_OVERLAP);
}
@ -186,7 +186,7 @@ public:
virtual ~Widget() {
for (int i = 0; i < _numStates; i++) {
if (_surfaces[i]._original)
DeleteSurface(_surfaces[i]._surface);
g_display->deleteSurface(_surfaces[i]._surface);
}
free(_sprites);
free(_surfaces);
@ -228,7 +228,7 @@ public:
}
virtual void paint(Common::Rect *clipRect = NULL) {
DrawSurface(&_sprites[_state], _surfaces[_state]._surface, clipRect);
g_display->drawSurface(&_sprites[_state], _surfaces[_state]._surface, clipRect);
}
virtual void onMouseEnter() {}
@ -291,7 +291,7 @@ void Widget::createSurfaceImage(int state, uint32 res, int x, int y, uint32 pc)
// Points to just after frame header, ie. start of sprite data
_sprites[state].data = (uint8 *) (frame_head + 1);
CreateSurface(&_sprites[state], &_surfaces[state]._surface);
g_display->createSurface(&_sprites[state], &_surfaces[state]._surface);
_surfaces[state]._original = true;
// Release the anim resource
@ -339,7 +339,7 @@ public:
virtual void onAction(Widget *widget, int result = 0) {}
virtual void paint() {
EraseBackBuffer();
g_display->clearScene();
for (int i = 0; i < _numWidgets; i++)
_widgets[i]->paint();
}
@ -362,12 +362,11 @@ int Dialog::run() {
while (!_finish) {
// So that the menu icons will reach their full size
ProcessMenu();
g_display->processMenu();
g_display->updateDisplay();
ServiceWindows();
int16 newMouseX = mousex;
int16 newMouseY = mousey + 40;
int16 newMouseX = g_display->_mouseX;
int16 newMouseY = g_display->_mouseY + 40;
_mouseEvent *me = MouseEvent();
_keyboardEvent ke;
@ -388,7 +387,7 @@ int Dialog::run() {
_widgets[i]->onMouseEnter();
if (oldHit && !newHit)
_widgets[i]->onMouseExit();
if (mousex != oldMouseX || mousey != oldMouseY)
if (g_display->_mouseX != oldMouseX || g_display->_mouseY != oldMouseY)
_widgets[i]->onMouseMove(newMouseX, newMouseY);
if (me) {
@ -788,8 +787,8 @@ public:
_musicSlider->setValue(g_sound->getMusicVolume());
_speechSlider->setValue(g_sound->getSpeechVolume());
_fxSlider->setValue(g_sound->getFxVolume());
_gfxSlider->setValue(GetRenderType());
_gfxPreview->setState(GetRenderType());
_gfxSlider->setValue(g_display->getRenderLevel());
_gfxPreview->setState(g_display->getRenderLevel());
}
~OptionsDialog() {
@ -901,7 +900,7 @@ int32 OptionsDialog::writeOptionSettings(void) {
buff[3] = g_sound->isMusicMute();
buff[4] = g_sound->isSpeechMute();
buff[5] = g_sound->isFxMute();
buff[6] = GetRenderType();
buff[6] = g_display->getRenderLevel();
buff[7] = gui._subtitles;
buff[8] = gui._pointerTextSelected;
buff[9] = gui._stereoReversed;
@ -1352,7 +1351,7 @@ void SaveLoadDialog::saveLoadError(char* text) {
while (1) {
_mouseEvent *me;
ServiceWindows();
g_display->updateDisplay();
if (KeyWaiting()) {
_keyboardEvent ke;
@ -1396,7 +1395,6 @@ void Gui::quitControl(void) {
// close engine systems down
Close_game();
CloseAppWindow();
exit(0);
}
@ -1410,13 +1408,13 @@ void Gui::restartControl(void) {
return;
}
// Stop music instantly! (James 22aug97)
// Stop music instantly!
Kill_music();
//in case we were dead - well we're not anymore!
DEAD = 0;
EraseBackBuffer();
g_display->clearScene();
// restart the game
// clear all memory and reset the globals
@ -1450,9 +1448,9 @@ void Gui::restartControl(void) {
// FN_register_frame)
Reset_mouse_list();
CloseMenuImmediately();
g_display->closeMenuImmediately();
// FOR THE DEMO - FORCE THE SCROLLING TO BE RESET! (James29may97)
// FOR THE DEMO - FORCE THE SCROLLING TO BE RESET!
// - this is taken from FN_init_background
// switch on scrolling (2 means first time on screen)
@ -1525,33 +1523,7 @@ void Gui::optionControl(void) {
}
void Gui::updateGraphicsLevel(uint8 newLevel) {
switch (newLevel) {
case 0:
// Lowest setting: no graphics fx
ClearTransFx();
ClearShadowFx();
ClearBltFx();
break;
case 1:
// Medium-low setting: transparency-blending
SetTransFx();
ClearShadowFx();
ClearBltFx();
break;
case 2:
// Medium-high setting: transparency-blending + shading
SetTransFx();
SetShadowFx();
ClearBltFx();
break;
case 3:
// Highest setting: transparency-blending + shading +
// edge-blending + improved stretching
SetTransFx();
SetShadowFx();
SetBltFx();
break;
}
g_display->setRenderLevel(newLevel);
// update our global variable - which needs to be checked when dimming
// the palette in PauseGame() in sword2.cpp (since palette-matching

162
sword2/driver/_mouse.cpp
View File

@ -29,49 +29,15 @@ namespace Sword2 {
#define MAX_MOUSE_EVENTS 16
#define MOUSEFLASHFRAME 6
#if !defined(__GNUC__)
#pragma START_PACK_STRUCTS
#endif
struct _mouseAnim {
uint8 runTimeComp; // type of runtime compression used for the
// frame data
uint8 noAnimFrames; // number of frames in the anim
int8 xHotSpot;
int8 yHotSpot;
uint8 mousew;
uint8 mouseh;
} GCC_PACK;
#if !defined(__GNUC__)
#pragma END_PACK_STRUCTS
#endif
int16 mousex;
int16 mousey;
static uint8 mouseBacklog = 0;
static uint8 mouseLogPos = 0;
static uint8 mouseFrame;
static uint8 *mouseSprite = NULL;
static _mouseAnim *mouseAnim = NULL;
static _mouseAnim *luggageAnim = NULL;
static _mouseEvent mouseLog[MAX_MOUSE_EVENTS];
static int32 *mouseOffsets;
static int32 *luggageOffset;
// This is the maximum mouse cursor size in the SDL backend
#define MAX_MOUSE_W 80
#define MAX_MOUSE_H 80
byte _mouseData[MAX_MOUSE_W * MAX_MOUSE_H];
void ResetRenderEngine(void) {
parallaxScrollx = 0;
parallaxScrolly = 0;
scrollx = 0;
scrolly = 0;
void Display::resetRenderEngine(void) {
_parallaxScrollX = 0;
_parallaxScrollY = 0;
_scrollX = 0;
_scrollY = 0;
}
// --------------------------------------------------------------------------
@ -96,7 +62,7 @@ void LogMouseEvent(uint16 buttons) {
// 0xFF. That means that parts of the mouse cursor that weren't meant to be
// transparent may be now.
int32 DecompressMouse(uint8 *decomp, uint8 *comp, int width, int height, int pitch, int xOff = 0, int yOff = 0) {
void Display::decompressMouse(uint8 *decomp, uint8 *comp, int width, int height, int pitch, int xOff, int yOff) {
int32 size = width * height;
int32 i = 0;
int x = 0;
@ -119,12 +85,10 @@ int32 DecompressMouse(uint8 *decomp, uint8 *comp, int width, int height, int pit
i += *comp++;
}
}
return RD_OK;
}
void DrawMouse(void) {
if (!mouseAnim && !luggageAnim)
void Display::drawMouse(void) {
if (!_mouseAnim && !_luggageAnim)
return;
// When an object is used in the game, the mouse cursor should be a
@ -140,27 +104,27 @@ void DrawMouse(void) {
int deltaX = 0;
int deltaY = 0;
if (mouseAnim) {
hotspot_x = mouseAnim->xHotSpot;
hotspot_y = mouseAnim->yHotSpot;
mouse_width = mouseAnim->mousew;
mouse_height = mouseAnim->mouseh;
if (_mouseAnim) {
hotspot_x = _mouseAnim->xHotSpot;
hotspot_y = _mouseAnim->yHotSpot;
mouse_width = _mouseAnim->mousew;
mouse_height = _mouseAnim->mouseh;
}
if (luggageAnim) {
if (!mouseAnim) {
hotspot_x = luggageAnim->xHotSpot;
hotspot_y = luggageAnim->yHotSpot;
if (_luggageAnim) {
if (!_mouseAnim) {
hotspot_x = _luggageAnim->xHotSpot;
hotspot_y = _luggageAnim->yHotSpot;
}
if (luggageAnim->mousew > mouse_width)
mouse_width = luggageAnim->mousew;
if (luggageAnim->mouseh > mouse_height)
mouse_height = luggageAnim->mouseh;
if (_luggageAnim->mousew > mouse_width)
mouse_width = _luggageAnim->mousew;
if (_luggageAnim->mouseh > mouse_height)
mouse_height = _luggageAnim->mouseh;
}
if (mouseAnim && luggageAnim) {
deltaX = mouseAnim->xHotSpot - luggageAnim->xHotSpot;
deltaY = mouseAnim->yHotSpot - luggageAnim->yHotSpot;
if (_mouseAnim && _luggageAnim) {
deltaX = _mouseAnim->xHotSpot - _luggageAnim->xHotSpot;
deltaY = _mouseAnim->yHotSpot - _luggageAnim->yHotSpot;
}
assert(deltaX >= 0);
@ -184,12 +148,12 @@ void DrawMouse(void) {
memset(_mouseData, 0xFF, mouse_width * mouse_height);
if (luggageAnim)
DecompressMouse(_mouseData, (uint8 *) luggageAnim + READ_LE_UINT32(luggageOffset), luggageAnim->mousew,
luggageAnim->mouseh, mouse_width, deltaX, deltaY);
if (_luggageAnim)
decompressMouse(_mouseData, (uint8 *) _luggageAnim + READ_LE_UINT32(_luggageOffset), _luggageAnim->mousew,
_luggageAnim->mouseh, mouse_width, deltaX, deltaY);
if (mouseAnim)
DecompressMouse(_mouseData, mouseSprite, mouseAnim->mousew, mouseAnim->mouseh, mouse_width);
if (_mouseAnim)
decompressMouse(_mouseData, _mouseSprite, _mouseAnim->mousew, _mouseAnim->mouseh, mouse_width);
g_system->set_mouse_cursor(_mouseData, mouse_width, mouse_height, hotspot_x, hotspot_y);
}
@ -222,19 +186,19 @@ uint8 CheckForMouseEvents(void) {
* Animates the current mouse pointer
*/
int32 AnimateMouse(void) {
uint8 prevMouseFrame = mouseFrame;
int32 Display::animateMouse(void) {
uint8 prevMouseFrame = _mouseFrame;
if (!mouseAnim)
if (!_mouseAnim)
return RDERR_UNKNOWN;
if (++mouseFrame == mouseAnim->noAnimFrames)
mouseFrame = MOUSEFLASHFRAME;
if (++_mouseFrame == _mouseAnim->noAnimFrames)
_mouseFrame = MOUSEFLASHFRAME;
mouseSprite = (uint8 *) mouseAnim + READ_LE_UINT32(mouseOffsets + mouseFrame);
_mouseSprite = (uint8 *) _mouseAnim + READ_LE_UINT32(_mouseOffsets + _mouseFrame);
if (mouseFrame != prevMouseFrame)
DrawMouse();
if (_mouseFrame != prevMouseFrame)
drawMouse();
return RD_OK;
}
@ -247,32 +211,32 @@ int32 AnimateMouse(void) {
* or not there is a lead-in animation
*/
int32 SetMouseAnim(uint8 *ma, int32 size, int32 mouseFlash) {
if (mouseAnim) {
free(mouseAnim);
mouseAnim = NULL;
int32 Display::setMouseAnim(uint8 *ma, int32 size, int32 mouseFlash) {
if (_mouseAnim) {
free(_mouseAnim);
_mouseAnim = NULL;
}
if (ma) {
if (mouseFlash == RDMOUSE_FLASH)
mouseFrame = 0;
_mouseFrame = 0;
else
mouseFrame = MOUSEFLASHFRAME;
_mouseFrame = MOUSEFLASHFRAME;
mouseAnim = (_mouseAnim *) malloc(size);
if (!mouseAnim)
_mouseAnim = (struct _mouseAnim *) malloc(size);
if (!_mouseAnim)
return RDERR_OUTOFMEMORY;
memcpy((uint8 *) mouseAnim, ma, size);
mouseOffsets = (int32 *) ((uint8 *) mouseAnim + sizeof(_mouseAnim));
memcpy((uint8 *) _mouseAnim, ma, size);
_mouseOffsets = (int32 *) ((uint8 *) _mouseAnim + sizeof(struct _mouseAnim));
AnimateMouse();
DrawMouse();
animateMouse();
drawMouse();
g_system->show_mouse(true);
} else {
if (luggageAnim)
DrawMouse();
if (_luggageAnim)
drawMouse();
else
g_system->show_mouse(false);
}
@ -287,27 +251,27 @@ int32 SetMouseAnim(uint8 *ma, int32 size, int32 mouseFlash) {
* @param size the size of the animation data
*/
int32 SetLuggageAnim(uint8 *ma, int32 size) {
if (luggageAnim) {
free(luggageAnim);
luggageAnim = NULL;
int32 Display::setLuggageAnim(uint8 *ma, int32 size) {
if (_luggageAnim) {
free(_luggageAnim);
_luggageAnim = NULL;
}
if (ma) {
luggageAnim = (_mouseAnim *) malloc(size);
if (!luggageAnim)
_luggageAnim = (struct _mouseAnim *) malloc(size);
if (!_luggageAnim)
return RDERR_OUTOFMEMORY;
memcpy((uint8 *) luggageAnim, ma, size);
luggageOffset = (int32 *) ((uint8 *) luggageAnim + sizeof(_mouseAnim));
memcpy((uint8 *) _luggageAnim, ma, size);
_luggageOffset = (int32 *) ((uint8 *) _luggageAnim + sizeof(struct _mouseAnim));
AnimateMouse();
DrawMouse();
animateMouse();
drawMouse();
g_system->show_mouse(true);
} else {
if (mouseAnim)
DrawMouse();
if (_mouseAnim)
drawMouse();
else
g_system->show_mouse(false);
}

4
sword2/driver/_mouse.h
View File

@ -22,11 +22,7 @@
namespace Sword2 {
extern int16 mousex; // Mouse x coordinate
extern int16 mousey; // Mouse y coordinate
extern void LogMouseEvent(uint16 buttons);
extern int32 DrawMouse(void);
} // End of namespace Sword2

158
sword2/driver/d_draw.cpp
View File

@ -30,118 +30,90 @@
namespace Sword2 {
byte *lpBackBuffer;
Display::Display(int16 width, int16 height)
: _iconCount(0), _needFullRedraw(false), _fadeStatus(RDFADE_NONE),
_mouseSprite(NULL), _mouseAnim(NULL), _luggageAnim(NULL),
_layer(0), _renderAverageTime(60), _lightMask(NULL),
_screenWide(width), _screenDeep(height) {
// Game screen metrics
int16 screenDeep;
int16 screenWide;
int i, j;
// Scroll variables. scrollx and scrolly hold the current scroll position,
_buffer = (byte *) malloc(width * height);
if (!_buffer)
error("Could not initialise display");
int16 scrollx;
int16 scrolly;
int32 renderCaps = 0;
/**
* Initialise the display with the sizes passed in.
* @return RD_OK, or an error code if the display cannot be set up.
*/
int32 InitialiseDisplay(int16 width, int16 height) {
g_system->init_size(width, height);
screenWide = width;
screenDeep = height;
for (i = 0; i < ARRAYSIZE(_blockSurfaces); i++)
_blockSurfaces[i] = NULL;
lpBackBuffer = (byte *) malloc(screenWide * screenDeep);
if (!lpBackBuffer)
return RDERR_OUTOFMEMORY;
return RD_OK;
for (i = 0; i < 2; i++) {
for (j = 0; j < RDMENU_MAXPOCKETS; j++) {
_icons[i][j] = NULL;
_pocketStatus[i][j] = 0;
}
// FIXME: Clean up this mess. I don't want to add any new flags, but some of
// them should be renamed. Or maybe we should abandon the whole renderCaps
// thing and simply check the numeric value of the graphics quality setting
// instead.
// Note that SetTransFx() actually clears a bit. That's intentional.
void SetTransFx(void) {
renderCaps &= ~RDBLTFX_ALLHARDWARE;
_menuStatus[i] = RDMENU_HIDDEN;
}
void ClearTransFx(void) {
renderCaps |= RDBLTFX_ALLHARDWARE;
}
/**
* Sets the edge blend and arithmetic stretching effects.
*/
void SetBltFx(void) {
renderCaps |= (RDBLTFX_EDGEBLEND | RDBLTFX_ARITHMETICSTRETCH);
}
/**
* Clears the edge blend and arithmetic stretching effects.
*/
void ClearBltFx(void) {
renderCaps &= ~(RDBLTFX_EDGEBLEND | RDBLTFX_ARITHMETICSTRETCH);
}
void SetShadowFx(void) {
renderCaps |= RDBLTFX_SHADOWBLEND;
}
void ClearShadowFx(void) {
renderCaps &= ~RDBLTFX_SHADOWBLEND;
}
/**
* @return the graphics detail setting
*/
int32 GetRenderType(void) {
if (renderCaps & RDBLTFX_ALLHARDWARE)
return 0;
if (renderCaps & (RDBLTFX_EDGEBLEND | RDBLTFX_ARITHMETICSTRETCH))
return 3;
if (renderCaps & RDBLTFX_SHADOWBLEND)
return 2;
return 1;
int8 Display::getRenderLevel(void) {
return _renderLevel;
}
void Display::setRenderLevel(int8 level) {
_renderLevel = level;
switch (_renderLevel) {
case 0:
// Lowest setting: no fancy stuff
_renderCaps = 0;
break;
case 1:
// Medium-low setting: transparency-blending
_renderCaps = RDBLTFX_SPRITEBLEND;
break;
case 2:
// Medium-high setting: transparency-blending + shading
_renderCaps = RDBLTFX_SPRITEBLEND | RDBLTFX_SHADOWBLEND;
break;
case 3:
// Highest setting: transparency-blending + shading +
// edge-blending + improved stretching
_renderCaps = RDBLTFX_SPRITEBLEND | RDBLTFX_SHADOWBLEND | RDBLTFX_EDGEBLEND;
break;
}
}
/**
* Fill the screen buffer with palette colour zero. Note that it does not
* touch the menu areas of the screen.
*/
int32 EraseBackBuffer( void ) {
memset(lpBackBuffer + MENUDEEP * screenWide, 0, screenWide * RENDERDEEP);
return RD_OK;
void Display::clearScene(void) {
memset(_buffer + MENUDEEP * _screenWide, 0, _screenWide * RENDERDEEP);
}
void MoviePlayer::openTextObject(_movieTextObject *obj) {
if (obj->textSprite)
CreateSurface(obj->textSprite, &_textSurface);
g_display->createSurface(obj->textSprite, &_textSurface);
}
void MoviePlayer::closeTextObject(_movieTextObject *obj) {
if (_textSurface) {
DeleteSurface(_textSurface);
g_display->deleteSurface(_textSurface);
_textSurface = NULL;
}
}
void MoviePlayer::drawTextObject(_movieTextObject *obj) {
if (obj->textSprite && _textSurface)
DrawSurface(obj->textSprite, _textSurface);
g_display->drawSurface(obj->textSprite, _textSurface);
}
/**
@ -161,14 +133,14 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
uint8 oldPal[1024];
uint8 tmpPal[1024];
EraseBackBuffer();
g_display->clearScene();
// HACK: Draw instructions
//
// I'm using the the menu area, because that's unlikely to be
// touched by anything else during the cutscene.
memset(lpBackBuffer, 0, screenWide * MENUDEEP);
memset(g_display->_buffer, 0, g_display->_screenWide * MENUDEEP);
uint8 msg[] = "Cutscene - Press ESC to exit";
mem *data = fontRenderer.makeTextSprite(msg, 640, 255, g_sword2->_speechFontId);
@ -176,16 +148,16 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
_spriteInfo msgSprite;
uint8 *msgSurface;
msgSprite.x = screenWide / 2 - frame->width / 2;
msgSprite.x = g_display->_screenWide / 2 - frame->width / 2;
msgSprite.y = RDMENU_MENUDEEP / 2 - frame->height / 2;
msgSprite.w = frame->width;
msgSprite.h = frame->height;
msgSprite.type = RDSPR_DISPLAYALIGN | RDSPR_NOCOMPRESSION | RDSPR_TRANS;
msgSprite.data = data->ad + sizeof(_frameHeader);
CreateSurface(&msgSprite, &msgSurface);
DrawSurface(&msgSprite, msgSurface);
DeleteSurface(msgSurface);
g_display->createSurface(&msgSprite, &msgSurface);
g_display->drawSurface(&msgSprite, msgSurface);
g_display->deleteSurface(msgSurface);
memory.freeMemory(data);
// In case the cutscene has a long lead-in, start just before
@ -201,12 +173,12 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
// The text should probably be colored the same as the rest of
// the in-game text.
memcpy(oldPal, palCopy, 1024);
memcpy(oldPal, g_display->_palCopy, 1024);
memset(tmpPal, 0, 1024);
tmpPal[255 * 4 + 0] = 255;
tmpPal[255 * 4 + 1] = 255;
tmpPal[255 * 4 + 2] = 255;
BS2_SetPalette(0, 256, tmpPal, RDPAL_INSTANT);
g_display->setPalette(0, 256, tmpPal, RDPAL_INSTANT);
PlayingSoundHandle handle = 0;
@ -217,7 +189,7 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
break;
if (frameCounter == text[textCounter]->startFrame) {
EraseBackBuffer();
g_display->clearScene();
openTextObject(text[textCounter]);
drawTextObject(text[textCounter]);
if (text[textCounter]->speech) {
@ -227,13 +199,13 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
if (frameCounter == text[textCounter]->endFrame) {
closeTextObject(text[textCounter]);
EraseBackBuffer();
g_display->clearScene();
textCounter++;
}
frameCounter++;
ServiceWindows();
g_display->updateDisplay();
_keyboardEvent ke;
@ -252,17 +224,17 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
closeTextObject(text[textCounter]);
EraseBackBuffer();
SetNeedRedraw();
g_display->clearScene();
g_display->setNeedFullRedraw();
// HACK: Remove the instructions created above
Common::Rect r;
memset(lpBackBuffer, 0, screenWide * MENUDEEP);
memset(g_display->_buffer, 0, g_display->_screenWide * MENUDEEP);
r.left = r.top = 0;
r.right = screenWide;
r.right = g_display->_screenWide;
r.bottom = MENUDEEP;
UploadRect(&r);
g_display->updateRect(&r);
// FIXME: For now, only play the lead-out music for cutscenes
// that have subtitles.
@ -270,7 +242,7 @@ int32 MoviePlayer::play(char *filename, _movieTextObject *text[], uint8 *musicOu
if (!skipCutscene)
g_sound->playLeadOut(musicOut);
BS2_SetPalette(0, 256, oldPal, RDPAL_INSTANT);
g_display->setPalette(0, 256, oldPal, RDPAL_INSTANT);
}
// Lead-in and lead-out music are, as far as I can tell, only used for

202
sword2/driver/d_draw.h
View File

@ -24,7 +24,40 @@
namespace Sword2 {
extern byte *lpBackBuffer;
// This is the maximum mouse cursor size in the SDL backend
#define MAX_MOUSE_W 80
#define MAX_MOUSE_H 80
#define RENDERAVERAGETOTAL 4
#define BLOCKWIDTH 64
#define BLOCKHEIGHT 64
#define MAXLAYERS 5
#define PALTABLESIZE 64 * 64 * 64
// Maximum scaled size of a sprite
#define SCALE_MAXWIDTH 512
#define SCALE_MAXHEIGHT 512
#if !defined(__GNUC__)
#pragma START_PACK_STRUCTS
#endif
struct _mouseAnim {
uint8 runTimeComp; // type of runtime compression used for the
// frame data
uint8 noAnimFrames; // number of frames in the anim
int8 xHotSpot;
int8 yHotSpot;
uint8 mousew;
uint8 mouseh;
} GCC_PACK;
#if !defined(__GNUC__)
#pragma END_PACK_STRUCTS
#endif
class MoviePlayer {
private:
@ -38,6 +71,173 @@ public:
int32 play(char *filename, _movieTextObject *text[], uint8 *musicOut);
};
typedef struct {
byte data[BLOCKWIDTH * BLOCKHEIGHT];
bool transparent;
} BlockSurface;
class Display {
friend class MoviePlayer;
private:
byte *_buffer;
int32 _renderCaps;
int8 _renderLevel;
uint8 _menuStatus[2];
byte *_icons[2][RDMENU_MAXPOCKETS];
uint8 _pocketStatus[2][RDMENU_MAXPOCKETS];
uint8 _iconCount;
bool _needFullRedraw;
uint8 _paletteMatch[PALTABLESIZE];
uint8 _fadePalette[256][4];
uint8 _fadeStatus;
int32 _fadeStartTime;
int32 _fadeTotalTime;
byte _mouseData[MAX_MOUSE_W * MAX_MOUSE_H];
uint8 _mouseFrame;
uint8 *_mouseSprite;
struct _mouseAnim *_mouseAnim;
struct _mouseAnim *_luggageAnim;
int32 *_mouseOffsets;
int32 *_luggageOffset;
// Scroll variables. _scrollX and _scrollY hold the current scroll
// position, and _scrollXTarget and _scrollYTarget are the target
// position for the end of the game cycle.
int16 _scrollX;
int16 _scrollY;
int16 _scrollXTarget;
int16 _scrollYTarget;
int16 _scrollXOld;
int16 _scrollYOld;
int16 _parallaxScrollX; // current x offset to link a sprite to the
// parallax layer
int16 _parallaxScrollY; // current y offset to link a sprite to the
// parallax layer
int16 _locationWide;
int16 _locationDeep;
uint16 _layer;
int32 _initialTime;
int32 _startTime;
int32 _totalTime;
int32 _renderAverageTime;
int32 _framesPerGameCycle;
bool _renderTooSlow;
uint8 _xBlocks[MAXLAYERS];
uint8 _yBlocks[MAXLAYERS];
// An array of sub-blocks, one for each of the parallax layers.
BlockSurface **_blockSurfaces[MAXLAYERS];
uint16 _xScale[SCALE_MAXWIDTH];
uint16 _yScale[SCALE_MAXHEIGHT];
uint8 *_lightMask;
void clearIconArea(int menu, int pocket, Common::Rect *r);
void decompressMouse(uint8 *decomp, uint8 *comp, int width, int height, int pitch, int xOff = 0, int yOff = 0);
void drawMouse(void);
uint8 getMatch(uint8 r, uint8 g, uint8 b);
void fadeServer(void);
void squashImage(byte *dst, uint16 dstPitch, uint16 dstWidth,
uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth,
uint16 srcHeight, byte *backbuf);
void stretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth,
uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth,
uint16 srcHeight, byte *backbuf);
void updateRect(Common::Rect *r);
void blitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clip_rect);
void mirrorSprite(uint8 *dst, uint8 *src, int16 w, int16 h);
int32 decompressRLE256(uint8 *dest, uint8 *source, int32 decompSize);
void unwindRaw16(uint8 *dest, uint8 *source, uint8 blockSize, uint8 *colTable);
int32 decompressRLE16(uint8 *dest, uint8 *source, int32 decompSize, uint8 *colTable);
public:
Display(int16 width, int16 height);
// Game screen metrics
int16 _screenWide;
int16 _screenDeep;
int16 _mouseX;
int16 _mouseY;
uint8 _palCopy[256][4];
int8 getRenderLevel(void);
void setRenderLevel(int8 level);
void clearScene(void);
void processMenu(void);
int32 showMenu(uint8 menu);
int32 hideMenu(uint8 menu);
int32 setMenuIcon(uint8 menu, uint8 pocket, uint8 *icon);
void closeMenuImmediately(void);
void updateDisplay(void);
void setWindowName(const char *windowName);
void setNeedFullRedraw(void);
void setPalette(int16 startEntry, int16 noEntries, uint8 *palette, uint8 setNow);
void updatePaletteMatchTable(uint8 *data);
uint8 quickMatch(uint8 r, uint8 g, uint8 b);
int32 fadeUp(float time = 0.75);
int32 fadeDown(float time = 0.75);
uint8 getFadeStatus(void);
void dimPalette(void);
void waitForFade(void);
int32 setMouseAnim(uint8 *ma, int32 size, int32 mouseFlash);
int32 setLuggageAnim(uint8 *la, int32 size);
int32 animateMouse(void);
void resetRenderEngine(void);
void setScrollTarget(int16 sx, int16 sy);
void initialiseRenderCycle(void);
void startRenderCycle(void);
bool endRenderCycle(void);
void renderParallax(_parallax *p, int16 layer);
void setLocationMetrics(uint16 w, uint16 h);
int32 initialiseBackgroundLayer(_parallax *p);
void closeBackgroundLayer(void);
#ifdef _SWORD2_DEBUG
void plotPoint(uint16 x, uint16 y, uint8 colour);
void drawLine(int16 x1, int16 y1, int16 x2, int16 y2, uint8 colour);
#endif
int32 createSurface(_spriteInfo *s, uint8 **surface);
void drawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect = NULL);
void deleteSurface(uint8 *surface);
int32 drawSprite(_spriteInfo *s);
int32 openLightMask(_spriteInfo *s);
int32 closeLightMask(void);
};
} // End of namespace Sword2
#endif

2
sword2/driver/d_sound.cpp
View File

@ -245,7 +245,7 @@ void Sound::playLeadOut(uint8 *leadOut) {
}
while (_fx[i]._handle) {
ServiceWindows();
g_display->updateDisplay();
g_system->delay_msecs(30);
}
}

101
sword2/driver/driver96.h
View File

@ -176,18 +176,9 @@ namespace Sword2 {
#define RDPAL_INSTANT 1
//Blitting FX defines
#define RDBLTFX_MOUSEBLT 0x01
#define RDBLTFX_FGPARALLAX 0x02
#define RDBLTFX_ARITHMETICSTRETCH 0x04
#define RDBLTFX_EDGEBLEND 0x08
#define RDBLTFX_SHADOWBLEND 0x10
#define RDBLTFX_FLATALPHA 0x20
#define RDBLTFX_GRADEDALPHA 0x40
#define RDBLTFX_ALLHARDWARE 0x80
// Maximum scaled size of a sprite
#define SCALE_MAXWIDTH 512
#define SCALE_MAXHEIGHT 512
#define RDBLTFX_SPRITEBLEND 0x01
#define RDBLTFX_SHADOWBLEND 0x02
#define RDBLTFX_EDGEBLEND 0x04
//
// Structure definitions
@ -275,29 +266,6 @@ typedef struct {
// -------------------
//
//-----------------------------------------------------------------------------
// Display functions - from d_draw.c
//-----------------------------------------------------------------------------
extern int32 InitialiseDisplay(int16 width, int16 height);
extern int32 EraseBackBuffer(void);
extern void SetTransFx(void);
extern void ClearTransFx(void);
extern void SetBltFx(void);
extern void ClearBltFx(void);
extern void ClearShadowFx(void);
extern void SetShadowFx(void);
extern int32 GetRenderType(void);
extern int32 PlaySmacker(char *filename, _movieTextObject *textObjects[], uint8 *musicOut);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Windows OS functions - from rdwin.c
//-----------------------------------------------------------------------------
extern int32 CloseAppWindow(void);
extern int32 ServiceWindows(void);
extern void SetWindowName(const char *windowName);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Language functions - from language.c
//-----------------------------------------------------------------------------
@ -305,28 +273,11 @@ extern int32 GetLanguageVersion(uint8 *version);
extern int32 SetLanguageVersion(uint8 version);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Palette functions - from palette.c
//-----------------------------------------------------------------------------
extern int32 BS2_SetPalette(int16 startEntry, int16 noEntries, uint8 *palette, uint8 setNow);
extern int32 UpdatePaletteMatchTable(uint8 *data);
extern uint8 QuickMatch(uint8 r, uint8 g, uint8 b);
extern int32 FadeUp(float time);
extern int32 FadeDown(float time);
extern uint8 GetFadeStatus(void);
extern int32 DimPalette(void);
extern void WaitForFade(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Mouse functions - from mouse.c
//-----------------------------------------------------------------------------
extern _mouseEvent *MouseEvent(void);
extern int32 SetMouseAnim(uint8 *ma, int32 size, int32 mouseFlash);
extern int32 SetLuggageAnim(uint8 *la, int32 size);
extern int32 AnimateMouse(void);
uint8 CheckForMouseEvents(void); // (James23july97)
extern void ResetRenderEngine(void);
uint8 CheckForMouseEvents(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@ -336,42 +287,6 @@ extern bool KeyWaiting(void);
extern int32 ReadKey(_keyboardEvent *ke);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Sprite functions - from sprite.c
//-----------------------------------------------------------------------------
extern int32 DrawSprite(_spriteInfo *s);
extern int32 CreateSurface(_spriteInfo *s, uint8 **surface);
extern void DrawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect = NULL);
extern void DeleteSurface(uint8 *surface);
extern int32 OpenLightMask(_spriteInfo *s);
extern int32 CloseLightMask(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Screen drawing and scrolling function - from render.c
//-----------------------------------------------------------------------------
extern int32 SetScrollTarget(int16 sx, int16 sy);
extern int32 InitialiseRenderCycle(void);
extern int32 StartRenderCycle(void);
extern int32 EndRenderCycle(bool *end);
extern int32 RenderParallax(_parallax *p, int16 layer);
extern int32 SetLocationMetrics(uint16 w, uint16 h);
extern int32 PlotPoint(uint16 x, uint16 y, uint8 colour);
extern int32 DrawLine(int16 x1, int16 y1, int16 x2, int16 y2, uint8 colour);
extern int32 InitialiseBackgroundLayer(_parallax *p);
extern int32 CloseBackgroundLayer(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Menubar control and drawing functions - from menu.c
//-----------------------------------------------------------------------------
extern int32 ProcessMenu(void);
extern int32 ShowMenu(uint8 menu);
extern int32 HideMenu(uint8 menu);
extern int32 SetMenuIcon(uint8 menu, uint8 pocket, uint8 *icon);
extern uint8 GetMenuStatus(uint8 menu);
extern int32 CloseMenuImmediately(void);
//-----------------------------------------------------------------------------
// Misc functions - from misc.cpp
//-----------------------------------------------------------------------------
@ -380,14 +295,6 @@ extern void SVM_SetFileAttributes(char *file, uint32 atrib);
extern void SVM_DeleteFile(char *file);
extern int32 SVM_GetVolumeInformation(char *cdPath, char *sCDName, uint32 maxPath, uint8 *, uint32 *dwMaxCompLength, uint32 *dwFSFlags, uint8 *, uint32 a);
//-----------------------------------------------------------------------------
extern int16 screenWide; // Width of the screen display
extern int16 screenDeep; // Height of the screen display
extern int16 mousex; // Mouse screen x coordinate
extern int16 mousey; // Mouse screen y coordinate
extern int32 renderCaps; // Flags which determine how to render the scene.
extern uint8 palCopy[256][4]; // Current palette.
} // End of namespace Sword2
#endif

164
sword2/driver/menu.cpp
View File

@ -29,23 +29,7 @@ namespace Sword2 {
#define MENUDEEP 40
#define MAXMENUANIMS 8
static uint8 menuStatus[2] = {
RDMENU_HIDDEN, RDMENU_HIDDEN
};
static byte *icons[2][RDMENU_MAXPOCKETS] = {
{ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
{ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
};
static uint8 pocketStatus[2][RDMENU_MAXPOCKETS] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
static uint8 iconCount = 0;
void ClearIconArea(int menu, int pocket, Common::Rect *r) {
void Display::clearIconArea(int menu, int pocket, Common::Rect *r) {
byte *dst;
int i;
@ -54,11 +38,11 @@ void ClearIconArea(int menu, int pocket, Common::Rect *r) {
r->left = RDMENU_ICONSTART + pocket * (RDMENU_ICONWIDE + RDMENU_ICONSPACING);
r->right = r->left + RDMENU_ICONWIDE;
dst = lpBackBuffer + r->top * screenWide + r->left;
dst = _buffer + r->top * _screenWide + r->left;
for (i = 0; i < RDMENU_ICONDEEP; i++) {
memset(dst, 0, RDMENU_ICONWIDE);
dst += screenWide;
dst += _screenWide;
}
}
@ -68,7 +52,7 @@ void ClearIconArea(int menu, int pocket, Common::Rect *r) {
* system is.
*/
int32 ProcessMenu(void) {
void Display::processMenu(void) {
byte *src, *dst;
uint8 menu;
uint8 i, j;
@ -90,84 +74,84 @@ int32 ProcessMenu(void) {
delta = 250;
frameCount = 1;
} else {
frameCount = (uint8) ((iconCount + 8) * delta / 750);
lastTime += frameCount * 750 / (iconCount + 8);
frameCount = (uint8) ((_iconCount + 8) * delta / 750);
lastTime += frameCount * 750 / (_iconCount + 8);
}
}
while (frameCount-- > 0) {
for (menu = RDMENU_TOP; menu <= RDMENU_BOTTOM; menu++) {
if (menuStatus[menu] == RDMENU_OPENING) {
if (_menuStatus[menu] == RDMENU_OPENING) {
// The menu is opening, so process it here
complete = 1;
// Propagate the animation from the first icon.
for (i = RDMENU_MAXPOCKETS - 1; i > 0; i--) {
pocketStatus[menu][i] = pocketStatus[menu][i - 1];
if (pocketStatus[menu][i] != MAXMENUANIMS)
_pocketStatus[menu][i] = _pocketStatus[menu][i - 1];
if (_pocketStatus[menu][i] != MAXMENUANIMS)
complete = 0;
}
if (pocketStatus[menu][i] != MAXMENUANIMS)
if (_pocketStatus[menu][i] != MAXMENUANIMS)
complete = 0;
// ... and animate the first icon
if (pocketStatus[menu][0] != MAXMENUANIMS)
pocketStatus[menu][0]++;
if (_pocketStatus[menu][0] != MAXMENUANIMS)
_pocketStatus[menu][0]++;
// Check to see if the menu is fully open
if (complete)
menuStatus[menu] = RDMENU_SHOWN;
} else if (menuStatus[menu] == RDMENU_CLOSING) {
_menuStatus[menu] = RDMENU_SHOWN;
} else if (_menuStatus[menu] == RDMENU_CLOSING) {
// The menu is closing, so process it here
complete = 1;
// Propagate the animation from the first icon.
for (i = RDMENU_MAXPOCKETS - 1; i > 0; i--) {
if (icons[menu][i] && pocketStatus[menu][i] != 0 && pocketStatus[menu][i - 1] == 0) {
ClearIconArea(menu, i, &r1);
UploadRect(&r1);
if (_icons[menu][i] && _pocketStatus[menu][i] != 0 && _pocketStatus[menu][i - 1] == 0) {
clearIconArea(menu, i, &r1);
updateRect(&r1);
}
pocketStatus[menu][i] = pocketStatus[menu][i - 1];
if (pocketStatus[menu][i] != 0)
_pocketStatus[menu][i] = _pocketStatus[menu][i - 1];
if (_pocketStatus[menu][i] != 0)
complete = 0;
}
if (pocketStatus[menu][i] != 0)
if (_pocketStatus[menu][i] != 0)
complete = 0;
// ... and animate the first icon
if (pocketStatus[menu][0] != 0) {
pocketStatus[menu][0]--;
if (_pocketStatus[menu][0] != 0) {
_pocketStatus[menu][0]--;
if (pocketStatus[menu][0] == 0) {
ClearIconArea(menu, 0, &r1);
UploadRect(&r1);
if (_pocketStatus[menu][0] == 0) {
clearIconArea(menu, 0, &r1);
updateRect(&r1);
}
}
// Check to see if the menu is fully closed
if (complete)
menuStatus[menu] = RDMENU_HIDDEN;
_menuStatus[menu] = RDMENU_HIDDEN;
}
}
}
// Does the menu need to be drawn?
for (menu = RDMENU_TOP; menu <= RDMENU_BOTTOM; menu++) {
if (menuStatus[menu] != RDMENU_HIDDEN) {
if (_menuStatus[menu] != RDMENU_HIDDEN) {
// Draw the menu here.
curx = RDMENU_ICONSTART + RDMENU_ICONWIDE / 2;
cury = (MENUDEEP / 2) + (RENDERDEEP + MENUDEEP) * menu;
for (i = 0; i < RDMENU_MAXPOCKETS; i++) {
if (icons[menu][i]) {
if (_icons[menu][i]) {
// Since we no longer clear the screen
// after each frame we need to clear
// the icon area.
ClearIconArea(menu, i, &r1);
clearIconArea(menu, i, &r1);
if (pocketStatus[menu][i] == MAXMENUANIMS) {
if (_pocketStatus[menu][i] == MAXMENUANIMS) {
xoff = (RDMENU_ICONWIDE / 2);
r2.left = curx - xoff;
r2.right = r2.left + RDMENU_ICONWIDE;
@ -175,30 +159,30 @@ int32 ProcessMenu(void) {
r2.top = cury - yoff;
r2.bottom = r2.top + RDMENU_ICONDEEP;
} else {
xoff = (RDMENU_ICONWIDE / 2) * pocketStatus[menu][i] / MAXMENUANIMS;
xoff = (RDMENU_ICONWIDE / 2) * _pocketStatus[menu][i] / MAXMENUANIMS;
r2.left = curx - xoff;
r2.right = curx + xoff;
yoff = (RDMENU_ICONDEEP / 2) * pocketStatus[menu][i] / MAXMENUANIMS;
yoff = (RDMENU_ICONDEEP / 2) * _pocketStatus[menu][i] / MAXMENUANIMS;
r2.top = cury - yoff;
r2.bottom = cury + yoff;
}
if (xoff != 0 && yoff != 0) {
dst = lpBackBuffer + r2.top * screenWide + r2.left;
src = icons[menu][i];
dst = _buffer + r2.top * _screenWide + r2.left;
src = _icons[menu][i];
if (pocketStatus[menu][i] != MAXMENUANIMS) {
SquashImage(
dst, screenWide, r2.right - r2.left, r2.bottom - r2.top,
if (_pocketStatus[menu][i] != MAXMENUANIMS) {
squashImage(
dst, _screenWide, r2.right - r2.left, r2.bottom - r2.top,
src, RDMENU_ICONWIDE, RDMENU_ICONWIDE, RDMENU_ICONDEEP, NULL);
} else {
for (j = 0; j < RDMENU_ICONDEEP; j++) {
memcpy(dst, src, RDMENU_ICONWIDE);
src += RDMENU_ICONWIDE;
dst += screenWide;
dst += _screenWide;
}
}
UploadRect(&r1);
updateRect(&r1);
}
}
curx += (RDMENU_ICONSPACING + RDMENU_ICONWIDE);
@ -207,8 +191,6 @@ int32 ProcessMenu(void) {
}
}
}
return RD_OK;
}
/**
@ -217,17 +199,17 @@ int32 ProcessMenu(void) {
* @return RD_OK, or an error code
*/
int32 ShowMenu(uint8 menu) {
int32 Display::showMenu(uint8 menu) {
// Check for invalid menu parameter
if (menu > RDMENU_BOTTOM)
return RDERR_INVALIDMENU;
// Check that the menu is not currently shown, or in the process of
// being shown.
if (menuStatus[menu] == RDMENU_SHOWN || menuStatus[menu] == RDMENU_OPENING)
if (_menuStatus[menu] == RDMENU_SHOWN || _menuStatus[menu] == RDMENU_OPENING)
return RDERR_INVALIDCOMMAND;
menuStatus[menu] = RDMENU_OPENING;
_menuStatus[menu] = RDMENU_OPENING;
return RD_OK;
}
@ -237,17 +219,17 @@ int32 ShowMenu(uint8 menu) {
* @return RD_OK, or an error code
*/
int32 HideMenu(uint8 menu) {
int32 Display::hideMenu(uint8 menu) {
// Check for invalid menu parameter
if (menu > RDMENU_BOTTOM)
return RDERR_INVALIDMENU;
// Check that the menu is not currently hidden, or in the process of
// being hidden.
if (menuStatus[menu] == RDMENU_HIDDEN || menuStatus[menu] == RDMENU_CLOSING)
if (_menuStatus[menu] == RDMENU_HIDDEN || _menuStatus[menu] == RDMENU_CLOSING)
return RDERR_INVALIDCOMMAND;
menuStatus[menu] = RDMENU_CLOSING;
_menuStatus[menu] = RDMENU_CLOSING;
return RD_OK;
}
@ -255,26 +237,25 @@ int32 HideMenu(uint8 menu) {
* This function hides both menus immediately.
*/
int32 CloseMenuImmediately(void) {
void Display::closeMenuImmediately(void) {
Common::Rect r;
int i;
menuStatus[0] = RDMENU_HIDDEN;
menuStatus[1] = RDMENU_HIDDEN;
_menuStatus[0] = RDMENU_HIDDEN;
_menuStatus[1] = RDMENU_HIDDEN;
for (i = 0; i < RDMENU_MAXPOCKETS; i++) {
if (icons[0][i]) {
ClearIconArea(0, i, &r);
UploadRect(&r);
if (_icons[0][i]) {
clearIconArea(0, i, &r);
updateRect(&r);
}
if (icons[1][i]) {
ClearIconArea(1, i, &r);
UploadRect(&r);
if (_icons[1][i]) {
clearIconArea(1, i, &r);
updateRect(&r);
}
}
memset(pocketStatus, 0, sizeof(uint8) * 2 * RDMENU_MAXPOCKETS);
return RD_OK;
memset(_pocketStatus, 0, sizeof(uint8) * 2 * RDMENU_MAXPOCKETS);
}
/**
@ -285,11 +266,9 @@ int32 CloseMenuImmediately(void) {
* @return RD_OK, or an error code
*/
int32 SetMenuIcon(uint8 menu, uint8 pocket, uint8 *icon) {
int32 Display::setMenuIcon(uint8 menu, uint8 pocket, uint8 *icon) {
Common::Rect r;
debug(5, "stub SetMenuIcon( %d, %d )", menu, pocket);
// Check for invalid menu parameter.
if (menu > RDMENU_BOTTOM)
return RDERR_INVALIDMENU;
@ -299,33 +278,24 @@ int32 SetMenuIcon(uint8 menu, uint8 pocket, uint8 *icon) {
return RDERR_INVALIDPOCKET;
// If there is an icon in the requested menu/pocket, clear it out.
if (icons[menu][pocket]) {
iconCount--;
free(icons[menu][pocket]);
icons[menu][pocket] = NULL;
ClearIconArea(menu, pocket, &r);
UploadRect(&r);
if (_icons[menu][pocket]) {
_iconCount--;
free(_icons[menu][pocket]);
_icons[menu][pocket] = NULL;
clearIconArea(menu, pocket, &r);
updateRect(&r);
}
// Only put the icon in the pocket if it is not NULL
if (icon != NULL) {
iconCount++;
icons[menu][pocket] = (uint8 *) malloc(RDMENU_ICONWIDE * RDMENU_ICONDEEP);
if (icons[menu][pocket] == NULL)
_iconCount++;
_icons[menu][pocket] = (uint8 *) malloc(RDMENU_ICONWIDE * RDMENU_ICONDEEP);
if (_icons[menu][pocket] == NULL)
return RDERR_OUTOFMEMORY;
memcpy(icons[menu][pocket], icon, RDMENU_ICONWIDE * RDMENU_ICONDEEP);
memcpy(_icons[menu][pocket], icon, RDMENU_ICONWIDE * RDMENU_ICONDEEP);
}
return RD_OK;
}
/**
* @return The status of the menu
*/
uint8 GetMenuStatus(uint8 menu) {
if (menu > RDMENU_BOTTOM)
return RDMENU_HIDDEN;
return menuStatus[menu];
}
} // End of namespace Sword2

140
sword2/driver/palette.cpp
View File

@ -20,54 +20,31 @@
#include "stdafx.h"
#include "common/util.h"
#include "base/engine.h"
#include "bs2/sword2.h"
#include "bs2/driver/d_draw.h"
#include "bs2/driver/driver96.h"
#include "bs2/sword2.h"
namespace Sword2 {
#define PALTABLESIZE 64 * 64 * 64
uint8 palCopy[256][4];
static uint8 fadePalette[256][4];
static uint8 paletteMatch[PALTABLESIZE];
static uint8 fadeStatus = RDFADE_NONE;
static int32 fadeStartTime;
static int32 fadeTotalTime;
// --------------------------------------------------------------------------
// int32 RestorePalette(void)
//
// This function restores the palette, and should be called whenever the
// screen mode changes, or something like that.
// --------------------------------------------------------------------------
int32 RestorePalette(void) {
g_system->set_palette((const byte *) palCopy, 0, 256);
return RD_OK;
}
uint8 GetMatch(uint8 r, uint8 g, uint8 b) {
uint8 Display::getMatch(uint8 r, uint8 g, uint8 b) {
int32 diff;
int32 min;
int16 diffred, diffgreen, diffblue;
int16 i;
uint8 minIndex;
diffred = palCopy[0][0] - r;
diffgreen = palCopy[0][1] - g;
diffblue = palCopy[0][2] - b;
diffred = _palCopy[0][0] - r;
diffgreen = _palCopy[0][1] - g;
diffblue = _palCopy[0][2] - b;
diff = diffred * diffred + diffgreen * diffgreen + diffblue * diffblue;
min = diff;
minIndex = 0;
if (diff > 0) {
for (i = 1; i < 256; i++) {
diffred = palCopy[i][0] - r;
diffgreen = palCopy[i][1] - g;
diffblue = palCopy[i][2] - b;
diffred = _palCopy[i][0] - r;
diffgreen = _palCopy[i][1] - g;
diffblue = _palCopy[i][2] - b;
diff = diffred * diffred + diffgreen * diffgreen + diffblue * diffblue;
if (diff < min) {
@ -90,7 +67,7 @@ uint8 GetMatch(uint8 r, uint8 g, uint8 b) {
* from the current palCopy
*/
int32 UpdatePaletteMatchTable(uint8 *data) {
void Display::updatePaletteMatchTable(uint8 *data) {
if (!data) {
int16 red, green, blue;
uint8 *p;
@ -99,20 +76,18 @@ int32 UpdatePaletteMatchTable(uint8 *data) {
// FIXME: Does this case ever happen?
p = &paletteMatch[0];
p = &_paletteMatch[0];
for (red = 0; red < 256; red += 4) {
for (green = 0; green < 256; green += 4) {
for (blue = 0; blue < 256; blue += 4) {
*p++ = GetMatch((uint8) red, (uint8) green, (uint8) blue);
*p++ = getMatch((uint8) red, (uint8) green, (uint8) blue);
}
}
}
} else {
// The provided data is the new palette match table
memcpy(paletteMatch, data, PALTABLESIZE);
memcpy(_paletteMatch, data, PALTABLESIZE);
}
return RD_OK;
}
/**
@ -126,8 +101,8 @@ int32 UpdatePaletteMatchTable(uint8 *data) {
// FIXME: This used to be inlined - probably a good idea - but the
// linker complained when I tried to use it in sprite.cpp.
uint8 QuickMatch(uint8 r, uint8 g, uint8 b) {
return paletteMatch[((int32) (r >> 2) << 12) + ((int32) (g >> 2) << 6) + (b >> 2)];
uint8 Display::quickMatch(uint8 r, uint8 g, uint8 b) {
return _paletteMatch[((int32) (r >> 2) << 12) + ((int32) (g >> 2) << 6) + (b >> 2)];
}
/**
@ -137,27 +112,22 @@ uint8 QuickMatch(uint8 r, uint8 g, uint8 b) {
* @param colourTable the new colour entries
*/
int32 BS2_SetPalette(int16 startEntry, int16 noEntries, uint8 *colourTable, uint8 fadeNow) {
if (noEntries == 0) {
RestorePalette();
return RD_OK;
}
memcpy(&palCopy[startEntry][0], colourTable, noEntries * 4);
void Display::setPalette(int16 startEntry, int16 noEntries, uint8 *colourTable, uint8 fadeNow) {
if (noEntries) {
memcpy(&_palCopy[startEntry][0], colourTable, noEntries * 4);
if (fadeNow == RDPAL_INSTANT)
g_system->set_palette((byte *) palCopy, startEntry, noEntries);
return RD_OK;
g_system->set_palette((const byte *) _palCopy, startEntry, noEntries);
} else
g_system->set_palette((const byte *) _palCopy, 0, 256);
}
int32 DimPalette(void) {
byte *p = (byte *) palCopy;
void Display::dimPalette(void) {
byte *p = (byte *) _palCopy;
for (int i = 0; i < 256 * 4; i++)
p[i] /= 2;
g_system->set_palette(p, 0, 256);
return RD_OK;
}
/**
@ -165,13 +135,13 @@ int32 DimPalette(void) {
* @param time the time it will take the palette to fade up
*/
int32 FadeUp(float time) {
if (fadeStatus != RDFADE_BLACK && fadeStatus != RDFADE_NONE)
int32 Display::fadeUp(float time) {
if (getFadeStatus() != RDFADE_BLACK && getFadeStatus() != RDFADE_NONE)
return RDERR_FADEINCOMPLETE;
fadeTotalTime = (int32) (time * 1000);
fadeStatus = RDFADE_UP;
fadeStartTime = SVM_timeGetTime();
_fadeTotalTime = (int32) (time * 1000);
_fadeStatus = RDFADE_UP;
_fadeStartTime = SVM_timeGetTime();
return RD_OK;
}
@ -181,13 +151,13 @@ int32 FadeUp(float time) {
* @param time the time it will take the palette to fade down
*/
int32 FadeDown(float time) {
if (fadeStatus != RDFADE_BLACK && fadeStatus != RDFADE_NONE)
int32 Display::fadeDown(float time) {
if (getFadeStatus() != RDFADE_BLACK && getFadeStatus() != RDFADE_NONE)
return RDERR_FADEINCOMPLETE;
fadeTotalTime = (int32) (time * 1000);
fadeStatus = RDFADE_DOWN;
fadeStartTime = SVM_timeGetTime();
_fadeTotalTime = (int32) (time * 1000);
_fadeStatus = RDFADE_DOWN;
_fadeStartTime = SVM_timeGetTime();
return RD_OK;
}
@ -198,20 +168,20 @@ int32 FadeDown(float time) {
* (not faded), or RDFADE_BLACK (completely faded down)
*/
uint8 GetFadeStatus(void) {
return fadeStatus;
uint8 Display::getFadeStatus(void) {
return _fadeStatus;
}
void WaitForFade(void) {
while (GetFadeStatus() != RDFADE_NONE && GetFadeStatus() != RDFADE_BLACK) {
ServiceWindows();
void Display::waitForFade(void) {
while (getFadeStatus() != RDFADE_NONE && getFadeStatus() != RDFADE_BLACK) {
updateDisplay();
g_system->delay_msecs(20);
}
}
void FadeServer() {
void Display::fadeServer(void) {
static int32 previousTime = 0;
const byte *newPalette = (const byte *) fadePalette;
const byte *newPalette = (const byte *) _fadePalette;
int32 currentTime;
int16 fadeMultiplier;
int16 i;
@ -221,7 +191,7 @@ void FadeServer() {
// actually update the screen.
// If we're not in the process of fading, do nothing.
if (fadeStatus != RDFADE_UP && fadeStatus != RDFADE_DOWN)
if (getFadeStatus() != RDFADE_UP && getFadeStatus() != RDFADE_DOWN)
return;
// I don't know if this is necessary, but let's limit how often the
@ -232,28 +202,28 @@ void FadeServer() {
previousTime = currentTime;
if (fadeStatus == RDFADE_UP) {
if (currentTime >= fadeStartTime + fadeTotalTime) {
fadeStatus = RDFADE_NONE;
newPalette = (const byte *) palCopy;
if (getFadeStatus() == RDFADE_UP) {
if (currentTime >= _fadeStartTime + _fadeTotalTime) {
_fadeStatus = RDFADE_NONE;
newPalette = (const byte *) _palCopy;
} else {
fadeMultiplier = (int16) (((int32) (currentTime - fadeStartTime) * 256) / fadeTotalTime);
fadeMultiplier = (int16) (((int32) (currentTime - _fadeStartTime) * 256) / _fadeTotalTime);
for (i = 0; i < 256; i++) {
fadePalette[i][0] = (palCopy[i][0] * fadeMultiplier) >> 8;
fadePalette[i][1] = (palCopy[i][1] * fadeMultiplier) >> 8;
fadePalette[i][2] = (palCopy[i][2] * fadeMultiplier) >> 8;
_fadePalette[i][0] = (_palCopy[i][0] * fadeMultiplier) >> 8;
_fadePalette[i][1] = (_palCopy[i][1] * fadeMultiplier) >> 8;
_fadePalette[i][2] = (_palCopy[i][2] * fadeMultiplier) >> 8;
}
}
} else {
if (currentTime >= fadeStartTime + fadeTotalTime) {
fadeStatus = RDFADE_BLACK;
memset(fadePalette, 0, sizeof(fadePalette));
if (currentTime >= _fadeStartTime + _fadeTotalTime) {
_fadeStatus = RDFADE_BLACK;
memset(_fadePalette, 0, sizeof(_fadePalette));
} else {
fadeMultiplier = (int16) (((int32) (fadeTotalTime - (currentTime - fadeStartTime)) * 256) / fadeTotalTime);
fadeMultiplier = (int16) (((int32) (_fadeTotalTime - (currentTime - _fadeStartTime)) * 256) / _fadeTotalTime);
for (i = 0; i < 256; i++) {
fadePalette[i][0] = (palCopy[i][0] * fadeMultiplier) >> 8;
fadePalette[i][1] = (palCopy[i][1] * fadeMultiplier) >> 8;
fadePalette[i][2] = (palCopy[i][2] * fadeMultiplier) >> 8;
_fadePalette[i][0] = (_palCopy[i][0] * fadeMultiplier) >> 8;
_fadePalette[i][1] = (_palCopy[i][1] * fadeMultiplier) >> 8;
_fadePalette[i][2] = (_palCopy[i][2] * fadeMultiplier) >> 8;
}
}
}

5
sword2/driver/palette.h
View File

@ -22,11 +22,6 @@
namespace Sword2 {
extern uint8 paletteMatch[64*64*64];
extern int32 RestorePalette(void);
extern void FadeServer();
} // End of namespace Sword2
#endif

39
sword2/driver/rdwin.cpp
View File

@ -44,8 +44,8 @@ void Sword2Engine::parseEvents() {
WriteKey(event.kbd.ascii, event.kbd.keycode, event.kbd.flags);
break;
case OSystem::EVENT_MOUSEMOVE:
mousex = event.mouse.x;
mousey = event.mouse.y - MENUDEEP;
g_display->_mouseX = event.mouse.x;
g_display->_mouseY = event.mouse.y - MENUDEEP;
break;
case OSystem::EVENT_LBUTTONDOWN:
LogMouseEvent(RD_LEFTBUTTONDOWN);
@ -61,7 +61,6 @@ void Sword2Engine::parseEvents() {
break;
case OSystem::EVENT_QUIT:
Close_game();
CloseAppWindow();
break;
default:
break;
@ -69,24 +68,8 @@ void Sword2Engine::parseEvents() {
}
}
/**
* Quit the game.
*/
int32 CloseAppWindow(void) {
warning("stub CloseAppWindow");
/*
DestroyWindow(hwnd);
*/
// just quit for now
g_system->quit();
return RD_OK;
}
static bool _needRedraw = false;
void SetNeedRedraw() {
_needRedraw = true;
void Display::setNeedFullRedraw() {
_needFullRedraw = true;
}
/**
@ -94,29 +77,27 @@ void SetNeedRedraw() {
* windows and the interface it provides.
*/
int32 ServiceWindows(void) {
void Display::updateDisplay(void) {
g_sword2->parseEvents();
FadeServer();
fadeServer();
// FIXME: We re-render the entire picture area of the screen for each
// frame, which is pretty horrible.
if (_needRedraw) {
g_system->copy_rect(lpBackBuffer + MENUDEEP * screenWide, screenWide, 0, MENUDEEP, screenWide, screenDeep - 2 * MENUDEEP);
_needRedraw = false;
if (_needFullRedraw) {
g_system->copy_rect(_buffer + MENUDEEP * _screenWide, _screenWide, 0, MENUDEEP, _screenWide, _screenDeep - 2 * MENUDEEP);
_needFullRedraw = false;
}
// We still need to update because of fades, menu animations, etc.
g_system->update_screen();
return RD_OK;
}
/**
* Set the window title
*/
void SetWindowName(const char *windowName) {
void Display::setWindowName(const char *windowName) {
OSystem::Property prop;
prop.caption = windowName;

2
sword2/driver/rdwin.h
View File

@ -22,8 +22,6 @@
namespace Sword2 {
extern void SetNeedRedraw(void);
} // End of namespace Sword2
#endif

359
sword2/driver/render.cpp
View File

@ -30,58 +30,16 @@ namespace Sword2 {
#define MILLISECSPERCYCLE 83
// Scroll variables. scrollx and scrolly hold the current scroll position,
// and scrollxTarget and scrollyTarget are the target position for the end
// of the game cycle.
extern int16 scrollx;
extern int16 scrolly;
int16 parallaxScrollx;
int16 parallaxScrolly;
int16 locationWide;
int16 locationDeep;
static int16 scrollxTarget;
static int16 scrollyTarget;
static int16 scrollxOld;
static int16 scrollyOld;
static uint16 layer = 0;
#define RENDERAVERAGETOTAL 4
static int32 renderCountIndex = 0;
static int32 renderTimeLog[RENDERAVERAGETOTAL] = { 60, 60, 60, 60 };
static int32 initialTime;
static int32 startTime;
static int32 totalTime;
static int32 renderAverageTime = 60;
static int32 framesPerGameCycle;
static int32 renderTooSlow;
#define BLOCKWIDTH 64
#define BLOCKHEIGHT 64
#define BLOCKWBITS 6
#define BLOCKHBITS 6
#define MAXLAYERS 5
static uint8 xblocks[MAXLAYERS];
static uint8 yblocks[MAXLAYERS];
// blockSurfaces stores an array of sub-blocks for each of the parallax layers.
typedef struct {
byte data[BLOCKWIDTH * BLOCKHEIGHT];
bool transparent;
} BlockSurface;
static BlockSurface **blockSurfaces[MAXLAYERS] = { 0, 0, 0, 0, 0 };
void UploadRect(Common::Rect *r) {
g_system->copy_rect(lpBackBuffer + r->top * screenWide + r->left,
screenWide, r->left, r->top, r->right - r->left, r->bottom - r->top);
void Display::updateRect(Common::Rect *r) {
g_system->copy_rect(_buffer + r->top * _screenWide + r->left,
_screenWide, r->left, r->top, r->right - r->left,
r->bottom - r->top);
}
void BlitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clip_rect) {
void Display::blitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clip_rect) {
if (r->top > clip_rect->bottom || r->left > clip_rect->right || r->bottom <= clip_rect->top || r->right <= clip_rect->left)
return;
@ -100,7 +58,7 @@ void BlitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clip_rect)
if (r->right > clip_rect->right)
r->right = clip_rect->right;
byte *dst = lpBackBuffer + r->top * screenWide + r->left;
byte *dst = _buffer + r->top * _screenWide + r->left;
int i, j;
if (s->transparent) {
@ -110,23 +68,20 @@ void BlitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clip_rect)
dst[j] = src[j];
}
src += BLOCKWIDTH;
dst += screenWide;
dst += _screenWide;
}
} else {
for (i = 0; i < r->bottom - r->top; i++) {
memcpy(dst, src, r->right - r->left);
src += BLOCKWIDTH;
dst += screenWide;
dst += _screenWide;
}
}
// UploadRect(r);
SetNeedRedraw();
g_display->setNeedFullRedraw();
}
static uint16 xScale[SCALE_MAXWIDTH];
static uint16 yScale[SCALE_MAXHEIGHT];
// I've made the scaling two separate functions because there were cases from
// DrawSprite() where it wasn't obvious if the sprite should grow or shrink,
// which caused crashes.
@ -140,7 +95,7 @@ static uint16 yScale[SCALE_MAXHEIGHT];
// be drawn. This is only used at the highest graphics detail setting (and not
// always even then) and is used to help anti-alias the image.
void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) {
void Display::squashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) {
int32 ince, incne, d;
int16 x, y;
@ -150,7 +105,7 @@ void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
incne = 2 * (dstWidth - srcWidth);
d = 2 * dstWidth - srcWidth;
x = y = 0;
xScale[y] = x;
_xScale[y] = x;
while (x < srcWidth) {
if (d <= 0) {
@ -161,7 +116,7 @@ void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
x++;
y++;
}
xScale[y] = x;
_xScale[y] = x;
}
// Work out the y-scale
@ -170,7 +125,7 @@ void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
incne = 2 * (dstHeight - srcHeight);
d = 2 * dstHeight - srcHeight;
x = y = 0;
yScale[y] = x;
_yScale[y] = x;
while (x < srcHeight) {
if (d <= 0) {
@ -181,7 +136,7 @@ void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
x++;
y++;
}
yScale[y] = x;
_yScale[y] = x;
}
// Copy the image (with or without anti-aliasing)
@ -198,19 +153,19 @@ void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
int blue = 0;
int i, j;
for (j = yScale[y]; j < yScale[y + 1]; j++) {
for (i = xScale[x]; i < xScale[x + 1]; i++) {
for (j = _yScale[y]; j < _yScale[y + 1]; j++) {
for (i = _xScale[x]; i < _xScale[x + 1]; i++) {
p = src[j * srcPitch + i];
if (p) {
red += palCopy[p][0];
green += palCopy[p][1];
blue += palCopy[p][2];
red += _palCopy[p][0];
green += _palCopy[p][1];
blue += _palCopy[p][2];
p1 = p;
spriteCount++;
} else {
red += palCopy[backbuf[x]][0];
green += palCopy[backbuf[x]][1];
blue += palCopy[backbuf[x]][2];
red += _palCopy[backbuf[x]][0];
green += _palCopy[backbuf[x]][1];
blue += _palCopy[backbuf[x]][2];
}
count++;
}
@ -220,22 +175,22 @@ void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
else if (spriteCount == 1)
dst[x] = p1;
else
dst[x] = QuickMatch((uint8) (red / count), (uint8) (green / count), (uint8) (blue / count));
dst[x] = quickMatch((uint8) (red / count), (uint8) (green / count), (uint8) (blue / count));
}
dst += dstPitch;
backbuf += screenWide;
backbuf += _screenWide;
}
} else {
for (y = 0; y < dstHeight; y++) {
for (x = 0; x < dstWidth; x++) {
dst[x] = src[yScale[y] * srcPitch + xScale[x]];
dst[x] = src[_yScale[y] * srcPitch + _xScale[x]];
}
dst += dstPitch;
}
}
}
void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) {
void Display::stretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) {
byte *origDst = dst;
int32 ince, incne, d;
int16 x, y, i, j, k;
@ -246,7 +201,7 @@ void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
incne = 2 * (srcWidth - dstWidth);
d = 2 * srcWidth - dstWidth;
x = y = 0;
xScale[y] = x;
_xScale[y] = x;
while (x < dstWidth) {
if (d <= 0) {
@ -256,7 +211,7 @@ void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
d += incne;
x++;
y++;
xScale[y] = x;
_xScale[y] = x;
}
}
@ -266,7 +221,7 @@ void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
incne = 2 * (srcHeight - dstHeight);
d = 2 * srcHeight - dstHeight;
x = y = 0;
yScale[y] = x;
_yScale[y] = x;
while (x < dstHeight) {
if (d <= 0) {
d += ince;
@ -275,17 +230,17 @@ void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
d += incne;
x++;
y++;
yScale[y] = x;
_yScale[y] = x;
}
}
// Copy the image
for (y = 0; y < srcHeight; y++) {
for (j = yScale[y]; j < yScale[y + 1]; j++) {
for (j = _yScale[y]; j < _yScale[y + 1]; j++) {
k = 0;
for (x = 0; x < srcWidth; x++) {
for (i = xScale[x]; i < xScale[x + 1]; i++) {
for (i = _xScale[x]; i < _xScale[x + 1]; i++) {
dst[k++] = src[y * srcPitch + x];
}
}
@ -342,16 +297,16 @@ void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
count++;
if (count) {
int red = palCopy[pt[0]][0] << 2;
int green = palCopy[pt[0]][1] << 2;
int blue = palCopy[pt[0]][2] << 2;
int red = _palCopy[pt[0]][0] << 2;
int green = _palCopy[pt[0]][1] << 2;
int blue = _palCopy[pt[0]][2] << 2;
for (i = 1; i < 5; i++) {
red += palCopy[pt[i]][0];
green += palCopy[pt[i]][1];
blue += palCopy[pt[i]][2];
red += _palCopy[pt[i]][0];
green += _palCopy[pt[i]][1];
blue += _palCopy[pt[i]][2];
}
*dst++ = QuickMatch((uint8) (red >> 3), (uint8) (green >> 3), (uint8) (blue >> 3));
*dst++ = quickMatch((uint8) (red >> 3), (uint8) (green >> 3), (uint8) (blue >> 3));
} else
*dst++ = 0;
src++;
@ -373,27 +328,7 @@ void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight,
}
}
int32 RestoreBackgroundLayer(_parallax *p, int16 l)
{
int16 oldLayer = layer;
debug(2, "RestoreBackgroundLayer %d", l);
layer = l;
if (blockSurfaces[l]) {
for (int i = 0; i < xblocks[l] * yblocks[l]; i++) {
if (blockSurfaces[l][i])
free(blockSurfaces[l][i]);
}
free(blockSurfaces[l]);
blockSurfaces[l] = NULL;
}
InitialiseBackgroundLayer(p);
layer = oldLayer;
return RD_OK;
}
#ifdef _SWORD2_DEBUG
/**
* Plots a point relative to the top left corner of the screen. This is only
* used for debugging.
@ -402,17 +337,15 @@ int32 RestoreBackgroundLayer(_parallax *p, int16 l)
* @param colour colour of the point
*/
int32 PlotPoint(uint16 x, uint16 y, uint8 colour) {
uint8 *buf = lpBackBuffer + 40 * RENDERWIDE;
void Display::plotPoint(uint16 x, uint16 y, uint8 colour) {
uint8 *buf = _buffer + 40 * RENDERWIDE;
int16 newx, newy;
newx = x - scrollx;
newy = y - scrolly;
newx = x - _scrollX;
newy = y - _scrollY;
if (newx >= 0 && newx < RENDERWIDE && newy >= 0 && newy < RENDERDEEP)
buf[newy * RENDERWIDE + newx] = colour;
return RD_OK;
}
/**
@ -425,8 +358,8 @@ int32 PlotPoint(uint16 x, uint16 y, uint8 colour) {
*/
// Uses Bressnham's incremental algorithm!
int32 DrawLine(int16 x0, int16 y0, int16 x1, int16 y1, uint8 colour) {
uint8 *buf = lpBackBuffer + 40 * RENDERWIDE;
void Display::drawLine(int16 x0, int16 y0, int16 x1, int16 y1, uint8 colour) {
uint8 *buf = _buffer + 40 * RENDERWIDE;
int dx, dy;
int dxmod, dymod;
int ince, incne;
@ -434,10 +367,10 @@ int32 DrawLine(int16 x0, int16 y0, int16 x1, int16 y1, uint8 colour) {
int x, y;
int addTo;
x1 -= scrollx;
y1 -= scrolly;
x0 -= scrollx;
y0 -= scrolly;
x1 -= _scrollX;
y1 -= _scrollY;
x0 -= _scrollX;
y0 -= _scrollY;
// Lock the surface if we're rendering to the back buffer.
@ -579,9 +512,8 @@ int32 DrawLine(int16 x0, int16 y0, int16 x1, int16 y1, uint8 colour) {
}
}
}
return RD_OK;
}
#endif
/**
* This function tells the driver the size of the background screen for the
@ -590,11 +522,9 @@ int32 DrawLine(int16 x0, int16 y0, int16 x1, int16 y1, uint8 colour) {
* @param h height of the current location
*/
int32 SetLocationMetrics(uint16 w, uint16 h) {
locationWide = w;
locationDeep = h;
return RD_OK;
void Display::setLocationMetrics(uint16 w, uint16 h) {
_locationWide = w;
_locationDeep = h;
}
/**
@ -602,45 +532,43 @@ int32 SetLocationMetrics(uint16 w, uint16 h) {
* parallax can be either foreground, background or the main screen.
*/
int32 RenderParallax(_parallax *p, int16 l) {
void Display::renderParallax(_parallax *p, int16 l) {
int16 x, y;
Common::Rect r;
if (locationWide == screenWide)
if (_locationWide == _screenWide)
x = 0;
else
x = ((int32) ((p->w - screenWide) * scrollx) / (int32) (locationWide - screenWide));
x = ((int32) ((p->w - _screenWide) * _scrollX) / (int32) (_locationWide - _screenWide));
if (locationDeep == (screenDeep - MENUDEEP * 2))
if (_locationDeep == _screenDeep - MENUDEEP * 2)
y = 0;
else
y = ((int32) ((p->h - (screenDeep - MENUDEEP * 2)) * scrolly) / (int32) (locationDeep - (screenDeep - MENUDEEP * 2)));
y = ((int32) ((p->h - (_screenDeep - MENUDEEP * 2)) * _scrollY) / (int32) (_locationDeep - (_screenDeep - MENUDEEP * 2)));
Common::Rect clip_rect;
// Leave enough space for the top and bottom menues
clip_rect.left = 0;
clip_rect.right = screenWide;
clip_rect.right = _screenWide;
clip_rect.top = MENUDEEP;
clip_rect.bottom = screenDeep - MENUDEEP;
clip_rect.bottom = _screenDeep - MENUDEEP;
for (int j = 0; j < yblocks[l]; j++) {
for (int i = 0; i < xblocks[l]; i++) {
if (blockSurfaces[l][i + j * xblocks[l]]) {
for (int j = 0; j < _yBlocks[l]; j++) {
for (int i = 0; i < _xBlocks[l]; i++) {
if (_blockSurfaces[l][i + j * _xBlocks[l]]) {
r.left = i * BLOCKWIDTH - x;
r.right = r.left + BLOCKWIDTH;
r.top = j * BLOCKHEIGHT - y + 40;
r.bottom = r.top + BLOCKHEIGHT;
BlitBlockSurface(blockSurfaces[l][i + j * xblocks[l]], &r, &clip_rect);
blitBlockSurface(_blockSurfaces[l][i + j * _xBlocks[l]], &r, &clip_rect);
}
}
}
parallaxScrollx = scrollx - x;
parallaxScrolly = scrolly - y;
return RD_OK;
_parallaxScrollX = _scrollX - x;
_parallaxScrollY = _scrollY - y;
}
// Uncomment this when benchmarking the drawing routines.
@ -650,10 +578,9 @@ int32 RenderParallax(_parallax *p, int16 l) {
* Initialises the timers before the render loop is entered.
*/
int32 InitialiseRenderCycle(void) {
initialTime = SVM_timeGetTime();
totalTime = initialTime + MILLISECSPERCYCLE;
return RD_OK;
void Display::initialiseRenderCycle(void) {
_initialTime = SVM_timeGetTime();
_totalTime = _initialTime + MILLISECSPERCYCLE;
}
/**
@ -661,24 +588,23 @@ int32 InitialiseRenderCycle(void) {
* render cycle.
*/
int32 StartRenderCycle(void) {
scrollxOld = scrollx;
scrollyOld = scrolly;
void Display::startRenderCycle(void) {
_scrollXOld = _scrollX;
_scrollYOld = _scrollY;
startTime = SVM_timeGetTime();
_startTime = SVM_timeGetTime();
if (startTime + renderAverageTime >= totalTime) {
scrollx = scrollxTarget;
scrolly = scrollyTarget;
renderTooSlow = 1;
if (_startTime + _renderAverageTime >= _totalTime) {
_scrollX = _scrollXTarget;
_scrollY = _scrollYTarget;
_renderTooSlow = true;
} else {
scrollx = (int16) (scrollxOld + ((scrollxTarget - scrollxOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime));
scrolly = (int16) (scrollyOld + ((scrollyTarget - scrollyOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime));
renderTooSlow = 0;
_scrollX = (int16) (_scrollXOld + ((_scrollXTarget - _scrollXOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime));
_scrollY = (int16) (_scrollYOld + ((_scrollYTarget - _scrollYOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime));
_renderTooSlow = false;
}
framesPerGameCycle = 0;
return RD_OK;
_framesPerGameCycle = 0;
}
/**
@ -687,52 +613,56 @@ int32 StartRenderCycle(void) {
* terminated, or false if it should continue
*/
int32 EndRenderCycle(bool *end) {
bool Display::endRenderCycle(void) {
static int32 renderTimeLog[4] = { 60, 60, 60, 60 };
static int32 renderCountIndex = 0;
int32 time;
time = SVM_timeGetTime();
renderTimeLog[renderCountIndex] = time - startTime;
startTime = time;
renderAverageTime = (renderTimeLog[0] + renderTimeLog[1] + renderTimeLog[2] + renderTimeLog[3]) >> 2;
renderTimeLog[renderCountIndex] = time - _startTime;
_startTime = time;
_renderAverageTime = (renderTimeLog[0] + renderTimeLog[1] + renderTimeLog[2] + renderTimeLog[3]) >> 2;
framesPerGameCycle++;
_framesPerGameCycle++;
if (++renderCountIndex == RENDERAVERAGETOTAL)
renderCountIndex = 0;
if (renderTooSlow) {
*end = true;
InitialiseRenderCycle();
} else if (startTime + renderAverageTime >= totalTime) {
*end = true;
totalTime += MILLISECSPERCYCLE;
initialTime = time;
if (_renderTooSlow) {
initialiseRenderCycle();
return true;
}
if (_startTime + _renderAverageTime >= _totalTime) {
_totalTime += MILLISECSPERCYCLE;
_initialTime = time;
return true;
}
#ifdef LIMIT_FRAME_RATE
} else if (scrollxTarget == scrollx && scrollyTarget == scrolly) {
if (_scrollXTarget == _scrollX && _scrollYTarget == _scrollY) {
// If we have already reached the scroll target sleep for the
// rest of the render cycle.
*end = true;
sleepUntil(totalTime);
initialTime = SVM_timeGetTime();
totalTime += MILLISECSPERCYCLE;
sleepUntil(_totalTime);
_initialTime = SVM_timeGetTime();
_totalTime += MILLISECSPERCYCLE;
return true;
}
#endif
} else {
*end = false;
// This is an attempt to ensure that we always reach the scroll
// target. Otherwise the game frequently tries to pump out new
// interpolation frames without ever getting anywhere.
// This is an attempt to ensure that we always reach the scroll target.
// Otherwise the game frequently tries to pump out new interpolation
// frames without ever getting anywhere.
if (ABS(scrollx - scrollxTarget) <= 1 && ABS(scrolly - scrollyTarget) <= 1) {
scrollx = scrollxTarget;
scrolly = scrollyTarget;
if (ABS(_scrollX - _scrollXTarget) <= 1 && ABS(_scrollY - _scrollYTarget) <= 1) {
_scrollX = _scrollXTarget;
_scrollY = _scrollYTarget;
} else {
scrollx = (int16) (scrollxOld + ((scrollxTarget - scrollxOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime));
scrolly = (int16) (scrollyOld + ((scrollyTarget - scrollyOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime));
}
_scrollX = (int16) (_scrollXOld + ((_scrollXTarget - _scrollXOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime));
_scrollY = (int16) (_scrollYOld + ((_scrollYTarget - _scrollYOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime));
}
return RD_OK;
return false;
}
/**
@ -741,11 +671,9 @@ int32 EndRenderCycle(bool *end) {
* position in the allotted time.
*/
int32 SetScrollTarget(int16 sx, int16 sy) {
scrollxTarget = sx;
scrollyTarget = sy;
return RD_OK;
void Display::setScrollTarget(int16 sx, int16 sy) {
_scrollXTarget = sx;
_scrollYTarget = sy;
}
/**
@ -753,7 +681,7 @@ int32 SetScrollTarget(int16 sx, int16 sy) {
* or a NULL pointer in order of background parallax to foreground parallax.
*/
int32 InitialiseBackgroundLayer(_parallax *p) {
int32 Display::initialiseBackgroundLayer(_parallax *p) {
uint8 *memchunk;
uint8 zeros;
uint16 count;
@ -764,29 +692,29 @@ int32 InitialiseBackgroundLayer(_parallax *p) {
_parallaxLine line;
uint8 *pLine;
debug(2, "InitialiseBackgroundLayer");
debug(2, "initialiseBackgroundLayer");
// This function is called to re-initialise the layers if they have
// been lost. We know this if the layers have already been assigned.
if (layer == MAXLAYERS)
CloseBackgroundLayer();
if (_layer == MAXLAYERS)
closeBackgroundLayer();
if (!p) {
layer++;
_layer++;
return RD_OK;
}
xblocks[layer] = (p->w + BLOCKWIDTH - 1) >> BLOCKWBITS;
yblocks[layer] = (p->h + BLOCKHEIGHT - 1) >> BLOCKHBITS;
_xBlocks[_layer] = (p->w + BLOCKWIDTH - 1) >> BLOCKWBITS;
_yBlocks[_layer] = (p->h + BLOCKHEIGHT - 1) >> BLOCKHBITS;
blockSurfaces[layer] = (BlockSurface **) calloc(xblocks[layer] * yblocks[layer], sizeof(BlockSurface *));
if (!blockSurfaces[layer])
_blockSurfaces[_layer] = (BlockSurface **) calloc(_xBlocks[_layer] * _yBlocks[_layer], sizeof(BlockSurface *));
if (!_blockSurfaces[_layer])
return RDERR_OUTOFMEMORY;
// Decode the parallax layer into a large chunk of memory
memchunk = (uint8 *) malloc(xblocks[layer] * BLOCKWIDTH * yblocks[layer] * BLOCKHEIGHT);
memchunk = (uint8 *) malloc(_xBlocks[_layer] * BLOCKWIDTH * _yBlocks[_layer] * BLOCKHEIGHT);
if (!memchunk)
return RDERR_OUTOFMEMORY;
@ -835,11 +763,11 @@ int32 InitialiseBackgroundLayer(_parallax *p) {
// Now create the surfaces!
for (i = 0; i < xblocks[layer] * yblocks[layer]; i++) {
for (i = 0; i < _xBlocks[_layer] * _yBlocks[_layer]; i++) {
bool block_has_data = false;
bool block_is_transparent = false;
data = memchunk + (p->w * BLOCKHEIGHT * (i / xblocks[layer])) + BLOCKWIDTH * (i % xblocks[layer]);
data = memchunk + (p->w * BLOCKHEIGHT * (i / _xBlocks[_layer])) + BLOCKWIDTH * (i % _xBlocks[_layer]);
for (j = 0; j < BLOCKHEIGHT; j++) {
for (k = 0; k < BLOCKWIDTH; k++) {
@ -853,24 +781,24 @@ int32 InitialiseBackgroundLayer(_parallax *p) {
// Only assign a surface to the block if it contains data.
if (block_has_data) {
blockSurfaces[layer][i] = (BlockSurface *) malloc(sizeof(BlockSurface));
_blockSurfaces[_layer][i] = (BlockSurface *) malloc(sizeof(BlockSurface));
// Copy the data into the surfaces.
dst = blockSurfaces[layer][i]->data;
dst = _blockSurfaces[_layer][i]->data;
for (j = 0; j < BLOCKHEIGHT; j++) {
memcpy(dst, data, BLOCKWIDTH);
data += p->w;
dst += BLOCKWIDTH;
}
blockSurfaces[layer][i]->transparent = block_is_transparent;
_blockSurfaces[_layer][i]->transparent = block_is_transparent;
} else
blockSurfaces[layer][i] = NULL;
_blockSurfaces[_layer][i] = NULL;
}
free(memchunk);
layer++;
_layer++;
return RD_OK;
}
@ -879,21 +807,20 @@ int32 InitialiseBackgroundLayer(_parallax *p) {
* Should be called once after leaving the room to free up memory.
*/
int32 CloseBackgroundLayer(void) {
void Display::closeBackgroundLayer(void) {
debug(2, "CloseBackgroundLayer");
for (int j = 0; j < MAXLAYERS; j++) {
if (blockSurfaces[j]) {
for (int i = 0; i < xblocks[j] * yblocks[j]; i++)
if (blockSurfaces[j][i])
free(blockSurfaces[j][i]);
free(blockSurfaces[j]);
blockSurfaces[j] = NULL;
if (_blockSurfaces[j]) {
for (int i = 0; i < _xBlocks[j] * _yBlocks[j]; i++)
if (_blockSurfaces[j][i])
free(_blockSurfaces[j][i]);
free(_blockSurfaces[j]);
_blockSurfaces[j] = NULL;
}
}
layer = 0;
return RD_OK;
_layer = 0;
}
} // End of namespace Sword2

14
sword2/driver/render.h
View File

@ -33,20 +33,6 @@ typedef struct {
uint16 offset;
} _parallaxLine;
extern int16 scrollx; // current x offset into background of display
extern int16 scrolly; // current y offset into background of display
extern int16 parallaxScrollx; // current x offset to link a sprite to the
// parallax layer
extern int16 parallaxScrolly; // current y offset to link a sprite to the
// parallax layer
extern int16 locationWide;
extern int16 locationDeep;
void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf);
void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf);
void UploadRect(Common::Rect *r);
} // End of namespace Sword2
#endif

140
sword2/driver/sprite.cpp
View File

@ -27,8 +27,6 @@
namespace Sword2 {
static uint8 *lightMask = 0;
/**
* This function takes a sprite and creates a mirror image of it.
* @param dst destination buffer
@ -37,17 +35,13 @@ static uint8 *lightMask = 0;
* @param h height of the sprite
*/
int32 MirrorSprite(uint8 *dst, uint8 *src, int16 w, int16 h) {
int16 x, y;
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
void Display::mirrorSprite(uint8 *dst, uint8 *src, int16 w, int16 h) {
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
*dst++ = *(src + w - x - 1);
}
src += w;
}
return RD_OK;
}
/**
@ -58,7 +52,7 @@ int32 MirrorSprite(uint8 *dst, uint8 *src, int16 w, int16 h) {
* @param decompSize the expected size of the decompressed sprite
*/
int32 DecompressRLE256(uint8 *dest, uint8 *source, int32 decompSize) {
int32 Display::decompressRLE256(uint8 *dest, uint8 *source, int32 decompSize) {
// PARAMETERS:
// source points to the start of the sprite data for input
// decompSize gives size of decompressed data in bytes
@ -138,7 +132,7 @@ int32 DecompressRLE256(uint8 *dest, uint8 *source, int32 decompSize) {
* Unwinds a run of 16-colour data into 256-colour palette data.
*/
void UnwindRaw16(uint8 *dest, uint8 *source, uint8 blockSize, uint8 *colTable) {
void Display::unwindRaw16(uint8 *dest, uint8 *source, uint8 blockSize, uint8 *colTable) {
// for each pair of pixels
while (blockSize > 1) {
// 1st colour = number in table at position given by upper
@ -173,7 +167,7 @@ void UnwindRaw16(uint8 *dest, uint8 *source, uint8 blockSize, uint8 *colTable) {
* @param colTable mapping from the 16 encoded colours to the current palette
*/
int32 DecompressRLE16(uint8 *dest, uint8 *source, int32 decompSize, uint8 *colTable) {
int32 Display::decompressRLE16(uint8 *dest, uint8 *source, int32 decompSize, uint8 *colTable) {
uint8 headerByte; // block header byte
uint8 *endDest = dest + decompSize; // pointer to byte after end of decomp buffer
int32 rv;
@ -223,7 +217,7 @@ int32 DecompressRLE16(uint8 *dest, uint8 *source, int32 decompSize, uint8 *colTa
// copy the next 'headerByte' pixels from source to
// destination (NB. 2 pixels per byte)
UnwindRaw16(dest, source, headerByte, colTable);
unwindRaw16(dest, source, headerByte, colTable);
// increment destination pointer to just after this
// block
@ -253,7 +247,7 @@ int32 DecompressRLE16(uint8 *dest, uint8 *source, int32 decompSize, uint8 *colTa
* @return RD_OK, or an error code
*/
int32 CreateSurface(_spriteInfo *s, uint8 **sprite) {
int32 Display::createSurface(_spriteInfo *s, uint8 **sprite) {
uint8 *newSprite;
*sprite = (uint8 *) malloc(s->w * s->h);
@ -264,12 +258,12 @@ int32 CreateSurface(_spriteInfo *s, uint8 **sprite) {
memcpy(*sprite, s->data, s->w * s->h);
} else {
if ((s->type >> 8) == (RDSPR_RLE16 >> 8)) {
if (DecompressRLE16(*sprite, s->data, s->w * s->h, s->colourTable)) {
if (decompressRLE16(*sprite, s->data, s->w * s->h, s->colourTable)) {
free(*sprite);
return RDERR_DECOMPRESSION;
}
} else {
if (DecompressRLE256(*sprite, s->data, s->w * s->h)) {
if (decompressRLE256(*sprite, s->data, s->w * s->h)) {
free(*sprite);
return RDERR_DECOMPRESSION;
}
@ -281,7 +275,7 @@ int32 CreateSurface(_spriteInfo *s, uint8 **sprite) {
free(*sprite);
return RDERR_OUTOFMEMORY;
}
MirrorSprite(newSprite, *sprite, s->w, s->h);
mirrorSprite(newSprite, *sprite, s->w, s->h);
free(*sprite);
*sprite = newSprite;
}
@ -297,7 +291,7 @@ int32 CreateSurface(_spriteInfo *s, uint8 **sprite) {
* @param clipRect the clipping rectangle
*/
void DrawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect) {
void Display::drawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect) {
Common::Rect rd, rs;
uint16 x, y, srcPitch;
uint8 *src, *dst;
@ -313,8 +307,8 @@ void DrawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect) {
rd.top = s->y;
rd.left = s->x;
} else {
rd.top = s->y - scrolly;
rd.left = s->x - scrollx;
rd.top = s->y - _scrollY;
rd.left = s->x - _scrollX;
}
rd.right = rd.left + rs.right;
@ -344,7 +338,7 @@ void DrawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect) {
}
src = surface + rs.top * srcPitch + rs.left;
dst = lpBackBuffer + screenWide * rd.top + rd.left;
dst = _buffer + _screenWide * rd.top + rd.left;
// Surfaces are always transparent.
@ -354,18 +348,18 @@ void DrawSurface(_spriteInfo *s, uint8 *surface, Common::Rect *clipRect) {
dst[x] = src[x];
}
src += srcPitch;
dst += screenWide;
dst += _screenWide;
}
UploadRect(&rd);
SetNeedRedraw();
updateRect(&rd);
setNeedFullRedraw();
}
/**
* Destroys a surface.
*/
void DeleteSurface(uint8 *surface) {
void Display::deleteSurface(uint8 *surface) {
free(surface);
}
@ -390,7 +384,7 @@ void DeleteSurface(uint8 *surface) {
// FIXME: I'm sure this could be optimized. There's plenty of data copying and
// mallocing here.
int32 DrawSprite(_spriteInfo *s) {
int32 Display::drawSprite(_spriteInfo *s) {
uint8 *src, *dst;
uint8 *sprite, *newSprite;
uint8 *backbuf = NULL;
@ -414,12 +408,12 @@ int32 DrawSprite(_spriteInfo *s) {
if (!sprite)
return RDERR_OUTOFMEMORY;
if ((s->type >> 8) == (RDSPR_RLE16 >> 8)) {
if (DecompressRLE16(sprite, s->data, s->w * s->h, s->colourTable)) {
if (decompressRLE16(sprite, s->data, s->w * s->h, s->colourTable)) {
free(sprite);
return RDERR_DECOMPRESSION;
}
} else {
if (DecompressRLE256(sprite, s->data, s->w * s->h)) {
if (decompressRLE256(sprite, s->data, s->w * s->h)) {
free(sprite);
return RDERR_DECOMPRESSION;
}
@ -433,7 +427,7 @@ int32 DrawSprite(_spriteInfo *s) {
free(sprite);
return RDERR_OUTOFMEMORY;
}
MirrorSprite(newSprite, sprite, s->w, s->h);
mirrorSprite(newSprite, sprite, s->w, s->h);
if (freeSprite)
free(sprite);
sprite = newSprite;
@ -445,8 +439,8 @@ int32 DrawSprite(_spriteInfo *s) {
// -----------------------------------------------------------------
if (!(s->type & RDSPR_DISPLAYALIGN)) {
s->x += parallaxScrollx;
s->y += parallaxScrolly;
s->x += _parallaxScrollX;
s->y += _parallaxScrollY;
}
s->y += 40;
@ -474,8 +468,8 @@ int32 DrawSprite(_spriteInfo *s) {
rd.left = s->x;
if (!(s->type & RDSPR_DISPLAYALIGN)) {
rd.top -= scrolly;
rd.left -= scrollx;
rd.top -= _scrollY;
rd.left -= _scrollX;
}
rd.right = rd.left + rs.right;
@ -515,8 +509,8 @@ int32 DrawSprite(_spriteInfo *s) {
// -----------------------------------------------------------------
if (scale != 256) {
if ((renderCaps & RDBLTFX_ARITHMETICSTRETCH) && !clipped)
backbuf = lpBackBuffer + screenWide * rd.top + rd.left;
if ((_renderCaps & RDBLTFX_EDGEBLEND) && !clipped)
backbuf = _buffer + _screenWide * rd.top + rd.left;
if (s->scaledWidth > SCALE_MAXWIDTH || s->scaledHeight > SCALE_MAXHEIGHT) {
@ -533,14 +527,14 @@ int32 DrawSprite(_spriteInfo *s) {
}
if (scale < 256) {
SquashImage(newSprite, s->scaledWidth, s->scaledWidth, s->scaledHeight, sprite, s->w, s->w, s->h, backbuf);
squashImage(newSprite, s->scaledWidth, s->scaledWidth, s->scaledHeight, sprite, s->w, s->w, s->h, backbuf);
} else {
if (s->scale > 512) {
if (freeSprite)
free(sprite);
return RDERR_INVALIDSCALING;
}
StretchImage(newSprite, s->scaledWidth, s->scaledWidth, s->scaledHeight, sprite, s->w, s->w, s->h, backbuf);
stretchImage(newSprite, s->scaledWidth, s->scaledWidth, s->scaledHeight, sprite, s->w, s->w, s->h, backbuf);
}
if (freeSprite)
@ -557,7 +551,7 @@ int32 DrawSprite(_spriteInfo *s) {
// and which is used to simulate light and shadows. Scaled sprites
// (actors, presumably) are always affected.
if ((renderCaps & RDBLTFX_SHADOWBLEND) && lightMask && (scale != 256 || (s->type & RDSPR_SHADOW))) {
if ((_renderCaps & RDBLTFX_SHADOWBLEND) && _lightMask && (scale != 256 || (s->type & RDSPR_SHADOW))) {
uint8 *lightMap;
if (!freeSprite) {
@ -568,19 +562,19 @@ int32 DrawSprite(_spriteInfo *s) {
}
src = sprite + rs.top * srcPitch + rs.left;
lightMap = lightMask + (rd.top + scrolly - 40) * locationWide + rd.left + scrollx;
lightMap = _lightMask + (rd.top + _scrollY - 40) * _locationWide + rd.left + _scrollX;
for (i = 0; i < rs.height(); i++) {
for (j = 0; j < rs.width(); j++) {
if (src[j] && lightMap[j]) {
uint8 r = ((32 - lightMap[j]) * palCopy[src[j]][0]) >> 5;
uint8 g = ((32 - lightMap[j]) * palCopy[src[j]][1]) >> 5;
uint8 b = ((32 - lightMap[j]) * palCopy[src[j]][2]) >> 5;
src[j] = QuickMatch(r, g, b);
uint8 r = ((32 - lightMap[j]) * _palCopy[src[j]][0]) >> 5;
uint8 g = ((32 - lightMap[j]) * _palCopy[src[j]][1]) >> 5;
uint8 b = ((32 - lightMap[j]) * _palCopy[src[j]][2]) >> 5;
src[j] = quickMatch(r, g, b);
}
}
src += srcPitch;
lightMap += locationWide;
lightMap += _locationWide;
}
}
@ -589,17 +583,17 @@ int32 DrawSprite(_spriteInfo *s) {
// -----------------------------------------------------------------
src = sprite + rs.top * srcPitch + rs.left;
dst = lpBackBuffer + screenWide * rd.top + rd.left;
dst = _buffer + _screenWide * rd.top + rd.left;
if (s->type & RDSPR_BLEND) {
if (renderCaps & RDBLTFX_ALLHARDWARE) {
if (!(_renderCaps & RDBLTFX_SPRITEBLEND)) {
for (i = 0; i < rs.height(); i++) {
for (j = 0; j < rs.width(); j++) {
if (src[j] && ((i & 1) == (j & 1)))
dst[j] = src[j];
}
src += srcPitch;
dst += screenWide;
dst += _screenWide;
}
} else {
if (s->blend & 0x01) {
@ -607,14 +601,14 @@ int32 DrawSprite(_spriteInfo *s) {
for (i = 0; i < rs.height(); i++) {
for (j = 0; j < rs.width(); j++) {
if (src[j]) {
uint8 r = (palCopy[src[j]][0] * red + palCopy[dst[j]][0] * (8 - red)) >> 3;
uint8 g = (palCopy[src[j]][1] * red + palCopy[dst[j]][1] * (8 - red)) >> 3;
uint8 b = (palCopy[src[j]][2] * red + palCopy[dst[j]][2] * (8 - red)) >> 3;
dst[j] = QuickMatch(r, g, b);
uint8 r = (_palCopy[src[j]][0] * red + _palCopy[dst[j]][0] * (8 - red)) >> 3;
uint8 g = (_palCopy[src[j]][1] * red + _palCopy[dst[j]][1] * (8 - red)) >> 3;
uint8 b = (_palCopy[src[j]][2] * red + _palCopy[dst[j]][2] * (8 - red)) >> 3;
dst[j] = quickMatch(r, g, b);
}
}
src += srcPitch;
dst += screenWide;
dst += _screenWide;
}
} else if (s->blend & 0x02) {
debug(2, "DrawSprite: s->blend & 0x02");
@ -631,20 +625,20 @@ int32 DrawSprite(_spriteInfo *s) {
// Does anyone know where this case was used
// anyway?
red = palCopy[s->blend >> 8][0];
green = palCopy[s->blend >> 8][0];
blue = palCopy[s->blend >> 8][0];
red = _palCopy[s->blend >> 8][0];
green = _palCopy[s->blend >> 8][0];
blue = _palCopy[s->blend >> 8][0];
for (i = 0; i < rs.height(); i++) {
for (j = 0; j < rs.width(); j++) {
if (src[j]) {
uint8 r = (src[j] * red + (16 - src[j]) * palCopy[dst[j]][0]) >> 4;
uint8 g = (src[j] * green + (16 - src[j]) * palCopy[dst[j]][1]) >> 4;
uint8 b = (src[j] * blue + (16 - src[j]) * palCopy[dst[j]][2]) >> 4;
dst[j] = QuickMatch(r, g, b);
uint8 r = (src[j] * red + (16 - src[j]) * _palCopy[dst[j]][0]) >> 4;
uint8 g = (src[j] * green + (16 - src[j]) * _palCopy[dst[j]][1]) >> 4;
uint8 b = (src[j] * blue + (16 - src[j]) * _palCopy[dst[j]][2]) >> 4;
dst[j] = quickMatch(r, g, b);
}
}
src += srcPitch;
dst += screenWide;
dst += _screenWide;
}
} else {
warning("DrawSprite: Invalid blended sprite");
@ -661,13 +655,13 @@ int32 DrawSprite(_spriteInfo *s) {
dst[j] = src[j];
}
src += srcPitch;
dst += screenWide;
dst += _screenWide;
}
} else {
for (i = 0; i < rs.height(); i++) {
memcpy(dst, src, rs.width());
src += srcPitch;
dst += screenWide;
dst += _screenWide;
}
}
}
@ -675,8 +669,8 @@ int32 DrawSprite(_spriteInfo *s) {
if (freeSprite)
free(sprite);
// UploadRect(&rd);
SetNeedRedraw();
// updateRect(&rd);
setNeedFullRedraw();
return RD_OK;
}
@ -685,20 +679,20 @@ int32 DrawSprite(_spriteInfo *s) {
* Opens the light masking sprite for a room.
*/
int32 OpenLightMask(_spriteInfo *s) {
int32 Display::openLightMask(_spriteInfo *s) {
// FIXME: The light mask is only needed on higher graphics detail
// settings, so to save memory we could simply ignore it on lower
// settings. But then we need to figure out how to ensure that it
// is properly loaded if the user changes the settings in mid-game.
if (lightMask)
if (_lightMask)
return RDERR_NOTCLOSED;
lightMask = (uint8 *) malloc(s->w * s->h);
if (!lightMask)
_lightMask = (uint8 *) malloc(s->w * s->h);
if (!_lightMask)
return RDERR_OUTOFMEMORY;
if (DecompressRLE256(lightMask, s->data, s->w * s->h))
if (decompressRLE256(_lightMask, s->data, s->w * s->h))
return RDERR_DECOMPRESSION;
return RD_OK;
@ -708,12 +702,12 @@ int32 OpenLightMask(_spriteInfo *s) {
* Closes the light masking sprite for a room.
*/
int32 CloseLightMask(void) {
if (!lightMask)
int32 Display::closeLightMask(void) {
if (!_lightMask)
return RDERR_NOTOPEN;
free(lightMask);
lightMask = 0;
free(_lightMask);
_lightMask = NULL;
return RD_OK;
}

51
sword2/function.cpp
View File

@ -31,7 +31,7 @@
#include "bs2/protocol.h"
#include "bs2/resman.h"
#include "bs2/sound.h"
#include "bs2/sword2.h" // for CloseGame()
#include "bs2/sword2.h"
namespace Sword2 {
@ -269,25 +269,25 @@ int32 FN_flash(int32 *params) {
// what colour?
switch (params[0]) {
case WHITE:
BS2_SetPalette(0, 1, white, RDPAL_INSTANT);
g_display->setPalette(0, 1, white, RDPAL_INSTANT);
break;
case RED:
BS2_SetPalette(0, 1, red, RDPAL_INSTANT);
g_display->setPalette(0, 1, red, RDPAL_INSTANT);
break;
case GREEN:
BS2_SetPalette(0, 1, green, RDPAL_INSTANT);
g_display->setPalette(0, 1, green, RDPAL_INSTANT);
break;
case BLUE:
BS2_SetPalette(0, 1, blue, RDPAL_INSTANT);
g_display->setPalette(0, 1, blue, RDPAL_INSTANT);
break;
}
// There used to be a busy-wait loop here, so I don't know how long
// the delay was meant to be. Probably doesn't matter much.
ServiceWindows();
g_display->updateDisplay();
g_system->delay_msecs(250);
BS2_SetPalette(0, 1, black, RDPAL_INSTANT);
g_display->setPalette(0, 1, black, RDPAL_INSTANT);
#endif
return IR_CONT;
@ -305,19 +305,19 @@ int32 FN_colour(int32 *params) {
// what colour?
switch (params[0]) {
case BLACK:
BS2_SetPalette(0, 1, black, RDPAL_INSTANT);
g_display->setPalette(0, 1, black, RDPAL_INSTANT);
break;
case WHITE:
BS2_SetPalette(0, 1, white, RDPAL_INSTANT);
g_display->setPalette(0, 1, white, RDPAL_INSTANT);
break;
case RED:
BS2_SetPalette(0, 1, red, RDPAL_INSTANT);
g_display->setPalette(0, 1, red, RDPAL_INSTANT);
break;
case GREEN:
BS2_SetPalette(0, 1, green, RDPAL_INSTANT);
g_display->setPalette(0, 1, green, RDPAL_INSTANT);
break;
case BLUE:
BS2_SetPalette(0, 1, blue, RDPAL_INSTANT);
g_display->setPalette(0, 1, blue, RDPAL_INSTANT);
break;
}
#endif
@ -396,17 +396,17 @@ int32 FN_play_credits(int32 *params) {
g_sound->muteSpeech(1);
g_sound->stopMusic();
memcpy(oldPal, palCopy, 1024);
memcpy(oldPal, g_display->_palCopy, 1024);
memset(tmpPal, 0, 1024);
WaitForFade();
FadeDown(0.75);
WaitForFade();
g_display->waitForFade();
g_display->fadeDown();
g_display->waitForFade();
tmpPal[4] = 255;
tmpPal[5] = 255;
tmpPal[6] = 255;
BS2_SetPalette(0, 256, tmpPal, RDPAL_INSTANT);
g_display->setPalette(0, 256, tmpPal, RDPAL_INSTANT);
// Play the credits music. Is it enough with just one
// repetition of it?
@ -419,17 +419,17 @@ int32 FN_play_credits(int32 *params) {
debug(0, "Credits music length: ~%d ms", music_length);
CloseMenuImmediately();
g_display->closeMenuImmediately();
while (g_sound->musicTimeRemaining()) {
EraseBackBuffer();
SetNeedRedraw();
g_display->clearScene();
g_display->setNeedFullRedraw();
// FIXME: Draw the credits text. The actual text
// messages are stored in credits.clu, and I'm guessing
// that credits.bmp or font.clu may be the font.
ServiceWindows();
g_display->updateDisplay();
_keyboardEvent ke;
@ -442,11 +442,11 @@ int32 FN_play_credits(int32 *params) {
FN_stop_music(NULL);
g_sound->restoreMusicState();
BS2_SetPalette(0, 256, oldPal, RDPAL_FADE);
FadeUp(0.75);
ServiceWindows();
g_display->setPalette(0, 256, oldPal, RDPAL_FADE);
g_display->fadeUp();
g_display->updateDisplay();
Build_display();
WaitForFade();
g_display->waitForFade();
g_sound->muteFx(0);
g_sound->muteSpeech(0);
@ -457,7 +457,6 @@ int32 FN_play_credits(int32 *params) {
if (g_sword2->_gameId == GID_SWORD2_DEMO) {
Close_game(); // close engine systems down
CloseAppWindow();
exit(0); // quit the game
}

14
sword2/icons.cpp
View File

@ -18,6 +18,7 @@
*/
#include "stdafx.h"
#include "bs2/sword2.h"
#include "bs2/driver/driver96.h"
#include "bs2/defs.h"
#include "bs2/icons.h"
@ -207,23 +208,22 @@ void Build_menu(void) {
if (icon_coloured)
icon += (RDMENU_ICONWIDE * RDMENU_ICONDEEP);
SetMenuIcon(RDMENU_BOTTOM, j, icon);
g_display->setMenuIcon(RDMENU_BOTTOM, j, icon);
res_man.close(res);
} else {
// no icon here
SetMenuIcon(RDMENU_BOTTOM, j, NULL);
g_display->setMenuIcon(RDMENU_BOTTOM, j, NULL);
debug(5, " NULL for %d", j);
}
}
ShowMenu(RDMENU_BOTTOM);
g_display->showMenu(RDMENU_BOTTOM);
}
void Build_system_menu(void) {
// start a fresh top system menu
uint8 *icon;
int j;
uint32 icon_list[5] = {
OPTIONS_ICON,
@ -236,7 +236,7 @@ void Build_system_menu(void) {
// build them all high in full colour - when one is clicked on all the
// rest will grey out
for (j = 0; j < ARRAYSIZE(icon_list); j++) {
for (int j = 0; j < ARRAYSIZE(icon_list); j++) {
icon = res_man.open(icon_list[j]) + sizeof(_standardHeader);
// The only case when an icon is grayed is when the player
@ -245,11 +245,11 @@ void Build_system_menu(void) {
if (!DEAD || icon_list[j] != SAVE_ICON)
icon += (RDMENU_ICONWIDE * RDMENU_ICONDEEP);
SetMenuIcon(RDMENU_TOP, j, icon);
g_display->setMenuIcon(RDMENU_TOP, j, icon);
res_man.close(icon_list[j]);
}
ShowMenu(RDMENU_TOP);
g_display->showMenu(RDMENU_TOP);
}
} // End of namespace Sword2

29
sword2/layers.cpp
View File

@ -26,6 +26,7 @@
// up to 2 foreground parallax layers
#include "stdafx.h"
#include "bs2/sword2.h"
#include "bs2/build_display.h"
#include "bs2/debug.h"
#include "bs2/header.h"
@ -67,11 +68,11 @@ int32 FN_init_background(int32 *params) {
#endif
// if the screen is still fading down then wait for black
WaitForFade();
g_display->waitForFade();
// if last screen was using a shading mask (see below)
if (this_screen.mask_flag) {
rv = CloseLightMask();
rv = g_display->closeLightMask();
if (rv)
error("Driver Error %.8x", rv);
}
@ -80,7 +81,7 @@ int32 FN_init_background(int32 *params) {
// for drivers: close the previous screen if one is open
if (this_screen.background_layer_id)
CloseBackgroundLayer();
g_display->closeBackgroundLayer();
this_screen.background_layer_id = params[0]; // set the res id
this_screen.new_palette = params[1]; // yes or no - palette is taken from layer file
@ -102,7 +103,7 @@ int32 FN_init_background(int32 *params) {
debug(5, "res test layers=%d width=%d depth=%d", screen_head->noLayers, screen_head->width, screen_head->height);
//initialise the driver back buffer
SetLocationMetrics(screen_head->width, screen_head->height);
g_display->setLocationMetrics(screen_head->width, screen_head->height);
if (screen_head->noLayers) {
for (int i = 0; i < screen_head->noLayers; i++) {
@ -124,7 +125,7 @@ int32 FN_init_background(int32 *params) {
// using the screen size setup the scrolling variables
// if layer is larger than physical screen
if (screen_head->width > screenWide || screen_head->height > screenDeep) {
if (screen_head->width > g_display->_screenWide || screen_head->height > g_display->_screenDeep) {
// switch on scrolling (2 means first time on screen)
this_screen.scroll_flag = 2;
@ -139,9 +140,9 @@ int32 FN_init_background(int32 *params) {
// calc max allowed offsets (to prevent scrolling off edge) -
// MOVE TO NEW_SCREEN in GTM_CORE.C !!
// NB. min scroll offsets are both zero
this_screen.max_scroll_offset_x = screen_head->width-screenWide;
this_screen.max_scroll_offset_x = screen_head->width - g_display->_screenWide;
// 'screenDeep' includes the menu's, so take away 80 pixels
this_screen.max_scroll_offset_y = screen_head->height - (screenDeep - (RDMENU_MENUDEEP * 2));
this_screen.max_scroll_offset_y = screen_head->height - (g_display->_screenDeep - (RDMENU_MENUDEEP * 2));
} else {
// layer fits on physical screen - scrolling not required
this_screen.scroll_flag = 0; // switch off scrolling
@ -151,7 +152,7 @@ int32 FN_init_background(int32 *params) {
// no inter-cycle scroll between new screens (see setScrollTarget in
// build display)
ResetRenderEngine();
g_display->resetRenderEngine();
// these are the physical screen coords where the system
// will try to maintain George's actual feet coords
@ -175,7 +176,7 @@ int32 FN_init_background(int32 *params) {
spriteInfo.data = FetchShadingMask(file);
spriteInfo.colourTable = 0;
rv = OpenLightMask(&spriteInfo);
rv = g_display->openLightMask(&spriteInfo);
if (rv)
error("Driver Error %.8x", rv);
@ -219,22 +220,22 @@ void SetUpBackgroundLayers(void) {
for (i = 0; i < 2; i++) {
if (screenLayerTable->bg_parallax[i])
InitialiseBackgroundLayer(FetchBackgroundParallaxLayer(file, i));
g_display->initialiseBackgroundLayer(FetchBackgroundParallaxLayer(file, i));
else
InitialiseBackgroundLayer(NULL);
g_display->initialiseBackgroundLayer(NULL);
}
// Normal backround layer
InitialiseBackgroundLayer(FetchBackgroundLayer(file));
g_display->initialiseBackgroundLayer(FetchBackgroundLayer(file));
// Foreground parallax layers
for (i = 0; i < 2; i++) {
if (screenLayerTable->fg_parallax[i])
InitialiseBackgroundLayer(FetchForegroundParallaxLayer(file, i));
g_display->initialiseBackgroundLayer(FetchForegroundParallaxLayer(file, i));
else
InitialiseBackgroundLayer(NULL);
g_display->initialiseBackgroundLayer(NULL);
}
// close the screen file

3
sword2/logic.cpp
View File

@ -18,6 +18,7 @@
*/
#include "stdafx.h"
#include "bs2/sword2.h"
#include "bs2/build_display.h"
#include "bs2/console.h"
#include "bs2/debug.h"
@ -347,7 +348,7 @@ uint32 logic::examineRunList(void) {
Build_display();
do {
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
// kill the key we just pressed

4
sword2/maketext.cpp
View File

@ -525,7 +525,7 @@ void FontRenderer::printTextBlocs(void) {
spriteInfo.data = _blocList[j].text_mem->ad + sizeof(_frameHeader);
spriteInfo.colourTable = 0;
rv = DrawSprite(&spriteInfo);
rv = g_display->drawSprite(&spriteInfo);
if (rv)
error("Driver Error %.8x in Print_text_blocs", rv);
}
@ -603,7 +603,7 @@ void Sword2Engine::initialiseFontResourceFlags(void) {
// GERMAN: "Baphomet's Fluch II"
// default: "Some game or other, part 86"
SetWindowName((char *) textLine);
g_display->setWindowName((char *) textLine);
// now ok to close the text file
res_man.close(TEXT_RES);

3
sword2/mem_view.cpp
View File

@ -18,6 +18,7 @@
*/
#include "stdafx.h"
#include "bs2/sword2.h"
#include "bs2/build_display.h"
#include "bs2/console.h"
#include "bs2/header.h"
@ -102,7 +103,7 @@ void MemoryManager::displayMemory(void) {
Build_display();
do {
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
ReadKey(&ke); //kill the key we just pressed

99
sword2/mouse.cpp
View File

@ -157,7 +157,7 @@ void Mouse_engine(void) {
System_menu_mouse();
break;
case MOUSE_holding:
if (mousey < 400) {
if (g_display->_mouseY < 400) {
mouse_mode = MOUSE_normal;
debug(5, " releasing");
}
@ -182,10 +182,10 @@ void System_menu_mouse(void) {
};
// can't close when player is dead
if (mousey > 0 && !DEAD) {
if (g_display->_mouseY > 0 && !DEAD) {
// close menu
mouse_mode = MOUSE_normal;
HideMenu(RDMENU_TOP);
g_display->hideMenu(RDMENU_TOP);
return;
}
@ -194,9 +194,9 @@ void System_menu_mouse(void) {
if (me && (me->buttons & RD_LEFTBUTTONDOWN)) {
// clicked on a top mouse pointer?
if (mousex >= 24 && mousex < 640 - 24 && mousey < 0) {
if (g_display->_mouseX >= 24 && g_display->_mouseX < 640 - 24 && g_display->_mouseY < 0) {
// which are we over?
hit = (mousex - 24) / 40;
hit = (g_display->_mouseX - 24) / 40;
// no save when dead
if (icon_list[hit] == SAVE_ICON && DEAD)
@ -210,7 +210,7 @@ void System_menu_mouse(void) {
// change all others to grey
if (j != hit) {
icon = res_man.open(icon_list[j]) + sizeof(_standardHeader);
SetMenuIcon(RDMENU_TOP, j, icon);
g_display->setMenuIcon(RDMENU_TOP, j, icon);
res_man.close( icon_list[j] );
}
}
@ -235,9 +235,9 @@ void System_menu_mouse(void) {
// clear the screen & set up the new palette
// for the menus
EraseBackBuffer();
ProcessMenu();
ResetRenderEngine();
g_display->clearScene();
g_display->processMenu();
g_display->resetRenderEngine();
// call the relevent screen
switch (hit) {
@ -261,7 +261,7 @@ void System_menu_mouse(void) {
// Menu stays open on death screen
if (!DEAD) {
mouse_mode = MOUSE_normal;
HideMenu(RDMENU_TOP);
g_display->hideMenu(RDMENU_TOP);
} else {
Set_mouse(NORMAL_MOUSE_ID);
Build_system_menu();
@ -270,8 +270,8 @@ void System_menu_mouse(void) {
// clear the screen & restore the location
// palette
EraseBackBuffer();
ProcessMenu();
g_display->clearScene();
g_display->processMenu();
// reset game palette, but not after a
// successful restore or restart!
@ -319,10 +319,10 @@ void Drag_mouse(void) {
_mouseEvent *me;
uint32 pos;
if (mousey < 400 && !menu_status) {
if (g_display->_mouseY < 400 && !menu_status) {
// close menu
mouse_mode = MOUSE_normal;
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_BOTTOM);
return;
}
@ -358,8 +358,8 @@ void Drag_mouse(void) {
// these might be required by the action script about
// to be run
MOUSE_X = (uint32) mousex + this_screen.scroll_offset_x;
MOUSE_Y = (uint32) mousey + this_screen.scroll_offset_y;
MOUSE_X = (uint32) g_display->_mouseX + this_screen.scroll_offset_x;
MOUSE_Y = (uint32) g_display->_mouseY + this_screen.scroll_offset_y;
// for scripts to know what's been clicked (21jan97).
// First used for 'room_13_turning_script' in object
@ -373,14 +373,14 @@ void Drag_mouse(void) {
// Hide menu - back to normal menu mode
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_BOTTOM);
mouse_mode = MOUSE_normal;
} else {
// better check for combine/cancel
// cancel puts us back in Menu_mouse mode
if (mousex >= 24 && mousex < 640 - 24) {
if (g_display->_mouseX >= 24 && g_display->_mouseX < 640 - 24) {
// which are we over?
pos = (mousex - 24) / 40;
pos = (g_display->_mouseX - 24) / 40;
//clicked on something - what button?
if (master_menu_list[pos].icon_resource) {
@ -432,10 +432,10 @@ void Menu_mouse(void) {
_mouseEvent *me;
uint32 pos;
if (mousey < 400 && !menu_status) {
if (g_display->_mouseY < 400 && !menu_status) {
// close menu
mouse_mode = MOUSE_normal;
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_BOTTOM);
return;
}
@ -448,9 +448,9 @@ void Menu_mouse(void) {
// there's a mouse event to be processed
// now check if we've clicked on an actual icon
if (mousex >= 24 && mousex < 640 - 24) {
if (g_display->_mouseX >= 24 && g_display->_mouseX < 640 - 24) {
// which are we over?
pos = (mousex - 24) / 40;
pos = (g_display->_mouseX - 24) / 40;
// clicked on something - what button?
if (master_menu_list[pos].icon_resource) {
@ -518,7 +518,7 @@ void Normal_mouse(void) {
_mouseEvent *me;
// no save in big-object menu lock situation
if (mousey < 0 && !menu_status && !mouse_mode_locked && !OBJECT_HELD) {
if (g_display->_mouseY < 0 && !menu_status && !mouse_mode_locked && !OBJECT_HELD) {
mouse_mode = MOUSE_system_menu;
if (mouse_touching) {
@ -533,7 +533,7 @@ void Normal_mouse(void) {
return;
}
if (mousey > 399 && !menu_status && !mouse_mode_locked) {
if (g_display->_mouseY > 399 && !menu_status && !mouse_mode_locked) {
// If an object is being held, i.e. if the mouse cursor has a
// luggage, we should be use dragging mode instead of inventory
// menu mode.
@ -578,8 +578,8 @@ void Normal_mouse(void) {
if (me && (me->buttons & (RD_LEFTBUTTONDOWN | RD_RIGHTBUTTONDOWN))) {
// set both (x1,y1) and (x2,y2) to this point
rect_x1 = rect_x2 = (uint32) mousex + this_screen.scroll_offset_x;
rect_y1 = rect_y2 = (uint32) mousey + this_screen.scroll_offset_y;
rect_x1 = rect_x2 = (uint32) g_display->_mouseX + this_screen.scroll_offset_x;
rect_y1 = rect_y2 = (uint32) g_display->_mouseY + this_screen.scroll_offset_y;
draggingRectangle = 1;
}
} else if (draggingRectangle == 1) {
@ -591,8 +591,8 @@ void Normal_mouse(void) {
draggingRectangle = 2;
} else {
// drag rectangle
rect_x2 = (uint32) mousex + this_screen.scroll_offset_x;
rect_y2 = (uint32) mousey + this_screen.scroll_offset_y;
rect_x2 = (uint32) g_display->_mouseX + this_screen.scroll_offset_x;
rect_y2 = (uint32) g_display->_mouseY + this_screen.scroll_offset_y;
}
} else {
// currently locked to avoid knocking out of place
@ -642,8 +642,8 @@ void Normal_mouse(void) {
}
// these might be required by the action script about to be run
MOUSE_X = (uint32) mousex + this_screen.scroll_offset_x;
MOUSE_Y = (uint32) mousey + this_screen.scroll_offset_y;
MOUSE_X = (uint32) g_display->_mouseX + this_screen.scroll_offset_x;
MOUSE_Y = (uint32) g_display->_mouseY + this_screen.scroll_offset_y;
// only left button
if (mouse_touching == EXIT_CLICK_ID && (me->buttons & RD_LEFTBUTTONDOWN)) {
@ -701,7 +701,7 @@ void Mouse_on_off(void) {
// don't detect objects that are hidden behind the menu bars (ie. in
// the scrolled-off areas of the screen)
if (mousey < 0 || mousey > 399) {
if (g_display->_mouseY < 0 || g_display->_mouseY > 399) {
pointer_type = 0;
mouse_touching = 0;
} else {
@ -799,14 +799,14 @@ void Set_mouse(uint32 res) {
// loop
if (res == NORMAL_MOUSE_ID)
SetMouseAnim(icon, len, RDMOUSE_NOFLASH);
g_display->setMouseAnim(icon, len, RDMOUSE_NOFLASH);
else
SetMouseAnim(icon, len, RDMOUSE_FLASH);
g_display->setMouseAnim(icon, len, RDMOUSE_FLASH);
res_man.close(res);
} else {
// blank cursor
SetMouseAnim(NULL, 0, 0);
g_display->setMouseAnim(NULL, 0, 0);
}
}
@ -820,11 +820,11 @@ void Set_luggage(uint32 res) {
icon = res_man.open(res) + sizeof(_standardHeader);
len = res_man._resList[res]->size - sizeof(_standardHeader);
SetLuggageAnim(icon, len);
g_display->setLuggageAnim(icon, len);
res_man.close(res);
} else
SetLuggageAnim(NULL, 0);
g_display->setLuggageAnim(NULL, 0);
}
uint32 Check_mouse_list(void) {
@ -838,10 +838,10 @@ uint32 Check_mouse_list(void) {
// mouse-detection-box
if (mouse_list[j].priority == priority &&
mousex + this_screen.scroll_offset_x >= mouse_list[j].x1 &&
mousex + this_screen.scroll_offset_x <= mouse_list[j].x2 &&
mousey + this_screen.scroll_offset_y >= mouse_list[j].y1 &&
mousey + this_screen.scroll_offset_y <= mouse_list[j].y2) {
g_display->_mouseX + this_screen.scroll_offset_x >= mouse_list[j].x1 &&
g_display->_mouseX + this_screen.scroll_offset_x <= mouse_list[j].x2 &&
g_display->_mouseY + this_screen.scroll_offset_y >= mouse_list[j].y1 &&
g_display->_mouseY + this_screen.scroll_offset_y <= mouse_list[j].y2) {
// record id
mouse_touching = mouse_list[j].id;
@ -1017,7 +1017,8 @@ void CreatePointerText(uint32 textId, uint32 pointerRes) {
// line reference number
pointer_text_bloc_no = fontRenderer.buildNewBloc(
text + 2, mousex + xOffset, mousey + yOffset,
text + 2, g_display->_mouseX + xOffset,
g_display->_mouseY + yOffset,
POINTER_TEXT_WIDTH, POINTER_TEXT_PEN,
RDSPR_TRANS | RDSPR_DISPLAYALIGN,
g_sword2->_speechFontId, justification);
@ -1054,12 +1055,12 @@ int32 FN_no_human(int32 *params) {
// dont hide menu in conversations
if (TALK_FLAG == 0)
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_BOTTOM);
if (mouse_mode == MOUSE_system_menu) {
// close menu
mouse_mode = MOUSE_normal;
HideMenu(RDMENU_TOP);
g_display->hideMenu(RDMENU_TOP);
}
// script continue
@ -1117,7 +1118,7 @@ int32 FN_add_human(int32 *params) {
}
// if mouse is over menu area
if (mousey > 399) {
if (g_display->_mouseY > 399) {
if (mouse_mode != MOUSE_holding) {
// VITAL - reset things & rebuild the menu
mouse_mode = MOUSE_normal;
@ -1292,7 +1293,7 @@ int32 FN_set_scroll_right_mouse(int32 *params) {
// Highest priority
ob_mouse->x1 = this_screen.scroll_offset_x + screenWide - SCROLL_MOUSE_WIDTH;
ob_mouse->x1 = this_screen.scroll_offset_x + g_display->_screenWide - SCROLL_MOUSE_WIDTH;
ob_mouse->y1 = 0;
ob_mouse->x2 = this_screen.screen_wide - 1;
ob_mouse->y2 = this_screen.screen_deep - 1;
@ -1327,7 +1328,7 @@ int32 FN_set_object_held(int32 *params) {
// appropriate to keep it displayed
int32 FN_remove_chooser(int32 *params) {
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_BOTTOM);
return IR_CONT;
}
@ -1336,8 +1337,8 @@ int32 FN_disable_menu(int32 *params) {
mouse_mode_locked = 1;
mouse_mode = MOUSE_normal;
HideMenu(RDMENU_TOP);
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_TOP);
g_display->hideMenu(RDMENU_BOTTOM);
return IR_CONT;
}

71
sword2/resman.cpp
View File

@ -18,6 +18,7 @@
*/
#include "stdafx.h"
#include "bs2/sword2.h"
#include "bs2/driver/driver96.h"
#include "bs2/build_display.h"
#include "bs2/console.h"
@ -32,7 +33,6 @@
#include "bs2/protocol.h"
#include "bs2/resman.h"
#include "bs2/sound.h" // for Clear_fx_queue() called from cacheNewCluster()
#include "bs2/sword2.h" // for CloseGame()
#include "bs2/router.h"
namespace Sword2 {
@ -961,7 +961,7 @@ void ResourceManager::killAll(uint8 wantInfo) {
Build_display();
do {
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
ReadKey(&ke);
@ -1033,7 +1033,7 @@ void ResourceManager::killAllObjects(uint8 wantInfo) {
Build_display();
do {
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
@ -1106,28 +1106,28 @@ void ResourceManager::cacheNewCluster(uint32 newCluster) {
char buf[1024];
sprintf(buf, "%sClusters\\%s", _cdPath, _resourceFiles[newCluster]);
WaitForFade();
g_display->waitForFade();
if (GetFadeStatus() != RDFADE_BLACK) {
FadeDown((float) 0.75);
WaitForFade();
if (g_display->getFadeStatus() != RDFADE_BLACK) {
g_display->fadeDown();
g_display->waitForFade();
}
EraseBackBuffer();
g_display->clearScene();
Set_mouse(0);
Set_luggage(0); //tw28Aug
Set_luggage(0);
uint8 *bgfile;
bgfile = res_man.open(2950); // open the screen resource
InitialiseBackgroundLayer(NULL);
InitialiseBackgroundLayer(NULL);
InitialiseBackgroundLayer(FetchBackgroundLayer(bgfile));
InitialiseBackgroundLayer(NULL);
InitialiseBackgroundLayer(NULL);
BS2_SetPalette(0, 256, FetchPalette(bgfile), RDPAL_FADE);
g_display->initialiseBackgroundLayer(NULL);
g_display->initialiseBackgroundLayer(NULL);
g_display->initialiseBackgroundLayer(FetchBackgroundLayer(bgfile));
g_display->initialiseBackgroundLayer(NULL);
g_display->initialiseBackgroundLayer(NULL);
g_display->setPalette(0, 256, FetchPalette(bgfile), RDPAL_FADE);
RenderParallax(FetchBackgroundLayer(bgfile), 2);
g_display->renderParallax(FetchBackgroundLayer(bgfile), 2);
res_man.close(2950); // release the screen resource
// Git rid of read-only status, if it is set.
@ -1153,8 +1153,8 @@ void ResourceManager::cacheNewCluster(uint32 newCluster) {
frame = (_frameHeader*) text_spr->ad;
textSprite.x = screenWide /2 - frame->width / 2;
textSprite.y = screenDeep /2 - frame->height / 2 - RDMENU_MENUDEEP;
textSprite.x = g_display->_screenWide /2 - frame->width / 2;
textSprite.y = g_display->_screenDeep /2 - frame->height / 2 - RDMENU_MENUDEEP;
textSprite.w = frame->width;
textSprite.h = frame->height;
textSprite.scale = 0;
@ -1194,18 +1194,17 @@ void ResourceManager::cacheNewCluster(uint32 newCluster) {
int16 textX = textSprite.x;
int16 textY = textSprite.y;
DrawSprite(&barSprite);
g_display->drawSprite(&barSprite);
barSprite.x = barX;
barSprite.y = barY;
textSprite.data = text_spr->ad + sizeof(_frameHeader);
DrawSprite(&textSprite);
g_display->drawSprite(&textSprite);
textSprite.x = textX;
textSprite.y = textY;
FadeUp((float) 0.75);
WaitForFade();
g_display->fadeUp();
g_display->waitForFade();
uint32 size = inFile.size();
@ -1227,19 +1226,19 @@ void ResourceManager::cacheNewCluster(uint32 newCluster) {
step = 0;
// open the screen resource
bgfile = res_man.open(2950);
RenderParallax(FetchBackgroundLayer(bgfile), 2);
g_display->renderParallax(FetchBackgroundLayer(bgfile), 2);
// release the screen resource
res_man.close(2950);
loadingBar = res_man.open(2951);
frame = FetchFrameHeader(loadingBar, fr);
barSprite.data = (uint8 *) (frame + 1);
res_man.close(2951);
DrawSprite(&barSprite);
g_display->drawSprite(&barSprite);
barSprite.x = barX;
barSprite.y = barY;
textSprite.data = text_spr->ad + sizeof(_frameHeader);
DrawSprite(&textSprite);
g_display->drawSprite(&textSprite);
textSprite.x = textX;
textSprite.y = textY;
@ -1247,7 +1246,7 @@ void ResourceManager::cacheNewCluster(uint32 newCluster) {
} else
step++;
ServiceWindows();
g_display->updateDisplay();
} while ((read % BUFFERSIZE) == 0);
if (read != size) {
@ -1258,11 +1257,11 @@ void ResourceManager::cacheNewCluster(uint32 newCluster) {
outFile.close();
memory.freeMemory(text_spr);
EraseBackBuffer();
g_display->clearScene();
FadeDown((float) 0.75);
WaitForFade();
FadeUp((float) 0.75);
g_display->fadeDown();
g_display->waitForFade();
g_display->fadeUp();
// Git rid of read-only status.
SVM_SetFileAttributes(_resourceFiles[newCluster], FILE_ATTRIBUTE_NORMAL);
@ -1379,8 +1378,8 @@ void ResourceManager::getCd(int cd) {
frame = (_frameHeader*) text_spr->ad;
spriteInfo.x = screenWide / 2 - frame->width / 2;
spriteInfo.y = screenDeep / 2 - frame->height / 2 - RDMENU_MENUDEEP;
spriteInfo.x = g_display->_screenWide / 2 - frame->width / 2;
spriteInfo.y = g_display->_screenDeep / 2 - frame->height / 2 - RDMENU_MENUDEEP;
spriteInfo.w = frame->width;
spriteInfo.h = frame->height;
spriteInfo.scale = 0;
@ -1418,10 +1417,10 @@ void ResourceManager::getCd(int cd) {
}
}
ServiceWindows();
g_display->updateDisplay();
EraseBackBuffer();
DrawSprite(&spriteInfo); // Keep the message there even when the user task swaps.
g_display->clearScene();
g_display->drawSprite(&spriteInfo); // Keep the message there even when the user task swaps.
spriteInfo.y = oldY; // Drivers change the y co-ordinate, don't know why...
spriteInfo.x = oldX;
} while (!done);

18
sword2/speech.cpp
View File

@ -220,17 +220,17 @@ int32 FN_choose(int32 *params) {
if (j < IN_SUBJECT) {
debug(5, " ICON res %d for %d", subject_list[j].res, j);
icon = res_man.open(subject_list[j].res) + sizeof(_standardHeader) + RDMENU_ICONWIDE * RDMENU_ICONDEEP;
SetMenuIcon(RDMENU_BOTTOM, (uint8) j, icon);
g_display->setMenuIcon(RDMENU_BOTTOM, (uint8) j, icon);
res_man.close(subject_list[j].res);
} else {
//no icon here
debug(5, " NULL for %d", j);
SetMenuIcon(RDMENU_BOTTOM, (uint8) j, NULL);
g_display->setMenuIcon(RDMENU_BOTTOM, (uint8) j, NULL);
}
}
// start menus appearing
ShowMenu(RDMENU_BOTTOM);
g_display->showMenu(RDMENU_BOTTOM);
// lets have the mouse pointer back
Set_mouse(NORMAL_MOUSE_ID);
@ -253,9 +253,9 @@ int32 FN_choose(int32 *params) {
// if so then end the choose, highlight only the
// chosen, blank the mouse and return the ref code * 8
if (mousey > 399 && mousex >= 24 && mousex < 640 - 24) {
if (g_display->_mouseY > 399 && g_display->_mouseX >= 24 && g_display->_mouseX < 640 - 24) {
//which are we over?
hit = (mousex - 24) / 40;
hit = (g_display->_mouseX - 24) / 40;
//clicked on something - what button?
if (hit < IN_SUBJECT) {
@ -268,7 +268,7 @@ int32 FN_choose(int32 *params) {
// change all others to grey
if (j != hit) {
icon = res_man.open( subject_list[j].res ) + sizeof(_standardHeader);
SetMenuIcon(RDMENU_BOTTOM, (uint8) j, icon);
g_display->setMenuIcon(RDMENU_BOTTOM, (uint8) j, icon);
res_man.close(subject_list[j].res);
}
}
@ -338,9 +338,9 @@ int32 FN_end_conversation(int32 *params) {
debug(5, "FN_end_conversation");
HideMenu(RDMENU_BOTTOM);
g_display->hideMenu(RDMENU_BOTTOM);
if (mousey > 399) {
if (g_display->_mouseY > 399) {
// will wait for cursor to move off the bottom menu
mouse_mode = MOUSE_holding;
debug(5, " holding");
@ -1302,7 +1302,7 @@ int32 FN_i_speak(int32 *params) {
#ifdef _SWORD2_DEBUG
// so that we can go to the options panel while text & speech is
// being tested
if (SYSTEM_TESTING_TEXT == 0 || mousey > 0) {
if (SYSTEM_TESTING_TEXT == 0 || g_display->_mouseY > 0) {
#endif
me = MouseEvent();

2
sword2/startup.cpp
View File

@ -196,7 +196,7 @@ uint32 Con_print_start_menu(void) {
do {
// Service windows
ServiceWindows();
g_display->updateDisplay();
} while (!KeyWaiting());
// kill the key we just pressed

42
sword2/sword2.cpp
View File

@ -96,6 +96,7 @@ uint8 stepOneCycle = 0; // for use while game paused
Sword2Engine *g_sword2 = NULL;
Sound *g_sound = NULL;
Display *g_display = NULL;
Sword2Engine::Sword2Engine(GameDetector *detector, OSystem *syst)
: Engine(detector, syst) {
@ -120,11 +121,13 @@ Sword2Engine::Sword2Engine(GameDetector *detector, OSystem *syst)
_mixer->setMusicVolume(256);
g_sound = _sound = new Sound(_mixer);
g_display = _display = new Display(640, 480);
}
Sword2Engine::~Sword2Engine() {
free(_targetName);
delete _sound;
delete _display;
}
void Sword2Engine::errorString(const char *buf1, char *buf2) {
@ -199,7 +202,6 @@ int32 Sword2Engine::InitialiseGame(void) {
void Close_game() {
debug(5, "Close_game() STARTING:");
EraseBackBuffer();
// Stop music instantly!
Kill_music();
@ -207,6 +209,8 @@ void Close_game() {
// free the memory again
memory.exit();
res_man.exit();
g_system->quit();
}
int32 GameCycle(void) {
@ -250,8 +254,6 @@ int32 GameCycle(void) {
}
void Sword2Engine::go() {
uint32 rv;
uint8 breakOut = 0;
_keyboardEvent ke;
// Call the application "Revolution" until the resource manager is
@ -262,21 +264,12 @@ void Sword2Engine::go() {
// manager until a window has been created as any errors are displayed
// via a window, thus time becomes a loop.
debug(5, "CALLING: InitialiseDisplay");
rv = InitialiseDisplay(640, 480);
if (rv != RD_OK) {
// ReportDriverError(rv);
CloseAppWindow();
return;
}
debug(5, "CALLING: readOptionSettings");
gui.readOptionSettings();
debug(5, "CALLING: InitialiseGame");
if (InitialiseGame()) {
CloseAppWindow();
Close_game();
return;
}
@ -291,11 +284,11 @@ void Sword2Engine::go() {
} else
Start_game();
debug(5, "CALLING: InitialiseRenderCycle");
InitialiseRenderCycle();
debug(5, "CALLING: initialiseRenderCycle");
g_display->initialiseRenderCycle();
while (1) {
ServiceWindows();
g_display->updateDisplay();
#ifdef _SWORD2_DEBUG
// FIXME: If we want this, we should re-work it to use the backend's
@ -304,10 +297,6 @@ void Sword2Engine::go() {
// GrabScreenShot();
#endif
// if we are closing down the game, break out of main game loop
if (breakOut)
break;
#ifdef _SWORD2_DEBUG
if (console_status) {
if (One_console()) {
@ -408,7 +397,6 @@ void Sword2Engine::go() {
}
Close_game(); //close engine systems down
CloseAppWindow();
return; //quit the game
}
@ -465,8 +453,8 @@ void sleepUntil(int32 time) {
g_sword2->parseEvents();
// Make sure menu animations and fades don't suffer
ProcessMenu();
ServiceWindows();
g_display->processMenu();
g_display->updateDisplay();
g_system->delay_msecs(10);
}
@ -481,8 +469,8 @@ void PauseGame(void) {
// now ok to close the text file
// res_man.close(3258);
// don't allow Pause while screen fading or while black (James 03sep97)
if (GetFadeStatus() != RDFADE_NONE)
// don't allow Pause while screen fading or while black
if (g_display->getFadeStatus() != RDFADE_NONE)
return;
PauseAllSound();
@ -493,7 +481,7 @@ void PauseGame(void) {
// mouse_mode=MOUSE_normal;
// this is the only place allowed to do it this way
SetLuggageAnim(NULL, 0);
g_display->setLuggageAnim(NULL, 0);
// blank cursor
Set_mouse(0);
@ -513,7 +501,7 @@ void PauseGame(void) {
// dim the palette during the pause (James26jun97)
if (stepOneCycle == 0)
DimPalette();
g_display->dimPalette();
gamePaused = 1;
}

3
sword2/sword2.h
View File

@ -26,6 +26,7 @@
#include "common/rect.h"
#include "common/str.h"
#include "bs2/driver/d_sound.h"
#include "bs2/driver/d_draw.h"
enum BSGameId {
GID_SWORD2 = GID_SWORD2_FIRST,
@ -77,6 +78,7 @@ public:
byte _gameId;
char *_targetName; // target name for saves
Sound *_sound;
Display *_display;
Common::RandomSource _rnd;
uint32 _speechFontId;
@ -90,6 +92,7 @@ public:
extern Sword2Engine *g_sword2;
extern Sound *g_sound;
extern Display *g_display;
} // End of namespace Sword2

3
sword2/walker.cpp
View File

@ -23,6 +23,7 @@
// on them
#include "stdafx.h"
#include "bs2/sword2.h"
#include "bs2/console.h"
#include "bs2/defs.h"
#include "bs2/events.h"
@ -137,7 +138,7 @@ int32 FN_walk(int32 *params) {
// resource
ob_graph->anim_resource = ob_mega->megaset_res;
} else if (EXIT_FADING && GetFadeStatus() == RDFADE_BLACK) {
} else if (EXIT_FADING && g_display->getFadeStatus() == RDFADE_BLACK) {
// double clicked an exit so quit the walk when screen is black
// ok, thats it - back to script and change screen