mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-12-13 04:20:10 +00:00
565 lines
18 KiB
C++
565 lines
18 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.
|
|
//
|
|
|
|
#pragma once
|
|
#ifndef OPENSUBDIV3_FAR_PATCH_TABLES_H
|
|
#define OPENSUBDIV3_FAR_PATCH_TABLES_H
|
|
|
|
#include "../version.h"
|
|
|
|
#include "../far/interpolate.h"
|
|
#include "../far/patchDescriptor.h"
|
|
|
|
#include "../sdc/options.h"
|
|
|
|
#include <cstdlib>
|
|
#include <cassert>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
#include <map>
|
|
|
|
namespace OpenSubdiv {
|
|
namespace OPENSUBDIV_VERSION {
|
|
|
|
namespace Far {
|
|
|
|
/// \brief Container for arrays of parametric patches
|
|
///
|
|
/// PatchTables contain topology and parametric information about the patches
|
|
/// generated by the Refinement process. Patches in the tables are sorted into
|
|
/// arrays based on their PatchDescriptor Type.
|
|
///
|
|
/// Note : PatchTables can be accessed either using a PatchHandle or a
|
|
/// combination of array and patch indices.
|
|
///
|
|
/// XXXX manuelk we should add a PatchIterator that can dereference into
|
|
/// a PatchHandle for fast linear traversal of the tables
|
|
///
|
|
class PatchTables {
|
|
|
|
public:
|
|
|
|
/// \brief Handle that can be used as unique patch identifier within PatchTables
|
|
class PatchHandle {
|
|
// XXXX manuelk members will eventually be made private
|
|
public:
|
|
|
|
friend class PatchTables;
|
|
friend class PatchMap;
|
|
|
|
Index arrayIndex, // Array index of the patch
|
|
patchIndex, // Absolute Index of the patch
|
|
vertIndex; // Relative offset to the first CV of the patch in array
|
|
};
|
|
|
|
public:
|
|
|
|
/// \brief Copy constructor
|
|
PatchTables(PatchTables const & src);
|
|
|
|
/// \brief Destructor
|
|
~PatchTables();
|
|
|
|
/// \brief True if the patches are of feature adaptive types
|
|
bool IsFeatureAdaptive() const;
|
|
|
|
/// \brief Returns the total number of control vertex indices in the tables
|
|
int GetNumControlVerticesTotal() const {
|
|
return (int)_patchVerts.size();
|
|
}
|
|
|
|
/// \brief Returns the total number of patches stored in the tables
|
|
int GetNumPatchesTotal() const;
|
|
|
|
/// \brief Returns max vertex valence
|
|
int GetMaxValence() const { return _maxValence; }
|
|
|
|
/// \brief Returns the total number of ptex faces in the mesh
|
|
int GetNumPtexFaces() const { return _numPtexFaces; }
|
|
|
|
|
|
//@{
|
|
/// @name Individual patches
|
|
///
|
|
/// \anchor individual_patches
|
|
///
|
|
/// \brief Accessors for individual patches
|
|
///
|
|
|
|
/// \brief Returns the PatchDescriptor for the patches in array 'array'
|
|
PatchDescriptor GetPatchDescriptor(PatchHandle const & handle) const;
|
|
|
|
/// \brief Returns the control vertex indices for the patch identified by 'handle'
|
|
ConstIndexArray GetPatchVertices(PatchHandle const & handle) const;
|
|
|
|
/// \brief Returns a PatchParam for the patch identified by 'handle'
|
|
PatchParam GetPatchParam(PatchHandle const & handle) const;
|
|
|
|
/// \brief Returns the control vertex indices for the patch 'patch' in array 'array'
|
|
ConstIndexArray GetPatchVertices(int array, int patch) const;
|
|
|
|
/// \brief Returns the PatchParam for the patch 'patch' in array 'array'
|
|
PatchParam GetPatchParam(int array, int patch) const;
|
|
//@}
|
|
|
|
|
|
//@{
|
|
/// @name Arrays of patches
|
|
///
|
|
/// \anchor arrays_of_patches
|
|
///
|
|
/// \brief Accessors for arrays of patches of the same type
|
|
///
|
|
|
|
/// \brief Returns the number of patch arrays in the table
|
|
int GetNumPatchArrays() const;
|
|
|
|
/// \brief Returns the number of patches in patch array 'array'
|
|
int GetNumPatches(int array) const;
|
|
|
|
/// \brief Returns the number of control vertices in patch array 'array'
|
|
int GetNumControlVertices(int array) const;
|
|
|
|
/// \brief Returns the PatchDescriptor for the patches in array 'array'
|
|
PatchDescriptor GetPatchArrayDescriptor(int array) const;
|
|
|
|
/// \brief Returns the control vertex indices for the patches in array 'array'
|
|
ConstIndexArray GetPatchArrayVertices(int array) const;
|
|
|
|
/// \brief Returns the PatchParams for the patches in array 'array'
|
|
ConstPatchParamArray const GetPatchParams(int array) const;
|
|
//@}
|
|
|
|
|
|
//@{
|
|
/// @name End-Cap patches
|
|
///
|
|
/// \anchor end_cap_patches
|
|
///
|
|
/// \brief Accessors for end-cap patch additional data
|
|
///
|
|
|
|
typedef Vtr::ConstArray<unsigned int> ConstQuadOffsetsArray;
|
|
|
|
/// \brief Returns the 'QuadOffsets' for the Gregory patch identified by 'handle'
|
|
ConstQuadOffsetsArray GetPatchQuadOffsets(PatchHandle const & handle) const;
|
|
|
|
typedef std::vector<Index> VertexValenceTable;
|
|
|
|
/// \brief Returns the 'VertexValences' table (vertex neighborhoods table)
|
|
VertexValenceTable const & GetVertexValenceTable() const {
|
|
return _vertexValenceTable;
|
|
}
|
|
|
|
/// \brief Returns the basis conversion stencil tables to get endcap patch points.
|
|
/// This stencil is relative to the max level refined vertices.
|
|
StencilTables const *GetEndCapVertexStencilTables() const {
|
|
return _vertexStencilTables;
|
|
}
|
|
|
|
/// \brief Returns the varying stencil tables for the endcap patches
|
|
/// which has same ordering as the endcap vertex stencil tables.
|
|
StencilTables const *GetEndCapVaryingStencilTables() const {
|
|
return _varyingStencilTables;
|
|
}
|
|
|
|
//@}
|
|
|
|
|
|
//@{
|
|
/// @name Single-crease patches
|
|
///
|
|
/// \anchor single_crease_patches
|
|
///
|
|
/// \brief Accessors for single-crease patch edge sharpness
|
|
///
|
|
|
|
/// \brief Returns the crease sharpness for the patch identified by 'handle'
|
|
/// if it is a single-crease patch, or 0.0f
|
|
float GetSingleCreasePatchSharpnessValue(PatchHandle const & handle) const;
|
|
|
|
/// \brief Returns the crease sharpness for the patch 'patch' in array 'array'
|
|
/// if it is a single-crease patch, or 0.0f
|
|
float GetSingleCreasePatchSharpnessValue(int array, int patch) const;
|
|
//@}
|
|
|
|
|
|
//@{
|
|
/// @name Face-varying channels
|
|
///
|
|
/// \anchor face_varying_channels
|
|
///
|
|
/// \brief Accessors for face-varying channels
|
|
///
|
|
|
|
/// \brief Returns the number of face-varying channels
|
|
int GetNumFVarChannels() const;
|
|
|
|
|
|
/// \brief Returns the interpolation mode for a given channel
|
|
Sdc::Options::FVarLinearInterpolation GetFVarChannelLinearInterpolation(int channel) const;
|
|
|
|
|
|
/// \brief Returns a descriptor for a given patch in a channel
|
|
PatchDescriptor::Type GetFVarPatchType(int channel, PatchHandle const & handle) const;
|
|
|
|
/// \brief Returns a descriptor for a given patch in a channel
|
|
PatchDescriptor::Type GetFVarPatchType(int channel, int array, int patch) const;
|
|
|
|
/// \brief Returns an array of descriptors for the patches in a channel
|
|
Vtr::ConstArray<PatchDescriptor::Type> GetFVarPatchTypes(int channel) const;
|
|
|
|
|
|
/// \brief Returns the value indices for a given patch in a channel
|
|
ConstIndexArray GetFVarPatchValues(int channel, PatchHandle const & handle) const;
|
|
|
|
/// \brief Returns the value indices for a given patch in a channel
|
|
ConstIndexArray GetFVarPatchValues(int channel, int array, int patch) const;
|
|
|
|
|
|
/// \brief Returns an array of value indices for the patches in a channel
|
|
ConstIndexArray GetFVarPatchesValues(int channel) const;
|
|
//@}
|
|
|
|
|
|
//@{
|
|
/// @name Direct accessors
|
|
///
|
|
/// \warning These direct accessors are left for convenience, but they are
|
|
/// likely going to be deprecated in future releases
|
|
///
|
|
|
|
typedef std::vector<Index> PatchVertsTable;
|
|
|
|
/// \brief Get the table of patch control vertices
|
|
PatchVertsTable const & GetPatchControlVerticesTable() const { return _patchVerts; }
|
|
|
|
/// \brief Returns the PatchParamTable (PatchParams order matches patch array sorting)
|
|
PatchParamTable const & GetPatchParamTable() const { return _paramTable; }
|
|
|
|
/// \brief Returns a sharpness index table for each patch (if exists)
|
|
std::vector<Index> const &GetSharpnessIndexTable() const { return _sharpnessIndices; }
|
|
|
|
/// \brief Returns sharpness values table
|
|
std::vector<float> const &GetSharpnessValues() const { return _sharpnessValues; }
|
|
|
|
typedef std::vector<unsigned int> QuadOffsetsTable;
|
|
|
|
/// \brief Returns the quad-offsets table
|
|
QuadOffsetsTable const & GetQuadOffsetsTable() const {
|
|
return _quadOffsetsTable;
|
|
}
|
|
//@}
|
|
|
|
/// debug helper
|
|
void print() const;
|
|
|
|
public:
|
|
|
|
//@{
|
|
/// @name Interpolation methods
|
|
//
|
|
|
|
/// \brief Interpolate the (s,t) parametric location of a *bilinear* patch
|
|
///
|
|
/// \note This method can only be used on uniform PatchTables of quads (see
|
|
/// IsFeatureAdaptive() method)
|
|
///
|
|
/// @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)
|
|
///
|
|
template <class T, class U> void EvaluateBilinear(PatchHandle const & handle,
|
|
float s, float t, T const & src, U & dst) const;
|
|
|
|
|
|
/// \brief Interpolate the (s,t) parametric location of a *bicubic* patch
|
|
///
|
|
/// \note This method can only be used on feature adaptive PatchTables (ie.
|
|
/// IsFeatureAdaptive() is false)
|
|
///
|
|
/// @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)
|
|
///
|
|
template <class T, class U> void Evaluate(PatchHandle const & handle,
|
|
float s, float t, T const & src, U & dst) const;
|
|
|
|
/// \brief Interpolate the (s,t) parametric location of a *bicubic*
|
|
/// face-varying patch
|
|
///
|
|
/// @param channel The face-varying primvar channel
|
|
///
|
|
/// @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)
|
|
///
|
|
template <class T, class U> void EvaluateFaceVarying(int channel,
|
|
PatchHandle const & handle, float s, float t, T const & src, U & dst) const;
|
|
|
|
//@}
|
|
|
|
protected:
|
|
|
|
friend class PatchTablesFactory;
|
|
friend class EndCapLegacyGregoryPatchFactory;
|
|
|
|
// Factory constructor
|
|
PatchTables(int maxvalence);
|
|
|
|
Index getPatchIndex(int array, int patch) const;
|
|
|
|
PatchParamArray getPatchParams(int arrayIndex);
|
|
|
|
Index * getSharpnessIndices(Index arrayIndex);
|
|
float * getSharpnessValues(Index arrayIndex);
|
|
|
|
private:
|
|
|
|
//
|
|
// Patch arrays
|
|
//
|
|
|
|
struct PatchArray;
|
|
typedef std::vector<PatchArray> PatchArrayVector;
|
|
|
|
PatchArray & getPatchArray(Index arrayIndex);
|
|
PatchArray const & getPatchArray(Index arrayIndex) const;
|
|
|
|
void reservePatchArrays(int numPatchArrays);
|
|
void pushPatchArray(PatchDescriptor desc, int npatches,
|
|
Index * vidx, Index * pidx, Index * qoidx=0);
|
|
|
|
IndexArray getPatchArrayVertices(int arrayIndex);
|
|
|
|
Index findPatchArray(PatchDescriptor desc);
|
|
|
|
|
|
//
|
|
// FVar patch channels
|
|
//
|
|
|
|
struct FVarPatchChannel;
|
|
typedef std::vector<FVarPatchChannel> FVarPatchChannelVector;
|
|
|
|
FVarPatchChannel & getFVarPatchChannel(int channel);
|
|
FVarPatchChannel const & getFVarPatchChannel(int channel) const;
|
|
|
|
void allocateFVarPatchChannels(int numChannels);
|
|
void allocateChannelValues(int channel, int numPatches, int numVerticesTotal);
|
|
|
|
void setFVarPatchChannelLinearInterpolation(int channel,
|
|
Sdc::Options::FVarLinearInterpolation interpolation);
|
|
|
|
void setFVarPatchChannelPatchesType(int channel, PatchDescriptor::Type type);
|
|
|
|
PatchDescriptor::Type getFVarPatchType(int channel, int patch) const;
|
|
Vtr::Array<PatchDescriptor::Type> getFVarPatchTypes(int channel);
|
|
|
|
IndexArray getFVarPatchesValues(int channel);
|
|
ConstIndexArray getFVarPatchValues(int channel, int patch) const;
|
|
|
|
void setBicubicFVarPatchChannelValues(int channel, int patchSize, std::vector<Index> const & values);
|
|
|
|
private:
|
|
|
|
//
|
|
// Topology
|
|
//
|
|
|
|
int _maxValence, // highest vertex valence found in the mesh
|
|
_numPtexFaces; // total number of ptex faces
|
|
|
|
PatchArrayVector _patchArrays; // Vector of descriptors for arrays of patches
|
|
|
|
std::vector<Index> _patchVerts; // Indices of the control vertices of the patches
|
|
|
|
PatchParamTable _paramTable; // PatchParam bitfields (one per patch)
|
|
|
|
//
|
|
// Extraordinary vertex closed-form evaluation / endcap basis conversion
|
|
//
|
|
// XXXtakahito: these data will probably be replaced with mask coefficient or something
|
|
// SchemeWorker populates.
|
|
//
|
|
QuadOffsetsTable _quadOffsetsTable; // Quad offsets (for Gregory patches)
|
|
VertexValenceTable _vertexValenceTable; // Vertex valence table (for Gregory patches)
|
|
StencilTables const * _vertexStencilTables; // endcap basis conversion stencils
|
|
StencilTables const * _varyingStencilTables; // endcap varying stencils (for convenience)
|
|
|
|
//
|
|
// Face-varying data
|
|
//
|
|
|
|
FVarPatchChannelVector _fvarChannels;
|
|
|
|
//
|
|
// 'single-crease' patch sharpness tables
|
|
//
|
|
|
|
std::vector<Index> _sharpnessIndices; // Indices of single-crease sharpness (one per patch)
|
|
std::vector<float> _sharpnessValues; // Sharpness values.
|
|
};
|
|
|
|
// XXXX manuelk evaluation should have the following interface :
|
|
// - EvaluateVertex<>()
|
|
// - EvaluateVarying<>()
|
|
// - EvaluateFaceVarying<>()
|
|
// this refactor is pending the move of fvar channels as a private data
|
|
// structure inside PatchTables, along with the addition of accessors that
|
|
// use PatchHandle and work that hides the indexing of the patches inside
|
|
// the tables
|
|
|
|
// Interpolates primvar limit at the given parametric location on a patch
|
|
template <class T, class U>
|
|
inline void
|
|
PatchTables::Evaluate(PatchHandle const & handle, float s, float t,
|
|
T const & src, U & dst) const {
|
|
|
|
assert(IsFeatureAdaptive());
|
|
|
|
PatchParam::BitField const & bits = _paramTable[handle.patchIndex].bitField;
|
|
|
|
PatchDescriptor::Type ptype =
|
|
GetPatchArrayDescriptor(handle.arrayIndex).GetType();
|
|
|
|
dst.Clear();
|
|
|
|
float Q[16], Qd1[16], Qd2[16];
|
|
|
|
if (ptype==PatchDescriptor::REGULAR) {
|
|
|
|
ConstIndexArray cvs = GetPatchVertices(handle);
|
|
|
|
GetBSplineWeights(bits, s, t, Q, Qd1, Qd2);
|
|
InterpolateRegularPatch(cvs.begin(), Q, Qd1, Qd2, src, dst);
|
|
|
|
} else if (ptype==PatchDescriptor::GREGORY_BASIS) {
|
|
|
|
ConstIndexArray cvs = GetPatchVertices(handle);
|
|
|
|
GetBezierWeights(bits, s, t, Q, Qd1, Qd2);
|
|
InterpolateGregoryPatch(cvs.begin(), s, t, Q, Qd1, Qd2, src, dst);
|
|
|
|
} else if (ptype==PatchDescriptor::QUADS) {
|
|
|
|
ConstIndexArray cvs = GetPatchVertices(handle);
|
|
|
|
GetBilinearWeights(bits, s, t, Q, Qd1, Qd2);
|
|
InterpolateBilinearPatch(cvs.begin(), Q, Qd1, Qd2, src, dst);
|
|
|
|
} else {
|
|
assert(0);
|
|
}
|
|
}
|
|
|
|
// Interpolates the limit position of a parametric location on a face-varying
|
|
// patch
|
|
// XXXX manuelk this method is very similar to the vertex Evaluate<>() method
|
|
// -> we should eventually merge them
|
|
template <class T, class U>
|
|
inline void
|
|
PatchTables::EvaluateFaceVarying(int channel, PatchHandle const & handle,
|
|
float s, float t, T const & src, U & dst) const {
|
|
|
|
ConstIndexArray cvs = GetFVarPatchValues(channel, handle);
|
|
|
|
PatchDescriptor::Type type = GetFVarPatchType(channel, handle);
|
|
|
|
PatchParam::BitField bits;
|
|
bits.Clear();
|
|
|
|
float Q[16], Qd1[16], Qd2[16];
|
|
|
|
switch (type) {
|
|
case PatchDescriptor::QUADS:
|
|
GetBilinearWeights(bits, s, t, Q, Qd1, Qd2);
|
|
InterpolateBilinearPatch(cvs.begin(), Q, Qd1, Qd2, src, dst);
|
|
break;
|
|
case PatchDescriptor::TRIANGLES:
|
|
assert("not implemented yet");
|
|
case PatchDescriptor::REGULAR:
|
|
GetBSplineWeights(bits, s, t, Q, Qd1, Qd2);
|
|
InterpolateRegularPatch(cvs.begin(), Q, Qd1, Qd2, src, dst);
|
|
break;
|
|
default:
|
|
assert(0);
|
|
|
|
// XXXX manuelk - how do we handle end-patches ?
|
|
// - is there a bicubic patch that we could use to reduce
|
|
// isolation of bilinear boundaries with smooth a interior ?
|
|
}
|
|
}
|
|
|
|
// Interpolates primvar at the given parametric location on a bilinear patch
|
|
template <class T, class U>
|
|
inline void
|
|
PatchTables::EvaluateBilinear(PatchHandle const & handle, float s, float t,
|
|
T const & src, U & dst) const {
|
|
|
|
ConstIndexArray cvs = GetPatchVertices(handle);
|
|
assert(cvs.size()==4);
|
|
|
|
PatchParam::BitField const & bits =
|
|
_paramTable[handle.patchIndex].bitField;
|
|
|
|
dst.Clear();
|
|
|
|
float Q[4], Qd1[4], Qd2[4];
|
|
GetBilinearWeights(bits, s, t, Q, Qd1, Qd2);
|
|
|
|
InterpolateBilinearPatch(cvs.begin(), Q, Qd1, Qd2, src, dst);
|
|
}
|
|
|
|
|
|
} // end namespace Far
|
|
|
|
} // end namespace OPENSUBDIV_VERSION
|
|
using namespace OPENSUBDIV_VERSION;
|
|
|
|
} // end namespace OpenSubdiv
|
|
|
|
#endif /* OPENSUBDIV3_FAR_PATCH_TABLES */
|