GU/GU_PrimGroupClosure.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Ondrej Kos
 *      Side Effects Software Inc.
 *      477 Richmond St. West
 *      Toronto, Ontario,  M5V 2M5 
 *      Canada
 *      416-504-9876
 *
 * NAME:        GU_PrimGroupClosure.h   
 *
 * COMMENTS:    A class to encapsulate the bit mask and point closure
 *              of a primitive group.
 *
 */

#ifndef __GU_PrimGroupClosure_h__
#define __GU_PrimGroupClosure_h__

#include "GU_API.h"
#include <UT/UT_BitArray.h>
#include <UT/UT_Assert.h>
#include <GB/GB_PrimGroupClosure.h>
#include <GEO/GEO_Primitive.h>
#include <GEO/GEO_Point.h>

class GU_Detail;

class GU_API GU_PrimGroupClosure : public GB_PrimGroupClosure
{
public:
    GU_PrimGroupClosure();
    GU_PrimGroupClosure(const GU_Detail *gdp, 
                        const char *group_name);
    virtual ~GU_PrimGroupClosure();

#define GU_CONTAINS_PRIM(prim) \
    UT_ASSERT_P(prim); \
    UT_ASSERT_P(myValid); \
    UT_ASSERT_P(myPrimGroup); \
    return myPrimGroup->contains(prim)

#define GU_CONTAINS_POINT(ppt) \
    UT_ASSERT_P(myValid); \
    return myPointArray(ppt->getNum())

    virtual bool containsBasePrim(const GB_Element *prim) const
            { GU_CONTAINS_PRIM(prim); }

    virtual bool containsBasePoint(const GB_Element *ppt) const
            { GU_CONTAINS_POINT(ppt); }

    // We could call the containsBase*() methods from the contains*() methods.
    // However, by not calling the virtuals there's a better chance that these
    // methods can be inlined.  So, we use macros instead.
    bool         containsPrim(const GEO_Primitive *prim) const
            { GU_CONTAINS_PRIM(prim); }

    bool        containsPoint(const GEO_Point *ppt) const
            { GU_CONTAINS_POINT(ppt); }
    bool        containsPoint(int ptnum) const
            {
                UT_ASSERT(myValid);
                return myPointArray(ptnum);
            }

    bool        isValid() const { return myValid; }

    // Refresh our bit array.  Call isValid() to determine whether
    // the bit array was successfully built.
    void        refresh(const GU_Detail *gdp,
                        const char *group_name,
                        bool shared_points_go_in_closure = true);

    const GB_PrimitiveGroup     *primGroup() const { return myPrimGroup; }
          GB_PrimitiveGroup     *primGroup()       { return myPrimGroup; }

private:
    GB_PrimitiveGroup   *myPrimGroup;

    UT_BitArray          myPointArray;  // a bit for each point, indicating
                                        // whether to draw it or not

    const GU_Detail     *myDetail;              // detail pointer
    int                  myDetailUniqueId;      // unique id of detail
    int                  myDetailCacheCount;    // last seen cache count

    bool                 myValid;       // is the point array valid
};

#endif

---