tessellation.h

Go to the documentation of this file.

//
//   Copyright 2021 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_BFR_TESSELLATION_H
#define OPENSUBDIV3_BFR_TESSELLATION_H
 
#include "../version.h"
 
#include "../bfr/parameterization.h"
 
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
 
namespace Bfr {
 
class Tessellation {
public:
    class Options {
    public:
        Options() : _preserveQuads(false), _facetSize4(false),
                    _coordStride(0), _facetStride(0) { }
 
        Options & PreserveQuads(bool on);
        bool      PreserveQuads() const { return _preserveQuads; }
 
        Options & SetFacetSize(int numIndices);
        //  @brief Return the number of indices per facet
        int       GetFacetSize() const { return 3 + (int)_facetSize4; }
 
        Options & SetFacetStride(int stride);
        int       GetFacetStride() const { return _facetStride; }
 
        Options & SetCoordStride(int stride);
        int       GetCoordStride() const { return _coordStride; }
 
    private:
        unsigned int _preserveQuads : 1;
        unsigned int _facetSize4    : 1;
 
        short _coordStride;
        short _facetStride;
    };
 
public:
 
 
    Tessellation(Parameterization const & p, int uniformRate,
                 Options const & options = Options());
 
    Tessellation(Parameterization const & p, int numRates, int const rates[],
                 Options const & options = Options());
 
    bool IsValid() const { return _isValid; }
 
    Tessellation() = delete;
 
    Tessellation(Tessellation const &) = delete;
    Tessellation & operator=(Tessellation const &) = delete;
    ~Tessellation();
 
 
 
    Parameterization GetParameterization() const { return _param; }
 
    int GetFaceSize() const { return _param.GetFaceSize(); }
 
    int GetRates(int rates[]) const;
 
    bool IsUniform() const { return _isUniform; }
 
 
 
    int GetNumCoords() const { return _numInteriorPoints + _numBoundaryPoints; }
 
    int GetCoordStride() const { return _coordStride; }
 
    int GetNumBoundaryCoords() const { return _numBoundaryPoints; }
 
    int GetNumInteriorCoords() const { return _numInteriorPoints; }
 
    int GetNumEdgeCoords(int edge) const { return _outerRates[edge] - 1; }
 
    template <typename REAL>
    int GetCoords(REAL coordTuples[]) const;
 
    template <typename REAL>
    int GetBoundaryCoords(REAL coordTuples[]) const;
 
    template <typename REAL>
    int GetInteriorCoords(REAL coordTuples[]) const;
 
    template <typename REAL>
    int GetVertexCoord(int vertex, REAL coordTuples[]) const;
 
    template <typename REAL>
    int GetEdgeCoords(int edge,  REAL coordTuples[]) const;
 
 
 
    int GetNumFacets() const { return _numFacets; }
 
    int GetFacetSize() const { return _facetSize; }
 
    int GetFacetStride() const { return _facetStride; }
 
    int GetFacets(int facetTuples[]) const;
 
 
 
    void TransformFacetCoordIndices(int facetTuples[], int commonOffset);
 
    void TransformFacetCoordIndices(int facetTuples[],
                                    int const boundaryIndices[],
                                    int       interiorOffset);
 
    void TransformFacetCoordIndices(int facetTuples[],
                                    int const boundaryIndices[],
                                    int const interiorIndices[]);
 
private:
    //  Private initialization methods:
    bool validateArguments(Parameterization const & p,
                    int nRates, int const rates[], Options const & options);
 
    void initialize(Parameterization const & p,
                    int nRates, int const rates[], Options const & options);
 
    void initializeDefaults();
    int  initializeRates(int nRates, int const rates[]);
    void initializeInventoryForParamTri(int sumOfOuterRates);
    void initializeInventoryForParamQuad(int sumOfOuterRates);
    void initializeInventoryForParamQPoly(int sumOfOuterRates);
 
private:
    //  Private members:
    Parameterization _param;
 
    unsigned short _isValid       :  1;
    unsigned short _isUniform     :  1;
    unsigned short _triangulate   :  1;
    unsigned short _singleFace    :  1;
    unsigned short _segmentedFace :  1;
    unsigned short _triangleFan   :  1;
    unsigned short _splitQuad     :  1;
 
    short _facetSize;
    int   _facetStride;
    int   _coordStride;
 
    int _numGivenRates;
    int _numBoundaryPoints;
    int _numInteriorPoints;
    int _numFacets;
 
    int  _innerRates[2];
    int* _outerRates;
    int  _outerRatesLocal[4];
};
 
//
//  Inline implementations:
//
inline Tessellation::Options &
Tessellation::Options::PreserveQuads(bool on) {
    _preserveQuads = on;
    return *this;
}
inline Tessellation::Options &
Tessellation::Options::SetFacetSize(int numIndices) {
    _facetSize4 = (numIndices == 4);
    return *this;
}
inline Tessellation::Options &
Tessellation::Options::SetFacetStride(int stride)  {
    _facetStride = (short) stride;
    return *this;
}
inline Tessellation::Options &
Tessellation::Options::SetCoordStride(int stride) {
    _coordStride = (short) stride;
    return *this;
}
 
template <typename REAL>
inline int
Tessellation::GetVertexCoord(int vertex, REAL coord[]) const {
    _param.GetVertexCoord(vertex, coord);
    return 1;
}
 
template <typename REAL>
inline int
Tessellation::GetCoords(REAL coordTuples[]) const {
    int nCoords = GetBoundaryCoords(coordTuples);
    nCoords += GetInteriorCoords(coordTuples + nCoords * _coordStride);
    return nCoords;
}
 
} // end namespace Bfr
 
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
 
} // end namespace OpenSubdiv
 
#endif /* OPENSUBDIV3_BFR_TESSELLATION */