StelVertexBuffer.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 _STELVERTEXBUFFER_HPP_
#define _STELVERTEXBUFFER_HPP_

#include "core/VecMath.hpp"
#include "StelVertexAttribute.hpp"
#include "StelVertexBufferBackend.hpp"


enum PrimitiveType
{
    PrimitiveType_Points,

    PrimitiveType_Triangles,

    PrimitiveType_TriangleStrip,

    PrimitiveType_TriangleFan,

    PrimitiveType_Lines, 

    PrimitiveType_LineStrip,

    PrimitiveType_LineLoop,
};

class StelAbstractVertexBuffer
{
public:
    virtual ~StelAbstractVertexBuffer(){};
};

template<class V> class StelVertexBuffer : public StelAbstractVertexBuffer
{
friend class StelRenderer;
friend class TestStelVertexBuffer;

public:
    ~StelVertexBuffer()
    {
        delete backend;
    }
    
    void addVertex(const V& vertex)
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO,
                   "Trying to add a vertex to a locked vertex buffer");
        backend->addVertex(static_cast<const void*>(&vertex));
        ++vertexCount;
    }
    
    V getVertex(const int index) const
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO,
                   "Trying to get a vertex in a locked vertex buffer");
        Q_ASSERT_X(index < vertexCount, Q_FUNC_INFO, "Vertex index out of bounds");
        // Using a char array instead of a V directly avoids calling the 
        // default constructor of V (which might not be defined, and the 
        // default-constructed data would be overwritten anyway)
        
        unsigned char storage[sizeof(V)];
        void* result = &storage[0];
        backend->getVertex(index, result);
        return *static_cast<V*>(result);
    }
    
    void setVertex(const int index, const V& vertex)
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO,
                   "Trying to set a vertex in a locked vertex buffer");
        Q_ASSERT_X(index < vertexCount, Q_FUNC_INFO, "Vertex index out of bounds");
        backend->setVertex(index, static_cast<const void*>(&vertex));
    }
    
    void lock() 
    {
        locked_ = true;
        backend->lock();
    }
    
    void unlock()
    {
        backend->unlock();
        locked_ = false;
    }
    
    bool locked() const
    {
        return locked_;
    }
    
    int length() const
    {
        return vertexCount;
    }

    PrimitiveType primitiveType() const 
    {
        return primitiveType_;
    }
    
    virtual void clear()
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO, "Trying to clear a locked vertex buffer");
        vertexCount = 0;
        backend->clear();
    }

private:
    StelVertexBuffer(StelVertexBufferBackend* backend, const PrimitiveType primitiveType)
        : locked_(false)
        , vertexCount(0)
        , primitiveType_(primitiveType)
        , backend(backend)
    {
        backend->validateVertexType(sizeof(V));
    }
    
    bool locked_;
    
    int vertexCount;

    PrimitiveType primitiveType_;
    
    StelVertexBufferBackend* backend;
};

#endif // _STELVERTEXBUFFER_HPP_