StelIndexBuffer.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 _STELINDEXBUFFER_HPP_
#define _STELINDEXBUFFER_HPP_


#include <QtGlobal>


enum IndexType
{
    IndexType_U16,
    IndexType_U32
};

class StelIndexBuffer
{
public:
    virtual ~StelIndexBuffer(){}
    
    void addIndex(const uint index)
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO,
                   "Trying to set an index in a locked index buffer");
        Q_ASSERT_X(indexType_ == IndexType_U32 || index < 65536, Q_FUNC_INFO,
                   "Trying to add a 16-bit index with value greater than 65536");

        addIndex_(index);
        ++indexCount_;
    }

    uint getIndex(const int which) const 
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO,
                   "Trying to get an index from a locked index buffer");
        Q_ASSERT_X(which < indexCount_, Q_FUNC_INFO, 
                   "Index to an index buffer element out of bounds");
        return getIndex_(which);
    }

    void setIndex(const int which, const uint index)
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO,
                   "Trying to set an index in a locked index buffer");
        Q_ASSERT_X(which < indexCount_, Q_FUNC_INFO, 
                   "Index to an index buffer element out of bounds");
        Q_ASSERT_X(indexType_ == IndexType_U32 || index < 65536, Q_FUNC_INFO,
                   "Trying to set a 16-bit index to a value greater than 65536");
        setIndex_(which, index);
    }

    void clear()
    {
        Q_ASSERT_X(!locked_, Q_FUNC_INFO, "Trying to clear a locked index buffer");
        clear_();
        indexCount_ = 0;
    }

    void lock()
    {
        locked_ = true;
        lock_();
    }

    void unlock()
    {
        unlock_();
        locked_ = false;
    }

    bool locked() const 
    {
        return locked_;
    }

    IndexType indexType() const
    {
        return indexType_;
    }

    int length() const
    {
        return indexCount_;
    }

protected:
    const IndexType indexType_;

    StelIndexBuffer(IndexType indexType)
        : indexType_(indexType)
        , locked_(false)
        , indexCount_(0)
    {
    }

    virtual void addIndex_(const uint index) = 0;

    virtual uint getIndex_(const int which) const = 0;

    virtual void setIndex_(const int which, const uint index) = 0;

    virtual void clear_() = 0;

    virtual void lock_() = 0;

    virtual void unlock_() = 0;

private:
    bool locked_;

    int indexCount_;
};


#endif //_STELINDEXBUFFER_HPP_