diff options
23 files changed, 270 insertions, 600 deletions
diff --git a/engines/sword25/gfx/bitmap.cpp b/engines/sword25/gfx/bitmap.cpp index db48b2d6fa..b5412c8276 100644 --- a/engines/sword25/gfx/bitmap.cpp +++ b/engines/sword25/gfx/bitmap.cpp @@ -32,26 +32,14 @@ * */ -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/gfx/bitmap.h" #include "sword25/kernel/outputpersistenceblock.h" #include "sword25/kernel/inputpersistenceblock.h" namespace Sword25 { -// ----------------------------------------------------------------------------- -// Logging -// ----------------------------------------------------------------------------- - #define BS_LOG_PREFIX "BITMAP" -// ----------------------------------------------------------------------------- -// Konstruktion / Destruktion -// ----------------------------------------------------------------------------- - Bitmap::Bitmap(RenderObjectPtr<RenderObject> parentPtr, TYPES type, uint handle) : RenderObject(parentPtr, type, handle), _modulationColor(0xffffffff), @@ -61,15 +49,9 @@ Bitmap::Bitmap(RenderObjectPtr<RenderObject> parentPtr, TYPES type, uint handle) _flipV(false) { } -// ----------------------------------------------------------------------------- - Bitmap::~Bitmap() { } -// ----------------------------------------------------------------------------- -// Darstellungsart festlegen -// ----------------------------------------------------------------------------- - void Bitmap::setAlpha(int alpha) { if (!isAlphaAllowed()) { BS_LOG_WARNINGLN("Tried to set alpha value on a bitmap that does not support alpha blending. Call was ignored."); @@ -94,8 +76,6 @@ void Bitmap::setAlpha(int alpha) { } } -// ----------------------------------------------------------------------------- - void Bitmap::setModulationColor(uint modulationColor) { if (!isColorModulationAllowed()) { BS_LOG_WARNINGLN("Tried to set modulation color of a bitmap that does not support color modulation. Call was ignored."); @@ -109,15 +89,11 @@ void Bitmap::setModulationColor(uint modulationColor) { } } -// ----------------------------------------------------------------------------- - void Bitmap::setScaleFactor(float scaleFactor) { setScaleFactorX(scaleFactor); setScaleFactorY(scaleFactor); } -// ----------------------------------------------------------------------------- - void Bitmap::setScaleFactorX(float scaleFactorX) { if (!isScalingAllowed()) { BS_LOG_WARNINGLN("Tried to set scale factor of a bitmap that does not support scaling. Call was ignored."); @@ -140,8 +116,6 @@ void Bitmap::setScaleFactorX(float scaleFactorX) { } } -// ----------------------------------------------------------------------------- - void Bitmap::setScaleFactorY(float scaleFactorY) { if (!isScalingAllowed()) { BS_LOG_WARNINGLN("Tried to set scale factor of a bitmap that does not support scaling. Call was ignored."); @@ -164,24 +138,16 @@ void Bitmap::setScaleFactorY(float scaleFactorY) { } } -// ----------------------------------------------------------------------------- - void Bitmap::setFlipH(bool flipH) { _flipH = flipH; forceRefresh(); } -// ----------------------------------------------------------------------------- - void Bitmap::setFlipV(bool flipV) { _flipV = flipV; forceRefresh(); } -// ----------------------------------------------------------------------------- -// Persistenz -// ----------------------------------------------------------------------------- - bool Bitmap::persist(OutputPersistenceBlock &writer) { bool result = true; @@ -197,8 +163,6 @@ bool Bitmap::persist(OutputPersistenceBlock &writer) { return result; } -// ----------------------------------------------------------------------------- - bool Bitmap::unpersist(InputPersistenceBlock &reader) { bool result = true; diff --git a/engines/sword25/gfx/bitmap.h b/engines/sword25/gfx/bitmap.h index a00baf37a4..741269c423 100644 --- a/engines/sword25/gfx/bitmap.h +++ b/engines/sword25/gfx/bitmap.h @@ -35,19 +35,11 @@ #ifndef SWORD25_BITMAP_H #define SWORD25_BITMAP_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "sword25/gfx/renderobject.h" namespace Sword25 { -// ----------------------------------------------------------------------------- -// Klassendeklaration -// ----------------------------------------------------------------------------- - class Bitmap : public RenderObject { protected: Bitmap(RenderObjectPtr<RenderObject> parentPtr, TYPES type, uint handle = 0); diff --git a/engines/sword25/gfx/bitmapresource.cpp b/engines/sword25/gfx/bitmapresource.cpp index 46e6ca77ce..1dde736621 100644 --- a/engines/sword25/gfx/bitmapresource.cpp +++ b/engines/sword25/gfx/bitmapresource.cpp @@ -42,9 +42,6 @@ namespace Sword25 { #define BS_LOG_PREFIX "BITMAP" -// Konstruktion / Destruktion -// -------------------------- - BitmapResource::BitmapResource(const Common::String &filename, Image *pImage) : _valid(false), _pImage(pImage), @@ -56,8 +53,6 @@ BitmapResource::~BitmapResource() { delete _pImage; } -// ----------------------------------------------------------------------------- - uint BitmapResource::getPixel(int x, int y) const { BS_ASSERT(x >= 0 && x < _pImage->getWidth()); BS_ASSERT(y >= 0 && y < _pImage->getHeight()); diff --git a/engines/sword25/gfx/bitmapresource.h b/engines/sword25/gfx/bitmapresource.h index 1054770e79..37849f918e 100644 --- a/engines/sword25/gfx/bitmapresource.h +++ b/engines/sword25/gfx/bitmapresource.h @@ -35,7 +35,6 @@ #ifndef SWORD25_BITMAP_RESOURCE_H #define SWORD25_BITMAP_RESOURCE_H -// Includes #include "sword25/kernel/common.h" #include "sword25/kernel/resource.h" #include "sword25/gfx/image/image.h" @@ -204,8 +203,8 @@ public: } private: - Image *_pImage; - bool _valid; + Image *_pImage; + bool _valid; }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/dynamicbitmap.cpp b/engines/sword25/gfx/dynamicbitmap.cpp index 47ff68b932..2766294d48 100644 --- a/engines/sword25/gfx/dynamicbitmap.cpp +++ b/engines/sword25/gfx/dynamicbitmap.cpp @@ -32,10 +32,6 @@ * */ -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/gfx/dynamicbitmap.h" #include "sword25/gfx/bitmapresource.h" #include "sword25/package/packagemanager.h" @@ -43,16 +39,8 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Logging -// ----------------------------------------------------------------------------- - #define BS_LOG_PREFIX "DYNAMICBITMAP" -// ----------------------------------------------------------------------------- -// Konstruktion / Destruktion -// ----------------------------------------------------------------------------- - DynamicBitmap::DynamicBitmap(RenderObjectPtr<RenderObject> parentPtr, uint width, uint height) : Bitmap(parentPtr, TYPE_DYNAMICBITMAP) { // Das BS_Bitmap konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. @@ -61,15 +49,11 @@ DynamicBitmap::DynamicBitmap(RenderObjectPtr<RenderObject> parentPtr, uint width _initSuccess = createRenderedImage(width, height); } -// ----------------------------------------------------------------------------- - DynamicBitmap::DynamicBitmap(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPtr, uint handle) : Bitmap(parentPtr, TYPE_DYNAMICBITMAP, handle) { _initSuccess = unpersist(reader); } -// ----------------------------------------------------------------------------- - bool DynamicBitmap::createRenderedImage(uint width, uint height) { // RenderedImage mit den gewünschten Maßen erstellen bool result = false; @@ -81,13 +65,9 @@ bool DynamicBitmap::createRenderedImage(uint width, uint height) { return result; } -// ----------------------------------------------------------------------------- - DynamicBitmap::~DynamicBitmap() { } -// ----------------------------------------------------------------------------- - uint DynamicBitmap::getPixel(int x, int y) const { BS_ASSERT(x >= 0 && x < _width); BS_ASSERT(y >= 0 && y < _height); @@ -95,8 +75,6 @@ uint DynamicBitmap::getPixel(int x, int y) const { return _image->getPixel(x, y); } -// ----------------------------------------------------------------------------- - bool DynamicBitmap::doRender() { // Framebufferobjekt holen GraphicEngine *pGfx = Kernel::GetInstance()->GetGfx(); @@ -119,42 +97,26 @@ bool DynamicBitmap::doRender() { return result; } -// ----------------------------------------------------------------------------- - bool DynamicBitmap::setContent(const byte *pixeldata, uint size, uint offset, uint stride) { return _image->setContent(pixeldata, size, offset, stride); } -// ----------------------------------------------------------------------------- -// Auskunftsmethoden -// ----------------------------------------------------------------------------- - bool DynamicBitmap::isScalingAllowed() const { return _image->isScalingAllowed(); } -// ----------------------------------------------------------------------------- - bool DynamicBitmap::isAlphaAllowed() const { return _image->isAlphaAllowed(); } -// ----------------------------------------------------------------------------- - bool DynamicBitmap::isColorModulationAllowed() const { return _image->isColorModulationAllowed(); } -// ----------------------------------------------------------------------------- - bool DynamicBitmap::isSetContentAllowed() const { return true; } -// ----------------------------------------------------------------------------- -// Persistenz -// ----------------------------------------------------------------------------- - bool DynamicBitmap::persist(OutputPersistenceBlock &writer) { bool result = true; diff --git a/engines/sword25/gfx/dynamicbitmap.h b/engines/sword25/gfx/dynamicbitmap.h index a02769fb57..1737bdf5fc 100644 --- a/engines/sword25/gfx/dynamicbitmap.h +++ b/engines/sword25/gfx/dynamicbitmap.h @@ -35,11 +35,6 @@ #ifndef SWORD25_DYNAMIC_BITMAP_H #define SWORD25_DYNAMIC_BITMAP_H - -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "sword25/gfx/bitmap.h" #include "sword25/gfx/image/renderedimage.h" @@ -48,10 +43,6 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Klassendeklaration -// ----------------------------------------------------------------------------- - class DynamicBitmap : public Bitmap { friend class RenderObject; @@ -60,18 +51,18 @@ public: virtual uint getPixel(int x, int y) const; - virtual bool setContent(const byte *pixeldata, uint size, uint offset, uint stride); + virtual bool setContent(const byte *pixeldata, uint size, uint offset, uint stride); - virtual bool isScalingAllowed() const; - virtual bool isAlphaAllowed() const; - virtual bool isColorModulationAllowed() const; - virtual bool isSetContentAllowed() const; + virtual bool isScalingAllowed() const; + virtual bool isAlphaAllowed() const; + virtual bool isColorModulationAllowed() const; + virtual bool isSetContentAllowed() const; - virtual bool persist(OutputPersistenceBlock &writer); - virtual bool unpersist(InputPersistenceBlock &reader); + virtual bool persist(OutputPersistenceBlock &writer); + virtual bool unpersist(InputPersistenceBlock &reader); protected: - virtual bool doRender(); + virtual bool doRender(); private: DynamicBitmap(RenderObjectPtr<RenderObject> parentPtr, uint width, uint height); diff --git a/engines/sword25/gfx/fontresource.cpp b/engines/sword25/gfx/fontresource.cpp index cdece041db..45acb9f045 100644 --- a/engines/sword25/gfx/fontresource.cpp +++ b/engines/sword25/gfx/fontresource.cpp @@ -34,10 +34,6 @@ #define BS_LOG_PREFIX "FONTRESOURCE" -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/kernel.h" #include "sword25/kernel/string.h" #include "sword25/package/packagemanager.h" @@ -46,23 +42,15 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Constants -// ----------------------------------------------------------------------------- - enum { DEFAULT_LINEHEIGHT = 20, DEFAULT_GAPWIDTH = 1 }; -// ----------------------------------------------------------------------------- -// Constructor / destructor -// ----------------------------------------------------------------------------- - -FontResource::FontResource(Kernel *pKernel, const Common::String &FileName) : +FontResource::FontResource(Kernel *pKernel, const Common::String &fileName) : _pKernel(pKernel), - _Valid(false), - Resource(FileName, Resource::TYPE_FONT), + _valid(false), + Resource(fileName, Resource::TYPE_FONT), Common::XMLParser() { // Get a pointer to the package manager @@ -82,27 +70,25 @@ FontResource::FontResource(Kernel *pKernel, const Common::String &FileName) : if (!loadBuffer((const byte *)xmlData, fileSize)) return; - _Valid = parse(); + _valid = parse(); close(); free(xmlData); } -// ----------------------------------------------------------------------------- - bool FontResource::parserCallback_font(ParserNode *node) { // Get the attributes of the font Common::String bitmapFilename = node->values["bitmap"]; - if (!parseIntegerKey(node->values["lineheight"], 1, &_LineHeight)) { + if (!parseIntegerKey(node->values["lineheight"], 1, &_lineHeight)) { BS_LOG_WARNINGLN("Illegal or missing lineheight attribute in <font> tag in \"%s\". Assuming default (\"%d\").", getFileName().c_str(), DEFAULT_LINEHEIGHT); - _LineHeight = DEFAULT_LINEHEIGHT; + _lineHeight = DEFAULT_LINEHEIGHT; } - if (!parseIntegerKey(node->values["gap"], 1, &_GapWidth)) { + if (!parseIntegerKey(node->values["gap"], 1, &_gapWidth)) { BS_LOG_WARNINGLN("Illegal or missing gap attribute in <font> tag in \"%s\". Assuming default (\"%d\").", getFileName().c_str(), DEFAULT_GAPWIDTH); - _GapWidth = DEFAULT_GAPWIDTH; + _gapWidth = DEFAULT_GAPWIDTH; } // Get a reference to the package manager @@ -111,22 +97,20 @@ bool FontResource::parserCallback_font(ParserNode *node) { BS_ASSERT(pPackage); // Get the full path and filename for the bitmap resource - _BitmapFileName = pPackage->getAbsolutePath(bitmapFilename); - if (_BitmapFileName == "") { + _bitmapFileName = pPackage->getAbsolutePath(bitmapFilename); + if (_bitmapFileName == "") { BS_LOG_ERRORLN("Image file \"%s\" was specified in <font> tag of \"%s\" but could not be found.", - _BitmapFileName.c_str(), getFileName().c_str()); + _bitmapFileName.c_str(), getFileName().c_str()); } // Pre-cache the resource - if (!_pKernel->GetResourceManager()->PrecacheResource(_BitmapFileName)) { - BS_LOG_ERRORLN("Could not precache \"%s\".", _BitmapFileName.c_str()); + if (!_pKernel->GetResourceManager()->PrecacheResource(_bitmapFileName)) { + BS_LOG_ERRORLN("Could not precache \"%s\".", _bitmapFileName.c_str()); } return true; } -// ----------------------------------------------------------------------------- - bool FontResource::parserCallback_character(ParserNode *node) { // Get the attributes of the character int charCode, top, left, right, bottom; @@ -148,7 +132,7 @@ bool FontResource::parserCallback_character(ParserNode *node) { return parserError("Illegal or missing bottom attribute in <character> tag in \"%s\".", getFileName().c_str()); } - this->_CharacterRects[charCode] = Common::Rect(left, top, right, bottom); + this->_characterRects[charCode] = Common::Rect(left, top, right, bottom); return true; } diff --git a/engines/sword25/gfx/fontresource.h b/engines/sword25/gfx/fontresource.h index 7ae2cd2c6b..19c44d0ade 100644 --- a/engines/sword25/gfx/fontresource.h +++ b/engines/sword25/gfx/fontresource.h @@ -35,10 +35,6 @@ #ifndef SWORD25_FONTRESOURCE_H #define SWORD25_FONTRESOURCE_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "common/scummsys.h" #include "common/rect.h" #include "common/xmlparser.h" @@ -47,16 +43,8 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Forward declarations -// ----------------------------------------------------------------------------- - class Kernel; -// ----------------------------------------------------------------------------- -// Class definition -// ----------------------------------------------------------------------------- - class FontResource : public Resource, Common::XMLParser { public: /** @@ -65,15 +53,15 @@ public: @param FileName der Dateiname der zu ladenen Resource @remark Wenn der Konstruktor erfolgreich ausgeführt werden konnte gibt die Methode IsValid true zurück. */ - FontResource(Kernel *pKernel, const Common::String &FileName); + FontResource(Kernel *pKernel, const Common::String &fileName); /** @brief Gibt true zurück, wenn das Objekt korrekt initialisiert wurde. Diese Methode kann dazu benutzt werden um festzustellen, ob der Konstruktor erfolgreich ausgeführt wurde. */ - bool IsValid() const { - return _Valid; + bool isValid() const { + return _valid; } /** @@ -81,8 +69,8 @@ public: Die Zeilenhöhe ist der Wert, der zur Y-Koordinate addiert wird, wenn ein Zeilenumbruch auftritt. */ - int GetLineHeight() const { - return _LineHeight; + int getLineHeight() const { + return _lineHeight; } /** @@ -90,8 +78,8 @@ public: Der Buchstabenabstand ist der Wert, der zwischen zwei Buchstaben freigelassen wird. */ - int GetGapWidth() const { - return _GapWidth; + int getGapWidth() const { + return _gapWidth; } /** @@ -99,25 +87,25 @@ public: @param Character der ASCII-Code des Zeichens @return Das Bounding-Rect des übergebenen Zeichens auf der Charactermap. */ - const Common::Rect &GetCharacterRect(int Character) const { - BS_ASSERT(Character >= 0 && Character < 256); - return _CharacterRects[Character]; + const Common::Rect &getCharacterRect(int character) const { + BS_ASSERT(character >= 0 && character < 256); + return _characterRects[character]; } /** @brief Gibt den Dateinamen der Charactermap zurück. */ - const Common::String &GetCharactermapFileName() const { - return _BitmapFileName; + const Common::String &getCharactermapFileName() const { + return _bitmapFileName; } private: Kernel *_pKernel; - bool _Valid; - Common::String _BitmapFileName; - int _LineHeight; - int _GapWidth; - Common::Rect _CharacterRects[256]; + bool _valid; + Common::String _bitmapFileName; + int _lineHeight; + int _gapWidth; + Common::Rect _characterRects[256]; // Parser CUSTOM_XML_PARSER(FontResource) { diff --git a/engines/sword25/gfx/graphicengine.cpp b/engines/sword25/gfx/graphicengine.cpp index 0a8638a5ec..e16876ddba 100644 --- a/engines/sword25/gfx/graphicengine.cpp +++ b/engines/sword25/gfx/graphicengine.cpp @@ -350,7 +350,7 @@ Resource *GraphicEngine::loadResource(const Common::String &filename) { // Load font if (filename.hasSuffix("_fnt.xml")) { FontResource *pResource = new FontResource(Kernel::GetInstance(), filename); - if (pResource->IsValid()) + if (pResource->isValid()) return pResource; else { delete pResource; @@ -418,7 +418,7 @@ bool doSaveScreenshot(GraphicEngine &graphicEngine, const Common::String &filena return false; } - bool result = Screenshot::SaveToFile(data, stream); + bool result = Screenshot::saveToFile(data, stream); delete stream; return result; diff --git a/engines/sword25/gfx/graphicengine_script.cpp b/engines/sword25/gfx/graphicengine_script.cpp index e197a40337..97359252db 100644 --- a/engines/sword25/gfx/graphicengine_script.cpp +++ b/engines/sword25/gfx/graphicengine_script.cpp @@ -1162,14 +1162,14 @@ static RenderObjectPtr<Text> checkText(lua_State *L) { static int t_setFont(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - textPtr->SetFont(luaL_checkstring(L, 2)); + textPtr->setFont(luaL_checkstring(L, 2)); return 0; } static int t_setText(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - textPtr->SetText(luaL_checkstring(L, 2)); + textPtr->setText(luaL_checkstring(L, 2)); return 0; } @@ -1190,28 +1190,28 @@ static int t_setColor(lua_State *L) { static int t_setAutoWrap(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - textPtr->SetAutoWrap(lua_tobooleancpp(L, 2)); + textPtr->setAutoWrap(lua_tobooleancpp(L, 2)); return 0; } static int t_setAutoWrapThreshold(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - textPtr->SetAutoWrapThreshold(static_cast<uint>(luaL_checknumber(L, 2))); + textPtr->setAutoWrapThreshold(static_cast<uint>(luaL_checknumber(L, 2))); return 0; } static int t_getText(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - lua_pushstring(L, textPtr->GetText().c_str()); + lua_pushstring(L, textPtr->getText().c_str()); return 1; } static int t_getFont(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - lua_pushstring(L, textPtr->GetFont().c_str()); + lua_pushstring(L, textPtr->getFont().c_str()); return 1; } @@ -1232,14 +1232,14 @@ static int t_getColor(lua_State *L) { static int t_isAutoWrap(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - lua_pushbooleancpp(L, textPtr->IsAutoWrapActive()); + lua_pushbooleancpp(L, textPtr->isAutoWrapActive()); return 1; } static int t_getAutoWrapThreshold(lua_State *L) { RenderObjectPtr<Text> textPtr = checkText(L); BS_ASSERT(textPtr.isValid()); - lua_pushnumber(L, textPtr->GetAutoWrapThreshold()); + lua_pushnumber(L, textPtr->getAutoWrapThreshold()); return 1; } diff --git a/engines/sword25/gfx/panel.cpp b/engines/sword25/gfx/panel.cpp index 888f6f7468..1e2921fd56 100644 --- a/engines/sword25/gfx/panel.cpp +++ b/engines/sword25/gfx/panel.cpp @@ -32,10 +32,6 @@ * */ -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/gfx/panel.h" #include "sword25/kernel/inputpersistenceblock.h" @@ -45,14 +41,8 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- - #define BS_LOG_PREFIX "PANEL" -// ----------------------------------------------------------------------------- -// Construction/Destruction -// ----------------------------------------------------------------------------- - Panel::Panel(RenderObjectPtr<RenderObject> parentPtr, int width, int height, uint color) : RenderObject(parentPtr, RenderObject::TYPE_PANEL), _color(color) { @@ -74,22 +64,14 @@ Panel::Panel(RenderObjectPtr<RenderObject> parentPtr, int width, int height, uin _initSuccess = true; } -// ----------------------------------------------------------------------------- - Panel::Panel(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPtr, uint handle) : RenderObject(parentPtr, RenderObject::TYPE_PANEL, handle) { _initSuccess = unpersist(reader); } -// ----------------------------------------------------------------------------- - Panel::~Panel() { } -// ----------------------------------------------------------------------------- -// Rendern -// ----------------------------------------------------------------------------- - bool Panel::doRender() { // Falls der Alphawert 0 ist, ist das Panel komplett durchsichtig und es muss nichts gezeichnet werden. if (_color >> 24 == 0) @@ -101,10 +83,6 @@ bool Panel::doRender() { return gfxPtr->fill(&_bbox, _color); } -// ----------------------------------------------------------------------------- -// Persistenz -// ----------------------------------------------------------------------------- - bool Panel::persist(OutputPersistenceBlock &writer) { bool result = true; @@ -116,8 +94,6 @@ bool Panel::persist(OutputPersistenceBlock &writer) { return result; } -// ----------------------------------------------------------------------------- - bool Panel::unpersist(InputPersistenceBlock &reader) { bool result = true; diff --git a/engines/sword25/gfx/panel.h b/engines/sword25/gfx/panel.h index 5fbcec5f34..6fe96369a6 100644 --- a/engines/sword25/gfx/panel.h +++ b/engines/sword25/gfx/panel.h @@ -35,19 +35,11 @@ #ifndef SWORD25_PANEL_H #define SWORD25_PANEL_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "sword25/gfx/renderobject.h" namespace Sword25 { -// ----------------------------------------------------------------------------- -// Class Definition -// ----------------------------------------------------------------------------- - class Panel : public RenderObject { friend class RenderObject; @@ -58,10 +50,10 @@ private: public: virtual ~Panel(); - uint getColor() const { + uint getColor() const { return _color; } - void setColor(uint color) { + void setColor(uint color) { _color = color; forceRefresh(); } diff --git a/engines/sword25/gfx/renderobject.cpp b/engines/sword25/gfx/renderobject.cpp index ae8fc8cba1..77af0bee92 100644 --- a/engines/sword25/gfx/renderobject.cpp +++ b/engines/sword25/gfx/renderobject.cpp @@ -53,8 +53,6 @@ namespace Sword25 { #define BS_LOG_PREFIX "RENDEROBJECT" -// Konstruktion / Destruktion -// -------------------------- RenderObject::RenderObject(RenderObjectPtr<RenderObject> parentPtr, TYPES type, uint handle) : _managerPtr(0), _parentPtr(parentPtr), @@ -113,8 +111,6 @@ RenderObject::~RenderObject() { RenderObjectRegistry::instance().deregisterObject(this); } -// Rendern -// ------- bool RenderObject::render() { // Objektänderungen validieren validateObject(); @@ -141,9 +137,6 @@ bool RenderObject::render() { return true; } -// Objektverwaltung -// ---------------- - void RenderObject::validateObject() { // Die Veränderungen in den Objektvariablen aufheben _oldBbox = _bbox; @@ -222,9 +215,6 @@ int RenderObject::calcAbsoluteY() const { return _y; } -// Baumverwaltung -// -------------- - void RenderObject::deleteAllChildren() { // Es ist nicht notwendig die Liste zu iterieren, da jedes Kind für sich DetatchChildren an diesem Objekt aufruft und sich somit // selber entfernt. Daher muss immer nur ein beliebiges Element (hier das letzte) gelöscht werden, bis die Liste leer ist. @@ -275,17 +265,12 @@ void RenderObject::updateAbsolutePos() { (*it)->updateAbsolutePos(); } -// Get-Methoden -// ------------ - bool RenderObject::getObjectIntersection(RenderObjectPtr<RenderObject> pObject, Common::Rect &result) { result = pObject->getBbox(); result.clip(_bbox); return result.isValidRect(); } -// Set-Methoden -// ------------ void RenderObject::setPos(int x, int y) { _x = x; _y = y; @@ -313,10 +298,6 @@ void RenderObject::setVisible(bool visible) { _visible = visible; } -// ----------------------------------------------------------------------------- -// Objekterzeuger -// ----------------------------------------------------------------------------- - RenderObjectPtr<Animation> RenderObject::addAnimation(const Common::String &filename) { RenderObjectPtr<Animation> aniPtr((new Animation(this->getHandle(), filename))->getHandle()); if (aniPtr.isValid() && aniPtr->getInitSuccess()) @@ -328,9 +309,6 @@ RenderObjectPtr<Animation> RenderObject::addAnimation(const Common::String &file } } - -// ----------------------------------------------------------------------------- - RenderObjectPtr<Animation> RenderObject::addAnimation(const AnimationTemplate &animationTemplate) { Animation *aniPtr = new Animation(this->getHandle(), animationTemplate); if (aniPtr && aniPtr->getInitSuccess()) @@ -341,8 +319,6 @@ RenderObjectPtr<Animation> RenderObject::addAnimation(const AnimationTemplate &a } } -// ----------------------------------------------------------------------------- - RenderObjectPtr<Bitmap> RenderObject::addBitmap(const Common::String &filename) { RenderObjectPtr<Bitmap> bitmapPtr((new StaticBitmap(this->getHandle(), filename))->getHandle()); if (bitmapPtr.isValid() && bitmapPtr->getInitSuccess()) @@ -354,8 +330,6 @@ RenderObjectPtr<Bitmap> RenderObject::addBitmap(const Common::String &filename) } } -// ----------------------------------------------------------------------------- - RenderObjectPtr<Bitmap> RenderObject::addDynamicBitmap(uint width, uint height) { RenderObjectPtr<Bitmap> bitmapPtr((new DynamicBitmap(this->getHandle(), width, height))->getHandle()); if (bitmapPtr.isValid() && bitmapPtr->getInitSuccess()) @@ -367,8 +341,6 @@ RenderObjectPtr<Bitmap> RenderObject::addDynamicBitmap(uint width, uint height) } } -// ----------------------------------------------------------------------------- - RenderObjectPtr<Panel> RenderObject::addPanel(int width, int height, uint color) { RenderObjectPtr<Panel> panelPtr((new Panel(this->getHandle(), width, height, color))->getHandle()); if (panelPtr.isValid() && panelPtr->getInitSuccess()) @@ -380,12 +352,10 @@ RenderObjectPtr<Panel> RenderObject::addPanel(int width, int height, uint color) } } -// ----------------------------------------------------------------------------- - RenderObjectPtr<Text> RenderObject::addText(const Common::String &font, const Common::String &text) { RenderObjectPtr<Text> textPtr((new Text(this->getHandle()))->getHandle()); - if (textPtr.isValid() && textPtr->getInitSuccess() && textPtr->SetFont(font)) { - textPtr->SetText(text); + if (textPtr.isValid() && textPtr->getInitSuccess() && textPtr->setFont(font)) { + textPtr->setText(text); return textPtr; } else { if (textPtr.isValid()) @@ -394,9 +364,6 @@ RenderObjectPtr<Text> RenderObject::addText(const Common::String &font, const Co } } -// Persistenz-Methoden -// ------------------- - bool RenderObject::persist(OutputPersistenceBlock &writer) { // Typ und Handle werden als erstes gespeichert, damit beim Laden ein Objekt vom richtigen Typ mit dem richtigen Handle erzeugt werden kann. writer.write(static_cast<uint>(_type)); @@ -431,8 +398,6 @@ bool RenderObject::persist(OutputPersistenceBlock &writer) { return true; } -// ----------------------------------------------------------------------------- - bool RenderObject::unpersist(InputPersistenceBlock &reader) { // Typ und Handle wurden schon von RecreatePersistedRenderObject() ausgelesen. Jetzt werden die restlichen Objekteigenschaften ausgelesen. reader.read(_x); @@ -468,8 +433,6 @@ bool RenderObject::unpersist(InputPersistenceBlock &reader) { return reader.isGood(); } -// ----------------------------------------------------------------------------- - bool RenderObject::persistChildren(OutputPersistenceBlock &writer) { bool result = true; @@ -486,8 +449,6 @@ bool RenderObject::persistChildren(OutputPersistenceBlock &writer) { return result; } -// ----------------------------------------------------------------------------- - bool RenderObject::unpersistChildren(InputPersistenceBlock &reader) { bool result = true; @@ -506,8 +467,6 @@ bool RenderObject::unpersistChildren(InputPersistenceBlock &reader) { return result && reader.isGood(); } -// ----------------------------------------------------------------------------- - RenderObjectPtr<RenderObject> RenderObject::recreatePersistedRenderObject(InputPersistenceBlock &reader) { RenderObjectPtr<RenderObject> result; @@ -547,8 +506,6 @@ RenderObjectPtr<RenderObject> RenderObject::recreatePersistedRenderObject(InputP return result; } -// Hilfs-Methoden -// -------------- bool RenderObject::greater(const RenderObjectPtr<RenderObject> lhs, const RenderObjectPtr<RenderObject> rhs) { // Das Objekt mit dem kleinem Z-Wert müssen zuerst gerendert werden. if (lhs->_z != rhs->_z) diff --git a/engines/sword25/gfx/renderobject.h b/engines/sword25/gfx/renderobject.h index 9d11c46b80..7b7b9047f7 100644 --- a/engines/sword25/gfx/renderobject.h +++ b/engines/sword25/gfx/renderobject.h @@ -45,7 +45,6 @@ #ifndef SWORD25_RENDEROBJECT_H #define SWORD25_RENDEROBJECT_H -// Includes #include "sword25/kernel/common.h" #include "sword25/kernel/persistable.h" #include "common/rect.h" @@ -55,10 +54,6 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Forward Declarations -// ----------------------------------------------------------------------------- - class Kernel; class RenderObjectManager; class Bitmap; @@ -462,11 +457,11 @@ private: @param pObject ein Pointer auf das zu entfernende Objekt @return Gibt false zurück, falls das zu entfernende Objekt nicht in der Liste gefunden werden konnte. */ - bool detatchChildren(RenderObjectPtr<RenderObject> pObject); + bool detatchChildren(RenderObjectPtr<RenderObject> pObject); /** @brief Berechnet die Bounding-Box und registriert das Dirty-Rect beim BS_RenderObjectManager. */ - void updateBoxes(); + void updateBoxes(); /** @brief Berechnet die Bounding-Box des Objektes. @return Gibt die Bounding-Box des Objektes in Bildschirmkoordinaten zurück. @@ -496,7 +491,7 @@ private: /** @brief Validiert den Zustand eines Objektes nachdem die durch die Veränderung verursachten Folgen abgearbeitet wurden. */ - void validateObject(); + void validateObject(); /** @brief Berechnet die absolute Position des Objektes und aller seiner Kinderobjekte neu. @@ -508,7 +503,7 @@ private: @brief Teilt dem Objekt mit, dass sich eines seiner Kinderobjekte dahingehend verändert hat, die eine erneute Bestimmung der Rendereihenfolge verlangt. */ - void signalChildChange() { + void signalChildChange() { _childChanged = true; } /** @@ -517,7 +512,7 @@ private: @param Result das Ergebnisrechteck @return Gibt false zurück, falls sich die Objekte gar nicht schneiden. */ - bool getObjectIntersection(RenderObjectPtr<RenderObject> pObject, Common::Rect &result); + bool getObjectIntersection(RenderObjectPtr<RenderObject> pObject, Common::Rect &result); /** @brief Vergleichsoperator der auf Objektpointern basiert statt auf Objekten. @remark Diese Methode wird fürs Sortieren der Kinderliste nach der Rendereihenfolge benutzt. diff --git a/engines/sword25/gfx/renderobjectmanager.h b/engines/sword25/gfx/renderobjectmanager.h index 05bba37cd0..8511382d6e 100644 --- a/engines/sword25/gfx/renderobjectmanager.h +++ b/engines/sword25/gfx/renderobjectmanager.h @@ -45,7 +45,6 @@ #ifndef SWORD25_RENDEROBJECTMANAGER_H #define SWORD25_RENDEROBJECTMANAGER_H -// Includes #include "common/rect.h" #include "sword25/kernel/common.h" #include "sword25/gfx/renderobjectptr.h" @@ -53,7 +52,6 @@ namespace Sword25 { -// Klassendefinition class Kernel; class RenderObject; class TimedRenderObject; diff --git a/engines/sword25/gfx/renderobjectregistry.h b/engines/sword25/gfx/renderobjectregistry.h index ff5d8997ec..357d041068 100644 --- a/engines/sword25/gfx/renderobjectregistry.h +++ b/engines/sword25/gfx/renderobjectregistry.h @@ -35,10 +35,6 @@ #ifndef SWORD25_RENDEROBJECTREGISTRY_H #define SWORD25_RENDEROBJECTREGISTRY_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "sword25/kernel/objectregistry.h" @@ -46,16 +42,8 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Forward Deklarationen -// ----------------------------------------------------------------------------- - class RenderObject; -// ----------------------------------------------------------------------------- -// Klassendeklaration -// ----------------------------------------------------------------------------- - class RenderObjectRegistry : public ObjectRegistry<RenderObject>, public Common::Singleton<RenderObjectRegistry> { diff --git a/engines/sword25/gfx/screenshot.cpp b/engines/sword25/gfx/screenshot.cpp index 941efbdf3c..74174cbcd9 100644 --- a/engines/sword25/gfx/screenshot.cpp +++ b/engines/sword25/gfx/screenshot.cpp @@ -34,10 +34,6 @@ #define BS_LOG_PREFIX "SCREENSHOT" -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "common/system.h" #include "common/savefile.h" #include "sword25/gfx/screenshot.h" @@ -46,13 +42,11 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- - #include "common/pack-start.h" struct RGB_PIXEL { - byte Red; - byte Green; - byte Blue; + byte red; + byte green; + byte blue; } PACKED_STRUCT; #include "common/pack-end.h" @@ -63,22 +57,21 @@ void userWriteFn(png_structp png_ptr, png_bytep data, png_size_t length) { void userFlushFn(png_structp png_ptr) { } - -bool Screenshot::SaveToFile(Graphics::Surface *Data, Common::WriteStream *Stream) { +bool Screenshot::saveToFile(Graphics::Surface *data, Common::WriteStream *stream) { // Reserve buffer space - RGB_PIXEL *pixelBuffer = new RGB_PIXEL[Data->w * Data->h]; + RGB_PIXEL *pixelBuffer = new RGB_PIXEL[data->w * data->h]; // Convert the RGBA data to RGB - const byte *pSrc = (const byte *)Data->getBasePtr(0, 0); + const byte *pSrc = (const byte *)data->getBasePtr(0, 0); RGB_PIXEL *pDest = pixelBuffer; - for (uint y = 0; y < Data->h; y++) { - for (uint x = 0; x < Data->w; x++) { + for (uint y = 0; y < data->h; y++) { + for (uint x = 0; x < data->w; x++) { uint32 srcPixel = READ_LE_UINT32(pSrc); pSrc += sizeof(uint32); - pDest->Red = (srcPixel >> 16) & 0xff; - pDest->Green = (srcPixel >> 8) & 0xff; - pDest->Blue = srcPixel & 0xff; + pDest->red = (srcPixel >> 16) & 0xff; + pDest->green = (srcPixel >> 8) & 0xff; + pDest->blue = srcPixel & 0xff; ++pDest; } } @@ -91,30 +84,30 @@ bool Screenshot::SaveToFile(Graphics::Surface *Data, Common::WriteStream *Stream if (!info_ptr) error("Could not create PNG info-struct."); - // The compression buffer must be large enough to the entire image. + // The compression buffer must be large enough to the entire image. // This ensures that only an IDAT chunk is created. // When buffer size is used 110% of the raw data size to be sure. - png_set_compression_buffer_size(png_ptr, (Data->w * Data->h * 3 * 110) / 100); + png_set_compression_buffer_size(png_ptr, (data->w * data->h * 3 * 110) / 100); // Initialise PNG-Info structure png_set_IHDR(png_ptr, info_ptr, - Data->w, // Width - Data->h, // Height - 8, // Bits depth + data->w, // Width + data->h, // Height + 8, // Bits depth PNG_COLOR_TYPE_RGB, // Colour type PNG_INTERLACE_NONE, // No interlacing PNG_COMPRESSION_TYPE_DEFAULT, // Compression type PNG_FILTER_TYPE_DEFAULT); // Filter Type // Rowpointer erstellen - png_bytep *rowPointers = new png_bytep[Data->h]; - for (uint i = 0; i < Data->h; i++) { - rowPointers[i] = (png_bytep)&pixelBuffer[Data->w * i]; + png_bytep *rowPointers = new png_bytep[data->h]; + for (uint i = 0; i < data->h; i++) { + rowPointers[i] = (png_bytep)&pixelBuffer[data->w * i]; } png_set_rows(png_ptr, info_ptr, &rowPointers[0]); // Write out the png data to the file - png_set_write_fn(png_ptr, (void *)Stream, userWriteFn, userFlushFn); + png_set_write_fn(png_ptr, (void *)stream, userWriteFn, userFlushFn); png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); png_destroy_write_struct(&png_ptr, &info_ptr); @@ -127,14 +120,14 @@ bool Screenshot::SaveToFile(Graphics::Surface *Data, Common::WriteStream *Stream // ----------------------------------------------------------------------------- -Common::MemoryReadStream *Screenshot::createThumbnail(Graphics::Surface *Data) { +Common::MemoryReadStream *Screenshot::createThumbnail(Graphics::Surface *data) { // This method takes a screen image with a dimension of 800x600, and creates a screenshot with a dimension of 200x125. // First 50 pixels are cut off the top and bottom (the interface boards in the game). The remaining image of 800x500 // will be on a 16th of its size, reduced by being handed out in 4x4 pixel blocks and the average of each block // generates a pixel of the target image. Finally, the result as a PNG file is stored as a file. // The source image must be 800x600. - if (Data->w != 800 || Data->h != 600 || Data->bytesPerPixel != 4) { + if (data->w != 800 || data->h != 600 || data->bytesPerPixel != 4) { BS_LOG_ERRORLN("The sreenshot dimensions have to be 800x600 in order to be saved as a thumbnail."); return false; } @@ -152,7 +145,7 @@ Common::MemoryReadStream *Screenshot::createThumbnail(Graphics::Surface *Data) { int alpha, red, green, blue; alpha = red = green = blue = 0; for (int j = 0; j < 4; ++j) { - const uint32 *srcP = (const uint32 *)Data->getBasePtr(x * 4, y * 4 + j + 50); + const uint32 *srcP = (const uint32 *)data->getBasePtr(x * 4, y * 4 + j + 50); for (int i = 0; i < 4; ++i) { uint32 pixel = READ_LE_UINT32(srcP + i); alpha += (pixel >> 24); @@ -178,7 +171,7 @@ Common::MemoryReadStream *Screenshot::createThumbnail(Graphics::Surface *Data) { // Create a PNG representation of the thumbnail data Common::MemoryWriteStreamDynamic *stream = new Common::MemoryWriteStreamDynamic(); - SaveToFile(&thumbnail, stream); + saveToFile(&thumbnail, stream); // Output a MemoryReadStream that encompasses the written data Common::MemoryReadStream *result = new Common::MemoryReadStream(stream->getData(), stream->size(), diff --git a/engines/sword25/gfx/screenshot.h b/engines/sword25/gfx/screenshot.h index d328130b3f..eefaa1bca6 100644 --- a/engines/sword25/gfx/screenshot.h +++ b/engines/sword25/gfx/screenshot.h @@ -35,23 +35,15 @@ #ifndef SWORD25_SCREENSHOT_H #define SWORD25_SCREENSHOT_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "graphics/surface.h" #include "sword25/kernel/common.h" namespace Sword25 { -// ----------------------------------------------------------------------------- -// Class declaration -// ----------------------------------------------------------------------------- - class Screenshot { public: - static bool SaveToFile(Graphics::Surface *Data, Common::WriteStream *Stream); - static Common::MemoryReadStream *createThumbnail(Graphics::Surface *Data); + static bool saveToFile(Graphics::Surface *data, Common::WriteStream *stream); + static Common::MemoryReadStream *createThumbnail(Graphics::Surface *data); }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/staticbitmap.cpp b/engines/sword25/gfx/staticbitmap.cpp index 3184e4f971..43e9ef73c6 100644 --- a/engines/sword25/gfx/staticbitmap.cpp +++ b/engines/sword25/gfx/staticbitmap.cpp @@ -32,10 +32,6 @@ * */ -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/gfx/staticbitmap.h" #include "sword25/gfx/bitmapresource.h" #include "sword25/package/packagemanager.h" @@ -44,16 +40,8 @@ namespace Sword25 { -// ----------------------------------------------------------------------------- -// Logging -// ----------------------------------------------------------------------------- - #define BS_LOG_PREFIX "STATICBITMAP" -// ----------------------------------------------------------------------------- -// Konstruktion / Destruktion -// ----------------------------------------------------------------------------- - StaticBitmap::StaticBitmap(RenderObjectPtr<RenderObject> parentPtr, const Common::String &filename) : Bitmap(parentPtr, TYPE_STATICBITMAP) { // Das BS_Bitmap konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. @@ -63,15 +51,11 @@ StaticBitmap::StaticBitmap(RenderObjectPtr<RenderObject> parentPtr, const Common _initSuccess = initBitmapResource(filename); } -// ----------------------------------------------------------------------------- - StaticBitmap::StaticBitmap(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPtr, uint handle) : Bitmap(parentPtr, TYPE_STATICBITMAP, handle) { _initSuccess = unpersist(reader); } -// ----------------------------------------------------------------------------- - bool StaticBitmap::initBitmapResource(const Common::String &filename) { // Bild-Resource laden Resource *resourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(filename); @@ -99,13 +83,9 @@ bool StaticBitmap::initBitmapResource(const Common::String &filename) { return true; } -// ----------------------------------------------------------------------------- - StaticBitmap::~StaticBitmap() { } -// ----------------------------------------------------------------------------- - bool StaticBitmap::doRender() { // Bitmap holen Resource *resourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename); @@ -137,8 +117,6 @@ bool StaticBitmap::doRender() { return result; } -// ----------------------------------------------------------------------------- - uint StaticBitmap::getPixel(int x, int y) const { BS_ASSERT(x >= 0 && x < _width); BS_ASSERT(y >= 0 && y < _height); @@ -151,17 +129,11 @@ uint StaticBitmap::getPixel(int x, int y) const { return result; } -// ----------------------------------------------------------------------------- - bool StaticBitmap::setContent(const byte *pixeldata, uint size, uint offset, uint stride) { BS_LOG_ERRORLN("SetContent() ist not supported with this object."); return false; } -// ----------------------------------------------------------------------------- -// Auskunftsmethoden -// ----------------------------------------------------------------------------- - bool StaticBitmap::isAlphaAllowed() const { Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename); BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP); @@ -170,8 +142,6 @@ bool StaticBitmap::isAlphaAllowed() const { return result; } -// ----------------------------------------------------------------------------- - bool StaticBitmap::isColorModulationAllowed() const { Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename); BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP); @@ -180,8 +150,6 @@ bool StaticBitmap::isColorModulationAllowed() const { return result; } -// ----------------------------------------------------------------------------- - bool StaticBitmap::isScalingAllowed() const { Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename); BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP); @@ -190,10 +158,6 @@ bool StaticBitmap::isScalingAllowed() const { return result; } -// ----------------------------------------------------------------------------- -// Persistenz -// ----------------------------------------------------------------------------- - bool StaticBitmap::persist(OutputPersistenceBlock &writer) { bool result = true; diff --git a/engines/sword25/gfx/staticbitmap.h b/engines/sword25/gfx/staticbitmap.h index a325487213..b5b4c4f5a2 100644 --- a/engines/sword25/gfx/staticbitmap.h +++ b/engines/sword25/gfx/staticbitmap.h @@ -35,19 +35,11 @@ #ifndef SWORD25_STATIC_BITMAP_H #define SWORD25_STATIC_BITMAP_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "sword25/gfx/bitmap.h" namespace Sword25 { -// ----------------------------------------------------------------------------- -// Klassendeklaration -// ----------------------------------------------------------------------------- - class StaticBitmap : public Bitmap { friend class RenderObject; @@ -63,20 +55,20 @@ public: virtual uint getPixel(int x, int y) const; - virtual bool setContent(const byte *pixeldata, uint size, uint offset, uint stride); + virtual bool setContent(const byte *pixeldata, uint size, uint offset, uint stride); - virtual bool isScalingAllowed() const; - virtual bool isAlphaAllowed() const; - virtual bool isColorModulationAllowed() const; - virtual bool isSetContentAllowed() const { + virtual bool isScalingAllowed() const; + virtual bool isAlphaAllowed() const; + virtual bool isColorModulationAllowed() const; + virtual bool isSetContentAllowed() const { return false; } - virtual bool persist(OutputPersistenceBlock &writer); - virtual bool unpersist(InputPersistenceBlock &reader); + virtual bool persist(OutputPersistenceBlock &writer); + virtual bool unpersist(InputPersistenceBlock &reader); protected: - virtual bool doRender(); + virtual bool doRender(); private: Common::String _resourceFilename; diff --git a/engines/sword25/gfx/text.cpp b/engines/sword25/gfx/text.cpp index 7b54170a26..69e0818503 100644 --- a/engines/sword25/gfx/text.cpp +++ b/engines/sword25/gfx/text.cpp @@ -36,10 +36,6 @@ // Entweder Fontfile absolut abspeichern, oder Verzeichniswechseln verbieten // Eine relative Fontfile-Angabe könnte verwandt werden nachdem das Verzeichnis bereits gewechselt wurde und die Datei würde nicht mehr gefunden -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/kernel.h" #include "sword25/kernel/outputpersistenceblock.h" #include "sword25/kernel/inputpersistenceblock.h" @@ -52,65 +48,49 @@ namespace Sword25 { #define BS_LOG_PREFIX "TEXT" -// ----------------------------------------------------------------------------- -// Konstanten -// ----------------------------------------------------------------------------- - namespace { const uint AUTO_WRAP_THRESHOLD_DEFAULT = 300; } -// ----------------------------------------------------------------------------- -// Konstruktion / Destruktion -// ----------------------------------------------------------------------------- - -Text::Text(RenderObjectPtr<RenderObject> ParentPtr) : - RenderObject(ParentPtr, RenderObject::TYPE_TEXT), +Text::Text(RenderObjectPtr<RenderObject> parentPtr) : + RenderObject(parentPtr, RenderObject::TYPE_TEXT), _modulationColor(0xffffffff), - m_AutoWrap(false), - m_AutoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT) { + _autoWrap(false), + _autoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT) { } -// ----------------------------------------------------------------------------- - -Text::Text(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, uint Handle) : - RenderObject(ParentPtr, TYPE_TEXT, Handle), +Text::Text(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPtr, uint handle) : + RenderObject(parentPtr, TYPE_TEXT, handle), // Temporarily set fields prior to unpersisting actual values _modulationColor(0xffffffff), - m_AutoWrap(false), - m_AutoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT) { + _autoWrap(false), + _autoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT) { // Unpersist the fields - _initSuccess = unpersist(Reader); + _initSuccess = unpersist(reader); } -// ----------------------------------------------------------------------------- - -bool Text::SetFont(const Common::String &Font) { +bool Text::setFont(const Common::String &font) { // Font precachen. - if (GetResourceManager()->PrecacheResource(Font)) { - m_Font = Font; - UpdateFormat(); + if (getResourceManager()->PrecacheResource(font)) { + _font = font; + updateFormat(); forceRefresh(); return true; } else { - BS_LOG_ERRORLN("Could not precache font \"%s\". Font probably does not exist.", Font.c_str()); + BS_LOG_ERRORLN("Could not precache font \"%s\". Font probably does not exist.", font.c_str()); return false; } } -// ----------------------------------------------------------------------------- - -void Text::SetText(const Common::String &text) { - m_Text = text; - UpdateFormat(); +void Text::setText(const Common::String &text) { + _text = text; + updateFormat(); forceRefresh(); } -// ----------------------------------------------------------------------------- - void Text::setColor(uint modulationColor) { uint newModulationColor = (modulationColor & 0x00ffffff) | (_modulationColor & 0xff000000); if (newModulationColor != _modulationColor) { @@ -119,8 +99,6 @@ void Text::setColor(uint modulationColor) { } } -// ----------------------------------------------------------------------------- - void Text::setAlpha(int alpha) { BS_ASSERT(alpha >= 0 && alpha < 256); uint newModulationColor = (_modulationColor & 0x00ffffff) | alpha << 24; @@ -130,225 +108,215 @@ void Text::setAlpha(int alpha) { } } -// ----------------------------------------------------------------------------- - -void Text::SetAutoWrap(bool AutoWrap) { - if (AutoWrap != m_AutoWrap) { - m_AutoWrap = AutoWrap; - UpdateFormat(); +void Text::setAutoWrap(bool autoWrap) { + if (autoWrap != _autoWrap) { + _autoWrap = autoWrap; + updateFormat(); forceRefresh(); } } -// ----------------------------------------------------------------------------- - -void Text::SetAutoWrapThreshold(uint AutoWrapThreshold) { - if (AutoWrapThreshold != m_AutoWrapThreshold) { - m_AutoWrapThreshold = AutoWrapThreshold; - UpdateFormat(); +void Text::setAutoWrapThreshold(uint autoWrapThreshold) { + if (autoWrapThreshold != _autoWrapThreshold) { + _autoWrapThreshold = autoWrapThreshold; + updateFormat(); forceRefresh(); } } -// ----------------------------------------------------------------------------- - bool Text::doRender() { // Font-Resource locken. - FontResource *FontPtr = LockFontResource(); - if (!FontPtr) return false; + FontResource *fontPtr = lockFontResource(); + if (!fontPtr) + return false; // Charactermap-Resource locken. - ResourceManager *RMPtr = GetResourceManager(); - BitmapResource *CharMapPtr; + ResourceManager *rmPtr = getResourceManager(); + BitmapResource *charMapPtr; { - Resource *pResource = RMPtr->RequestResource(FontPtr->GetCharactermapFileName()); + Resource *pResource = rmPtr->RequestResource(fontPtr->getCharactermapFileName()); if (!pResource) { - BS_LOG_ERRORLN("Could not request resource \"%s\".", FontPtr->GetCharactermapFileName().c_str()); + BS_LOG_ERRORLN("Could not request resource \"%s\".", fontPtr->getCharactermapFileName().c_str()); return false; } if (pResource->GetType() != Resource::TYPE_BITMAP) { - BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", FontPtr->GetCharactermapFileName().c_str()); + BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", fontPtr->getCharactermapFileName().c_str()); return false; } - CharMapPtr = static_cast<BitmapResource *>(pResource); + charMapPtr = static_cast<BitmapResource *>(pResource); } // Framebufferobjekt holen. - GraphicEngine *GfxPtr = Kernel::GetInstance()->GetGfx(); - BS_ASSERT(GfxPtr); + GraphicEngine *gfxPtr = Kernel::GetInstance()->GetGfx(); + BS_ASSERT(gfxPtr); - bool Result = true; - Common::Array<LINE>::iterator Iter = m_Lines.begin(); - for (; Iter != m_Lines.end(); ++Iter) { + bool result = true; + Common::Array<Line>::iterator iter = _lines.begin(); + for (; iter != _lines.end(); ++iter) { // Feststellen, ob überhaupt Buchstaben der aktuellen Zeile vom Update betroffen sind. - Common::Rect CheckRect = (*Iter).BBox; - CheckRect.translate(_absoluteX, _absoluteY); + Common::Rect checkRect = (*iter).bbox; + checkRect.translate(_absoluteX, _absoluteY); // Jeden Buchstaben einzeln Rendern. - int CurX = _absoluteX + (*Iter).BBox.left; - int CurY = _absoluteY + (*Iter).BBox.top; - for (uint i = 0; i < (*Iter).Text.size(); ++i) { - Common::Rect CurRect = FontPtr->GetCharacterRect((byte)(*Iter).Text[i]); - - Common::Rect RenderRect(CurX, CurY, CurX + CurRect.width(), CurY + CurRect.height()); - int RenderX = CurX + (RenderRect.left - RenderRect.left); - int RenderY = CurY + (RenderRect.top - RenderRect.top); - RenderRect.translate(CurRect.left - CurX, CurRect.top - CurY); - Result = CharMapPtr->blit(RenderX, RenderY, Image::FLIP_NONE, &RenderRect, _modulationColor); - if (!Result) break; - - CurX += CurRect.width() + FontPtr->GetGapWidth(); + int curX = _absoluteX + (*iter).bbox.left; + int curY = _absoluteY + (*iter).bbox.top; + for (uint i = 0; i < (*iter).text.size(); ++i) { + Common::Rect curRect = fontPtr->getCharacterRect((byte)(*iter).text[i]); + + Common::Rect renderRect(curX, curY, curX + curRect.width(), curY + curRect.height()); + int renderX = curX + (renderRect.left - renderRect.left); + int renderY = curY + (renderRect.top - renderRect.top); + renderRect.translate(curRect.left - curX, curRect.top - curY); + result = charMapPtr->blit(renderX, renderY, Image::FLIP_NONE, &renderRect, _modulationColor); + if (!result) + break; + + curX += curRect.width() + fontPtr->getGapWidth(); } } // Charactermap-Resource freigeben. - CharMapPtr->release(); + charMapPtr->release(); // Font-Resource freigeben. - FontPtr->release(); + fontPtr->release(); - return Result; + return result; } -// ----------------------------------------------------------------------------- - -ResourceManager *Text::GetResourceManager() { +ResourceManager *Text::getResourceManager() { // Pointer auf den Resource-Manager holen. return Kernel::GetInstance()->GetResourceManager(); } -// ----------------------------------------------------------------------------- - -FontResource *Text::LockFontResource() { - ResourceManager *RMPtr = GetResourceManager(); +FontResource *Text::lockFontResource() { + ResourceManager *rmPtr = getResourceManager(); // Font-Resource locken. - FontResource *FontPtr; + FontResource *fontPtr; { - Resource *ResourcePtr = RMPtr->RequestResource(m_Font); - if (!ResourcePtr) { - BS_LOG_ERRORLN("Could not request resource \"%s\".", m_Font.c_str()); + Resource *resourcePtr = rmPtr->RequestResource(_font); + if (!resourcePtr) { + BS_LOG_ERRORLN("Could not request resource \"%s\".", _font.c_str()); return NULL; } - if (ResourcePtr->GetType() != Resource::TYPE_FONT) { - BS_LOG_ERRORLN("Requested resource \"%s\" is not a font.", m_Font.c_str()); + if (resourcePtr->GetType() != Resource::TYPE_FONT) { + BS_LOG_ERRORLN("Requested resource \"%s\" is not a font.", _font.c_str()); return NULL; } - FontPtr = static_cast<FontResource *>(ResourcePtr); + fontPtr = static_cast<FontResource *>(resourcePtr); } - return FontPtr; + return fontPtr; } -// ----------------------------------------------------------------------------- - -void Text::UpdateFormat() { - FontResource *FontPtr = LockFontResource(); - BS_ASSERT(FontPtr); +void Text::updateFormat() { + FontResource *fontPtr = lockFontResource(); + BS_ASSERT(fontPtr); - UpdateMetrics(*FontPtr); + updateMetrics(*fontPtr); - m_Lines.resize(1); - if (m_AutoWrap && (uint) _width >= m_AutoWrapThreshold && m_Text.size() >= 2) { + _lines.resize(1); + if (_autoWrap && (uint) _width >= _autoWrapThreshold && _text.size() >= 2) { _width = 0; - uint CurLineWidth = 0; - uint CurLineHeight = 0; - uint CurLine = 0; - uint TempLineWidth = 0; - uint LastSpace = 0; // we need at least 1 space character to start a new line... - m_Lines[0].Text = ""; - for (uint i = 0; i < m_Text.size(); ++i) { + uint curLineWidth = 0; + uint curLineHeight = 0; + uint curLine = 0; + uint tempLineWidth = 0; + uint lastSpace = 0; // we need at least 1 space character to start a new line... + _lines[0].text = ""; + for (uint i = 0; i < _text.size(); ++i) { uint j; - TempLineWidth = 0; - LastSpace = 0; - for (j = i; j < m_Text.size(); ++j) { - if ((byte)m_Text[j] == ' ') LastSpace = j; + tempLineWidth = 0; + lastSpace = 0; + for (j = i; j < _text.size(); ++j) { + if ((byte)_text[j] == ' ') + lastSpace = j; - const Common::Rect &CurCharRect = FontPtr->GetCharacterRect((byte)m_Text[j]); - TempLineWidth += CurCharRect.width(); - TempLineWidth += FontPtr->GetGapWidth(); + const Common::Rect &curCharRect = fontPtr->getCharacterRect((byte)_text[j]); + tempLineWidth += curCharRect.width(); + tempLineWidth += fontPtr->getGapWidth(); - if ((TempLineWidth >= m_AutoWrapThreshold) && (LastSpace > 0)) + if ((tempLineWidth >= _autoWrapThreshold) && (lastSpace > 0)) break; } - if (j == m_Text.size()) LastSpace = m_Text.size(); // everything in 1 line. + if (j == _text.size()) // everything in 1 line. + lastSpace = _text.size(); - CurLineWidth = 0; - CurLineHeight = 0; - for (j = i; j < LastSpace; ++j) { - m_Lines[CurLine].Text += m_Text[j]; + curLineWidth = 0; + curLineHeight = 0; + for (j = i; j < lastSpace; ++j) { + _lines[curLine].text += _text[j]; - const Common::Rect &CurCharRect = FontPtr->GetCharacterRect((byte)m_Text[j]); - CurLineWidth += CurCharRect.width(); - CurLineWidth += FontPtr->GetGapWidth(); - if ((uint) CurCharRect.height() > CurLineHeight) CurLineHeight = CurCharRect.height(); + const Common::Rect &curCharRect = fontPtr->getCharacterRect((byte)_text[j]); + curLineWidth += curCharRect.width(); + curLineWidth += fontPtr->getGapWidth(); + if ((uint)curCharRect.height() > curLineHeight) + curLineHeight = curCharRect.height(); } - m_Lines[CurLine].BBox.right = CurLineWidth; - m_Lines[CurLine].BBox.bottom = CurLineHeight; - if ((uint) _width < CurLineWidth) _width = CurLineWidth; + _lines[curLine].bbox.right = curLineWidth; + _lines[curLine].bbox.bottom = curLineHeight; + if ((uint)_width < curLineWidth) + _width = curLineWidth; - if (LastSpace < m_Text.size()) { - ++CurLine; - BS_ASSERT(CurLine == m_Lines.size()); - m_Lines.resize(CurLine + 1); - m_Lines[CurLine].Text = ""; + if (lastSpace < _text.size()) { + ++curLine; + BS_ASSERT(curLine == _lines.size()); + _lines.resize(curLine + 1); + _lines[curLine].text = ""; } - i = LastSpace; + i = lastSpace; } // Bounding-Box der einzelnen Zeilen relativ zur ersten festlegen (vor allem zentrieren). _height = 0; - Common::Array<LINE>::iterator Iter = m_Lines.begin(); - for (; Iter != m_Lines.end(); ++Iter) { - Common::Rect &BBox = (*Iter).BBox; - BBox.left = (_width - BBox.right) / 2; - BBox.right = BBox.left + BBox.right; - BBox.top = (Iter - m_Lines.begin()) * FontPtr->GetLineHeight(); - BBox.bottom = BBox.top + BBox.bottom; - _height += BBox.height(); + Common::Array<Line>::iterator iter = _lines.begin(); + for (; iter != _lines.end(); ++iter) { + Common::Rect &bbox = (*iter).bbox; + bbox.left = (_width - bbox.right) / 2; + bbox.right = bbox.left + bbox.right; + bbox.top = (iter - _lines.begin()) * fontPtr->getLineHeight(); + bbox.bottom = bbox.top + bbox.bottom; + _height += bbox.height(); } } else { // Keine automatische Formatierung, also wird der gesamte Text in nur eine Zeile kopiert. - m_Lines[0].Text = m_Text; - m_Lines[0].BBox = Common::Rect(0, 0, _width, _height); + _lines[0].text = _text; + _lines[0].bbox = Common::Rect(0, 0, _width, _height); } - FontPtr->release(); + fontPtr->release(); } -// ----------------------------------------------------------------------------- - -void Text::UpdateMetrics(FontResource &fontResource) { +void Text::updateMetrics(FontResource &fontResource) { _width = 0; _height = 0; - for (uint i = 0; i < m_Text.size(); ++i) { - const Common::Rect &CurRect = fontResource.GetCharacterRect((byte)m_Text[i]); - _width += CurRect.width(); - if (i != m_Text.size() - 1) _width += fontResource.GetGapWidth(); - if (_height < CurRect.height()) _height = CurRect.height(); + for (uint i = 0; i < _text.size(); ++i) { + const Common::Rect &curRect = fontResource.getCharacterRect((byte)_text[i]); + _width += curRect.width(); + if (i != _text.size() - 1) + _width += fontResource.getGapWidth(); + if (_height < curRect.height()) + _height = curRect.height(); } } -// ----------------------------------------------------------------------------- -// Persistenz -// ----------------------------------------------------------------------------- - bool Text::persist(OutputPersistenceBlock &writer) { bool result = true; result &= RenderObject::persist(writer); writer.write(_modulationColor); - writer.write(m_Font); - writer.write(m_Text); - writer.write(m_AutoWrap); - writer.write(m_AutoWrapThreshold); + writer.write(_font); + writer.write(_text); + writer.write(_autoWrap); + writer.write(_autoWrapThreshold); result &= RenderObject::persistChildren(writer); @@ -366,21 +334,21 @@ bool Text::unpersist(InputPersistenceBlock &reader) { // Beim Laden der anderen Member werden die Set-Methoden benutzt statt der tatsächlichen Member. // So wird das Layout automatisch aktualisiert und auch alle anderen notwendigen Methoden ausgeführt. - Common::String Font; - reader.read(Font); - SetFont(Font); + Common::String font; + reader.read(font); + setFont(font); Common::String text; reader.read(text); - SetText(text); + setText(text); - bool AutoWrap; - reader.read(AutoWrap); - SetAutoWrap(AutoWrap); + bool autoWrap; + reader.read(autoWrap); + setAutoWrap(autoWrap); - uint AutoWrapThreshold; - reader.read(AutoWrapThreshold); - SetAutoWrapThreshold(AutoWrapThreshold); + uint autoWrapThreshold; + reader.read(autoWrapThreshold); + setAutoWrapThreshold(autoWrapThreshold); result &= RenderObject::unpersistChildren(reader); diff --git a/engines/sword25/gfx/text.h b/engines/sword25/gfx/text.h index 407cd3c1cb..42c1cd7c5d 100644 --- a/engines/sword25/gfx/text.h +++ b/engines/sword25/gfx/text.h @@ -35,28 +35,16 @@ #ifndef SWORD25_TEXT_H #define SWORD25_TEXT_H -// ----------------------------------------------------------------------------- -// Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "common/rect.h" #include "sword25/gfx/renderobject.h" namespace Sword25 { -// ----------------------------------------------------------------------------- -// Forward Declarations -// ----------------------------------------------------------------------------- - class Kernel; class FontResource; class ResourceManager; -// ----------------------------------------------------------------------------- -// Klassendefinition -// ----------------------------------------------------------------------------- - class Text : public RenderObject { friend class RenderObject; @@ -66,13 +54,13 @@ public: @param Font der Dateiname der Fontdatei. @return Gibt false zurück, wenn der Font nicht gefunden wurde. */ - bool SetFont(const Common::String &Font); + bool setFont(const Common::String &font); /** @brief Setzt den darzustellenden Text. @param Text der darzustellende Text */ - void SetText(const Common::String &text); + void setText(const Common::String &text); /** @brief Setzt den Alphawert des Textes. @@ -88,27 +76,27 @@ public: @param AutoWrap gibt an, ob der automatische Umbruch aktiviert oder deaktiviert werden soll. @remark Dieses Attribut wird mit dem Wert false initialisiert. */ - void SetAutoWrap(bool AutoWrap); + void setAutoWrap(bool autoWrap); /** @brief Legt die Längengrenze des Textes in Pixeln fest, ab der ein automatischer Zeilenumbruch vorgenommen wird. @remark Dieses Attribut wird mit dem Wert 300 initialisiert. @remark Eine automatische Formatierung wird nur vorgenommen, wenn diese durch einen Aufruf von SetAutoWrap() aktiviert wurde. */ - void SetAutoWrapThreshold(uint AutoWrapThreshold); + void setAutoWrapThreshold(uint autoWrapThreshold); /** @brief Gibt den dargestellten Text zurück. */ - const Common::String &GetText() { - return m_Text; + const Common::String &getText() { + return _text; } /** @brief Gibt den Namen das momentan benutzten Fonts zurück. */ - const Common::String &GetFont() { - return m_Font; + const Common::String &getFont() { + return _font; } /** @@ -136,44 +124,44 @@ public: /** @brief Gibt zurück, ob die automatische Formatierung aktiviert ist. */ - bool IsAutoWrapActive() const { - return m_AutoWrap; + bool isAutoWrapActive() const { + return _autoWrap; } /** @brief Gibt die Längengrenze des Textes in Pixeln zurück, ab der eine automatische Formatierung vorgenommen wird. */ - uint GetAutoWrapThreshold() const { - return m_AutoWrapThreshold; + uint getAutoWrapThreshold() const { + return _autoWrapThreshold; } - virtual bool persist(OutputPersistenceBlock &writer); - virtual bool unpersist(InputPersistenceBlock &reader); + virtual bool persist(OutputPersistenceBlock &writer); + virtual bool unpersist(InputPersistenceBlock &reader); protected: virtual bool doRender(); private: - Text(RenderObjectPtr<RenderObject> ParentPtr); - Text(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, uint Handle); - - uint _modulationColor; - Common::String m_Font; - Common::String m_Text; - bool m_AutoWrap; - uint m_AutoWrapThreshold; - - struct LINE { - Common::Rect BBox; - Common::String Text; + Text(RenderObjectPtr<RenderObject> parentPtr); + Text(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPtr, uint handle); + + uint _modulationColor; + Common::String _font; + Common::String _text; + bool _autoWrap; + uint _autoWrapThreshold; + + struct Line { + Common::Rect bbox; + Common::String text; }; - Common::Array<LINE> m_Lines; + Common::Array<Line> _lines; - void UpdateFormat(); - void UpdateMetrics(FontResource &fontResource); - ResourceManager *GetResourceManager(); - FontResource *LockFontResource(); + void updateFormat(); + void updateMetrics(FontResource &fontResource); + ResourceManager *getResourceManager(); + FontResource *lockFontResource(); }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/timedrenderobject.h b/engines/sword25/gfx/timedrenderobject.h index 94d882d18e..6fee19882a 100644 --- a/engines/sword25/gfx/timedrenderobject.h +++ b/engines/sword25/gfx/timedrenderobject.h @@ -32,14 +32,6 @@ * */ -// ----------------------------------------------------------------------------- -// System Includes -// ----------------------------------------------------------------------------- - -// ----------------------------------------------------------------------------- -// Engine Includes -// ----------------------------------------------------------------------------- - #include "sword25/kernel/common.h" #include "sword25/gfx/renderobject.h" |