2012-12-11 01:15:13 +00:00
|
|
|
//
|
2013-09-26 19:04:57 +00:00
|
|
|
// Copyright 2013 Pixar
|
2012-12-11 01:15:13 +00:00
|
|
|
//
|
2013-09-26 19:04:57 +00:00
|
|
|
// 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:
|
2012-12-11 01:15:13 +00:00
|
|
|
//
|
2013-09-26 19:04:57 +00:00
|
|
|
// 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.
|
2012-12-11 01:15:13 +00:00
|
|
|
//
|
2013-09-26 19:04:57 +00:00
|
|
|
// You may obtain a copy of the Apache License at
|
2012-12-11 01:15:13 +00:00
|
|
|
//
|
2013-09-26 19:04:57 +00:00
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
2013-07-18 21:19:50 +00:00
|
|
|
//
|
2013-09-26 19:04:57 +00:00
|
|
|
// 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.
|
2012-12-11 01:15:13 +00:00
|
|
|
//
|
|
|
|
|
2013-03-23 01:20:50 +00:00
|
|
|
#ifndef FAR_PATCH_TABLES_H
|
|
|
|
#define FAR_PATCH_TABLES_H
|
2012-12-11 01:15:13 +00:00
|
|
|
|
|
|
|
#include "../version.h"
|
2013-03-25 14:32:17 +00:00
|
|
|
|
2013-05-17 16:47:44 +00:00
|
|
|
#include "../far/patchParam.h"
|
2014-09-05 22:07:46 +00:00
|
|
|
#include "../far/types.h"
|
2013-05-17 16:47:44 +00:00
|
|
|
|
2013-05-09 16:23:01 +00:00
|
|
|
#include <cstdlib>
|
|
|
|
#include <cassert>
|
2013-06-11 22:59:43 +00:00
|
|
|
#include <algorithm>
|
2013-03-08 01:50:15 +00:00
|
|
|
#include <vector>
|
2013-05-17 22:46:29 +00:00
|
|
|
#include <map>
|
2012-12-11 01:15:13 +00:00
|
|
|
|
|
|
|
namespace OpenSubdiv {
|
|
|
|
namespace OPENSUBDIV_VERSION {
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
namespace Far {
|
|
|
|
|
2012-12-11 01:15:13 +00:00
|
|
|
/// \brief Container for patch vertex indices tables
|
|
|
|
///
|
2014-09-05 22:07:46 +00:00
|
|
|
/// PatchTables contain the lists of vertices for each patch of an adaptive
|
2012-12-11 01:15:13 +00:00
|
|
|
/// mesh representation.
|
|
|
|
///
|
2014-09-05 22:07:46 +00:00
|
|
|
class PatchTables {
|
2012-12-11 01:15:13 +00:00
|
|
|
|
|
|
|
public:
|
2013-05-09 00:06:59 +00:00
|
|
|
typedef std::vector<unsigned int> PTable;
|
|
|
|
typedef std::vector<int> VertexValenceTable;
|
|
|
|
typedef std::vector<unsigned int> QuadOffsetTable;
|
2014-09-05 22:07:46 +00:00
|
|
|
typedef std::vector<PatchParam> PatchParamTable;
|
2013-05-09 00:06:59 +00:00
|
|
|
|
|
|
|
enum Type {
|
2013-07-11 01:51:43 +00:00
|
|
|
NON_PATCH = 0, ///< undefined
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
POINTS, ///< points (useful for cage drawing)
|
|
|
|
LINES, ///< lines (useful for cage drawing)
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
QUADS, ///< bilinear quads-only patches
|
|
|
|
TRIANGLES, ///< bilinear triangles-only mesh
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
LOOP, ///< Loop patch (unsupported)
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
REGULAR, ///< feature-adaptive bicubic patches
|
2013-05-09 00:06:59 +00:00
|
|
|
BOUNDARY,
|
|
|
|
CORNER,
|
|
|
|
GREGORY,
|
|
|
|
GREGORY_BOUNDARY
|
|
|
|
};
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
enum TransitionPattern {
|
|
|
|
NON_TRANSITION = 0,
|
|
|
|
PATTERN0,
|
|
|
|
PATTERN1,
|
|
|
|
PATTERN2,
|
|
|
|
PATTERN3,
|
2014-05-16 01:03:44 +00:00
|
|
|
PATTERN4
|
2013-05-09 00:06:59 +00:00
|
|
|
};
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
/// \brief Describes the type of a patch
|
2013-05-09 01:47:36 +00:00
|
|
|
///
|
|
|
|
/// Uniquely identifies all the types of patches in a mesh :
|
|
|
|
///
|
|
|
|
/// * Raw polygon meshes are identified as POLYGONS and can contain faces
|
|
|
|
/// with arbitrary number of vertices
|
|
|
|
///
|
|
|
|
/// * Uniformly subdivided meshes contain bilinear patches of either QUADS
|
|
|
|
/// or TRIANGLES
|
|
|
|
///
|
|
|
|
/// * Adaptively subdivided meshes contain bicubic patches of types REGULAR,
|
|
|
|
/// BOUNDARY, CORNER, GREGORY, GREGORY_BOUNDARY. These bicubic patches are
|
|
|
|
/// also further distinguished by a transition pattern as well as a rotational
|
|
|
|
/// orientation.
|
|
|
|
///
|
|
|
|
/// An iterator class is provided as a convenience to enumerate over the set
|
|
|
|
/// of valid feature adaptive patch descriptors.
|
|
|
|
///
|
2013-05-09 00:06:59 +00:00
|
|
|
class Descriptor {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
public:
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Default constructor.
|
2013-05-09 00:06:59 +00:00
|
|
|
Descriptor() :
|
2013-05-09 20:14:02 +00:00
|
|
|
_type(NON_PATCH), _pattern(NON_TRANSITION), _rotation(0) {}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Constructor
|
2013-05-09 20:14:02 +00:00
|
|
|
Descriptor(int type, int pattern, unsigned char rotation) :
|
2013-05-14 01:43:05 +00:00
|
|
|
_type(type), _pattern(pattern), _rotation(rotation) { }
|
2013-05-09 00:06:59 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Copy Constructor
|
2013-05-09 00:06:59 +00:00
|
|
|
Descriptor( Descriptor const & d ) :
|
2013-05-09 20:14:02 +00:00
|
|
|
_type(d.GetType()), _pattern(d.GetPattern()), _rotation(d.GetRotation()) { }
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the type of the patch
|
2013-05-09 00:06:59 +00:00
|
|
|
Type GetType() const {
|
2013-05-14 01:43:05 +00:00
|
|
|
return (Type)_type;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the transition pattern of the patch if any (5 types)
|
2013-05-09 00:06:59 +00:00
|
|
|
TransitionPattern GetPattern() const {
|
2013-05-14 01:43:05 +00:00
|
|
|
return (TransitionPattern)_pattern;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the rotation of the patch (4 rotations)
|
2013-05-09 00:06:59 +00:00
|
|
|
unsigned char GetRotation() const {
|
2014-05-16 01:03:44 +00:00
|
|
|
return (unsigned char)_rotation;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the number of control vertices expected for a patch of the
|
2013-05-09 01:47:36 +00:00
|
|
|
/// type described
|
2014-05-16 01:03:44 +00:00
|
|
|
static inline short GetNumControlVertices( Type t );
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
static inline short GetNumFVarControlVertices( Type t );
|
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
/// \brief Returns the number of control vertices expected for a patch of the
|
2013-05-09 01:47:36 +00:00
|
|
|
/// type described
|
2013-05-09 00:06:59 +00:00
|
|
|
short GetNumControlVertices() const {
|
|
|
|
return GetNumControlVertices( this->GetType() );
|
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
/// \brief Returns the number of control vertices expected for a patch of the
|
|
|
|
/// type described
|
|
|
|
short GetNumFVarControlVertices() const {
|
|
|
|
return GetNumFVarControlVertices( this->GetType() );
|
|
|
|
}
|
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
/// Returns a vector of all the legal patch descriptors
|
2014-05-16 01:03:44 +00:00
|
|
|
static inline std::vector<Descriptor> const & GetAllValidDescriptors();
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
/// \brief Allows ordering of patches by type
|
2014-05-16 01:03:44 +00:00
|
|
|
inline bool operator < ( Descriptor const other ) const;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
/// \brief True if the descriptors are identical
|
2014-05-16 01:03:44 +00:00
|
|
|
inline bool operator == ( Descriptor const other ) const;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
/// \brief Descriptor Iterator
|
|
|
|
/// Iterates through the patches in the following preset order
|
2013-07-11 01:51:43 +00:00
|
|
|
///
|
2014-03-19 16:10:49 +00:00
|
|
|
/// ANY order:
|
|
|
|
/// POINTS
|
|
|
|
/// LINES
|
|
|
|
/// QUADS
|
|
|
|
/// TRIANGLES
|
|
|
|
/// LOOP
|
|
|
|
///
|
|
|
|
/// FEATURE_ADAPTIVE_CATMARK order:
|
2013-05-09 00:06:59 +00:00
|
|
|
///
|
2013-07-11 01:51:43 +00:00
|
|
|
/// NON_TRANSITION ( REGULAR
|
|
|
|
/// BOUNDARY
|
|
|
|
/// CORNER
|
|
|
|
/// GREGORY
|
|
|
|
/// GREGORY_BOUNDARY )
|
2013-05-09 00:06:59 +00:00
|
|
|
///
|
2013-07-11 01:51:43 +00:00
|
|
|
/// PATTERN0 ( REGULAR
|
|
|
|
/// BOUNDARY ROT0 ROT1 ROT2 ROT3
|
|
|
|
/// CORNER ROT0 ROT1 ROT2 ROT3 )
|
2013-05-09 00:06:59 +00:00
|
|
|
///
|
2013-07-11 01:51:43 +00:00
|
|
|
/// PATTERN1 ( REGULAR
|
|
|
|
/// BOUNDARY ROT0 ROT1 ROT2 ROT3
|
|
|
|
/// CORNER ROT0 ROT1 ROT2 ROT3 )
|
|
|
|
/// ...
|
2013-05-09 00:06:59 +00:00
|
|
|
///
|
2013-07-11 01:51:43 +00:00
|
|
|
/// NON_TRANSITION NON_PATCH ROT0 (end)
|
2013-05-09 00:06:59 +00:00
|
|
|
///
|
|
|
|
class iterator;
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2014-03-19 16:10:49 +00:00
|
|
|
enum PrimType {
|
|
|
|
ANY,
|
2014-05-16 01:03:44 +00:00
|
|
|
FEATURE_ADAPTIVE_CATMARK
|
2014-03-19 16:10:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// \brief Returns a patch type iterator
|
|
|
|
/// @param type if type=ANY then the iterater points to type POINTS
|
|
|
|
/// if type=FEATURE_ADAPTIVE_CATMARK then the iterator
|
|
|
|
/// points to type NON_TRANSITION REGULAR
|
|
|
|
static iterator begin(PrimType type);
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns an iterator to the end of the list of patch types (NON_PATCH)
|
2013-06-24 23:59:49 +00:00
|
|
|
static iterator end();
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
private:
|
2014-09-05 22:07:46 +00:00
|
|
|
friend class PatchTablesFactory;
|
2013-05-09 00:06:59 +00:00
|
|
|
friend class iterator;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-14 01:43:05 +00:00
|
|
|
unsigned int _type:4;
|
|
|
|
unsigned int _pattern:3;
|
|
|
|
unsigned int _rotation:2;
|
2013-05-09 00:06:59 +00:00
|
|
|
};
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-05-17 16:06:40 +00:00
|
|
|
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-05-17 16:06:40 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
/// \brief Describes an array of patches of the same type
|
|
|
|
class PatchArray {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
public:
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Constructor.
|
2013-05-10 17:44:03 +00:00
|
|
|
///
|
2014-02-25 01:12:39 +00:00
|
|
|
/// @param desc descriptor information for the patches in
|
2013-05-17 21:07:53 +00:00
|
|
|
/// the array
|
|
|
|
///
|
2013-05-10 17:44:03 +00:00
|
|
|
/// @param vertIndex absolute index to the first control vertex
|
|
|
|
/// of the first patch in the PTable
|
|
|
|
///
|
2014-02-25 01:12:39 +00:00
|
|
|
/// @param patchIndex absolute index of the first patch in the
|
2013-05-10 17:44:03 +00:00
|
|
|
/// array
|
|
|
|
///
|
|
|
|
/// @param npatches number of patches in the array
|
|
|
|
///
|
|
|
|
/// @param quadOffsetIndex absolute index of the first quad offset
|
|
|
|
/// entry
|
|
|
|
///
|
|
|
|
PatchArray( Descriptor desc, unsigned int vertIndex, unsigned int patchIndex, unsigned int npatches, unsigned int quadOffsetIndex ) :
|
|
|
|
_desc(desc), _range(vertIndex, patchIndex, npatches, quadOffsetIndex) { }
|
|
|
|
|
|
|
|
/// Returns a patch descriptor defining the type of patches in the array
|
|
|
|
Descriptor GetDescriptor() const {
|
|
|
|
return _desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Describes the range of patches in a PatchArray
|
2013-05-09 20:14:02 +00:00
|
|
|
struct ArrayRange {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Constructor
|
2013-05-10 17:44:03 +00:00
|
|
|
///
|
2014-05-16 01:03:44 +00:00
|
|
|
/// @param ivertIndex absolute index to the first control vertex
|
|
|
|
/// of the first patch in the PTable
|
2013-05-10 17:44:03 +00:00
|
|
|
///
|
2014-05-16 01:03:44 +00:00
|
|
|
/// @param ipatchIndex absolute index of the first patch in the
|
|
|
|
/// array
|
2013-05-10 17:44:03 +00:00
|
|
|
///
|
2014-05-16 01:03:44 +00:00
|
|
|
/// @param inpatches number of patches in the array
|
2013-05-10 17:44:03 +00:00
|
|
|
///
|
2014-05-16 01:03:44 +00:00
|
|
|
/// @param iquadOffsetIndex absolute index of the first quad offset
|
|
|
|
/// entry
|
2013-05-10 17:44:03 +00:00
|
|
|
///
|
2014-05-16 01:03:44 +00:00
|
|
|
ArrayRange( unsigned int ivertIndex, unsigned int ipatchIndex, unsigned int inpatches, unsigned int iquadOffsetIndex ) :
|
|
|
|
vertIndex(ivertIndex), patchIndex(ipatchIndex), npatches(inpatches), quadOffsetIndex(iquadOffsetIndex) { }
|
2013-05-09 20:14:02 +00:00
|
|
|
|
|
|
|
unsigned int vertIndex, // absolute index to the first control vertex of the first patch in the PTable
|
|
|
|
patchIndex, // absolute index of the first patch in the array
|
|
|
|
npatches, // number of patches in the array
|
|
|
|
quadOffsetIndex; // absolute index of the first quad offset entry
|
|
|
|
};
|
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns a array range struct
|
2013-05-09 20:14:02 +00:00
|
|
|
ArrayRange const & GetArrayRange() const {
|
|
|
|
return _range;
|
|
|
|
}
|
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
/// \brief Returns the index of the first control vertex of the first patch
|
2013-05-09 01:47:36 +00:00
|
|
|
/// of this array in the global PTable
|
2014-02-25 01:12:39 +00:00
|
|
|
unsigned int GetVertIndex() const {
|
2013-05-09 20:14:02 +00:00
|
|
|
return _range.vertIndex;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the global index of the first patch in this array (Used to
|
2013-05-17 16:47:44 +00:00
|
|
|
/// access param / fvar table data)
|
2013-05-09 00:06:59 +00:00
|
|
|
unsigned int GetPatchIndex() const {
|
2013-05-09 20:14:02 +00:00
|
|
|
return _range.patchIndex;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the number of patches in the array
|
2013-05-09 00:06:59 +00:00
|
|
|
unsigned int GetNumPatches() const {
|
2013-05-09 20:14:02 +00:00
|
|
|
return _range.npatches;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2013-05-09 16:23:01 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the index to the first entry in the QuadOffsetTable
|
2013-05-09 16:23:01 +00:00
|
|
|
unsigned int GetQuadOffsetIndex() const {
|
2013-05-09 20:14:02 +00:00
|
|
|
return _range.quadOffsetIndex;
|
2013-05-09 16:23:01 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
private:
|
2014-09-05 22:07:46 +00:00
|
|
|
friend class PatchTablesFactory;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 20:14:02 +00:00
|
|
|
Descriptor _desc; // type of patches in the array
|
|
|
|
|
|
|
|
ArrayRange _range; // index locators in the array
|
2013-05-09 00:06:59 +00:00
|
|
|
};
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
typedef std::vector<PatchArray> PatchArrayVector;
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2014-09-19 00:48:34 +00:00
|
|
|
/// \brief Handle that can be used as unique patch identifier within PatchTables
|
|
|
|
struct PatchHandle {
|
|
|
|
unsigned int patchArrayIdx, // OsdPatchArray containing the patch
|
|
|
|
patchIdx, // Absolute index of the patch
|
|
|
|
vertexOffset; // Offset to the first CV of the patch
|
|
|
|
};
|
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Get the table of patch control vertices
|
2013-05-09 00:06:59 +00:00
|
|
|
PTable const & GetPatchTable() const { return _patches; }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns a pointer to the array of patches matching the descriptor
|
2014-02-25 01:12:39 +00:00
|
|
|
PatchArray const * GetPatchArray( Descriptor desc ) const {
|
2014-09-05 22:07:46 +00:00
|
|
|
return const_cast<PatchTables *>(this)->findPatchArray( desc );
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns all arrays of patches
|
2013-05-16 00:53:40 +00:00
|
|
|
PatchArrayVector const & GetPatchArrayVector() const {
|
2013-05-09 16:23:01 +00:00
|
|
|
return _patchArrays;
|
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
/// brief Returns a pointer to the PatchArry of uniformly subdivided faces at 'level'
|
|
|
|
///
|
|
|
|
/// @param level the level of subdivision of the faces (returns the highest
|
|
|
|
/// level by default)
|
|
|
|
///
|
|
|
|
/// @return a pointer to the PatchArray or NULL if the mesh is not uniformly
|
|
|
|
/// subdivided or the level cannot be found.
|
|
|
|
///
|
|
|
|
PatchArray const * GetPatchArray(int level=0) const;
|
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns a pointer to the vertex indices of uniformly subdivided faces
|
2013-05-16 00:53:40 +00:00
|
|
|
///
|
2014-09-05 22:07:46 +00:00
|
|
|
/// In uniform mode the PatchTablesFactory can be set to generate either a
|
2013-07-26 17:38:49 +00:00
|
|
|
/// patch array containing the faces at the highest level of subdivision, or
|
|
|
|
/// a range of arrays, corresponding to multiple successive levels of subdivision.
|
|
|
|
///
|
|
|
|
/// Note : level '0' is not the coarse mesh. Currently there is no path in the
|
2014-09-05 22:07:46 +00:00
|
|
|
/// factories to convert the coarse mesh to PatchTables.
|
2013-07-26 17:38:49 +00:00
|
|
|
///
|
2013-06-19 23:31:06 +00:00
|
|
|
/// @param level the level of subdivision of the faces (returns the highest
|
|
|
|
/// level by default)
|
2013-05-16 00:53:40 +00:00
|
|
|
///
|
|
|
|
/// @return a pointer to the first vertex index or NULL if the mesh
|
|
|
|
/// is not uniformly subdivided or the level cannot be found.
|
|
|
|
///
|
2013-06-19 23:31:06 +00:00
|
|
|
unsigned int const * GetFaceVertices(int level=0) const;
|
2013-05-09 16:23:01 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the number of faces in a uniformly subdivided mesh at a given level
|
2013-05-16 00:53:40 +00:00
|
|
|
///
|
2014-09-05 22:07:46 +00:00
|
|
|
/// In uniform mode the PatchTablesFactory can be set to generate either a
|
2013-07-26 17:38:49 +00:00
|
|
|
/// patch array containing the faces at the highest level of subdivision, or
|
|
|
|
/// a range of arrays, corresponding to multiple successive levels of subdivision.
|
|
|
|
///
|
|
|
|
/// Note : level '0' is not the coarse mesh. Currently there is no path in the
|
2014-09-05 22:07:46 +00:00
|
|
|
/// factories to convert the coarse mesh to PatchTables.
|
2013-07-26 17:38:49 +00:00
|
|
|
///
|
2013-06-19 23:31:06 +00:00
|
|
|
/// @param level the level of subdivision of the faces (returns the highest
|
|
|
|
/// level by default)
|
2013-05-16 00:53:40 +00:00
|
|
|
///
|
|
|
|
/// @return the number of faces in the mesh given the subdivision level
|
2013-06-19 23:31:06 +00:00
|
|
|
/// or -1 if the mesh is not uniform or the level is incorrect.
|
2013-05-16 00:53:40 +00:00
|
|
|
///
|
2013-06-19 23:31:06 +00:00
|
|
|
int GetNumFaces(int level=0) const;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns a vertex valence table used by Gregory patches
|
2012-12-11 01:15:13 +00:00
|
|
|
VertexValenceTable const & GetVertexValenceTable() const { return _vertexValenceTable; }
|
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns a quad offsets table used by Gregory patches
|
2012-12-11 01:15:13 +00:00
|
|
|
QuadOffsetTable const & GetQuadOffsetTable() const { return _quadOffsetTable; }
|
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns a PatchParamTable for each type of patch
|
2013-05-17 16:47:44 +00:00
|
|
|
PatchParamTable const & GetPatchParamTable() const { return _paramTable; }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Ringsize of Regular Patches in table.
|
2014-05-16 01:03:44 +00:00
|
|
|
static short GetRegularPatchRingsize() { return 16; }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Ringsize of Boundary Patches in table.
|
2014-05-16 01:03:44 +00:00
|
|
|
static short GetBoundaryPatchRingsize() { return 12; }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Ringsize of Boundary Patches in table.
|
2014-05-16 01:03:44 +00:00
|
|
|
static short GetCornerPatchRingsize() { return 9; }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Ringsize of Gregory (and Gregory Boundary) Patches in table.
|
2014-05-16 01:03:44 +00:00
|
|
|
static short GetGregoryPatchRingsize() { return 4; }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the total number of patches stored in the tables
|
2013-05-09 00:06:59 +00:00
|
|
|
int GetNumPatches() const;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns the total number of control vertex indices in the tables
|
2013-05-09 00:06:59 +00:00
|
|
|
int GetNumControlVertices() const;
|
2013-03-23 01:20:50 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief Returns max vertex valence
|
2012-12-11 01:15:13 +00:00
|
|
|
int GetMaxValence() const { return _maxValence; }
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-07-11 01:51:43 +00:00
|
|
|
/// \brief True if the patches are of feature adaptive types
|
2013-05-16 00:53:40 +00:00
|
|
|
bool IsFeatureAdaptive() const;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-03-25 02:13:40 +00:00
|
|
|
/// \brief Returns the total number of vertices in the mesh across across all depths
|
|
|
|
int GetNumPtexFaces() const { return _numPtexFaces; }
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
/// \brief Face-varying patch vertex indices tables
|
|
|
|
///
|
|
|
|
/// FVarPatchTables contain the topology for face-varying primvar data
|
|
|
|
/// channels. The patch ordering matches that of PatchTables PatchArrays.
|
|
|
|
///
|
|
|
|
class FVarPatchTables {
|
2014-04-05 02:10:34 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
/// \brief Returns the number of face-varying primvar channels
|
|
|
|
int GetNumChannels() const {
|
|
|
|
return (int)_channels.size();
|
2014-04-05 02:10:34 +00:00
|
|
|
}
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
/// \brief Returns the face-varying patches vertex indices
|
|
|
|
///
|
|
|
|
/// @param channel Then face-varying primvar channel index
|
|
|
|
///
|
|
|
|
std::vector<unsigned int> const & GetPatchVertices(int channel) const {
|
|
|
|
return _channels[channel].patchVertIndices;
|
2014-04-05 02:10:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2014-09-05 22:07:46 +00:00
|
|
|
friend class PatchTablesFactory;
|
2014-04-05 02:10:34 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
struct Channel {
|
|
|
|
friend class PatchTablesFactory;
|
2014-04-05 02:10:34 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
std::vector<unsigned int> patchVertIndices; // face-varying vertex indices
|
|
|
|
};
|
2014-04-05 02:10:34 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
std::vector<Channel> _channels; // face-varying primvar channels
|
2014-04-05 02:10:34 +00:00
|
|
|
};
|
2014-09-05 22:07:46 +00:00
|
|
|
|
|
|
|
/// \brief Returns the face-varying patches
|
|
|
|
FVarPatchTables const * GetFVarPatchTables() const { return _fvarPatchTables; }
|
|
|
|
|
|
|
|
/// \brief Public constructor
|
|
|
|
///
|
|
|
|
/// @param patchArrays Vector of descriptors and ranges for arrays of patches
|
|
|
|
///
|
|
|
|
/// @param patches Indices of the control vertices of the patches
|
|
|
|
///
|
|
|
|
/// @param vertexValences Vertex valance table
|
|
|
|
///
|
|
|
|
/// @param quadOffsets Quad offset table
|
|
|
|
///
|
|
|
|
/// @param fvarPatchTables Indices of the face-varying control vertices of the patches
|
|
|
|
///
|
|
|
|
/// @param patchParams Local patch parameterization
|
|
|
|
///
|
|
|
|
/// @param maxValence Highest vertex valence allowed in the mesh
|
|
|
|
///
|
|
|
|
PatchTables(PatchArrayVector const & patchArrays,
|
2014-09-19 00:48:34 +00:00
|
|
|
PTable const & patches,
|
|
|
|
VertexValenceTable const * vertexValences,
|
|
|
|
QuadOffsetTable const * quadOffsets,
|
|
|
|
PatchParamTable const * patchParams,
|
|
|
|
FVarPatchTables const * fvarPatchTables,
|
|
|
|
int maxValence);
|
2014-09-05 22:07:46 +00:00
|
|
|
|
|
|
|
/// \brief Destructor
|
|
|
|
~PatchTables() { delete _fvarPatchTables; }
|
2014-04-05 02:10:34 +00:00
|
|
|
|
2014-09-22 17:34:46 +00:00
|
|
|
/// \brief Interpolate the (s,t) parametric location of a patch
|
2014-09-19 00:48:34 +00:00
|
|
|
///
|
|
|
|
/// @param handle A patch handle indentifying the sub-patch containing the
|
|
|
|
/// (s,t) location
|
|
|
|
///
|
|
|
|
/// @param s Patch coordinate (in coarse face normalized space)
|
|
|
|
///
|
|
|
|
/// @param t Patch coordinate (in coarse face normalized space)
|
|
|
|
///
|
|
|
|
/// @param src Source primvar buffer (control vertices data)
|
|
|
|
///
|
|
|
|
/// @param dst Destination primvar buffer (limit surface data)
|
|
|
|
///
|
2014-09-20 00:22:35 +00:00
|
|
|
template <class T, class U> void Limit(PatchHandle const & handle,
|
2014-09-19 00:48:34 +00:00
|
|
|
float s, float t, T const src, U * dst) const;
|
|
|
|
|
|
|
|
|
2012-12-11 01:15:13 +00:00
|
|
|
private:
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
friend class PatchTablesFactory;
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2014-09-19 00:48:34 +00:00
|
|
|
// Returns bi-cubic interpolation coefficients for a given (u,v) location
|
|
|
|
// on a b-spline patch
|
|
|
|
static void getBSplineWeightsAtUV(PatchParam::BitField bits, float s, float t,
|
|
|
|
float point[16], float deriv1[16], float deriv2[16]);
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2013-05-09 01:47:36 +00:00
|
|
|
// Returns the array of patches of type "desc", or NULL if there aren't any in the primitive
|
2014-05-16 01:03:44 +00:00
|
|
|
inline PatchArray * findPatchArray( Descriptor desc );
|
2013-05-09 00:06:59 +00:00
|
|
|
|
2012-12-11 01:15:13 +00:00
|
|
|
// Private constructor
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables( int maxvalence ) : _fvarPatchTables(0), _maxValence(maxvalence) { }
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchArrayVector _patchArrays; // Vector of descriptors for arrays of patches
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
PTable _patches; // Indices of the control vertices of the patches
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
VertexValenceTable _vertexValenceTable; // vertex valence table (for Gregory patches)
|
2012-12-11 01:15:13 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
QuadOffsetTable _quadOffsetTable; // quad offsets table (for Gregory patches)
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchParamTable _paramTable;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
FVarPatchTables const * _fvarPatchTables; // sparse face-varying patch table
|
2013-03-08 01:50:15 +00:00
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
// highest vertex valence allowed in the mesh (used for Gregory
|
2013-05-09 16:23:01 +00:00
|
|
|
// vertexValance & quadOffset tables)
|
2013-03-23 01:20:50 +00:00
|
|
|
int _maxValence;
|
2014-03-25 02:13:40 +00:00
|
|
|
|
|
|
|
// number of total ptex faces in quads or triangles(loop)
|
|
|
|
int _numPtexFaces;
|
|
|
|
|
2012-12-11 01:15:13 +00:00
|
|
|
};
|
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
/// \brief Descriptor iterator class
|
2014-09-05 22:07:46 +00:00
|
|
|
class PatchTables::Descriptor::iterator {
|
2013-06-24 23:59:49 +00:00
|
|
|
public:
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-06-24 23:59:49 +00:00
|
|
|
/// Constructor
|
2014-02-25 01:12:39 +00:00
|
|
|
iterator() : _pos(-1) {}
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
/// Copy Constructor
|
2014-02-25 01:12:39 +00:00
|
|
|
iterator(Descriptor desc);
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
/// Iteration increment operator
|
2014-02-25 01:12:39 +00:00
|
|
|
iterator & operator ++ ();
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
/// True of the two descriptors are identical
|
2014-02-25 01:12:39 +00:00
|
|
|
bool operator == ( iterator const & other ) const {
|
|
|
|
return (_pos==other._pos);
|
|
|
|
}
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
/// True if the two descriptors are different
|
2014-02-25 01:12:39 +00:00
|
|
|
bool operator != ( iterator const & other ) const {
|
|
|
|
return not (*this==other);
|
|
|
|
}
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
/// Dereferencing operator
|
2014-02-25 01:12:39 +00:00
|
|
|
Descriptor const * operator -> () const {
|
|
|
|
return getValue();
|
|
|
|
}
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
/// Dereferencing operator
|
2014-02-25 01:12:39 +00:00
|
|
|
Descriptor const & operator * () const {
|
|
|
|
return *getValue();
|
|
|
|
}
|
2013-06-24 23:59:49 +00:00
|
|
|
|
|
|
|
private:
|
2014-05-16 01:03:44 +00:00
|
|
|
inline Descriptor const * getValue() const;
|
2014-09-05 22:07:46 +00:00
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
int _pos;
|
2013-06-24 23:59:49 +00:00
|
|
|
};
|
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
// Iterator constructor
|
2014-09-05 22:07:46 +00:00
|
|
|
inline PatchTables::Descriptor::iterator::iterator(Descriptor desc) {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
_pos = -1;
|
|
|
|
std::vector<Descriptor> const & descs =
|
|
|
|
Descriptor::GetAllValidDescriptors();
|
|
|
|
|
|
|
|
for (int i=0; i<(int)descs.size(); ++i) {
|
|
|
|
if (descs[i] == desc) {
|
|
|
|
_pos = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Iteration increment operator
|
2014-09-05 22:07:46 +00:00
|
|
|
inline PatchTables::Descriptor::iterator &
|
|
|
|
PatchTables::Descriptor::iterator::operator ++ () {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
if (++_pos>=(int)Descriptor::GetAllValidDescriptors().size()) {
|
|
|
|
_pos = -1;
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
inline PatchTables::Descriptor const *
|
|
|
|
PatchTables::Descriptor::iterator::getValue() const {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
static Descriptor _nonpatch;
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
std::vector<Descriptor> const & descs =
|
2014-02-25 01:12:39 +00:00
|
|
|
Descriptor::GetAllValidDescriptors();
|
2014-09-05 22:07:46 +00:00
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
if (_pos>=0 and _pos<(int)descs.size()) {
|
|
|
|
return &descs[_pos];
|
|
|
|
}
|
2014-09-05 22:07:46 +00:00
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
return &_nonpatch;
|
|
|
|
}
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
inline std::vector<PatchTables::Descriptor> const &
|
|
|
|
PatchTables::Descriptor::GetAllValidDescriptors() {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
static std::vector<Descriptor> _descriptors;
|
|
|
|
|
|
|
|
if (_descriptors.empty()) {
|
2014-03-19 16:10:49 +00:00
|
|
|
_descriptors.reserve(55);
|
|
|
|
|
|
|
|
// non-patch primitives
|
|
|
|
for (int i=POINTS; i<=LOOP; ++i) {
|
|
|
|
_descriptors.push_back( Descriptor(i, NON_TRANSITION, 0) );
|
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
|
|
|
// non-transition patches
|
|
|
|
for (int i=REGULAR; i<=GREGORY_BOUNDARY; ++i) {
|
|
|
|
_descriptors.push_back( Descriptor(i, NON_TRANSITION, 0) );
|
|
|
|
}
|
|
|
|
|
|
|
|
// transition patches
|
|
|
|
for (int i=PATTERN0; i<=PATTERN4; ++i) {
|
|
|
|
|
|
|
|
_descriptors.push_back( Descriptor(REGULAR, i, 0) );
|
|
|
|
|
|
|
|
// 4 rotations for boundary & corner patches
|
|
|
|
for (int j=0; j<4; ++j) {
|
|
|
|
_descriptors.push_back( Descriptor(BOUNDARY, i, j) );
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int j=0; j<4; ++j) {
|
|
|
|
_descriptors.push_back( Descriptor(CORNER, i, j) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return _descriptors;
|
|
|
|
}
|
|
|
|
|
2013-06-24 23:59:49 +00:00
|
|
|
// Returns an iterator to the first type of patch (REGULAR NON_TRANSITION ROT0)
|
2014-09-05 22:07:46 +00:00
|
|
|
inline PatchTables::Descriptor::iterator
|
|
|
|
PatchTables::Descriptor::begin(PrimType type) {
|
2014-03-19 16:10:49 +00:00
|
|
|
switch (type) {
|
|
|
|
case ANY:
|
|
|
|
return iterator( Descriptor(POINTS, NON_TRANSITION, 0) );
|
|
|
|
case FEATURE_ADAPTIVE_CATMARK:
|
|
|
|
return iterator( Descriptor(REGULAR, NON_TRANSITION, 0) );
|
|
|
|
default:
|
|
|
|
return iterator( Descriptor() );
|
|
|
|
}
|
2013-06-24 23:59:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Returns an iterator to the end of the list of patch types (NON_PATCH)
|
2014-09-05 22:07:46 +00:00
|
|
|
inline PatchTables::Descriptor::iterator
|
|
|
|
PatchTables::Descriptor::end() {
|
2013-06-24 23:59:49 +00:00
|
|
|
return iterator( Descriptor() );
|
|
|
|
}
|
|
|
|
|
2013-05-17 19:49:57 +00:00
|
|
|
// Constructor
|
|
|
|
inline
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables::PatchTables(PatchArrayVector const & patchArrays,
|
2013-05-17 19:49:57 +00:00
|
|
|
PTable const & patches,
|
|
|
|
VertexValenceTable const * vertexValences,
|
|
|
|
QuadOffsetTable const * quadOffsets,
|
|
|
|
PatchParamTable const * patchParams,
|
2014-09-05 22:07:46 +00:00
|
|
|
FVarPatchTables const * fvarPatchTables,
|
2013-05-17 19:49:57 +00:00
|
|
|
int maxValence) :
|
|
|
|
_patchArrays(patchArrays),
|
|
|
|
_patches(patches),
|
2014-09-05 22:07:46 +00:00
|
|
|
_fvarPatchTables(fvarPatchTables),
|
2014-03-25 02:13:40 +00:00
|
|
|
_maxValence(maxValence),
|
|
|
|
_numPtexFaces(0) {
|
2013-05-17 19:49:57 +00:00
|
|
|
|
|
|
|
// copy other tables if exist
|
|
|
|
if (vertexValences)
|
|
|
|
_vertexValenceTable = *vertexValences;
|
|
|
|
if (quadOffsets)
|
|
|
|
_quadOffsetTable = *quadOffsets;
|
|
|
|
if (patchParams)
|
|
|
|
_paramTable = *patchParams;
|
|
|
|
}
|
|
|
|
|
2014-02-25 01:12:39 +00:00
|
|
|
inline bool
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables::IsFeatureAdaptive() const {
|
2013-06-10 21:36:25 +00:00
|
|
|
|
|
|
|
// the vertex valence table is only used by Gregory patches, so the PatchTables
|
|
|
|
// contain feature adaptive patches if this is not empty.
|
|
|
|
if (not _vertexValenceTable.empty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
PatchArrayVector const & parrays = GetPatchArrayVector();
|
|
|
|
|
|
|
|
// otherwise, we have to check each patch array
|
|
|
|
for (int i=0; i<(int)parrays.size(); ++i) {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-06-10 21:36:25 +00:00
|
|
|
if (parrays[i].GetDescriptor().GetType() >= REGULAR and
|
|
|
|
parrays[i].GetDescriptor().GetType() <= GREGORY_BOUNDARY)
|
|
|
|
return true;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-06-10 21:36:25 +00:00
|
|
|
}
|
|
|
|
return false;
|
2013-05-16 00:53:40 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
// Returns the number of control vertices expected for a patch of this type
|
2014-02-25 01:12:39 +00:00
|
|
|
inline short
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables::Descriptor::GetNumControlVertices( PatchTables::Type type ) {
|
2013-05-09 00:06:59 +00:00
|
|
|
switch (type) {
|
2014-09-05 22:07:46 +00:00
|
|
|
case REGULAR : return PatchTables::GetRegularPatchRingsize();
|
2013-05-09 00:06:59 +00:00
|
|
|
case QUADS : return 4;
|
|
|
|
case GREGORY :
|
2014-09-05 22:07:46 +00:00
|
|
|
case GREGORY_BOUNDARY : return PatchTables::GetGregoryPatchRingsize();
|
|
|
|
case BOUNDARY : return PatchTables::GetBoundaryPatchRingsize();
|
|
|
|
case CORNER : return PatchTables::GetCornerPatchRingsize();
|
2013-05-09 00:06:59 +00:00
|
|
|
case TRIANGLES : return 3;
|
2013-05-17 19:49:57 +00:00
|
|
|
case LINES : return 2;
|
|
|
|
case POINTS : return 1;
|
2013-05-09 00:06:59 +00:00
|
|
|
default : return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
// Returns the total number of control vertex indices in the tables
|
|
|
|
inline int
|
|
|
|
PatchTables::GetNumControlVertices() const {
|
|
|
|
|
|
|
|
int result=0;
|
|
|
|
for (int i=0; i<(int)_patchArrays.size(); ++i) {
|
|
|
|
result += _patchArrays[i].GetDescriptor().GetNumControlVertices() *
|
|
|
|
_patchArrays[i].GetNumPatches();
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the number of face-varying control vertices expected for a patch of this type
|
|
|
|
inline short
|
|
|
|
PatchTables::Descriptor::GetNumFVarControlVertices( PatchTables::Type type ) {
|
|
|
|
switch (type) {
|
|
|
|
case REGULAR : // We only support bilinear interpolation for now,
|
|
|
|
case QUADS : // so all these patches only carry 4 CVs.
|
|
|
|
case GREGORY :
|
|
|
|
case GREGORY_BOUNDARY :
|
|
|
|
case BOUNDARY :
|
|
|
|
case CORNER : return 4;
|
|
|
|
case TRIANGLES : return 3;
|
|
|
|
case LINES : return 2;
|
|
|
|
case POINTS : return 1;
|
|
|
|
default : return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a pointer to the PatchArry of uniformly subdivided faces at 'level'
|
|
|
|
inline PatchTables::PatchArray const *
|
|
|
|
PatchTables::GetPatchArray(int level) const {
|
2013-05-16 00:53:40 +00:00
|
|
|
|
|
|
|
if (IsFeatureAdaptive())
|
|
|
|
return NULL;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-16 00:53:40 +00:00
|
|
|
PatchArrayVector const & parrays = GetPatchArrayVector();
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-06-19 23:31:06 +00:00
|
|
|
if (parrays.empty())
|
|
|
|
return NULL;
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-06-19 23:31:06 +00:00
|
|
|
if (level < 1) {
|
2014-09-05 22:07:46 +00:00
|
|
|
return &(*parrays.rbegin());
|
2013-06-19 23:31:06 +00:00
|
|
|
} else if ((level-1) < (int)parrays.size() ) {
|
2014-09-05 22:07:46 +00:00
|
|
|
return &parrays[level-1];
|
2013-05-16 00:53:40 +00:00
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2013-05-16 00:53:40 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
// Returns a pointer to the vertex indices of uniformly subdivided faces
|
|
|
|
inline unsigned int const *
|
|
|
|
PatchTables::GetFaceVertices(int level) const {
|
2013-05-16 00:53:40 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchArray const * parray = GetPatchArray(level);
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
if (parray) {
|
|
|
|
return &GetPatchTable()[ parray->GetVertIndex() ];
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
// Returns the number of faces in a uniformly subdivided mesh at a given level
|
|
|
|
inline int
|
|
|
|
PatchTables::GetNumFaces(int level) const {
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchArray const * parray = GetPatchArray(level);
|
2014-02-25 01:12:39 +00:00
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
if (parray) {
|
|
|
|
return parray->GetNumPatches();
|
|
|
|
}
|
2013-05-16 00:53:40 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-05-09 00:06:59 +00:00
|
|
|
// Allows ordering of patches by type
|
2014-02-25 01:12:39 +00:00
|
|
|
inline bool
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables::Descriptor::operator < ( Descriptor const other ) const {
|
2013-05-09 17:53:22 +00:00
|
|
|
return _pattern < other._pattern or ((_pattern == other._pattern) and
|
|
|
|
(_type < other._type or ((_type == other._type) and
|
2013-05-09 20:14:02 +00:00
|
|
|
(_rotation < other._rotation))));
|
|
|
|
}
|
2013-05-09 00:06:59 +00:00
|
|
|
|
|
|
|
// True if the descriptors are identical
|
2013-05-09 16:23:01 +00:00
|
|
|
inline bool
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables::Descriptor::operator == ( Descriptor const other ) const {
|
2013-05-09 16:23:01 +00:00
|
|
|
return _pattern == other._pattern and
|
|
|
|
_type == other._type and
|
2013-05-09 20:14:02 +00:00
|
|
|
_rotation == other._rotation;
|
2013-05-09 00:06:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a pointer to the array of patches matching the descriptor
|
2014-09-05 22:07:46 +00:00
|
|
|
inline PatchTables::PatchArray *
|
|
|
|
PatchTables::findPatchArray( PatchTables::Descriptor desc ) {
|
2013-05-09 00:06:59 +00:00
|
|
|
|
|
|
|
for (int i=0; i<(int)_patchArrays.size(); ++i) {
|
|
|
|
if (_patchArrays[i].GetDescriptor()==desc)
|
|
|
|
return &_patchArrays[i];
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-23 01:20:50 +00:00
|
|
|
// Returns the total number of patches stored in the tables
|
2013-05-09 00:06:59 +00:00
|
|
|
inline int
|
2014-09-05 22:07:46 +00:00
|
|
|
PatchTables::GetNumPatches() const {
|
2013-06-11 22:59:43 +00:00
|
|
|
// there is one PatchParam record for each patch in the mesh
|
|
|
|
return (int)GetPatchParamTable().size();
|
2013-03-23 01:20:50 +00:00
|
|
|
}
|
|
|
|
|
2014-09-19 00:48:34 +00:00
|
|
|
template <class T, class U>
|
|
|
|
inline void
|
|
|
|
InterpolateRegularPatch(unsigned int const * cvs,
|
|
|
|
float const * Q, float const *Qd1, float const *Qd2,
|
|
|
|
T const src, U * dst) {
|
|
|
|
|
|
|
|
//
|
|
|
|
// v0 -- v1 -- v2 -- v3
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// v4 -- v5 -- v6 -- v7
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// v8 -- v9 -- v10-- v11
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// v12-- v13-- v14-- v15
|
|
|
|
//
|
|
|
|
for (int k=0; k<16; ++k) {
|
|
|
|
dst->AddWithWeight(src[cvs[k]], Q[k], Qd1[k], Qd2[k]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T, class U>
|
|
|
|
inline void
|
|
|
|
InterpolateBoundaryPatch(unsigned int const * cvs,
|
|
|
|
float const * Q, float const *Qd1, float const *Qd2,
|
|
|
|
T const src, U * dst) {
|
|
|
|
|
|
|
|
// mirror the missing vertices (M)
|
|
|
|
//
|
|
|
|
// M0 -- M1 -- M2 -- M3 (corner)
|
|
|
|
// | | | |
|
|
|
|
// | | | |
|
|
|
|
// v0 -- v1 -- v2 -- v3 M : mirrored
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// v4 -- v5 -- v6 -- v7 v : original Cv
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// |.....|.....|.....|
|
|
|
|
// v8 -- v9 -- v10-- v11
|
|
|
|
//
|
|
|
|
for (int k=0; k<4; ++k) { // M0 - M3
|
|
|
|
dst->AddWithWeight(src[cvs[k]], 2.0f*Q[k], 2.0f*Qd1[k], 2.0f*Qd2[k]);
|
|
|
|
dst->AddWithWeight(src[cvs[k+4]], -1.0f*Q[k], -1.0f*Qd1[k], -1.0f*Qd2[k]);
|
|
|
|
}
|
|
|
|
for (int k=0; k<12; ++k) {
|
|
|
|
dst->AddWithWeight(src[cvs[k]], Q[k+4], Qd1[k+4], Qd2[k+4]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T, class U>
|
|
|
|
inline void
|
|
|
|
InterpolateCornerPatch(unsigned int const * cvs,
|
|
|
|
float const * Q, float const *Qd1, float const *Qd2,
|
|
|
|
T const src, U * dst) {
|
|
|
|
|
|
|
|
// mirror the missing vertices (M)
|
|
|
|
//
|
|
|
|
// M0 -- M1 -- M2 -- M3 (corner)
|
|
|
|
// | | | |
|
|
|
|
// | | | |
|
|
|
|
// v0 -- v1 -- v2 -- M4 M : mirrored
|
|
|
|
// |.....|.....| |
|
|
|
|
// |.....|.....| |
|
|
|
|
// v3.--.v4.--.v5 -- M5 v : original Cv
|
|
|
|
// |.....|.....| |
|
|
|
|
// |.....|.....| |
|
|
|
|
// v6 -- v7 -- v8 -- M6
|
|
|
|
//
|
|
|
|
for (int k=0; k<3; ++k) { // M0 - M2
|
|
|
|
dst->AddWithWeight(src[cvs[k ]], 2.0f*Q[k], 2.0f*Qd1[k], 2.0f*Qd2[k]);
|
|
|
|
dst->AddWithWeight(src[cvs[k+3]], -1.0f*Q[k], -1.0f*Qd1[k], -1.0f*Qd2[k]);
|
|
|
|
}
|
|
|
|
for (int k=0; k<3; ++k) { // M4 - M6
|
|
|
|
int idx = (k+1)*4 + 3;
|
|
|
|
dst->AddWithWeight(src[cvs[k*3+2]], 2.0f*Q[idx], 2.0f*Qd1[idx], 2.0f*Qd2[idx]);
|
|
|
|
dst->AddWithWeight(src[cvs[k*3+1]], -1.0f*Q[idx], -1.0f*Qd1[idx], -1.0f*Qd2[idx]);
|
|
|
|
}
|
|
|
|
// M3 = -2.v1 + 4.v2 + v4 - 2.v5
|
|
|
|
dst->AddWithWeight(src[cvs[1]], -2.0f*Q[3], -2.0f*Qd1[3], -2.0f*Qd2[3]);
|
|
|
|
dst->AddWithWeight(src[cvs[2]], 4.0f*Q[3], 4.0f*Qd1[3], 4.0f*Qd2[3]);
|
|
|
|
dst->AddWithWeight(src[cvs[4]], 1.0f*Q[3], 1.0f*Qd1[3], 1.0f*Qd2[3]);
|
|
|
|
dst->AddWithWeight(src[cvs[5]], -2.0f*Q[3], -2.0f*Qd1[3], -2.0f*Qd2[3]);
|
|
|
|
for (int y=0; y<3; ++y) { // v0 - v8
|
|
|
|
for (int x=0; x<3; ++x) {
|
|
|
|
int idx = y*4+x+4;
|
|
|
|
dst->AddWithWeight(src[cvs[y*3+x]], Q[idx], Qd1[idx], Qd2[idx]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Interpolates the limit position of a parametric location on a patch
|
|
|
|
template <class T, class U>
|
|
|
|
inline void
|
2014-09-20 00:22:35 +00:00
|
|
|
PatchTables::Limit(PatchHandle const & handle, float s, float t,
|
2014-09-19 00:48:34 +00:00
|
|
|
T const src, U * dst) const {
|
|
|
|
|
|
|
|
assert(dst);
|
|
|
|
|
|
|
|
PatchTables::PatchArray const & parray =
|
|
|
|
_patchArrays[handle.patchArrayIdx];
|
|
|
|
|
|
|
|
unsigned int const * cvs =
|
|
|
|
&_patches[parray.GetVertIndex() + handle.vertexOffset];
|
|
|
|
|
|
|
|
PatchParam::BitField const & bits =
|
|
|
|
_paramTable[handle.patchIdx].bitField;
|
|
|
|
|
|
|
|
bits.Normalize(s,t);
|
|
|
|
|
|
|
|
Type ptype = parray.GetDescriptor().GetType();
|
|
|
|
|
|
|
|
if (ptype>=REGULAR and ptype<=CORNER) {
|
|
|
|
|
|
|
|
float Q[16], Qd1[16], Qd2[16];
|
|
|
|
|
|
|
|
getBSplineWeightsAtUV(bits, s, t, Q, Qd1, Qd2);
|
|
|
|
|
|
|
|
float scale = float(1 << bits.GetDepth());
|
|
|
|
for (int k=0; k<16; ++k) {
|
|
|
|
Qd1[k] *= scale;
|
|
|
|
Qd2[k] *= scale;
|
|
|
|
}
|
2014-09-22 17:34:46 +00:00
|
|
|
|
2014-09-19 00:48:34 +00:00
|
|
|
dst->Clear();
|
|
|
|
|
|
|
|
switch (ptype) {
|
|
|
|
case REGULAR:
|
|
|
|
InterpolateRegularPatch(cvs, Q, Qd1, Qd2, src, dst);
|
|
|
|
break;
|
|
|
|
case BOUNDARY:
|
|
|
|
InterpolateBoundaryPatch(cvs, Q, Qd1, Qd2, src, dst);
|
|
|
|
break;
|
|
|
|
case CORNER:
|
|
|
|
InterpolateCornerPatch(cvs, Q, Qd1, Qd2, src, dst);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
} else if (ptype>=GREGORY and ptype<=GREGORY_BOUNDARY) {
|
|
|
|
|
|
|
|
} else {
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-05 22:07:46 +00:00
|
|
|
} // end namespace Far
|
2013-03-23 01:20:50 +00:00
|
|
|
|
2012-12-11 01:15:13 +00:00
|
|
|
} // end namespace OPENSUBDIV_VERSION
|
|
|
|
using namespace OPENSUBDIV_VERSION;
|
|
|
|
|
|
|
|
} // end namespace OpenSubdiv
|
|
|
|
|
2013-03-23 01:20:50 +00:00
|
|
|
#endif /* FAR_PATCH_TABLES */
|