VRS - The Virtual Rendering System

version 3.3

vertexattributebufferobjectgl.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * 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 Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: vertexattributebufferobjectgl.h 6662 2009-02-20 08:54:23Z Amir_Semmo $
// $Date: 2009-02-20 09:54:23 +0100 (Fri, 20 Feb 2009) $
// $Revision: 6662 $
// $State$
// $Author: Amir_Semmo $
//
// $Log$
// Revision 1.21  2005/01/03 01:43:10  klimetschek
// - modified win32 project layout, splitted vrs.vcproj into vrs_container, vrs_core, vrs_sg, vrs_image, vrs_opengl and vrs_io
// - removed vrs.vcproj
// minor things:
// - added all glutexamples to vrs4glut.sln
// - fixed some problems in glutexamples
// - removed all project references from all VS projects (using solution wide project dependencies instead)
//
// Revision 1.20  2004/12/03 16:31:41  buchholz
// clone methods added
//
// Revision 1.19  2004/11/03 14:45:07  saar
// Class comment changed (Doxygen style)
//
// Revision 1.18  2004/10/11 09:26:39  buchholz
// changed static_cast<T*> to static_cast<const T*> in mapAttributePointer()
//
// Revision 1.17  2004/06/24 17:12:22  baumann
// fixes for MAC OS X
//
// Revision 1.16  2004/03/12 16:28:41  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.15  2004/01/19 11:43:58  baumann
// serialization mechanism improved
//
// Revision 1.14  2003/12/09 14:56:54  buchholz
// serialization for self-contained buffer-objects added
//
// Revision 1.13  2003/11/24 10:38:18  baumann
// - general code cleanup
// - new method replace() added
//
// Revision 1.12  2003/11/10 15:39:45  baumann
// added some methods with argument std::vector<T> (in addition to Iterator<T>*)
//
// Revision 1.11  2003/09/29 17:28:16  kirsch
// temporarily deactivated GLhalf
//
// Revision 1.10  2003/06/18 09:13:10  baumann
// #include <vrs/vector.h> added
//
// Revision 1.9  2003/05/20 13:36:50  kirsch
// fixed memory leak if data from a provided iterator is copied into a static array
//
// Revision 1.8  2003/05/15 10:03:57  baumann
// - new class VertexData<DIM, T> added
// - class Color is now derived from VertexData<4, double>
// - renamed method Color::rep() to Color::pointer()
// - class Vector is now derived from VertexData<3, double>
// - renamed method Vector::rep() to Vector::pointer()
// - class VertexAttributeGL<DIM, T> removed
//
// Revision 1.7  2003/04/22 15:07:59  kirsch
// gcc: fixed member templates
//
// Revision 1.6  2003/04/22 11:50:56  baumann
// bug fix: linker problem for getComponents() and getComponentType() fixed
//
// Revision 1.5  2003/04/13 15:34:40  baumann
// added forward declarations for Vector and Color
//
// Revision 1.4  2003/04/04 08:02:09  baumann
// comments added
//
// Revision 1.3  2003/04/02 09:19:46  baumann
// - methods copyIntoVectorIterator() and copyIntoColorIterator() added
// - bug fix: method update()
//
// Revision 1.2  2003/04/02 06:55:50  baumann
// interface improved
//
// Revision 1.1  2003/03/31 17:00:14  baumann
// initial version of BufferObjectGL and VertexAttributeBufferObjectGL
//

#ifndef VRS_OPENGL_VERTEXATTRIBUTEBUFFEROBJECTGL_H
#define VRS_OPENGL_VERTEXATTRIBUTEBUFFEROBJECTGL_H

#include <vrs/vector.h>
#include <vrs/vertexdata.h>
#include <vrs/container/staticarray.h>
#include <vrs/opengl/bufferobjectgl.h>
#include <vrs/opengl/openglconfig.h>
#include <vector>

namespace VRS {

class Color;

class VRS_CORE_API BaseVertexAttributeBufferObjectGL : public BufferObjectGL {
public:
    virtual GLenum componentType() const = 0;
    virtual UINT components() const = 0;
    virtual UINT elements() const = 0;

    Iterator<Vector>* copyIntoVectorIterator() const;
    Iterator<Color>* copyIntoColorIterator() const;
    Iterator<unsigned int>* copyIntoIndexIterator() const;

    virtual SO<BaseVertexAttributeBufferObjectGL> clone(EngineGL* engine, UsagePattern usagePattern) = 0;

    virtual SO<BaseVertexAttributeBufferObjectGL> clone(EngineGL* engine, UINT elements, UsagePattern usagePattern) = 0;

    VRS_TYPEINFO(BaseVertexAttributeBufferObjectGL, BufferObjectGL);
    VRS_SERIALIZABLE_ABSTRACT_CLASS(BaseVertexAttributeBufferObjectGL);

protected:
    BaseVertexAttributeBufferObjectGL(EngineGL* engine, UINT bytes, const void* pointer,
                                      DataType type, UsagePattern usage)
        : BufferObjectGL(engine, bytes, pointer, type, usage) {
    }
    BaseVertexAttributeBufferObjectGL(UINT bytes, void* pointer, SharedObj* owner = NULL)
        : BufferObjectGL(bytes, pointer, owner) {
    }
}; // class BaseVertexAttributeBufferObjectGL

template<typename T>
class VertexAttributeBufferObjectGL : public BaseVertexAttributeBufferObjectGL {
public:
    VertexAttributeBufferObjectGL(EngineGL* engine, UINT elements,
                                  DataType type, UsagePattern usagePattern);
    VertexAttributeBufferObjectGL(EngineGL* engine, Iterator<T>* iter,
                                  DataType type, UsagePattern usagePattern);
    VertexAttributeBufferObjectGL(EngineGL* engine, const std::vector<T>& values,
                                  DataType type, UsagePattern usagePattern);
    // This constructor does NOT copy the content of the iterator!!!
    VertexAttributeBufferObjectGL(Iterator<T>* iter);
    virtual ~VertexAttributeBufferObjectGL();

    virtual GLenum componentType() const { return getComponentType(static_cast<T*>(NULL)); }
    virtual UINT   components()    const { return getComponents(static_cast<T*>(NULL)); }
    virtual UINT   elements()      const { return (bytes() / sizeof(T)); }

    T*       mapAttributePointer(MapAccess access)       { return static_cast<T*>(mapPointer(access)); }
    const T* mapAttributePointer(MapAccess access) const { return static_cast<const T*>(mapPointer(access)); }
    bool     unmapAttributePointer()               const { return unmapPointer(); }
    bool     attributePointerIsMapped()            const { return pointerIsMapped(); }
    void update(Iterator<T>* iter, UINT offset = 0);
    void update(const std::vector<T>& values, UINT offset = 0);
    void replace(Iterator<T>* iter);
    void replace(const std::vector<T>& values);
    virtual SO<BaseVertexAttributeBufferObjectGL> clone(EngineGL* engine, UsagePattern usagePattern);
    virtual SO<BaseVertexAttributeBufferObjectGL> clone(EngineGL* engine, UINT elements, UsagePattern usagePattern);

    VRS_TYPEINFO(VertexAttributeBufferObjectGL, BaseVertexAttributeBufferObjectGL);
    VRS_SERIALIZABLE(VertexAttributeBufferObjectGL);

protected:
    static UINT getComponents(const GLubyte*  /* dummy */) { return 1; }
    static UINT getComponents(const GLbyte*   /* dummy */) { return 1; }
    static UINT getComponents(const GLushort* /* dummy */) { return 1; }
    static UINT getComponents(const GLshort*  /* dummy */) { return 1; }
    static UINT getComponents(const GLuint*   /* dummy */) { return 1; }
    static UINT getComponents(const GLint*    /* dummy */) { return 1; }
#ifdef __APPLE__
    //static UINT getComponents(const unsigned int* /* dummy */) { return 1; } // Mac OSX: GLuint is a typedef of "unsigned long"!
    //static UINT getComponents(const int*          /* dummy */) { return 1; } // Mac OSX: GLint is a typedef of "long"!
#endif // __APPLE__
    static UINT getComponents(const GLfloat*  /* dummy */) { return 1; }
    static UINT getComponents(const GLdouble* /* dummy */) { return 1; }
    //static UINT getComponents(const GLhalf*   /* dummy */) { return 1; }
    static UINT getComponents(const bool*     /* dummy */) { return 1; }
    template<unsigned int DIM, typename TYPE>
    static UINT getComponents(const VertexData<DIM, TYPE>* /* dummy */) { return DIM; }

    static GLenum getComponentType(const GLubyte*  /* dummy */) { return GL_UNSIGNED_BYTE; }
    static GLenum getComponentType(const GLbyte*   /* dummy */) { return GL_BYTE; }
    static GLenum getComponentType(const GLushort* /* dummy */) { return GL_UNSIGNED_SHORT; }
    static GLenum getComponentType(const GLshort*  /* dummy */) { return GL_SHORT; }
    static GLenum getComponentType(const GLuint*   /* dummy */) { return GL_UNSIGNED_INT; }
    static GLenum getComponentType(const GLint*    /* dummy */) { return GL_INT; }
#ifdef __APPLE__
    //static GLenum getComponentType(const unsigned int* /* dummy */) { return GL_INT; } // Mac OSX: GLuint is a typedef of "unsigned long"!
    //static GLenum getComponentType(const int*          /* dummy */) { return GL_UNSIGNED_INT; } // Mac OSX: GLint is a typedef of "long"!
#endif // __APPLE__
    static GLenum getComponentType(const GLfloat*  /* dummy */) { return GL_FLOAT; }
    static GLenum getComponentType(const GLdouble* /* dummy */) { return GL_DOUBLE; }
    //static GLenum getComponentType(const GLhalf*   /* dummy */) { return GL_HALF_FLOAT_NV; }
    static GLenum getComponentType(const bool*     /* dummy */) { return GL_UNSIGNED_BYTE; }
    template<unsigned int DIM, typename TYPE>
    static GLenum getComponentType(const VertexData<DIM, TYPE>* /* dummy */) { return getComponentType(static_cast<TYPE*>(NULL)); }

private:
    VertexAttributeBufferObjectGL();   // only for persistency.
    NonPersistentStaticArray<T>* data_; // temporary data that must be deleted
}; // class VertexAttributeBufferObjectGL<T>

} // namespace VRS

#include <vrs/opengl/vertexattributebufferobjectgl.tli>

#endif // VRS_OPENGL_VERTEXATTRIBUTEBUFFEROBJECTGL_H

---

Generated on Thu May 23 06:00:21 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact