core/kgllib/geometrybuffer.h

/*
 * Copyright (C) 2008 Rivo Laks <rivolaks@hot.ee>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef KGLLIB_GEOMETRYBUFFER_H
#define KGLLIB_GEOMETRYBUFFER_H

#include "kgllib.h"

#include <Eigen/Core>


namespace KGLLib
{

class KGLLIB_EXPORT GeometryBufferFormat
{
public:
    enum Format
    {
        Vertex3   = 1 << 0,
        Vertex4   = 1 << 1,
        Color3    = 1 << 2,
        Color4    = 1 << 3,
        Normal3   = 1 << 4,
        Normal    = Normal3,
        TexCoord2 = 1 << 5
    };

    GeometryBufferFormat();
    GeometryBufferFormat(int vertexCount, int indexCount = 0);
    GeometryBufferFormat(Format fmt, int vertexCount, int indexCount = 0);

    void addVertices(int size)  { mVertexSize = size; }
    void addNormals()  { mNormalSize = 3; }
    void addColors(int size)  { mColorSize = size; }
    void addTexCoords(int size)  { mTexCoordSize = size; }

    int vertexSize() const  { return mVertexSize; }
    int colorSize() const  { return mColorSize; }
    int normalSize() const  { return mNormalSize; }
    int texCoordSize() const  { return mTexCoordSize; }

    int vertexCount() const  { return mVertexCount; }
    void setVertexCount(int count);
    int indexCount() const  { return mIndexCount; }
    void setIndexCount(int count);

    bool isIndexed() const  { return mIndexCount > 0; }

protected:
    void init(int vertexCount, int indexCount);

private:
    int mVertexCount;
    int mIndexCount;

    int mVertexSize;
    int mColorSize;
    int mNormalSize;
    int mTexCoordSize;  // TODO: support multiple texcoords
    // TODO: support vertex attributes
};


class KGLLIB_EXPORT GeometryBuffer
{
public:
    static GeometryBuffer* createBuffer(const GeometryBufferFormat& format);
    static GeometryBuffer* createBuffer(GeometryBufferFormat::Format format, int vertexCount, int indexCount = 0);


    virtual ~GeometryBuffer();

    virtual void render();
    virtual void renderIndexed(int indices, int offset) = 0;
    virtual void render(int vertices, int offset) = 0;

    virtual bool bind()  { return true; }
    virtual bool unbind()  { return true; }

    void addVertices(void* vertices, int count, int offset = 0);
    void addColors(void* colors, int count, int offset = 0);
    void addNormals(void* normals, int count, int offset = 0);
    void addTexCoords(void* texcoords, int count, int offset = 0);
    virtual void addIndices(unsigned int* indices, int count, int offset = 0) = 0;

    virtual void setPrimitiveType(GLenum type);
    GLenum primitiveType() const  { return mPrimitiveType; }

    const GeometryBufferFormat& format() const  { return mFormat; }

protected:
    GeometryBuffer(const GeometryBufferFormat& format);

    virtual void init(const GeometryBufferFormat& format);

    int bufferSize() const;
    int indexBufferSize() const;

    virtual void addData(void* data, int size, int offset) = 0;

protected:
    struct AttributeData
    {
        AttributeData(int _size, int _offset, int _stride)
        {
            size = _size;
            offset = _offset;
            stride = _stride;
        }
        AttributeData()
        {
            size = offset = stride = 0;
        }

        // Size of a single element, in bytes
        int size;
        // Offset of the first element in the buffer
        int offset;
        // Number of bytes between two consecutive elements
        int stride;
    };

    GLenum mPrimitiveType;
    GeometryBufferFormat mFormat;

    AttributeData mVertexData;
    AttributeData mColorData;
    AttributeData mNormalData;
    AttributeData mTexCoordData;
};

class GeometryBufferVertexArray : public GeometryBuffer
{
public:
    GeometryBufferVertexArray(const GeometryBufferFormat& format);
    virtual ~GeometryBufferVertexArray();

    virtual bool bind();
    virtual bool unbind();

    virtual void renderIndexed(int indices, int offset);
    virtual void render(int vertices, int offset);

    virtual void addIndices(unsigned int* indices, int count, int offset = 0);

protected:
    // FIXME: ugly
    GeometryBufferVertexArray(const GeometryBufferFormat& format, bool createArrays);

    virtual void createArrays();
    virtual void addData(void* data, int size, int offset);

private:
    char* mBuffer;
    char* mIndexBuffer;
};

class GeometryBufferVBO : public GeometryBufferVertexArray
{
public:
    GeometryBufferVBO(const GeometryBufferFormat& format);
    virtual ~GeometryBufferVBO();

    virtual bool bind();
    virtual bool unbind();

    virtual void addIndices(unsigned int* indices, int count, int offset = 0);

protected:
    virtual void createArrays();
    virtual void addData(void* data, int size, int offset);

private:
    GLuint mVBOId, mIndexVBOId;
};

}

#endif