OpenSubdiv
surface.h
Go to the documentation of this file.
1 //
2 // Copyright 2021 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_BFR_SURFACE_H
26 #define OPENSUBDIV3_BFR_SURFACE_H
27 
28 #include "../version.h"
29 
30 #include "../bfr/surfaceData.h"
31 #include "../bfr/parameterization.h"
32 #include "../vtr/array.h"
33 
34 namespace OpenSubdiv {
35 namespace OPENSUBDIV_VERSION {
36 
37 namespace Bfr {
38 
58 template <typename REAL>
59 class Surface {
60 public:
63  struct PointDescriptor {
64  PointDescriptor() : size(0), stride(0) { }
65  PointDescriptor(int n) : size(n), stride(n) { }
66  PointDescriptor(int n, int m) : size(n), stride(m) { }
67 
68  int size, stride;
69  };
70 
72  typedef int Index;
73 
74 public:
76 
86  bool IsValid() const { return _data.isValid(); }
87 
89  void Clear() { _data.reinitialize(); }
90 
92  Surface();
93 
94  Surface(Surface const & src) = default;
95  Surface& operator=(Surface const & src) = default;
96  ~Surface() = default;
98 
100 
106  Parameterization GetParameterization() const { return _data.getParam(); }
107 
109  int GetFaceSize() const { return GetParameterization().GetFaceSize(); }
110 
112  bool IsRegular() const { return _data.isRegular(); }
113 
115  bool IsLinear() const { return _data.isLinear(); }
117 
119 
137  int GetNumControlPoints() const { return _data.getNumCVs(); }
138 
140  int GetControlPointIndices(Index meshPointIndices[]) const;
141 
151  template <typename REAL_MESH>
152  void GatherControlPoints(REAL_MESH const meshPoints[],
153  PointDescriptor const & meshPointDesc,
154  REAL controlPoints[],
155  PointDescriptor const & controlPointDesc) const;
156 
158  void BoundControlPoints(REAL const controlPoints[],
159  PointDescriptor const & controlPointDesc,
160  REAL minExtent[],
161  REAL maxExtent[]) const;
162 
164  void BoundControlPointsFromMesh(REAL const meshPoints[],
165  PointDescriptor const & meshPointDesc,
166  REAL minExtent[],
167  REAL maxExtent[]) const;
169 
171 
179  int GetNumPatchPoints() const;
180 
199  void PreparePatchPoints(REAL const meshPoints[],
200  PointDescriptor const & meshPointDesc,
201  REAL patchPoints[],
202  PointDescriptor const & patchPointDesc) const;
203 
213  void ComputePatchPoints(REAL patchPoints[],
214  PointDescriptor const & patchPointDesc) const;
216 
218 
227  void Evaluate(REAL const uv[2],
228  REAL const patchPoints[], PointDescriptor const & pointDesc,
229  REAL P[]) const;
230 
232  void Evaluate(REAL const uv[2],
233  REAL const patchPoints[], PointDescriptor const & pointDesc,
234  REAL P[], REAL Du[], REAL Dv[]) const;
235 
237  void Evaluate(REAL const uv[2],
238  REAL const patchPoints[], PointDescriptor const & pointDesc,
239  REAL P[], REAL Du[], REAL Dv[],
240  REAL Duu[], REAL Duv[], REAL Dvv[]) const;
242 
244 
258  int EvaluateStencil(REAL const uv[2], REAL sP[]) const;
259 
261  int EvaluateStencil(REAL const uv[2], REAL sP[],
262  REAL sDu[], REAL sDv[]) const;
263 
265  int EvaluateStencil(REAL const uv[2], REAL sP[],
266  REAL sDu[], REAL sDv[],
267  REAL sDuu[], REAL sDuv[], REAL sDvv[]) const;
268 
270  void ApplyStencil(REAL const stencil[],
271  REAL const controlPoints[], PointDescriptor const &,
272  REAL result[]) const;
273 
275  void ApplyStencilFromMesh(REAL const stencil[],
276  REAL const meshPoints[], PointDescriptor const &,
277  REAL result[]) const;
279 
280 private:
281  // Internal methods for evaluating derivatives, basis weights and
282  // stencils for regular, irregular and irregular linear patches:
283  typedef Vtr::ConstArray<int> IndexArray;
284 
285  void evaluateDerivs(REAL const uv[2], REAL const patchPoints[],
286  PointDescriptor const &, REAL * derivs[]) const;
287  void evalRegularDerivs(REAL const uv[2], REAL const patchPoints[],
288  PointDescriptor const &, REAL * derivs[]) const;
289  void evalIrregularDerivs(REAL const uv[2], REAL const patchPoints[],
290  PointDescriptor const &, REAL * derivs[]) const;
291  void evalMultiLinearDerivs(REAL const uv[2], REAL const patchPoints[],
292  PointDescriptor const &, REAL * derivs[]) const;
293 
294  void evalRegularBasis(REAL const uv[2], REAL * wDeriv[]) const;
295  IndexArray evalIrregularBasis(REAL const uv[2], REAL * wDeriv[]) const;
296  int evalMultiLinearBasis(REAL const uv[2], REAL * wDeriv[]) const;
297 
298  int evaluateStencils(REAL const uv[2], REAL * sDeriv[]) const;
299  int evalRegularStencils(REAL const uv[2], REAL * sDeriv[]) const;
300  int evalIrregularStencils(REAL const uv[2], REAL * sDeriv[]) const;
301  int evalMultiLinearStencils(REAL const uv[2], REAL * sDeriv[]) const;
302 
303  // Internal methods to compute patch points:
304  void computeLinearPatchPoints(REAL p[], PointDescriptor const &) const;
305  void computeIrregularPatchPoints(REAL p[], PointDescriptor const &) const;
306 
307  // Internal methods specific to regular or irregular patches:
308  unsigned char getRegPatchType() const { return _data.getRegPatchType(); }
309  unsigned char getRegPatchMask() const { return _data.getRegPatchMask(); }
310 
311  internal::IrregularPatchType const & getIrregPatch() const;
312 
313 private:
314  // Access to the set of member variables - provided to the Factory:
315  friend class SurfaceFactory;
316 
317  internal::SurfaceData & getSurfaceData() { return _data; }
318  internal::SurfaceData const & getSurfaceData() const { return _data; }
319 
320 private:
321  // All member variables encapsulated in a single class:
322  internal::SurfaceData _data;
323 };
324 
325 
326 //
327 // Simple inline methods composed of other methods:
328 //
329 template <typename REAL>
330 inline void
332  PointDescriptor const & pointDesc) const {
333 
334  if (!IsRegular()) {
335  if (IsLinear()) {
336  computeLinearPatchPoints(points, pointDesc);
337  } else {
338  computeIrregularPatchPoints(points, pointDesc);
339  }
340  }
341 }
342 
343 template <typename REAL>
344 inline void
346  REAL const meshPoints[], PointDescriptor const & meshPointDesc,
347  REAL patchPoints[], PointDescriptor const & patchPointDesc) const {
348 
349  GatherControlPoints(meshPoints, meshPointDesc, patchPoints, patchPointDesc);
350  ComputePatchPoints(patchPoints, patchPointDesc);
351 }
352 
353 //
354 // Inline invocations of more general methods for derivative overloads:
355 //
356 template <typename REAL>
357 inline void
358 Surface<REAL>::evaluateDerivs(REAL const uv[2],
359  REAL const patchPoints[],
360  PointDescriptor const & pointDesc,
361  REAL * derivatives[]) const {
362  if (IsRegular()) {
363  evalRegularDerivs(uv, patchPoints, pointDesc, derivatives);
364  } else if (IsLinear()) {
365  evalMultiLinearDerivs(uv, patchPoints, pointDesc, derivatives);
366  } else {
367  evalIrregularDerivs(uv, patchPoints, pointDesc, derivatives);
368  }
369 }
370 template <typename REAL>
371 inline void
372 Surface<REAL>::Evaluate(REAL const uv[2],
373  REAL const patchPoints[],
374  PointDescriptor const & pointDesc,
375  REAL P[]) const {
376 
377  REAL * derivatives[6] = { P, 0, 0, 0, 0, 0 };
378  evaluateDerivs(uv, patchPoints, pointDesc, derivatives);
379 }
380 template <typename REAL>
381 inline void
382 Surface<REAL>::Evaluate(REAL const uv[2],
383  REAL const patchPoints[],
384  PointDescriptor const & pointDesc,
385  REAL P[], REAL Du[], REAL Dv[]) const {
386 
387  REAL * derivatives[6] = { P, Du, Dv, 0, 0, 0 };
388  evaluateDerivs(uv, patchPoints, pointDesc, derivatives);
389 }
390 template <typename REAL>
391 inline void
392 Surface<REAL>::Evaluate(REAL const uv[2],
393  REAL const patchPoints[],
394  PointDescriptor const & pointDesc,
395  REAL P[], REAL Du[], REAL Dv[],
396  REAL Duu[], REAL Duv[], REAL Dvv[]) const {
397 
398  REAL * derivatives[6] = { P, Du, Dv, Duu, Duv, Dvv };
399  evaluateDerivs(uv, patchPoints, pointDesc, derivatives);
400 }
401 
402 template <typename REAL>
403 inline int
404 Surface<REAL>::evaluateStencils(REAL const uv[2], REAL * sDeriv[]) const {
405 
406  if (IsRegular()) {
407  return evalRegularStencils(uv, sDeriv);
408  } else if (IsLinear()) {
409  return evalMultiLinearStencils(uv, sDeriv);
410  } else {
411  return evalIrregularStencils(uv, sDeriv);
412  }
413 }
414 template <typename REAL>
415 inline int
416 Surface<REAL>::EvaluateStencil(REAL const uv[2], REAL sP[]) const {
417 
418  REAL * derivativeStencils[6] = { sP, 0, 0, 0, 0, 0 };
419  return evaluateStencils(uv, derivativeStencils);
420 }
421 template <typename REAL>
422 inline int
424  REAL sP[], REAL sDu[], REAL sDv[]) const {
425 
426  REAL * derivativeStencils[6] = { sP, sDu, sDv, 0, 0, 0 };
427  return evaluateStencils(uv, derivativeStencils);
428 }
429 template <typename REAL>
430 inline int
432  REAL sP[], REAL sDu[], REAL sDv[],
433  REAL sDuu[], REAL sDuv[], REAL sDvv[]) const {
434 
435  REAL * derivativeStencils[6] = { sP, sDu, sDv, sDuu, sDuv, sDvv };
436  return evaluateStencils(uv, derivativeStencils);
437 }
438 
439 } // end namespace Bfr
440 
441 } // end namespace OPENSUBDIV_VERSION
442 using namespace OPENSUBDIV_VERSION;
443 
444 } // end namespace OpenSubdiv
445 
446 #endif /* OPENSUBDIV3_BFR_SURFACE */
void ApplyStencil(REAL const stencil[], REAL const controlPoints[], PointDescriptor const &, REAL result[]) const
Apply a single stencil to control points from a local array.
void Evaluate(REAL const uv[2], REAL const patchPoints[], PointDescriptor const &pointDesc, REAL P[]) const
Evaluation of position.
Definition: surface.h:372
void GatherControlPoints(REAL_MESH const meshPoints[], PointDescriptor const &meshPointDesc, REAL controlPoints[], PointDescriptor const &controlPointDesc) const
Gather control points in a local array.
void Clear()
Clear a previously initialized Surface.
Definition: surface.h:89
Simple class defining the 2D parameterization of a face.
void BoundControlPoints(REAL const controlPoints[], PointDescriptor const &controlPointDesc, REAL minExtent[], REAL maxExtent[]) const
Compute bounds of control points from a local array.
bool IsValid() const
Return true if successfully initialized.
Definition: surface.h:86
void PreparePatchPoints(REAL const meshPoints[], PointDescriptor const &meshPointDesc, REAL patchPoints[], PointDescriptor const &patchPointDesc) const
Prepare patch points in a local array for evaluation.
Definition: surface.h:345
int GetNumPatchPoints() const
Return the number of patch points representing the Surface.
void ApplyStencilFromMesh(REAL const stencil[], REAL const meshPoints[], PointDescriptor const &, REAL result[]) const
Apply a single stencil to control points from the mesh data.
Base class providing initialization of a Surface for each face of a mesh.
int GetFaceSize() const
Returns the size (number of vertices) of the corresponding face.
int GetNumControlPoints() const
Return the number of control points affecting the Surface.
Definition: surface.h:137
int EvaluateStencil(REAL const uv[2], REAL sP[]) const
Evaluation of the limit stencil for position.
Definition: surface.h:416
int Index
Integer type representing a mesh index.
Definition: surface.h:72
bool IsLinear() const
Return if the Surface is linear.
Definition: surface.h:115
bool IsRegular() const
Return if the Surface is a single regular patch.
Definition: surface.h:112
void ComputePatchPoints(REAL patchPoints[], PointDescriptor const &patchPointDesc) const
Compute all patch points following the control points.
Definition: surface.h:331
void BoundControlPointsFromMesh(REAL const meshPoints[], PointDescriptor const &meshPointDesc, REAL minExtent[], REAL maxExtent[]) const
Compute bounds of control points from the mesh data.
Simple struct defining the size and stride of points in arrays.
Definition: surface.h:63
Surface()
Default construction produces an invalid instance.
int GetFaceSize() const
Return the size of the face.
Definition: surface.h:109
Encapsulates the limit surface for a face of a mesh.
Definition: surface.h:59
Surface & operator=(Surface const &src)=default
int GetControlPointIndices(Index meshPointIndices[]) const
Identify indices of control points in the mesh.
Parameterization GetParameterization() const
Return the Parameterization.
Definition: surface.h:106