StelGLUtilityFunctions.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 _STELGLUTILITYFUNCTIONS_HPP_
#define _STELGLUTILITYFUNCTIONS_HPP_

#include <QGLContext>
#include <QString>

#include "StelGLCompatibility.hpp"
#include "StelRenderer.hpp"
#include "StelIndexBuffer.hpp"
#include "StelTextureParams.hpp"
#include "StelVertexAttribute.hpp"
#include "StelVertexBuffer.hpp"


inline GLint glAttributeType(const AttributeType type)
{
    switch(type)
    {
        case AttributeType_Vec2f:
        case AttributeType_Vec3f:
        case AttributeType_Vec4f:
            return GL_FLOAT;
        default:
            break;
    }
    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown vertex attribute type");
    
    // Prevents GCC from complaining about exiting a non-void function:
    return -1;
}


inline const char* glslAttributeName(const AttributeInterpretation interpretation)
{
    switch(interpretation)
    {
        case AttributeInterpretation_Position: return "vertex";
        case AttributeInterpretation_TexCoord: return "texCoord";
        case AttributeInterpretation_Normal:   return "normal";
        case AttributeInterpretation_Color:    return "color";
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown vertex attribute interpretation");
    }
    
    // Prevents GCC from complaining about exiting a non-void function:
    return NULL;
}


inline GLenum gl1AttributeEnum(const AttributeInterpretation interpretation)
{
    switch(interpretation)
    {
        case AttributeInterpretation_Position: return GL_VERTEX_ARRAY;
        case AttributeInterpretation_TexCoord: return GL_TEXTURE_COORD_ARRAY;
        case AttributeInterpretation_Normal:   return GL_NORMAL_ARRAY;
        case AttributeInterpretation_Color:    return GL_COLOR_ARRAY;
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown vertex attribute interpretation");
    }
    
    // Prevents GCC from complaining about exiting a non-void function:
    return GL_VERTEX_ARRAY;
}

inline GLint glPrimitiveType(const PrimitiveType type)
{
    switch(type)
    {
        case PrimitiveType_Points:        return GL_POINTS;
        case PrimitiveType_Triangles:     return GL_TRIANGLES;
        case PrimitiveType_TriangleStrip: return GL_TRIANGLE_STRIP;
        case PrimitiveType_TriangleFan:   return GL_TRIANGLE_FAN;
        case PrimitiveType_Lines:         return GL_LINES;
        case PrimitiveType_LineStrip:     return GL_LINE_STRIP;
        case PrimitiveType_LineLoop:      return GL_LINE_LOOP;
    }
    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown graphics primitive type");
    
    // Prevents GCC from complaining about exiting a non-void function:
    return -1;
}

inline GLenum glIndexType(const IndexType indexType)
{
    if(indexType == IndexType_U16)      {return GL_UNSIGNED_SHORT;}
    else if(indexType == IndexType_U32) {return GL_UNSIGNED_INT;}
    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown index type");
    // Prevents GCC from complaining about exiting a non-void function:
    return -1;
}

inline GLint glTextureWrap(const TextureWrap wrap)
{
    switch(wrap)
    {
        case TextureWrap_Repeat:      return GL_REPEAT;
        case TextureWrap_ClampToEdge: return GL_CLAMP_TO_EDGE;
    }
    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown texture wrap mode");

    // Prevents GCC from complaining about exiting a non-void function:
    return -1;
}

inline QString glErrorToString(const GLenum error)
{
    switch(error)
    {
        case GL_NO_ERROR:                      return "GL_NO_ERROR";
        case GL_INVALID_ENUM:                  return "GL_INVALID_ENUM";
        case GL_INVALID_VALUE:                 return "GL_INVALID_VALUE"; 
        case GL_INVALID_OPERATION:             return "GL_INVALID_OPERATION"; 
        case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION"; 
        case GL_OUT_OF_MEMORY:                 return "GL_OUT_OF_MEMORY"; 
    }
    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown GL error");

    // Prevents GCC from complaining about exiting a non-void function:
    return QString();
}

inline GLint glGetTextureInternalFormat(const QImage& image)
{
    const bool gray  = image.isGrayscale();
    const bool alpha = image.hasAlphaChannel();
    if(gray) {return alpha ? GL_LUMINANCE8_ALPHA8 : GL_LUMINANCE8;}
    else     {return alpha ? GL_RGBA8 : GL_RGB8;}
}

inline GLint glGetTextureInternalFormat(const TextureDataFormat format)
{
    switch(format)
    {
        case TextureDataFormat_RGBA_F32: return GL_RGBA32F; break;
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown texture data format");
    }
    // Avoid compiler warnings
    return -1;
}

inline GLenum glGetTextureLoadFormat(const QImage& image)
{
    const bool gray  = image.isGrayscale();
    const bool alpha = image.hasAlphaChannel();
    if(gray) {return alpha ? GL_LUMINANCE_ALPHA : GL_LUMINANCE;}
    else     {return alpha ? GL_RGBA : GL_RGB;}
}

inline GLint glGetTextureLoadFormat(const TextureDataFormat format)
{
    switch(format)
    {
        case TextureDataFormat_RGBA_F32: return GL_RGBA; break;
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown texture data format");
    }
    // Avoid compiler warnings
    return -1;
}

inline GLenum glGetTextureType(const QImage& image)
{
    Q_UNUSED(image);
    return GL_UNSIGNED_BYTE;
}

inline GLint glGetTextureType(const TextureDataFormat format)
{
    switch(format)
    {
        case TextureDataFormat_RGBA_F32: return GL_FLOAT; break;
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown texture data format");
    }
    // Avoid compiler warnings
    return -1;
}

inline bool glTextureSizeWithinLimits(const QSize size, const TextureDataFormat format)
{
    const GLint internalFormat = glGetTextureInternalFormat(format);
    const GLenum loadFormat    = glGetTextureLoadFormat(format);
    const GLenum type          = glGetTextureType(format);

    glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, size.width(), size.height(), 0,
                 loadFormat, type, NULL);

    GLint width  = size.width();
    GLint height = size.height();
    glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
    glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &height);

    return width != 0 && height != 0;
}

inline bool glTextureSizeWithinLimits(const QImage& image)
{
    const GLint  internalFormat = glGetTextureInternalFormat(image);
    const GLenum loadFormat     = glGetTextureLoadFormat(image);
    const GLenum type           = glGetTextureType(image);

    glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, image.width(), image.height(), 0,
                 loadFormat, type, NULL);

    GLint width  = image.width();
    GLint height = image.height();
    glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
    glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &height);

    return width != 0 && height != 0;
}

inline void glEnsureTextureSizeWithinLimits(QImage& image)
{
    while(!glTextureSizeWithinLimits(image))
    {
        if(image.width() <= 1)
        {
            Q_ASSERT_X(false, Q_FUNC_INFO, "Even a texture with width <= 1 is \"too large\": "
                       "maybe image format is invalid/not GL supported?");
        }
        image = image.scaledToWidth(image.width() / 2, Qt::FastTransformation);
    }
}

QString glFileSystemTexturePath(const QString& filename, const bool pvrSupported);

inline void checkGLErrors(const QString& context)
{
    const GLenum glError = glGetError();
    if(glError == GL_NO_ERROR) {return;}

    qWarning() << "OpenGL error detected at " << context <<  " : " 
               << glErrorToString(glError);
}

#endif // _STELGLUTILITYFUNCTIONS_HPP_