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