GU_SplitLoc.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_SplitLoc.h ( GU Library, C++)
 *
 * COMMENTS: This class defines a split location.  It represents a place where
 *           a split will occur.  A list of these things is what we need to
 *           make a complete cut.
 */

#ifndef __GU_SplitLoc_h__
#define __GU_SplitLoc_h__

#include "GU_API.h"
#include "GU_Detail.h"

#include <GA/GA_Edge.h>
#include <GEO/GEO_PrimPoly.h>
#include <UT/UT_VectorTypes.h>

namespace GU_EdgeSplitUtils
{
    template <typename Prec>
    SYS_FORCE_INLINE
    const Prec getTol()
    {
        if constexpr (std::is_same_v<Prec, fpreal32>)
            return 1e-5;
        else
            return SYS_FP64_EPSILON;
    }
}

class GU_API GU_SplitLocParent
{
public:
    GU_SplitLocParent(const GU_Detail *curve = nullptr,
                      exint v0 = -1,
                      exint v1 = -1,
                      GA_Offset cp = GA_INVALID_OFFSET)
    : myCV0(v0)
    , myCV1(v1)
    , myCPrim(cp)
    , myCurve(curve) {}

    bool           operator==(const GU_SplitLocParent& src) const
    {
        return myCPrim == src.myCPrim 
               && myCV0 == src.myCV0 
               && myCV1 == src.myCV1;
    }

    bool           operator<(const GU_SplitLocParent& src) const
    {
        if (myCPrim != src.myCPrim)
            return myCPrim < src.myCPrim;
        else if (myCV0 != src.myCV0)
            return myCV0 < src.myCV0;
        else
            return myCV1 < src.myCV1;
    }

    size_t hash() const
    {
        size_t hash_val;
        hash_val = GA_Size(myCPrim);
        hashCombine(hash_val, GA_Size(myCV0));
        hashCombine(hash_val, GA_Size(myCV1));
        return hash_val;
    }

    GU_SplitLocParent next() const
    {
        GU_SplitLocParent next = *this;

        exint nv =
            (exint)myCurve->getPrimitiveVertexCount(myCPrim);
        next.myCV0 = (myCV0 + 1) % nv;
        next.myCV1 = (myCV1 + 1) % nv;
        return next;
    }

    const GU_Detail     *myCurve;
    exint                myCV0;        // Curve vertex (projection point)
    exint                myCV1;        // Curve vertex (surface direction)
    GA_Offset            myCPrim;      // Curve primitive

private:
    // TODO: copied from GA_Edge.h:
    static size_t hashValueSigned(GA_Size val)
    {
        const unsigned int size_t_bits = 
           std::numeric_limits<size_t>::digits;
        const int length = (std::numeric_limits<fpreal>::digits - 1)
            / static_cast<int>(size_t_bits);

        size_t seed = 0;
        GA_Size positive = val < 0 ? -1 - val : val;

        // Hopefully, this loop can be unrolled.
        for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
        { 
            seed ^= (size_t) (positive >> i) + (seed<<6) + (seed>>2);
        }
        seed ^= (size_t) val + (seed<<6) + (seed>>2);

        return seed;
    }

    static void hashCombine(size_t &seed, GA_Size const &value)
    {
        auto hash_value = hashValueSigned(value);

        // On macOS, size_t != hboost::uint64_t
        const size_t m = UINT64_C(0xc6a4a7935bd1e995);
        const int r = 47;

        hash_value *= m;
        hash_value ^= hash_value >> r;
        hash_value *= m;

        seed ^= hash_value;
        seed *= m;

        // Completely arbitrary number, to prevent 0's
        // from hashing to 0.
        seed += 0xe6546b64;
    }
};

SYS_FORCE_INLINE size_t hash_value(const GU_SplitLocParent &parent)
{
    return parent.hash();
}

// Templated abstraction of the GU_SplitLoc allowing for different floating
// point types and tolerances.
template<typename Prec>
class GU_API GU_SplitLocT
{
public:
    GU_SplitLocT(const GA_Detail *gdp = nullptr,
                 GA_Offset p0off = GA_INVALID_OFFSET,
                 GA_Offset p1off = GA_INVALID_OFFSET,
                 Prec t = 0,
                 GEO_PrimPoly *poly = nullptr,
                 const UT_SharedPtr<GU_Detail> curve = nullptr,
                 exint v0 = -1,
                 exint v1 = -1,
                 GA_Offset cp = GA_INVALID_OFFSET)
        : myP0Off(p0off)
        , myP1Off(p1off)
        , myT(t)
        , myT2(-1)
        , myPoly(poly)
        , myOldPoly(poly)
        , myInsidePrim(false)
        , myIsFirst(false)
        , myIsLast(false)
        , myGdp(gdp)
        , myCurveSegment(curve.get(), v0, v1, cp)
        { }

    GU_SplitLocT(const GA_Detail *gdp,
                 GA_Offset p0off,
                 GA_Offset p1off,
                 Prec t,
                 GEO_PrimPoly *poly,
                 bool is_first,
                 bool is_last,
                 const UT_SharedPtr<GU_Detail> curve = nullptr,
                 exint v0 = -1,
                 exint v1 = -1,
                 GA_Offset cp = GA_INVALID_OFFSET)
        : myP0Off(p0off)
        , myP1Off(p1off)
        , myT(t)
        , myT2(-1)
        , myPoly(poly)
        , myOldPoly(poly)
        , myInsidePrim(false)
        , myIsFirst(is_first)
        , myIsLast(is_last)
        , myGdp(gdp)
        , myCurveSegment(curve.get(), v0, v1, cp)
        { }

    GU_SplitLocT(Prec u,
                 Prec v,
                 GEO_PrimPoly *poly,
                 const UT_SharedPtr<GU_Detail> curve = nullptr,
                 exint v0 = -1,
                 exint v1 = -1,
                 GA_Offset cp = GA_INVALID_OFFSET)
        : myP0Off(GA_INVALID_OFFSET)
        , myP1Off(GA_INVALID_OFFSET)
        , myT(u)
        , myT2(v)
        , myPoly(poly)
        , myInsidePrim(true)
        , myIsFirst(false)
        , myIsLast(false)
        , myOldPoly(poly)
        , myGdp(&poly->getDetail())
        , myCurveSegment(curve.get(), v0, v1, cp)
        { }

    GU_SplitLocT(Prec u,
                 Prec v,
                 GEO_PrimPoly *poly,
                 bool is_first,
                 bool is_last,
                 const UT_SharedPtr<GU_Detail> curve = nullptr,
                 exint v0 = -1,
                 exint v1 = -1,
                 GA_Offset cp = GA_INVALID_OFFSET)
        : myP0Off(GA_INVALID_OFFSET)
        , myP1Off(GA_INVALID_OFFSET)
        , myT(u)
        , myT2(v)
        , myPoly(poly)
        , myInsidePrim(true)
        , myIsFirst(is_first)
        , myIsLast(is_last)
        , myOldPoly(poly)
        , myGdp(&poly->getDetail())
        , myCurveSegment(curve.get(), v0, v1, cp)
        { }

    bool           operator==(const GU_SplitLocT& src) const;

    bool           operator!=(const GU_SplitLocT &src) const
                   {
                       return !(operator==(src));
                   }

    UT_Vector3T<Prec>     getPos3() const;

    void           setParentCurve(const GU_SplitLocT &src)
                   {
                        myCurveSegment = src.myCurveSegment;
                   }

    void           print() const;       // TODO: debug only

    GA_Offset      myP0Off;
    GA_Offset      myP1Off;
    Prec           myT;
    Prec           myT2;         // second uv value for face vertices
    bool           myInsidePrim; // the point is not a vertex/edge cut
    GEO_PrimPoly  *myPoly;
    GEO_PrimPoly  *myOldPoly;    // used to store references to old polygons
                                 // for in-polygon cuts to save recalculating
                                 // u, v values
    bool           myIsFirst;    // Indicator for closed curves
    bool           myIsLast;     // Indicator for closed curves

    const GA_Detail     *myGdp;
    GU_SplitLocParent    myCurveSegment;
};

GU_EXTERN_TEMPLATE(GU_SplitLocT<fpreal32>);
GU_EXTERN_TEMPLATE(GU_SplitLocT<fpreal64>);
typedef GU_SplitLocT<fpreal32> GU_SplitLoc;

typedef UT_SharedPtr< GU_SplitLocT<fpreal> > GU_SplitLocTPtr;
typedef UT_Array<GU_SplitLocTPtr> GU_SplitLocTArray;
typedef UT_Array<GU_SplitLocParent> GU_SplitLocParentArray;
typedef UT_Array<GU_SplitLoc *> GU_SplitLocArray;

#endif /* __GU_SplitLoc_h__ */