VRS - The Virtual Rendering System

version 3.3

triangleset.h

Go to the documentation of this file.

#ifndef VRS_TRIANGLESET_H
#define VRS_TRIANGLESET_H

#include <vrs/shape.h>
#include <vrs/container/dictionary.h>
#include <vrs/container/dataiterator.h>
#include <vrs/opengl/bufferobjectgl.h>
#include <vrs/vertexattributemap.h>
#include <vrs/opengl/vertexattributebufferobjectgl.h>
#include <vrs/opengl/vertexattributedatagl.h>
#include <vrs/opengl/vertexattributeindexgl.h>

/* TODOs:
        -Consider and handle range updates of contained data. May however be better to assume
         this to be handled by clients via retreive iterator -> modify data -> set data to iterator.

        -Is clone still applicable since the triangle set takes ownership of any data? Instancing?

        -Doing a double copy upon recovery from video ram right now. Fix this.

        -Fix serialization.

        -Consider improving the on the fly conversion of vectors into VDs when copying.

        -Consider 'custom' buffer objects.

        -Make state flags protected.

        -Iterators vs DataIterators as return types for getters.
*/
namespace VRS { 

class VRS_CORE_API TriangleSet : public Shape {
public:
    typedef VertexData<4, float> VD;
    TriangleSet(
        SO<Iterator<VD> > vertices = NULL, 
        SO<Iterator<UINT> > indices = NULL
    );
    TriangleSet(
        SO<Iterator<Vector> > vertices, 
        SO<Iterator<UINT> > indices = NULL
    );
   
    void clear();  
    //SO<TriangleSet> clone() const;
    SO<TriangleSet> copy() const;
    SO<DataIterator<VD> > vertices() const;
    void copyVertices(const Iterator<VD>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void copyVertices(const Iterator<Vector>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void setVertices(SO<DataIterator<VD> > vertIter);
    SO<DataIterator<VD> > normals() const;
    void copyNormals(const Iterator<VD>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void copyNormals(const Iterator<Vector>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void setNormals(SO<DataIterator<VD> > normalIter);
    SO<DataIterator<VD> > colors() const;
    void copyColors(const Iterator<VD>* sourceColors /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void copyColors(const Iterator<Color>* sourceColors /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void setColors(SO<DataIterator<VD> > colorIter); 
    SO<DataIterator<VD> > texCoords(const UINT index) const;
    void copyTexCoords(const UINT index, const Iterator<VD>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void copyTexCoords(const UINT index, const Iterator<Vector>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void setTexCoords(UINT index, SO<DataIterator<VD> > texCoordIter);
    SO<DataIterator<UINT> > indices() const;
    void copyIndices(const Iterator<UINT>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ );
    void setIndices(SO<DataIterator<UINT> > indexIter);
    SO<DataIterator<UINT> > objectIDs() const;
    void copyObjectIDs(const Iterator<UINT>* /*, UINT rangeBegin = UINT_MAX, UINT rangeEnd = UINT_MAX*/ ); 
    void setObjectIDs(SO<DataIterator<UINT> > objectIdIter);    
    SO<DataIterator<VD> > vertexData(const ID& vertexDataID) const;
    void copyVertexData(
        const ID& vertexDataID, 
        const Iterator<VD>* sourceData /*, 
        UINT rangeBegin = UINT_MAX,
        UINT rangeEnd = UINT_MAX*/
    );
    void copyVertexData(
        const ID& vertexDataID,
        const Iterator<Vector>* sourceData /*, 
        UINT rangeBegin = UINT_MAX,
        UINT rangeEnd = UINT_MAX*/
    );
    void copyVertexData(
        const ID& vertexDataID,
        const Iterator<Color>* sourceData /*, 
        UINT rangeBegin = UINT_MAX,
        UINT rangeEnd = UINT_MAX*/
    );
    void setVertexData(const ID& vertexDataID, SO<DataIterator<VD> > iter);
    enum VertexDataConfigFlags {
        VD_ENABLE_VRAM = 0x1,
        VD_ENABLE_SOURCE_ELIMINATION = 0x2,
        VD_CONFIG_MASK = VD_ENABLE_SOURCE_ELIMINATION | VD_ENABLE_VRAM,

    };
    
    void lock(UINT configFlags = VD_ENABLE_VRAM);
    void lock(const ID& vertexDataID, UINT configFlags = VD_ENABLE_VRAM);
    void lockIndices(UINT configFlags = VD_ENABLE_VRAM);
    void unlock();
    void unlock(const ID& vertexDataID);
    void unlockIndices();
    SO<Iterator<ID> > vertexDataIDs() const;
    static UINT maxTexCoordSets();

    virtual void setBoundingBox(const Bounds& newBBox);
    virtual Bounds boundingBox() const;
    virtual void modified();

    void reportState(const char* triSetName = NULL);
    // TODO: needed by some static functions in trianglesetsimplifier.cpp, hence unfortunately public.
    // Figure out a better way to handle this.
    enum VertexDataStateFlags {
        VD_LOCK         = 0x4,
        VD_LOCKED       = 0x8,
        VD_UPDATE_ALL   = 0x10,
        VD_UPDATE_RANGE = 0x20,
        VD_DELETE       = 0x40,
        VD_CUSTOM       = 0x80,
        VD_UPDATE_MASK = VD_UPDATE_ALL | VD_UPDATE_RANGE,
        VD_STATE_MASK = VD_CUSTOM | VD_DELETE | VD_UPDATE_MASK | VD_LOCKED | VD_LOCK
    };

    VRS_TYPEINFO(TriangleSet, Shape);
    //VRS_SERIALIZABLE(TriangleSet);

protected:
    const ID& texCoordIdFromIndex(const UINT index) const;
    
    template<class T>
    class VertexDataEntry : public SharedObj {
    public:
        VertexDataEntry() 
            : m_data(NULL),
              m_bufferObject(NULL),
              /* m_updateRangeBegin(0),
                 m_updateRangeEnd(0), */
              m_flags(0),
              m_numElements(0) {
        }
        
        VertexDataEntry(SO<DataIterator<T> > data, UINT numElements) 
            : m_data(data), 
              m_bufferObject(NULL),
              /* m_updateRangeBegin(0),
                 m_updateRangeEnd(0), */
              m_numElements(numElements),
              m_flags(VD_UPDATE_ALL) {
        }
        
        SO<DataIterator<T> > m_data;
        SO<BaseVertexAttributeBufferObjectGL> m_bufferObject;
        UINT m_flags;
        UINT m_numElements; // Necessary to keep this info in case data is locked out of main ram,
        /* UINT m_updateRangeBegin; // Start of updated range
           UINT m_updateRangeEnd; // End of updated range */
    };

    // Source data in Main-RAM. Could be temporarly unloaded in case the
    // data is locked into VRAM without mirroring / with source elimination (see below).
    typedef SO<Dictionary<ID, SO<VertexDataEntry<VD> > > > VertexDataDictionary;
    VertexDataDictionary m_vertexData;
    SO<VertexDataEntry<UINT> > m_indexDataEntry;
    SO<DataIterator<UINT> > m_objectIdData;

    UINT m_configFlags;

    // These Objects hold or reference data for rendering. Individual buffer object
    // could link back to the source data in main RAM or could be in VRAM with the main
    // RAM data temporarily unloaded or mirrored.
    // The corresponding buffer objects are generated during render and the memory
    // trasferred to VRAM as needed depending on the lock-state of the given vertex data.
    // Data that has not been flagged as locked will be rendered directly from main ram.
    mutable SO<VertexAttributeDataGL> m_bufferObjectData;
    mutable SO<VertexAttributeIndexGL> m_bufferObjectIndex;

    mutable Bounds m_bbox;           
    mutable TransactionNo m_bboxValid;

    mutable TransactionNo m_bufferObjectUpdate;

    friend class TriangleSetSimplifierGL;

private:
    void Init();
};

} // namespace VRS

#endif

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

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