VRS - The Virtual Rendering System

version 3.3

batchtreegl.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2005 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: batchtreegl.h 6014 2007-08-09 07:51:16Z Konstantin_Baumann $
//
// $Log$
// Revision 1.5  2006/03/01 16:30:38  baumann
// StaticArray<T> replaced by FixedSizeIterator<T>
//
// Revision 1.4  2006/03/01 15:56:49  baumann
// added m_primitiveType
//
// Revision 1.3  2006/02/08 13:02:26  buchholz
// transformTexCoords() method added
//
// Revision 1.2  2006/02/03 15:26:18  buchholz
// default batchsize set to 5000
//
// Revision 1.1  2006/02/03 15:15:30  buchholz
// first check-in
//

#ifndef VRS_OPENGL_BATCHTREEGL_H
#define VRS_OPENGL_BATCHTREEGL_H

#include <vrs/polygonset.h>

namespace VRS {


    class MappedVertexAttributeShapeGL;
    template<typename T> class Iterator;
    template<typename T> class FixedSizeIterator;
    template<typename K, typename V> class Dictionary;

    class VRS_CORE_API BatchTreeGL : public Shape {
    public:

        BatchTreeGL();

        int insertShape(SO<PolygonSet> shape);        

        SO<Iterator<int> > insertShapes(SO<Iterator<SO<PolygonSet> > > shapes);

        bool canBeInserted(SO<PolygonSet> shape) const;

        bool removeShape(int index);

        bool removeShapes(SO<Iterator<int> > indices);


        SO<PolygonSet> extractShape(int index) const;

        virtual Bounds boundingBox() const;


        unsigned int getMaximumBatchSize() const;
        void setMaximumBatchSize(unsigned int size = 5000);


        void transformTextureCoords(const Matrix& matrix);


        struct Node : public SharedObj {            
            SO<Node> m_children[2];
            SO<Node> m_parent;
            Bounds m_bounds;
            SO<MappedVertexAttributeShapeGL> m_geometry; // NULL for inner nodes
            SO<Iterator<int> > m_vertexRanges; 
            SO<Iterator<int> > m_indexRanges;             
            SO<Iterator<int> > m_shapeIDs;
                // the i-th value contains the end of the i-th range.
                // the #ranges-th element contains the length of the array
                // => the iterator length is #ranges + 1
                // All three iterators have equal length and related elements            
            int m_numVertices;

            VRS_TYPEINFO(Node, SharedObj);
            VRS_SERIALIZABLE(Node);
        };    
        
        VRS_TYPEINFO(BatchTreeGL, Shape);
        VRS_SERIALIZABLE(BatchTreeGL);

    private:

        friend class BatchTreeSimplifierGL;
        friend class BatchTreeRayIntersectorGL;

        
        // private structs and methods

        // Each shape is addressed by an integer index that is used as a key
        // to find the corresponding node and the range within the vertex array
        // that contains the triangles of the shape.
        struct VRS_CORE_API ShapeInfo {
            SO<Node> m_node;
            int m_rangeNumber; // the sub-shape number within the node
            VRS_SERIALIZABLE_NO_SO_CLASS(ShapeInfo);
        };
        
        // finds the best-suited node to insert a shape with given bounds
        SO<Node> findNode(const Bounds& bounds); 
        // inserts new shapes into a node and performs node splits if necessary
        // 'shapeNums' indicated which elements of 'shapes' are inserted.
        // 'newIDs' is filled with the assigned ids for each shape.
        void insertShapes(
            SO<Node> node, 
            SO<Iterator<SO<PolygonSet> > > shapes, 
            SO<Iterator<Bounds> > boundingBoxes,
            SO<Iterator<int> > shapeNums,
            SO<FixedSizeIterator<int> > newIDs
        );
        // builds the vertex array and the range iterators of a node and inserts the keys into m_index2Shape
        void buildSubNode(
            SO<Node> node, 
            SO<MappedVertexAttributeShapeGL> oldShapes,
            SO<Iterator<SO<PolygonSet> > > newShapes,
            SO<FixedSizeIterator<int> > newShapeIDs,
            SO<Iterator<int> > oldShapeNums,
            SO<Iterator<int> > newShapeNums,
            SO<Iterator<int> > oldVertexRanges,
            SO<Iterator<int> > oldIndexRanges,
            SO<Iterator<int> > oldShapeIDs
        );
        void updateBoundsAndNumVertices(SO<Node> leaf);
        void collapseNode(SO<Node> node);
        int generateNewID();

        // member variables
        int m_nextShapeID;
        unsigned int m_maxBatchSize;
        SO<Node> m_root;
        bool m_normalsStored;
        bool m_texCoordsStored;
        bool m_colorsStored;
        SO<Dictionary<int, ShapeInfo> > m_index2Shape;

        PolygonSet::PrimitiveType m_primitiveType;
    };

} // namespace VRS

#endif // VRS_OPENGL_BATCHTREEGL_H

---

Generated on Fri May 18 06:00:13 2012 by Doxygen 1.5.6

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