/*************************************************************************** * 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 // 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 "renderbackend.h" #include "video/devicecaps.h" namespace FIFE { RenderBackend::RenderBackend(const SDL_Color& colorkey): m_window(NULL), m_screen(NULL), m_target(NULL), m_compressimages(false), m_useframebuffer(false), m_usenpot(false), m_isalphaoptimized(false), m_iscolorkeyenabled(false), m_colorkey(colorkey), m_isMipmapping(false), m_textureFilter(TEXTURE_FILTER_NONE), m_maxAnisotropy(0), m_monochrome(false), m_isDepthBuffer(false), m_alphaValue(0.3), m_vSync(false), m_isframelimit(false), m_frame_start(0), m_framelimit(60) { m_isbackgroundcolor = false; m_backgroundcolor.r = 0; m_backgroundcolor.g = 0; m_backgroundcolor.b = 0; } RenderBackend::~RenderBackend() { } void RenderBackend::deinit() { SDL_QuitSubSystem(SDL_INIT_VIDEO); SDL_Quit(); } void RenderBackend::startFrame() { if (m_isframelimit) { m_frame_start = SDL_GetTicks(); } } void RenderBackend::endFrame () { if (m_isframelimit) { uint16_t frame_time = SDL_GetTicks() - m_frame_start; const float frame_limit = 1000.0f/m_framelimit; if (frame_time < frame_limit) { SDL_Delay(static_cast(frame_limit) - frame_time); } } } const ScreenMode& RenderBackend::getCurrentScreenMode() const{ return m_screenMode; } uint32_t RenderBackend::getWidth() const { return m_screen->w; } uint32_t RenderBackend::getHeight() const { return m_screen->h; } const Rect& RenderBackend::getArea() const { static Rect r(0, 0, m_screen->w, m_screen->h); return r; } void RenderBackend::pushClipArea(const Rect& cliparea, bool clear) { ClipInfo ci; ci.r = cliparea; ci.clearing = clear; m_clipstack.push(ci); setClipArea(cliparea, clear); } void RenderBackend::popClipArea() { assert(!m_clipstack.empty()); m_clipstack.pop(); if (m_clipstack.empty()) { setClipArea(getArea(), false); } else { ClipInfo ci = m_clipstack.top(); // instead of using ci.clearing, we set it to false // to avoid double clearing setClipArea(ci.r, false); } } const Rect& RenderBackend::getClipArea() const { if (!m_clipstack.empty()) { return m_clipstack.top().r; } else { return getArea(); } } void RenderBackend::clearClipArea() { setClipArea(getArea(), true); } void RenderBackend::setTextureFiltering(TextureFiltering filter) { m_textureFilter = filter; } TextureFiltering RenderBackend::getTextureFiltering() const { return m_textureFilter; } void RenderBackend::setMipmappingEnabled(bool enabled) { m_isMipmapping = enabled; } bool RenderBackend::isMipmappingEnabled() const { return m_isMipmapping; } int32_t RenderBackend::getMaxAnisotropy() const { return m_maxAnisotropy; } void RenderBackend::setMonochromeEnabled(bool enabled) { m_monochrome = enabled; } bool RenderBackend::isMonochromeEnabled() const { return m_monochrome; } void RenderBackend::setDepthBufferEnabled(bool enabled) { m_isDepthBuffer = enabled; } bool RenderBackend::isDepthBufferEnabled() const { return m_isDepthBuffer; } void RenderBackend::setAlphaTestValue(float alpha) { m_alphaValue = alpha; } float RenderBackend::getAlphaTestValue() const { return m_alphaValue; } void RenderBackend::setColorKeyEnabled(bool colorkeyenable) { m_iscolorkeyenabled = colorkeyenable; } bool RenderBackend::isColorKeyEnabled() const { return m_iscolorkeyenabled; } void RenderBackend::setColorKey(const SDL_Color& colorkey) { m_colorkey = colorkey; } const SDL_Color& RenderBackend::getColorKey() const { return m_colorkey; } void RenderBackend::setBackgroundColor(uint8_t r, uint8_t g, uint8_t b) { if (r != m_backgroundcolor.r || g != m_backgroundcolor.g || b != m_backgroundcolor.b) { m_isbackgroundcolor = true; m_backgroundcolor.r = r; m_backgroundcolor.g = g; m_backgroundcolor.b = b; } } void RenderBackend::resetBackgroundColor() { setBackgroundColor(0,0,0); } const SDL_PixelFormat& RenderBackend::getPixelFormat() const { return m_rgba_format; } void RenderBackend::setVSyncEnabled(bool vsync) { m_vSync = vsync; } bool RenderBackend::isVSyncEnabled() const { return m_vSync; } void RenderBackend::setFrameLimitEnabled(bool limited) { m_isframelimit = limited; } bool RenderBackend::isFrameLimitEnabled() const { return m_isframelimit; } void RenderBackend::setFrameLimit(uint16_t framelimit) { m_framelimit = framelimit; } uint16_t RenderBackend::getFrameLimit() const { return m_framelimit; } SDL_Surface* RenderBackend::getScreenSurface() { return m_screen; } SDL_Surface* RenderBackend::getRenderTargetSurface() { return m_target; } Point RenderBackend::getBezierPoint(const std::vector& points, int32_t elements, float t) { if (t < 0.0) { return points[0]; } else if (t >= static_cast(elements)) { return points.back(); } // Interpolate double px = 0.0; double py = 0.0; int32_t n = elements - 1; double muk = 1.0; double mu = static_cast(t) / static_cast(elements); double munk = Mathd::Pow(1.0 - mu, static_cast(n)); for (int32_t i = 0; i <= n; ++i) { int32_t tmpn = n; int32_t tmpi = i; int32_t diffn = n - i; double blend = muk * munk; muk *= mu; munk /= 1.0 - mu; while (tmpn) { blend *= static_cast(tmpn); tmpn--; if (tmpi > 1) { blend /= static_cast(tmpi); tmpi--; } if (diffn > 1) { blend /= static_cast(diffn); diffn--; } } px += static_cast(points[i].x) * blend; py += static_cast(points[i].y) * blend; } return Point(static_cast(px), static_cast(py)); } void RenderBackend::addControlPoints(const std::vector& points, std::vector& newPoints) { if (points.empty()) { return; } int32_t n = points.size() - 1; // min 2 points if (n < 1) { return; } Point p; // straight line if (n == 1) { newPoints.push_back(points[0]); p.x = (2 * points[0].x + points[1].x) / 3; p.y = (2 * points[0].y + points[1].y) / 3; newPoints.push_back(p); p.x = 2 * p.x - points[0].x; p.y = 2 * p.y - points[0].y; newPoints.push_back(p); newPoints.push_back(points[1]); return; } // calculate x and y values float* xrhs = new float[n]; float* yrhs = new float[n]; // first xrhs[0] = points[0].x + 2 * points[1].x; yrhs[0] = points[0].y + 2 * points[1].y; // last xrhs[n - 1] = (8 * points[n - 1].x + points[n].x) / 2.0; yrhs[n - 1] = (8 * points[n - 1].y + points[n].y) / 2.0; // rest for (int32_t i = 1; i < n - 1; ++i) { xrhs[i] = 4 * points[i].x + 2 * points[i + 1].x; yrhs[i] = 4 * points[i].y + 2 * points[i + 1].y; } float* x = new float[n]; float* y = new float[n]; float* xtmp = new float[n]; float* ytmp = new float[n]; float xb = 2.0; float yb = 2.0; x[0] = xrhs[0] / xb; y[0] = yrhs[0] / yb; // Decomposition and forward substitution. for (int32_t i = 1; i < n; i++) { xtmp[i] = 1 / xb; ytmp[i] = 1 / yb; xb = (i < n - 1 ? 4.0 : 3.5) - xtmp[i]; yb = (i < n - 1 ? 4.0 : 3.5) - ytmp[i]; x[i] = (xrhs[i] - x[i - 1]) / xb; y[i] = (yrhs[i] - y[i - 1]) / yb; } // Backward substitution for (int32_t i = 1; i < n; i++) { x[n - i - 1] -= xtmp[n - i] * x[n - i]; y[n - i - 1] -= ytmp[n - i] * y[n - i]; } // start point newPoints.push_back(points[0]); for (int32_t i = 0; i < n - 1; ++i) { p.x = x[i]; p.y = y[i]; newPoints.push_back(p); p.x = 2 * points[i + 1].x - x[i + 1]; p.y = 2 * points[i + 1].y - y[i + 1]; newPoints.push_back(p); newPoints.push_back(points[i+1]); } p.x = x[n - 1]; p.y = y[n - 1]; newPoints.push_back(p); p.x = (points[n].x + x[n - 1]) / 2; p.y = (points[n].y + y[n - 1]) / 2; newPoints.push_back(p); // end point newPoints.push_back(points[n]); delete[] xrhs; delete[] yrhs; delete[] x; delete[] y; delete[] xtmp; delete[] ytmp; } }