surfaceFactoryMeshAdapter.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_FACTORY_ADAPTER_H
#define OPENSUBDIV3_BFR_SURFACE_FACTORY_ADAPTER_H
 
#include "../version.h"
 
#include <cstdint>
 
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
 
namespace Bfr {
 
class VertexDescriptor;

//  SurfaceFactoryMeshAdapter is an abstract class that defines the interface
//  through which subclasses of SurfaceFactory adapt to a connected mesh
//  representation. The interface defines methods that describe the mesh
//  topology and control indices in the neighborhood of a mesh -- from
//  which the SurfaceFactory to identifies an appropriate limit surface.
//
//  SurfaceFactoryMeshAdapter methods require a subclass to provide a complete
//  description of the topology around a base face, as well as indices
//  associated with it (both vertex and face-varying).  The intent here is
//  to keep the number of methods required to a minimum, and also to minimize
//  the number of invocations required by the factory.
//
//  With the need to support both linear and non-linear cases (for which
//  linear is trivial by comparison) and the limit surface for both vertex
//  and face-varying topologies, the result is a small set of methods
//  covering this matrix of functionality.
//
//  Since face-varying data may differ in topology from the vertex data --
//  with each set of face-varying data potentially having its own unique
//  topology -- sets of face-varying data are uniquely distinguished by an
//  associated integer (a face-varying ID).
//
class SurfaceFactoryMeshAdapter {
public:
    typedef int Index;

    typedef std::intptr_t FVarID;
 
protected:
    SurfaceFactoryMeshAdapter() { }
    virtual ~SurfaceFactoryMeshAdapter() { }
 
protected:


    virtual bool isFaceHole(Index faceIndex) const = 0;

    virtual int getFaceSize(Index faceIndex) const = 0;



    virtual int getFaceVertexIndices(Index faceIndex,
                    Index vertexIndices[]) const = 0;

    virtual int getFaceFVarValueIndices(Index faceIndex,
                    FVarID fvarID, Index fvarValueIndices[]) const = 0;
 
protected:

 
    virtual int populateFaceVertexDescriptor(
                    Index faceIndex, int faceVertex,
                    VertexDescriptor * vertexDescriptor) const = 0;
 
    virtual int getFaceVertexIncidentFaceVertexIndices(
                    Index faceIndex, int faceVertex,
                    Index vertexIndices[]) const = 0;

    virtual int getFaceVertexIncidentFaceFVarValueIndices(
                    Index faceIndex, int faceVertex,
                    FVarID fvarID, Index fvarValueIndices[]) const = 0;
 
protected:

    virtual bool getFaceNeighborhoodVertexIndicesIfRegular(
            Index faceIndex, Index vertexIndices[]) const;
 
    virtual bool getFaceNeighborhoodFVarValueIndicesIfRegular(
            Index faceIndex, FVarID fvarID, Index fvarValueIndices[]) const;
 
private:
    //  No private members
};
 
//
//  Inline defaults for optional methods:
//
inline bool
SurfaceFactoryMeshAdapter::getFaceNeighborhoodVertexIndicesIfRegular(
        Index, Index[]) const {
    return false;
}
 
inline bool
SurfaceFactoryMeshAdapter::getFaceNeighborhoodFVarValueIndicesIfRegular(
        Index, FVarID, Index[]) const {
    return false;
}
 
} // end namespace Bfr
 
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
 
} // end namespace OpenSubdiv
 
#endif /* OPENSUBDIV3_BFR_SURFACE_FACTORY_ADAPTER_H */