/* 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. * */ #include "common/algorithm.h" #include "common/memstream.h" #include "neverhood/resource.h" #include "neverhood/resourceman.h" namespace Neverhood { // SpriteResource SpriteResource::SpriteResource(NeverhoodEngine *vm) : _vm(vm), _pixels(NULL) { } SpriteResource::~SpriteResource() { unload(); } void SpriteResource::draw(Graphics::Surface *destSurface, bool flipX, bool flipY) { if (_pixels) { byte *dest = (byte*)destSurface->getPixels(); const int destPitch = destSurface->pitch; if (_rle) unpackSpriteRle(_pixels, _dimensions.width, _dimensions.height, dest, destPitch, flipX, flipY); else unpackSpriteNormal(_pixels, _dimensions.width, _dimensions.height, dest, destPitch, flipX, flipY); } } bool SpriteResource::load(uint32 fileHash, bool doLoadPosition) { debug(2, "SpriteResource::load(%08X)", fileHash); unload(); _vm->_res->queryResource(fileHash, _resourceHandle); if (_resourceHandle.isValid() && _resourceHandle.type() == kResTypeBitmap) { _vm->_res->loadResource(_resourceHandle, _vm->applyResourceFixes()); const byte *spriteData = _resourceHandle.data(); NPoint *position = doLoadPosition ? &_position : NULL; parseBitmapResource(spriteData, &_rle, &_dimensions, position, NULL, &_pixels); } return _pixels != NULL; } void SpriteResource::unload() { _vm->_res->unloadResource(_resourceHandle); _pixels = NULL; _rle = false; } // PaletteResource PaletteResource::PaletteResource(NeverhoodEngine *vm) : _vm(vm), _palette(NULL) { } PaletteResource::~PaletteResource() { unload(); } bool PaletteResource::load(uint32 fileHash) { debug(2, "PaletteResource::load(%08X)", fileHash); unload(); _vm->_res->queryResource(fileHash, _resourceHandle); if (_resourceHandle.isValid() && (_resourceHandle.type() == kResTypeBitmap || _resourceHandle.type() == kResTypePalette)) { _vm->_res->loadResource(_resourceHandle, _vm->applyResourceFixes()); _palette = _resourceHandle.data(); // Check if the palette is stored in a bitmap if (_resourceHandle.type() == kResTypeBitmap) parseBitmapResource(_palette, NULL, NULL, NULL, &_palette, NULL); } return _palette != NULL; } void PaletteResource::unload() { _vm->_res->unloadResource(_resourceHandle); _palette = NULL; } void PaletteResource::copyPalette(byte *destPalette) { if (_palette) memcpy(destPalette, _palette, 1024); } // AnimResource AnimResource::AnimResource(NeverhoodEngine *vm) : _vm(vm), _width(0), _height(0), _currSpriteData(NULL), _fileHash(0), _paletteData(NULL), _spriteData(NULL), _replEnabled(false), _replOldColor(0), _replNewColor(0) { } AnimResource::~AnimResource() { unload(); } void AnimResource::draw(uint frameIndex, Graphics::Surface *destSurface, bool flipX, bool flipY) { const AnimFrameInfo frameInfo = _frames[frameIndex]; byte *dest = (byte*)destSurface->getPixels(); const int destPitch = destSurface->pitch; _currSpriteData = _spriteData + frameInfo.spriteDataOffs; _width = frameInfo.drawOffset.width; _height = frameInfo.drawOffset.height; if (_replEnabled && _replOldColor != _replNewColor) unpackSpriteRle(_currSpriteData, _width, _height, dest, destPitch, flipX, flipY, _replOldColor, _replNewColor); else unpackSpriteRle(_currSpriteData, _width, _height, dest, destPitch, flipX, flipY); } bool AnimResource::load(uint32 fileHash) { debug(2, "AnimResource::load(%08X)", fileHash); if (fileHash == _fileHash) return true; unload(); _vm->_res->queryResource(fileHash, _resourceHandle); if (!_resourceHandle.isValid() || _resourceHandle.type() != kResTypeAnimation) return false; const byte *resourceData, *animList, *frameList; uint16 animInfoStartOfs, animListIndex, animListCount; uint16 frameListStartOfs, frameCount; uint32 spriteDataOfs, paletteDataOfs; _vm->_res->loadResource(_resourceHandle, _vm->applyResourceFixes()); resourceData = _resourceHandle.data(); animListCount = READ_LE_UINT16(resourceData); animInfoStartOfs = READ_LE_UINT16(resourceData + 2); spriteDataOfs = READ_LE_UINT32(resourceData + 4); paletteDataOfs = READ_LE_UINT32(resourceData + 8); animList = resourceData + 12; for (animListIndex = 0; animListIndex < animListCount; animListIndex++) { debug(8, "hash: %08X", READ_LE_UINT32(animList)); if (READ_LE_UINT32(animList) == fileHash) break; animList += 8; } if (animListIndex >= animListCount) { _vm->_res->unloadResource(_resourceHandle); return false; } _spriteData = resourceData + spriteDataOfs; if (paletteDataOfs > 0) _paletteData = resourceData + paletteDataOfs; frameCount = READ_LE_UINT16(animList + 4); frameListStartOfs = READ_LE_UINT16(animList + 6); debug(8, "frameCount = %d; frameListStartOfs = %04X; animInfoStartOfs = %04X", frameCount, frameListStartOfs, animInfoStartOfs); frameList = resourceData + animInfoStartOfs + frameListStartOfs; _frames.clear(); _frames.reserve(frameCount); for (uint16 frameIndex = 0; frameIndex < frameCount; frameIndex++) { AnimFrameInfo frameInfo; frameInfo.frameHash = READ_LE_UINT32(frameList); frameInfo.counter = READ_LE_UINT16(frameList + 4); frameInfo.drawOffset.x = READ_LE_UINT16(frameList + 6); frameInfo.drawOffset.y = READ_LE_UINT16(frameList + 8); frameInfo.drawOffset.width = READ_LE_UINT16(frameList + 10); frameInfo.drawOffset.height = READ_LE_UINT16(frameList + 12); frameInfo.deltaX = READ_LE_UINT16(frameList + 14); frameInfo.deltaY = READ_LE_UINT16(frameList + 16); frameInfo.collisionBoundsOffset.x = READ_LE_UINT16(frameList + 18); frameInfo.collisionBoundsOffset.y = READ_LE_UINT16(frameList + 20); frameInfo.collisionBoundsOffset.width = READ_LE_UINT16(frameList + 22); frameInfo.collisionBoundsOffset.height = READ_LE_UINT16(frameList + 24); frameInfo.spriteDataOffs = READ_LE_UINT32(frameList + 28); debug(8, "frameHash = %08X; counter = %d; rect = (%d,%d,%d,%d); deltaX = %d; deltaY = %d; collisionBoundsOffset = (%d,%d,%d,%d); spriteDataOffs = %08X", frameInfo.frameHash, frameInfo.counter, frameInfo.drawOffset.x, frameInfo.drawOffset.y, frameInfo.drawOffset.width, frameInfo.drawOffset.height, frameInfo.deltaX, frameInfo.deltaY, frameInfo.collisionBoundsOffset.x, frameInfo.collisionBoundsOffset.y, frameInfo.collisionBoundsOffset.width, frameInfo.collisionBoundsOffset.height, frameInfo.spriteDataOffs); frameList += 32; _frames.push_back(frameInfo); } _fileHash = fileHash; return true; } void AnimResource::unload() { _vm->_res->unloadResource(_resourceHandle); _currSpriteData = NULL; _fileHash = 0; _paletteData = NULL; _spriteData = NULL; _replEnabled = true; _replOldColor = 0; _replNewColor = 0; } int16 AnimResource::getFrameIndex(uint32 frameHash) { int16 frameIndex = -1; for (uint i = 0; i < _frames.size(); i++) if (_frames[i].frameHash == frameHash) { frameIndex = (int16)i; break; } debug(2, "AnimResource::getFrameIndex(%08X) -> %d", frameHash, frameIndex); return frameIndex; } void AnimResource::setRepl(byte oldColor, byte newColor) { _replOldColor = oldColor; _replNewColor = newColor; } NDimensions AnimResource::loadSpriteDimensions(uint32 fileHash) { ResourceHandle resourceHandle; NDimensions dimensions; _vm->_res->queryResource(fileHash, resourceHandle); const byte *resDimensions = resourceHandle.extData(); if (resDimensions) { dimensions.width = READ_LE_UINT16(resDimensions + 0); dimensions.height = READ_LE_UINT16(resDimensions + 2); } else { dimensions.width = 0; dimensions.height = 0; } return dimensions; } // MouseCursorResource MouseCursorResource::MouseCursorResource(NeverhoodEngine *vm) : _cursorSprite(vm), _cursorNum(4), _currFileHash(0) { _rect.width = 32; _rect.height = 32; } void MouseCursorResource::load(uint32 fileHash) { if (_currFileHash != fileHash) { if (_cursorSprite.load(fileHash) && !_cursorSprite.isRle() && _cursorSprite.getDimensions().width == 96 && _cursorSprite.getDimensions().height == 224) { _currFileHash = fileHash; } else { unload(); } } } void MouseCursorResource::unload() { _cursorSprite.unload(); _currFileHash = 0; _cursorNum = 4; } NDrawRect& MouseCursorResource::getRect() { static const NPoint kCursorHotSpots[] = { {-15, -5}, {-17, -25}, {-17, -30}, {-14, -1}, {-3, -7}, {-30, -18}, {-1, -18} }; _rect.x = kCursorHotSpots[_cursorNum].x; _rect.y = kCursorHotSpots[_cursorNum].y; return _rect; } void MouseCursorResource::draw(int frameNum, Graphics::Surface *destSurface) { if (_cursorSprite.getPixels()) { const int sourcePitch = (_cursorSprite.getDimensions().width + 3) & 0xFFFC; // 4 byte alignment const int destPitch = destSurface->pitch; const byte *source = _cursorSprite.getPixels() + _cursorNum * (sourcePitch * 32) + frameNum * 32; byte *dest = (byte*)destSurface->getPixels(); for (int16 yc = 0; yc < 32; yc++) { memcpy(dest, source, 32); source += sourcePitch; dest += destPitch; } } } // TextResource TextResource::TextResource(NeverhoodEngine *vm) : _vm(vm), _textData(NULL), _count(0) { } TextResource::~TextResource() { unload(); } void TextResource::load(uint32 fileHash) { debug(2, "TextResource::load(%08X)", fileHash); unload(); _vm->_res->queryResource(fileHash, _resourceHandle); if (_resourceHandle.isValid() && _resourceHandle.type() == kResTypeText) { _vm->_res->loadResource(_resourceHandle, _vm->applyResourceFixes()); _textData = _resourceHandle.data(); _count = READ_LE_UINT32(_textData); } } void TextResource::unload() { _vm->_res->unloadResource(_resourceHandle); _textData = NULL; _count = 0; } const char *TextResource::getString(uint index, const char *&textEnd) { const char *textStart = (const char*)(_textData + 4 + _count * 4 + READ_LE_UINT32(_textData + (index + 1) * 4)); textEnd = (const char*)(_textData + 4 + _count * 4 + READ_LE_UINT32(_textData + (index + 2) * 4)); return textStart; } // DataResource DataResource::DataResource(NeverhoodEngine *vm) : _vm(vm) { } DataResource::~DataResource() { unload(); } void DataResource::load(uint32 fileHash) { if (_resourceHandle.fileHash() == fileHash) return; const byte *data = NULL; uint32 dataSize = 0; unload(); _vm->_res->queryResource(fileHash, _resourceHandle); if (_resourceHandle.isValid() && _resourceHandle.type() == kResTypeData) { _vm->_res->loadResource(_resourceHandle, _vm->applyResourceFixes()); data = _resourceHandle.data(); dataSize = _resourceHandle.size(); } if (data && dataSize) { Common::MemoryReadStream dataS(data, dataSize); uint itemCount = dataS.readUint16LE(); uint32 itemStartOffs = 2 + itemCount * 8; debug(2, "itemCount = %d", itemCount); for (uint i = 0; i < itemCount; i++) { dataS.seek(2 + i * 8); DRDirectoryItem drDirectoryItem; drDirectoryItem.nameHash = dataS.readUint32LE(); drDirectoryItem.offset = dataS.readUint16LE(); drDirectoryItem.type = dataS.readUint16LE(); debug(2, "%03d nameHash = %08X; offset = %04X; type = %d", i, drDirectoryItem.nameHash, drDirectoryItem.offset, drDirectoryItem.type); dataS.seek(itemStartOffs + drDirectoryItem.offset); switch (drDirectoryItem.type) { case 1: { debug(3, "NPoint"); NPoint point; point.x = dataS.readUint16LE(); point.y = dataS.readUint16LE(); debug(3, "(%d, %d)", point.x, point.y); drDirectoryItem.offset = _points.size(); _points.push_back(point); break; } case 2: { uint count = dataS.readUint16LE(); NPointArray *pointArray = new NPointArray(); debug(3, "NPointArray; count = %d", count); for (uint j = 0; j < count; j++) { NPoint point; point.x = dataS.readUint16LE(); point.y = dataS.readUint16LE(); debug(3, "(%d, %d)", point.x, point.y); pointArray->push_back(point); } drDirectoryItem.offset = _pointArrays.size(); _pointArrays.push_back(pointArray); break; } case 3: { uint count = dataS.readUint16LE(); HitRectList *hitRectList = new HitRectList(); debug(3, "HitRectList; count = %d", count); for (uint j = 0; j < count; j++) { HitRect hitRect; hitRect.rect.x1 = dataS.readUint16LE(); hitRect.rect.y1 = dataS.readUint16LE(); hitRect.rect.x2 = dataS.readUint16LE(); hitRect.rect.y2 = dataS.readUint16LE(); hitRect.type = dataS.readUint16LE() + 0x5001; debug(3, "(%d, %d, %d, %d) -> %04d", hitRect.rect.x1, hitRect.rect.y1, hitRect.rect.x2, hitRect.rect.y2, hitRect.type); hitRectList->push_back(hitRect); } drDirectoryItem.offset = _hitRectLists.size(); _hitRectLists.push_back(hitRectList); break; } case 4: { uint count = dataS.readUint16LE(); MessageList *messageList = new MessageList(); debug(3, "MessageList; count = %d", count); for (uint j = 0; j < count; j++) { MessageItem messageItem; messageItem.messageNum = dataS.readUint32LE(); messageItem.messageValue = dataS.readUint32LE(); debug(3, "(%08X, %08X)", messageItem.messageNum, messageItem.messageValue); messageList->push_back(messageItem); } drDirectoryItem.offset = _messageLists.size(); _messageLists.push_back(messageList); break; } case 5: { uint count = dataS.readUint16LE(); DRSubRectList *drSubRectList = new DRSubRectList(); debug(3, "SubRectList; count = %d", count); for (uint j = 0; j < count; j++) { DRSubRect drSubRect; drSubRect.rect.x1 = dataS.readUint16LE(); drSubRect.rect.y1 = dataS.readUint16LE(); drSubRect.rect.x2 = dataS.readUint16LE(); drSubRect.rect.y2 = dataS.readUint16LE(); drSubRect.messageListHash = dataS.readUint32LE(); drSubRect.messageListItemIndex = dataS.readUint16LE(); debug(3, "(%d, %d, %d, %d) -> %08X (%d)", drSubRect.rect.x1, drSubRect.rect.y1, drSubRect.rect.x2, drSubRect.rect.y2, drSubRect.messageListHash, drSubRect.messageListItemIndex); drSubRectList->push_back(drSubRect); } drDirectoryItem.offset = _drSubRectLists.size(); _drSubRectLists.push_back(drSubRectList); break; } case 6: { DRRect drRect; drRect.rect.x1 = dataS.readUint16LE(); drRect.rect.y1 = dataS.readUint16LE(); drRect.rect.x2 = dataS.readUint16LE(); drRect.rect.y2 = dataS.readUint16LE(); drRect.subRectIndex = dataS.readUint16LE(); debug(3, "(%d, %d, %d, %d) -> %d", drRect.rect.x1, drRect.rect.y1, drRect.rect.x2, drRect.rect.y2, drRect.subRectIndex); drDirectoryItem.offset = _drRects.size(); _drRects.push_back(drRect); break; } case 7: { uint count = dataS.readUint16LE(); NRectArray *rectArray = new NRectArray(); debug(3, "NRectArray; count = %d", count); for (uint j = 0; j < count; j++) { NRect rect; rect.x1 = dataS.readUint16LE(); rect.y1 = dataS.readUint16LE(); rect.x2 = dataS.readUint16LE(); rect.y2 = dataS.readUint16LE(); debug(3, "(%d, %d, %d, %d)", rect.x1, rect.y1, rect.x2, rect.y2); rectArray->push_back(rect); } drDirectoryItem.offset = _rectArrays.size(); _rectArrays.push_back(rectArray); break; } } _directory.push_back(drDirectoryItem); } } } void DataResource::unload() { _directory.clear(); _points.clear(); for (Common::Array<NPointArray*>::iterator it = _pointArrays.begin(); it != _pointArrays.end(); ++it) delete (*it); _pointArrays.clear(); for (Common::Array<NRectArray*>::iterator it = _rectArrays.begin(); it != _rectArrays.end(); ++it) delete (*it); _rectArrays.clear(); for (Common::Array<HitRectList*>::iterator it = _hitRectLists.begin(); it != _hitRectLists.end(); ++it) delete (*it); _hitRectLists.clear(); for (Common::Array<MessageList*>::iterator it = _messageLists.begin(); it != _messageLists.end(); ++it) delete (*it); _messageLists.clear(); _drRects.clear(); for (Common::Array<DRSubRectList*>::iterator it = _drSubRectLists.begin(); it != _drSubRectLists.end(); ++it) delete (*it); _drSubRectLists.clear(); _vm->_res->unloadResource(_resourceHandle); } NPoint DataResource::getPoint(uint32 nameHash) { DataResource::DRDirectoryItem *drDirectoryItem = findDRDirectoryItem(nameHash, 1); return drDirectoryItem ? _points[drDirectoryItem->offset] : NPoint(); } NPointArray *DataResource::getPointArray(uint32 nameHash) { DataResource::DRDirectoryItem *drDirectoryItem = findDRDirectoryItem(nameHash, 2); return drDirectoryItem ? _pointArrays[drDirectoryItem->offset] : NULL; } NRectArray *DataResource::getRectArray(uint32 nameHash) { DataResource::DRDirectoryItem *drDirectoryItem = findDRDirectoryItem(nameHash, 3); return drDirectoryItem ? _rectArrays[drDirectoryItem->offset] : NULL; } HitRectList *DataResource::getHitRectList() { DataResource::DRDirectoryItem *drDirectoryItem = findDRDirectoryItem(calcHash("HitArray"), 3); return drDirectoryItem ? _hitRectLists[drDirectoryItem->offset] : NULL; } MessageList *DataResource::getMessageListAtPos(int16 klaymenX, int16 klaymenY, int16 mouseX, int16 mouseY) { for (uint i = 0; i < _drRects.size(); i++) { if (klaymenX >= _drRects[i].rect.x1 && klaymenX <= _drRects[i].rect.x2 && klaymenY >= _drRects[i].rect.y1 && klaymenY <= _drRects[i].rect.y2) { DRSubRectList *drSubRectList = _drSubRectLists[_drRects[i].subRectIndex]; for (uint j = 0; j < drSubRectList->size(); j++) { DRSubRect &subRect = (*drSubRectList)[j]; if (mouseX >= subRect.rect.x1 && mouseX <= subRect.rect.x2 && mouseY >= subRect.rect.y1 && mouseY <= subRect.rect.y2) { return _messageLists[subRect.messageListItemIndex]; } } } } return NULL; } DataResource::DRDirectoryItem *DataResource::findDRDirectoryItem(uint32 nameHash, uint16 type) { for (Common::Array<DRDirectoryItem>::iterator it = _directory.begin(); it != _directory.end(); it++) if ((*it).nameHash == nameHash && (*it).type == type) return &(*it); return NULL; } uint32 calcHash(const char *value) { uint32 hash = 0, shiftValue = 0; while (*value != 0) { char ch = *value++; if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) { if (ch >= 'a' && ch <= 'z') ch -= 32; else if (ch >= '0' && ch <= '9') ch += 22; shiftValue += ch - 64; if (shiftValue >= 32) shiftValue -= 32; hash ^= 1 << shiftValue; } } return hash; } } // End of namespace Neverhood