GU_NSidedSubdivPatch.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_NSidedSubdivPatch.h (GU Library, C++)
 *
 * COMMENTS: This class is based off the subdivision scheme detailed in the
 * following paper:
 *      Filling an N-sided hole using subdivision schemes, Adi Levin
 *
 * Note that this is different from GU_SubDivPatch, this takes some extra work
 * to ensure that the sides of the hole are smooth with the surface surrounding
 * the hole. An example of it's use can be seen in GU_PolyBevel.C in
 * BlendPositioner::positionPointsCubicSubdiv().
 */


#ifndef __GU_NSidedSubdivPatch_h__
#define __GU_NSidedSubdivPatch_h__

#include "GU_API.h"

#include <UT/UT_Vector.h>
#include <array>

template <typename T>
class GU_API GU_NSidedSubdivPatchT
{
public:
    using                Real = T;
    using                Patch = GU_NSidedSubdivPatchT<T>;

                         GU_NSidedSubdivPatchT() = default;

    explicit             GU_NSidedSubdivPatchT(int sides, int divs = 1) :
                            mySides(sides), myDivs(divs) { setupMesh(); }


    SYS_FORCE_INLINE
    int                  divs() const { return myDivs; }

    SYS_FORCE_INLINE
    int                  sides() const { return mySides; }

    SYS_FORCE_INLINE
    const
    UT_Vector3T<T>      &pos(int m, int i, int j) const
                            { return myPoints(pointIndex(m, i, j)); }

    SYS_FORCE_INLINE
    UT_Vector3T<T>      &pos(int m, int i, int j)
                            { return myPoints(pointIndex(m, i, j)); }

    void                 subdivide(const Patch &src);
    UT_Vector3T<T>       interpolate(int m, T u, T v);

private:
    using PosArray = UT_Array< UT_Vector3T<T> >;

    void                 setupMesh();

    SYS_FORCE_INLINE
    int                  pointIndex(int m, int i, int j) const;


    int                  myDivs                                 = 1;
    int                  mySides                                = 0;
    int                  myMeshSize                             = 0;
    fpreal               myMeshUnit                             = 1.0;
    PosArray             myPoints;
};


template<typename T>
int
GU_NSidedSubdivPatchT<T>::pointIndex(int m, int i, int j) const
{
    // The point with coordinates (myDivs, myDivs) is shared between all
    // corner meshes.
    if (i == myDivs && j == myDivs)
        return int(myPoints.size()) - 1;

    // Either of i or j (both *not* both) can have values greater than
    // myDivs (but less than 2 * myDivs).
    UT_ASSERT_P(i < myDivs || j < myDivs);

    if (i > myDivs)
    {
        m = (m + mySides - 1) % mySides;
        auto tmp = i;
        i = j;
        j = 2 * myDivs - tmp;
    }

    if (j >= myDivs)
    {
        m = (m + 1) % mySides;
        auto tmp = i;
        i = 2 * myDivs - j;
        j = tmp;
    }

    return myMeshSize * m + myDivs * i + j;
}


template <typename S>
UT_Vector3T< UT_Vector3T<typename S::Real> >
interpolatePatch(const S &s, int m, typename S::Real u, typename S::Real v);


using GU_NSidedSubdivPatchF = GU_NSidedSubdivPatchT<fpreal32>;
using GU_NSidedSubdivPatchD = GU_NSidedSubdivPatchT<fpreal64>;
using GU_NSidedSubdivPatchR = GU_NSidedSubdivPatchT<fpreal>;
using GU_NSidedSubdivPatch = GU_NSidedSubdivPatchF;

#endif