StelVertexAttribute.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 _STELVERTEXATTRIBUTE_HPP_
#define _STELVERTEXATTRIBUTE_HPP_

#include <QDebug>
#include <QString>
#include <QStringList>
#include <QVector>

#include "VecMath.hpp"

enum AttributeType
{
    AttributeType_Vec4f = 0,
    AttributeType_Vec3f = 1,
    AttributeType_Vec2f = 2,
    AttributeType_Max   = 3
};

inline int attributeDimensions(const AttributeType type)
{
    static const int attributeDimensionsArray [AttributeType_Max] =
        {4, 3, 2};
    return attributeDimensionsArray[type];
}

inline int attributeSize(const AttributeType type)
{
    static const int attributeSizeArray [AttributeType_Max] = 
        {sizeof(Vec4f), sizeof(Vec3f), sizeof(Vec2f)};
    return attributeSizeArray[type];
}

enum AttributeInterpretation
{
    AttributeInterpretation_Position = 0,
    AttributeInterpretation_Color    = 1,
    AttributeInterpretation_Normal   = 2,
    AttributeInterpretation_TexCoord = 3,
    AttributeInterpretation_MAX
};

struct StelVertexAttribute
{
    AttributeType type;
    AttributeInterpretation interpretation;
    
    StelVertexAttribute(){}
    
    StelVertexAttribute(const QString& attributeString)
    {
        const QString typeStr = 
            attributeString.section(' ', 0, 0, QString::SectionSkipEmpty);
        const QString interpretationStr = 
            attributeString.section(' ', 1, 1, QString::SectionSkipEmpty);

        if(typeStr == "Vec2f")      {type = AttributeType_Vec2f;}
        else if(typeStr == "Vec3f") {type = AttributeType_Vec3f;}
        else if(typeStr == "Vec4f") {type = AttributeType_Vec4f;}
        else 
        {
            qDebug() << "Unknown vertex attribute type: \"" << typeStr 
                     << "\" in attribute \"" << attributeString << "\"";
            Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown vertex attribute type");
        }

        if(interpretationStr == "Position")      
        {
            interpretation = AttributeInterpretation_Position;
        }
        else if(interpretationStr == "Color") 
        {
            interpretation = AttributeInterpretation_Color;
        }
        else if(interpretationStr == "Normal") 
        {
            interpretation = AttributeInterpretation_Normal;
        }
        else if(interpretationStr == "TexCoord") 
        {
            interpretation = AttributeInterpretation_TexCoord;
        }
        else 
        {
            qDebug() << "Unknown vertex attribute interpretation: \"" << interpretationStr 
                     << "\" in attribute \"" << attributeString << "\"";
            Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown vertex attribute interpretation");
        }
    }

    static QVector<StelVertexAttribute> parseAttributes(const char* const attribsCString)
    {
        QString attributes(attribsCString);
        QVector<StelVertexAttribute> result;
        const QStringList parts = attributes.split(",");
        for(int part = 0; part < parts.size(); ++part)
        {
            result << StelVertexAttribute(parts.at(part));
        }

#ifndef NDEBUG
        validateAttributes(result);
#endif
        return result;
    }

private:
#ifndef NDEBUG




    static void validateAttributes(const QVector<StelVertexAttribute>& attributes)
    {
        bool vertex, texCoord, normal, color;
        vertex = texCoord = normal = color = false;
        
        // Ensure that every kind of vertex attribute is present at most once.
        foreach(const StelVertexAttribute& attribute, attributes)
        {
            switch(attribute.interpretation)
            {
                case AttributeInterpretation_Position:
                    Q_ASSERT_X(!vertex, Q_FUNC_INFO,
                               "Vertex type has more than one vertex position attribute");
                    vertex = true;
                    break;
                case AttributeInterpretation_TexCoord:
                    Q_ASSERT_X(attributeDimensions(attribute.type) == 2, Q_FUNC_INFO,
                               "Only 2D texture coordinates are supported at the moment");
                    Q_ASSERT_X(!texCoord, 
                               Q_FUNC_INFO,
                               "Vertex type has more than one texture coordinate attribute");
                    texCoord = true;
                    break;
                case AttributeInterpretation_Normal:
                    Q_ASSERT_X(attributeDimensions(attribute.type) == 3, Q_FUNC_INFO,
                               "Only 3D vertex normals are supported");
                    Q_ASSERT_X(!normal, Q_FUNC_INFO,
                               "Vertex type has more than one normal attribute");
                    normal = true;
                    break;
                case AttributeInterpretation_Color:
                    Q_ASSERT_X(!color, Q_FUNC_INFO,
                               "Vertex type has more than one color attribute");
                    color = true;
                    break;
                default:
                    Q_ASSERT_X(false, Q_FUNC_INFO,
                               "Unknown vertex attribute interpretation");
            }
        }

        Q_ASSERT_X(vertex, Q_FUNC_INFO, 
                   "Vertex formats without a position attribute are not supported");
    }
#endif
};

#define VERTEX_ATTRIBUTES(...)\
    static const QVector<StelVertexAttribute>& attributes()\
    {\
        static QVector<StelVertexAttribute> attribs =\
            StelVertexAttribute::parseAttributes(#__VA_ARGS__);\
        return attribs;\
    }

#endif // _STELVERTEXATTRIBUTE_HPP_