thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SCI: Make the implicit segMan param to GET_SEL32(V) and PUT_SEL32(V) explicit

Browse source 
svn-id: r45234
This commit is contained in:
Max Horn 2009-10-18 19:42:56 +00:00
parent 2bbf708dea
commit f3ab3051d8
15 changed files with 415 additions and 415 deletions
Download patch file Download diff file Expand all files Collapse all files

8
engines/sci/console.cpp
View file

@ -2746,14 +2746,14 @@ bool Console::cmdStopSfx(int argc, const char **argv) {
} }
int handle = id.segment << 16 | id.offset; // frobnicate handle int handle = id.segment << 16 | id.offset; // frobnicate handle
SegManager *segMan = _vm->_gamestate->_segMan; // for PUT_SEL32V
if (id.segment) { if (id.segment) {
SegManager *segMan = _vm->_gamestate->_segMan; // for PUT_SEL32V
_vm->_gamestate->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); _vm->_gamestate->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
_vm->_gamestate->_sound.sfx_remove_song(handle); _vm->_gamestate->_sound.sfx_remove_song(handle);
PUT_SEL32V(id, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, id, signal, SIGNAL_OFFSET);
PUT_SEL32V(id, nodePtr, 0); PUT_SEL32V(segMan, id, nodePtr, 0);
PUT_SEL32V(id, handle, 0); PUT_SEL32V(segMan, id, handle, 0);
} }
return true; return true;

48
engines/sci/engine/kernel.h
View file

@ -150,33 +150,37 @@ enum SelectorInvocation {
kContinueOnInvalidSelector = 1 kContinueOnInvalidSelector = 1
}; };
#define GET_SEL32(_o_, _slc_) read_selector(segMan, _o_, ((SciEngine*)g_engine)->getKernel()->_selectorCache._slc_, __FILE__, __LINE__) /**
#define GET_SEL32V(_o_, _slc_) (GET_SEL32(_o_, _slc_).offset) * Retrieves a selector from an object.
/* Retrieves a selector from an object * @param segMan the segment mananger
** Parameters: (reg_t) object: The address of the object which the selector should be read from * @param _obj_ the address of the object which the selector should be read from
** (selector_name) selector: The selector to read * @param _slc_ the selector to read
** Returns : (int16/uint16/reg_t) The selector value * @return the selector value as a reg_t
** This macro halts on error. 'selector' must be a selector name registered in vm.h's * This macro halts on error. 'selector' must be a selector name registered in vm.h's
** SelectorCache and mapped in script.cpp. * SelectorCache and mapped in script.cpp.
*/ */
#define GET_SEL32(segMan, _obj_, _slc_) read_selector(segMan, _obj_, ((SciEngine*)g_engine)->getKernel()->_selectorCache._slc_, __FILE__, __LINE__)
#define GET_SEL32V(segMan, _obj_, _slc_) (GET_SEL32(segMan, _obj_, _slc_).offset)
#define PUT_SEL32(_o_, _slc_, _val_) write_selector(segMan, _o_, ((SciEngine*)g_engine)->getKernel()->_selectorCache._slc_, _val_, __FILE__, __LINE__) /**
#define PUT_SEL32V(_o_, _slc_, _val_) PUT_SEL32(_o_, _slc_, make_reg(0, _val_)) * Writes a selector value to an object.
/* Writes a selector value to an object * @param segMan the segment mananger
** Parameters: (reg_t) object: The address of the object which the selector should be written to * @param _obj_ the address of the object which the selector should be written to
** (selector_name) selector: The selector to read * @param _slc_ the selector to read
** (int16) value: The value to write * @param _val_ the value to write
** Returns : (void) * This macro halts on error. 'selector' must be a selector name registered in vm.h's
** This macro halts on error. 'selector' must be a selector name registered in vm.h's * SelectorCache and mapped in script.cpp.
** SelectorCache and mapped in script.cpp. */
*/ #define PUT_SEL32(segMan, _obj_, _slc_, _val_) write_selector(segMan, _obj_, ((SciEngine*)g_engine)->getKernel()->_selectorCache._slc_, _val_, __FILE__, __LINE__)
#define PUT_SEL32V(segMan, _obj_, _slc_, _val_) PUT_SEL32(segMan, _obj_, _slc_, make_reg(0, _val_))
/**
* Kludge for use with invoke_selector(). Used for compatibility with compilers
* that cannot handle vararg macros.
*/
#define INV_SEL(_object_, _selector_, _noinvalid_) \ #define INV_SEL(_object_, _selector_, _noinvalid_) \
s, _object_, s->_kernel->_selectorCache._selector_, _noinvalid_, argv, argc, __FILE__, __LINE__ s, _object_, s->_kernel->_selectorCache._selector_, _noinvalid_, argv, argc, __FILE__, __LINE__
/* Kludge for use with invoke_selector(). Used for compatibility with compilers that can't
** handle vararg macros.
*/
reg_t read_selector(SegManager *segMan, reg_t object, Selector selector_id, const char *fname, int line); reg_t read_selector(SegManager *segMan, reg_t object, Selector selector_id, const char *fname, int line);

50
engines/sci/engine/kevent.cpp
View file

@ -49,11 +49,11 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
// If there's a simkey pending, and the game wants a keyboard event, use the // If there's a simkey pending, and the game wants a keyboard event, use the
// simkey instead of a normal event // simkey instead of a normal event
if (g_debug_simulated_key && (mask & SCI_EVT_KEYBOARD)) { if (g_debug_simulated_key && (mask & SCI_EVT_KEYBOARD)) {
PUT_SEL32V(obj, type, SCI_EVT_KEYBOARD); // Keyboard event PUT_SEL32V(segMan, obj, type, SCI_EVT_KEYBOARD); // Keyboard event
PUT_SEL32V(obj, message, g_debug_simulated_key); PUT_SEL32V(segMan, obj, message, g_debug_simulated_key);
PUT_SEL32V(obj, modifiers, SCI_EVM_NUMLOCK); // Numlock on PUT_SEL32V(segMan, obj, modifiers, SCI_EVM_NUMLOCK); // Numlock on
PUT_SEL32V(obj, x, mousePos.x); PUT_SEL32V(segMan, obj, x, mousePos.x);
PUT_SEL32V(obj, y, mousePos.y); PUT_SEL32V(segMan, obj, y, mousePos.y);
g_debug_simulated_key = 0; g_debug_simulated_key = 0;
return make_reg(0, 1); return make_reg(0, 1);
} }
@ -64,8 +64,8 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
s->parser_event = NULL_REG; // Invalidate parser event s->parser_event = NULL_REG; // Invalidate parser event
PUT_SEL32V(obj, x, mousePos.x); PUT_SEL32V(segMan, obj, x, mousePos.x);
PUT_SEL32V(obj, y, mousePos.y); PUT_SEL32V(segMan, obj, y, mousePos.y);
//s->_gui->moveCursor(s->gfx_state->pointer_pos.x, s->gfx_state->pointer_pos.y); //s->_gui->moveCursor(s->gfx_state->pointer_pos.x, s->gfx_state->pointer_pos.y);
@ -84,12 +84,12 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
g_debugState.seeking = kDebugSeekNothing; g_debugState.seeking = kDebugSeekNothing;
g_debugState.runningStep = 0; g_debugState.runningStep = 0;
} else { } else {
PUT_SEL32V(obj, type, SCI_EVT_KEYBOARD); // Keyboard event PUT_SEL32V(segMan, obj, type, SCI_EVT_KEYBOARD); // Keyboard event
s->r_acc = make_reg(0, 1); s->r_acc = make_reg(0, 1);
PUT_SEL32V(obj, message, e.character); PUT_SEL32V(segMan, obj, message, e.character);
// We only care about the translated // We only care about the translated
// character // character
PUT_SEL32V(obj, modifiers, e.buckybits&modifier_mask); PUT_SEL32V(segMan, obj, modifiers, e.buckybits&modifier_mask);
} }
break; break;
@ -115,9 +115,9 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
break; break;
} }
PUT_SEL32V(obj, type, e.type); PUT_SEL32V(segMan, obj, type, e.type);
PUT_SEL32V(obj, message, 0); PUT_SEL32V(segMan, obj, message, 0);
PUT_SEL32V(obj, modifiers, (e.buckybits | extra_bits)&modifier_mask); PUT_SEL32V(segMan, obj, modifiers, (e.buckybits | extra_bits)&modifier_mask);
s->r_acc = make_reg(0, 1); s->r_acc = make_reg(0, 1);
} }
break; break;
@ -158,9 +158,9 @@ reg_t kMapKeyToDir(EngineState *s, int argc, reg_t *argv) {
reg_t obj = argv[0]; reg_t obj = argv[0];
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
if (GET_SEL32V(obj, type) == SCI_EVT_KEYBOARD) { // Keyboard if (GET_SEL32V(segMan, obj, type) == SCI_EVT_KEYBOARD) { // Keyboard
int mover = -1; int mover = -1;
switch (GET_SEL32V(obj, message)) { switch (GET_SEL32V(segMan, obj, message)) {
case SCI_K_HOME: case SCI_K_HOME:
mover = 8; mover = 8;
break; break;
@ -194,8 +194,8 @@ reg_t kMapKeyToDir(EngineState *s, int argc, reg_t *argv) {
} }
if (mover >= 0) { if (mover >= 0) {
PUT_SEL32V(obj, type, SCI_EVT_JOYSTICK); PUT_SEL32V(segMan, obj, type, SCI_EVT_JOYSTICK);
PUT_SEL32V(obj, message, mover); PUT_SEL32V(segMan, obj, message, mover);
return make_reg(0, 1); return make_reg(0, 1);
} else } else
return NULL_REG; return NULL_REG;
@ -209,13 +209,13 @@ reg_t kGlobalToLocal(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
if (obj.segment) { if (obj.segment) {
int16 x = GET_SEL32V(obj, x); int16 x = GET_SEL32V(segMan, obj, x);
int16 y = GET_SEL32V(obj, y); int16 y = GET_SEL32V(segMan, obj, y);
s->_gui->globalToLocal(&x, &y); s->_gui->globalToLocal(&x, &y);
PUT_SEL32V(obj, x, x); PUT_SEL32V(segMan, obj, x, x);
PUT_SEL32V(obj, y, y); PUT_SEL32V(segMan, obj, y, y);
} }
return s->r_acc; return s->r_acc;
@ -227,13 +227,13 @@ reg_t kLocalToGlobal(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
if (obj.segment) { if (obj.segment) {
int16 x = GET_SEL32V(obj, x); int16 x = GET_SEL32V(segMan, obj, x);
int16 y = GET_SEL32V(obj, y); int16 y = GET_SEL32V(segMan, obj, y);
s->_gui->localToGlobal(&x, &y); s->_gui->localToGlobal(&x, &y);
PUT_SEL32V(obj, x, x); PUT_SEL32V(segMan, obj, x, x);
PUT_SEL32V(obj, y, y); PUT_SEL32V(segMan, obj, y, y);
} }
return s->r_acc; return s->r_acc;

66
engines/sci/engine/kgraphics.cpp
View file

@ -61,8 +61,8 @@ enum {
void _k_dirloop(reg_t obj, uint16 angle, EngineState *s, int argc, reg_t *argv) { void _k_dirloop(reg_t obj, uint16 angle, EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
int view = GET_SEL32V(obj, view); int view = GET_SEL32V(segMan, obj, view);
int signal = GET_SEL32V(obj, signal); int signal = GET_SEL32V(segMan, obj, signal);
int loop; int loop;
int maxloops; int maxloops;
bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY); bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
@ -100,7 +100,7 @@ void _k_dirloop(reg_t obj, uint16 angle, EngineState *s, int argc, reg_t *argv)
if ((loop > 1) && (maxloops < 4)) if ((loop > 1) && (maxloops < 4))
return; return;
PUT_SEL32V(obj, loop, loop); PUT_SEL32V(segMan, obj, loop, loop);
} }
static reg_t kSetCursorSci0(EngineState *s, int argc, reg_t *argv) { static reg_t kSetCursorSci0(EngineState *s, int argc, reg_t *argv) {
@ -443,7 +443,7 @@ reg_t kCelWide(EngineState *s, int argc, reg_t *argv) {
reg_t kNumLoops(EngineState *s, int argc, reg_t *argv) { reg_t kNumLoops(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
reg_t obj = argv[0]; reg_t obj = argv[0];
int view = GET_SEL32V(obj, view); int view = GET_SEL32V(segMan, obj, view);
int loops_nr = gfxop_lookup_view_get_loops(s->gfx_state, view); int loops_nr = gfxop_lookup_view_get_loops(s->gfx_state, view);
if (loops_nr < 0) { if (loops_nr < 0) {
@ -459,8 +459,8 @@ reg_t kNumLoops(EngineState *s, int argc, reg_t *argv) {
reg_t kNumCels(EngineState *s, int argc, reg_t *argv) { reg_t kNumCels(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
reg_t obj = argv[0]; reg_t obj = argv[0];
int loop = GET_SEL32V(obj, loop); int loop = GET_SEL32V(segMan, obj, loop);
int view = GET_SEL32V(obj, view); int view = GET_SEL32V(segMan, obj, view);
int cel = 0xffff; int cel = 0xffff;
gfxop_check_cel(s->gfx_state, view, &loop, &cel); gfxop_check_cel(s->gfx_state, view, &loop, &cel);
@ -544,10 +544,10 @@ reg_t kBaseSetter(EngineState *s, int argc, reg_t *argv) {
Common::Rect absrect = set_base(s, object); Common::Rect absrect = set_base(s, object);
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
PUT_SEL32V(object, brLeft, absrect.left); PUT_SEL32V(segMan, object, brLeft, absrect.left);
PUT_SEL32V(object, brRight, absrect.right); PUT_SEL32V(segMan, object, brRight, absrect.right);
PUT_SEL32V(object, brTop, absrect.top); PUT_SEL32V(segMan, object, brTop, absrect.top);
PUT_SEL32V(object, brBottom, absrect.bottom); PUT_SEL32V(segMan, object, brBottom, absrect.bottom);
} }
return s->r_acc; return s->r_acc;
@ -620,12 +620,12 @@ reg_t kPalVary(EngineState *s, int argc, reg_t *argv) {
} }
static void disableCertainButtons(SegManager *segMan, Common::String gameName, reg_t obj) { static void disableCertainButtons(SegManager *segMan, Common::String gameName, reg_t obj) {
reg_t text_pos = GET_SEL32(obj, text); reg_t text_pos = GET_SEL32(segMan, obj, text);
Common::String text; Common::String text;
if (!text_pos.isNull()) if (!text_pos.isNull())
text = segMan->getString(text_pos); text = segMan->getString(text_pos);
int type = GET_SEL32V(obj, type); int type = GET_SEL32V(segMan, obj, type);
int state = GET_SEL32V(obj, state); int state = GET_SEL32V(segMan, obj, state);
/* /*
* WORKAROUND: The function is a "prevent the user from doing something * WORKAROUND: The function is a "prevent the user from doing something
@ -649,25 +649,25 @@ static void disableCertainButtons(SegManager *segMan, Common::String gameName, r
// NOTE: This _only_ works with the English version // NOTE: This _only_ works with the English version
if (type == SCI_CONTROLS_TYPE_BUTTON && (gameName == "sq4") && if (type == SCI_CONTROLS_TYPE_BUTTON && (gameName == "sq4") &&
getSciVersion() < SCI_VERSION_1_1 && text == " Delete ") { getSciVersion() < SCI_VERSION_1_1 && text == " Delete ") {
PUT_SEL32V(obj, state, (state | kControlStateDisabled) & ~kControlStateEnabled); PUT_SEL32V(segMan, obj, state, (state | kControlStateDisabled) & ~kControlStateEnabled);
} }
// Disable the "Change Directory" button, as we don't allow the game engine to // Disable the "Change Directory" button, as we don't allow the game engine to
// change the directory where saved games are placed // change the directory where saved games are placed
// NOTE: This _only_ works with the English version // NOTE: This _only_ works with the English version
if (type == SCI_CONTROLS_TYPE_BUTTON && text == "Change\r\nDirectory") { if (type == SCI_CONTROLS_TYPE_BUTTON && text == "Change\r\nDirectory") {
PUT_SEL32V(obj, state, (state | kControlStateDisabled) & ~kControlStateEnabled); PUT_SEL32V(segMan, obj, state, (state | kControlStateDisabled) & ~kControlStateEnabled);
} }
} }
void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) { void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
int16 type = GET_SEL32V(controlObject, type); int16 type = GET_SEL32V(segMan, controlObject, type);
int16 style = GET_SEL32V(controlObject, state); int16 style = GET_SEL32V(segMan, controlObject, state);
int16 x = GET_SEL32V(controlObject, nsLeft); int16 x = GET_SEL32V(segMan, controlObject, nsLeft);
int16 y = GET_SEL32V(controlObject, nsTop); int16 y = GET_SEL32V(segMan, controlObject, nsTop);
GuiResourceId fontId = GET_SEL32V(controlObject, font); GuiResourceId fontId = GET_SEL32V(segMan, controlObject, font);
reg_t textReference = GET_SEL32(controlObject, text); reg_t textReference = GET_SEL32(segMan, controlObject, text);
Common::String text; Common::String text;
Common::Rect rect; Common::Rect rect;
GuiTextAlignment alignment; GuiTextAlignment alignment;
@ -681,7 +681,7 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
const char **listEntries = NULL; const char **listEntries = NULL;
bool isAlias = false; bool isAlias = false;
kGraphCreateRect(x, y, GET_SEL32V(controlObject, nsRight), GET_SEL32V(controlObject, nsBottom), &rect); kGraphCreateRect(x, y, GET_SEL32V(segMan, controlObject, nsRight), GET_SEL32V(segMan, controlObject, nsBottom), &rect);
if (!textReference.isNull()) if (!textReference.isNull())
text = segMan->getString(textReference); text = segMan->getString(textReference);
@ -693,25 +693,25 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
return; return;
case SCI_CONTROLS_TYPE_TEXT: case SCI_CONTROLS_TYPE_TEXT:
alignment = GET_SEL32V(controlObject, mode); alignment = GET_SEL32V(segMan, controlObject, mode);
debugC(2, kDebugLevelGraphics, "drawing text %04x:%04x ('%s') to %d,%d, mode=%d\n", PRINT_REG(controlObject), text.c_str(), x, y, alignment); debugC(2, kDebugLevelGraphics, "drawing text %04x:%04x ('%s') to %d,%d, mode=%d\n", PRINT_REG(controlObject), text.c_str(), x, y, alignment);
s->_gui->drawControlText(rect, controlObject, s->strSplit(text.c_str(), NULL).c_str(), fontId, alignment, style, hilite); s->_gui->drawControlText(rect, controlObject, s->strSplit(text.c_str(), NULL).c_str(), fontId, alignment, style, hilite);
return; return;
case SCI_CONTROLS_TYPE_TEXTEDIT: case SCI_CONTROLS_TYPE_TEXTEDIT:
mode = GET_SEL32V(controlObject, mode); mode = GET_SEL32V(segMan, controlObject, mode);
maxChars = GET_SEL32V(controlObject, max); maxChars = GET_SEL32V(segMan, controlObject, max);
cursorPos = GET_SEL32V(controlObject, cursor); cursorPos = GET_SEL32V(segMan, controlObject, cursor);
debugC(2, kDebugLevelGraphics, "drawing edit control %04x:%04x (text %04x:%04x, '%s') to %d,%d\n", PRINT_REG(controlObject), PRINT_REG(textReference), text.c_str(), x, y); debugC(2, kDebugLevelGraphics, "drawing edit control %04x:%04x (text %04x:%04x, '%s') to %d,%d\n", PRINT_REG(controlObject), PRINT_REG(textReference), text.c_str(), x, y);
s->_gui->drawControlTextEdit(rect, controlObject, s->strSplit(text.c_str(), NULL).c_str(), fontId, mode, style, cursorPos, maxChars, hilite); s->_gui->drawControlTextEdit(rect, controlObject, s->strSplit(text.c_str(), NULL).c_str(), fontId, mode, style, cursorPos, maxChars, hilite);
return; return;
case SCI_CONTROLS_TYPE_ICON: case SCI_CONTROLS_TYPE_ICON:
viewId = GET_SEL32V(controlObject, view); viewId = GET_SEL32V(segMan, controlObject, view);
{ {
int l = GET_SEL32V(controlObject, loop); int l = GET_SEL32V(segMan, controlObject, loop);
loopNo = (l & 0x80) ? l - 256 : l; loopNo = (l & 0x80) ? l - 256 : l;
int c = GET_SEL32V(controlObject, cel); int c = GET_SEL32V(segMan, controlObject, cel);
celNo = (c & 0x80) ? c - 256 : c; celNo = (c & 0x80) ? c - 256 : c;
} }
debugC(2, kDebugLevelGraphics, "drawing icon control %04x:%04x to %d,%d\n", PRINT_REG(controlObject), x, y - 1); debugC(2, kDebugLevelGraphics, "drawing icon control %04x:%04x to %d,%d\n", PRINT_REG(controlObject), x, y - 1);
@ -723,18 +723,18 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
if (type == SCI_CONTROLS_TYPE_LIST_ALIAS) if (type == SCI_CONTROLS_TYPE_LIST_ALIAS)
isAlias = true; isAlias = true;
maxChars = GET_SEL32V(controlObject, x); // max chars per entry maxChars = GET_SEL32V(segMan, controlObject, x); // max chars per entry
// NOTE: most types of pointer dereferencing don't like odd offsets // NOTE: most types of pointer dereferencing don't like odd offsets
if (maxChars & 1) { if (maxChars & 1) {
warning("List control with odd maxChars %d. This is not yet implemented for all types of segments", maxChars); warning("List control with odd maxChars %d. This is not yet implemented for all types of segments", maxChars);
} }
cursorOffset = GET_SEL32V(controlObject, cursor); cursorOffset = GET_SEL32V(segMan, controlObject, cursor);
if (s->_kernel->_selectorCache.topString != -1) { if (s->_kernel->_selectorCache.topString != -1) {
// Games from early SCI1 onwards use topString // Games from early SCI1 onwards use topString
upperOffset = GET_SEL32V(controlObject, topString); upperOffset = GET_SEL32V(segMan, controlObject, topString);
} else { } else {
// Earlier games use lsTop // Earlier games use lsTop
upperOffset = GET_SEL32V(controlObject, lsTop); upperOffset = GET_SEL32V(segMan, controlObject, lsTop);
} }
// Count string entries in NULL terminated string list // Count string entries in NULL terminated string list

10
engines/sci/engine/klists.cpp
View file

@ -389,11 +389,11 @@ reg_t kSort(EngineState *s, int argc, reg_t *argv) {
reg_t dest = argv[1]; reg_t dest = argv[1];
reg_t order_func = argv[2]; reg_t order_func = argv[2];
int input_size = (int16)GET_SEL32V(source, size); int input_size = (int16)GET_SEL32V(segMan, source, size);
int i; int i;
reg_t input_data = GET_SEL32(source, elements); reg_t input_data = GET_SEL32(segMan, source, elements);
reg_t output_data = GET_SEL32(dest, elements); reg_t output_data = GET_SEL32(segMan, dest, elements);
List *list; List *list;
Node *node; Node *node;
@ -404,10 +404,10 @@ reg_t kSort(EngineState *s, int argc, reg_t *argv) {
if (output_data.isNull()) { if (output_data.isNull()) {
list = s->_segMan->allocateList(&output_data); list = s->_segMan->allocateList(&output_data);
list->first = list->last = NULL_REG; list->first = list->last = NULL_REG;
PUT_SEL32(dest, elements, output_data); PUT_SEL32(segMan, dest, elements, output_data);
} }
PUT_SEL32V(dest, size, input_size); PUT_SEL32V(segMan, dest, size, input_size);
list = s->_segMan->lookupList(input_data); list = s->_segMan->lookupList(input_data);
node = s->_segMan->lookupNode(list->first); node = s->_segMan->lookupNode(list->first);

8
engines/sci/engine/kmenu.cpp
View file

@ -114,9 +114,9 @@ reg_t kMenuSelect(EngineState *s, int argc, reg_t *argv) {
reg_t event = argv[0]; reg_t event = argv[0];
/*int pause_sound = (argc > 1) ? argv[1].toUint16() : 1;*/ /* FIXME: Do this eventually */ /*int pause_sound = (argc > 1) ? argv[1].toUint16() : 1;*/ /* FIXME: Do this eventually */
bool claimed = false; bool claimed = false;
int type = GET_SEL32V(event, type); int type = GET_SEL32V(segMan, event, type);
int message = GET_SEL32V(event, message); int message = GET_SEL32V(segMan, event, message);
int modifiers = GET_SEL32V(event, modifiers); int modifiers = GET_SEL32V(segMan, event, modifiers);
int menu_nr = -1, item_nr = 0; int menu_nr = -1, item_nr = 0;
MenuItem *item; MenuItem *item;
int menu_mode = 0; /* Menu is active */ int menu_mode = 0; /* Menu is active */
@ -320,7 +320,7 @@ reg_t kMenuSelect(EngineState *s, int argc, reg_t *argv) {
} }
if (claimed) { if (claimed) {
PUT_SEL32(event, claimed, make_reg(0, 1)); PUT_SEL32(segMan, event, claimed, make_reg(0, 1));
if (menu_nr > -1) { if (menu_nr > -1) {
s->r_acc = make_reg(0, ((menu_nr + 1) << 8) | (item_nr + 1)); s->r_acc = make_reg(0, ((menu_nr + 1) << 8) | (item_nr + 1));

124
engines/sci/engine/kmovement.cpp
View file

@ -155,8 +155,8 @@ reg_t kSetJump(EngineState *s, int argc, reg_t *argv) {
debugC(2, kDebugLevelBresen, "SetJump for object at %04x:%04x\n", PRINT_REG(object)); debugC(2, kDebugLevelBresen, "SetJump for object at %04x:%04x\n", PRINT_REG(object));
debugC(2, kDebugLevelBresen, "xStep: %d, yStep: %d\n", vx, vy); debugC(2, kDebugLevelBresen, "xStep: %d, yStep: %d\n", vx, vy);
PUT_SEL32V(object, xStep, vx); PUT_SEL32V(segMan, object, xStep, vx);
PUT_SEL32V(object, yStep, vy); PUT_SEL32V(segMan, object, yStep, vy);
return s->r_acc; return s->r_acc;
} }
@ -165,9 +165,9 @@ reg_t kSetJump(EngineState *s, int argc, reg_t *argv) {
#define _K_BRESEN_AXIS_Y 1 #define _K_BRESEN_AXIS_Y 1
static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t mover, int step_factor, int deltax, int deltay) { static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t mover, int step_factor, int deltax, int deltay) {
reg_t client = GET_SEL32(mover, client); reg_t client = GET_SEL32(segMan, mover, client);
int stepx = (int16)GET_SEL32V(client, xStep) * step_factor; int stepx = (int16)GET_SEL32V(segMan, client, xStep) * step_factor;
int stepy = (int16)GET_SEL32V(client, yStep) * step_factor; int stepy = (int16)GET_SEL32V(segMan, client, yStep) * step_factor;
int numsteps_x = stepx ? (abs(deltax) + stepx - 1) / stepx : 0; int numsteps_x = stepx ? (abs(deltax) + stepx - 1) / stepx : 0;
int numsteps_y = stepy ? (abs(deltay) + stepy - 1) / stepy : 0; int numsteps_y = stepy ? (abs(deltay) + stepy - 1) / stepy : 0;
int bdi, i1; int bdi, i1;
@ -188,15 +188,15 @@ static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t m
/* if (abs(deltax) > abs(deltay)) {*/ // Bresenham on y /* if (abs(deltax) > abs(deltay)) {*/ // Bresenham on y
if (numsteps_y < numsteps_x) { if (numsteps_y < numsteps_x) {
PUT_SEL32V(mover, b_xAxis, _K_BRESEN_AXIS_Y); PUT_SEL32V(segMan, mover, b_xAxis, _K_BRESEN_AXIS_Y);
PUT_SEL32V(mover, b_incr, (deltay < 0) ? -1 : 1); PUT_SEL32V(segMan, mover, b_incr, (deltay < 0) ? -1 : 1);
//i1 = 2 * (abs(deltay) - abs(deltay_step * numsteps)) * abs(deltax_step); //i1 = 2 * (abs(deltay) - abs(deltay_step * numsteps)) * abs(deltax_step);
//bdi = -abs(deltax); //bdi = -abs(deltax);
i1 = 2 * (abs(deltay) - abs(deltay_step * (numsteps - 1))) * abs(deltax_step); i1 = 2 * (abs(deltay) - abs(deltay_step * (numsteps - 1))) * abs(deltax_step);
bdi = -abs(deltax); bdi = -abs(deltax);
} else { // Bresenham on x } else { // Bresenham on x
PUT_SEL32V(mover, b_xAxis, _K_BRESEN_AXIS_X); PUT_SEL32V(segMan, mover, b_xAxis, _K_BRESEN_AXIS_X);
PUT_SEL32V(mover, b_incr, (deltax < 0) ? -1 : 1); PUT_SEL32V(segMan, mover, b_incr, (deltax < 0) ? -1 : 1);
//i1= 2 * (abs(deltax) - abs(deltax_step * numsteps)) * abs(deltay_step); //i1= 2 * (abs(deltax) - abs(deltax_step * numsteps)) * abs(deltay_step);
//bdi = -abs(deltay); //bdi = -abs(deltay);
i1 = 2 * (abs(deltax) - abs(deltax_step * (numsteps - 1))) * abs(deltay_step); i1 = 2 * (abs(deltax) - abs(deltax_step * (numsteps - 1))) * abs(deltay_step);
@ -204,26 +204,26 @@ static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t m
} }
PUT_SEL32V(mover, dx, deltax_step); PUT_SEL32V(segMan, mover, dx, deltax_step);
PUT_SEL32V(mover, dy, deltay_step); PUT_SEL32V(segMan, mover, dy, deltay_step);
debugC(2, kDebugLevelBresen, "Init bresen for mover %04x:%04x: d=(%d,%d)\n", PRINT_REG(mover), deltax, deltay); debugC(2, kDebugLevelBresen, "Init bresen for mover %04x:%04x: d=(%d,%d)\n", PRINT_REG(mover), deltax, deltay);
debugC(2, kDebugLevelBresen, " steps=%d, mv=(%d, %d), i1= %d, i2=%d\n", debugC(2, kDebugLevelBresen, " steps=%d, mv=(%d, %d), i1= %d, i2=%d\n",
numsteps, deltax_step, deltay_step, i1, bdi*2); numsteps, deltax_step, deltay_step, i1, bdi*2);
//PUT_SEL32V(mover, b_movCnt, numsteps); // Needed for HQ1/Ogre? //PUT_SEL32V(segMan, mover, b_movCnt, numsteps); // Needed for HQ1/Ogre?
PUT_SEL32V(mover, b_di, bdi); PUT_SEL32V(segMan, mover, b_di, bdi);
PUT_SEL32V(mover, b_i1, i1); PUT_SEL32V(segMan, mover, b_i1, i1);
PUT_SEL32V(mover, b_i2, bdi * 2); PUT_SEL32V(segMan, mover, b_i2, bdi * 2);
} }
reg_t kInitBresen(EngineState *s, int argc, reg_t *argv) { reg_t kInitBresen(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
reg_t mover = argv[0]; reg_t mover = argv[0];
reg_t client = GET_SEL32(mover, client); reg_t client = GET_SEL32(segMan, mover, client);
int deltax = (int16)GET_SEL32V(mover, x) - (int16)GET_SEL32V(client, x); int deltax = (int16)GET_SEL32V(segMan, mover, x) - (int16)GET_SEL32V(segMan, client, x);
int deltay = (int16)GET_SEL32V(mover, y) - (int16)GET_SEL32V(client, y); int deltay = (int16)GET_SEL32V(segMan, mover, y) - (int16)GET_SEL32V(segMan, client, y);
int step_factor = (argc < 1) ? argv[1].toUint16() : 1; int step_factor = (argc < 1) ? argv[1].toUint16() : 1;
initialize_bresen(s->_segMan, argc, argv, mover, step_factor, deltax, deltay); initialize_bresen(s->_segMan, argc, argv, mover, step_factor, deltax, deltay);
@ -237,42 +237,42 @@ reg_t kInitBresen(EngineState *s, int argc, reg_t *argv) {
reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) { reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
reg_t mover = argv[0]; reg_t mover = argv[0];
reg_t client = GET_SEL32(mover, client); reg_t client = GET_SEL32(segMan, mover, client);
int x = (int16)GET_SEL32V(client, x); int x = (int16)GET_SEL32V(segMan, client, x);
int y = (int16)GET_SEL32V(client, y); int y = (int16)GET_SEL32V(segMan, client, y);
int oldx, oldy, destx, desty, dx, dy, bdi, bi1, bi2, movcnt, bdelta, axis; int oldx, oldy, destx, desty, dx, dy, bdi, bi1, bi2, movcnt, bdelta, axis;
uint16 signal = GET_SEL32V(client, signal); uint16 signal = GET_SEL32V(segMan, client, signal);
int completed = 0; int completed = 0;
int max_movcnt = GET_SEL32V(client, moveSpeed); int max_movcnt = GET_SEL32V(segMan, client, moveSpeed);
if (getSciVersion() > SCI_VERSION_01) if (getSciVersion() > SCI_VERSION_01)
signal &= ~_K_VIEW_SIG_FLAG_HIT_OBSTACLE; signal &= ~_K_VIEW_SIG_FLAG_HIT_OBSTACLE;
PUT_SEL32(client, signal, make_reg(0, signal)); // This is a NOP for SCI0 PUT_SEL32(segMan, client, signal, make_reg(0, signal)); // This is a NOP for SCI0
oldx = x; oldx = x;
oldy = y; oldy = y;
destx = (int16)GET_SEL32V(mover, x); destx = (int16)GET_SEL32V(segMan, mover, x);
desty = (int16)GET_SEL32V(mover, y); desty = (int16)GET_SEL32V(segMan, mover, y);
dx = (int16)GET_SEL32V(mover, dx); dx = (int16)GET_SEL32V(segMan, mover, dx);
dy = (int16)GET_SEL32V(mover, dy); dy = (int16)GET_SEL32V(segMan, mover, dy);
bdi = (int16)GET_SEL32V(mover, b_di); bdi = (int16)GET_SEL32V(segMan, mover, b_di);
bi1 = (int16)GET_SEL32V(mover, b_i1); bi1 = (int16)GET_SEL32V(segMan, mover, b_i1);
bi2 = (int16)GET_SEL32V(mover, b_i2); bi2 = (int16)GET_SEL32V(segMan, mover, b_i2);
movcnt = GET_SEL32V(mover, b_movCnt); movcnt = GET_SEL32V(segMan, mover, b_movCnt);
bdelta = (int16)GET_SEL32V(mover, b_incr); bdelta = (int16)GET_SEL32V(segMan, mover, b_incr);
axis = (int16)GET_SEL32V(mover, b_xAxis); axis = (int16)GET_SEL32V(segMan, mover, b_xAxis);
//printf("movecnt %d, move speed %d\n", movcnt, max_movcnt); //printf("movecnt %d, move speed %d\n", movcnt, max_movcnt);
if (s->handleMoveCount()) { if (s->handleMoveCount()) {
if (max_movcnt > movcnt) { if (max_movcnt > movcnt) {
++movcnt; ++movcnt;
PUT_SEL32V(mover, b_movCnt, movcnt); // Needed for HQ1/Ogre? PUT_SEL32V(segMan, mover, b_movCnt, movcnt); // Needed for HQ1/Ogre?
return NULL_REG; return NULL_REG;
} else { } else {
movcnt = 0; movcnt = 0;
PUT_SEL32V(mover, b_movCnt, movcnt); // Needed for HQ1/Ogre? PUT_SEL32V(segMan, mover, b_movCnt, movcnt); // Needed for HQ1/Ogre?
} }
} }
@ -285,7 +285,7 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
dy += bdelta; dy += bdelta;
} }
PUT_SEL32V(mover, b_di, bdi); PUT_SEL32V(segMan, mover, b_di, bdi);
x += dx; x += dx;
y += dy; y += dy;
@ -307,8 +307,8 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x\n", PRINT_REG(mover)); debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x\n", PRINT_REG(mover));
} }
PUT_SEL32V(client, x, x); PUT_SEL32V(segMan, client, x, x);
PUT_SEL32V(client, y, y); PUT_SEL32V(segMan, client, y, y);
debugC(2, kDebugLevelBresen, "New data: (x,y)=(%d,%d), di=%d\n", x, y, bdi); debugC(2, kDebugLevelBresen, "New data: (x,y)=(%d,%d), di=%d\n", x, y, bdi);
@ -320,11 +320,11 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
} }
if (!s->r_acc.offset) { // Contains the return value if (!s->r_acc.offset) { // Contains the return value
signal = GET_SEL32V(client, signal); signal = GET_SEL32V(segMan, client, signal);
PUT_SEL32V(client, x, oldx); PUT_SEL32V(segMan, client, x, oldx);
PUT_SEL32V(client, y, oldy); PUT_SEL32V(segMan, client, y, oldy);
PUT_SEL32V(client, signal, (signal | _K_VIEW_SIG_FLAG_HIT_OBSTACLE)); PUT_SEL32V(segMan, client, signal, (signal | _K_VIEW_SIG_FLAG_HIT_OBSTACLE));
debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x by collision\n", PRINT_REG(mover)); debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x by collision\n", PRINT_REG(mover));
completed = 1; completed = 1;
@ -356,15 +356,15 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
return NULL_REG; return NULL_REG;
} }
client = GET_SEL32(avoider, client); client = GET_SEL32(segMan, avoider, client);
if (!s->_segMan->isHeapObject(client)) { if (!s->_segMan->isHeapObject(client)) {
warning("DoAvoider() where client %04x:%04x is not an object", PRINT_REG(client)); warning("DoAvoider() where client %04x:%04x is not an object", PRINT_REG(client));
return NULL_REG; return NULL_REG;
} }
looper = GET_SEL32(client, looper); looper = GET_SEL32(segMan, client, looper);
mover = GET_SEL32(client, mover); mover = GET_SEL32(segMan, client, mover);
if (!s->_segMan->isHeapObject(mover)) { if (!s->_segMan->isHeapObject(mover)) {
if (mover.segment) { if (mover.segment) {
@ -373,8 +373,8 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
return s->r_acc; return s->r_acc;
} }
destx = GET_SEL32V(mover, x); destx = GET_SEL32V(segMan, mover, x);
desty = GET_SEL32V(mover, y); desty = GET_SEL32V(segMan, mover, y);
debugC(2, kDebugLevelBresen, "Doing avoider %04x:%04x (dest=%d,%d)\n", PRINT_REG(avoider), destx, desty); debugC(2, kDebugLevelBresen, "Doing avoider %04x:%04x (dest=%d,%d)\n", PRINT_REG(avoider), destx, desty);
@ -383,7 +383,7 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
return NULL_REG; return NULL_REG;
} }
mover = GET_SEL32(client, mover); mover = GET_SEL32(segMan, client, mover);
if (!mover.segment) // Mover has been disposed? if (!mover.segment) // Mover has been disposed?
return s->r_acc; // Return gracefully. return s->r_acc; // Return gracefully.
@ -393,18 +393,18 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
return NULL_REG; return NULL_REG;
} }
dx = destx - GET_SEL32V(client, x); dx = destx - GET_SEL32V(segMan, client, x);
dy = desty - GET_SEL32V(client, y); dy = desty - GET_SEL32V(segMan, client, y);
angle = get_angle(dx, dy); angle = get_angle(dx, dy);
debugC(2, kDebugLevelBresen, "Movement (%d,%d), angle %d is %sblocked\n", dx, dy, angle, (s->r_acc.offset) ? " " : "not "); debugC(2, kDebugLevelBresen, "Movement (%d,%d), angle %d is %sblocked\n", dx, dy, angle, (s->r_acc.offset) ? " " : "not ");
if (s->r_acc.offset) { // isBlocked() returned non-zero if (s->r_acc.offset) { // isBlocked() returned non-zero
int rotation = (rand() & 1) ? 45 : (360 - 45); // Clockwise/counterclockwise int rotation = (rand() & 1) ? 45 : (360 - 45); // Clockwise/counterclockwise
int oldx = GET_SEL32V(client, x); int oldx = GET_SEL32V(segMan, client, x);
int oldy = GET_SEL32V(client, y); int oldy = GET_SEL32V(segMan, client, y);
int xstep = GET_SEL32V(client, xStep); int xstep = GET_SEL32V(segMan, client, xStep);
int ystep = GET_SEL32V(client, yStep); int ystep = GET_SEL32V(segMan, client, yStep);
int moves; int moves;
debugC(2, kDebugLevelBresen, " avoider %04x:%04x\n", PRINT_REG(avoider)); debugC(2, kDebugLevelBresen, " avoider %04x:%04x\n", PRINT_REG(avoider));
@ -413,8 +413,8 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
int move_x = (int)(sin(angle * PI / 180.0) * (xstep)); int move_x = (int)(sin(angle * PI / 180.0) * (xstep));
int move_y = (int)(-cos(angle * PI / 180.0) * (ystep)); int move_y = (int)(-cos(angle * PI / 180.0) * (ystep));
PUT_SEL32V(client, x, oldx + move_x); PUT_SEL32V(segMan, client, x, oldx + move_x);
PUT_SEL32V(client, y, oldy + move_y); PUT_SEL32V(segMan, client, y, oldy + move_y);
debugC(2, kDebugLevelBresen, "Pos (%d,%d): Trying angle %d; delta=(%d,%d)\n", oldx, oldy, angle, move_x, move_y); debugC(2, kDebugLevelBresen, "Pos (%d,%d): Trying angle %d; delta=(%d,%d)\n", oldx, oldy, angle, move_x, move_y);
@ -424,12 +424,12 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
return NULL_REG; return NULL_REG;
} }
PUT_SEL32V(client, x, oldx); PUT_SEL32V(segMan, client, x, oldx);
PUT_SEL32V(client, y, oldy); PUT_SEL32V(segMan, client, y, oldy);
if (s->r_acc.offset) { // We can be here if (s->r_acc.offset) { // We can be here
debugC(2, kDebugLevelBresen, "Success\n"); debugC(2, kDebugLevelBresen, "Success\n");
PUT_SEL32V(client, heading, angle); PUT_SEL32V(segMan, client, heading, angle);
return make_reg(0, angle); return make_reg(0, angle);
} }
@ -442,12 +442,12 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
warning("DoAvoider failed for avoider %04x:%04x", PRINT_REG(avoider)); warning("DoAvoider failed for avoider %04x:%04x", PRINT_REG(avoider));
} else { } else {
int heading = GET_SEL32V(client, heading); int heading = GET_SEL32V(segMan, client, heading);
if (heading == -1) if (heading == -1)
return s->r_acc; // No change return s->r_acc; // No change
PUT_SEL32V(client, heading, angle); PUT_SEL32V(segMan, client, heading, angle);
s->r_acc = make_reg(0, angle); s->r_acc = make_reg(0, angle);

30
engines/sci/engine/kpathing.cpp
View file

@ -278,17 +278,17 @@ static Common::Point read_point(SegManager *segMan, reg_t list, int offset) {
*/ */
static bool polygons_equal(SegManager *segMan, reg_t p1, reg_t p2) { static bool polygons_equal(SegManager *segMan, reg_t p1, reg_t p2) {
// Check for same type // Check for same type
if (GET_SEL32(p1, type).toUint16() != GET_SEL32(p2, type).toUint16()) if (GET_SEL32(segMan, p1, type).toUint16() != GET_SEL32(segMan, p2, type).toUint16())
return false; return false;
int size = GET_SEL32(p1, size).toUint16(); int size = GET_SEL32(segMan, p1, size).toUint16();
// Check for same number of points // Check for same number of points
if (size != GET_SEL32(p2, size).toUint16()) if (size != GET_SEL32(segMan, p2, size).toUint16())
return false; return false;
reg_t p1_points = GET_SEL32(p1, points); reg_t p1_points = GET_SEL32(segMan, p1, points);
reg_t p2_points = GET_SEL32(p2, points); reg_t p2_points = GET_SEL32(segMan, p2, points);
// Check for the same points // Check for the same points
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
@ -346,9 +346,9 @@ static void draw_point(EngineState *s, Common::Point p, int start) {
static void draw_polygon(EngineState *s, reg_t polygon) { static void draw_polygon(EngineState *s, reg_t polygon) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
reg_t points = GET_SEL32(polygon, points); reg_t points = GET_SEL32(segMan, polygon, points);
int size = GET_SEL32(polygon, size).toUint16(); int size = GET_SEL32(segMan, polygon, size).toUint16();
int type = GET_SEL32(polygon, type).toUint16(); int type = GET_SEL32(segMan, polygon, type).toUint16();
Common::Point first, prev; Common::Point first, prev;
int i; int i;
@ -391,9 +391,9 @@ static void draw_input(EngineState *s, reg_t poly_list, Common::Point start, Com
#endif // DEBUG_AVOIDPATH #endif // DEBUG_AVOIDPATH
static void print_polygon(SegManager *segMan, reg_t polygon) { static void print_polygon(SegManager *segMan, reg_t polygon) {
reg_t points = GET_SEL32(polygon, points); reg_t points = GET_SEL32(segMan, polygon, points);
int size = GET_SEL32(polygon, size).toUint16(); int size = GET_SEL32(segMan, polygon, size).toUint16();
int type = GET_SEL32(polygon, type).toUint16(); int type = GET_SEL32(segMan, polygon, type).toUint16();
int i; int i;
Common::Point point; Common::Point point;
@ -1220,15 +1220,15 @@ static Polygon *convert_polygon(EngineState *s, reg_t polygon) {
// Returns : (Polygon *) The converted polygon, or NULL on error // Returns : (Polygon *) The converted polygon, or NULL on error
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
int i; int i;
reg_t points = GET_SEL32(polygon, points); reg_t points = GET_SEL32(segMan, polygon, points);
int size = GET_SEL32(polygon, size).toUint16(); int size = GET_SEL32(segMan, polygon, size).toUint16();
if (size == 0) { if (size == 0) {
// If the polygon has no vertices, we skip it // If the polygon has no vertices, we skip it
return NULL; return NULL;
} }
Polygon *poly = new Polygon(GET_SEL32(polygon, type).toUint16()); Polygon *poly = new Polygon(GET_SEL32(segMan, polygon, type).toUint16());
int skip = 0; int skip = 0;
@ -1388,7 +1388,7 @@ static PathfindingState *convert_polygon_set(EngineState *s, reg_t poly_list, Co
if (polygon) { if (polygon) {
pf_s->polygons.push_back(polygon); pf_s->polygons.push_back(polygon);
count += GET_SEL32(node->value, size).toUint16(); count += GET_SEL32(segMan, node->value, size).toUint16();
} }
} }

178
engines/sci/engine/ksound.cpp
View file

@ -131,9 +131,9 @@ enum AudioSyncCommands {
static void script_set_priority(EngineState *s, reg_t obj, int priority) { static void script_set_priority(EngineState *s, reg_t obj, int priority) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
int song_nr = GET_SEL32V(obj, number); int song_nr = GET_SEL32V(segMan, obj, number);
Resource *song = s->resMan->findResource(ResourceId(kResourceTypeSound, song_nr), 0); Resource *song = s->resMan->findResource(ResourceId(kResourceTypeSound, song_nr), 0);
int flags = GET_SEL32V(obj, flags); int flags = GET_SEL32V(segMan, obj, flags);
if (priority == -1) { if (priority == -1) {
if (song->data[0] == 0xf0) if (song->data[0] == 0xf0)
@ -145,7 +145,7 @@ static void script_set_priority(EngineState *s, reg_t obj, int priority) {
} else flags |= SCI1_SOUND_FLAG_SCRIPTED_PRI; } else flags |= SCI1_SOUND_FLAG_SCRIPTED_PRI;
s->_sound.sfx_song_renice(FROBNICATE_HANDLE(obj), priority); s->_sound.sfx_song_renice(FROBNICATE_HANDLE(obj), priority);
PUT_SEL32V(obj, flags, flags); PUT_SEL32V(segMan, obj, flags, flags);
} }
SongIterator *build_iterator(EngineState *s, int song_nr, SongIteratorType type, songit_id_t id) { SongIterator *build_iterator(EngineState *s, int song_nr, SongIteratorType type, songit_id_t id) {
@ -183,27 +183,27 @@ void process_sound_events(EngineState *s) { /* Get all sound events, apply their
case SI_LOOP: case SI_LOOP:
debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x looped (to %d)\n", debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x looped (to %d)\n",
PRINT_REG(obj), cue); PRINT_REG(obj), cue);
/* PUT_SEL32V(obj, loops, GET_SEL32V(obj, loop) - 1);*/ /* PUT_SEL32V(segMan, obj, loops, GET_SEL32V(segMan, obj, loop) - 1);*/
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
break; break;
case SI_RELATIVE_CUE: case SI_RELATIVE_CUE:
debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x received relative cue %d\n", debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x received relative cue %d\n",
PRINT_REG(obj), cue); PRINT_REG(obj), cue);
PUT_SEL32V(obj, signal, cue + 0x7f); PUT_SEL32V(segMan, obj, signal, cue + 0x7f);
break; break;
case SI_ABSOLUTE_CUE: case SI_ABSOLUTE_CUE:
debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x received absolute cue %d\n", debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x received absolute cue %d\n",
PRINT_REG(obj), cue); PRINT_REG(obj), cue);
PUT_SEL32V(obj, signal, cue); PUT_SEL32V(segMan, obj, signal, cue);
break; break;
case SI_FINISHED: case SI_FINISHED:
debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x finished\n", debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x finished\n",
PRINT_REG(obj)); PRINT_REG(obj));
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
PUT_SEL32V(obj, state, _K_SOUND_STATUS_STOPPED); PUT_SEL32V(segMan, obj, state, _K_SOUND_STATUS_STOPPED);
break; break;
default: default:
@ -220,7 +220,7 @@ static reg_t kDoSoundSci0(EngineState *s, int argc, reg_t *argv) {
uint16 command = argv[0].toUint16(); uint16 command = argv[0].toUint16();
SongHandle handle = FROBNICATE_HANDLE(obj); SongHandle handle = FROBNICATE_HANDLE(obj);
int number = obj.segment ? int number = obj.segment ?
GET_SEL32V(obj, number) : GET_SEL32V(segMan, obj, number) :
-1; /* We were not going to use it anyway */ -1; /* We were not going to use it anyway */
#ifdef DEBUG_SOUND #ifdef DEBUG_SOUND
@ -285,20 +285,20 @@ static reg_t kDoSoundSci0(EngineState *s, int argc, reg_t *argv) {
switch (command) { switch (command) {
case _K_SCI0_SOUND_INIT_HANDLE: case _K_SCI0_SOUND_INIT_HANDLE:
if (obj.segment) { if (obj.segment) {
debugC(2, kDebugLevelSound, "Initializing song number %d\n", GET_SEL32V(obj, number)); debugC(2, kDebugLevelSound, "Initializing song number %d\n", GET_SEL32V(segMan, obj, number));
s->_sound.sfx_add_song(build_iterator(s, number, SCI_SONG_ITERATOR_TYPE_SCI0, s->_sound.sfx_add_song(build_iterator(s, number, SCI_SONG_ITERATOR_TYPE_SCI0,
handle), 0, handle, number); handle), 0, handle, number);
PUT_SEL32V(obj, state, _K_SOUND_STATUS_INITIALIZED); PUT_SEL32V(segMan, obj, state, _K_SOUND_STATUS_INITIALIZED);
PUT_SEL32(obj, handle, obj); /* ``sound handle'': we use the object address */ PUT_SEL32(segMan, obj, handle, obj); /* ``sound handle'': we use the object address */
} }
break; break;
case _K_SCI0_SOUND_PLAY_HANDLE: case _K_SCI0_SOUND_PLAY_HANDLE:
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_PLAYING); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_PLAYING);
s->_sound.sfx_song_set_loops(handle, GET_SEL32V(obj, loop)); s->_sound.sfx_song_set_loops(handle, GET_SEL32V(segMan, obj, loop));
PUT_SEL32V(obj, state, _K_SOUND_STATUS_PLAYING); PUT_SEL32V(segMan, obj, state, _K_SOUND_STATUS_PLAYING);
} }
break; break;
@ -309,27 +309,27 @@ static reg_t kDoSoundSci0(EngineState *s, int argc, reg_t *argv) {
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_remove_song(handle); s->_sound.sfx_remove_song(handle);
} }
PUT_SEL32V(obj, handle, 0x0000); PUT_SEL32V(segMan, obj, handle, 0x0000);
break; break;
case _K_SCI0_SOUND_STOP_HANDLE: case _K_SCI0_SOUND_STOP_HANDLE:
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
PUT_SEL32V(obj, state, SOUND_STATUS_STOPPED); PUT_SEL32V(segMan, obj, state, SOUND_STATUS_STOPPED);
} }
break; break;
case _K_SCI0_SOUND_SUSPEND_HANDLE: case _K_SCI0_SOUND_SUSPEND_HANDLE:
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_SUSPENDED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_SUSPENDED);
PUT_SEL32V(obj, state, SOUND_STATUS_SUSPENDED); PUT_SEL32V(segMan, obj, state, SOUND_STATUS_SUSPENDED);
} }
break; break;
case _K_SCI0_SOUND_RESUME_HANDLE: case _K_SCI0_SOUND_RESUME_HANDLE:
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_PLAYING); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_PLAYING);
PUT_SEL32V(obj, state, SOUND_STATUS_PLAYING); PUT_SEL32V(segMan, obj, state, SOUND_STATUS_PLAYING);
} }
break; break;
@ -360,8 +360,8 @@ static reg_t kDoSoundSci0(EngineState *s, int argc, reg_t *argv) {
case _K_SCI0_SOUND_UPDATE_VOL_PRI: case _K_SCI0_SOUND_UPDATE_VOL_PRI:
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_loops(handle, GET_SEL32V(obj, loop)); s->_sound.sfx_song_set_loops(handle, GET_SEL32V(segMan, obj, loop));
script_set_priority(s, obj, GET_SEL32V(obj, pri)); script_set_priority(s, obj, GET_SEL32V(segMan, obj, pri));
} }
break; break;
@ -371,8 +371,8 @@ static reg_t kDoSoundSci0(EngineState *s, int argc, reg_t *argv) {
** than fading it! */ ** than fading it! */
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
PUT_SEL32V(obj, state, SOUND_STATUS_STOPPED); PUT_SEL32V(segMan, obj, state, SOUND_STATUS_STOPPED);
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
} }
break; break;
@ -400,7 +400,7 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
reg_t obj = (argc > 1) ? argv[1] : NULL_REG; reg_t obj = (argc > 1) ? argv[1] : NULL_REG;
SongHandle handle = FROBNICATE_HANDLE(obj); SongHandle handle = FROBNICATE_HANDLE(obj);
int number = obj.segment ? int number = obj.segment ?
GET_SEL32V(obj, number) : GET_SEL32V(segMan, obj, number) :
-1; /* We were not going to use it anyway */ -1; /* We were not going to use it anyway */
#ifdef DEBUG_SOUND #ifdef DEBUG_SOUND
@ -499,9 +499,9 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
break; break;
} }
case _K_SCI01_SOUND_PLAY_HANDLE : { case _K_SCI01_SOUND_PLAY_HANDLE : {
int looping = GET_SEL32V(obj, loop); int looping = GET_SEL32V(segMan, obj, loop);
//int vol = GET_SEL32V(obj, vol); //int vol = GET_SEL32V(segMan, obj, vol);
int pri = GET_SEL32V(obj, pri); int pri = GET_SEL32V(segMan, obj, pri);
RESTORE_BEHAVIOR rb = (RESTORE_BEHAVIOR) argv[2].toUint16(); /* Too lazy to look up a default value for this */ RESTORE_BEHAVIOR rb = (RESTORE_BEHAVIOR) argv[2].toUint16(); /* Too lazy to look up a default value for this */
if (obj.segment) { if (obj.segment) {
@ -509,22 +509,22 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
s->_sound.sfx_song_set_loops(handle, looping); s->_sound.sfx_song_set_loops(handle, looping);
s->_sound.sfx_song_renice(handle, pri); s->_sound.sfx_song_renice(handle, pri);
s->_sound._songlib.setSongRestoreBehavior(handle, rb); s->_sound._songlib.setSongRestoreBehavior(handle, rb);
PUT_SEL32V(obj, signal, 0); PUT_SEL32V(segMan, obj, signal, 0);
} }
break; break;
} }
case _K_SCI01_SOUND_INIT_HANDLE : { case _K_SCI01_SOUND_INIT_HANDLE : {
//int looping = GET_SEL32V(obj, loop); //int looping = GET_SEL32V(segMan, obj, loop);
//int vol = GET_SEL32V(obj, vol); //int vol = GET_SEL32V(segMan, obj, vol);
//int pri = GET_SEL32V(obj, pri); //int pri = GET_SEL32V(segMan, obj, pri);
if (obj.segment && (s->resMan->testResource(ResourceId(kResourceTypeSound, number)))) { if (obj.segment && (s->resMan->testResource(ResourceId(kResourceTypeSound, number)))) {
debugC(2, kDebugLevelSound, "Initializing song number %d\n", number); debugC(2, kDebugLevelSound, "Initializing song number %d\n", number);
s->_sound.sfx_add_song(build_iterator(s, number, SCI_SONG_ITERATOR_TYPE_SCI1, s->_sound.sfx_add_song(build_iterator(s, number, SCI_SONG_ITERATOR_TYPE_SCI1,
handle), 0, handle, number); handle), 0, handle, number);
PUT_SEL32(obj, nodePtr, obj); PUT_SEL32(segMan, obj, nodePtr, obj);
PUT_SEL32(obj, handle, obj); PUT_SEL32(segMan, obj, handle, obj);
} }
break; break;
} }
@ -543,24 +543,24 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
int frame = 0; int frame = 0;
/* FIXME: Update the sound server state with 'vol' */ /* FIXME: Update the sound server state with 'vol' */
int looping = GET_SEL32V(obj, loop); int looping = GET_SEL32V(segMan, obj, loop);
//int vol = GET_SEL32V(obj, vol); //int vol = GET_SEL32V(segMan, obj, vol);
int pri = GET_SEL32V(obj, pri); int pri = GET_SEL32V(segMan, obj, pri);
s->_sound.sfx_song_set_loops(handle, looping); s->_sound.sfx_song_set_loops(handle, looping);
s->_sound.sfx_song_renice(handle, pri); s->_sound.sfx_song_renice(handle, pri);
debugC(2, kDebugLevelSound, "[sound01-update-handle] -- CUE %04x:%04x", PRINT_REG(obj)); debugC(2, kDebugLevelSound, "[sound01-update-handle] -- CUE %04x:%04x", PRINT_REG(obj));
PUT_SEL32V(obj, signal, signal); PUT_SEL32V(segMan, obj, signal, signal);
PUT_SEL32V(obj, min, min); PUT_SEL32V(segMan, obj, min, min);
PUT_SEL32V(obj, sec, sec); PUT_SEL32V(segMan, obj, sec, sec);
PUT_SEL32V(obj, frame, frame); PUT_SEL32V(segMan, obj, frame, frame);
break; break;
} }
case _K_SCI01_SOUND_STOP_HANDLE : { case _K_SCI01_SOUND_STOP_HANDLE : {
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
} }
@ -581,7 +581,7 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
* TODO: Figure out the exact semantics */ * TODO: Figure out the exact semantics */
/* FIXME: The next couple of lines actually STOP the song right away */ /* FIXME: The next couple of lines actually STOP the song right away */
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
} }
@ -605,7 +605,7 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
debugC(2, kDebugLevelSound, "--- [CUE] %04x:%04x Absolute Cue: %d\n", debugC(2, kDebugLevelSound, "--- [CUE] %04x:%04x Absolute Cue: %d\n",
PRINT_REG(obj), signal); PRINT_REG(obj), signal);
PUT_SEL32V(obj, signal, signal); PUT_SEL32V(segMan, obj, signal, signal);
break; break;
case SI_RELATIVE_CUE: case SI_RELATIVE_CUE:
@ -616,13 +616,13 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
/* FIXME to match commented-out semantics /* FIXME to match commented-out semantics
* below, with proper storage of dataInc and * below, with proper storage of dataInc and
* signal in the iterator code. */ * signal in the iterator code. */
PUT_SEL32V(obj, dataInc, signal); PUT_SEL32V(segMan, obj, dataInc, signal);
PUT_SEL32V(obj, signal, signal); PUT_SEL32V(segMan, obj, signal, signal);
break; break;
case SI_FINISHED: case SI_FINISHED:
debugC(2, kDebugLevelSound, "--- [FINISHED] %04x:%04x\n", PRINT_REG(obj)); debugC(2, kDebugLevelSound, "--- [FINISHED] %04x:%04x\n", PRINT_REG(obj));
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
break; break;
case SI_LOOP: case SI_LOOP:
@ -632,13 +632,13 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
/* switch (signal) */ /* switch (signal) */
/* { */ /* { */
/* case 0x00: */ /* case 0x00: */
/* if (dataInc!=GET_SEL32V(obj, dataInc)) */ /* if (dataInc!=GET_SEL32V(segMan, obj, dataInc)) */
/* { */ /* { */
/* PUT_SEL32V(obj, dataInc, dataInc); */ /* PUT_SEL32V(segMan, obj, dataInc, dataInc); */
/* PUT_SEL32V(obj, signal, dataInc+0x7f); */ /* PUT_SEL32V(segMan, obj, signal, dataInc+0x7f); */
/* } else */ /* } else */
/* { */ /* { */
/* PUT_SEL32V(obj, signal, signal); */ /* PUT_SEL32V(segMan, obj, signal, signal); */
/* } */ /* } */
/* break; */ /* break; */
/* case 0xFF: /\* May be unnecessary *\/ */ /* case 0xFF: /\* May be unnecessary *\/ */
@ -646,20 +646,20 @@ static reg_t kDoSoundSci1Early(EngineState *s, int argc, reg_t *argv) {
/* handle, SOUND_STATUS_STOPPED); */ /* handle, SOUND_STATUS_STOPPED); */
/* break; */ /* break; */
/* default : */ /* default : */
/* if (dataInc!=GET_SEL32V(obj, dataInc)) */ /* if (dataInc!=GET_SEL32V(segMan, obj, dataInc)) */
/* { */ /* { */
/* PUT_SEL32V(obj, dataInc, dataInc); */ /* PUT_SEL32V(segMan, obj, dataInc, dataInc); */
/* PUT_SEL32V(obj, signal, dataInc+0x7f); */ /* PUT_SEL32V(segMan, obj, signal, dataInc+0x7f); */
/* } else */ /* } else */
/* { */ /* { */
/* PUT_SEL32V(obj, signal, signal); */ /* PUT_SEL32V(segMan, obj, signal, signal); */
/* } */ /* } */
/* break; */ /* break; */
/* } */ /* } */
PUT_SEL32V(obj, min, min); PUT_SEL32V(segMan, obj, min, min);
PUT_SEL32V(obj, sec, sec); PUT_SEL32V(segMan, obj, sec, sec);
PUT_SEL32V(obj, frame, frame); PUT_SEL32V(segMan, obj, frame, frame);
break; break;
} }
case _K_SCI01_SOUND_MIDI_SEND : { case _K_SCI01_SOUND_MIDI_SEND : {
@ -692,7 +692,7 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
reg_t obj = (argc > 1) ? argv[1] : NULL_REG; reg_t obj = (argc > 1) ? argv[1] : NULL_REG;
SongHandle handle = FROBNICATE_HANDLE(obj); SongHandle handle = FROBNICATE_HANDLE(obj);
int number = obj.segment ? int number = obj.segment ?
GET_SEL32V(obj, number) : GET_SEL32V(segMan, obj, number) :
-1; /* We were not going to use it anyway */ -1; /* We were not going to use it anyway */
#ifdef DEBUG_SOUND #ifdef DEBUG_SOUND
@ -812,19 +812,19 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
return make_reg(0, 1); return make_reg(0, 1);
} }
case _K_SCI1_SOUND_PLAY_HANDLE : { case _K_SCI1_SOUND_PLAY_HANDLE : {
int looping = GET_SEL32V(obj, loop); int looping = GET_SEL32V(segMan, obj, loop);
//int vol = GET_SEL32V(obj, vol); //int vol = GET_SEL32V(segMan, obj, vol);
int pri = GET_SEL32V(obj, pri); int pri = GET_SEL32V(segMan, obj, pri);
int sampleLen = 0; int sampleLen = 0;
Song *song = s->_sound._songlib.findSong(handle); Song *song = s->_sound._songlib.findSong(handle);
if (GET_SEL32V(obj, nodePtr) && (song && number != song->_resourceNum)) { if (GET_SEL32V(segMan, obj, nodePtr) && (song && number != song->_resourceNum)) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
s->_sound.sfx_remove_song(handle); s->_sound.sfx_remove_song(handle);
PUT_SEL32(obj, nodePtr, NULL_REG); PUT_SEL32(segMan, obj, nodePtr, NULL_REG);
} }
if (!GET_SEL32V(obj, nodePtr) && obj.segment) { if (!GET_SEL32V(segMan, obj, nodePtr) && obj.segment) {
// In SCI1.1 games, sound effects are started from here. If we can find // In SCI1.1 games, sound effects are started from here. If we can find
// a relevant audio resource, play it, otherwise switch to synthesized // a relevant audio resource, play it, otherwise switch to synthesized
// effects. If the resource exists, play it using map 65535 (sound // effects. If the resource exists, play it using map 65535 (sound
@ -842,7 +842,7 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
warning("Could not open song number %d", number); warning("Could not open song number %d", number);
// Send a "stop handle" event so that the engine won't wait forever here // Send a "stop handle" event so that the engine won't wait forever here
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
return s->r_acc; return s->r_acc;
} }
debugC(2, kDebugLevelSound, "Initializing song number %d\n", number); debugC(2, kDebugLevelSound, "Initializing song number %d\n", number);
@ -850,25 +850,25 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
handle), 0, handle, number); handle), 0, handle, number);
} }
PUT_SEL32(obj, nodePtr, obj); PUT_SEL32(segMan, obj, nodePtr, obj);
PUT_SEL32(obj, handle, obj); PUT_SEL32(segMan, obj, handle, obj);
} }
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_PLAYING); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_PLAYING);
s->_sound.sfx_song_set_loops(handle, looping); s->_sound.sfx_song_set_loops(handle, looping);
s->_sound.sfx_song_renice(handle, pri); s->_sound.sfx_song_renice(handle, pri);
PUT_SEL32V(obj, signal, 0); PUT_SEL32V(segMan, obj, signal, 0);
} }
break; break;
} }
case _K_SCI1_SOUND_INIT_HANDLE : { case _K_SCI1_SOUND_INIT_HANDLE : {
//int looping = GET_SEL32V(obj, loop); //int looping = GET_SEL32V(segMan, obj, loop);
//int vol = GET_SEL32V(obj, vol); //int vol = GET_SEL32V(segMan, obj, vol);
//int pri = GET_SEL32V(obj, pri); //int pri = GET_SEL32V(segMan, obj, pri);
if (GET_SEL32V(obj, nodePtr)) { if (GET_SEL32V(segMan, obj, nodePtr)) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
s->_sound.sfx_remove_song(handle); s->_sound.sfx_remove_song(handle);
} }
@ -877,8 +877,8 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
debugC(2, kDebugLevelSound, "Initializing song number %d\n", number); debugC(2, kDebugLevelSound, "Initializing song number %d\n", number);
s->_sound.sfx_add_song(build_iterator(s, number, SCI_SONG_ITERATOR_TYPE_SCI1, s->_sound.sfx_add_song(build_iterator(s, number, SCI_SONG_ITERATOR_TYPE_SCI1,
handle), 0, handle, number); handle), 0, handle, number);
PUT_SEL32(obj, nodePtr, obj); PUT_SEL32(segMan, obj, nodePtr, obj);
PUT_SEL32(obj, handle, obj); PUT_SEL32(segMan, obj, handle, obj);
} }
break; break;
} }
@ -890,7 +890,7 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
break; break;
} }
case _K_SCI1_SOUND_STOP_HANDLE : { case _K_SCI1_SOUND_STOP_HANDLE : {
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
if (obj.segment) { if (obj.segment) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
} }
@ -914,13 +914,13 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
/* FIXME: The next couple of lines actually STOP the handle, rather /* FIXME: The next couple of lines actually STOP the handle, rather
** than fading it! */ ** than fading it! */
if (argv[5].toUint16()) { if (argv[5].toUint16()) {
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
PUT_SEL32V(obj, nodePtr, 0); PUT_SEL32V(segMan, obj, nodePtr, 0);
PUT_SEL32V(obj, handle, 0); PUT_SEL32V(segMan, obj, handle, 0);
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED); s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
} else { } else {
// FIXME: Support fade-and-continue. For now, send signal right away. // FIXME: Support fade-and-continue. For now, send signal right away.
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
} }
} }
break; break;
@ -944,14 +944,14 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
break; break;
} }
case _K_SCI1_SOUND_SET_HANDLE_LOOP : { case _K_SCI1_SOUND_SET_HANDLE_LOOP : {
if (!GET_SEL32(obj, nodePtr).isNull()) { if (!GET_SEL32(segMan, obj, nodePtr).isNull()) {
uint16 looping = argv[2].toUint16(); uint16 looping = argv[2].toUint16();
if (looping < 65535) if (looping < 65535)
looping = 1; looping = 1;
s->_sound.sfx_song_set_loops(handle, looping); s->_sound.sfx_song_set_loops(handle, looping);
PUT_SEL32V(obj, loop, looping); PUT_SEL32V(segMan, obj, loop, looping);
} }
break; break;
} }
@ -973,19 +973,19 @@ static reg_t kDoSoundSci1Late(EngineState *s, int argc, reg_t *argv) {
debugC(2, kDebugLevelSound, "[CUE] %04x:%04x Absolute Cue: %d\n", debugC(2, kDebugLevelSound, "[CUE] %04x:%04x Absolute Cue: %d\n",
PRINT_REG(obj), signal); PRINT_REG(obj), signal);
PUT_SEL32V(obj, signal, signal); PUT_SEL32V(segMan, obj, signal, signal);
break; break;
case SI_RELATIVE_CUE: case SI_RELATIVE_CUE:
debugC(2, kDebugLevelSound, "[CUE] %04x:%04x Relative Cue: %d\n", debugC(2, kDebugLevelSound, "[CUE] %04x:%04x Relative Cue: %d\n",
PRINT_REG(obj), cue); PRINT_REG(obj), cue);
PUT_SEL32V(obj, dataInc, cue); PUT_SEL32V(segMan, obj, dataInc, cue);
PUT_SEL32V(obj, signal, cue + 127); PUT_SEL32V(segMan, obj, signal, cue + 127);
break; break;
case SI_FINISHED: case SI_FINISHED:
PUT_SEL32V(obj, signal, SIGNAL_OFFSET); PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
break; break;
case SI_LOOP: case SI_LOOP:
@ -1110,12 +1110,12 @@ reg_t kDoSync(EngineState *s, int argc, reg_t *argv) {
s->_sound._syncResource = s->resMan->findResource(id, 1); s->_sound._syncResource = s->resMan->findResource(id, 1);
if (s->_sound._syncResource) { if (s->_sound._syncResource) {
PUT_SEL32V(argv[1], syncCue, 0); PUT_SEL32V(segMan, argv[1], syncCue, 0);
s->_sound._syncOffset = 0; s->_sound._syncOffset = 0;
} else { } else {
warning("DoSync: failed to find resource %s", id.toString().c_str()); warning("DoSync: failed to find resource %s", id.toString().c_str());
// Notify the scripts to stop sound sync // Notify the scripts to stop sound sync
PUT_SEL32V(argv[1], syncCue, SIGNAL_OFFSET); PUT_SEL32V(segMan, argv[1], syncCue, SIGNAL_OFFSET);
} }
break; break;
} }
@ -1132,8 +1132,8 @@ reg_t kDoSync(EngineState *s, int argc, reg_t *argv) {
s->_sound._syncOffset += 2; s->_sound._syncOffset += 2;
} }
PUT_SEL32V(argv[1], syncTime, syncTime); PUT_SEL32V(segMan, argv[1], syncTime, syncTime);
PUT_SEL32V(argv[1], syncCue, syncCue); PUT_SEL32V(segMan, argv[1], syncCue, syncCue);
} }
break; break;
} }

15
engines/sci/engine/kstring.cpp
View file

@ -79,7 +79,6 @@ Common::String kernel_lookup_text(EngineState *s, reg_t address, int index) {
reg_t kSaid(EngineState *s, int argc, reg_t *argv) { reg_t kSaid(EngineState *s, int argc, reg_t *argv) {
SegManager *segMan = s->_segMan;
reg_t heap_said_block = argv[0]; reg_t heap_said_block = argv[0];
byte *said_block; byte *said_block;
int new_lastmatch; int new_lastmatch;
@ -104,7 +103,7 @@ reg_t kSaid(EngineState *s, int argc, reg_t *argv) {
s->_voc->decipherSaidBlock(said_block); s->_voc->decipherSaidBlock(said_block);
#endif #endif
if (s->parser_event.isNull() || (GET_SEL32V(s->parser_event, claimed))) { if (s->parser_event.isNull() || (GET_SEL32V(s->_segMan, s->parser_event, claimed))) {
return NULL_REG; return NULL_REG;
} }
@ -118,7 +117,7 @@ reg_t kSaid(EngineState *s, int argc, reg_t *argv) {
s->r_acc = make_reg(0, 1); s->r_acc = make_reg(0, 1);
if (new_lastmatch != SAID_PARTIAL_MATCH) if (new_lastmatch != SAID_PARTIAL_MATCH)
PUT_SEL32V(s->parser_event, claimed, 1); PUT_SEL32V(s->_segMan, s->parser_event, claimed, 1);
} else { } else {
return NULL_REG; return NULL_REG;
@ -137,14 +136,14 @@ reg_t kSetSynonyms(EngineState *s, int argc, reg_t *argv) {
s->_voc->clearSynonyms(); s->_voc->clearSynonyms();
list = s->_segMan->lookupList(GET_SEL32(object, elements)); list = s->_segMan->lookupList(GET_SEL32(segMan, object, elements));
node = s->_segMan->lookupNode(list->first); node = s->_segMan->lookupNode(list->first);
while (node) { while (node) {
reg_t objpos = node->value; reg_t objpos = node->value;
int seg; int seg;
script = GET_SEL32V(objpos, number); script = GET_SEL32V(segMan, objpos, number);
seg = s->_segMan->getScriptSegment(script); seg = s->_segMan->getScriptSegment(script);
if (seg > 0) if (seg > 0)
@ -214,7 +213,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
if (syntax_fail) { if (syntax_fail) {
s->r_acc = make_reg(0, 1); s->r_acc = make_reg(0, 1);
PUT_SEL32V(event, claimed, 1); PUT_SEL32V(segMan, event, claimed, 1);
invoke_selector(INV_SEL(s->game_obj, syntaxFail, kStopOnInvalidSelector), 2, s->parser_base, stringpos); invoke_selector(INV_SEL(s->game_obj, syntaxFail, kStopOnInvalidSelector), 2, s->parser_base, stringpos);
/* Issue warning */ /* Issue warning */
@ -223,7 +222,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
} else { } else {
s->parserIsValid = true; s->parserIsValid = true;
PUT_SEL32V(event, claimed, 0); PUT_SEL32V(segMan, event, claimed, 0);
#ifdef DEBUG_PARSER #ifdef DEBUG_PARSER
s->_voc->dumpParseTree(); s->_voc->dumpParseTree();
@ -233,7 +232,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
} else { } else {
s->r_acc = make_reg(0, 0); s->r_acc = make_reg(0, 0);
PUT_SEL32V(event, claimed, 1); PUT_SEL32V(segMan, event, claimed, 1);
if (error) { if (error) {
s->_segMan->strcpy(s->parser_base, error); s->_segMan->strcpy(s->parser_base, error);
debugC(2, kDebugLevelParser, "Word unknown: %s\n", error); debugC(2, kDebugLevelParser, "Word unknown: %s\n", error);

8
engines/sci/engine/state.cpp
View file

@ -177,8 +177,7 @@ kLanguage EngineState::getLanguage() {
kLanguage lang = K_LANG_ENGLISH; kLanguage lang = K_LANG_ENGLISH;
if (_kernel->_selectorCache.printLang != -1) { if (_kernel->_selectorCache.printLang != -1) {
SegManager *segMan = _segMan; lang = (kLanguage)GET_SEL32V(_segMan, this->game_obj, printLang);
lang = (kLanguage)GET_SEL32V(this->game_obj, printLang);
if ((getSciVersion() == SCI_VERSION_1_1) || (lang == K_LANG_NONE)) { if ((getSciVersion() == SCI_VERSION_1_1) || (lang == K_LANG_NONE)) {
// If language is set to none, we use the language from the game detector. // If language is set to none, we use the language from the game detector.
@ -213,7 +212,7 @@ kLanguage EngineState::getLanguage() {
} }
// Store language in printLang selector // Store language in printLang selector
PUT_SEL32V(this->game_obj, printLang, lang); PUT_SEL32V(_segMan, this->game_obj, printLang, lang);
} }
} }
@ -225,8 +224,7 @@ Common::String EngineState::strSplit(const char *str, const char *sep) {
kLanguage subLang = K_LANG_NONE; kLanguage subLang = K_LANG_NONE;
if (_kernel->_selectorCache.subtitleLang != -1) { if (_kernel->_selectorCache.subtitleLang != -1) {
SegManager *segMan = _segMan; subLang = (kLanguage)GET_SEL32V(_segMan, this->game_obj, subtitleLang);
subLang = (kLanguage)GET_SEL32V(this->game_obj, subtitleLang);
} }
Common::String retval = getLanguageString(str, lang); Common::String retval = getLanguageString(str, lang);

15
engines/sci/gui/gui.cpp
View file

@ -407,8 +407,7 @@ void SciGui::drawControlList(Common::Rect rect, reg_t obj, int16 maxChars, int16
} }
void SciGui::editControl(reg_t controlObject, reg_t eventObject) { void SciGui::editControl(reg_t controlObject, reg_t eventObject) {
SegManager *segMan = _s->_segMan; int16 controlType = GET_SEL32V(_s->_segMan, controlObject, type);
int16 controlType = GET_SEL32V(controlObject, type);
switch (controlType) { switch (controlType) {
case SCI_CONTROLS_TYPE_TEXTEDIT: case SCI_CONTROLS_TYPE_TEXTEDIT:
@ -586,12 +585,12 @@ bool SciGui::canBeHere(reg_t curObject, reg_t listReference) {
uint16 signal, controlMask; uint16 signal, controlMask;
bool result; bool result;
checkRect.left = GET_SEL32V(curObject, brLeft); checkRect.left = GET_SEL32V(segMan, curObject, brLeft);
checkRect.top = GET_SEL32V(curObject, brTop); checkRect.top = GET_SEL32V(segMan, curObject, brTop);
checkRect.right = GET_SEL32V(curObject, brRight); checkRect.right = GET_SEL32V(segMan, curObject, brRight);
checkRect.bottom = GET_SEL32V(curObject, brBottom); checkRect.bottom = GET_SEL32V(segMan, curObject, brBottom);
signal = GET_SEL32V(curObject, signal); signal = GET_SEL32V(segMan, curObject, signal);
controlMask = GET_SEL32V(curObject, illegalBits); controlMask = GET_SEL32V(segMan, curObject, illegalBits);
result = (_gfx->onControl(SCI_SCREEN_MASK_CONTROL, checkRect) & controlMask) ? false : true; result = (_gfx->onControl(SCI_SCREEN_MASK_CONTROL, checkRect) & controlMask) ? false : true;
if ((result) && (signal & (SCI_ANIMATE_SIGNAL_IGNOREACTOR | SCI_ANIMATE_SIGNAL_REMOVEVIEW)) == 0) { if ((result) && (signal & (SCI_ANIMATE_SIGNAL_IGNOREACTOR | SCI_ANIMATE_SIGNAL_REMOVEVIEW)) == 0) {
List *list = _s->_segMan->lookupList(listReference); List *list = _s->_segMan->lookupList(listReference);

64
engines/sci/gui/gui_animate.cpp
View file

@ -65,7 +65,7 @@ void SciGuiAnimate::invoke(List *list, int argc, reg_t *argv) {
while (curNode) { while (curNode) {
curObject = curNode->value; curObject = curNode->value;
signal = GET_SEL32V(curObject, signal); signal = GET_SEL32V(segMan, curObject, signal);
if (!(signal & SCI_ANIMATE_SIGNAL_FROZEN)) { if (!(signal & SCI_ANIMATE_SIGNAL_FROZEN)) {
// Call .doit method of that object // Call .doit method of that object
invoke_selector(_s, curObject, _s->_kernel->_selectorCache.doit, kContinueOnInvalidSelector, argv, argc, __FILE__, __LINE__, 0); invoke_selector(_s, curObject, _s->_kernel->_selectorCache.doit, kContinueOnInvalidSelector, argv, argc, __FILE__, __LINE__, 0);
@ -121,15 +121,15 @@ void SciGuiAnimate::makeSortedList(List *list) {
listEntry->object = curObject; listEntry->object = curObject;
// Get data from current object // Get data from current object
listEntry->viewId = GET_SEL32V(curObject, view); listEntry->viewId = GET_SEL32V(segMan, curObject, view);
listEntry->loopNo = GET_SEL32V(curObject, loop); listEntry->loopNo = GET_SEL32V(segMan, curObject, loop);
listEntry->celNo = GET_SEL32V(curObject, cel); listEntry->celNo = GET_SEL32V(segMan, curObject, cel);
listEntry->paletteNo = GET_SEL32V(curObject, palette); listEntry->paletteNo = GET_SEL32V(segMan, curObject, palette);
listEntry->x = GET_SEL32V(curObject, x); listEntry->x = GET_SEL32V(segMan, curObject, x);
listEntry->y = GET_SEL32V(curObject, y); listEntry->y = GET_SEL32V(segMan, curObject, y);
listEntry->z = GET_SEL32V(curObject, z); listEntry->z = GET_SEL32V(segMan, curObject, z);
listEntry->priority = GET_SEL32V(curObject, priority); listEntry->priority = GET_SEL32V(segMan, curObject, priority);
listEntry->signal = GET_SEL32V(curObject, signal); listEntry->signal = GET_SEL32V(segMan, curObject, signal);
// listEntry->celRect is filled in AnimateFill() // listEntry->celRect is filled in AnimateFill()
listEntry->showBitsFlag = false; listEntry->showBitsFlag = false;
@ -167,26 +167,26 @@ void SciGuiAnimate::fill(byte &old_picNotValid) {
// adjust loop and cel, if any of those is invalid // adjust loop and cel, if any of those is invalid
if (listEntry->loopNo >= view->getLoopCount()) { if (listEntry->loopNo >= view->getLoopCount()) {
listEntry->loopNo = 0; listEntry->loopNo = 0;
PUT_SEL32V(curObject, loop, listEntry->loopNo); PUT_SEL32V(segMan, curObject, loop, listEntry->loopNo);
} }
if (listEntry->celNo >= view->getCelCount(listEntry->loopNo)) { if (listEntry->celNo >= view->getCelCount(listEntry->loopNo)) {
listEntry->celNo = 0; listEntry->celNo = 0;
PUT_SEL32V(curObject, cel, listEntry->celNo); PUT_SEL32V(segMan, curObject, cel, listEntry->celNo);
} }
// Create rect according to coordinates and given cel // Create rect according to coordinates and given cel
view->getCelRect(listEntry->loopNo, listEntry->celNo, listEntry->x, listEntry->y, listEntry->z, &listEntry->celRect); view->getCelRect(listEntry->loopNo, listEntry->celNo, listEntry->x, listEntry->y, listEntry->z, &listEntry->celRect);
PUT_SEL32V(curObject, nsLeft, listEntry->celRect.left); PUT_SEL32V(segMan, curObject, nsLeft, listEntry->celRect.left);
PUT_SEL32V(curObject, nsTop, listEntry->celRect.top); PUT_SEL32V(segMan, curObject, nsTop, listEntry->celRect.top);
PUT_SEL32V(curObject, nsRight, listEntry->celRect.right); PUT_SEL32V(segMan, curObject, nsRight, listEntry->celRect.right);
PUT_SEL32V(curObject, nsBottom, listEntry->celRect.bottom); PUT_SEL32V(segMan, curObject, nsBottom, listEntry->celRect.bottom);
signal = listEntry->signal; signal = listEntry->signal;
// Calculate current priority according to y-coordinate // Calculate current priority according to y-coordinate
if (!(signal & SCI_ANIMATE_SIGNAL_FIXEDPRIORITY)) { if (!(signal & SCI_ANIMATE_SIGNAL_FIXEDPRIORITY)) {
listEntry->priority = _gfx->CoordinateToPriority(listEntry->y); listEntry->priority = _gfx->CoordinateToPriority(listEntry->y);
PUT_SEL32V(curObject, priority, listEntry->priority); PUT_SEL32V(segMan, curObject, priority, listEntry->priority);
} }
if (signal & SCI_ANIMATE_SIGNAL_NOUPDATE) { if (signal & SCI_ANIMATE_SIGNAL_NOUPDATE) {
@ -229,14 +229,14 @@ void SciGuiAnimate::update() {
if (signal & SCI_ANIMATE_SIGNAL_NOUPDATE) { if (signal & SCI_ANIMATE_SIGNAL_NOUPDATE) {
if (!(signal & SCI_ANIMATE_SIGNAL_REMOVEVIEW)) { if (!(signal & SCI_ANIMATE_SIGNAL_REMOVEVIEW)) {
bitsHandle = GET_SEL32(curObject, underBits); bitsHandle = GET_SEL32(segMan, curObject, underBits);
if (_screen->_picNotValid != 1) { if (_screen->_picNotValid != 1) {
_gfx->BitsRestore(bitsHandle); _gfx->BitsRestore(bitsHandle);
listEntry->showBitsFlag = true; listEntry->showBitsFlag = true;
} else { } else {
_gfx->BitsFree(bitsHandle); _gfx->BitsFree(bitsHandle);
} }
PUT_SEL32V(curObject, underBits, 0); PUT_SEL32V(segMan, curObject, underBits, 0);
} }
signal &= 0xFFFF ^ SCI_ANIMATE_SIGNAL_FORCEUPDATE; signal &= 0xFFFF ^ SCI_ANIMATE_SIGNAL_FORCEUPDATE;
signal &= signal & SCI_ANIMATE_SIGNAL_VIEWUPDATED ? 0xFFFF ^ (SCI_ANIMATE_SIGNAL_VIEWUPDATED | SCI_ANIMATE_SIGNAL_NOUPDATE) : 0xFFFF; signal &= signal & SCI_ANIMATE_SIGNAL_VIEWUPDATED ? 0xFFFF ^ (SCI_ANIMATE_SIGNAL_VIEWUPDATED | SCI_ANIMATE_SIGNAL_NOUPDATE) : 0xFFFF;
@ -286,7 +286,7 @@ void SciGuiAnimate::update() {
bitsHandle = _gfx->BitsSave(listEntry->celRect, SCI_SCREEN_MASK_VISUAL|SCI_SCREEN_MASK_PRIORITY); bitsHandle = _gfx->BitsSave(listEntry->celRect, SCI_SCREEN_MASK_VISUAL|SCI_SCREEN_MASK_PRIORITY);
else else
bitsHandle = _gfx->BitsSave(listEntry->celRect, SCI_SCREEN_MASK_ALL); bitsHandle = _gfx->BitsSave(listEntry->celRect, SCI_SCREEN_MASK_ALL);
PUT_SEL32(curObject, underBits, bitsHandle); PUT_SEL32(segMan, curObject, underBits, bitsHandle);
} }
listEntry->signal = signal; listEntry->signal = signal;
} }
@ -333,7 +333,7 @@ void SciGuiAnimate::drawCels() {
if (!(signal & (SCI_ANIMATE_SIGNAL_NOUPDATE | SCI_ANIMATE_SIGNAL_HIDDEN | SCI_ANIMATE_SIGNAL_ALWAYSUPDATE))) { if (!(signal & (SCI_ANIMATE_SIGNAL_NOUPDATE | SCI_ANIMATE_SIGNAL_HIDDEN | SCI_ANIMATE_SIGNAL_ALWAYSUPDATE))) {
// Save background // Save background
bitsHandle = _gfx->BitsSave(listEntry->celRect, SCI_SCREEN_MASK_ALL); bitsHandle = _gfx->BitsSave(listEntry->celRect, SCI_SCREEN_MASK_ALL);
PUT_SEL32(curObject, underBits, bitsHandle); PUT_SEL32(segMan, curObject, underBits, bitsHandle);
// draw corresponding cel // draw corresponding cel
_gfx->drawCel(listEntry->viewId, listEntry->loopNo, listEntry->celNo, listEntry->celRect, listEntry->priority, listEntry->paletteNo); _gfx->drawCel(listEntry->viewId, listEntry->loopNo, listEntry->celNo, listEntry->celRect, listEntry->priority, listEntry->paletteNo);
@ -377,10 +377,10 @@ void SciGuiAnimate::updateScreen(byte oldPicNotValid) {
if (listEntry->showBitsFlag || !(signal & (SCI_ANIMATE_SIGNAL_REMOVEVIEW | SCI_ANIMATE_SIGNAL_NOUPDATE) || if (listEntry->showBitsFlag || !(signal & (SCI_ANIMATE_SIGNAL_REMOVEVIEW | SCI_ANIMATE_SIGNAL_NOUPDATE) ||
(!(signal & SCI_ANIMATE_SIGNAL_REMOVEVIEW) && (signal & SCI_ANIMATE_SIGNAL_NOUPDATE) && oldPicNotValid))) { (!(signal & SCI_ANIMATE_SIGNAL_REMOVEVIEW) && (signal & SCI_ANIMATE_SIGNAL_NOUPDATE) && oldPicNotValid))) {
lsRect.left = GET_SEL32V(curObject, lsLeft); lsRect.left = GET_SEL32V(segMan, curObject, lsLeft);
lsRect.top = GET_SEL32V(curObject, lsTop); lsRect.top = GET_SEL32V(segMan, curObject, lsTop);
lsRect.right = GET_SEL32V(curObject, lsRight); lsRect.right = GET_SEL32V(segMan, curObject, lsRight);
lsRect.bottom = GET_SEL32V(curObject, lsBottom); lsRect.bottom = GET_SEL32V(segMan, curObject, lsBottom);
workerRect = lsRect; workerRect = lsRect;
workerRect.clip(listEntry->celRect); workerRect.clip(listEntry->celRect);
@ -392,10 +392,10 @@ void SciGuiAnimate::updateScreen(byte oldPicNotValid) {
_gfx->BitsShow(lsRect); _gfx->BitsShow(lsRect);
workerRect = listEntry->celRect; workerRect = listEntry->celRect;
} }
PUT_SEL32V(curObject, lsLeft, workerRect.left); PUT_SEL32V(segMan, curObject, lsLeft, workerRect.left);
PUT_SEL32V(curObject, lsTop, workerRect.top); PUT_SEL32V(segMan, curObject, lsTop, workerRect.top);
PUT_SEL32V(curObject, lsRight, workerRect.right); PUT_SEL32V(segMan, curObject, lsRight, workerRect.right);
PUT_SEL32V(curObject, lsBottom, workerRect.bottom); PUT_SEL32V(segMan, curObject, lsBottom, workerRect.bottom);
_gfx->BitsShow(workerRect); _gfx->BitsShow(workerRect);
if (signal & SCI_ANIMATE_SIGNAL_HIDDEN) { if (signal & SCI_ANIMATE_SIGNAL_HIDDEN) {
@ -424,12 +424,12 @@ void SciGuiAnimate::restoreAndDelete(int argc, reg_t *argv) {
signal = listEntry->signal; signal = listEntry->signal;
if ((signal & (SCI_ANIMATE_SIGNAL_NOUPDATE | SCI_ANIMATE_SIGNAL_REMOVEVIEW)) == 0) { if ((signal & (SCI_ANIMATE_SIGNAL_NOUPDATE | SCI_ANIMATE_SIGNAL_REMOVEVIEW)) == 0) {
_gfx->BitsRestore(GET_SEL32(curObject, underBits)); _gfx->BitsRestore(GET_SEL32(segMan, curObject, underBits));
PUT_SEL32V(curObject, underBits, 0); PUT_SEL32V(segMan, curObject, underBits, 0);
} }
// Finally update signal // Finally update signal
PUT_SEL32V(curObject, signal, signal); PUT_SEL32V(segMan, curObject, signal, signal);
if (signal & SCI_ANIMATE_SIGNAL_DISPOSEME) { if (signal & SCI_ANIMATE_SIGNAL_DISPOSEME) {
// Call .delete_ method of that object // Call .delete_ method of that object

48
engines/sci/gui/gui_gfx.cpp
View file

@ -827,9 +827,9 @@ void SciGuiGfx::TexteditSetBlinkTime() {
void SciGuiGfx::TexteditChange(reg_t controlObject, reg_t eventObject) { void SciGuiGfx::TexteditChange(reg_t controlObject, reg_t eventObject) {
SegManager *segMan = _s->_segMan; SegManager *segMan = _s->_segMan;
uint16 cursorPos = GET_SEL32V(controlObject, cursor); uint16 cursorPos = GET_SEL32V(segMan, controlObject, cursor);
uint16 maxChars = GET_SEL32V(controlObject, max); uint16 maxChars = GET_SEL32V(segMan, controlObject, max);
reg_t textReference = GET_SEL32(controlObject, text); reg_t textReference = GET_SEL32(segMan, controlObject, text);
Common::String text; Common::String text;
uint16 textSize, eventType, eventKey; uint16 textSize, eventType, eventKey;
bool textChanged = false; bool textChanged = false;
@ -840,14 +840,14 @@ void SciGuiGfx::TexteditChange(reg_t controlObject, reg_t eventObject) {
if (!eventObject.isNull()) { if (!eventObject.isNull()) {
textSize = text.size(); textSize = text.size();
eventType = GET_SEL32V(eventObject, type); eventType = GET_SEL32V(segMan, eventObject, type);
switch (eventType) { switch (eventType) {
case SCI_EVT_MOUSE_PRESS: case SCI_EVT_MOUSE_PRESS:
// TODO: Implement mouse support for cursor change // TODO: Implement mouse support for cursor change
break; break;
case SCI_EVT_KEYBOARD: case SCI_EVT_KEYBOARD:
eventKey = GET_SEL32V(eventObject, message); eventKey = GET_SEL32V(segMan, eventObject, message);
switch (eventKey) { switch (eventKey) {
case SCI_K_BACKSPACE: case SCI_K_BACKSPACE:
if (cursorPos > 0) { if (cursorPos > 0) {
@ -888,10 +888,10 @@ void SciGuiGfx::TexteditChange(reg_t controlObject, reg_t eventObject) {
if (textChanged) { if (textChanged) {
GuiResourceId oldFontId = GetFontId(); GuiResourceId oldFontId = GetFontId();
GuiResourceId fontId = GET_SEL32V(controlObject, font); GuiResourceId fontId = GET_SEL32V(segMan, controlObject, font);
Common::Rect rect; Common::Rect rect;
rect = Common::Rect (GET_SEL32V(controlObject, nsLeft), GET_SEL32V(controlObject, nsTop), rect = Common::Rect(GET_SEL32V(segMan, controlObject, nsLeft), GET_SEL32V(segMan, controlObject, nsTop),
GET_SEL32V(controlObject, nsRight), GET_SEL32V(controlObject, nsBottom)); GET_SEL32V(segMan, controlObject, nsRight), GET_SEL32V(segMan, controlObject, nsBottom));
rect.top++; rect.top++;
TexteditCursorErase(); TexteditCursorErase();
EraseRect(rect); EraseRect(rect);
@ -912,7 +912,7 @@ void SciGuiGfx::TexteditChange(reg_t controlObject, reg_t eventObject) {
} }
} }
PUT_SEL32V(controlObject, cursor, cursorPos); PUT_SEL32V(segMan, controlObject, cursor, cursorPos);
} }
uint16 SciGuiGfx::onControl(uint16 screenMask, Common::Rect rect) { uint16 SciGuiGfx::onControl(uint16 screenMask, Common::Rect rect) {
@ -1011,12 +1011,12 @@ bool SciGuiGfx::CanBeHereCheckRectList(reg_t checkObject, Common::Rect checkRect
while (curNode) { while (curNode) {
curObject = curNode->value; curObject = curNode->value;
if (curObject != checkObject) { if (curObject != checkObject) {
signal = GET_SEL32V(curObject, signal); signal = GET_SEL32V(segMan, curObject, signal);
if ((signal & (SCI_ANIMATE_SIGNAL_IGNOREACTOR | SCI_ANIMATE_SIGNAL_REMOVEVIEW | SCI_ANIMATE_SIGNAL_NOUPDATE)) == 0) { if ((signal & (SCI_ANIMATE_SIGNAL_IGNOREACTOR | SCI_ANIMATE_SIGNAL_REMOVEVIEW | SCI_ANIMATE_SIGNAL_NOUPDATE)) == 0) {
curRect.left = GET_SEL32V(curObject, brLeft); curRect.left = GET_SEL32V(segMan, curObject, brLeft);
curRect.top = GET_SEL32V(curObject, brTop); curRect.top = GET_SEL32V(segMan, curObject, brTop);
curRect.right = GET_SEL32V(curObject, brRight); curRect.right = GET_SEL32V(segMan, curObject, brRight);
curRect.bottom = GET_SEL32V(curObject, brBottom); curRect.bottom = GET_SEL32V(segMan, curObject, brBottom);
// Check if curRect is within checkRect // Check if curRect is within checkRect
if (curRect.right > checkRect.left && curRect.left < checkRect.right && curRect.bottom > checkRect.top && curRect.top < checkRect.bottom) { if (curRect.right > checkRect.left && curRect.left < checkRect.right && curRect.bottom > checkRect.top && curRect.top < checkRect.bottom) {
return false; return false;
@ -1033,14 +1033,14 @@ void SciGuiGfx::SetNowSeen(reg_t objectReference) {
SegManager *segMan = _s->_segMan; SegManager *segMan = _s->_segMan;
SciGuiView *view = NULL; SciGuiView *view = NULL;
Common::Rect celRect(0, 0); Common::Rect celRect(0, 0);
GuiResourceId viewId = (GuiResourceId)GET_SEL32V(objectReference, view); GuiResourceId viewId = (GuiResourceId)GET_SEL32V(segMan, objectReference, view);
GuiViewLoopNo loopNo = sign_extend_byte((GuiViewLoopNo)GET_SEL32V(objectReference, loop)); GuiViewLoopNo loopNo = sign_extend_byte((GuiViewLoopNo)GET_SEL32V(segMan, objectReference, loop));
GuiViewCelNo celNo = sign_extend_byte((GuiViewCelNo)GET_SEL32V(objectReference, cel)); GuiViewCelNo celNo = sign_extend_byte((GuiViewCelNo)GET_SEL32V(segMan, objectReference, cel));
int16 x = (int16)GET_SEL32V(objectReference, x); int16 x = (int16)GET_SEL32V(segMan, objectReference, x);
int16 y = (int16)GET_SEL32V(objectReference, y); int16 y = (int16)GET_SEL32V(segMan, objectReference, y);
int16 z = 0; int16 z = 0;
if (_s->_kernel->_selectorCache.z > -1) { if (_s->_kernel->_selectorCache.z > -1) {
z = (int16)GET_SEL32V(objectReference, z); z = (int16)GET_SEL32V(segMan, objectReference, z);
} }
// now get cel rectangle // now get cel rectangle
@ -1049,10 +1049,10 @@ void SciGuiGfx::SetNowSeen(reg_t objectReference) {
// TODO: sometimes loop is negative. Check what it means // TODO: sometimes loop is negative. Check what it means
if (lookup_selector(_s->_segMan, objectReference, _s->_kernel->_selectorCache.nsTop, NULL, NULL) == kSelectorVariable) { if (lookup_selector(_s->_segMan, objectReference, _s->_kernel->_selectorCache.nsTop, NULL, NULL) == kSelectorVariable) {
PUT_SEL32V(objectReference, nsLeft, celRect.left); PUT_SEL32V(segMan, objectReference, nsLeft, celRect.left);
PUT_SEL32V(objectReference, nsRight, celRect.right); PUT_SEL32V(segMan, objectReference, nsRight, celRect.right);
PUT_SEL32V(objectReference, nsTop, celRect.top); PUT_SEL32V(segMan, objectReference, nsTop, celRect.top);
PUT_SEL32V(objectReference, nsBottom, celRect.bottom); PUT_SEL32V(segMan, objectReference, nsBottom, celRect.bottom);
} }
delete view; delete view;

158
engines/sci/gui32/gui32.cpp
View file

@ -272,35 +272,35 @@ Common::Rect set_base(EngineState *s, reg_t object) {
int xmod = 0, ymod = 0; int xmod = 0, ymod = 0;
Common::Rect retval; Common::Rect retval;
x = (int16)GET_SEL32V(object, x); x = (int16)GET_SEL32V(segMan, object, x);
original_y = y = (int16)GET_SEL32V(object, y); original_y = y = (int16)GET_SEL32V(segMan, object, y);
if (s->_kernel->_selectorCache.z > -1) if (s->_kernel->_selectorCache.z > -1)
z = (int16)GET_SEL32V(object, z); z = (int16)GET_SEL32V(segMan, object, z);
else else
z = 0; z = 0;
y -= z; // Subtract z offset y -= z; // Subtract z offset
ystep = (int16)GET_SEL32V(object, yStep); ystep = (int16)GET_SEL32V(segMan, object, yStep);
view = (int16)GET_SEL32V(object, view); view = (int16)GET_SEL32V(segMan, object, view);
int l = GET_SEL32V(object, loop); int l = GET_SEL32V(segMan, object, loop);
oldloop = loop = (l & 0x80) ? l - 256 : l; oldloop = loop = (l & 0x80) ? l - 256 : l;
int c = GET_SEL32V(object, cel); int c = GET_SEL32V(segMan, object, cel);
oldcel = cel = (c & 0x80) ? c - 256 : c; oldcel = cel = (c & 0x80) ? c - 256 : c;
Common::Point offset = Common::Point(0, 0); Common::Point offset = Common::Point(0, 0);
if (loop != oldloop) { if (loop != oldloop) {
loop = 0; loop = 0;
PUT_SEL32V(object, loop, 0); PUT_SEL32V(segMan, object, loop, 0);
debugC(2, kDebugLevelGraphics, "Resetting loop for %04x:%04x!\n", PRINT_REG(object)); debugC(2, kDebugLevelGraphics, "Resetting loop for %04x:%04x!\n", PRINT_REG(object));
} }
if (cel != oldcel) { if (cel != oldcel) {
cel = 0; cel = 0;
PUT_SEL32V(object, cel, 0); PUT_SEL32V(segMan, object, cel, 0);
} }
gfxop_get_cel_parameters(s->gfx_state, view, loop, cel, &xsize, &ysize, &offset); gfxop_get_cel_parameters(s->gfx_state, view, loop, cel, &xsize, &ysize, &offset);
@ -373,26 +373,26 @@ Common::Rect get_nsrect(EngineState *s, reg_t object, byte clip) {
int view, loop, cel; int view, loop, cel;
Common::Rect retval; Common::Rect retval;
x = (int16)GET_SEL32V(object, x); x = (int16)GET_SEL32V(segMan, object, x);
y = (int16)GET_SEL32V(object, y); y = (int16)GET_SEL32V(segMan, object, y);
if (s->_kernel->_selectorCache.z > -1) if (s->_kernel->_selectorCache.z > -1)
z = (int16)GET_SEL32V(object, z); z = (int16)GET_SEL32V(segMan, object, z);
else else
z = 0; z = 0;
y -= z; // Subtract z offset y -= z; // Subtract z offset
view = (int16)GET_SEL32V(object, view); view = (int16)GET_SEL32V(segMan, object, view);
int l = (int16)GET_SEL32V(object, loop); int l = (int16)GET_SEL32V(segMan, object, loop);
loop = (l & 0x80) ? l - 256 : l; loop = (l & 0x80) ? l - 256 : l;
int c = (int16)GET_SEL32V(object, cel); int c = (int16)GET_SEL32V(segMan, object, cel);
cel = (c & 0x80) ? c - 256 : c; cel = (c & 0x80) ? c - 256 : c;
retval = calculate_nsrect(s, x, y, view, loop, cel); retval = calculate_nsrect(s, x, y, view, loop, cel);
if (clip) { if (clip) {
int priority = (int16)GET_SEL32V(object, priority); int priority = (int16)GET_SEL32V(segMan, object, priority);
return nsrect_clip(s, y, retval, priority); return nsrect_clip(s, y, retval, priority);
} }
@ -405,26 +405,26 @@ Common::Rect get_nsrect32(EngineState *s, reg_t object, byte clip) {
int view, loop, cel; int view, loop, cel;
Common::Rect retval; Common::Rect retval;
x = (int16)GET_SEL32V(object, x); x = (int16)GET_SEL32V(segMan, object, x);
y = (int16)GET_SEL32V(object, y); y = (int16)GET_SEL32V(segMan, object, y);
if (s->_kernel->_selectorCache.z > -1) if (s->_kernel->_selectorCache.z > -1)
z = (int16)GET_SEL32V(object, z); z = (int16)GET_SEL32V(segMan, object, z);
else else
z = 0; z = 0;
y -= z; // Subtract z offset y -= z; // Subtract z offset
view = (int16)GET_SEL32V(object, view); view = (int16)GET_SEL32V(segMan, object, view);
int l = (int16)GET_SEL32V(object, loop); int l = (int16)GET_SEL32V(segMan, object, loop);
loop = (l & 0x80) ? l - 256 : l; loop = (l & 0x80) ? l - 256 : l;
int c = (int16)GET_SEL32V(object, cel); int c = (int16)GET_SEL32V(segMan, object, cel);
cel = (c & 0x80) ? c - 256 : c; cel = (c & 0x80) ? c - 256 : c;
retval = calculate_nsrect(s, x, y, view, loop, cel); retval = calculate_nsrect(s, x, y, view, loop, cel);
if (clip) { if (clip) {
int priority = (int16)GET_SEL32V(object, priority); int priority = (int16)GET_SEL32V(segMan, object, priority);
return nsrect_clip(s, y, retval, priority); return nsrect_clip(s, y, retval, priority);
} }
@ -1046,7 +1046,7 @@ static inline int sign_extend_byte(int value) {
void SciGui32::editControl(reg_t controlObject, reg_t eventObject) { void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
SegManager *segMan = _s->_segMan; SegManager *segMan = _s->_segMan;
uint16 ct_type = GET_SEL32V(controlObject, type); uint16 ct_type = GET_SEL32V(segMan, controlObject, type);
switch (ct_type) { switch (ct_type) {
@ -1054,13 +1054,13 @@ void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
break; // NOP break; // NOP
case K_CONTROL_EDIT: case K_CONTROL_EDIT:
if (eventObject.segment && ((GET_SEL32V(eventObject, type)) == SCI_EVT_KEYBOARD)) { if (eventObject.segment && ((GET_SEL32V(segMan, eventObject, type)) == SCI_EVT_KEYBOARD)) {
int max_displayed = GET_SEL32V(controlObject, max); int max_displayed = GET_SEL32V(segMan, controlObject, max);
int max = max_displayed; int max = max_displayed;
int cursor = GET_SEL32V(controlObject, cursor); int cursor = GET_SEL32V(segMan, controlObject, cursor);
int modifiers = GET_SEL32V(eventObject, modifiers); int modifiers = GET_SEL32V(segMan, eventObject, modifiers);
int key = GET_SEL32V(eventObject, message); int key = GET_SEL32V(segMan, eventObject, message);
reg_t text_pos = GET_SEL32(controlObject, text); reg_t text_pos = GET_SEL32(segMan, controlObject, text);
int display_offset = 0; int display_offset = 0;
Common::String text = _s->_segMan->getString(text_pos); Common::String text = _s->_segMan->getString(text_pos);
@ -1105,7 +1105,7 @@ void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
_K_EDIT_DELETE; _K_EDIT_DELETE;
break; break;
} }
PUT_SEL32V(eventObject, claimed, 1); PUT_SEL32V(segMan, eventObject, claimed, 1);
} else if (modifiers & SCI_EVM_ALT) { // Ctrl has precedence over Alt } else if (modifiers & SCI_EVM_ALT) { // Ctrl has precedence over Alt
switch (key) { switch (key) {
@ -1129,15 +1129,15 @@ void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
break; break;
} }
} }
PUT_SEL32V(eventObject, claimed, 1); PUT_SEL32V(segMan, eventObject, claimed, 1);
} else if (key < 31) { } else if (key < 31) {
PUT_SEL32V(eventObject, claimed, 1); PUT_SEL32V(segMan, eventObject, claimed, 1);
switch (key) { switch (key) {
case SCI_K_BACKSPACE: case SCI_K_BACKSPACE:
_K_EDIT_BACKSPACE; _K_EDIT_BACKSPACE;
break; break;
default: default:
PUT_SEL32V(eventObject, claimed, 0); PUT_SEL32V(segMan, eventObject, claimed, 0);
} }
} else if (key & 0xff00) { } else if (key & 0xff00) {
switch (key) { switch (key) {
@ -1159,7 +1159,7 @@ void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
_K_EDIT_DELETE; _K_EDIT_DELETE;
break; break;
} }
PUT_SEL32V(eventObject, claimed, 1); PUT_SEL32V(segMan, eventObject, claimed, 1);
} else if ((key > 31) && (key < 128)) { } else if ((key > 31) && (key < 128)) {
int inserting = (modifiers & SCI_EVM_INSERT); int inserting = (modifiers & SCI_EVM_INSERT);
@ -1188,13 +1188,13 @@ void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
cursor -= display_offset; cursor -= display_offset;
PUT_SEL32V(eventObject, claimed, 1); PUT_SEL32V(segMan, eventObject, claimed, 1);
} }
PUT_SEL32V(controlObject, cursor, cursor); // Write back cursor position PUT_SEL32V(segMan, controlObject, cursor, cursor); // Write back cursor position
_s->_segMan->strcpy(text_pos, text.c_str()); // Write back string _s->_segMan->strcpy(text_pos, text.c_str()); // Write back string
} }
if (eventObject.segment) PUT_SEL32V(eventObject, claimed, 1); if (eventObject.segment) PUT_SEL32V(segMan, eventObject, claimed, 1);
_k_GenericDrawControl(_s, controlObject, false); _k_GenericDrawControl(_s, controlObject, false);
return; return;
@ -1204,10 +1204,10 @@ void SciGui32::editControl(reg_t controlObject, reg_t eventObject) {
return; return;
case K_CONTROL_TEXT: { case K_CONTROL_TEXT: {
int state = GET_SEL32V(controlObject, state); int state = GET_SEL32V(segMan, controlObject, state);
PUT_SEL32V(controlObject, state, state | kControlStateDitherFramed); PUT_SEL32V(segMan, controlObject, state, state | kControlStateDitherFramed);
_k_GenericDrawControl(_s, controlObject, false); _k_GenericDrawControl(_s, controlObject, false);
PUT_SEL32V(controlObject, state, state); PUT_SEL32V(segMan, controlObject, state, state);
} }
break; break;
@ -1449,7 +1449,7 @@ enum {
GfxDynView *SciGui32::_k_make_dynview_obj(reg_t obj, int options, int nr, int argc, reg_t *argv) { GfxDynView *SciGui32::_k_make_dynview_obj(reg_t obj, int options, int nr, int argc, reg_t *argv) {
SegManager *segMan = _s->_segMan; SegManager *segMan = _s->_segMan;
short oldloop, oldcel; short oldloop, oldcel;
int cel, loop, view_nr = (int16)GET_SEL32V(obj, view); int cel, loop, view_nr = (int16)GET_SEL32V(segMan, obj, view);
int palette; int palette;
int signal; int signal;
reg_t under_bits; reg_t under_bits;
@ -1461,19 +1461,19 @@ GfxDynView *SciGui32::_k_make_dynview_obj(reg_t obj, int options, int nr, int ar
obj = obj; obj = obj;
pos.x = (int16)GET_SEL32V(obj, x); pos.x = (int16)GET_SEL32V(segMan, obj, x);
pos.y = (int16)GET_SEL32V(obj, y); pos.y = (int16)GET_SEL32V(segMan, obj, y);
pos.y++; // magic: Sierra appears to do something like this pos.y++; // magic: Sierra appears to do something like this
z = (int16)GET_SEL32V(obj, z); z = (int16)GET_SEL32V(segMan, obj, z);
// !-- nsRect used to be checked here! // !-- nsRect used to be checked here!
loop = oldloop = sign_extend_byte(GET_SEL32V(obj, loop)); loop = oldloop = sign_extend_byte(GET_SEL32V(segMan, obj, loop));
cel = oldcel = sign_extend_byte(GET_SEL32V(obj, cel)); cel = oldcel = sign_extend_byte(GET_SEL32V(segMan, obj, cel));
if (_s->_kernel->_selectorCache.palette) if (_s->_kernel->_selectorCache.palette)
palette = GET_SEL32V(obj, palette); palette = GET_SEL32V(segMan, obj, palette);
else else
palette = 0; palette = 0;
@ -1486,10 +1486,10 @@ GfxDynView *SciGui32::_k_make_dynview_obj(reg_t obj, int options, int nr, int ar
cel = 0; cel = 0;
if (oldloop != loop) if (oldloop != loop)
PUT_SEL32V(obj, loop, loop); PUT_SEL32V(segMan, obj, loop, loop);
if (oldcel != cel) { if (oldcel != cel) {
PUT_SEL32V(obj, cel, cel); PUT_SEL32V(segMan, obj, cel, cel);
} }
ObjVarRef under_bitsp; ObjVarRef under_bitsp;
@ -1554,7 +1554,7 @@ void SciGui32::_k_make_view_list(GfxList **widget_list, List *list, int options,
GfxDynView *tempWidget; GfxDynView *tempWidget;
if (options & _K_MAKE_VIEW_LIST_CYCLE) { if (options & _K_MAKE_VIEW_LIST_CYCLE) {
unsigned int signal = GET_SEL32V(obj, signal); unsigned int signal = GET_SEL32V(segMan, obj, signal);
if (!(signal & _K_VIEW_SIG_FLAG_FROZEN)) { if (!(signal & _K_VIEW_SIG_FLAG_FROZEN)) {
@ -1716,10 +1716,10 @@ void SciGui32::_k_set_now_seen(reg_t object) {
return; return;
} // This isn't fatal } // This isn't fatal
PUT_SEL32V(object, nsLeft, absrect.left); PUT_SEL32V(segMan, object, nsLeft, absrect.left);
PUT_SEL32V(object, nsRight, absrect.right); PUT_SEL32V(segMan, object, nsRight, absrect.right);
PUT_SEL32V(object, nsTop, absrect.top); PUT_SEL32V(segMan, object, nsTop, absrect.top);
PUT_SEL32V(object, nsBottom, absrect.bottom); PUT_SEL32V(segMan, object, nsBottom, absrect.bottom);
} }
void SciGui32::_k_prepare_view_list(GfxList *list, int options) { void SciGui32::_k_prepare_view_list(GfxList *list, int options) {
@ -1736,18 +1736,18 @@ void SciGui32::_k_prepare_view_list(GfxList *list, int options) {
_priority = _find_view_priority(_s, _priority - 1); _priority = _find_view_priority(_s, _priority - 1);
if (options & _K_MAKE_VIEW_LIST_DRAW_TO_CONTROL_MAP) { // Picview if (options & _K_MAKE_VIEW_LIST_DRAW_TO_CONTROL_MAP) { // Picview
priority = (int16)GET_SEL32V(obj, priority); priority = (int16)GET_SEL32V(segMan, obj, priority);
if (priority < 0) if (priority < 0)
priority = _priority; // Always for picviews priority = _priority; // Always for picviews
} else { // Dynview } else { // Dynview
if (has_nsrect && !(view->signal & _K_VIEW_SIG_FLAG_FIX_PRI_ON)) { // Calculate priority if (has_nsrect && !(view->signal & _K_VIEW_SIG_FLAG_FIX_PRI_ON)) { // Calculate priority
if (options & _K_MAKE_VIEW_LIST_CALC_PRIORITY) if (options & _K_MAKE_VIEW_LIST_CALC_PRIORITY)
PUT_SEL32V(obj, priority, _priority); PUT_SEL32V(segMan, obj, priority, _priority);
priority = _priority; priority = _priority;
} else // DON'T calculate the priority } else // DON'T calculate the priority
priority = (int16)GET_SEL32V(obj, priority); priority = (int16)GET_SEL32V(segMan, obj, priority);
} }
view->_color.priority = priority; view->_color.priority = priority;
@ -1993,17 +1993,17 @@ void SciGui32::_k_view_list_do_postdraw(GfxList *list) {
if (has_nsrect) { if (has_nsrect) {
int temp; int temp;
temp = GET_SEL32V(obj, nsLeft); temp = GET_SEL32V(segMan, obj, nsLeft);
PUT_SEL32V(obj, lsLeft, temp); PUT_SEL32V(segMan, obj, lsLeft, temp);
temp = GET_SEL32V(obj, nsRight); temp = GET_SEL32V(segMan, obj, nsRight);
PUT_SEL32V(obj, lsRight, temp); PUT_SEL32V(segMan, obj, lsRight, temp);
temp = GET_SEL32V(obj, nsTop); temp = GET_SEL32V(segMan, obj, nsTop);
PUT_SEL32V(obj, lsTop, temp); PUT_SEL32V(segMan, obj, lsTop, temp);
temp = GET_SEL32V(obj, nsBottom); temp = GET_SEL32V(segMan, obj, nsBottom);
PUT_SEL32V(obj, lsBottom, temp); PUT_SEL32V(segMan, obj, lsBottom, temp);
#ifdef DEBUG_LSRECT #ifdef DEBUG_LSRECT
fprintf(_stderr, "lsRected %04x:%04x\n", PRINT_REG(obj)); fprintf(_stderr, "lsRected %04x:%04x\n", PRINT_REG(obj));
#endif #endif
@ -2607,19 +2607,19 @@ void SciGui32::setNowSeen(reg_t objectReference) {
static int collides_with(EngineState *s, Common::Rect area, reg_t other_obj, int use_nsrect, int view_mask) { static int collides_with(EngineState *s, Common::Rect area, reg_t other_obj, int use_nsrect, int view_mask) {
SegManager *segMan = s->_segMan; SegManager *segMan = s->_segMan;
int other_signal = GET_SEL32V(other_obj, signal); int other_signal = GET_SEL32V(segMan, other_obj, signal);
int other_priority = GET_SEL32V(other_obj, priority); int other_priority = GET_SEL32V(segMan, other_obj, priority);
int y = (int16)GET_SEL32V(other_obj, y); int y = (int16)GET_SEL32V(segMan, other_obj, y);
Common::Rect other_area; Common::Rect other_area;
if (use_nsrect) { if (use_nsrect) {
other_area = get_nsrect(s, other_obj, 0); other_area = get_nsrect(s, other_obj, 0);
other_area = nsrect_clip(s, y, other_area, other_priority); other_area = nsrect_clip(s, y, other_area, other_priority);
} else { } else {
other_area.left = GET_SEL32V(other_obj, brLeft); other_area.left = GET_SEL32V(segMan, other_obj, brLeft);
other_area.right = GET_SEL32V(other_obj, brRight); other_area.right = GET_SEL32V(segMan, other_obj, brRight);
other_area.top = GET_SEL32V(other_obj, brTop); other_area.top = GET_SEL32V(segMan, other_obj, brTop);
other_area.bottom = GET_SEL32V(other_obj, brBottom); other_area.bottom = GET_SEL32V(segMan, other_obj, brBottom);
} }
if (other_area.right < 0 || other_area.bottom < 0 || area.right < 0 || area.bottom < 0) if (other_area.right < 0 || other_area.bottom < 0 || area.right < 0 || area.bottom < 0)
@ -2660,19 +2660,19 @@ bool SciGui32::canBeHere(reg_t curObject, reg_t listReference) {
uint16 edgehit; uint16 edgehit;
uint16 illegal_bits; uint16 illegal_bits;
abs_zone.left = (int16)GET_SEL32V(curObject, brLeft); abs_zone.left = (int16)GET_SEL32V(segMan, curObject, brLeft);
abs_zone.right = (int16)GET_SEL32V(curObject, brRight); abs_zone.right = (int16)GET_SEL32V(segMan, curObject, brRight);
abs_zone.top = (int16)GET_SEL32V(curObject, brTop); abs_zone.top = (int16)GET_SEL32V(segMan, curObject, brTop);
abs_zone.bottom = (int16)GET_SEL32V(curObject, brBottom); abs_zone.bottom = (int16)GET_SEL32V(segMan, curObject, brBottom);
zone = gfx_rect(abs_zone.left + port->zone.x, abs_zone.top + port->zone.y, abs_zone.width(), abs_zone.height()); zone = gfx_rect(abs_zone.left + port->zone.x, abs_zone.top + port->zone.y, abs_zone.width(), abs_zone.height());
signal = GET_SEL32V(curObject, signal); signal = GET_SEL32V(segMan, curObject, signal);
debugC(2, kDebugLevelBresen, "Checking collision: (%d,%d) to (%d,%d) ([%d..%d]x[%d..%d]), obj=%04x:%04x, sig=%04x, cliplist=%04x:%04x\n", debugC(2, kDebugLevelBresen, "Checking collision: (%d,%d) to (%d,%d) ([%d..%d]x[%d..%d]), obj=%04x:%04x, sig=%04x, cliplist=%04x:%04x\n",
GFX_PRINT_RECT(zone), abs_zone.left, abs_zone.right, abs_zone.top, abs_zone.bottom, GFX_PRINT_RECT(zone), abs_zone.left, abs_zone.right, abs_zone.top, abs_zone.bottom,
PRINT_REG(curObject), signal, PRINT_REG(listReference)); PRINT_REG(curObject), signal, PRINT_REG(listReference));
illegal_bits = GET_SEL32V(curObject, illegalBits); illegal_bits = GET_SEL32V(segMan, curObject, illegalBits);
retval = !(illegal_bits & (edgehit = gfxop_scan_bitmask(_s->gfx_state, zone, GFX_MASK_CONTROL))); retval = !(illegal_bits & (edgehit = gfxop_scan_bitmask(_s->gfx_state, zone, GFX_MASK_CONTROL)));