BVList.h

Go to the documentation of this file.

/* $Id: BVList.h,v 1.2 2002/11/05 14:31:15 anonymous Exp $ */

#ifndef __BV_LIST_H
#define __BV_LIST_H

#include <esg/List.h>
#include <esg/SceneGraphObject.h>
#include <esg/explorer/Explorer.h>

namespace esg {

class OGSCENE_EXPORT BVList {
public:
        enum SplitStrategy {
            SPLIT_BY_MAX_VARIATION, 
            SPLIT_BY_MAX_EXTENT
        };
    
protected:
        struct BVNode {
                SceneGraphObject* pObject;
                float*            handle;
                Interval*         extents;
                
                BVNode (unsigned s, SceneGraphObject* o = NULL) {
                    handle  = new float    [s];
                    extents = new Interval [s];
                    pObject = o;
                }
                
                ~BVNode () {
                    if (handle)  delete [] handle;
                    if (extents) delete [] extents;
                }
                
                void __debug() { if (pObject) pObject->__debug(); }
        };
    
        List<BVNode> * _pList;
        unsigned       _dirs;
        const float  (*_dirMat)[3];  // matrix of direction

protected: // methods and attribute used for qsort()
        static unsigned qsortIndex;
        static int qsortCompare (const void*, const void*);

protected:
        /*
         * split list by handles using median
         */
        void _split_by_handles (List<BVNode>&      /* src */,
                                List<BVNode>&      /* dst */,
                                unsigned           /* split dir */);

        /*
         * Precompute object extents and a handle of centroid
         */
        virtual void _comp_handle  (BVNode*);
        virtual void _comp_extents (BVNode*);

        /*
         * Extent splitting strategy taken from POV-Ray 3.5
         */
        unsigned _index_with_max_extent ();
        void     _build_area_table      (BVNode**, long, long, double*) const;
        unsigned _split_by_extent       (List<BVNode>&);
        
        /*
         * Splitting strategy using maximal variation + median
         */
        unsigned _index_with_max_variation ();
        unsigned _split_by_variation (List<BVNode>&);
    
public:
        BVList (unsigned s, const float (*m)[3]);

        virtual ~BVList ();

        void append (SceneGraphObject* o);

        SceneGraphObject* remove (SceneGraphObject*);

        unsigned length () const { return _pList->length(); }

        unsigned split (BVList& list, SplitStrategy splitStrategy);

        SceneGraphObject* firstItem () {
            BVNode* pN = _pList->firstItem();
            return ((pN) ? pN->pObject : NULL);
        }

        SceneGraphObject* nextItem () {
            BVNode* pN = _pList->nextItem();
            return ((pN) ? pN->pObject : NULL);
        }

        SceneGraphObject* iThItem (unsigned i, bool setAct) {
            BVNode* pN = _pList->iThItem(i, setAct);
            return ((pN) ? pN->pObject : NULL);
        }


        virtual void __debug() { _pList->__debug(); }
};

}; // namespace

#endif // __BV_LIST_H

---