renderbackend.cpp

Go to the documentation of this file.

/***************************************************************************
 *   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<Uint32>(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<Point>& points, int32_t elements, float t) {
        if (t < 0.0) {
            return points[0];
        } else if (t >= static_cast<double>(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<double>(t) / static_cast<double>(elements);
        double munk = Mathd::Pow(1.0 - mu, static_cast<double>(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<double>(tmpn);
                tmpn--;
                if (tmpi > 1) {
                    blend /= static_cast<double>(tmpi);
                    tmpi--;
                }
                if (diffn > 1) {
                    blend /= static_cast<double>(diffn);
                    diffn--;
                }
            }
            px += static_cast<double>(points[i].x) * blend;
            py += static_cast<double>(points[i].y) * blend;
        }

        return Point(static_cast<int32_t>(px), static_cast<int32_t>(py));
    }

    void RenderBackend::addControlPoints(const std::vector<Point>& points, std::vector<Point>& 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;
    }
}