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