/*************************************************************************** * Copyright (C) 2005-2019 by the FIFE team * * http://www.fifengine.net * * This file is part of FIFE. * * * * FIFE is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ // Standard C++ library includes #include #include // 3rd party library includes // FIFE includes // These includes are split up in two parts, separated by one empty line // First block: files included from the FIFE root src directory // Second block: files included from the same folder #include "util/base/exception.h" #include "util/log/logger.h" #include "util/structures/rect.h" #include "video/imagemanager.h" #include "video/renderbackend.h" #include "renderbackendsdl.h" #include "sdlimage.h" namespace FIFE { /** Logger to use for this source file. * @relates Logger */ static Logger _log(LM_VIDEO); SDLImage::SDLImage(IResourceLoader* loader): Image(loader) { resetSdlimage(); } SDLImage::SDLImage(const std::string& name, IResourceLoader* loader): Image(name, loader) { resetSdlimage(); } SDLImage::SDLImage(SDL_Surface* surface): Image(surface) { resetSdlimage(); } SDLImage::SDLImage(const std::string& name, SDL_Surface* surface): Image(name, surface) { resetSdlimage(); } SDLImage::SDLImage(const uint8_t* data, uint32_t width, uint32_t height): Image(data, width, height) { resetSdlimage(); } SDLImage::SDLImage(const std::string& name, const uint8_t* data, uint32_t width, uint32_t height): Image(name, data, width, height) { resetSdlimage(); } void SDLImage::resetSdlimage() { m_colorkey = RenderBackend::instance()->getColorKey(); m_texture = NULL; } SDLImage::~SDLImage() { invalidate(); } void SDLImage::invalidate() { if (m_texture && !m_shared) { SDL_DestroyTexture(m_texture); } m_texture = NULL; } void SDLImage::setSurface(SDL_Surface* surface) { invalidate(); reset(surface); resetSdlimage(); } void SDLImage::render(const Rect& rect, uint8_t alpha, uint8_t const* rgb) { if (alpha == 0) { return; } SDL_Surface* target = RenderBackend::instance()->getRenderTargetSurface(); assert(target != m_surface); // can't draw on the source surface if (rect.right() < 0 || rect.x > static_cast(target->w) || rect.bottom() < 0 || rect.y > static_cast(target->h)) { return; } SDL_Rect tarRect; tarRect.x = rect.x; tarRect.y = rect.y; tarRect.w = rect.w; tarRect.h = rect.h; Rect tmpRect = m_shared ? getSubImageRect() : getArea(); SDL_Rect srcRect; srcRect.x = tmpRect.x; srcRect.y = tmpRect.y; srcRect.w = tmpRect.w; srcRect.h = tmpRect.h; SDL_Renderer* renderer = static_cast(RenderBackend::instance())->getRenderer(); // create texture if (!m_texture) { if (!m_surface) { load(); } m_texture = SDL_CreateTextureFromSurface(renderer, m_surface); } // set additonal color and alpha mods if (rgb) { SDL_SetTextureColorMod(m_texture, rgb[0], rgb[1], rgb[2]); SDL_SetTextureAlphaMod(m_texture, rgb[3]); } else { SDL_SetTextureColorMod(m_texture, 255, 255, 255); SDL_SetTextureAlphaMod(m_texture, 255); } // set render color SDL_SetRenderDrawColor(renderer, 255, 255, 255, alpha); if (SDL_RenderCopy(renderer, m_texture, &srcRect, &tarRect) != 0) { throw SDLException(SDL_GetError()); } } size_t SDLImage::getSize() { size_t size = 0; if (m_surface && !m_shared) { size += m_surface->h * m_surface->pitch; } return size; } void SDLImage::useSharedImage(const ImagePtr& shared, const Rect& region) { if(shared->getState() != IResource::RES_LOADED) { shared->load(); } SDL_Surface* surface = shared->getSurface(); if (!surface) { shared->load(); surface = shared->getSurface(); } SDLImage* image = static_cast(shared.get()); m_texture = image->getTexture(); if (!m_texture) { // create atlas texture SDL_Renderer* renderer = static_cast(RenderBackend::instance())->getRenderer(); m_texture = SDL_CreateTextureFromSurface(renderer, surface); image->setTexture(m_texture); } setSurface(surface); m_shared = true; m_subimagerect = region; m_atlas_img = shared; m_atlas_name = shared->getName(); setState(IResource::RES_LOADED); } void SDLImage::forceLoadInternal() { validateShared(); } void SDLImage::validateShared() { if (m_atlas_name.empty()) { return; } if (m_atlas_img->getState() == IResource::RES_NOT_LOADED || getState() == IResource::RES_NOT_LOADED) { load(); } } void SDLImage::load() { if (!m_atlas_name.empty()) { // check atlas image // if it does not exist, it is created. if (!ImageManager::instance()->exists(m_atlas_name)) { ImagePtr newAtlas = ImageManager::instance()->create(m_atlas_name); m_atlas_img = newAtlas; } useSharedImage(m_atlas_img , m_subimagerect); } else { Image::load(); } } void SDLImage::free() { // save the image offsets int32_t xshift = m_xshift; int32_t yshift = m_yshift; setSurface(NULL); m_xshift = xshift; m_yshift = yshift; m_state = IResource::RES_NOT_LOADED; } SDL_Texture* SDLImage::getTexture() { return m_texture; } void SDLImage::setTexture(SDL_Texture* texture) { if (m_texture == texture) { return; } if (m_texture && !m_shared) { SDL_DestroyTexture(m_texture); } m_texture = texture; } }