core/kgllib/batch.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_BATCH_H
#define KGLLIB_BATCH_H

#include "kgllib.h"
#include "geometrybuffer.h"
#include <QList>
#include <Eigen/Core>


namespace KGLLib
{
class GeometryBuffer;

class KGLLIB_EXPORT Batch
{
public:
    Batch();
    Batch(GeometryBuffer* buffer, int offset, int indexOffset);

    virtual ~Batch();

    virtual void render();

    virtual void bind();
    virtual void renderOnce();
    virtual void unbind();

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

    void setVertices(Eigen::Vector2f* vertices)  { setVertices(vertices, 2); }
    void setVertices(Eigen::Vector3f* vertices)  { setVertices(vertices, 3); }
    void setVertices(Eigen::Vector4f* vertices)  { setVertices(vertices, 4); }
    const void* verticesArray() const  { return mVertices; }
    void setColors(Eigen::Vector3f* colors)  { setColors(colors, 3); }
    void setColors(Eigen::Vector4f* colors)  { setColors(colors, 4); }
    const void* colorsArray() const  { return mColors; }
    void setNormals(Eigen::Vector3f* normals);
    const void* normalsArray() const  { return mNormals; }
    void setTexcoords(float* texcoords)  { setTexcoords(texcoords, 1); }
    void setTexcoords(Eigen::Vector2f* texcoords)  { setTexcoords(texcoords, 2); }
    void setTexcoords(Eigen::Vector3f* texcoords)  { setTexcoords(texcoords, 3); }
    void setTexcoords(Eigen::Vector4f* texcoords)  { setTexcoords(texcoords, 4); }
    const void* texcoordsArray() const  { return mTexcoords; }
    void setIndices(unsigned int* indices, int count);
    const void* indicesArray() const  { return mIndices; }
    int indicesCount() const  { return mIndexCount; }

    virtual void setPrimitiveType(GLenum type);
    GLenum primitiveType() const;

    virtual void update();

    GeometryBuffer* buffer() const  { return mBuffer; }
    void setBuffer(GeometryBuffer* buffer, int offset, int indexOffset);

    GeometryBufferFormat bestBufferFormat() const;

    static GeometryBuffer* createSharedBuffer(const QList<Batch*>& batches);

protected:
    void setVertices(void* vertices, int size);
    void setColors(void* colors, int size);
    void setTexcoords(void* texcoords, int size);

    void init();

private:
    // Pointers to corresponding arrays
    void* mVertices;
    void* mColors;
    void* mNormals;
    void* mTexcoords;
    // How many float components does each element have
    int mVertexSize;
    int mColorSize;
    int mNormalSize;
    int mTexcoordSize;
    // Indices array
    void* mIndices;

    int mVertexCount;
    int mIndexCount;

    bool mDirty;
    GLenum mPrimitiveType;

    GeometryBuffer* mBuffer;
    int mBufferOffset;
    int mBufferIndexOffset;
    bool mOwnBuffer;
};

}

#endif