GU_PolyExtrude2.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 Library (C++)
 *
 * COMMENTS: Poly Extrude code.
 *
 */
#ifndef __GU_PolyExtrude2_h__
#define __GU_PolyExtrude2_h__

#include "GU_API.h"
#include "GU_PolyBridge.h"
#include <GU/GU_Decompose.h>
#include <GU/GU_Detail.h>

#include <GEO/GEO_HedgeInterface.h>
#include <GA/GA_Types.h>

#include <UT/UT_Matrix4.h>
#include <UT/UT_Array.h>
#include <UT/UT_Vector3.h>


class GA_Group;
class GA_PrimitiveGroup;
class GA_PointGroup;
class GA_PrimitiveGroup;
class GA_ElementWranglerCache;
class GEO_Face;
class GEO_PrimPoly;
class GU_Detail;
class GA_Attribute;
class GEO_DetachedHedgeInterface;


template<typename T, bool B> class GA_EdgeT; 
using GA_Edge = GA_EdgeT<GA_Offset, false>;


class GU_API GU_PolyExtrude2
{
public:

                         GU_PolyExtrude2(GU_Detail *gdp,
                                const GA_PrimitiveGroup *prims,
                                const GA_EdgeGroup *split_edges = nullptr,
                                bool split_all = false);

                         GU_PolyExtrude2(GU_Detail *gdp,
                                const GA_EdgeGroup *edges,
                                const GA_PointGroup *split_points = nullptr,
                                bool split_all = false);

                        ~GU_PolyExtrude2();

    enum ExtrusionMode
    {
        PRIM_OR_EDGE_NORMAL = 0,
        POINT_NORMAL,
    };

    using MorphMethod = GU_PolyBridge::MorphMethod;
    using SpineSampleMethod = GU_PolyBridge::SpineSampleMethod;

    // Performs the extrusion
    void                 extrude(fpreal distance = 0.0);

    // Methods to help placing a handle on the first component
    UT_Vector3           getXformHandleCenter() const;
    UT_Matrix4           getXformHandleXform() const;
    UT_Vector3           getDraggerStart() const { return myDraggerStart; }
    UT_Vector3           getDraggerDir() const { return myDraggerDir; }


    bool                 isTrivial() const;

    void                 setExtrusionMode(ExtrusionMode m)
                            { myExtrusionMode = m; }
    void                 setMorphMethod(MorphMethod m)
                            { myMorphMethod = m; }

    void                 setOutputFront(bool b) { myOutputFront = b; }
    void                 setOutputBack(bool b) { myOutputBack = b; }
    void                 setOutputSide(bool b) { myOutputSide = b; }

    void                 setUseExistingPointNormal(bool b)
                            { myUseExistingNormal = b; }

    void                 setPointNormalAttrib(GA_ROHandleV3 ptnml)
                            { mySuppliedPointNormal = ptnml; }

    void                 setFrontGroup(GA_PrimitiveGroup *grp)
                            { myAddFrontPrimGroup = grp; }

    void                 setFrontGroup(GA_EdgeGroup *grp)
                            { myAddFrontEdgeGroup = grp; }

    void                 setBackGroup(GA_PrimitiveGroup *grp)
                            { myAddBackPrimGroup = grp; }

    void                 setBackGroup(GA_EdgeGroup *grp)
                            { myAddBackEdgeGroup = grp; }

    void                 setSideGroup(GA_PrimitiveGroup *grp)
                            { myAddSidePrimGroup = grp; }

    void                 setFrontSeamGroup(GA_EdgeGroup *grp)
                            { myAddFrontSeamGroup = grp; }

    void                 setBackSeamGroup(GA_EdgeGroup *grp)
                            { myAddBackSeamGroup = grp; }

    void                 setSelectionGroup(GA_PrimitiveGroup *grp)
                            { myPrimSelection = grp; }

    void                 setSelectionGroup(GA_EdgeGroup *grp)
                            { myEdgeSelection = grp; }

    void                 setInset(float inset) { myInset = inset; }
    void                 setDivisions(int div) { myDivisions = div; }
    void                 setStraightSpine(bool b) { myStraightSpine = b; }
    void                 setTwist(fpreal t) { myTwist = t; }
    void                 setThicknessScale(fpreal s) { myThicknessScale = s; }
    void                 setTwistScale(fpreal s) { myTwistScale = s; }
    void                 setThicknessRamp(UT_Ramp *r) { myThicknessRamp = r; }
    void                 setTwistRamp(UT_Ramp *r) { myTwistRamp = r; }
    void                 setDeviationTolerance(fpreal a)
                            { myDeviationToleranceCos = SYScos(a); }
    void                 setAxialRotation(fpreal r)  { myAxialRotation = r; }

    void                 setExtSpineBlend(fpreal s, fpreal d)
                            { myExtSpineSrcBlend = s; myExtSpineDstBlend = d; }

    void                 setXform(const UT_Matrix4 &frontxform,
                               bool is_global = false);

    void                 setExternalSpine(const GEO_Face *curve)
                             { myExternalSpine = curve; }


    void                 setThicknessAttrib(GA_Attribute *attrib)
                            { myThicknessAttrib = attrib; }

    void                 setTwistAttrib(GA_Attribute *attrib)
                            { myTwistAttrib = attrib; }

    void                 setSpineRange(fpreal s, fpreal e)
                            { mySpineStart = s; mySpineEnd = e; }

    void                 setReverseSpine(bool b) { myReverseSpine = b; }
    void                 setMagnitudes(fpreal s, fpreal d)
                            { mySrcMagnitude = s; myDstMagnitude = d; }

    void                 setStiffnesses(fpreal s, fpreal d)
                            { mySrcStiffness = s; myDstStiffness = d; }

    void                 addVertexNormals(fpreal cusp_angle_degrees,
                                bool cusp_front, bool cusp_back);

    void                 setSpineSampleMethod(SpineSampleMethod m)
                            { mySpineSampleMethod = m; }

    void                 limitInset(bool limit, bool common_limit)
                            { myLimitInset = limit;
                                myCommonInsetLimit = common_limit; }

    void                 setLocalXDirAttrib(const char *attrib_name);
    void                 setLocalZDirAttrib(const char *attrib_name);
    void                 setLocalCtrAttrib(const char *attrib_name);
    void                 setLocalDistScaleAttrib(const char *attrib_name);
    void                 setLocalInsetScaleAttrib(const char *attrib_name);
    void                 setLocalTwistScaleAttrib(const char *attrib_name);
    void                 setLocalDivsScaleAttrib(const char *attrib_name);

    using TextureMode = GU_PolyBridge::TextureMode;
    using TextureScaling = GU_PolyBridge::TextureScaling;

    void                 setSideTexturing(TextureMode mode,
                                TextureScaling scaling);

    fpreal               getCompInsetScale(int k);
    fpreal               getCompDistScale(int k);
    fpreal               getCompTwistScale(int k);
    fpreal               getCompDivsScale(int k);

private:

    using HedgeInterface = const GEO_DetachedHedgeInterface;
    using IndexPairArray = GU_PolyBridge::IndexPairArray;
    using PolyPatches = GU_Decomposition::PolyPatches;
    using EdgePaths = GU_Decomposition::EdgePaths;

    void                 initialize();
    void                 cleanPrivateAttributes();
    void                 computeOpenPolyNormals();

    void                 buildPrimFront();
    void                 buildEdgeFront(bool generate_edge_polys);

    void                 setupGroupsAndAttribs();
    void                 copyEdgeGroupMembership();
    void                 wrangleFrontPt(GA_Offset fpt,
                                GA_PointWrangler &wrangler);
    void                 wrangleFrontVtxs(GA_Offset fpt,
                                GA_VertexWrangler &wrangler);

    void                 buildPrimExtrusionMaps();

    void                 buildEdgeExtrusionMap();
    void                 calculatePathNormals(bool trivial);

    void                 transformEdgeFront(bool trivial);

    UT_Vector3           calcBoundaryExtrusion(GEO_Hedge h0, GEO_Hedge h1,
                                int comp);

    UT_Vector3           calcInteriorExtrusion(GA_Offset pt, int comp,
                                HedgeInterface *fhip = nullptr);


    UT_Vector3           calcBoundaryInset(GA_Offset pt0, GA_Offset pt1,
                                GA_Offset pt2, GA_Offset prim0,
                                GA_Offset prim1);

    UT_Vector3           calcPathNormal(GA_Offset pt_prev, GA_Offset pt,
                                GA_Offset pt_next,
                                UT_Vector3 *out_edge_nml = nullptr);

    UT_Vector3           calcHedgeNormal(GEO_Hedge h, int &degree,
                                UT_Vector3 *binormal = nullptr);

    void                 transformPrimFront(bool trivial);
    void                 insetPrimFront();

    GU_PolyBridge       *bridgeLoops(int comp, GA_OffsetArray &src_chain,
                                GA_OffsetArray &dst_chain,
                                bool closed);

    void                 bridgePrimComponents(int batch_size = -1);
    void                 bridgeEdgeComponents(int batch_size = -1);

    void                 buildPrimSeams();
    void                 buildEdgeSeams();

    void                 calcPrimLocalFrames();
    void                 calcPrimCompLocalFrame(int k);

    void                 calcEdgeLocalFrames();
    void                 calcEdgeCompLocalFrame(int k);

    void                 calcCenterAndNormal(int component_id,
                                UT_Vector3 &center,
                                UT_Vector3 &normal,
                                bool add_extrusion = false,
                                bool collect_from_attributes = false);

    UT_Vector3           farthestBoundaryEdgePerp(int k);
    UT_Vector3           longestBoundaryEdgeDir(int k);

    void                 updateAffectedNormals();

    UT_Vector3           getMinAreaBoxXDirection(int comp);

    void                 fillOutputGroups();
    void                 cleanup();
    fpreal               getRescaleFactor() const;

    void                 buildHandleSpaceChangMat();

    void                 saveEdgeGroupToDetailArray(const GA_EdgeGroup *grp,
                                const char *attrib_name);

    void                 rescaleFront();

    bool                 isFrontXformTrivial() const;

    SYS_FORCE_INLINE
    int                  numCompFrontPts(int k)
                            { return (myCompFrontFirstPt(k + 1) -
                                        myCompFrontFirstPt(k)); }

    SYS_FORCE_INLINE
    GA_Offset            compFrontPt(int k, int i)
                            { return myFrontPts(myCompFrontFirstPt(k) + i); }

    SYS_FORCE_INLINE
    int                  numCompFrontPrims(int k)
                            { return (myCompFrontFirstPrim(k + 1) -
                                        myCompFrontFirstPrim(k)); }

    SYS_FORCE_INLINE
    GA_Offset            compFrontPrim(int k, int i)
                            { return myFrontPrims(myCompFrontFirstPrim(k) + i); }


    // NB: only used with edge extrusion
    SYS_FORCE_INLINE
    int                  frontPtIdx(int k, int i)
                            { return (myCompFrontFirstPt(k) + i); }

    SYS_FORCE_INLINE
    UT_Vector3          &frontPtExtrusion(int k, int i)
                            { return myFrontPtExtrusion(frontPtIdx(k, i)); }

    SYS_FORCE_INLINE
    UT_Vector3          &frontPtPathNormal(int k, int i)
                            { return myFrontPtPathNormal(frontPtIdx(k, i)); }
    // ---

    // index of the the ith boundary of the kth component among all boundaries
    SYS_FORCE_INLINE
    int                  frontBdIdx(int k, int j)
                            { return (myCompFrontFirstBd(k) + j); }

    // index of the ith vertex of the jth boundary
    SYS_FORCE_INLINE
    int                  frontBdVtxIdx(int j, int i)
                            { return (myFrontBdFirstVtx(j) + i); }

    // The ith vertex of the jth front boundary
    SYS_FORCE_INLINE
    GA_Offset           &frontBdVtx(int i)
                            { return myFrontBdVtxs(i); }

    // The ith vertex of the jth front boundary
    SYS_FORCE_INLINE
    GA_Offset           &frontBdVtx(int j, int i)
                            { return myFrontBdVtxs(frontBdVtxIdx(j, i)); }

    // ith vertex of the jth boundary of the kth component
    SYS_FORCE_INLINE
    GA_Offset           &compFrontBdVtx(int k, int j, int i)
                            { return frontBdVtx(frontBdIdx(k, j), i); }

    // total number of boundary components of the front
    SYS_FORCE_INLINE
    int                  numFrontBds()
                                { return int(myCompFrontFirstBd.size() - 1); }

    // number of boundaries of the kth front component
    SYS_FORCE_INLINE
    int                  numCompFrontBds(int k)
                            { return (myCompFrontFirstBd(k + 1)
                                        - myCompFrontFirstBd(k)); }

    SYS_FORCE_INLINE
    int                  numFrontBdVtxs()
                            { return int(myFrontBdVtxs.size()); }

    // number of vertices in the jth front boundary
    SYS_FORCE_INLINE
    int                  numFrontBdVtxs(int j)
                            { return (myFrontBdFirstVtx(j + 1)
                                        - myFrontBdFirstVtx(j)); }

    // number of vertices in the jth boundary of the kth front component
    SYS_FORCE_INLINE
    int                  numCompFrontBdVtxs(int k, int j)
                            { return numFrontBdVtxs(frontBdIdx(k, j)); }

    // used only in primitive extrusion
    SYS_FORCE_INLINE
    GA_Offset            frontVtxToBackVtx(GA_Offset v)
                            { return GA_Offset(myFrontToBackVtxMap.get(v)); }

    // used only in edge extrusion
    SYS_FORCE_INLINE
    GA_Offset            frontPtToBackPt(GA_Offset pt)
                            { return GA_Offset(myFrontToBackPtMap.get(pt)); }


    SYS_FORCE_INLINE
    int                  bdComp(int j) { return myBdComp(j); }

    // used in edge extrusion only
    SYS_FORCE_INLINE
    bool                 isFrontCompClosed(int k)
                            { return myFrontCompClosed.getBitFast(k); }

    SYS_FORCE_INLINE
    GA_Offset            srcPoint(GEO_Hedge h) const
                            { return myHip->srcPoint(h); }

    SYS_FORCE_INLINE
    GA_Offset            dstPoint(GEO_Hedge h) const
                            { return myHip->dstPoint(h); }
                            
    SYS_FORCE_INLINE
    GA_Offset            srcVertex(GEO_Hedge h) const
                            { return myHip->srcVertex(h); }

    SYS_FORCE_INLINE
    GA_Offset            dstVertex(GEO_Hedge h) const
                            { return myHip->dstVertex(h); }

    SYS_FORCE_INLINE
    GA_Offset            vertexPrimitive(GA_Offset vtx) const
                            { return myGdp->vertexPrimitive(vtx); }

    SYS_FORCE_INLINE
    GEO_Hedge            findHedgeWithEndpoints(GA_Offset p0,
                                GA_Offset p1) const
                            { return myHip->findHedgeWithEndpoints(p0, p1); }

    SYS_FORCE_INLINE
    GEO_Hedge            sym(GEO_Hedge h) const
                            { return myHip->sym(h); }

    SYS_FORCE_INLINE
    GEO_Hedge            lnext(GEO_Hedge h) const
                            { return myHip->lnext(h); }

    SYS_FORCE_INLINE
    GEO_Hedge            lprev(GEO_Hedge h) const
                            { return myHip->lprev(h); }

    SYS_FORCE_INLINE
    UT_Vector3           getPos3(GA_Offset pt) const
                            { return { myGdp->getPos3(pt) }; }

    SYS_FORCE_INLINE
    bool                 isValidHedge(GEO_Hedge h) const
                            { return myHip->isValidHedge(h); }

    SYS_FORCE_INLINE
    UT_Vector3           pointNormal(GA_Offset pt) const
                            { return { myPointNormal.get(pt) }; }

    SYS_FORCE_INLINE
    UT_Vector3           polyNormal(GA_Offset pt) const
                            { return { myPolyNormal.get(pt) }; }

    GU_Detail           *myGdp                          = nullptr;
    GA_PrimitiveGroup   *myPolys                        = nullptr;
    const GA_EdgeGroup  *myEdges                        = nullptr;
    fpreal              myTolerance;

    GA_RWHandleV3        myPolyNormal;
    GA_RWHandleV3        myPointNormal;

    UT_Vector3Array      myBackCompCtr;         // Center used for back
    UT_Vector3Array      myBackCompBary;        // Barycenter of the back

    UT_Vector3Array      myCompXDir, myCompYDir, myCompZDir;

    UT_Vector3Array      myFrontCompCtr;        // Calculated front center
    UT_Vector3Array      myExtrudedCompCtr;     // Centroid of extruded comp
    UT_Vector3Array      myFrontCompZDir, myFrontCompXDir;

    UT_FprealArray       myCompDivsScale;
    UT_FprealArray       myCompZScale;
    UT_FprealArray       myCompInsetScale;
    UT_FprealArray       myCompTwistScale;


    UT_Matrix4           myHandleSpaceChangeMat;

    fpreal               myDeviationToleranceCos        = 0.984807753012208;
    fpreal               mySrcMagnitude                 = 1.0;
    fpreal               myDstMagnitude                 = 1.0;
    fpreal               mySrcStiffness                 = 1.0;
    fpreal               myDstStiffness                 = 1.0;
    fpreal               myExtSpineSrcBlend, myExtSpineDstBlend;

    UT_Vector3           myDraggerStart, myDraggerDir;

    //GU_Decompose      *myDecompose                    = nullptr;
    PolyPatches         *myPolyPatches                  = nullptr;
    EdgePaths           *myEdgePaths                    = nullptr;


    GA_PointGroupUPtr    myFrontBoundaryPtGroup;
    GA_PrimitiveGroup   *myFrontPrimGroup               = nullptr;
    GA_PrimitiveGroup   *myBackPrimGroup                = nullptr;
    GA_PrimitiveGroup   *mySidePrimGroup                = nullptr;
    GA_EdgeGroup        *myFrontEdgeGroup               = nullptr;
    GA_EdgeGroup        *myBackEdgeGroup                = nullptr;

    GA_PrimitiveGroup   *myAddFrontPrimGroup            = nullptr;
    GA_PrimitiveGroup   *myAddBackPrimGroup             = nullptr;
    GA_PrimitiveGroup   *myAddSidePrimGroup             = nullptr;
    GA_EdgeGroup        *myAddFrontEdgeGroup            = nullptr;
    GA_EdgeGroup        *myAddBackEdgeGroup             = nullptr;
    GA_EdgeGroup        *myAddFrontSeamGroup            = nullptr;
    GA_EdgeGroup        *myAddBackSeamGroup             = nullptr;

    GA_PrimitiveGroup   *myPrimSelection                = nullptr;
    GA_EdgeGroup        *myEdgeSelection                = nullptr;

    ExtrusionMode        myExtrusionMode                = PRIM_OR_EDGE_NORMAL;

    UT_Matrix4           myFrontXform;
    fpreal               myDistance                     = 0.0;
    int                  myNumFrontPts                  = 0;

    MorphMethod          myMorphMethod                  = MorphMethod::LINEAR;

    bool                 myOutputFront                  = true;
    bool                 myOutputBack                   = false;
    bool                 myReverseBack                  = true;
    bool                 myOutputSide                   = true;
    bool                 myStraightSpine                = true;
    bool                 myReverseSpine                 = false;
    bool                 myUseExistingNormal            = false;

    bool                 myAddVertexNormal              = false;
    bool                 myCuspFront                    = true;
    bool                 myCuspBack                     = true;

    bool                 myWranglePt                    = false;
    bool                 myWranglePrim                  = false;
    bool                 myWrangleVtx                   = false;

    bool                 myXformIsTrivial               = true;
    bool                 myTrivialNormal                = true;

    bool                 myLimitInset                   = true;
    bool                 myCommonInsetLimit             = true;

    fpreal               myCuspAngleDegrees             = 60.06;

    int                  myDivisions                    = 1;
    fpreal               myTwist                        = 0.0;
    fpreal               myInset                        = 0.0;
    fpreal               myThicknessScale               = 1.0;
    fpreal               myTwistScale                   = M_PI;
    UT_Ramp             *myTwistRamp                    = nullptr;
    UT_Ramp             *myThicknessRamp                = nullptr;

    const  GEO_Face     *myExternalSpine                = nullptr;
    GA_Attribute        *myThicknessAttrib              = nullptr;
    GA_Attribute        *myTwistAttrib                  = nullptr;

    fpreal               mySpineStart                   = 0.0;
    fpreal               mySpineEnd                     = 1.0;
    fpreal               myAxialRotation                = 0.0;

    GA_AttributeUPtr     myFrontPtIdxOwner;
    GA_AttributeUPtr     myFrontToBackVtxMapOwner;
    GA_AttributeUPtr     myFrontToBackPtMapOwner;

    GA_ROHandleI         myFrontPtIdx;
    GA_ROHandleI         myFrontToBackVtxMap;
    GA_ROHandleI         myFrontToBackPtMap;

    GA_ROHandleV3        myLocalXDirAttr;
    GA_ROHandleV3        myLocalZDirAttr;
    GA_ROHandleV3        myLocalCtrAttr;
    GA_ROHandleF         myLocalZScaleAttr;
    GA_ROHandleF         myLocalInsetScaleAttr;
    GA_ROHandleF         myLocalTwistScaleAttr;
    GA_ROHandleF         myLocalDivsScaleAttr;

    GA_ROHandleV3        mySuppliedPointNormal;

    int                  myNumComponents                = 0;
    int                  myNumCompBoundaries            = 0;

    SpineSampleMethod    mySpineSampleMethod;

    UT_Vector3Array      myFrontPtPos;
    UT_Vector3Array      myFrontPtExtrusion;
    UT_Vector3Array      myFrontPtInset;
    UT_Vector3Array      myFrontPtPathNormal;

    bool                 myXformIsGlobal                = false;

    GA_OffsetArray       myFrontPts;
    UT_IntArray          myCompFrontFirstPt;
    UT_BitArray          myFrontCompClosed;     // edge extrusion use only

    GA_OffsetArray       myFrontPrims;
    UT_IntArray          myCompFrontFirstPrim;

    GA_OffsetArray       myFrontBdVtxs;
    UT_IntArray          myFrontBdFirstVtx;
    UT_IntArray          myCompFrontFirstBd;
    UT_IntArray          myBdComp;

    TextureMode          mySideTextureMode = GU_PolyBridge::INTERPOLATE;
    TextureScaling       mySideTextureScaling = GU_PolyBridge::FIT_UNIT_SQUARE;

    IndexPairArray       myBridgePairing;
    HedgeInterface      *myHip;
};

#endif