VRS - The Virtual Rendering System

version 3.3

texturedbatchtreegl.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: texturedbatchtreegl.h 6549 2008-11-18 16:13:03Z Henrik_Buchholz $
//
// $Log$
// Revision 1.2  2006/04/03 08:14:37  buchholz
// stateset management added
//
// Revision 1.1  2006/02/08 13:02:01  buchholz
// first check-in
//

#ifndef VRS_OPENGL_TEXTUREDBATCHTREEGL_H
#define VRS_OPENGL_TEXTUREDBATCHTREEGL_H

#include <vrs/shape.h>
#include <vrs/opengl/imagetexture2dgl.h> // necessary to avoid compiler errors when array is included earlier
#include <vrs/opengl/batchtreegl.h>      //

namespace VRS {

    class BatchTreeGL;
    class PolygonSet;
    class ImageTexture2DGL;
    template<typename T> class HashTable;
    template<typename T> class Iterator;
    template<typename T> class Array;
    template<typename T> class StaticArray;
    template<typename K, typename V> class Dictionary;

    class VRS_CORE_API TexturedBatchTreeGL : public Shape {
    public:

        TexturedBatchTreeGL();

        enum TextureHint { TH_DISABLE_ATLAS, TH_ENABLE_ATLAS, TH_UNKNOWN };

        int insertShape(SO<PolygonSet> shape, SO<ImageTexture2DGL> texture = NULL, TextureHint hint = TH_UNKNOWN, int stateSetID = -1);

        SO<Iterator<int> > insertShapes(
            SO<Iterator<SO<PolygonSet> > > shapes, 
            SO<ImageTexture2DGL> texture = NULL, 
            TextureHint hint = TH_UNKNOWN,
            int stateSetID = -1
        );
        SO<Iterator<int> > insertShapes(
            SO<Iterator<SO<PolygonSet> > > shapes, 
            SO<Iterator<SO<ImageTexture2DGL> > > textures, 
            SO<Iterator<TextureHint> > hints,
            SO<Iterator<int> > stateSetIDs
        );
        
        bool removeShape(int id);

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


        SO<PolygonSet> extractShape(int index) const;

        SO<Iterator<int> > shapeIDs() const;

        SO<ImageTexture2DGL> getTexture(int index) const;

        virtual Bounds boundingBox() const;

        void setShapeVisibility(int index, bool visible);
        bool getShapeVisibility(int index) const;

        void optimize(int maxAtlasSize = 1024);

        unsigned int getMaximumBatchSize() const;
        void setMaximumBatchSize(unsigned int size = 0xffff);
        
        typedef Iterator<SO<RenderObj> > StateSet;


        int registerStateSet(SO<StateSet> stateSet, bool doNotUnify = false);

        SO<StateSet> getStateSet(int stateSetID) const;        
        bool unregisterStateSet(int stateSetID);

        void cleanUpStateSets();

        int getShapeStateSet(int shapeID) const;

        SO<Iterator<int> > getStateSetIDs() const;

        void changeStateSet(int shapeID, int newStateSetID, SO<ImageTexture2DGL> tex);
        void changeStateSets(
            SO<Iterator<int> > shapeIDs, 
            SO<Iterator<int> > newStateSetIDs, 
            SO<Iterator<SO<ImageTexture2DGL> > > textures = NULL
        );

        bool replaceStateSet(int stateSetIndex, SO<StateSet> stateSet);
        

        VRS_TYPEINFO(TexturedBatchTreeGL, Shape);
        VRS_SERIALIZABLE(TexturedBatchTreeGL);

    private:

        friend class TexturedBatchTreeSimplifierGL;
        friend class TexturedBatchTreeRayIntersectorGL;

        // rendering data: Contains a set of textures (atlas textures or original textures) and one or more combined shapes per texture
        SO<Dictionary<SO<ImageTexture2DGL>, SO<Array<SO<BatchTreeGL> > > > > m_renderingData;
        
        // management structs
        struct VRS_CORE_API ShapeInfo {
            SO<BatchTreeGL> m_tree; // tree containing the shape
            int m_internalShapeID;  // id to address the shape within m_tree
            SO<PolygonSet> m_hiddenGeometry; // if m_tree is NULL, the shape is currently invisible and
                                             // stored in this member
            
            VRS_SERIALIZABLE_NO_SO_CLASS(ShapeInfo);
        };
        
        struct AtlasImage : public SharedObj {
            SO<ImageTexture2DGL> m_atlas;
            SO<Array<SO<ImageTexture2DGL> > > m_replacedOriginalTextures;
            SO<Array<Matrix> > m_texCoordTransforms; // contains the texture coordinate matrix for each replaced texture
            int m_texturesUsedForCreation;  // Since m_replacedOriginalTextures contains only those textures replaced by the atlas
                                            // that are currently still in use, m_texturesUsedForCreation indicates how many    
                                            // textures were used initially.
            VRS_TYPEINFO(AtlasImage, SharedObj);
            VRS_SERIALIZABLE(AtlasImage);
        };

        // management data structures
        SO<Dictionary<int, ShapeInfo> > m_index2Shape;
        SO<HashTable<SO<ImageTexture2DGL> > > m_atlasEnabled; // all stored textures are allowed to be replaced by atlases
        SO<Dictionary<SO<ImageTexture2DGL>, SO<AtlasImage> > > m_tex2Atlas;
            // contains all original textures that are currently replaced by atlases. These are mapped
            // to information about the related texture atlases.
        SO<Dictionary<SO<ImageTexture2DGL>, SO<Array<SO<BatchTreeGL> > > > > m_tex2Geometry; 
            // contains all original textures as keys and maps them to the related geometry. 
            // Note: m_tex2Geometry stores the original textures that might not currently be
            //       part of the current rendering data, since m_textures might contain
            //       a texture implicitly as a part of a texture atlas.
        SO<Dictionary<SO<BatchTreeGL>, SO<Array<int> > > > m_tree2HiddenShapes;
            // contains for each BatchTreeGL an array of shapes that are currently set to invisible
        SO<Dictionary<std::pair<SO<BatchTreeGL>, int>, int> > m_internalID2ExternalID;
            // maps batchtrees with internal shape ids to external shape ids (needed for rayintersection)

        SO<Dictionary<SO<BatchTreeGL>, int> > m_tree2StateSet;
            // contains for each batchtree the stateset determining its appearance. statesets may be shared by several trees.
        SO<Dictionary<int, SO<StateSet> > > m_id2StateSet;
            // stores all currently registered state sets
        SO<HashTable<int> > m_lockedStateSets; 
            // indicates which statesets must not be unified with other statesets
        
        int m_nextShapeID; // running counters for unique shape/stateset ids
        int m_nextStateSetID; 

        Bounds m_bounds;
        bool m_boundsValid;
        int m_maxBatchSize;        

        int createNewShapeID();

        void registerShapes(
            SO<Iterator<SO<PolygonSet> > > allNewShapes,
            SO<Iterator<int> > allNewShapeIDs,
            SO<Iterator<int> > shapeNums,
            SO<BatchTreeGL> target,
            SO<ImageTexture2DGL> texture
        );
        void resolveTextureAtlas(SO<AtlasImage> atlas);
        
        SO<Iterator<int> > insertShapesImpl(
            SO<Iterator<SO<PolygonSet> > > shapes, 
            SO<StaticArray<int> > newShapeIDs,
            SO<ImageTexture2DGL> texture = NULL, 
            TextureHint hint = TH_UNKNOWN,
            int stateSetID = -1
        );        
        SO<Iterator<int> > insertShapesImpl(
            SO<Iterator<SO<PolygonSet> > > shapes, 
            SO<StaticArray<int> > newShapeIDs,
            SO<Iterator<SO<ImageTexture2DGL> > > textures, 
            SO<Iterator<TextureHint> > hints,
            SO<Iterator<int> > stateSetIDs
        );
        
    };

} // namespace VRS

#endif // VRS_OPENGL_TEXTUREDBATCHTREEGL_H

---

Generated on Fri May 24 06:00:18 2013 by Doxygen 1.5.6

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