mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-12-13 12:30:10 +00:00
673088637b
- PatchTableFactory::Options method returns TopologyRefiner::AdaptiveOptions
- far/tutorial_6 and 9 updated to illustrate use of the new method
225 lines
10 KiB
C++
225 lines
10 KiB
C++
//
|
|
// 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 {
|
|
|
|
/// \brief Factory for constructing a PatchTable from a TopologyRefiner
|
|
///
|
|
class PatchTableFactory {
|
|
public:
|
|
|
|
/// \brief Public options for the PatchTable factory
|
|
///
|
|
struct Options {
|
|
|
|
enum EndCapType {
|
|
ENDCAP_NONE = 0, ///< no endcap
|
|
ENDCAP_BILINEAR_BASIS, ///< use bilinear quads (4 cp) as end-caps
|
|
ENDCAP_BSPLINE_BASIS, ///< use BSpline basis patches (16 cp) as end-caps
|
|
ENDCAP_GREGORY_BASIS, ///< use Gregory basis patches (20 cp) as end-caps
|
|
ENDCAP_LEGACY_GREGORY ///< use legacy (2.x) Gregory patches (4 cp + valence table) as end-caps
|
|
};
|
|
|
|
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),
|
|
setPatchPrecisionDouble(false),
|
|
setFVarPatchPrecisionDouble(false),
|
|
generateFVarLegacyLinearPatches(true),
|
|
generateLegacySharpCornerPatches(true),
|
|
numFVarChannels(-1),
|
|
fvarChannelIndices(0)
|
|
{ }
|
|
|
|
/// \brief Get endcap patch type
|
|
EndCapType GetEndCapType() const { return (EndCapType)endCapType; }
|
|
|
|
/// \brief Set endcap patch type
|
|
void SetEndCapType(EndCapType e) { endCapType = e; }
|
|
|
|
/// \brief Set precision of vertex patches
|
|
template <typename REAL> void SetPatchPrecision();
|
|
|
|
/// \brief Set precision of face-varying patches
|
|
template <typename REAL> void SetFVarPatchPrecision();
|
|
|
|
/// \brief Determine adaptive refinement options to match assigned patch options
|
|
TopologyRefiner::AdaptiveOptions GetRefineAdaptiveOptions() const {
|
|
TopologyRefiner::AdaptiveOptions adaptiveOptions(maxIsolationLevel);
|
|
|
|
adaptiveOptions.useInfSharpPatch = useInfSharpPatch;
|
|
adaptiveOptions.useSingleCreasePatch = useSingleCreasePatch;
|
|
adaptiveOptions.considerFVarChannels = generateFVarTables &&
|
|
!generateFVarLegacyLinearPatches;
|
|
return adaptiveOptions;
|
|
}
|
|
|
|
unsigned int generateAllLevels : 1, ///< Generate levels from 'firstLevel' to 'maxLevel' (Uniform mode only)
|
|
includeBaseLevelIndices : 1, ///< Include base level in patch point indices (Uniform mode only)
|
|
includeFVarBaseLevelIndices : 1, ///< Include base level in face-varying patch point indices (Uniform mode only)
|
|
triangulateQuads : 1, ///< Triangulate 'QUADS' primitives (Uniform mode only)
|
|
|
|
useSingleCreasePatch : 1, ///< Use single crease patch
|
|
useInfSharpPatch : 1, ///< Use infinitely-sharp patch
|
|
maxIsolationLevel : 4, ///< Cap adaptive feature isolation to the given level (max. 10)
|
|
|
|
// end-capping
|
|
endCapType : 3, ///< EndCapType
|
|
shareEndCapPatchPoints : 1, ///< Share endcap patch points among adjacent endcap patches.
|
|
///< currently only work with GregoryBasis.
|
|
|
|
// varying
|
|
generateVaryingTables : 1, ///< Generate varying patch tables
|
|
generateVaryingLocalPoints : 1, ///< Generate local points with varying patches
|
|
|
|
// face-varying
|
|
generateFVarTables : 1, ///< Generate face-varying patch tables
|
|
|
|
// precision
|
|
setPatchPrecisionDouble : 1, ///< Generate double-precision stencils for vertex patches
|
|
setFVarPatchPrecisionDouble : 1, ///< Generate double-precision stencils for face-varying patches
|
|
|
|
// legacy behaviors (default to true)
|
|
generateFVarLegacyLinearPatches : 1, ///< Generate all linear face-varying patches (legacy)
|
|
generateLegacySharpCornerPatches : 1; ///< Generate sharp regular patches at smooth corners (legacy)
|
|
|
|
int numFVarChannels; ///< Number of channel indices and interpolation modes passed
|
|
int const * fvarChannelIndices; ///< List containing the indices of the channels selected for the factory
|
|
};
|
|
|
|
/// \brief Instantiates a PatchTable from a client-provided TopologyRefiner.
|
|
///
|
|
/// A PatchTable can be constructed from a TopologyRefiner that has been
|
|
/// either adaptively or uniformly refined. In both cases, the resulting
|
|
/// patches reference vertices in the various refined levels by index,
|
|
/// and those indices accumulate with the levels in different ways.
|
|
///
|
|
/// For adaptively refined patches, patches are defined at different levels,
|
|
/// including the base level, so the indices of patch vertices include
|
|
/// vertices from all levels. A sparse set of patches can be created by
|
|
/// restricting the patches generated to those descending from a given set
|
|
/// of faces at the base level. This sparse set of base faces is expected
|
|
/// to be a subset of the faces that were adaptively refined in the given
|
|
/// TopologyRefiner, otherwise results are undefined.
|
|
///
|
|
/// For uniformly refined patches, all patches are completely defined within
|
|
/// the last level. There is often no use for intermediate levels and they
|
|
/// can usually be ignored. Indices of patch vertices might therefore be
|
|
/// expected to be defined solely within the last level. While this is true
|
|
/// for face-varying patches, for historical reasons it is not the case for
|
|
/// vertex and varying patches. Indices for vertex and varying patches include
|
|
/// the base level in addition to the last level while indices for face-varying
|
|
/// patches include only the last level.
|
|
///
|
|
/// @param refiner TopologyRefiner from which to generate patches
|
|
///
|
|
/// @param options Options controlling the creation of the table
|
|
///
|
|
/// @param selectedFaces Only create patches for the given set of base faces.
|
|
///
|
|
/// @return A new instance of PatchTable
|
|
///
|
|
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.
|
|
//
|
|
/// \brief Obsolete internal struct accidentally exposed for public use -- due to
|
|
/// be deprecated.
|
|
//
|
|
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>() {
|
|
setPatchPrecisionDouble = false;
|
|
}
|
|
template <> inline void PatchTableFactory::Options::SetFVarPatchPrecision<float>() {
|
|
setFVarPatchPrecisionDouble = false;
|
|
}
|
|
|
|
template <> inline void PatchTableFactory::Options::SetPatchPrecision<double>() {
|
|
setPatchPrecisionDouble = true;
|
|
}
|
|
template <> inline void PatchTableFactory::Options::SetFVarPatchPrecision<double>() {
|
|
setFVarPatchPrecisionDouble = true;
|
|
}
|
|
|
|
|
|
} // end namespace Far
|
|
|
|
} // end namespace OPENSUBDIV_VERSION
|
|
using namespace OPENSUBDIV_VERSION;
|
|
|
|
} // end namespace OpenSubdiv
|
|
|
|
|
|
#endif /* OPENSUBDIV3_FAR_PATCH_TABLE_FACTORY_H */
|