patchTable.h

Go to the documentation of this file.

//
//   Copyright 2013 Pixar
//
//   Licensed under the Apache License, Version 2.0 (the "Apache License")
//   with the following modification; you may not use this file except in
//   compliance with the Apache License and the following modification to it:
//   Section 6. Trademarks. is deleted and replaced with:
//
//   6. Trademarks. This License does not grant permission to use the trade
//      names, trademarks, service marks, or product names of the Licensor
//      and its affiliates, except as required to comply with Section 4(c) of
//      the License and to reproduce the content of the NOTICE file.
//
//   You may obtain a copy of the Apache License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the Apache License with the above modification is
//   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//   KIND, either express or implied. See the Apache License for the specific
//   language governing permissions and limitations under the Apache 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;

    template <class T> void
    ComputeLocalPointValues(T const *src, T *dst) const;

    StencilTable const *GetLocalPointStencilTable() const {
        return _localPointStencils;
    }

    int GetNumLocalPointsVarying() const;

    template <class T> void
    ComputeLocalPointValuesVarying(T const *src, T *dst) const;

    StencilTable const *GetLocalPointVaryingStencilTable() const {
        return _localPointVaryingStencils;
    }

    int GetNumLocalPointsFaceVarying(int channel = 0) const;

    template <class T> void
    ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel = 0) const;

    StencilTable const *GetLocalPointFaceVaryingStencilTable(int channel = 0) const {
        if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
            return _localPointFaceVaryingStencils[channel];
        }
        return NULL;
    }



    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 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;

    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:


    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 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 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;

protected:

    friend class PatchTableFactory;

    // 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;
    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
    //

    struct FVarPatchChannel;
    typedef std::vector<FVarPatchChannel> FVarPatchChannelVector;

    FVarPatchChannel & getFVarPatchChannel(int channel);
    FVarPatchChannel const & getFVarPatchChannel(int channel) const;

    void allocateFVarPatchChannels(int numChannels);
    void allocateFVarPatchChannelValues(
        PatchDescriptor desc, 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:

    //
    // 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)
    StencilTable const * _localPointStencils;  // endcap basis conversion stencils
    StencilTable const * _localPointVaryingStencils; // endcap varying stencils (for convenience)

    //
    // Varying data
    //

    PatchDescriptor _varyingDesc;

    std::vector<Index>   _varyingVerts;

    //
    // Face-varying data
    //

    FVarPatchChannelVector _fvarChannels;

    std::vector<StencilTable const *> _localPointFaceVaryingStencils;

    //
    // 'single-crease' patch sharpness tables
    //

    std::vector<Index>   _sharpnessIndices; // Indices of single-crease sharpness (one per patch)
    std::vector<float>   _sharpnessValues;  // Sharpness values.
};

template <class T>
inline void
PatchTable::ComputeLocalPointValues(T const *src, T *dst) const {
    if (_localPointStencils) {
        _localPointStencils->UpdateValues(src, dst);
    }
}

template <class T>
inline void
PatchTable::ComputeLocalPointValuesVarying(T const *src, T *dst) const {
    if (_localPointVaryingStencils) {
        _localPointVaryingStencils->UpdateValues(src, dst);
    }
}

template <class T>
inline void
PatchTable::ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel) const {
    if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
        if (_localPointFaceVaryingStencils[channel]) {
            _localPointFaceVaryingStencils[channel]->UpdateValues(src, dst);
        }
    }
}


} // end namespace Far

} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;

} // end namespace OpenSubdiv

#endif /* OPENSUBDIV3_FAR_PATCH_TABLE */