IteratorSDS.h

Go to the documentation of this file.

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

#ifndef __ITERATOR_SDS_H
#define __ITERATOR_SDS_H

#include <esg/Definitions.h>
#include <esg/Group.h>
#include <esg/SceneGraphObject.h>
#include <esg/iterator/Iterator.h>
#include <esg/geometry/Geometry.h>
#include <esg/spacesorting/SDS.h>
#include <esg/List.h>

/*
 * Iterator of space-sorting structure
 *
 * Protocol:
 *    IteratorSDS * it = space_sorting.createIterator();
 *    it->initRyaItersection();
 *       -or-
 *    it->initChildrenSearch();
 *       -...-
 *    it->firstChild();
 *    it->nextChild(); _UNTIL_NOT_NULL;
 *
 *    it->init...();
 *    it->firstChild();
 *    it->nextChild(); _UNTIL_NOT_NULL;
 *
 *    delete it;
 */

namespace esg {

class OGSCENE_EXPORT IteratorSDS : public Iterator {
public:
    enum Traverse {
        NONE,                // no traverse strategy is set
        RAY_INTERSECTION,    // intersection with ray
        HALF_SPACE,          // objects infering half-space
        AREA,                // objects infering enclosed space
        CHILDREN             // child by child
    };

protected:
    struct RIAttr { // attributes of "ray intersection" search
        Vector3      origin;
        Vector3      direction;
        PointEnv     iEnv;
        float        distLimit;
        const void*  parentElement;
        RIAttr(const Vector3& o, const Vector3& d, float l, const void* e)
            : origin(o), direction(d), distLimit(l), parentElement(e) {}
    };
    
    struct HSAttr { // attributes of "objects in half-space" search
        Vector3      origin;
        Vector3      direction;
        HSAttr(const Vector3& o, const Vector3& d)
            : origin(o), direction(d) {}
    };
    
    struct ARAttr { // attributes of "objects inside area" search 
        Geometry* area;
        ARAttr(Geometry* e) : area(e) {}
    };

protected:
    RIAttr*  _riAttr;   // attributes used by "ray intersection"
    HSAttr*  _hsAttr;   // attributes used by "objs in half-space" search
    ARAttr*  _arAttr;   // attributes used by "objects inside area" search
    Traverse _traverse; // type of traversal
    SDS*     _pAggregate;
    bool     _iterateTangible;

protected:
    virtual SceneGraphObject* _first_child (void) = 0;
    virtual SceneGraphObject* _next_child  (void) = 0;

public:    
    IteratorSDS (SDS* /* aggregate */);
    virtual ~IteratorSDS();

    /*
     * Initialization for different traversals.
     *
     * parentElement is element of spacial data structure which is
     * intersected by the given ray. If we now than some concrete element
     * is intersected then we can exploit this information to get faster
     * tests.
     */
    virtual void initRayIntersection (const Vector3& o /* ray's origin     */,
                                      const Vector3& d /* ray's direction  */,
                                      bool           clearCache,
                                      float          distLimit = MAXFLOAT,
                                      const void*    parentElement  = NULL);
    
    virtual void initHalfSpaceSearch (const Vector3& /* ray's origin */,
                                      const Vector3& /* ray's direction */);
    
    virtual void initAreaSearch      (Geometry*      /* area */);

    virtual void initChildrenSearch  (void);

    //    virtual bool      iteratesBVH     (void) const { return false; }
    //    virtual Geometry* delimitBoundary (void) const { return NULL; }
    
    // Methods for children traversal:
    virtual SceneGraphObject* firstChild (void);
    virtual SceneGraphObject* nextChild  (void);

    /*
     * This method returns pointer to an element of the inner ordering
     * tructure. Returned element is that containing the child successfully
     * returned in previous call of the firstChild() or nextChild().
     * Therefore it should be invoked after the firstChild() or nextChild().
     */
    virtual const void* lastExploitedElement (void) const { return NULL; }
};

}; // namespace

#endif // __ITERATOR_SDS_H

---