StelRenderer.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * 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 (at your option) 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELRENDERER_HPP_
#define _STELRENDERER_HPP_

#include <QImage>
#include <QPainter>
#include <QSize>

#include "StelApp.hpp"
#include "StelCore.hpp"
#include "StelGLSLShader.hpp"
#include "StelIndexBuffer.hpp"
#include "StelRendererStatistics.hpp"
#include "StelVertexAttribute.hpp"
#include "StelVertexBuffer.hpp"
#include "StelViewportEffect.hpp"
#include "StelTextureNew.hpp"
#include "StelTextureParams.hpp"

enum BlendMode
{
    BlendMode_None,
    BlendMode_Add,
    BlendMode_Alpha,
    BlendMode_Multiply
};

enum CullFace 
{
    CullFace_None,
    CullFace_Front,
    CullFace_Back
};

enum DepthTest
{
    DepthTest_Disabled,
    DepthTest_ReadOnly,
    DepthTest_ReadWrite
};

enum StencilTest
{
    StencilTest_Disabled,
    StencilTest_Write_1,
    StencilTest_DrawIf_1
};

enum TextureDataFormat
{
    TextureDataFormat_RGBA_F32
};

class StelRenderClient
{
public:
    virtual bool drawPartial() = 0;

    virtual QPainter* getPainter() = 0;

    virtual StelViewportEffect* getViewportEffect() = 0;
};

struct TextParams
{
friend class StelQGLRenderer;
    TextParams(const float x, const float y, const QString& string)
        : position_(x, y, 0.0f)
        , string_(string)
        , angleDegrees_(0.0f)
        , xShift_(0.0f)
        , yShift_(0.0f)
        , noGravity_(true)
        , projector_(NULL)
        , doNotProject_(true)
    {}

    template<class F>
    TextParams(Vector3<F>& position3D, StelProjectorP projector, const QString& string)
        : position_(position3D[0], position3D[1], position3D[2])
        , string_(string)
        , angleDegrees_(0.0f)
        , xShift_(0.0f)
        , yShift_(0.0f)
        , noGravity_(true)
        , projector_(projector)
        , doNotProject_(false)
    {
    }

    TextParams& angleDegrees(const float angle)
    {
        angleDegrees_ = angle;
        return *this;
    }

    TextParams& shift(const float x, const float y)
    {
        xShift_ = x;
        yShift_ = y;
        return *this;
    }

    TextParams& useGravity()
    {
        noGravity_ = false;
        return *this;
    }

    TextParams& projector(StelProjectorP projector)
    {
        projector_ = projector;
        return *this;
    }

private:
    Vec3f position_;
    QString string_;
    float angleDegrees_;
    float xShift_;
    float yShift_;
    bool  noGravity_;
    StelProjectorP projector_;
    bool doNotProject_;
};

class StelRenderer
{
// For destroyTextureBackend() and bindTextureBackend()
friend class StelTextureNew;
public:
    virtual ~StelRenderer(){};

    virtual bool init() = 0;
    
    virtual QImage screenshot() = 0;
    
    virtual void viewportHasBeenResized(const QSize size) = 0;

    virtual class StelIndexBuffer* createIndexBuffer(const IndexType type) = 0;
    
    template<class V>
    StelVertexBuffer<V>* createVertexBuffer(const PrimitiveType primitiveType)
    {
        return new StelVertexBuffer<V>
            (createVertexBufferBackend(primitiveType, V::attributes()), primitiveType);
    }
    
    template<class V>
    void drawVertexBuffer(StelVertexBuffer<V>* vertexBuffer, 
                          class StelIndexBuffer* indexBuffer = NULL,
                          StelProjectorP projector = StelProjectorP(NULL),
                          bool dontProject = false)
    {
        drawVertexBufferBackend(vertexBuffer->backend, indexBuffer, &(*projector), dontProject);
    }

    template<class V>
    void drawVertexBuffer(StelVertexBuffer<V>* vertexBuffer, 
                          class StelIndexBuffer* indexBuffer,
                          StelProjector* projector,
                          bool dontProject = false)
    {
        drawVertexBufferBackend(vertexBuffer->backend, indexBuffer, projector, dontProject);
    }

    virtual void drawLine(const float startX, const float startY, 
                          const float endX, const float endY);

    virtual void drawRect(const float x, const float y, 
                          const float width, const float height, 
                          const float angle = 0.0f) = 0;
    
    virtual void drawTexturedRect(const float x, const float y, 
                                  const float width, const float height, 
                                  const float angle = 0.0f) = 0;

    virtual void drawText(const TextParams& params) = 0;

    virtual void setFont(const QFont& font) = 0;

    virtual void renderFrame(StelRenderClient& renderClient) = 0;

    StelTextureNew* createTexture
        (const QString& filename, const TextureParams& params = TextureParams(), 
         const TextureLoadingMode loadingMode = TextureLoadingMode_Normal)
    {
        //This function tests preconditions and calls implementation.
        Q_ASSERT_X(!filename.endsWith(".pvr"), Q_FUNC_INFO,
                   "createTexture() can't load a PVR texture directly, as PVR "
                   "support may not be implemented by all Renderer backends. Request "
                   "a non-PVR texture, and if a PVR version exists and the backend "
                   "supports it, it will be loaded.");
        Q_ASSERT_X(!filename.isEmpty(), Q_FUNC_INFO,
                   "Trying to load a texture with an empty filename or URL");
        Q_ASSERT_X(!(filename.startsWith("http://") && loadingMode == TextureLoadingMode_Normal),
                   Q_FUNC_INFO,
                   "When loading a texture from network, texture loading mode must be "
                   "Asynchronous or LazyAsynchronous");

        return new StelTextureNew(this, createTextureBackend(filename, params, loadingMode));
    }

    StelTextureNew* createTexture
        (QImage& image, const TextureParams& params = TextureParams())
    {
        Q_ASSERT_X(!image.isNull(), Q_FUNC_INFO, "Trying to create a texture from a null image");
        return new StelTextureNew(this, createTextureBackend(image, params));
    }

    StelTextureNew* createTexture
        (const void* const data, const QSize size, const TextureDataFormat format, 
         const TextureParams& params = TextureParams())
    {
        Q_ASSERT_X(NULL != data, Q_FUNC_INFO, "Trying to load a texture from a NULL pointer to data");
        if(!areFloatTexturesSupported())
        {
            Q_ASSERT_X(format != TextureDataFormat_RGBA_F32, Q_FUNC_INFO,
                       "Trying to load a floating-point texture even though "
                       "float textures are not supported");
        }
        return new StelTextureNew(this, createTextureBackend(data, size, format, params));
    }

    virtual bool areFloatTexturesSupported() const = 0;

    StelTextureNew* getViewportTexture()
    {
        return new StelTextureNew(this, getViewportTextureBackend());
    }

    virtual StelGLSLShader* createGLSLShader()
    {
        Q_ASSERT_X(false, Q_FUNC_INFO, 
                   "Trying to create a GLSL shader with a renderer backend that doesn't "
                   "support GLSL");
        // Avoids compiler warnings.
        return NULL;
    }

    virtual bool isGLSLSupported() const = 0;

    virtual QSize getViewportSize() const = 0;

    virtual void setGlobalColor(const Vec4f& color) = 0;

    void setGlobalColor(const float r, const float g, const float b, const float a = 1.0f)
    {
        setGlobalColor(Vec4f(r, g, b, a));
    }

    virtual void setBlendMode(const BlendMode blendMode) = 0;

    virtual void setCulledFaces(const CullFace cullFace) = 0;

    virtual void clearDepthBuffer() = 0;

    virtual void setDepthTest(const DepthTest test) = 0;

    virtual void clearStencilBuffer() = 0;

    virtual void setStencilTest(const StencilTest test) = 0;

    virtual void swapBuffers() = 0;

    virtual StelRendererStatistics& getStatistics() = 0;

protected:
    virtual StelVertexBufferBackend* createVertexBufferBackend
        (const PrimitiveType primitiveType, const QVector<StelVertexAttribute>& attributes) = 0;

    virtual void drawVertexBufferBackend(StelVertexBufferBackend* vertexBuffer, 
                                         class StelIndexBuffer* indexBuffer,
                                         StelProjector* projector,
                                         const bool dontProject) = 0;

    virtual class StelTextureBackend* createTextureBackend
        (const QString& filename, const TextureParams& params, 
         const TextureLoadingMode loadingMode) = 0;


    virtual class StelTextureBackend* createTextureBackend
        (QImage& image, const TextureParams& params) = 0;

    virtual class StelTextureBackend* createTextureBackend
        (const void* data, const QSize size, const TextureDataFormat format, 
         const TextureParams& params) = 0;

    virtual class StelTextureBackend* getViewportTextureBackend() = 0;

    virtual void destroyTextureBackend(class StelTextureBackend* backend) = 0;

    virtual void bindTextureBackend(class StelTextureBackend* textureBackend, const int textureUnit) = 0;
};

#endif // _STELRENDERER_HPP_