diff options
Diffstat (limited to 'engines/m4/ws_sequence.cpp')
| -rw-r--r-- | engines/m4/ws_sequence.cpp | 764 |
1 files changed, 764 insertions, 0 deletions
diff --git a/engines/m4/ws_sequence.cpp b/engines/m4/ws_sequence.cpp new file mode 100644 index 0000000000..918979ad17 --- /dev/null +++ b/engines/m4/ws_sequence.cpp @@ -0,0 +1,764 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "m4/woodscript.h" + +namespace M4 { + +long sinCosTable[320] = { + 0, 1608, 3215, 4821, 6423, 8022, 9616, 11204, + 12785, 14359, 15923, 17479, 19024, 20557, 22078, 23586, + 25079, 26557, 28020, 29465, 30893, 32302, 33692, 35061, + 36409, 37736, 39039, 40319, 41575, 42806, 44011, 45189, + 46340, 47464, 48558, 49624, 50660, 51665, 52639, 53581, + 54491, 55368, 56212, 57022, 57797, 58538, 59243, 59913, + 60547, 61144, 61705, 62228, 62714, 63162, 63571, 63943, + 64276, 64571, 64826, 65043, 65220, 65358, 65457, 65516, + 65536, 65516, 65457, 65358, 65220, 65043, 64826, 64571, + 64276, 63943, 63571, 63162, 62714, 62228, 61705, 61144, + 60547, 59913, 59243, 58538, 57797, 57022, 56212, 55368, + 54491, 53581, 52639, 51665, 50660, 49624, 48558, 47464, + 46340, 45189, 44011, 42806, 41575, 40319, 39039, 37736, + 36409, 35061, 33692, 32302, 30893, 29465, 28020, 26557, + 25079, 23586, 22078, 20557, 19024, 17479, 15923, 14359, + 12785, 11204, 9616, 8022, 6423, 4821, 3215, 1608, + 0, -1608, -3215, -4821, -6423, -8022, -9616, -11204, + -12785, -14359, -15923, -17479, -19024, -20557, -22078, -23586, + -25079, -26557, -28020, -29465, -30893, -32302, -33692, -35061, + -36409, -37736, -39039, -40319, -41575, -42806, -44011, -45189, + -46340, -47464, -48558, -49624, -50660, -51665, -52639, -53581, + -54491, -55368, -56212, -57022, -57797, -58538, -59243, -59913, + -60547, -61144, -61705, -62228, -62714, -63162, -63571, -63943, + -64276, -64571, -64826, -65043, -65220, -65358, -65457, -65516, + -65536, -65516, -65457, -65358, -65220, -65043, -64826, -64571, + -64276, -63943, -63571, -63162, -62714, -62228, -61705, -61144, + -60547, -59913, -59243, -58538, -57797, -57022, -56212, -55368, + -54491, -53581, -52639, -51665, -50660, -49624, -48558, -47464, + -46340, -45189, -44011, -42806, -41575, -40319, -39039, -37736, + -36409, -35061, -33692, -32302, -30893, -29465, -28020, -26557, + -25079, -23586, -22078, -20557, -19024, -17479, -15923, -14359, + -12785, -11204, -9616, -8022, -6423, -4821, -3215, -1608, + 0, 1608, 3215, 4821, 6423, 8022, 9616, 11204, + 12785, 14359, 15923, 17479, 19024, 20557, 22078, 23586, + 25079, 26557, 28020, 29465, 30893, 32302, 33692, 35061, + 36409, 37736, 39039, 40319, 41575, 42806, 44011, 45189, + 46340, 47464, 48558, 49624, 50660, 51665, 52639, 53581, + 54491, 55368, 56212, 57022, 57797, 58538, 59243, 59913, + 60547, 61144, 61705, 62228, 62714, 63162, 63571, 63943, + 64276, 64571, 64826, 65043, 65220, 65358, 65457, 65516 +}; + +long *sinTable = &(sinCosTable[0]); +long *cosTable = &(sinCosTable[64]); + +// FIXME: Tables + +const int sequenceVariableCount = 33; + +enum SequenceVariables { + kSeqVarTimer = 0, + kSeqVarTag = 1, + kSeqVarLayer = 2, + kSeqVarWidth = 3, + kSeqVarHeight = 4, + kSeqVarX = 5, + kSeqVarY = 6, + kSeqVarScale = 7, + kSeqVarR = 8, + kSeqVarSpriteHash = 9, + kSeqVarSpriteFrameNumber = 10, + kSeqVarSpriteFrameCount = 11, + kSeqVarSpriteFrameRate = 12, + kSeqVarSpriteFramePixelSpeed = 13, + kSeqVarTargetS = 14, + kSeqVarTargetR = 15, + kSeqVarTargetX = 16, + kSeqVarTargetY = 17, + kSeqVarDeltaS = 18, + kSeqVarDeltaR = 19, + kSeqVarDeltaX = 20, + kSeqVarDeltaY = 21, + kSeqVarVelocity = 22, + kSeqVarTheta = 23, + kSeqVarTemp1 = 24, + kSeqVarTemp2 = 25, + kSeqVarTemp3 = 26, + kSeqVarTemp4 = 27, + kSeqVarTemp5 = 28, + kSeqVarTemp6 = 29, + kSeqVarTemp7 = 30, + kSeqVarTemp8 = 31, + kSeqVarMachineID = 32 +}; + +bool (Sequence::*sequenceCommandsTable[])(Instruction &instruction) = { + &Sequence::s1_end, + &Sequence::s1_clearVars, + &Sequence::s1_set, + &Sequence::s1_compare, + &Sequence::s1_add, + &Sequence::s1_sub, + &Sequence::s1_mul, + &Sequence::s1_div, + &Sequence::s1_and, + &Sequence::s1_or, + &Sequence::s1_not, + &Sequence::s1_sin, + &Sequence::s1_cos, + &Sequence::s1_abs, + &Sequence::s1_min, + &Sequence::s1_max, + &Sequence::s1_mod, + &Sequence::s1_floor, + &Sequence::s1_round, + &Sequence::s1_ceil, + &Sequence::s1_point, + &Sequence::s1_dist2d, + &Sequence::s1_crunch, + &Sequence::s1_branch, + &Sequence::s1_setFrame, + &Sequence::s1_sendMessage, + &Sequence::s1_push, + &Sequence::s1_pop, + &Sequence::s1_jumpSub, + &Sequence::s1_return, + &Sequence::s1_getFrameCount, + &Sequence::s1_getFrameRate, + &Sequence::s1_getCelsPixSpeed, + &Sequence::s1_setIndex, + &Sequence::s1_setLayer, + &Sequence::s1_setDepth, + &Sequence::s1_setData, + &Sequence::s1_openStream, + &Sequence::s1_streamNextFrame, + &Sequence::s1_closeStream +}; + +Sequence::Sequence(WoodScript *ws, Machine *machine, int32 sequenceHash) { + + _ws = ws; + + SequenceAsset *sequenceAsset = _ws->assets()->getSequence(sequenceHash); + + // initialize the sequence's bytecode + byte *code; + uint32 codeSize; + sequenceAsset->getCode(code, codeSize); + _code = new Bytecode(_ws, code, codeSize, this); + + _active = true; + _sequenceHash = sequenceHash; + _machine = machine; + _parentSequence = _machine->parentSequence(); + _dataRow = _machine->dataRow(); + _startTime = 0; + _switchTime = 0; + //TODO _flags = 0; + _localVarCount = sequenceAsset->localVarCount(); + _vars = new long[sequenceVariableCount + _localVarCount]; + _returnStackIndex = 0; + _layer = 0; + _terminated = false; + + clearVars(); + _vars[kSeqVarMachineID] = _machine->getId(); + +} + +Sequence::~Sequence() { + delete _code; +} + +void Sequence::pause() { + _active = false; +} + +void Sequence::resume() { + _active = true; +} + +void Sequence::issueEndOfSequenceRequest(int32 codeOffset, int32 count) { + + //printf("Sequence::issueEndOfSequenceRequest(%04X, %04X)\n", codeOffset, count); fflush(stdout); + //g_system->delayMillis(5000); + + _endOfSequenceRequest.codeOffset = codeOffset; + _endOfSequenceRequest.count = count; +} + +void Sequence::cancelEndOfSequenceRequest() { + _endOfSequenceRequest.codeOffset = -1; +} + +bool Sequence::runProgram() { + + bool done = true; + + //printf("_ws->getGlobal(kGlobTime) = %ld, _switchTime = %d\n", _ws->getGlobal(kGlobTime), _switchTime); + + if (_switchTime >= 0 && _ws->getGlobal(kGlobTime) >= _switchTime) + done = false; + + _vars[kSeqVarTimer] -= _ws->getGlobal(kGlobTimeDelta) << 16; + + while (!done) { + Instruction instruction; + _code->loadInstruction(instruction); + if (sequenceCommandsTable[instruction.instr] != NULL) + done = !(this->*sequenceCommandsTable[instruction.instr])(instruction); + else { fflush(stdout); /*g_system->delayMillis(1000);*/ } + } + + return _terminated; +} + +void Sequence::clearVars() { + for (int i = 0; i < sequenceVariableCount + _localVarCount; i++) + _vars[i] = 0; + // set default scaling to 100% + _vars[kSeqVarScale] = 0x10000; +} + +bool Sequence::changeProgram(int32 sequenceHash) { + + SequenceAsset *sequenceAsset = _ws->assets()->getSequence(sequenceHash); + + if (sequenceAsset->localVarCount() > _localVarCount) { + //printf("Sequence::changeProgram(%d) sequenceAsset->localVarCount() > _localVarCount\n", sequenceHash); + return false; + } + + // Initialize the sequence's bytecode + byte *code; + uint32 codeSize; + sequenceAsset->getCode(code, codeSize); + _code->setCode(code, codeSize); + + // Reset status variables + _switchTime = 0; + _active = true; + _terminated = false; + _endOfSequenceRequest.codeOffset = -1; + + _sequenceHash = sequenceHash; + _returnStackIndex = 0; + + return true; + +} + +long *Sequence::getVarPtr(int index) { + return &_vars[index]; +} + +long *Sequence::getParentVarPtr(int index) { + return _parentSequence->getVarPtr(index); +} + +long *Sequence::getDataPtr(int index) { + return &_dataRow[index]; +} + +void Sequence::draw(M4Surface *surface, const Common::Rect &clipRect, Common::Rect &updateRect) { + + SpriteInfo info; + + info.sprite = _curFrame; + info.hotX = _curFrame->xOffset; + info.hotY = _curFrame->yOffset; + info.encoding = _curFrame->encoding; + info.inverseColorTable = _vm->_scene->getInverseColorTable(); + info.palette = _ws->getMainPalette(); + info.width = _curFrame->w; + info.height = _curFrame->h; + int32 scaler = FixedMul(_vars[kSeqVarScale], 100 << 16) >> 16; + info.scaleX = _vars[kSeqVarWidth] < 0 ? -scaler : scaler; + info.scaleY = scaler; + surface->drawSprite(_vars[kSeqVarX] >> 16, _vars[kSeqVarY] >> 16, info, clipRect); + +} + +bool Sequence::s1_end(Instruction &instruction) { + //printf("Sequence::s1_end()\n"); + + _terminated = true; + return false; +} + +bool Sequence::s1_clearVars(Instruction &instruction) { + //printf("Sequence::s1_clearVars()\n"); + + clearVars(); + _vars[kSeqVarMachineID] = _machine->getId(); + return true; +} + +bool Sequence::s1_set(Instruction &instruction) { + //printf("Sequence::s1_set()\n"); + + *instruction.argp[0] = instruction.getValue(); + return true; +} + +bool Sequence::s1_compare(Instruction &instruction) { + //printf("Sequence::s1_compare()\n"); + + long value = instruction.getValue(); + if (instruction.argv[0] < value) + _cmpFlags = -1; + else if (instruction.argv[0] > value) + _cmpFlags = 1; + else + _cmpFlags = 0; + return true; +} + +bool Sequence::s1_add(Instruction &instruction) { + //printf("Sequence::s1_add()\n"); + + *instruction.argp[0] += instruction.getValue(); + return true; +} + +bool Sequence::s1_sub(Instruction &instruction) { + //printf("Sequence::s1_sub()\n"); + + *instruction.argp[0] -= instruction.getValue(); + return true; +} + +bool Sequence::s1_mul(Instruction &instruction) { + //printf("Sequence::s1_mul()\n"); + + *instruction.argp[0] = FixedMul(instruction.argv[0], instruction.getValue()); + return true; +} + +bool Sequence::s1_div(Instruction &instruction) { + //printf("Sequence::s1_div()\n"); + + // TODO: Catch divisor = 0 in FixedDiv + *instruction.argp[0] = FixedDiv(instruction.argv[0], instruction.getValue()); + return true; +} + +bool Sequence::s1_and(Instruction &instruction) { + //printf("Sequence::s1_and()\n"); + + *instruction.argp[0] = instruction.argv[0] & instruction.getValue(); + if (*instruction.argp[0]) + _cmpFlags = 0; + else + _cmpFlags = 1; + return true; +} + +bool Sequence::s1_or(Instruction &instruction) { + //printf("Sequence::s1_or()\n"); + + *instruction.argp[0] = instruction.argv[0] | instruction.getValue(); + if (*instruction.argp[0]) + _cmpFlags = 0; + else + _cmpFlags = 1; + return true; +} + +bool Sequence::s1_not(Instruction &instruction) { + //printf("Sequence::s1_not()\n"); + + if (instruction.argv[0] == 0) { + *instruction.argp[0] = 0x10000; + _cmpFlags = 1; + } else { + *instruction.argp[0] = 0; + _cmpFlags = 0; + } + return true; +} + +bool Sequence::s1_sin(Instruction &instruction) { + //printf("Sequence::s1_sin()\n"); + + int32 tempAngle = *instruction.argp[1] >> 16; + if (tempAngle < 0) + tempAngle = 0x0100 - ((-tempAngle) & 0xff); + else + tempAngle &= 0xff; + + *instruction.argp[0] = -cosTable[tempAngle]; + + return true; +} + +bool Sequence::s1_cos(Instruction &instruction) { + //printf("Sequence::s1_cos()\n"); + + int32 tempAngle = *instruction.argp[1] >> 16; + if (tempAngle < 0) + tempAngle = 0x0100 - ((-tempAngle) & 0xff); + else + tempAngle &= 0xff; + + *instruction.argp[0] = sinTable[tempAngle]; + + return true; +} + +bool Sequence::s1_abs(Instruction &instruction) { + //printf("Sequence::s1_abs()\n"); + + *instruction.argp[0] = ABS(instruction.argv[1]); + return true; +} + +bool Sequence::s1_min(Instruction &instruction) { + //printf("Sequence::s1_min()\n"); + + *instruction.argp[0] = MIN(instruction.argv[1], instruction.argv[2]); + return true; +} + +bool Sequence::s1_max(Instruction &instruction) { + //printf("Sequence::s1_max()\n"); + + *instruction.argp[0] = MAX(instruction.argv[1], instruction.argv[2]); + return true; +} + +bool Sequence::s1_mod(Instruction &instruction) { + //printf("Sequence::s1_mod()\n"); + + *instruction.argp[0] = instruction.argv[0] % instruction.getValue(); + return true; +} + +bool Sequence::s1_floor(Instruction &instruction) { + //printf("Sequence::s1_floor()\n"); + + *instruction.argp[0] = instruction.getValue() & 0xffff0000; + return true; +} + +bool Sequence::s1_round(Instruction &instruction) { + //printf("Sequence::s1_round()\n"); + + if ((*instruction.argp[1] & 0xffff) >= 0x8000) + *instruction.argp[0] = (*instruction.argp[1] + 0x10000) & 0xffff0000; + else + *instruction.argp[0] = *instruction.argp[1] & 0xffff0000; + return true; +} + +bool Sequence::s1_ceil(Instruction &instruction) { + //printf("Sequence::s1_ceil()\n"); + + if ((*instruction.argp[1] & 0xffff) >= 0) + *instruction.argp[0] = (*instruction.argp[1] + 0x10000) & 0xffff0000; + else + *instruction.argp[0] = *instruction.argp[1] & 0xffff0000; + return true; +} + +bool Sequence::s1_point(Instruction &instruction) { + printf("Sequence::s1_point()\n"); + // TODO + return true; +} + +bool Sequence::s1_dist2d(Instruction &instruction) { + printf("Sequence::s1_dist2d()\n"); + // TODO + return true; +} + +bool Sequence::s1_crunch(Instruction &instruction) { + //printf("Sequence::s1_crunch()\n"); + + long deltaTime; + + if (instruction.argc == 2) { + deltaTime = _vm->imath_ranged_rand16(instruction.argv[0], instruction.argv[1]); + } else if (instruction.argc == 1) { + deltaTime = instruction.argv[0]; + } else { + deltaTime = 0; + } + + _startTime = _ws->getGlobal(kGlobTime); + + //printf("deltaTime = %ld\n", deltaTime >> 16); fflush(stdout); + //g_system->delayMillis(5000); + + if (deltaTime >= 0) { + _switchTime = _ws->getGlobal(kGlobTime) + (deltaTime >> 16); + //printf("_ws->getGlobal(kGlobTime) = %ld\n", _ws->getGlobal(kGlobTime)); fflush(stdout); + //g_system->delayMillis(5000); + } else { + _switchTime = -1; + } + + // TODO: Update if walking etc. + + return false; +} + +bool Sequence::s1_branch(Instruction &instruction) { + //printf("Sequence::s1_branch()\n"); + + uint32 ofs = instruction.argv[1] >> 16; + switch (instruction.argv[0] >> 16) { + case 0: // jmp + _code->jumpRelative(ofs); + break; + case 1: // < + if (_cmpFlags < 0) + _code->jumpRelative(ofs); + break; + case 2: // <= + if (_cmpFlags <= 0) + _code->jumpRelative(ofs); + break; + case 3: // == + if (_cmpFlags == 0) + _code->jumpRelative(ofs); + break; + case 4: // != + if (_cmpFlags != 0) + _code->jumpRelative(ofs); + break; + case 5: // >= + if (_cmpFlags >= 0) + _code->jumpRelative(ofs); + break; + case 6: // > + if (_cmpFlags > 0) + _code->jumpRelative(ofs); + break; + } + + return true; +} + +bool Sequence::s1_setFrame(Instruction &instruction) { + //printf("Sequence::s1_setFrame()\n"); + + int32 frameIndex; + if (instruction.argc == 3) { + frameIndex = _vm->imath_ranged_rand(instruction.argv[1] >> 16, instruction.argv[2] >> 16); + } else if (instruction.argc == 2) { + frameIndex = instruction.argv[1] >> 16; + } else { + frameIndex = (instruction.argv[0] & 0xFF0000) >> 16; + } + + //printf("Sequence::s1_setFrame() spriteHash = %d\n", (uint32)instruction.argv[0] >> 24); + //printf("Sequence::s1_setFrame() frameIndex = %d\n", frameIndex); + + SpriteAsset *spriteAsset = _ws->assets()->getSprite((uint32)instruction.argv[0] >> 24); + _curFrame = spriteAsset->getFrame(frameIndex); + + return true; +} + +bool Sequence::s1_sendMessage(Instruction &instruction) { + printf("Sequence::s1_sendMessage()\n"); + // TODO + return true; +} + +bool Sequence::s1_push(Instruction &instruction) { + printf("Sequence::s1_push()\n"); + // TODO + return true; +} + +bool Sequence::s1_pop(Instruction &instruction) { + printf("Sequence::s1_pop()\n"); + // TODO + return true; +} + +bool Sequence::s1_jumpSub(Instruction &instruction) { + //printf("Sequence::s1_jumpSub()\n"); + + _returnHashes[_returnStackIndex] = _sequenceHash; + _returnOffsets[_returnStackIndex] = _code->pos(); + _returnStackIndex++; + + _sequenceHash = instruction.argv[0] >> 16; + + SequenceAsset *sequenceAsset = _ws->assets()->getSequence(_sequenceHash); + + // initialize the sequence's bytecode + byte *code; + uint32 codeSize; + sequenceAsset->getCode(code, codeSize); + _code->setCode(code, codeSize); + + return true; +} + +bool Sequence::s1_return(Instruction &instruction) { + //printf("Sequence::s1_return()\n"); + + if (_returnStackIndex <= 0) + return s1_end(instruction); + + _returnStackIndex--; + + _sequenceHash = _returnHashes[_returnStackIndex]; + uint32 ofs = _returnOffsets[_returnStackIndex]; + + SequenceAsset *sequenceAsset = _ws->assets()->getSequence(_sequenceHash); + + // initialize the sequence's bytecode + byte *code; + uint32 codeSize; + sequenceAsset->getCode(code, codeSize); + _code->setCode(code, codeSize); + _code->jumpAbsolute(ofs); + + + return true; +} + +bool Sequence::s1_getFrameCount(Instruction &instruction) { + //printf("Sequence::s1_getFrameCount()\n"); + + SpriteAsset *spriteAsset = _ws->assets()->getSprite(instruction.argv[1] >> 24); + *instruction.argp[0] = spriteAsset->getCount() << 16; + return true; +} + +bool Sequence::s1_getFrameRate(Instruction &instruction) { + //printf("Sequence::s1_getFrameRate()\n"); + + SpriteAsset *spriteAsset = _ws->assets()->getSprite(instruction.argv[1] >> 24); + *instruction.argp[0] = spriteAsset->getFrameRate(); + return true; +} + +bool Sequence::s1_getCelsPixSpeed(Instruction &instruction) { + printf("Sequence::s1_getCelsPixSpeed()\n"); + // TODO + return true; +} + +bool Sequence::s1_setIndex(Instruction &instruction) { + printf("Sequence::s1_setIndex()\n"); + // TODO + return true; +} + +bool Sequence::s1_setLayer(Instruction &instruction) { + printf("Sequence::s1_setLayer()\n"); + //TODO + return true; +} + +bool Sequence::s1_setDepth(Instruction &instruction) { + printf("Sequence::s1_setDepth()\n"); + //TODO + return true; +} + +bool Sequence::s1_setData(Instruction &instruction) { + printf("Sequence::s1_setData()\n"); + //TODO + return true; +} + +bool Sequence::s1_openStream(Instruction &instruction) { + //printf("Sequence::s1_openStream()\n"); + + _stream = _vm->res()->openFile(_machine->name().c_str()); + streamOpen(); + return true; +} + +bool Sequence::s1_streamNextFrame(Instruction &instruction) { + //printf("Sequence::s1_streamNextFrame()\n"); + + streamNextFrame(); + return true; +} + +bool Sequence::s1_closeStream(Instruction &instruction) { + printf("Sequence::s1_closeStream()\n"); + //TODO + return true; +} + +bool Sequence::streamOpen() { + + _streamSpriteAsset = new SpriteAsset(_vm, _stream, _stream->size(), "stream", true); + + _vars[kSeqVarSpriteFrameNumber] = -0x10000; + _vars[kSeqVarSpriteFrameCount] = _streamSpriteAsset->getCount() << 16; + _vars[kSeqVarSpriteFrameRate] = _streamSpriteAsset->getFrameRate() << 16; + + //printf("Sequence::streamOpen() frames = %d; max = %d x %d\n", _streamSpriteAsset->getCount(), _streamSpriteAsset->getMaxFrameWidth(), _streamSpriteAsset->getMaxFrameHeight()); + //fflush(stdout); + + _curFrame = new M4Sprite(_vm, _streamSpriteAsset->getMaxFrameWidth(), _streamSpriteAsset->getMaxFrameHeight()); + streamNextFrame(); + + // TODO: Just a hack to see the series with the correct palette. + _vm->_palette->setPalette(_streamSpriteAsset->getPalette(), 0, 256); + + return true; +} + +bool Sequence::streamNextFrame() { + + _vars[kSeqVarSpriteFrameNumber] += 0x10000; + + int32 frameNum = _vars[kSeqVarSpriteFrameNumber] >> 16; + if (frameNum >= _streamSpriteAsset->getCount()) { + // End reached + return false; + } + + _streamSpriteAsset->loadStreamingFrame(_curFrame, frameNum, _vars[kSeqVarX], _vars[kSeqVarY]); + + _vars[kSeqVarWidth] = _curFrame->w << 16; + _vars[kSeqVarHeight] = _curFrame->h << 16; + + return true; +} + +void Sequence::streamClose() { + _stream = NULL; + _vm->res()->toss(_machine->name().c_str()); + //_vm->res()->purge(); + delete _streamSpriteAsset; + delete _curFrame; + _stream = NULL; + _streamSpriteAsset = NULL; + _curFrame = NULL; +} + +} |