patchTableFactory.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_FACTORY_H
#define OPENSUBDIV3_FAR_PATCH_TABLE_FACTORY_H

#include "../version.h"

#include "../far/topologyRefiner.h"
#include "../far/patchTable.h"

namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {

namespace Far {

class PatchTableFactory {
public:

    struct Options {

        enum EndCapType {
            ENDCAP_NONE = 0,        
            ENDCAP_BILINEAR_BASIS,  
            ENDCAP_BSPLINE_BASIS,   
            ENDCAP_GREGORY_BASIS,   
            ENDCAP_LEGACY_GREGORY   
        };

        Options(unsigned int maxIsolation=10) :
             generateAllLevels(false),
             includeBaseLevelIndices(true),
             includeFVarBaseLevelIndices(false),
             triangulateQuads(false),
             useSingleCreasePatch(false),
             useInfSharpPatch(false),
             maxIsolationLevel(maxIsolation),
             endCapType(ENDCAP_GREGORY_BASIS),
             shareEndCapPatchPoints(true),
             generateVaryingTables(true),
             generateVaryingLocalPoints(true),
             generateFVarTables(false),
             patchPrecisionDouble(false),
             fvarPatchPrecisionDouble(false),
             generateFVarLegacyLinearPatches(true),
             generateLegacySharpCornerPatches(true),
             numFVarChannels(-1),
             fvarChannelIndices(0)
        { }

        EndCapType GetEndCapType() const { return (EndCapType)endCapType; }

        void SetEndCapType(EndCapType e) { endCapType = e; }

        template <typename REAL> void SetPatchPrecision();

        template <typename REAL> void SetFVarPatchPrecision();

        TopologyRefiner::AdaptiveOptions GetRefineAdaptiveOptions() const {
            TopologyRefiner::AdaptiveOptions adaptiveOptions(maxIsolationLevel);

            adaptiveOptions.useInfSharpPatch     = useInfSharpPatch;
            adaptiveOptions.useSingleCreasePatch = useSingleCreasePatch;
            adaptiveOptions.considerFVarChannels = generateFVarTables &&
                                                  !generateFVarLegacyLinearPatches;
            return adaptiveOptions;
        }

        unsigned int generateAllLevels           : 1, 
                     includeBaseLevelIndices     : 1, 
                     includeFVarBaseLevelIndices : 1, 
                     triangulateQuads            : 1, 

                     useSingleCreasePatch : 1, 
                     useInfSharpPatch     : 1, 
                     maxIsolationLevel    : 4, 

                     // end-capping
                     endCapType              : 3, 
                     shareEndCapPatchPoints  : 1, 

                     // varying
                     generateVaryingTables      : 1, 
                     generateVaryingLocalPoints : 1, 

                     // face-varying
                     generateFVarTables  : 1, 

                     // precision
                     patchPrecisionDouble     : 1, 
                     fvarPatchPrecisionDouble : 1, 

                     // legacy behaviors (default to true)
                     generateFVarLegacyLinearPatches  : 1, 
                     generateLegacySharpCornerPatches : 1; 

        int          numFVarChannels;          
        int const *  fvarChannelIndices;       
    };

    static PatchTable * Create(TopologyRefiner const & refiner,
                               Options options = Options(),
                               ConstIndexArray selectedFaces = ConstIndexArray());

public:
    //  PatchFaceTag
    //
    //  This simple struct was previously used within the factory to take inventory of
    //  various kinds of patches to fully allocate buffers prior to populating them.  It
    //  was not intended to be exposed as part of the public interface.
    //
    //  It is no longer used internally and is being kept here to respect preservation
    //  of the public interface, but it will be deprecated at the earliest opportunity.
    //
    //
    struct PatchFaceTag {
    public:
        unsigned int   _hasPatch        : 1;
        unsigned int   _isRegular       : 1;
        unsigned int   _transitionMask  : 4;
        unsigned int   _boundaryMask    : 4;
        unsigned int   _boundaryIndex   : 2;
        unsigned int   _boundaryCount   : 3;
        unsigned int   _hasBoundaryEdge : 3;
        unsigned int   _isSingleCrease  : 1;

        void clear();
        void assignBoundaryPropertiesFromEdgeMask(int boundaryEdgeMask);
        void assignBoundaryPropertiesFromVertexMask(int boundaryVertexMask);
        void assignTransitionPropertiesFromEdgeMask(int boundaryVertexMask);
    };
    typedef std::vector<PatchFaceTag> PatchTagVector;
};


template <> inline void PatchTableFactory::Options::SetPatchPrecision<float>() {
    patchPrecisionDouble = false;
}
template <> inline void PatchTableFactory::Options::SetFVarPatchPrecision<float>() {
    fvarPatchPrecisionDouble = false;
}

template <> inline void PatchTableFactory::Options::SetPatchPrecision<double>() {
    patchPrecisionDouble = true;
}
template <> inline void PatchTableFactory::Options::SetFVarPatchPrecision<double>() {
    fvarPatchPrecisionDouble = true;
}


} // end namespace Far

} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;

} // end namespace OpenSubdiv


#endif /* OPENSUBDIV3_FAR_PATCH_TABLE_FACTORY_H */