patchTable.h

Go to the documentation of this file.

//
//   Copyright 2013 Pixar
//
//   Licensed under the terms set forth in the LICENSE.txt file available at
//   https://opensubdiv.org/license.
//
 
#ifndef OPENSUBDIV3_FAR_PATCH_TABLE_H
#define OPENSUBDIV3_FAR_PATCH_TABLE_H
 
#include "../version.h"
 
#include "../far/patchDescriptor.h"
#include "../far/patchParam.h"
#include "../far/stencilTable.h"
 
#include "../sdc/options.h"
 
#include <vector>
 
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
 
namespace Far {
 
class PatchTable {
 
public:
 
    class PatchHandle {
    // XXXX manuelk members will eventually be made private
    public:
 
        friend class PatchTable;
        friend class PatchMap;
 
        Index arrayIndex, // Array index of the patch
              patchIndex, // Absolute Index of the patch
              vertIndex;  // Relative offset to the first CV of the patch in array
    };
 
public:
 
    PatchTable(PatchTable const & src);
 
    ~PatchTable();
 
    bool IsFeatureAdaptive() const;
 
    int GetNumControlVerticesTotal() const {
        return (int)_patchVerts.size();
    }
 
    int GetNumPatchesTotal() const;
 
    int GetMaxValence() const { return _maxValence; }
 
    int GetNumPtexFaces() const { return _numPtexFaces; }
 
 
 
 
    PatchDescriptor GetPatchDescriptor(PatchHandle const & handle) const;
 
    ConstIndexArray GetPatchVertices(PatchHandle const & handle) const;
 
    PatchParam GetPatchParam(PatchHandle const & handle) const;
 
    ConstIndexArray GetPatchVertices(int array, int patch) const;
 
    PatchParam GetPatchParam(int array, int patch) const;
 
 
 
 
    int GetNumPatchArrays() const;
 
    int GetNumPatches(int array) const;
 
    int GetNumControlVertices(int array) const;
 
    PatchDescriptor GetPatchArrayDescriptor(int array) const;
 
    ConstIndexArray GetPatchArrayVertices(int array) const;
 
    ConstPatchParamArray const GetPatchParams(int array) const;
 
 
 
 
    int GetNumLocalPoints() const;
 
    StencilTable const *GetLocalPointStencilTable() const;
 
    template <typename REAL>
    StencilTableReal<REAL> const *GetLocalPointStencilTable() const;
 
    template <typename REAL> bool LocalPointStencilPrecisionMatchesType() const;
 
    template <class T> void
    ComputeLocalPointValues(T const *src, T *dst) const;
 
 
    int GetNumLocalPointsVarying() const;
 
    StencilTable const *GetLocalPointVaryingStencilTable() const;
 
    template <typename REAL>
    StencilTableReal<REAL> const *GetLocalPointVaryingStencilTable() const;
 
    template <typename REAL> bool LocalPointVaryingStencilPrecisionMatchesType() const;
 
    template <class T> void
    ComputeLocalPointValuesVarying(T const *src, T *dst) const;
 
 
    int GetNumLocalPointsFaceVarying(int channel = 0) const;
 
    StencilTable const *GetLocalPointFaceVaryingStencilTable(int channel = 0) const;
 
    template <typename REAL>
    StencilTableReal<REAL> const * GetLocalPointFaceVaryingStencilTable(int channel = 0) const;
 
    template <typename REAL> bool LocalPointFaceVaryingStencilPrecisionMatchesType() const;
 
    template <class T> void
    ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel = 0) const;
 
 
 
 
    typedef Vtr::ConstArray<unsigned int> ConstQuadOffsetsArray;
 
    ConstQuadOffsetsArray GetPatchQuadOffsets(PatchHandle const & handle) const;
 
    typedef std::vector<Index> VertexValenceTable;
 
    VertexValenceTable const & GetVertexValenceTable() const {
        return _vertexValenceTable;
    }
 
 
 
 
    float GetSingleCreasePatchSharpnessValue(PatchHandle const & handle) const;
 
    float GetSingleCreasePatchSharpnessValue(int array, int patch) const;
 
 
 
 
    PatchDescriptor GetVaryingPatchDescriptor() const;
 
    ConstIndexArray GetPatchVaryingVertices(PatchHandle const & handle) const;
 
    ConstIndexArray GetPatchVaryingVertices(int array, int patch) const;
 
    ConstIndexArray GetPatchArrayVaryingVertices(int array) const;
 
    ConstIndexArray GetVaryingVertices() const;
 
 
 
 
    int GetNumFVarChannels() const;
 
    PatchDescriptor GetFVarPatchDescriptorRegular(int channel = 0) const;
 
    PatchDescriptor GetFVarPatchDescriptorIrregular(int channel = 0) const;
 
    PatchDescriptor GetFVarPatchDescriptor(int channel = 0) const;
 
    ConstIndexArray GetPatchFVarValues(PatchHandle const & handle, int channel = 0) const;
 
    ConstIndexArray GetPatchFVarValues(int array, int patch, int channel = 0) const;
 
    ConstIndexArray GetPatchArrayFVarValues(int array, int channel = 0) const;
 
    ConstIndexArray GetFVarValues(int channel = 0) const;
 
    int GetFVarValueStride(int channel = 0) const;
 
    PatchParam GetPatchFVarPatchParam(PatchHandle const & handle, int channel = 0) const;
 
    PatchParam GetPatchFVarPatchParam(int array, int patch, int channel = 0) const;
 
    ConstPatchParamArray GetPatchArrayFVarPatchParams(int array, int channel = 0) const;
 
    ConstPatchParamArray GetFVarPatchParams(int channel = 0) const;
 
    Sdc::Options::FVarLinearInterpolation GetFVarChannelLinearInterpolation(int channel = 0) const;
 
 
 
 
    typedef std::vector<Index> PatchVertsTable;
 
    PatchVertsTable const & GetPatchControlVerticesTable() const { return _patchVerts; }
 
    PatchParamTable const & GetPatchParamTable() const { return _paramTable; }
 
    std::vector<Index> const &GetSharpnessIndexTable() const { return _sharpnessIndices; }
 
    std::vector<float> const &GetSharpnessValues() const { return _sharpnessValues; }
 
    typedef std::vector<unsigned int> QuadOffsetsTable;
 
    QuadOffsetsTable const & GetQuadOffsetsTable() const {
        return _quadOffsetsTable;
    }
 
    void print() const;
 
public:
 
 
 
    template <typename REAL>
    void EvaluateBasis(PatchHandle const & handle, REAL u, REAL v,
        REAL wP[], REAL wDu[] = 0, REAL wDv[] = 0,
        REAL wDuu[] = 0, REAL wDuv[] = 0, REAL wDvv[] = 0) const;
 
    void EvaluateBasis(PatchHandle const & handle, float u, float v,
        float wP[], float wDu[] = 0, float wDv[] = 0,
        float wDuu[] = 0, float wDuv[] = 0, float wDvv[] = 0) const;
 
    void EvaluateBasis(PatchHandle const & handle, double u, double v,
        double wP[], double wDu[] = 0, double wDv[] = 0,
        double wDuu[] = 0, double wDuv[] = 0, double wDvv[] = 0) const;
 
    template <typename REAL>
    void EvaluateBasisVarying(PatchHandle const & handle, REAL u, REAL v,
        REAL wP[], REAL wDu[] = 0, REAL wDv[] = 0,
        REAL wDuu[] = 0, REAL wDuv[] = 0, REAL wDvv[] = 0) const;
 
    void EvaluateBasisVarying(PatchHandle const & handle, float u, float v,
        float wP[], float wDu[] = 0, float wDv[] = 0,
        float wDuu[] = 0, float wDuv[] = 0, float wDvv[] = 0) const;
 
    void EvaluateBasisVarying(PatchHandle const & handle, double u, double v,
        double wP[], double wDu[] = 0, double wDv[] = 0,
        double wDuu[] = 0, double wDuv[] = 0, double wDvv[] = 0) const;
 
    template <typename REAL>
    void EvaluateBasisFaceVarying(PatchHandle const & handle, REAL u, REAL v,
        REAL wP[], REAL wDu[] = 0, REAL wDv[] = 0,
        REAL wDuu[] = 0, REAL wDuv[] = 0, REAL wDvv[] = 0,
        int channel = 0) const;
 
    void EvaluateBasisFaceVarying(PatchHandle const & handle, float u, float v,
        float wP[], float wDu[] = 0, float wDv[] = 0,
        float wDuu[] = 0, float wDuv[] = 0, float wDvv[] = 0,
        int channel = 0) const;
 
    void EvaluateBasisFaceVarying(PatchHandle const & handle, double u, double v,
        double wP[], double wDu[] = 0, double wDv[] = 0,
        double wDuu[] = 0, double wDuv[] = 0, double wDvv[] = 0,
        int channel = 0) const;
 
protected:
 
    friend class PatchTableBuilder;
 
    // Factory constructor
    PatchTable(int maxvalence);
 
    Index getPatchIndex(int array, int patch) const;
 
    PatchParamArray getPatchParams(int arrayIndex);
 
    Index * getSharpnessIndices(Index arrayIndex);
    float * getSharpnessValues(Index arrayIndex);
 
private:
 
    //
    // Patch arrays
    //
    struct PatchArray {
        PatchArray(PatchDescriptor d, int np, Index v, Index p, Index qo) :
            desc(d), numPatches(np), vertIndex(v),
            patchIndex(p), quadOffsetIndex (qo) { }
 
        void print() const;
 
        PatchDescriptor desc;  // type of patches in the array
 
        int numPatches;        // number of patches in the array
 
        Index vertIndex,       // index to the first control vertex
              patchIndex,      // absolute index of the first patch in the array
              quadOffsetIndex; // index of the first quad offset entry
    };
 
    typedef std::vector<PatchArray> PatchArrayVector;
 
    PatchArray & getPatchArray(Index arrayIndex);
    PatchArray const & getPatchArray(Index arrayIndex) const;
 
    void reservePatchArrays(int numPatchArrays);
    void pushPatchArray(PatchDescriptor desc, int npatches,
        Index * vidx, Index * pidx, Index * qoidx=0);
 
    IndexArray getPatchArrayVertices(int arrayIndex);
 
    Index findPatchArray(PatchDescriptor desc);
 
 
    //
    // Varying patch arrays
    //
    IndexArray getPatchArrayVaryingVertices(int arrayIndex);
 
    void allocateVaryingVertices(
        PatchDescriptor desc, int numPatches);
    void populateVaryingVertices();
 
    //
    // Face-varying patch channels
    //
 
    //
    // FVarPatchChannel
    //
    // Stores a record for each patch in the primitive :
    //
    //  - Each patch in the PatchTable has a corresponding patch in each
    //    face-varying patch channel. Patch vertex indices are sorted in the same
    //    patch-type order as PatchTable::PTables. Face-varying data for a patch
    //    can therefore be quickly accessed by using the patch primitive ID as
    //    index into patchValueOffsets to locate the face-varying control vertex
    //    indices.
    //
    //  - Face-varying channels can have a different interpolation modes
    //
    //  - Unlike "vertex" patches, there are no transition masks required
    //    for face-varying patches.
    //
    //  - Face-varying patches still require boundary edge masks.
    //
    //  - currently most patches with sharp boundaries but smooth interiors have
    //    to be isolated to level 10 : we need a special type of bicubic patch
    //    similar to single-crease to resolve this condition without requiring
    //    isolation if possible
    //
    struct FVarPatchChannel {
        Sdc::Options::FVarLinearInterpolation interpolation;
 
        PatchDescriptor regDesc;
        PatchDescriptor irregDesc;
 
        int stride;
 
        std::vector<Index> patchValues;
        std::vector<PatchParam> patchParam;
    };
    typedef std::vector<FVarPatchChannel> FVarPatchChannelVector;
 
    FVarPatchChannel & getFVarPatchChannel(int channel);
    FVarPatchChannel const & getFVarPatchChannel(int channel) const;
 
    void allocateFVarPatchChannels(int numChannels);
    void allocateFVarPatchChannelValues(
        PatchDescriptor regDesc, PatchDescriptor irregDesc,
        int numPatches, int channel);
 
    // deprecated
    void setFVarPatchChannelLinearInterpolation(
        Sdc::Options::FVarLinearInterpolation interpolation, int channel);
 
    IndexArray getFVarValues(int channel);
    ConstIndexArray getPatchFVarValues(int patch, int channel) const;
 
    PatchParamArray getFVarPatchParams(int channel);
    PatchParam getPatchFVarPatchParam(int patch, int channel) const;
 
private:
    //
    //  Simple private class to hold stencil table pointers of varying precision,
    //  where the discriminant of the precision is external.
    //
    //  NOTE that this is a simple pointer container and NOT a smart pointer that
    //  manages the ownership of the object referred to by it.
    //
    class StencilTablePtr {
    private:
        typedef StencilTableReal<float>  float_type;
        typedef StencilTableReal<double> double_type;
 
        union {
            float_type  * _fPtr;
            double_type * _dPtr;
        };
 
    public:
        StencilTablePtr()                  { _fPtr = 0; }
        StencilTablePtr(float_type  * ptr) { _fPtr = ptr; }
        StencilTablePtr(double_type * ptr) { _dPtr = ptr; }
 
        operator bool() const { return _fPtr != 0; }
 
        void Set()                  { _fPtr = 0; }
        void Set(float_type  * ptr) { _fPtr = ptr; }
        void Set(double_type * ptr) { _dPtr = ptr; }
 
        template <typename REAL> StencilTableReal<REAL> * Get() const;
    };
 
private:
 
    //
    // Topology
    //
 
    int _maxValence,   // highest vertex valence found in the mesh
        _numPtexFaces; // total number of ptex faces
 
    PatchArrayVector     _patchArrays;  // Vector of descriptors for arrays of patches
 
    std::vector<Index>   _patchVerts;   // Indices of the control vertices of the patches
 
    PatchParamTable      _paramTable;   // PatchParam bitfields (one per patch)
 
    //
    // Extraordinary vertex closed-form evaluation / endcap basis conversion
    //
    // XXXtakahito: these data will probably be replaced with mask coefficient or something
    //              SchemeWorker populates.
    //
    QuadOffsetsTable     _quadOffsetsTable;   // Quad offsets (for Gregory patches)
    VertexValenceTable   _vertexValenceTable; // Vertex valence table (for Gregory patches)
 
    StencilTablePtr _localPointStencils;        // local point conversion stencils
    StencilTablePtr _localPointVaryingStencils; // local point varying stencils
 
    //
    // Varying data
    //
    PatchDescriptor _varyingDesc;
 
    std::vector<Index>   _varyingVerts;
 
    //
    // Face-varying data
    //
    FVarPatchChannelVector _fvarChannels;
 
    std::vector<StencilTablePtr> _localPointFaceVaryingStencils;
 
    //
    // 'single-crease' patch sharpness tables
    //
    std::vector<Index>   _sharpnessIndices; // Indices of single-crease sharpness (one per patch)
    std::vector<float>   _sharpnessValues;  // Sharpness values.
 
    //
    //  Construction history -- relevant to at least one public query:
    //
    unsigned int _isUniformLinear : 1;
 
    //
    //  Precision -- only applies to local-point stencil tables
    //
    unsigned int _vertexPrecisionIsDouble      : 1;
    unsigned int _varyingPrecisionIsDouble     : 1;
    unsigned int _faceVaryingPrecisionIsDouble : 1;
};
 
 
//
//  Template specializations for float/double -- to be defined before used:
//
template <> inline StencilTableReal<float> *
PatchTable::StencilTablePtr::Get<float>() const { return _fPtr; }
 
template <> inline StencilTableReal<double> *
PatchTable::StencilTablePtr::Get<double>() const { return _dPtr; }
 
template <> inline bool
PatchTable::LocalPointStencilPrecisionMatchesType<float>() const {
    return !_vertexPrecisionIsDouble;
}
template <> inline bool
PatchTable::LocalPointVaryingStencilPrecisionMatchesType<float>() const {
    return !_varyingPrecisionIsDouble;
}
template <> inline bool
PatchTable::LocalPointFaceVaryingStencilPrecisionMatchesType<float>() const {
    return !_faceVaryingPrecisionIsDouble;
}
 
template <> inline bool
PatchTable::LocalPointStencilPrecisionMatchesType<double>() const {
    return _vertexPrecisionIsDouble;
}
template <> inline bool
PatchTable::LocalPointVaryingStencilPrecisionMatchesType<double>() const {
    return _varyingPrecisionIsDouble;
}
template <> inline bool
PatchTable::LocalPointFaceVaryingStencilPrecisionMatchesType<double>() const {
    return _faceVaryingPrecisionIsDouble;
}
 
//
//  StencilTable access -- backward compatible and generic:
//
inline StencilTable const *
PatchTable::GetLocalPointStencilTable() const {
    assert(LocalPointStencilPrecisionMatchesType<float>());
    return reinterpret_cast<StencilTable const *>(_localPointStencils.Get<float>());
}
inline StencilTable const *
PatchTable::GetLocalPointVaryingStencilTable() const {
    assert(LocalPointVaryingStencilPrecisionMatchesType<float>());
    return reinterpret_cast<StencilTable const *>(
            _localPointVaryingStencils.Get<float>());
}
inline StencilTable const *
PatchTable::GetLocalPointFaceVaryingStencilTable(int channel) const {
    assert(LocalPointFaceVaryingStencilPrecisionMatchesType<float>());
    if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
        return reinterpret_cast<StencilTable const *>(
                _localPointFaceVaryingStencils[channel].Get<float>());
    }
    return NULL;
}
 
template <typename REAL>
inline StencilTableReal<REAL> const *
PatchTable::GetLocalPointStencilTable() const {
    assert(LocalPointStencilPrecisionMatchesType<REAL>());
    return _localPointStencils.Get<REAL>();
}
template <typename REAL>
inline StencilTableReal<REAL> const *
PatchTable::GetLocalPointVaryingStencilTable() const {
    assert(LocalPointVaryingStencilPrecisionMatchesType<REAL>());
    return _localPointVaryingStencils.Get<REAL>();
}
template <typename REAL>
inline StencilTableReal<REAL> const *
PatchTable::GetLocalPointFaceVaryingStencilTable(int channel) const {
    assert(LocalPointFaceVaryingStencilPrecisionMatchesType<REAL>());
    if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
        return _localPointFaceVaryingStencils[channel].Get<REAL>();
    }
    return NULL;
}
 
 
//
//  Computation of local point values:
//
template <class T>
inline void
PatchTable::ComputeLocalPointValues(T const *src, T *dst) const {
    assert(LocalPointStencilPrecisionMatchesType<float>());
    if (_localPointStencils) {
        _localPointStencils.Get<float>()->UpdateValues(src, dst);
    }
}
 
template <class T>
inline void
PatchTable::ComputeLocalPointValuesVarying(T const *src, T *dst) const {
    assert(LocalPointVaryingStencilPrecisionMatchesType<float>());
    if (_localPointVaryingStencils) {
        _localPointVaryingStencils.Get<float>()->UpdateValues(src, dst);
    }
}
 
template <class T>
inline void
PatchTable::ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel) const {
    assert(LocalPointFaceVaryingStencilPrecisionMatchesType<float>());
    if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
        if (_localPointFaceVaryingStencils[channel]) {
            _localPointFaceVaryingStencils[channel].Get<float>()->UpdateValues(src, dst);
        }
    }
}
 
 
//
//  Basis evaluation overloads
//
inline void
PatchTable::EvaluateBasis(PatchHandle const & handle, float u, float v,
    float wP[], float wDu[], float wDv[],
    float wDuu[], float wDuv[], float wDvv[]) const {
 
    EvaluateBasis<float>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
}
inline void
PatchTable::EvaluateBasis(PatchHandle const & handle, double u, double v,
    double wP[], double wDu[], double wDv[],
    double wDuu[], double wDuv[], double wDvv[]) const {
 
    EvaluateBasis<double>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
}
 
inline void
PatchTable::EvaluateBasisVarying(PatchHandle const & handle, float u, float v,
    float wP[], float wDu[], float wDv[],
    float wDuu[], float wDuv[], float wDvv[]) const {
 
    EvaluateBasisVarying<float>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
}
inline void
PatchTable::EvaluateBasisVarying(PatchHandle const & handle, double u, double v,
    double wP[], double wDu[], double wDv[],
    double wDuu[], double wDuv[], double wDvv[]) const {
 
    EvaluateBasisVarying<double>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
}
 
inline void
PatchTable::EvaluateBasisFaceVarying(PatchHandle const & handle, float u, float v,
    float wP[], float wDu[], float wDv[],
    float wDuu[], float wDuv[], float wDvv[], int channel) const {
 
    EvaluateBasisFaceVarying<float>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv, channel);
}
inline void
PatchTable::EvaluateBasisFaceVarying(PatchHandle const & handle, double u, double v,
    double wP[], double wDu[], double wDv[],
    double wDuu[], double wDuv[], double wDvv[], int channel) const {
 
    EvaluateBasisFaceVarying<double>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv, channel);
}
 
} // end namespace Far
 
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
 
} // end namespace OpenSubdiv
 
#endif /* OPENSUBDIV3_FAR_PATCH_TABLE */