My Project
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 */
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::getPatchIndex
Index getPatchIndex(int array, int patch) const
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::ComputeLocalPointValues
void ComputeLocalPointValues(T const *src, T *dst) const
Updates local point vertex values.
Definition: patchTable.h:778
OpenSubdiv
Definition: error.h:30
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::EvaluateBasis
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...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumLocalPointsFaceVarying
int GetNumLocalPointsFaceVarying(int channel=0) const
Returns the number of local face-varying points for channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchTable
PatchTable(PatchTable const &src)
Copy constructor.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::VertexValenceTable
std::vector< Index > VertexValenceTable
Definition: patchTable.h:264
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetVaryingPatchDescriptor
PatchDescriptor GetVaryingPatchDescriptor() const
Returns the varying patch descriptor.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchArrayFVarPatchParams
ConstPatchParamArray GetPatchArrayFVarPatchParams(int array, int channel=0) const
Returns the face-varying for a given patch in array in channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumPatchesTotal
int GetNumPatchesTotal() const
Returns the total number of patches stored in the table.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::EvaluateBasisVarying
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 ...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchFVarValues
ConstIndexArray GetPatchFVarValues(PatchHandle const &handle, int channel=0) const
Returns the value indices for a given patch in channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::StencilTableReal
Table of subdivision stencils.
Definition: stencilTable.h:141
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarChannelLinearInterpolation
Sdc::Options::FVarLinearInterpolation GetFVarChannelLinearInterpolation(int channel=0) const
Deprecated.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::getSharpnessIndices
Index * getSharpnessIndices(Index arrayIndex)
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Options::FVarLinearInterpolation
FVarLinearInterpolation
Definition: options.h:60
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchHandle::arrayIndex
Index arrayIndex
Definition: patchTable.h:67
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::ComputeLocalPointValuesVarying
void ComputeLocalPointValuesVarying(T const *src, T *dst) const
Updates local point varying values.
Definition: patchTable.h:787
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::Array
Definition: array.h:105
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchParams
const ConstPatchParamArray GetPatchParams(int array) const
Returns the PatchParams for the patches in array.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarPatchDescriptor
PatchDescriptor GetFVarPatchDescriptor(int channel=0) const
Returns the default/irregular patch descriptor for channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetVaryingVertices
ConstIndexArray GetVaryingVertices() const
Returns an array of varying vertex indices for the patches.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::getSharpnessValues
float * getSharpnessValues(Index arrayIndex)
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::LocalPointFaceVaryingStencilPrecisionMatchesType
bool LocalPointFaceVaryingStencilPrecisionMatchesType() const
Tests if the precision of the stencil table to compute local point face-varying values matches the gi...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumLocalPointsVarying
int GetNumLocalPointsVarying() const
Returns the number of local varying points.
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::ConstArray< Index >
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchHandle::patchIndex
Index patchIndex
Definition: patchTable.h:68
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumPtexFaces
int GetNumPtexFaces() const
Returns the total number of ptex faces in the mesh.
Definition: patchTable.h:95
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::IsFeatureAdaptive
bool IsFeatureAdaptive() const
True if the patches are of feature adaptive types.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchVertices
ConstIndexArray GetPatchVertices(PatchHandle const &handle) const
Returns the control vertex indices for the patch identified by handle.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchArrayVaryingVertices
ConstIndexArray GetPatchArrayVaryingVertices(int array) const
Returns the varying vertex indices for the patches in array.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetSharpnessIndexTable
const std::vector< Index > & GetSharpnessIndexTable() const
Returns a sharpness index table for each patch (if exists)
Definition: patchTable.h:384
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchVaryingVertices
ConstIndexArray GetPatchVaryingVertices(PatchHandle const &handle) const
Returns the varying vertex indices for a given patch.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumFVarChannels
int GetNumFVarChannels() const
Returns the number of face-varying channels.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchControlVerticesTable
const PatchVertsTable & GetPatchControlVerticesTable() const
Get the table of patch control vertices.
Definition: patchTable.h:378
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchArrayFVarValues
ConstIndexArray GetPatchArrayFVarValues(int array, int channel=0) const
Returns the value indices for the patches in array in channel.
OpenSubdiv::OPENSUBDIV_VERSION::Osd::PatchArrayVector
std::vector< PatchArray > PatchArrayVector
Definition: types.h:132
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchQuadOffsets
ConstQuadOffsetsArray GetPatchQuadOffsets(PatchHandle const &handle) const
Returns the 'QuadOffsets' for the Gregory patch identified by handle.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarPatchDescriptorRegular
PatchDescriptor GetFVarPatchDescriptorRegular(int channel=0) const
Returns the regular patch descriptor for channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::LocalPointVaryingStencilPrecisionMatchesType
bool LocalPointVaryingStencilPrecisionMatchesType() const
Tests if the precision of the stencil table to compute local point varying values matches the given f...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::EvaluateBasisFaceVarying
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...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumPatchArrays
int GetNumPatchArrays() const
Returns the number of patch arrays in the table.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetLocalPointFaceVaryingStencilTable
const StencilTable * GetLocalPointFaceVaryingStencilTable(int channel=0) const
Returns the stencil table to compute local point face-varying values.
Definition: patchTable.h:741
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumControlVerticesTotal
int GetNumControlVerticesTotal() const
Returns the total number of control vertex indices in the table.
Definition: patchTable.h:84
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumLocalPoints
int GetNumLocalPoints() const
Returns the number of local vertex points.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchArrayVertices
ConstIndexArray GetPatchArrayVertices(int array) const
Returns the control vertex indices for the patches in array.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetSharpnessValues
const std::vector< float > & GetSharpnessValues() const
Returns sharpness values table.
Definition: patchTable.h:387
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetMaxValence
int GetMaxValence() const
Returns max vertex valence.
Definition: patchTable.h:92
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::print
void print() const
debug helper
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumPatches
int GetNumPatches(int array) const
Returns the number of patches in array.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable
Container for arrays of parametric patches.
Definition: patchTable.h:55
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::getPatchParams
PatchParamArray getPatchParams(int arrayIndex)
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetQuadOffsetsTable
const QuadOffsetsTable & GetQuadOffsetsTable() const
Returns the quad-offsets table.
Definition: patchTable.h:392
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::~PatchTable
~PatchTable()
Destructor.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarPatchDescriptorIrregular
PatchDescriptor GetFVarPatchDescriptorIrregular(int channel=0) const
Returns the irregular patch descriptor for channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::Index
Vtr::Index Index
Definition: types.h:41
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::ConstQuadOffsetsArray
Vtr::ConstArray< unsigned int > ConstQuadOffsetsArray
Accessors for the gregory patch evaluation buffers. These methods will be deprecated.
Definition: patchTable.h:259
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchVertsTable
std::vector< Index > PatchVertsTable
Definition: patchTable.h:375
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchHandle
Handle that can be used as unique patch identifier within PatchTable.
Definition: patchTable.h:60
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchParamTable
std::vector< PatchParam > PatchParamTable
Definition: patchParam.h:243
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchDescriptor
PatchDescriptor GetPatchDescriptor(PatchHandle const &handle) const
Returns the PatchDescriptor for the patch identified by handle.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchFVarPatchParam
PatchParam GetPatchFVarPatchParam(PatchHandle const &handle, int channel=0) const
Returns the value indices for a given patch in channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchDescriptor
Describes the type of a patch.
Definition: patchDescriptor.h:44
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetSingleCreasePatchSharpnessValue
float GetSingleCreasePatchSharpnessValue(PatchHandle const &handle) const
Returns the crease sharpness for the patch identified by handle if it is a single-crease patch,...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchParam
Patch parameterization.
Definition: patchParam.h:152
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetLocalPointVaryingStencilTable
const StencilTable * GetLocalPointVaryingStencilTable() const
Returns the stencil table to compute local point varying values.
Definition: patchTable.h:735
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchHandle::vertIndex
Index vertIndex
Definition: patchTable.h:69
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchMap
An quadtree-based map connecting coarse faces to their sub-patches.
Definition: patchMap.h:49
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchParam
PatchParam GetPatchParam(PatchHandle const &handle) const
Returns a PatchParam for the patch identified by handle.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetNumControlVertices
int GetNumControlVertices(int array) const
Returns the number of control vertices in array.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchArrayDescriptor
PatchDescriptor GetPatchArrayDescriptor(int array) const
Returns the PatchDescriptor for the patches in array.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::PatchTableBuilder
friend class PatchTableBuilder
Definition: patchTable.h:531
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetVertexValenceTable
const VertexValenceTable & GetVertexValenceTable() const
Returns the 'VertexValences' table (vertex neighborhoods table)
Definition: patchTable.h:267
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarValues
ConstIndexArray GetFVarValues(int channel=0) const
Returns an array of value indices for the patches in channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::LocalPointStencilPrecisionMatchesType
bool LocalPointStencilPrecisionMatchesType() const
Tests if the precision of the stencil table to compute local point vertex values matches the given fl...
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarValueStride
int GetFVarValueStride(int channel=0) const
Returns the stride between patches in the value index array of channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetLocalPointStencilTable
const StencilTable * GetLocalPointStencilTable() const
Returns the stencil table to compute local point vertex values.
Definition: patchTable.h:730
OpenSubdiv::OPENSUBDIV_VERSION::Far::StencilTable
Stencil table class wrapping the template for compatibility.
Definition: stencilTable.h:273
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetPatchParamTable
const PatchParamTable & GetPatchParamTable() const
Returns the PatchParamTable (PatchParams order matches patch array sorting)
Definition: patchTable.h:381
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::ComputeLocalPointValuesFaceVarying
void ComputeLocalPointValuesFaceVarying(T const *src, T *dst, int channel=0) const
Updates local point face-varying values.
Definition: patchTable.h:796
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::GetFVarPatchParams
ConstPatchParamArray GetFVarPatchParams(int channel=0) const
Returns an array of face-varying patch param for channel.
OpenSubdiv::OPENSUBDIV_VERSION::Far::PatchTable::QuadOffsetsTable
std::vector< unsigned int > QuadOffsetsTable
Definition: patchTable.h:389