StelQGLArrayVertexBufferBackend.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 _STELQGLARRAYVERTEXBUFFERBACKEND_HPP_
#define _STELQGLARRAYVERTEXBUFFERBACKEND_HPP_

#include "VecMath.hpp"
#include "StelProjectorType.hpp"
#include "StelVertexBuffer.hpp"
#include "StelVertexBufferBackend.hpp"
#include "StelVertexAttribute.hpp"


class StelQGLArrayVertexBufferBackend : public StelVertexBufferBackend
{
public:
    virtual ~StelQGLArrayVertexBufferBackend();

    virtual void addVertex(const void* const vertexInPtr);

    virtual void getVertex(const int index, void* const vertexOutPtr) const;

    virtual void setVertex(const int index, const void* const vertexInPtr)
    {
        setVertexNonVirtual(index, vertexInPtr);
    }

    virtual void lock()
    {
        locked = true;
    }

    virtual void unlock()
    {
        locked = false;
    }

    virtual void clear()
    {
        vertexCount = 0;
    }

    void projectVertices(StelProjector* projector, 
                         class StelQGLIndexBuffer* indexBuffer);

    int length() const
    {
        return vertexCount;
    }

    PrimitiveType getPrimitiveType() const
    {
        return primitiveType;
    }

protected:
    bool locked;

    PrimitiveType primitiveType;

    int vertexCount;

    int vertexCapacity;

    void* attributeBuffers[AttributeInterpretation_MAX];

    bool usingProjectedPositions;

    Vec3f* projectedPositions;

    int projectedPositionsCapacity;

    StelQGLArrayVertexBufferBackend(const PrimitiveType type,
                                    const QVector<StelVertexAttribute>& attributes);

private:

    void setVertexNonVirtual(const int index, const void* const vertexInPtr)
    {
        // Points to the current attribute (e.g. color, normal, vertex) within the vertex.
        const unsigned char* attribPtr = static_cast<const unsigned char*>(vertexInPtr);
        for(int attrib = 0; attrib < attributes.count; ++attrib)
        {
            const AttributeInterpretation interpretation = 
                attributes.attributes[attrib].interpretation;
            //Set each attribute in its buffer.
            switch(attributes.attributes[attrib].type)
            {
                case AttributeType_Vec2f:
                    getAttribute<Vec2f>(interpretation, index) 
                        = *reinterpret_cast<const Vec2f*>(attribPtr);
                    break;
                case AttributeType_Vec3f:
                    getAttribute<Vec3f>(interpretation, index) 
                        = *reinterpret_cast<const Vec3f*>(attribPtr);
                    break;
                case AttributeType_Vec4f:
                    getAttribute<Vec4f>(interpretation, index) 
                        = *reinterpret_cast<const Vec4f*>(attribPtr);
                    break;
                default:
                    Q_ASSERT(false);
            }

            // This always works, because the C standard requires that 
            // sizeof(unsigned char) == 1  (that 1 might mean e.g. 16 bits instead of 8
            // on some platforms, but both the size of attribute and of unsigned char is 
            // measured in the same unit, so it's not a problem.
            attribPtr += attributes.sizes[attrib];
        }
    }

    template<class A>
    A& getAttribute(const AttributeInterpretation interpretation, const int vertexIndex) 
    {
        return static_cast<A*>(attributeBuffers[interpretation])[vertexIndex];
    }

    template<class A>
    const A& getAttributeConst(const AttributeInterpretation interpretation, const int vertexIndex) const
    {
        return static_cast<A*>(attributeBuffers[interpretation])[vertexIndex];
    }

    int getAttributeIndex(const AttributeInterpretation interpretation) const;
};

#endif // _STELQGLARRAYVERTEXBUFFERBACKEND_HPP_