GU_LoopHelper.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.
 * 
 * NAME:        GU_LoopHelper.h
 *
 * COMMENTS:
 *      This is a helper class for creating nice edge/prim/point loops.
 */

#ifndef __GU_LoopHelper_h__
#define __GU_LoopHelper_h__

#include "GU_API.h"
#include "GU_LoopType.h"
#include "GU_PathFinder.h"
#include "GU_PathHedge.h"
#include <GA/GA_EdgeGroup.h>
#include <GA/GA_ElementGroup.h>
#include <GA/GA_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_UniquePtr.h>
#include <SYS/SYS_Types.h>

class GU_Detail;
class GEO_DetachedHedgeInterface;
class GEO_Hedge;
class GEO_SHedge;
class GA_Attribute;
class GA_Group;


class GU_API GU_LoopHelper
{
public:
     GU_LoopHelper();
    ~GU_LoopHelper();

    // New edge loop methods to later fully replace the old ones
    bool                 primLoop(GA_Index start, GA_Index end,
                                GU_LoopType loop_type,
                                UT_Array<GEO_SHedge> &loop);

    bool                 edgeLoop(GEO_Hedge start, GEO_Hedge end,
                                GU_LoopType loop_type,
                                bool allow_ring_instead,
                                UT_Array<GEO_SHedge> &loop);

    bool                 edgeRing(GEO_Hedge start, GEO_Hedge end,
                                GU_LoopType loop_type,
                                UT_Array<GEO_SHedge> &loop);

    bool                 pointLoop(GA_Index start, GA_Index end,
                                GU_LoopType loop_type,
                                UT_Array<GEO_SHedge> &loop);

    bool                 vertexLoop(GA_Index start, int svtx, GA_Index end,
                                int evtx, GU_LoopType loop_type,
                                UT_Array<GEO_SHedge> &loop);

    // New edge loop methods to later fully replace the old ones
    bool                 primLoop(GA_Index start, GA_Index end,
                                GU_LoopType loop_type,
                                UT_Array<GU_PathSHedge> &loop);

    bool                 edgeLoop(GU_PathHedge start, GU_PathHedge end,
                                GU_LoopType loop_type,
                                bool allow_ring_instead,
                                bool force_find_path,
                                bool & result_is_ring, //out param. True is edge ring, false if edge loop
                                UT_Array<GU_PathSHedge> &loop);

    bool                 edgeLoop(GU_PathHedge start, GU_PathHedge end,
                                GU_LoopType loop_type,
                                bool allow_ring_instead,
                                UT_Array<GU_PathSHedge> &loop)
    {
        bool tmp;
        return edgeLoop(start, end, loop_type,
                        allow_ring_instead, false, tmp, loop);
    }

    bool                 edgeRing(GU_PathHedge start, GU_PathHedge end,
                                GU_LoopType loop_type,
                                UT_Array<GU_PathSHedge> &loop);

    bool                 pointLoop(GA_Index start, GA_Index end,
                                GU_LoopType loop_type,
                                UT_Array<GU_PathSHedge> &loop);

    bool                 vertexLoop(GA_Index start, int svtx, GA_Index end,
                                int evtx, GU_LoopType loop_type,
                                UT_Array<GU_PathSHedge> &loop);

    //Call to extend an existing path directly
    bool                extendLoop(UT_Array<GU_PathSHedge> & loop);
    bool                extendRing(UT_Array<GU_PathSHedge> & loop,
                                    bool is_for_prim_loop = false);

    // Sets the active detail, should only be called by setActiveNode.
    void                 setActiveDetail(const GU_Detail *gdp,
                                const GA_Attribute *uv_attrib = nullptr);

    // Returns our active detail.  May be NULL.
    const GU_Detail     *getActiveDetail() const;

    // Access our cached ring zero.  The first time this is called with a new
    // detail it will create a new ring zero.
    const UT_Array<GA_OffsetArray>
                        *getActiveRingZero();

    // Access our cached hedge interface.  The first time this is called with
    // a new detail it will create a new hedge interface.
    const GEO_DetachedHedgeInterface
                        *getActiveHedgeInterface();

    GU_PathHedge::Interface *
                        getActivePathHedgeInterface();

    const GA_Attribute  *getActiveUVAttrib();

    //Used for setting elements to avoid
    //if replace_existing is true, then any avoid group with the same type
    //will be replaced. If false, then it will be added to it.
    void setPreviousPath(const GA_Group * prev_gp,
                         bool replace_existing = true);
    void resetPreviousPath();

    void setCollisionGroup(const GA_Group * g,
                           bool exclude_collision_group,
                           bool collision_strong_rule)
    {
        myCollisionGroup = g;
        myExcludeCollisionGroup = exclude_collision_group;
        myCollisionGroupStrong = collision_strong_rule;
    }
private:

    using LoopFinderUptr = UT_UniquePtr<GU_EdgeLoopFinder>;
    using RingFinderUptr = UT_UniquePtr<GU_EdgeRingFinder>;
    using HedgeInterfaceUptr = UT_UniquePtr<const GEO_DetachedHedgeInterface>;
    using PathHedgeInterfacePtr = UT_UniquePtr<GU_PathHedge::Interface>;
    using OffsetArrayUptr = UT_UniquePtr<const UT_Array<GA_OffsetArray> >;
    using SHedgeArray =  UT_Array<GU_PathSHedge>;

    GU_EdgeRingFinder   *getLeftRingFinder();
    GU_EdgeRingFinder   *getRightRingFinder();

    GU_EdgeLoopFinder   *getLeftLoopFinder();
    GU_EdgeLoopFinder   *getRightLoopFinder();

    void                 addPathToPointGroup(const SHedgeArray &path,
                                GA_PointGroup *grp);

    void                 addPathToVertexGroup(const SHedgeArray &path,
                                GA_VertexGroup *grp);

    void                 addPathToPrimitiveGroup(const SHedgeArray &path,
                                GA_PrimitiveGroup *grp);

    // Returns true (and returns the shortest partial edge ring in "path") if
    // the the start and end edges given by ssh and esh suggest an edge ring
    // selection more than they do an edge loop one. This is the case exactly
    // when ssh and esh are distinct and there is a perfect partial edge
    // from start and end but while no perfect edge loops can be found between
    // them. If false is returned the shortest perfect edge loop between start
    // and end is returned as evidence.
    bool                 shouldFindEdgeRingInstead(GU_PathSHedge ssh,
                                GU_PathSHedge esh, UT_Array<GU_PathSHedge> &path);

    bool                 findPartialEdgeLoop(UT_Array<GU_PathSHedge> &loop);
    bool                 findPartialEdgeRing(UT_Array<GU_PathSHedge> &loop);

    bool                 findEdgeLoop(UT_Array<GU_PathSHedge> &loop,
                                GU_LoopType loop_type,
                                bool same_start_and_end = false);

    bool                 findEdgeRing(UT_Array<GU_PathSHedge> &loop,
                                GU_LoopType loop_type,
                                bool is_for_prim_loop = false);

    exint                myActiveDetailId;
    exint                myActiveDetailMetaCount;
    exint                myUVAttribDataId;


    LoopFinderUptr       myLeftLoopFinder;
    LoopFinderUptr       myRightLoopFinder;
    RingFinderUptr       myLeftRingFinder;
    RingFinderUptr       myRightRingFinder;

    const GU_Detail     *myActiveDetail;
    const GA_Attribute  *myUVAttrib;

    PathHedgeInterfacePtr myPathHedgeInterface;

    HedgeInterfaceUptr   myActiveHedgeInterface;
    OffsetArrayUptr      myActiveRingZero;

    GA_PointGroupUPtr        myPrevPathPts;
    GA_VertexGroupUPtr       myPrevPathVtx;
    GA_PrimitiveGroupUPtr    myPrevPathPrims;
    GA_EdgeGroupUPtr         myPrevPathEdges;


    const GA_Group * myCollisionGroup = nullptr;
    //when true, will prevent paths within collision group,
    //if false will constrain paths to collision group
    bool myExcludeCollisionGroup = true;

    //when true will NOT allow paths along boundaries of collision group
    //when false will allow paths to partially contain elements of collision group
    bool myCollisionGroupStrong = false;
};

#endif