topologyRefiner.h

Go to the documentation of this file.

//
//   Copyright 2014 DreamWorks Animation LLC.
//
//   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_TOPOLOGY_REFINER_H
#define OPENSUBDIV3_FAR_TOPOLOGY_REFINER_H
 
#include "../version.h"
 
#include "../sdc/types.h"
#include "../sdc/options.h"
#include "../far/types.h"
#include "../far/topologyLevel.h"
 
#include <vector>
 
 
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
 
namespace Vtr { namespace internal { class SparseSelector; } }
namespace Far { namespace internal { class FeatureMask; } }
 
namespace Far {
 
template <typename REAL> class PrimvarRefinerReal;
template <class MESH> class TopologyRefinerFactory;
 
class TopologyRefiner {
 
public:
 
    TopologyRefiner(Sdc::SchemeType type, Sdc::Options options = Sdc::Options());
 
    ~TopologyRefiner();
 
    Sdc::SchemeType GetSchemeType() const    { return _subdivType; }
 
    Sdc::Options GetSchemeOptions() const { return _subdivOptions; }
 
    bool IsUniform() const   { return _isUniform; }
 
    int  GetNumLevels() const { return (int)_farLevels.size(); }
 
    int  GetMaxLevel() const { return _maxLevel; }
 
    int  GetMaxValence() const { return _maxValence; }
 
    bool HasHoles() const { return _hasHoles; }
 
    int GetNumVerticesTotal() const { return _totalVertices; }
 
    int GetNumEdgesTotal() const { return _totalEdges; }
 
    int GetNumFacesTotal() const { return _totalFaces; }
 
    int GetNumFaceVerticesTotal() const { return _totalFaceVertices; }
 
    TopologyLevel const & GetLevel(int level) const { return _farLevels[level]; }
 
 
 
    //
    // Uniform refinement
    //
 
    struct UniformOptions {
 
        UniformOptions(int level) :
            refinementLevel(level & 0xf),
            orderVerticesFromFacesFirst(false),
            fullTopologyInLastLevel(false) { }
 
        void SetRefinementLevel(int level) { refinementLevel = level & 0xf; }
 
        unsigned int refinementLevel:4,             
                     orderVerticesFromFacesFirst:1, 
                     fullTopologyInLastLevel:1;     
    };
 
    void RefineUniform(UniformOptions options);
 
    UniformOptions GetUniformOptions() const { return _uniformOptions; }
 
    //
    // Adaptive refinement
    //
 
    struct AdaptiveOptions {
 
        AdaptiveOptions(int level) :
            isolationLevel(level & 0xf),
            secondaryLevel(0xf),
            useSingleCreasePatch(false),
            useInfSharpPatch(false),
            considerFVarChannels(false),
            orderVerticesFromFacesFirst(false) { }
 
        void SetIsolationLevel(int level) { isolationLevel = level & 0xf; }
 
        void SetSecondaryLevel(int level) { secondaryLevel = level & 0xf; }
 
        unsigned int isolationLevel:4;              
        unsigned int secondaryLevel:4;              
        unsigned int useSingleCreasePatch:1;        
        unsigned int useInfSharpPatch:1;            
        unsigned int considerFVarChannels:1;        
        unsigned int orderVerticesFromFacesFirst:1; 
    };
 
    void RefineAdaptive(AdaptiveOptions options,
                        ConstIndexArray selectedFaces = ConstIndexArray());
 
    AdaptiveOptions GetAdaptiveOptions() const { return _adaptiveOptions; }
 
    void Unrefine();
 
 
 
 
    int GetNumFVarChannels() const;
 
    Sdc::Options::FVarLinearInterpolation GetFVarLinearInterpolation(int channel = 0) const;
 
    int GetNumFVarValuesTotal(int channel = 0) const;
 
 
protected:
 
    //
    //  Lower level protected methods intended strictly for internal use:
    //
    template <class MESH>
    friend class TopologyRefinerFactory;
    friend class TopologyRefinerFactoryBase;
    friend class PatchTableBuilder;
    friend class PatchBuilder;
    friend class PtexIndices;
    template <typename REAL>
    friend class PrimvarRefinerReal;
 
    //  Copy constructor exposed via the factory class:
    TopologyRefiner(TopologyRefiner const & source);
 
public:
    //  Levels and Refinements available internally (avoids need for more friends)
    Vtr::internal::Level & getLevel(int l) { return *_levels[l]; }
    Vtr::internal::Level const & getLevel(int l) const { return *_levels[l]; }
 
    Vtr::internal::Refinement & getRefinement(int l) { return *_refinements[l]; }
    Vtr::internal::Refinement const & getRefinement(int l) const { return *_refinements[l]; }
 
private:
    //  Not default constructible or copyable:
    TopologyRefiner() : _uniformOptions(0), _adaptiveOptions(0) { }
    TopologyRefiner & operator=(TopologyRefiner const &) { return *this; }
 
    void selectFeatureAdaptiveComponents(Vtr::internal::SparseSelector& selector,
                                         internal::FeatureMask const & mask,
                                         ConstIndexArray selectedFaces);
    void selectLinearIrregularFaces(Vtr::internal::SparseSelector& selector,
                                    ConstIndexArray selectedFaces);
 
    void initializeInventory();
    void updateInventory(Vtr::internal::Level const & newLevel);
 
    void appendLevel(Vtr::internal::Level & newLevel);
    void appendRefinement(Vtr::internal::Refinement & newRefinement);
    void assembleFarLevels();
 
private:
 
    Sdc::SchemeType _subdivType;
    Sdc::Options    _subdivOptions;
 
    unsigned int _isUniform     : 1;
    unsigned int _hasHoles      : 1;
    unsigned int _hasIrregFaces : 1;
    unsigned int _regFaceSize   : 3;
    unsigned int _maxLevel      : 4;
 
    //  Options assigned on refinement:
    UniformOptions  _uniformOptions;
    AdaptiveOptions _adaptiveOptions;
 
    //  Cumulative properties of all levels:
    int _totalVertices;
    int _totalEdges;
    int _totalFaces;
    int _totalFaceVertices;
    int _maxValence;
 
    //  Note the base level may be shared with another instance
    bool _baseLevelOwned;
 
    std::vector<Vtr::internal::Level *>      _levels;
    std::vector<Vtr::internal::Refinement *> _refinements;
 
    std::vector<TopologyLevel> _farLevels;
};
 
 
inline int
TopologyRefiner::GetNumFVarChannels() const {
 
    return _levels[0]->getNumFVarChannels();
}
inline Sdc::Options::FVarLinearInterpolation
TopologyRefiner::GetFVarLinearInterpolation(int channel) const {
 
    return _levels[0]->getFVarOptions(channel).GetFVarLinearInterpolation();
}
 
} // end namespace Far
 
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
} // end namespace OpenSubdiv
 
#endif /* OPENSUBDIV3_FAR_TOPOLOGY_REFINER_H */