surface.h

Go to the documentation of this file.

//
//   Copyright 2021 Pixar
//
//   Licensed under the terms set forth in the LICENSE.txt file available at
//   https://opensubdiv.org/license.
//
 
#ifndef OPENSUBDIV3_BFR_SURFACE_H
#define OPENSUBDIV3_BFR_SURFACE_H
 
#include "../version.h"
 
#include "../bfr/surfaceData.h"
#include "../bfr/parameterization.h"
#include "../vtr/array.h"
 
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
 
namespace Bfr {
 
template <typename REAL>
class Surface {
public:
    struct PointDescriptor {
        PointDescriptor() : size(0), stride(0) { }
        PointDescriptor(int n) : size(n), stride(n) { }
        PointDescriptor(int n, int m) : size(n), stride(m) { }
 
        int size, stride;
    };
 
    typedef int Index;
 
public:
 
 
    bool IsValid() const { return _data.isValid(); }
 
    void Clear() { _data.reinitialize(); }
 
    Surface();
 
    Surface(Surface const & src) = default;
    Surface& operator=(Surface const & src) = default;
    ~Surface() = default;
 
 
 
    Parameterization GetParameterization() const { return _data.getParam(); }
 
    int GetFaceSize() const { return GetParameterization().GetFaceSize(); }
 
    bool IsRegular() const { return _data.isRegular(); }
 
    bool IsLinear() const { return _data.isLinear(); }
 
 
 
    int GetNumControlPoints() const { return _data.getNumCVs(); }
 
    int GetControlPointIndices(Index meshPointIndices[]) const;
 
    template <typename REAL_MESH>
    void GatherControlPoints(REAL_MESH       const   meshPoints[],
                             PointDescriptor const & meshPointDesc,
                             REAL                    controlPoints[],
                             PointDescriptor const & controlPointDesc) const;
 
    void BoundControlPoints(REAL            const   controlPoints[],
                            PointDescriptor const & controlPointDesc,
                            REAL                    minExtent[],
                            REAL                    maxExtent[]) const;
 
    void BoundControlPointsFromMesh(REAL            const   meshPoints[],
                                    PointDescriptor const & meshPointDesc,
                                    REAL                    minExtent[],
                                    REAL                    maxExtent[]) const;
 
 
 
    int GetNumPatchPoints() const;
 
    void PreparePatchPoints(REAL            const   meshPoints[],
                            PointDescriptor const & meshPointDesc,
                            REAL                    patchPoints[],
                            PointDescriptor const & patchPointDesc) const;
 
    void ComputePatchPoints(REAL                    patchPoints[],
                            PointDescriptor const & patchPointDesc) const;
 
 
 
    void Evaluate(REAL const uv[2],
                  REAL const patchPoints[], PointDescriptor const & pointDesc,
                  REAL P[]) const;
 
    void Evaluate(REAL const uv[2],
                  REAL const patchPoints[], PointDescriptor const & pointDesc,
                  REAL P[], REAL Du[], REAL Dv[]) const;
 
    void Evaluate(REAL const uv[2],
                  REAL const patchPoints[], PointDescriptor const & pointDesc,
                  REAL P[], REAL Du[],  REAL Dv[],
                  REAL Duu[], REAL Duv[], REAL Dvv[]) const;
 
 
 
    int EvaluateStencil(REAL const uv[2], REAL sP[]) const;
 
    int EvaluateStencil(REAL const uv[2], REAL sP[],
                        REAL sDu[], REAL sDv[]) const;
 
    int EvaluateStencil(REAL const uv[2], REAL sP[],
                        REAL sDu[],  REAL sDv[],
                        REAL sDuu[], REAL sDuv[], REAL sDvv[]) const;
 
    void ApplyStencil(REAL const stencil[],
                      REAL const controlPoints[], PointDescriptor const &,
                      REAL result[]) const;
 
    void ApplyStencilFromMesh(REAL const stencil[],
                              REAL const meshPoints[], PointDescriptor const &,
                              REAL result[]) const;
 
private:
    //  Internal methods for evaluating derivatives, basis weights and
    //  stencils for regular, irregular and irregular linear patches:
    typedef Vtr::ConstArray<int> IndexArray;
 
    void evaluateDerivs(REAL const uv[2], REAL const patchPoints[],
                        PointDescriptor const &, REAL * derivs[]) const;
    void evalRegularDerivs(REAL const uv[2], REAL const patchPoints[],
                           PointDescriptor const &, REAL * derivs[]) const;
    void evalIrregularDerivs(REAL const uv[2], REAL const patchPoints[],
                             PointDescriptor const &, REAL * derivs[]) const;
    void evalMultiLinearDerivs(REAL const uv[2], REAL const patchPoints[],
                               PointDescriptor const &, REAL * derivs[]) const;
 
    void       evalRegularBasis(REAL const uv[2], REAL * wDeriv[]) const;
    IndexArray evalIrregularBasis(REAL const uv[2], REAL * wDeriv[]) const;
    int        evalMultiLinearBasis(REAL const uv[2], REAL * wDeriv[]) const;
 
    int evaluateStencils(REAL const uv[2], REAL * sDeriv[]) const;
    int evalRegularStencils(REAL const uv[2], REAL * sDeriv[]) const;
    int evalIrregularStencils(REAL const uv[2], REAL * sDeriv[]) const;
    int evalMultiLinearStencils(REAL const uv[2], REAL * sDeriv[]) const;
 
    //  Internal methods to compute patch points:
    void computeLinearPatchPoints(REAL p[], PointDescriptor const &) const;
    void computeIrregularPatchPoints(REAL p[], PointDescriptor const &) const;
 
    //  Internal methods specific to regular or irregular patches:
    unsigned char getRegPatchType() const { return _data.getRegPatchType(); }
    unsigned char getRegPatchMask() const { return _data.getRegPatchMask(); }
 
    internal::IrregularPatchType const & getIrregPatch() const;
 
private:
    //  Access to the set of member variables - provided to the Factory:
    friend class SurfaceFactory;
 
    internal::SurfaceData       & getSurfaceData()       { return _data; }
    internal::SurfaceData const & getSurfaceData() const { return _data; }
 
private:
    //  All member variables encapsulated in a single class:
    internal::SurfaceData _data;
};
 
 
//
//  Simple inline methods composed of other methods:
//
template <typename REAL>
inline void
Surface<REAL>::ComputePatchPoints(REAL points[],
                                  PointDescriptor const & pointDesc) const {
 
    if (!IsRegular()) {
        if (IsLinear()) {
            computeLinearPatchPoints(points, pointDesc);
        } else {
            computeIrregularPatchPoints(points, pointDesc);
        }
    }
}
 
template <typename REAL>
inline void
Surface<REAL>::PreparePatchPoints(
        REAL const meshPoints[], PointDescriptor const & meshPointDesc,
        REAL patchPoints[],  PointDescriptor const & patchPointDesc) const {
 
    GatherControlPoints(meshPoints, meshPointDesc, patchPoints, patchPointDesc);
    ComputePatchPoints(patchPoints, patchPointDesc);
}
 
//
//  Inline invocations of more general methods for derivative overloads:
//
template <typename REAL>
inline void
Surface<REAL>::evaluateDerivs(REAL const uv[2],
                              REAL const patchPoints[],
                              PointDescriptor const & pointDesc,
                              REAL * derivatives[]) const {
    if (IsRegular()) {
        evalRegularDerivs(uv, patchPoints, pointDesc, derivatives);
    } else if (IsLinear()) {
        evalMultiLinearDerivs(uv, patchPoints, pointDesc, derivatives);
    } else {
        evalIrregularDerivs(uv, patchPoints, pointDesc, derivatives);
    }
}
template <typename REAL>
inline void
Surface<REAL>::Evaluate(REAL const uv[2],
                        REAL const patchPoints[],
                        PointDescriptor const & pointDesc,
                        REAL P[]) const {
 
    REAL * derivatives[6] = { P, 0, 0, 0, 0, 0 };
    evaluateDerivs(uv, patchPoints, pointDesc, derivatives);
}
template <typename REAL>
inline void
Surface<REAL>::Evaluate(REAL const uv[2],
                        REAL const patchPoints[],
                        PointDescriptor const & pointDesc,
                        REAL P[], REAL Du[], REAL Dv[]) const {
 
    REAL * derivatives[6] = { P, Du, Dv, 0, 0, 0 };
    evaluateDerivs(uv, patchPoints, pointDesc, derivatives);
}
template <typename REAL>
inline void
Surface<REAL>::Evaluate(REAL const uv[2],
                        REAL const patchPoints[],
                        PointDescriptor const & pointDesc,
                        REAL P[],   REAL Du[],  REAL Dv[],
                        REAL Duu[], REAL Duv[], REAL Dvv[]) const {
 
    REAL * derivatives[6] = { P, Du, Dv, Duu, Duv, Dvv };
    evaluateDerivs(uv, patchPoints, pointDesc, derivatives);
}
 
template <typename REAL>
inline int
Surface<REAL>::evaluateStencils(REAL const uv[2], REAL * sDeriv[]) const {
 
    if (IsRegular()) {
        return evalRegularStencils(uv, sDeriv);
    } else if (IsLinear()) {
        return evalMultiLinearStencils(uv, sDeriv);
    } else {
        return evalIrregularStencils(uv, sDeriv);
    }
}
template <typename REAL>
inline int
Surface<REAL>::EvaluateStencil(REAL const uv[2], REAL sP[]) const {
 
    REAL * derivativeStencils[6] = { sP, 0, 0, 0, 0, 0 };
    return evaluateStencils(uv, derivativeStencils);
}
template <typename REAL>
inline int
Surface<REAL>::EvaluateStencil(REAL const uv[2],
                          REAL sP[], REAL sDu[], REAL sDv[]) const {
 
    REAL * derivativeStencils[6] = { sP, sDu, sDv, 0, 0, 0 };
    return evaluateStencils(uv, derivativeStencils);
}
template <typename REAL>
inline int
Surface<REAL>::EvaluateStencil(REAL const uv[2],
                          REAL sP[],   REAL sDu[],  REAL sDv[],
                          REAL sDuu[], REAL sDuv[], REAL sDvv[]) const {
 
    REAL * derivativeStencils[6] = { sP, sDu, sDv, sDuu, sDuv, sDvv };
    return evaluateStencils(uv, derivativeStencils);
}
 
} // end namespace Bfr
 
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
 
} // end namespace OpenSubdiv
 
#endif /* OPENSUBDIV3_BFR_SURFACE */