All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends
patchTable.h
Go to the documentation of this file.
1 //
2 // Copyright 2013 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 
25 #ifndef OPENSUBDIV3_FAR_PATCH_TABLE_H
26 #define OPENSUBDIV3_FAR_PATCH_TABLE_H
27 
28 #include "../version.h"
29 
30 #include "../far/patchDescriptor.h"
31 #include "../far/patchParam.h"
32 #include "../far/stencilTable.h"
33 
34 #include "../sdc/options.h"
35 
36 #include <vector>
37 
38 namespace OpenSubdiv {
39 namespace OPENSUBDIV_VERSION {
40 
41 namespace Far {
42 
55 class PatchTable {
56 
57 public:
58 
60  class PatchHandle {
61  // XXXX manuelk members will eventually be made private
62  public:
63 
64  friend class PatchTable;
65  friend class PatchMap;
66 
67  Index arrayIndex, // Array index of the patch
68  patchIndex, // Absolute Index of the patch
69  vertIndex; // Relative offset to the first CV of the patch in array
70  };
71 
72 public:
73 
75  PatchTable(PatchTable const & src);
76 
78  ~PatchTable();
79 
81  bool IsFeatureAdaptive() const;
82 
85  return (int)_patchVerts.size();
86  }
87 
89  int GetNumPatchesTotal() const;
90 
92  int GetMaxValence() const { return _maxValence; }
93 
95  int GetNumPtexFaces() const { return _numPtexFaces; }
96 
97 
99 
107  PatchDescriptor GetPatchDescriptor(PatchHandle const & handle) const;
108 
110  ConstIndexArray GetPatchVertices(PatchHandle const & handle) const;
111 
113  PatchParam GetPatchParam(PatchHandle const & handle) const;
114 
116  ConstIndexArray GetPatchVertices(int array, int patch) const;
117 
119  PatchParam GetPatchParam(int array, int patch) const;
121 
122 
124 
132  int GetNumPatchArrays() const;
133 
135  int GetNumPatches(int array) const;
136 
138  int GetNumControlVertices(int array) const;
139 
141  PatchDescriptor GetPatchArrayDescriptor(int array) const;
142 
144  ConstIndexArray GetPatchArrayVertices(int array) const;
145 
147  ConstPatchParamArray const GetPatchParams(int array) const;
149 
150 
152 
161  int GetNumLocalPoints() const;
162 
165 
167  template <typename REAL>
169 
172  template <typename REAL> bool LocalPointStencilPrecisionMatchesType() const;
173 
186  template <class T> void
187  ComputeLocalPointValues(T const *src, T *dst) const;
188 
189 
191  int GetNumLocalPointsVarying() const;
192 
195 
197  template <typename REAL>
199 
202  template <typename REAL> bool LocalPointVaryingStencilPrecisionMatchesType() const;
203 
216  template <class T> void
217  ComputeLocalPointValuesVarying(T const *src, T *dst) const;
218 
219 
221  int GetNumLocalPointsFaceVarying(int channel = 0) const;
222 
224  StencilTable const *GetLocalPointFaceVaryingStencilTable(int channel = 0) const;
225 
227  template <typename REAL>
228  StencilTableReal<REAL> const * GetLocalPointFaceVaryingStencilTable(int channel = 0) const;
229 
232  template <typename REAL> bool LocalPointFaceVaryingStencilPrecisionMatchesType() const;
233 
248  template <class T> void
249  ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel = 0) const;
251 
252 
254 
260 
263 
264  typedef std::vector<Index> VertexValenceTable;
265 
268  return _vertexValenceTable;
269  }
271 
272 
274 
283  float GetSingleCreasePatchSharpnessValue(PatchHandle const & handle) const;
284 
287  float GetSingleCreasePatchSharpnessValue(int array, int patch) const;
289 
290 
292 
301 
303  ConstIndexArray GetPatchVaryingVertices(PatchHandle const & handle) const;
304 
306  ConstIndexArray GetPatchVaryingVertices(int array, int patch) const;
307 
310 
314 
315 
317 
325  int GetNumFVarChannels() const;
326 
328  PatchDescriptor GetFVarPatchDescriptorRegular(int channel = 0) const;
329 
331  PatchDescriptor GetFVarPatchDescriptorIrregular(int channel = 0) const;
332 
334  PatchDescriptor GetFVarPatchDescriptor(int channel = 0) const;
335 
337  ConstIndexArray GetPatchFVarValues(PatchHandle const & handle, int channel = 0) const;
338 
340  ConstIndexArray GetPatchFVarValues(int array, int patch, int channel = 0) const;
341 
343  ConstIndexArray GetPatchArrayFVarValues(int array, int channel = 0) const;
344 
346  ConstIndexArray GetFVarValues(int channel = 0) const;
347 
349  int GetFVarValueStride(int channel = 0) const;
350 
352  PatchParam GetPatchFVarPatchParam(PatchHandle const & handle, int channel = 0) const;
353 
355  PatchParam GetPatchFVarPatchParam(int array, int patch, int channel = 0) const;
356 
358  ConstPatchParamArray GetPatchArrayFVarPatchParams(int array, int channel = 0) const;
359 
361  ConstPatchParamArray GetFVarPatchParams(int channel = 0) const;
362 
366 
367 
369 
375  typedef std::vector<Index> PatchVertsTable;
376 
378  PatchVertsTable const & GetPatchControlVerticesTable() const { return _patchVerts; }
379 
381  PatchParamTable const & GetPatchParamTable() const { return _paramTable; }
382 
384  std::vector<Index> const &GetSharpnessIndexTable() const { return _sharpnessIndices; }
385 
387  std::vector<float> const &GetSharpnessValues() const { return _sharpnessValues; }
388 
389  typedef std::vector<unsigned int> QuadOffsetsTable;
390 
393  return _quadOffsetsTable;
394  }
396 
398  void print() const;
399 
400 public:
401 
403 
428  template <typename REAL>
429  void EvaluateBasis(PatchHandle const & handle, REAL u, REAL v,
430  REAL wP[], REAL wDu[] = 0, REAL wDv[] = 0,
431  REAL wDuu[] = 0, REAL wDuv[] = 0, REAL wDvv[] = 0) const;
432 
435  void EvaluateBasis(PatchHandle const & handle, float u, float v,
436  float wP[], float wDu[] = 0, float wDv[] = 0,
437  float wDuu[] = 0, float wDuv[] = 0, float wDvv[] = 0) const;
438 
441  void EvaluateBasis(PatchHandle const & handle, double u, double v,
442  double wP[], double wDu[] = 0, double wDv[] = 0,
443  double wDuu[] = 0, double wDuv[] = 0, double wDvv[] = 0) const;
444 
467  template <typename REAL>
468  void EvaluateBasisVarying(PatchHandle const & handle, REAL u, REAL v,
469  REAL wP[], REAL wDu[] = 0, REAL wDv[] = 0,
470  REAL wDuu[] = 0, REAL wDuv[] = 0, REAL wDvv[] = 0) const;
471 
474  void EvaluateBasisVarying(PatchHandle const & handle, float u, float v,
475  float wP[], float wDu[] = 0, float wDv[] = 0,
476  float wDuu[] = 0, float wDuv[] = 0, float wDvv[] = 0) const;
477 
480  void EvaluateBasisVarying(PatchHandle const & handle, double u, double v,
481  double wP[], double wDu[] = 0, double wDv[] = 0,
482  double wDuu[] = 0, double wDuv[] = 0, double wDvv[] = 0) const;
483 
508  template <typename REAL>
509  void EvaluateBasisFaceVarying(PatchHandle const & handle, REAL u, REAL v,
510  REAL wP[], REAL wDu[] = 0, REAL wDv[] = 0,
511  REAL wDuu[] = 0, REAL wDuv[] = 0, REAL wDvv[] = 0,
512  int channel = 0) const;
513 
516  void EvaluateBasisFaceVarying(PatchHandle const & handle, float u, float v,
517  float wP[], float wDu[] = 0, float wDv[] = 0,
518  float wDuu[] = 0, float wDuv[] = 0, float wDvv[] = 0,
519  int channel = 0) const;
520 
523  void EvaluateBasisFaceVarying(PatchHandle const & handle, double u, double v,
524  double wP[], double wDu[] = 0, double wDv[] = 0,
525  double wDuu[] = 0, double wDuv[] = 0, double wDvv[] = 0,
526  int channel = 0) const;
528 
529 protected:
530 
531  friend class PatchTableBuilder;
532 
533  // Factory constructor
534  PatchTable(int maxvalence);
535 
536  Index getPatchIndex(int array, int patch) const;
537 
538  PatchParamArray getPatchParams(int arrayIndex);
539 
540  Index * getSharpnessIndices(Index arrayIndex);
541  float * getSharpnessValues(Index arrayIndex);
542 
543 private:
544 
545  //
546  // Patch arrays
547  //
548 
549  struct PatchArray;
550  typedef std::vector<PatchArray> PatchArrayVector;
551 
552  PatchArray & getPatchArray(Index arrayIndex);
553  PatchArray const & getPatchArray(Index arrayIndex) const;
554 
555  void reservePatchArrays(int numPatchArrays);
556  void pushPatchArray(PatchDescriptor desc, int npatches,
557  Index * vidx, Index * pidx, Index * qoidx=0);
558 
559  IndexArray getPatchArrayVertices(int arrayIndex);
560 
561  Index findPatchArray(PatchDescriptor desc);
562 
563 
564  //
565  // Varying patch arrays
566  //
567  IndexArray getPatchArrayVaryingVertices(int arrayIndex);
568 
569  void allocateVaryingVertices(
570  PatchDescriptor desc, int numPatches);
571  void populateVaryingVertices();
572 
573  //
574  // Face-varying patch channels
575  //
576 
577  struct FVarPatchChannel;
578  typedef std::vector<FVarPatchChannel> FVarPatchChannelVector;
579 
580  FVarPatchChannel & getFVarPatchChannel(int channel);
581  FVarPatchChannel const & getFVarPatchChannel(int channel) const;
582 
583  void allocateFVarPatchChannels(int numChannels);
584  void allocateFVarPatchChannelValues(
585  PatchDescriptor regDesc, PatchDescriptor irregDesc,
586  int numPatches, int channel);
587 
588  // deprecated
589  void setFVarPatchChannelLinearInterpolation(
590  Sdc::Options::FVarLinearInterpolation interpolation, int channel);
591 
592  IndexArray getFVarValues(int channel);
593  ConstIndexArray getPatchFVarValues(int patch, int channel) const;
594 
595  PatchParamArray getFVarPatchParams(int channel);
596  PatchParam getPatchFVarPatchParam(int patch, int channel) const;
597 
598 private:
599  //
600  // Simple private class to hold stencil table pointers of varying precision,
601  // where the discriminant of the precision is external.
602  //
603  // NOTE that this is a simple pointer container and NOT a smart pointer that
604  // manages the ownership of the object referred to by it.
605  //
606  class StencilTablePtr {
607  private:
608  typedef StencilTableReal<float> float_type;
609  typedef StencilTableReal<double> double_type;
610 
611  union {
612  float_type * _fPtr;
613  double_type * _dPtr;
614  };
615 
616  public:
617  StencilTablePtr() { _fPtr = 0; }
618  StencilTablePtr(float_type * ptr) { _fPtr = ptr; }
619  StencilTablePtr(double_type * ptr) { _dPtr = ptr; }
620 
621  operator bool() const { return _fPtr != 0; }
622 
623  void Set() { _fPtr = 0; }
624  void Set(float_type * ptr) { _fPtr = ptr; }
625  void Set(double_type * ptr) { _dPtr = ptr; }
626 
627  template <typename REAL> StencilTableReal<REAL> * Get() const;
628  };
629 
630 private:
631 
632  //
633  // Topology
634  //
635 
636  int _maxValence, // highest vertex valence found in the mesh
637  _numPtexFaces; // total number of ptex faces
638 
639  PatchArrayVector _patchArrays; // Vector of descriptors for arrays of patches
640 
641  std::vector<Index> _patchVerts; // Indices of the control vertices of the patches
642 
643  PatchParamTable _paramTable; // PatchParam bitfields (one per patch)
644 
645  //
646  // Extraordinary vertex closed-form evaluation / endcap basis conversion
647  //
648  // XXXtakahito: these data will probably be replaced with mask coefficient or something
649  // SchemeWorker populates.
650  //
651  QuadOffsetsTable _quadOffsetsTable; // Quad offsets (for Gregory patches)
652  VertexValenceTable _vertexValenceTable; // Vertex valence table (for Gregory patches)
653 
654  StencilTablePtr _localPointStencils; // local point conversion stencils
655  StencilTablePtr _localPointVaryingStencils; // local point varying stencils
656 
657  //
658  // Varying data
659  //
660  PatchDescriptor _varyingDesc;
661 
662  std::vector<Index> _varyingVerts;
663 
664  //
665  // Face-varying data
666  //
667  FVarPatchChannelVector _fvarChannels;
668 
669  std::vector<StencilTablePtr> _localPointFaceVaryingStencils;
670 
671  //
672  // 'single-crease' patch sharpness tables
673  //
674  std::vector<Index> _sharpnessIndices; // Indices of single-crease sharpness (one per patch)
675  std::vector<float> _sharpnessValues; // Sharpness values.
676 
677  //
678  // Construction history -- relevant to at least one public query:
679  //
680  unsigned int _isUniformLinear : 1;
681 
682  //
683  // Precision -- only applies to local-point stencil tables
684  //
685  unsigned int _vertexPrecisionIsDouble : 1;
686  unsigned int _varyingPrecisionIsDouble : 1;
687  unsigned int _faceVaryingPrecisionIsDouble : 1;
688 };
689 
690 
691 //
692 // Template specializations for float/double -- to be defined before used:
693 //
694 template <> inline StencilTableReal<float> *
695 PatchTable::StencilTablePtr::Get<float>() const { return _fPtr; }
696 
697 template <> inline StencilTableReal<double> *
698 PatchTable::StencilTablePtr::Get<double>() const { return _dPtr; }
699 
700 template <> inline bool
701 PatchTable::LocalPointStencilPrecisionMatchesType<float>() const {
702  return !_vertexPrecisionIsDouble;
703 }
704 template <> inline bool
705 PatchTable::LocalPointVaryingStencilPrecisionMatchesType<float>() const {
706  return !_varyingPrecisionIsDouble;
707 }
708 template <> inline bool
709 PatchTable::LocalPointFaceVaryingStencilPrecisionMatchesType<float>() const {
710  return !_faceVaryingPrecisionIsDouble;
711 }
712 
713 template <> inline bool
714 PatchTable::LocalPointStencilPrecisionMatchesType<double>() const {
715  return _vertexPrecisionIsDouble;
716 }
717 template <> inline bool
718 PatchTable::LocalPointVaryingStencilPrecisionMatchesType<double>() const {
719  return _varyingPrecisionIsDouble;
720 }
721 template <> inline bool
722 PatchTable::LocalPointFaceVaryingStencilPrecisionMatchesType<double>() const {
723  return _faceVaryingPrecisionIsDouble;
724 }
725 
726 //
727 // StencilTable access -- backward compatible and generic:
728 //
729 inline StencilTable const *
731  assert(LocalPointStencilPrecisionMatchesType<float>());
732  return static_cast<StencilTable const *>(_localPointStencils.Get<float>());
733 }
734 inline StencilTable const *
736  assert(LocalPointVaryingStencilPrecisionMatchesType<float>());
737  return static_cast<StencilTable const *>(
738  _localPointVaryingStencils.Get<float>());
739 }
740 inline StencilTable const *
742  assert(LocalPointFaceVaryingStencilPrecisionMatchesType<float>());
743  if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
744  return static_cast<StencilTable const *>(
745  _localPointFaceVaryingStencils[channel].Get<float>());
746  }
747  return NULL;
748 }
749 
750 template <typename REAL>
751 inline StencilTableReal<REAL> const *
753  assert(LocalPointStencilPrecisionMatchesType<REAL>());
754  return _localPointStencils.Get<REAL>();
755 }
756 template <typename REAL>
757 inline StencilTableReal<REAL> const *
759  assert(LocalPointVaryingStencilPrecisionMatchesType<REAL>());
760  return _localPointVaryingStencils.Get<REAL>();
761 }
762 template <typename REAL>
763 inline StencilTableReal<REAL> const *
765  assert(LocalPointFaceVaryingStencilPrecisionMatchesType<REAL>());
766  if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
767  return _localPointFaceVaryingStencils[channel].Get<REAL>();
768  }
769  return NULL;
770 }
771 
772 
773 //
774 // Computation of local point values:
775 //
776 template <class T>
777 inline void
778 PatchTable::ComputeLocalPointValues(T const *src, T *dst) const {
779  assert(LocalPointStencilPrecisionMatchesType<float>());
780  if (_localPointStencils) {
781  _localPointStencils.Get<float>()->UpdateValues(src, dst);
782  }
783 }
784 
785 template <class T>
786 inline void
787 PatchTable::ComputeLocalPointValuesVarying(T const *src, T *dst) const {
788  assert(LocalPointVaryingStencilPrecisionMatchesType<float>());
789  if (_localPointVaryingStencils) {
790  _localPointVaryingStencils.Get<float>()->UpdateValues(src, dst);
791  }
792 }
793 
794 template <class T>
795 inline void
796 PatchTable::ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel) const {
797  assert(LocalPointFaceVaryingStencilPrecisionMatchesType<float>());
798  if (channel >= 0 && channel < (int)_localPointFaceVaryingStencils.size()) {
799  if (_localPointFaceVaryingStencils[channel]) {
800  _localPointFaceVaryingStencils[channel].Get<float>()->UpdateValues(src, dst);
801  }
802  }
803 }
804 
805 
806 //
807 // Basis evaluation overloads
808 //
809 inline void
810 PatchTable::EvaluateBasis(PatchHandle const & handle, float u, float v,
811  float wP[], float wDu[], float wDv[],
812  float wDuu[], float wDuv[], float wDvv[]) const {
813 
814  EvaluateBasis<float>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
815 }
816 inline void
817 PatchTable::EvaluateBasis(PatchHandle const & handle, double u, double v,
818  double wP[], double wDu[], double wDv[],
819  double wDuu[], double wDuv[], double wDvv[]) const {
820 
821  EvaluateBasis<double>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
822 }
823 
824 inline void
825 PatchTable::EvaluateBasisVarying(PatchHandle const & handle, float u, float v,
826  float wP[], float wDu[], float wDv[],
827  float wDuu[], float wDuv[], float wDvv[]) const {
828 
829  EvaluateBasisVarying<float>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
830 }
831 inline void
832 PatchTable::EvaluateBasisVarying(PatchHandle const & handle, double u, double v,
833  double wP[], double wDu[], double wDv[],
834  double wDuu[], double wDuv[], double wDvv[]) const {
835 
836  EvaluateBasisVarying<double>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv);
837 }
838 
839 inline void
840 PatchTable::EvaluateBasisFaceVarying(PatchHandle const & handle, float u, float v,
841  float wP[], float wDu[], float wDv[],
842  float wDuu[], float wDuv[], float wDvv[], int channel) const {
843 
844  EvaluateBasisFaceVarying<float>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv, channel);
845 }
846 inline void
847 PatchTable::EvaluateBasisFaceVarying(PatchHandle const & handle, double u, double v,
848  double wP[], double wDu[], double wDv[],
849  double wDuu[], double wDuv[], double wDvv[], int channel) const {
850 
851  EvaluateBasisFaceVarying<double>(handle, u, v, wP, wDu, wDv, wDuu, wDuv, wDvv, channel);
852 }
853 
854 } // end namespace Far
855 
856 } // end namespace OPENSUBDIV_VERSION
857 using namespace OPENSUBDIV_VERSION;
858 
859 } // end namespace OpenSubdiv
860 
861 #endif /* OPENSUBDIV3_FAR_PATCH_TABLE */
PatchTable(PatchTable const &src)
Copy constructor.
std::vector< Index > const & GetSharpnessIndexTable() const
Returns a sharpness index table for each patch (if exists)
Definition: patchTable.h:384
void EvaluateBasisVarying(PatchHandle const &handle, REAL u, REAL v, REAL wP[], REAL wDu[]=0, REAL wDv[]=0, REAL wDuu[]=0, REAL wDuv[]=0, REAL wDvv[]=0) const
Evaluate basis functions for a varying value and derivatives at a given (u,v) parametric location of ...
int GetNumPatches(int array) const
Returns the number of patches in array.
void ComputeLocalPointValuesVarying(T const *src, T *dst) const
Updates local point varying values.
Definition: patchTable.h:787
int GetNumPatchesTotal() const
Returns the total number of patches stored in the table.
ConstIndexArray GetPatchFVarValues(PatchHandle const &handle, int channel=0) const
Returns the value indices for a given patch in channel.
QuadOffsetsTable const & GetQuadOffsetsTable() const
Returns the quad-offsets table.
Definition: patchTable.h:392
PatchParam GetPatchFVarPatchParam(PatchHandle const &handle, int channel=0) const
Returns the value indices for a given patch in channel.
int GetNumControlVertices(int array) const
Returns the number of control vertices in array.
int GetNumPtexFaces() const
Returns the total number of ptex faces in the mesh.
Definition: patchTable.h:95
VertexValenceTable const & GetVertexValenceTable() const
Returns the 'VertexValences' table (vertex neighborhoods table)
Definition: patchTable.h:267
StencilTable const * GetLocalPointStencilTable() const
Returns the stencil table to compute local point vertex values.
Definition: patchTable.h:730
void ComputeLocalPointValues(T const *src, T *dst) const
Updates local point vertex values.
Definition: patchTable.h:778
PatchDescriptor GetFVarPatchDescriptorRegular(int channel=0) const
Returns the regular patch descriptor for channel.
int GetNumPatchArrays() const
Returns the number of patch arrays in the table.
bool IsFeatureAdaptive() const
True if the patches are of feature adaptive types.
PatchParam GetPatchParam(PatchHandle const &handle) const
Returns a PatchParam for the patch identified by handle.
ConstPatchParamArray GetFVarPatchParams(int channel=0) const
Returns an array of face-varying patch param for channel.
std::vector< unsigned int > QuadOffsetsTable
Definition: patchTable.h:389
ConstIndexArray GetPatchVertices(PatchHandle const &handle) const
Returns the control vertex indices for the patch identified by handle.
int GetNumLocalPointsFaceVarying(int channel=0) const
Returns the number of local face-varying points for channel.
std::vector< float > const & GetSharpnessValues() const
Returns sharpness values table.
Definition: patchTable.h:387
bool LocalPointFaceVaryingStencilPrecisionMatchesType() const
Tests if the precision of the stencil table to compute local point face-varying values matches the gi...
int GetNumLocalPointsVarying() const
Returns the number of local varying points.
An quadtree-based map connecting coarse faces to their sub-patches.
Definition: patchMap.h:49
bool LocalPointVaryingStencilPrecisionMatchesType() const
Tests if the precision of the stencil table to compute local point varying values matches the given f...
Sdc::Options::FVarLinearInterpolation GetFVarChannelLinearInterpolation(int channel=0) const
Deprecated.
ConstIndexArray GetPatchArrayVertices(int array) const
Returns the control vertex indices for the patches in array.
int GetMaxValence() const
Returns max vertex valence.
Definition: patchTable.h:92
PatchParamArray getPatchParams(int arrayIndex)
int GetFVarValueStride(int channel=0) const
Returns the stride between patches in the value index array of channel.
StencilTable const * GetLocalPointVaryingStencilTable() const
Returns the stencil table to compute local point varying values.
Definition: patchTable.h:735
PatchParamTable const & GetPatchParamTable() const
Returns the PatchParamTable (PatchParams order matches patch array sorting)
Definition: patchTable.h:381
PatchDescriptor GetPatchArrayDescriptor(int array) const
Returns the PatchDescriptor for the patches in array.
std::vector< PatchParam > PatchParamTable
Definition: patchParam.h:243
void EvaluateBasis(PatchHandle const &handle, REAL u, REAL v, REAL wP[], REAL wDu[]=0, REAL wDv[]=0, REAL wDuu[]=0, REAL wDuv[]=0, REAL wDvv[]=0) const
Evaluate basis functions for position and derivatives at a given (u,v) parametric location of a patch...
PatchDescriptor GetPatchDescriptor(PatchHandle const &handle) const
Returns the PatchDescriptor for the patch identified by handle.
ConstIndexArray GetPatchArrayVaryingVertices(int array) const
Returns the varying vertex indices for the patches in array.
Container for arrays of parametric patches.
Definition: patchTable.h:55
ConstIndexArray GetPatchVaryingVertices(PatchHandle const &handle) const
Returns the varying vertex indices for a given patch.
int GetNumFVarChannels() const
Returns the number of face-varying channels.
PatchVertsTable const & GetPatchControlVerticesTable() const
Get the table of patch control vertices.
Definition: patchTable.h:378
ConstIndexArray GetFVarValues(int channel=0) const
Returns an array of value indices for the patches in channel.
void ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel=0) const
Updates local point face-varying values.
Definition: patchTable.h:796
ConstPatchParamArray const GetPatchParams(int array) const
Returns the PatchParams for the patches in array.
StencilTable const * GetLocalPointFaceVaryingStencilTable(int channel=0) const
Returns the stencil table to compute local point face-varying values.
Definition: patchTable.h:741
bool LocalPointStencilPrecisionMatchesType() const
Tests if the precision of the stencil table to compute local point vertex values matches the given fl...
ConstQuadOffsetsArray GetPatchQuadOffsets(PatchHandle const &handle) const
Returns the 'QuadOffsets' for the Gregory patch identified by handle.
PatchDescriptor GetFVarPatchDescriptorIrregular(int channel=0) const
Returns the irregular patch descriptor for channel.
Handle that can be used as unique patch identifier within PatchTable.
Definition: patchTable.h:60
float GetSingleCreasePatchSharpnessValue(PatchHandle const &handle) const
Returns the crease sharpness for the patch identified by handle if it is a single-crease patch...
std::vector< PatchArray > PatchArrayVector
Definition: types.h:132
void EvaluateBasisFaceVarying(PatchHandle const &handle, REAL u, REAL v, REAL wP[], REAL wDu[]=0, REAL wDv[]=0, REAL wDuu[]=0, REAL wDuv[]=0, REAL wDvv[]=0, int channel=0) const
Evaluate basis functions for a face-varying value and derivatives at a given (u,v) parametric locatio...
Stencil table class wrapping the template for compatibility.
Definition: stencilTable.h:273
Vtr::ConstArray< unsigned int > ConstQuadOffsetsArray
Accessors for the gregory patch evaluation buffers. These methods will be deprecated.
Definition: patchTable.h:259
PatchDescriptor GetFVarPatchDescriptor(int channel=0) const
Returns the default/irregular patch descriptor for channel.
PatchDescriptor GetVaryingPatchDescriptor() const
Returns the varying patch descriptor.
ConstIndexArray GetVaryingVertices() const
Returns an array of varying vertex indices for the patches.
int GetNumControlVerticesTotal() const
Returns the total number of control vertex indices in the table.
Definition: patchTable.h:84
int GetNumLocalPoints() const
Returns the number of local vertex points.
Index getPatchIndex(int array, int patch) const
ConstPatchParamArray GetPatchArrayFVarPatchParams(int array, int channel=0) const
Returns the face-varying for a given patch in array in channel.
ConstIndexArray GetPatchArrayFVarValues(int array, int channel=0) const
Returns the value indices for the patches in array in channel.