summaryrefslogtreecommitdiff
path: root/src/being/compoundsprite.cpp
diff options
context:
space:
mode:
authorAndrei Karas <akaras@inbox.ru>2013-08-31 22:42:10 +0300
committerAndrei Karas <akaras@inbox.ru>2013-08-31 22:42:10 +0300
commit00cda69b883d6354f093be6ee39a7936cb798979 (patch)
treef1daa290abfb53180bd8420a45fe6dff1c7a2ab3 /src/being/compoundsprite.cpp
parent5919cdc663d5f60a8c5cc7e50ad0c43a18cf9829 (diff)
downloadManaVerse-00cda69b883d6354f093be6ee39a7936cb798979.tar.gz
ManaVerse-00cda69b883d6354f093be6ee39a7936cb798979.tar.bz2
ManaVerse-00cda69b883d6354f093be6ee39a7936cb798979.tar.xz
ManaVerse-00cda69b883d6354f093be6ee39a7936cb798979.zip
move being related files into being dir.
Diffstat (limited to 'src/being/compoundsprite.cpp')
-rw-r--r--src/being/compoundsprite.cpp567
1 files changed, 567 insertions, 0 deletions
diff --git a/src/being/compoundsprite.cpp b/src/being/compoundsprite.cpp
new file mode 100644
index 000000000..68a0d42e3
--- /dev/null
+++ b/src/being/compoundsprite.cpp
@@ -0,0 +1,567 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2010 The Mana Developers
+ * Copyright (C) 2011-2013 The ManaPlus Developers
+ *
+ * This file is part of The ManaPlus Client.
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "being/compoundsprite.h"
+
+#include "client.h"
+#include "configuration.h"
+#include "game.h"
+
+#ifdef USE_OPENGL
+#include "main.h"
+#endif
+
+#include "map.h"
+#include "sdlshared.h"
+
+#include "render/surfacegraphics.h"
+
+#include "resources/image.h"
+#include "resources/imagehelper.h"
+
+#include "utils/dtor.h"
+#include "utils/sdlcheckutils.h"
+
+#include <SDL.h>
+
+#include "debug.h"
+
+static const int BUFFER_WIDTH = 100;
+static const int BUFFER_HEIGHT = 100;
+
+static const unsigned cache_max_size = 10;
+static const unsigned cache_clean_part = 3;
+bool CompoundSprite::mEnableDelay = true;
+
+CompoundSprite::CompoundSprite() :
+ imagesCache(),
+ mCacheItem(nullptr),
+ mImage(nullptr),
+ mAlphaImage(nullptr),
+ mOffsetX(0),
+ mOffsetY(0),
+ mSprites(),
+ mNextRedrawTime(0),
+ mNeedsRedraw(false),
+ mEnableAlphaFix(config.getBoolValue("enableAlphaFix")),
+ mDisableAdvBeingCaching(config.getBoolValue("disableAdvBeingCaching")),
+ mDisableBeingCaching(config.getBoolValue("disableBeingCaching"))
+{
+ mAlpha = 1.0f;
+}
+
+CompoundSprite::~CompoundSprite()
+{
+ clear();
+ mImage = nullptr;
+ mAlphaImage = nullptr;
+}
+
+bool CompoundSprite::reset()
+{
+ bool ret = false;
+ FOR_EACH (SpriteIterator, it, mSprites)
+ {
+ if (*it)
+ ret |= (*it)->reset();
+ }
+ mNeedsRedraw |= ret;
+ return ret;
+}
+
+bool CompoundSprite::play(const std::string &action)
+{
+ bool ret = false;
+ FOR_EACH (SpriteIterator, it, mSprites)
+ {
+ if (*it)
+ ret |= (*it)->play(action);
+ }
+ mNeedsRedraw |= ret;
+ return ret;
+}
+
+bool CompoundSprite::update(const int time)
+{
+ bool ret = false;
+ FOR_EACH (SpriteIterator, it, mSprites)
+ {
+ if (*it)
+ ret |= (*it)->update(time);
+ }
+ mNeedsRedraw |= ret;
+ return ret;
+}
+
+bool CompoundSprite::draw(Graphics *const graphics,
+ const int posX, const int posY) const
+{
+ FUNC_BLOCK("CompoundSprite::draw", 1)
+ if (mNeedsRedraw)
+ updateImages();
+
+ if (mSprites.empty()) // Nothing to draw
+ return false;
+
+ if (mAlpha == 1.0f && mImage)
+ {
+ return graphics->drawImage(mImage, posX + mOffsetX, posY + mOffsetY);
+ }
+ else if (mAlpha && mAlphaImage)
+ {
+ mAlphaImage->setAlpha(mAlpha);
+ return graphics->drawImage(mAlphaImage,
+ posX + mOffsetX, posY + mOffsetY);
+ }
+ else
+ {
+ drawSprites(graphics, posX, posY);
+ }
+ return false;
+}
+
+void CompoundSprite::drawSprites(Graphics *const graphics,
+ const int posX, const int posY) const
+{
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ {
+ (*it)->setAlpha(mAlpha);
+ (*it)->draw(graphics, posX, posY);
+ }
+ }
+}
+
+void CompoundSprite::drawSpritesSDL(Graphics *const graphics,
+ const int posX, const int posY) const
+{
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ (*it)->draw(graphics, posX, posY);
+ }
+}
+
+int CompoundSprite::getWidth() const
+{
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ const Sprite *const base = *it;
+ if (base)
+ return base->getWidth();
+ }
+
+ return 0;
+}
+
+int CompoundSprite::getHeight() const
+{
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ const Sprite *const base = *it;
+ if (base)
+ return base->getHeight();
+ }
+
+ return 0;
+}
+
+const Image *CompoundSprite::getImage() const
+{
+ return mImage;
+}
+
+bool CompoundSprite::setSpriteDirection(const SpriteDirection direction)
+{
+ bool ret = false;
+ FOR_EACH (SpriteIterator, it, mSprites)
+ {
+ if (*it)
+ ret |= (*it)->setSpriteDirection(direction);
+ }
+ mNeedsRedraw |= ret;
+ return ret;
+}
+
+int CompoundSprite::getNumberOfLayers() const
+{
+ if (mImage || mAlphaImage)
+ return 1;
+ else
+ return static_cast<int>(size());
+}
+
+unsigned int CompoundSprite::getCurrentFrame() const
+{
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ return (*it)->getCurrentFrame();
+ }
+ return 0;
+}
+
+unsigned int CompoundSprite::getFrameCount() const
+{
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ return (*it)->getFrameCount();
+ }
+ return 0;
+}
+
+void CompoundSprite::addSprite(Sprite *const sprite)
+{
+ mSprites.push_back(sprite);
+ mNeedsRedraw = true;
+}
+
+void CompoundSprite::setSprite(const int layer, Sprite *const sprite)
+{
+ // Skip if it won't change anything
+ if (mSprites.at(layer) == sprite)
+ return;
+
+ delete mSprites.at(layer);
+ mSprites[layer] = sprite;
+ mNeedsRedraw = true;
+}
+
+void CompoundSprite::removeSprite(const int layer)
+{
+ // Skip if it won't change anything
+ if (!mSprites.at(layer))
+ return;
+
+ delete mSprites.at(layer);
+ mSprites.at(layer) = nullptr;
+ mNeedsRedraw = true;
+}
+
+void CompoundSprite::clear()
+{
+ // Skip if it won't change anything
+ if (!mSprites.empty())
+ {
+ delete_all(mSprites);
+ mSprites.clear();
+ }
+ mNeedsRedraw = true;
+ delete_all(imagesCache);
+ imagesCache.clear();
+ delete mCacheItem;
+ mCacheItem = nullptr;
+}
+
+void CompoundSprite::ensureSize(size_t layerCount)
+{
+ // Skip if it won't change anything
+ if (mSprites.size() >= layerCount)
+ return;
+
+// resize(layerCount, nullptr);
+ mSprites.resize(layerCount);
+}
+
+/**
+ * Returns the curent frame in the current animation of the given layer.
+ */
+unsigned int CompoundSprite::getCurrentFrame(unsigned int layer) const
+{
+ if (layer >= mSprites.size())
+ return 0;
+
+ const Sprite *const s = getSprite(layer);
+ if (s)
+ return s->getCurrentFrame();
+
+ return 0;
+}
+
+/**
+ * Returns the frame count in the current animation of the given layer.
+ */
+unsigned int CompoundSprite::getFrameCount(unsigned int layer)
+{
+ if (layer >= mSprites.size())
+ return 0;
+
+ const Sprite *const s = getSprite(layer);
+ if (s)
+ return s->getFrameCount();
+
+ return 0;
+}
+
+void CompoundSprite::redraw() const
+{
+#ifndef USE_SDL2
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+ const int rmask = 0xff000000;
+ const int gmask = 0x00ff0000;
+ const int bmask = 0x0000ff00;
+ const int amask = 0x000000ff;
+#else
+ const int rmask = 0x000000ff;
+ const int gmask = 0x0000ff00;
+ const int bmask = 0x00ff0000;
+ const int amask = 0xff000000;
+#endif
+
+ SDL_Surface *const surface = MSDL_CreateRGBSurface(SDL_HWSURFACE,
+ BUFFER_WIDTH, BUFFER_HEIGHT, 32, rmask, gmask, bmask, amask);
+
+ if (!surface)
+ return;
+
+ SurfaceGraphics *graphics = new SurfaceGraphics();
+ graphics->setBlitMode(SurfaceGraphics::BLIT_GFX);
+ graphics->setTarget(surface);
+ graphics->_beginDraw();
+
+ int tileX = 32 / 2;
+ int tileY = 32;
+
+ const Game *const game = Game::instance();
+ if (game)
+ {
+ const Map *const map = game->getCurrentMap();
+ if (map)
+ {
+ tileX = map->getTileWidth() / 2;
+ tileY = map->getTileWidth();
+ }
+ }
+
+ const int posX = BUFFER_WIDTH / 2 - tileX;
+ const int posY = BUFFER_HEIGHT - tileY;
+
+ mOffsetX = tileX - BUFFER_WIDTH / 2;
+ mOffsetY = tileY - BUFFER_HEIGHT;
+
+ drawSpritesSDL(graphics, posX, posY);
+
+ delete graphics;
+ graphics = nullptr;
+
+ SDL_Surface *const surfaceA = MSDL_CreateRGBSurface(SDL_HWSURFACE,
+ BUFFER_WIDTH, BUFFER_HEIGHT, 32, rmask, gmask, bmask, amask);
+
+#ifdef USE_SDL2
+ SDL_SetSurfaceAlphaMod(surface, 255);
+#else
+ SDL_SetAlpha(surface, 0, SDL_ALPHA_OPAQUE);
+#endif
+ SDL_BlitSurface(surface, nullptr, surfaceA, nullptr);
+
+ delete mImage;
+ delete mAlphaImage;
+
+ mImage = imageHelper->load(surface);
+ MSDL_FreeSurface(surface);
+
+ if (ImageHelper::mEnableAlpha)
+ {
+ mAlphaImage = imageHelper->load(surfaceA);
+ MSDL_FreeSurface(surfaceA);
+ }
+ else
+ {
+ mAlphaImage = nullptr;
+ }
+#endif
+}
+
+void CompoundSprite::setAlpha(float alpha)
+{
+ if (alpha != mAlpha)
+ {
+#ifdef USE_OPENGL
+ if (mEnableAlphaFix && imageHelper->useOpenGL() == 0
+ && size() > 3)
+#else
+ if (mEnableAlphaFix && size() > 3)
+#endif
+ {
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ (*it)->setAlpha(alpha);
+ }
+ }
+ mAlpha = alpha;
+ }
+}
+
+void CompoundSprite::updateImages() const
+{
+#ifndef USE_SDL2
+#ifdef USE_OPENGL
+ if (imageHelper->useOpenGL())
+ return;
+#endif
+
+ if (mEnableDelay)
+ {
+ if (get_elapsed_time1(mNextRedrawTime) < 10)
+ return;
+ mNextRedrawTime = tick_time;
+ }
+ mNeedsRedraw = false;
+
+ if (!mDisableBeingCaching)
+ {
+ if (size() <= 3)
+ return;
+
+ if (!mDisableAdvBeingCaching)
+ {
+ if (updateFromCache())
+ return;
+
+ redraw();
+
+ if (mImage)
+ initCurrentCacheItem();
+ }
+ else
+ {
+ redraw();
+ }
+ }
+#endif
+}
+
+bool CompoundSprite::updateFromCache() const
+{
+#ifndef USE_SDL2
+// static int hits = 0;
+// static int miss = 0;
+
+ if (mCacheItem && mCacheItem->image)
+ {
+ imagesCache.push_front(mCacheItem);
+ mCacheItem = nullptr;
+ if (imagesCache.size() > cache_max_size)
+ {
+ for (unsigned f = 0; f < cache_clean_part; f ++)
+ {
+ CompoundItem *item = imagesCache.back();
+ imagesCache.pop_back();
+ delete item;
+ }
+ }
+ }
+
+// logger->log("cache size: %d, hit %d, miss %d",
+// (int)imagesCache.size(), hits, miss);
+
+ const size_t sz = size();
+ FOR_EACH (ImagesCache::iterator, it, imagesCache)
+ {
+ CompoundItem *const ic = *it;
+ if (ic && ic->data.size() == sz)
+ {
+ bool fail(false);
+ VectorPointers::const_iterator it2 = ic->data.begin();
+ const VectorPointers::const_iterator it2_end = ic->data.end();
+
+ for (SpriteConstIterator it1 = mSprites.begin(),
+ it1_end = mSprites.end();
+ it1 != it1_end && it2 != it2_end;
+ ++ it1, ++ it2)
+ {
+ const void *ptr1 = nullptr;
+ const void *ptr2 = nullptr;
+ if (*it1)
+ ptr1 = (*it1)->getHash();
+ if (*it2)
+ ptr2 = *it2;
+ if (ptr1 != ptr2)
+ {
+ fail = true;
+ break;
+ }
+ }
+ if (!fail)
+ {
+// hits ++;
+ mImage = (*it)->image;
+ mAlphaImage = (*it)->alphaImage;
+ imagesCache.erase(it);
+ mCacheItem = ic;
+ return true;
+ }
+ }
+ }
+ mImage = nullptr;
+ mAlphaImage = nullptr;
+// miss++;
+#endif
+ return false;
+}
+
+void CompoundSprite::initCurrentCacheItem() const
+{
+ delete mCacheItem;
+ mCacheItem = new CompoundItem();
+ mCacheItem->image = mImage;
+ mCacheItem->alphaImage = mAlphaImage;
+// mCacheItem->alpha = mAlpha;
+
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ mCacheItem->data.push_back((*it)->getHash());
+ else
+ mCacheItem->data.push_back(nullptr);
+ }
+}
+
+bool CompoundSprite::updateNumber(unsigned num)
+{
+ bool res(false);
+ FOR_EACH (SpriteConstIterator, it, mSprites)
+ {
+ if (*it)
+ {
+ if ((*it)->updateNumber(num))
+ res = true;
+ }
+ }
+ return res;
+}
+
+CompoundItem::CompoundItem() :
+ data(),
+ image(nullptr),
+ alphaImage(nullptr)
+{
+}
+
+CompoundItem::~CompoundItem()
+{
+ delete image;
+ delete alphaImage;
+}