My Project: opensubdiv/far/primvarRefiner.h Source File

| My Project

primvarRefiner.h
Go to the documentation of this file.
1 //
2 // Copyright 2015 DreamWorks Animation LLC.
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 #ifndef OPENSUBDIV3_FAR_PRIMVAR_REFINER_H
25 #define OPENSUBDIV3_FAR_PRIMVAR_REFINER_H
26
27 #include "../version.h"
28
29 #include "../sdc/types.h"
30 #include "../sdc/options.h"
31 #include "../sdc/bilinearScheme.h"
32 #include "../sdc/catmarkScheme.h"
33 #include "../sdc/loopScheme.h"
34 #include "../vtr/level.h"
35 #include "../vtr/fvarLevel.h"
36 #include "../vtr/refinement.h"
37 #include "../vtr/fvarRefinement.h"
38 #include "../vtr/stackBuffer.h"
39 #include "../vtr/componentInterfaces.h"
40 #include "../far/types.h"
41 #include "../far/error.h"
42 #include "../far/topologyLevel.h"
43 #include "../far/topologyRefiner.h"
44
45 #include <cassert>
46
47 namespace OpenSubdiv {
48 namespace OPENSUBDIV_VERSION {
49
50 namespace Far {
51
55 template <typename REAL>
56 class PrimvarRefinerReal {
57
58 public:
59 PrimvarRefinerReal(TopologyRefiner const & refiner) : _refiner(refiner) { }
60 ~PrimvarRefinerReal() { }
61
62 TopologyRefiner const & GetTopologyRefiner() const { return _refiner; }
63
65
113 template <class T, class U> void Interpolate(int level, T const & src, U & dst) const;
114
130 template <class T, class U> void InterpolateVarying(int level, T const & src, U & dst) const;
131
148 template <class T, class U> void InterpolateFaceUniform(int level, T const & src, U & dst) const;
149
161 template <class T, class U> void InterpolateFaceVarying(int level, T const & src, U & dst, int channel = 0) const;
162
163
175 template <class T, class U> void Limit(T const & src, U & dstPos) const;
176
177 template <class T, class U, class U1, class U2>
178 void Limit(T const & src, U & dstPos, U1 & dstTan1, U2 & dstTan2) const;
179
180 template <class T, class U> void LimitFaceVarying(T const & src, U & dst, int channel = 0) const;
181
183
184 private:
185 typedef REAL Weight;
186
187 // Non-copyable:
188 PrimvarRefinerReal(PrimvarRefinerReal const & src) : _refiner(src._refiner) { }
189 PrimvarRefinerReal & operator=(PrimvarRefinerReal const &) { return *this; }
190
191 template <Sdc::SchemeType SCHEME, class T, class U> void interpFromFaces(int, T const &, U &) const;
192 template <Sdc::SchemeType SCHEME, class T, class U> void interpFromEdges(int, T const &, U &) const;
193 template <Sdc::SchemeType SCHEME, class T, class U> void interpFromVerts(int, T const &, U &) const;
194
195 template <Sdc::SchemeType SCHEME, class T, class U> void interpFVarFromFaces(int, T const &, U &, int) const;
196 template <Sdc::SchemeType SCHEME, class T, class U> void interpFVarFromEdges(int, T const &, U &, int) const;
197 template <Sdc::SchemeType SCHEME, class T, class U> void interpFVarFromVerts(int, T const &, U &, int) const;
198
199 template <Sdc::SchemeType SCHEME, class T, class U, class U1, class U2>
200 void limit(T const & src, U & pos, U1 * tan1, U2 * tan2) const;
201
202 template <Sdc::SchemeType SCHEME, class T, class U>
203 void limitFVar(T const & src, U & dst, int channel) const;
204
205 private:
206 TopologyRefiner const & _refiner;
207
208 private:
209 //
210 // Local class to fulfill interface for <typename MASK> in the Scheme mask queries:
211 //
212 class Mask {
213 public:
214 typedef REAL Weight; // Also part of the expected interface
215
216 public:
217 Mask(Weight* v, Weight* e, Weight* f) :
218 _vertWeights(v), _edgeWeights(e), _faceWeights(f),
219 _vertCount(0), _edgeCount(0), _faceCount(0),
220 _faceWeightsForFaceCenters(false)
221 { }
222
223 ~Mask() { }
224
225 public: // Generic interface expected of <typename MASK>:
226 int GetNumVertexWeights() const { return _vertCount; }
227 int GetNumEdgeWeights() const { return _edgeCount; }
228 int GetNumFaceWeights() const { return _faceCount; }
229
230 void SetNumVertexWeights(int count) { _vertCount = count; }
231 void SetNumEdgeWeights( int count) { _edgeCount = count; }
232 void SetNumFaceWeights( int count) { _faceCount = count; }
233
234 Weight const& VertexWeight(int index) const { return _vertWeights[index]; }
235 Weight const& EdgeWeight( int index) const { return _edgeWeights[index]; }
236 Weight const& FaceWeight( int index) const { return _faceWeights[index]; }
237
238 Weight& VertexWeight(int index) { return _vertWeights[index]; }
239 Weight& EdgeWeight( int index) { return _edgeWeights[index]; }
240 Weight& FaceWeight( int index) { return _faceWeights[index]; }
241
242 bool AreFaceWeightsForFaceCenters() const { return _faceWeightsForFaceCenters; }
243 void SetFaceWeightsForFaceCenters(bool on) { _faceWeightsForFaceCenters = on; }
244
245 private:
246 Weight* _vertWeights;
247 Weight* _edgeWeights;
248 Weight* _faceWeights;
249
250 int _vertCount;
251 int _edgeCount;
252 int _faceCount;
253
254 bool _faceWeightsForFaceCenters;
255 };
256 };
257
258
259 //
260 // Public entry points to the methods. Queries of the scheme type and its
261 // use as a template parameter in subsequent implementation will be factored
262 // out of a later release:
263 //
264 template <typename REAL>
265 template <class T, class U>
266 inline void
267 PrimvarRefinerReal<REAL>::Interpolate(int level, T const & src, U & dst) const {
268
269 assert(level>0 && level<=(int)_refiner._refinements.size());
270
271 switch (_refiner._subdivType) {
272 case Sdc::SCHEME_CATMARK:
273 interpFromFaces<Sdc::SCHEME_CATMARK>(level, src, dst);
274 interpFromEdges<Sdc::SCHEME_CATMARK>(level, src, dst);
275 interpFromVerts<Sdc::SCHEME_CATMARK>(level, src, dst);
276 break;
277 case Sdc::SCHEME_LOOP:
278 interpFromFaces<Sdc::SCHEME_LOOP>(level, src, dst);
279 interpFromEdges<Sdc::SCHEME_LOOP>(level, src, dst);
280 interpFromVerts<Sdc::SCHEME_LOOP>(level, src, dst);
281 break;
282 case Sdc::SCHEME_BILINEAR:
283 interpFromFaces<Sdc::SCHEME_BILINEAR>(level, src, dst);
284 interpFromEdges<Sdc::SCHEME_BILINEAR>(level, src, dst);
285 interpFromVerts<Sdc::SCHEME_BILINEAR>(level, src, dst);
286 break;
287 }
288 }
289
290 template <typename REAL>
291 template <class T, class U>
292 inline void
293 PrimvarRefinerReal<REAL>::InterpolateFaceVarying(int level, T const & src, U & dst, int channel) const {
294
295 assert(level>0 && level<=(int)_refiner._refinements.size());
296
297 switch (_refiner._subdivType) {
298 case Sdc::SCHEME_CATMARK:
299 interpFVarFromFaces<Sdc::SCHEME_CATMARK>(level, src, dst, channel);
300 interpFVarFromEdges<Sdc::SCHEME_CATMARK>(level, src, dst, channel);
301 interpFVarFromVerts<Sdc::SCHEME_CATMARK>(level, src, dst, channel);
302 break;
303 case Sdc::SCHEME_LOOP:
304 interpFVarFromFaces<Sdc::SCHEME_LOOP>(level, src, dst, channel);
305 interpFVarFromEdges<Sdc::SCHEME_LOOP>(level, src, dst, channel);
306 interpFVarFromVerts<Sdc::SCHEME_LOOP>(level, src, dst, channel);
307 break;
308 case Sdc::SCHEME_BILINEAR:
309 interpFVarFromFaces<Sdc::SCHEME_BILINEAR>(level, src, dst, channel);
310 interpFVarFromEdges<Sdc::SCHEME_BILINEAR>(level, src, dst, channel);
311 interpFVarFromVerts<Sdc::SCHEME_BILINEAR>(level, src, dst, channel);
312 break;
313 }
314 }
315
316 template <typename REAL>
317 template <class T, class U>
318 inline void
319 PrimvarRefinerReal<REAL>::Limit(T const & src, U & dst) const {
320
321 if (_refiner.getLevel(_refiner.GetMaxLevel()).getNumVertexEdgesTotal() == 0) {
322 Error(FAR_RUNTIME_ERROR,
323 "Failure in PrimvarRefiner::Limit() -- "
324 "last level of refinement does not include full topology.");
325 return;
326 }
327
328 switch (_refiner._subdivType) {
329 case Sdc::SCHEME_CATMARK:
330 limit<Sdc::SCHEME_CATMARK>(src, dst, (U*)0, (U*)0);
331 break;
332 case Sdc::SCHEME_LOOP:
333 limit<Sdc::SCHEME_LOOP>(src, dst, (U*)0, (U*)0);
334 break;
335 case Sdc::SCHEME_BILINEAR:
336 limit<Sdc::SCHEME_BILINEAR>(src, dst, (U*)0, (U*)0);
337 break;
338 }
339 }
340
341 template <typename REAL>
342 template <class T, class U, class U1, class U2>
343 inline void
344 PrimvarRefinerReal<REAL>::Limit(T const & src, U & dstPos, U1 & dstTan1, U2 & dstTan2) const {
345
346 if (_refiner.getLevel(_refiner.GetMaxLevel()).getNumVertexEdgesTotal() == 0) {
347 Error(FAR_RUNTIME_ERROR,
348 "Failure in PrimvarRefiner::Limit() -- "
349 "last level of refinement does not include full topology.");
350 return;
351 }
352
353 switch (_refiner._subdivType) {
354 case Sdc::SCHEME_CATMARK:
355 limit<Sdc::SCHEME_CATMARK>(src, dstPos, &dstTan1, &dstTan2);
356 break;
357 case Sdc::SCHEME_LOOP:
358 limit<Sdc::SCHEME_LOOP>(src, dstPos, &dstTan1, &dstTan2);
359 break;
360 case Sdc::SCHEME_BILINEAR:
361 limit<Sdc::SCHEME_BILINEAR>(src, dstPos, &dstTan1, &dstTan2);
362 break;
363 }
364 }
365
366 template <typename REAL>
367 template <class T, class U>
368 inline void
369 PrimvarRefinerReal<REAL>::LimitFaceVarying(T const & src, U & dst, int channel) const {
370
371 if (_refiner.getLevel(_refiner.GetMaxLevel()).getNumVertexEdgesTotal() == 0) {
372 Error(FAR_RUNTIME_ERROR,
373 "Failure in PrimvarRefiner::LimitFaceVarying() -- "
374 "last level of refinement does not include full topology.");
375 return;
376 }
377
378 switch (_refiner._subdivType) {
379 case Sdc::SCHEME_CATMARK:
380 limitFVar<Sdc::SCHEME_CATMARK>(src, dst, channel);
381 break;
382 case Sdc::SCHEME_LOOP:
383 limitFVar<Sdc::SCHEME_LOOP>(src, dst, channel);
384 break;
385 case Sdc::SCHEME_BILINEAR:
386 limitFVar<Sdc::SCHEME_BILINEAR>(src, dst, channel);
387 break;
388 }
389 }
390
391 template <typename REAL>
392 template <class T, class U>
393 inline void
394 PrimvarRefinerReal<REAL>::InterpolateFaceUniform(int level, T const & src, U & dst) const {
395
396 assert(level>0 && level<=(int)_refiner._refinements.size());
397
398 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
399 Vtr::internal::Level const & child = refinement.child();
400
401 for (int cFace = 0; cFace < child.getNumFaces(); ++cFace) {
402
403 Vtr::Index pFace = refinement.getChildFaceParentFace(cFace);
404
405 dst[cFace] = src[pFace];
406 }
407 }
408
409 template <typename REAL>
410 template <class T, class U>
411 inline void
412 PrimvarRefinerReal<REAL>::InterpolateVarying(int level, T const & src, U & dst) const {
413
414 assert(level>0 && level<=(int)_refiner._refinements.size());
415
416 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
417 Vtr::internal::Level const & parent = refinement.parent();
418
419 //
420 // Group values to interpolate based on origin -- note that there may
421 // be none originating from faces:
422 //
423 if (refinement.getNumChildVerticesFromFaces() > 0) {
424
425 for (int face = 0; face < parent.getNumFaces(); ++face) {
426
427 Vtr::Index cVert = refinement.getFaceChildVertex(face);
428 if (Vtr::IndexIsValid(cVert)) {
429
430 // Apply the weights to the parent face's vertices:
431 ConstIndexArray fVerts = parent.getFaceVertices(face);
432
433 Weight fVaryingWeight = 1.0f / (Weight) fVerts.size();
434
435 dst[cVert].Clear();
436 for (int i = 0; i < fVerts.size(); ++i) {
437 dst[cVert].AddWithWeight(src[fVerts[i]], fVaryingWeight);
438 }
439 }
440 }
441 }
442 for (int edge = 0; edge < parent.getNumEdges(); ++edge) {
443
444 Vtr::Index cVert = refinement.getEdgeChildVertex(edge);
445 if (Vtr::IndexIsValid(cVert)) {
446
447 // Apply the weights to the parent edges's vertices
448 ConstIndexArray eVerts = parent.getEdgeVertices(edge);
449
450 dst[cVert].Clear();
451 dst[cVert].AddWithWeight(src[eVerts[0]], 0.5f);
452 dst[cVert].AddWithWeight(src[eVerts[1]], 0.5f);
453 }
454 }
455 for (int vert = 0; vert < parent.getNumVertices(); ++vert) {
456
457 Vtr::Index cVert = refinement.getVertexChildVertex(vert);
458 if (Vtr::IndexIsValid(cVert)) {
459
460 // Essentially copy the parent vertex:
461 dst[cVert].Clear();
462 dst[cVert].AddWithWeight(src[vert], 1.0f);
463 }
464 }
465 }
466
467
468 //
469 // Internal implementation methods -- grouping vertices to be interpolated
470 // based on the type of parent component from which they originated:
471 //
472 template <typename REAL>
473 template <Sdc::SchemeType SCHEME, class T, class U>
474 inline void
475 PrimvarRefinerReal<REAL>::interpFromFaces(int level, T const & src, U & dst) const {
476
477 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
478 Vtr::internal::Level const & parent = refinement.parent();
479
480 if (refinement.getNumChildVerticesFromFaces() == 0) return;
481
482 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
483
484 Vtr::internal::StackBuffer<Weight,16> fVertWeights(parent.getMaxValence());
485
486 for (int face = 0; face < parent.getNumFaces(); ++face) {
487
488 Vtr::Index cVert = refinement.getFaceChildVertex(face);
489 if (!Vtr::IndexIsValid(cVert))
490 continue;
491
492 // Declare and compute mask weights for this vertex relative to its parent face:
493 ConstIndexArray fVerts = parent.getFaceVertices(face);
494
495 Mask fMask(fVertWeights, 0, 0);
496 Vtr::internal::FaceInterface fHood(fVerts.size());
497
498 scheme.ComputeFaceVertexMask(fHood, fMask);
499
500 // Apply the weights to the parent face's vertices:
501 dst[cVert].Clear();
502
503 for (int i = 0; i < fVerts.size(); ++i) {
504
505 dst[cVert].AddWithWeight(src[fVerts[i]], fVertWeights[i]);
506 }
507 }
508 }
509
510 template <typename REAL>
511 template <Sdc::SchemeType SCHEME, class T, class U>
512 inline void
513 PrimvarRefinerReal<REAL>::interpFromEdges(int level, T const & src, U & dst) const {
514
515 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
516 Vtr::internal::Level const & parent = refinement.parent();
517 Vtr::internal::Level const & child = refinement.child();
518
519 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
520
521 Vtr::internal::EdgeInterface eHood(parent);
522
523 Weight eVertWeights[2];
524 Vtr::internal::StackBuffer<Weight,8> eFaceWeights(parent.getMaxEdgeFaces());
525
526 for (int edge = 0; edge < parent.getNumEdges(); ++edge) {
527
528 Vtr::Index cVert = refinement.getEdgeChildVertex(edge);
529 if (!Vtr::IndexIsValid(cVert))
530 continue;
531
532 // Declare and compute mask weights for this vertex relative to its parent edge:
533 ConstIndexArray eVerts = parent.getEdgeVertices(edge),
534 eFaces = parent.getEdgeFaces(edge);
535
536 Mask eMask(eVertWeights, 0, eFaceWeights);
537
538 eHood.SetIndex(edge);
539
540 Sdc::Crease::Rule pRule = (parent.getEdgeSharpness(edge) > 0.0f) ? Sdc::Crease::RULE_CREASE : Sdc::Crease::RULE_SMOOTH;
541 Sdc::Crease::Rule cRule = child.getVertexRule(cVert);
542
543 scheme.ComputeEdgeVertexMask(eHood, eMask, pRule, cRule);
544
545 // Apply the weights to the parent edges's vertices and (if applicable) to
546 // the child vertices of its incident faces:
547 dst[cVert].Clear();
548 dst[cVert].AddWithWeight(src[eVerts[0]], eVertWeights[0]);
549 dst[cVert].AddWithWeight(src[eVerts[1]], eVertWeights[1]);
550
551 if (eMask.GetNumFaceWeights() > 0) {
552
553 for (int i = 0; i < eFaces.size(); ++i) {
554
555 if (eMask.AreFaceWeightsForFaceCenters()) {
556 assert(refinement.getNumChildVerticesFromFaces() > 0);
557 Vtr::Index cVertOfFace = refinement.getFaceChildVertex(eFaces[i]);
558
559 assert(Vtr::IndexIsValid(cVertOfFace));
560 dst[cVert].AddWithWeight(dst[cVertOfFace], eFaceWeights[i]);
561 } else {
562 Vtr::Index pFace = eFaces[i];
563 ConstIndexArray pFaceEdges = parent.getFaceEdges(pFace),
564 pFaceVerts = parent.getFaceVertices(pFace);
565
566 int eInFace = 0;
567 for ( ; pFaceEdges[eInFace] != edge; ++eInFace ) ;
568
569 int vInFace = eInFace + 2;
570 if (vInFace >= pFaceVerts.size()) vInFace -= pFaceVerts.size();
571
572 Vtr::Index pVertNext = pFaceVerts[vInFace];
573 dst[cVert].AddWithWeight(src[pVertNext], eFaceWeights[i]);
574 }
575 }
576 }
577 }
578 }
579
580 template <typename REAL>
581 template <Sdc::SchemeType SCHEME, class T, class U>
582 inline void
583 PrimvarRefinerReal<REAL>::interpFromVerts(int level, T const & src, U & dst) const {
584
585 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
586 Vtr::internal::Level const & parent = refinement.parent();
587 Vtr::internal::Level const & child = refinement.child();
588
589 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
590
591 Vtr::internal::VertexInterface vHood(parent, child);
592
593 Vtr::internal::StackBuffer<Weight,32> weightBuffer(2*parent.getMaxValence());
594
595 for (int vert = 0; vert < parent.getNumVertices(); ++vert) {
596
597 Vtr::Index cVert = refinement.getVertexChildVertex(vert);
598 if (!Vtr::IndexIsValid(cVert))
599 continue;
600
601 // Declare and compute mask weights for this vertex relative to its parent edge:
602 ConstIndexArray vEdges = parent.getVertexEdges(vert),
603 vFaces = parent.getVertexFaces(vert);
604
605 Weight vVertWeight,
606 * vEdgeWeights = weightBuffer,
607 * vFaceWeights = vEdgeWeights + vEdges.size();
608
609 Mask vMask(&vVertWeight, vEdgeWeights, vFaceWeights);
610
611 vHood.SetIndex(vert, cVert);
612
613 Sdc::Crease::Rule pRule = parent.getVertexRule(vert);
614 Sdc::Crease::Rule cRule = child.getVertexRule(cVert);
615
616 scheme.ComputeVertexVertexMask(vHood, vMask, pRule, cRule);
617
618 // Apply the weights to the parent vertex, the vertices opposite its incident
619 // edges, and the child vertices of its incident faces:
620 //
621 // In order to improve numerical precision, it's better to apply smaller weights
622 // first, so begin with the face-weights followed by the edge-weights and the
623 // vertex weight last.
624 dst[cVert].Clear();
625
626 if (vMask.GetNumFaceWeights() > 0) {
627 assert(vMask.AreFaceWeightsForFaceCenters());
628
629 for (int i = 0; i < vFaces.size(); ++i) {
630
631 Vtr::Index cVertOfFace = refinement.getFaceChildVertex(vFaces[i]);
632 assert(Vtr::IndexIsValid(cVertOfFace));
633 dst[cVert].AddWithWeight(dst[cVertOfFace], vFaceWeights[i]);
634 }
635 }
636 if (vMask.GetNumEdgeWeights() > 0) {
637
638 for (int i = 0; i < vEdges.size(); ++i) {
639
640 ConstIndexArray eVerts = parent.getEdgeVertices(vEdges[i]);
641 Vtr::Index pVertOppositeEdge = (eVerts[0] == vert) ? eVerts[1] : eVerts[0];
642
643 dst[cVert].AddWithWeight(src[pVertOppositeEdge], vEdgeWeights[i]);
644 }
645 }
646 dst[cVert].AddWithWeight(src[vert], vVertWeight);
647 }
648 }
649
650
651 //
652 // Internal face-varying implementation details:
653 //
654 template <typename REAL>
655 template <Sdc::SchemeType SCHEME, class T, class U>
656 inline void
657 PrimvarRefinerReal<REAL>::interpFVarFromFaces(int level, T const & src, U & dst, int channel) const {
658
659 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
660
661 if (refinement.getNumChildVerticesFromFaces() == 0) return;
662
663 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
664
665 Vtr::internal::Level const & parentLevel = refinement.parent();
666 Vtr::internal::Level const & childLevel = refinement.child();
667
668 Vtr::internal::FVarLevel const & parentFVar = parentLevel.getFVarLevel(channel);
669 Vtr::internal::FVarLevel const & childFVar = childLevel.getFVarLevel(channel);
670
671 Vtr::internal::StackBuffer<Weight,16> fValueWeights(parentLevel.getMaxValence());
672
673 for (int face = 0; face < parentLevel.getNumFaces(); ++face) {
674
675 Vtr::Index cVert = refinement.getFaceChildVertex(face);
676 if (!Vtr::IndexIsValid(cVert))
677 continue;
678
679 Vtr::Index cVertValue = childFVar.getVertexValueOffset(cVert);
680
681 // The only difference for face-varying here is that we get the values associated
682 // with each face-vertex directly from the FVarLevel, rather than using the parent
683 // face-vertices directly. If any face-vertex has any sibling values, then we may
684 // get the wrong one using the face-vertex index directly.
685
686 // Declare and compute mask weights for this vertex relative to its parent face:
687 ConstIndexArray fValues = parentFVar.getFaceValues(face);
688
689 Mask fMask(fValueWeights, 0, 0);
690 Vtr::internal::FaceInterface fHood(fValues.size());
691
692 scheme.ComputeFaceVertexMask(fHood, fMask);
693
694 // Apply the weights to the parent face's vertices:
695 dst[cVertValue].Clear();
696
697 for (int i = 0; i < fValues.size(); ++i) {
698 dst[cVertValue].AddWithWeight(src[fValues[i]], fValueWeights[i]);
699 }
700 }
701 }
702
703 template <typename REAL>
704 template <Sdc::SchemeType SCHEME, class T, class U>
705 inline void
706 PrimvarRefinerReal<REAL>::interpFVarFromEdges(int level, T const & src, U & dst, int channel) const {
707
708 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
709
710 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
711
712 Vtr::internal::Level const & parentLevel = refinement.parent();
713 Vtr::internal::Level const & childLevel = refinement.child();
714
715 Vtr::internal::FVarRefinement const & refineFVar = refinement.getFVarRefinement(channel);
716 Vtr::internal::FVarLevel const & parentFVar = parentLevel.getFVarLevel(channel);
717 Vtr::internal::FVarLevel const & childFVar = childLevel.getFVarLevel(channel);
718
719 //
720 // Allocate and initialize (if linearly interpolated) interpolation weights for
721 // the edge mask:
722 //
723 Weight eVertWeights[2];
724 Vtr::internal::StackBuffer<Weight,8> eFaceWeights(parentLevel.getMaxEdgeFaces());
725
726 Mask eMask(eVertWeights, 0, eFaceWeights);
727
728 bool isLinearFVar = parentFVar.isLinear() || (_refiner._subdivType == Sdc::SCHEME_BILINEAR);
729 if (isLinearFVar) {
730 eMask.SetNumVertexWeights(2);
731 eMask.SetNumEdgeWeights(0);
732 eMask.SetNumFaceWeights(0);
733
734 eVertWeights[0] = 0.5f;
735 eVertWeights[1] = 0.5f;
736 }
737
738 Vtr::internal::EdgeInterface eHood(parentLevel);
739
740 for (int edge = 0; edge < parentLevel.getNumEdges(); ++edge) {
741
742 Vtr::Index cVert = refinement.getEdgeChildVertex(edge);
743 if (!Vtr::IndexIsValid(cVert))
744 continue;
745
746 ConstIndexArray cVertValues = childFVar.getVertexValues(cVert);
747
748 bool fvarEdgeVertMatchesVertex = childFVar.valueTopologyMatches(cVertValues[0]);
749 if (fvarEdgeVertMatchesVertex) {
750 //
751 // If smoothly interpolated, compute new weights for the edge mask:
752 //
753 if (!isLinearFVar) {
754 eHood.SetIndex(edge);
755
756 Sdc::Crease::Rule pRule = (parentLevel.getEdgeSharpness(edge) > 0.0f)
757 ? Sdc::Crease::RULE_CREASE : Sdc::Crease::RULE_SMOOTH;
758 Sdc::Crease::Rule cRule = childLevel.getVertexRule(cVert);
759
760 scheme.ComputeEdgeVertexMask(eHood, eMask, pRule, cRule);
761 }
762
763 // Apply the weights to the parent edge's vertices and (if applicable) to
764 // the child vertices of its incident faces:
765 //
766 // Even though the face-varying topology matches the vertex topology, we need
767 // to be careful here when getting values corresponding to the two end-vertices.
768 // While the edge may be continuous, the vertices at their ends may have
769 // discontinuities elsewhere in their neighborhood (i.e. on the "other side"
770 // of the end-vertex) and so have sibling values associated with them. In most
771 // cases the topology for an end-vertex will match and we can use it directly,
772 // but we must still check and retrieve as needed.
773 //
774 // Indices for values corresponding to face-vertices are guaranteed to match,
775 // so we can use the child-vertex indices directly.
776 //
777 // And by "directly", we always use getVertexValue(vertexIndex) to reference
778 // values in the "src" to account for the possible indirection that may exist at
779 // level 0 -- where there may be fewer values than vertices and an additional
780 // indirection is necessary. We can use a vertex index directly for "dst" when
781 // it matches.
782 //
783 Vtr::Index eVertValues[2];
784
785 parentFVar.getEdgeFaceValues(edge, 0, eVertValues);
786
787 Index cVertValue = cVertValues[0];
788
789 dst[cVertValue].Clear();
790 dst[cVertValue].AddWithWeight(src[eVertValues[0]], eVertWeights[0]);
791 dst[cVertValue].AddWithWeight(src[eVertValues[1]], eVertWeights[1]);
792
793 if (eMask.GetNumFaceWeights() > 0) {
794
795 ConstIndexArray eFaces = parentLevel.getEdgeFaces(edge);
796
797 for (int i = 0; i < eFaces.size(); ++i) {
798 if (eMask.AreFaceWeightsForFaceCenters()) {
799
800 Vtr::Index cVertOfFace = refinement.getFaceChildVertex(eFaces[i]);
801 assert(Vtr::IndexIsValid(cVertOfFace));
802
803 Vtr::Index cValueOfFace = childFVar.getVertexValueOffset(cVertOfFace);
804 dst[cVertValue].AddWithWeight(dst[cValueOfFace], eFaceWeights[i]);
805 } else {
806 Vtr::Index pFace = eFaces[i];
807 ConstIndexArray pFaceEdges = parentLevel.getFaceEdges(pFace),
808 pFaceVerts = parentLevel.getFaceVertices(pFace);
809
810 int eInFace = 0;
811 for ( ; pFaceEdges[eInFace] != edge; ++eInFace ) ;
812
813 // Edge "i" spans vertices [i,i+1] so we want i+2...
814 int vInFace = eInFace + 2;
815 if (vInFace >= pFaceVerts.size()) vInFace -= pFaceVerts.size();
816
817 Vtr::Index pValueNext = parentFVar.getFaceValues(pFace)[vInFace];
818 dst[cVertValue].AddWithWeight(src[pValueNext], eFaceWeights[i]);
819 }
820 }
821 }
822 } else {
823 //
824 // Mismatched edge-verts should just be linearly interpolated between the pairs of
825 // values for each sibling of the child edge-vertex -- the question is: which face
826 // holds that pair of values for a given sibling?
827 //
828 // In the manifold case, the sibling and edge-face indices will correspond. We
829 // will eventually need to update this to account for > 3 incident faces.
830 //
831 for (int i = 0; i < cVertValues.size(); ++i) {
832 Vtr::Index eVertValues[2];
833 int eFaceIndex = refineFVar.getChildValueParentSource(cVert, i);
834 assert(eFaceIndex == i);
835
836 parentFVar.getEdgeFaceValues(edge, eFaceIndex, eVertValues);
837
838 Index cVertValue = cVertValues[i];
839
840 dst[cVertValue].Clear();
841 dst[cVertValue].AddWithWeight(src[eVertValues[0]], 0.5);
842 dst[cVertValue].AddWithWeight(src[eVertValues[1]], 0.5);
843 }
844 }
845 }
846 }
847
848 template <typename REAL>
849 template <Sdc::SchemeType SCHEME, class T, class U>
850 inline void
851 PrimvarRefinerReal<REAL>::interpFVarFromVerts(int level, T const & src, U & dst, int channel) const {
852
853 Vtr::internal::Refinement const & refinement = _refiner.getRefinement(level-1);
854
855 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
856
857 Vtr::internal::Level const & parentLevel = refinement.parent();
858 Vtr::internal::Level const & childLevel = refinement.child();
859
860 Vtr::internal::FVarRefinement const & refineFVar = refinement.getFVarRefinement(channel);
861 Vtr::internal::FVarLevel const & parentFVar = parentLevel.getFVarLevel(channel);
862 Vtr::internal::FVarLevel const & childFVar = childLevel.getFVarLevel(channel);
863
864 bool isLinearFVar = parentFVar.isLinear() || (_refiner._subdivType == Sdc::SCHEME_BILINEAR);
865
866 Vtr::internal::StackBuffer<Weight,32> weightBuffer(2*parentLevel.getMaxValence());
867
868 Vtr::internal::StackBuffer<Vtr::Index,16> vEdgeValues(parentLevel.getMaxValence());
869
870 Vtr::internal::VertexInterface vHood(parentLevel, childLevel);
871
872 for (int vert = 0; vert < parentLevel.getNumVertices(); ++vert) {
873
874 Vtr::Index cVert = refinement.getVertexChildVertex(vert);
875 if (!Vtr::IndexIsValid(cVert))
876 continue;
877
878 ConstIndexArray pVertValues = parentFVar.getVertexValues(vert),
879 cVertValues = childFVar.getVertexValues(cVert);
880
881 bool fvarVertVertMatchesVertex = childFVar.valueTopologyMatches(cVertValues[0]);
882 if (isLinearFVar && fvarVertVertMatchesVertex) {
883 dst[cVertValues[0]].Clear();
884 dst[cVertValues[0]].AddWithWeight(src[pVertValues[0]], 1.0f);
885 continue;
886 }
887
888 if (fvarVertVertMatchesVertex) {
889 //
890 // Declare and compute mask weights for this vertex relative to its parent edge:
891 //
892 // (We really need to encapsulate this somewhere else for use here and in the
893 // general case)
894 //
895 ConstIndexArray vEdges = parentLevel.getVertexEdges(vert);
896
897 Weight vVertWeight;
898 Weight * vEdgeWeights = weightBuffer;
899 Weight * vFaceWeights = vEdgeWeights + vEdges.size();
900
901 Mask vMask(&vVertWeight, vEdgeWeights, vFaceWeights);
902
903 vHood.SetIndex(vert, cVert);
904
905 Sdc::Crease::Rule pRule = parentLevel.getVertexRule(vert);
906 Sdc::Crease::Rule cRule = childLevel.getVertexRule(cVert);
907
908 scheme.ComputeVertexVertexMask(vHood, vMask, pRule, cRule);
909
910 // Apply the weights to the parent vertex, the vertices opposite its incident
911 // edges, and the child vertices of its incident faces:
912 //
913 // Even though the face-varying topology matches the vertex topology, we need
914 // to be careful here when getting values corresponding to vertices at the
915 // ends of edges. While the edge may be continuous, the end vertex may have
916 // discontinuities elsewhere in their neighborhood (i.e. on the "other side"
917 // of the end-vertex) and so have sibling values associated with them. In most
918 // cases the topology for an end-vertex will match and we can use it directly,
919 // but we must still check and retrieve as needed.
920 //
921 // Indices for values corresponding to face-vertices are guaranteed to match,
922 // so we can use the child-vertex indices directly.
923 //
924 // And by "directly", we always use getVertexValue(vertexIndex) to reference
925 // values in the "src" to account for the possible indirection that may exist at
926 // level 0 -- where there may be fewer values than vertices and an additional
927 // indirection is necessary. We can use a vertex index directly for "dst" when
928 // it matches.
929 //
930 // As with applying the mask to vertex data, in order to improve numerical
931 // precision, it's better to apply smaller weights first, so begin with the
932 // face-weights followed by the edge-weights and the vertex weight last.
933 //
934 Vtr::Index pVertValue = pVertValues[0];
935 Vtr::Index cVertValue = cVertValues[0];
936
937 dst[cVertValue].Clear();
938 if (vMask.GetNumFaceWeights() > 0) {
939 assert(vMask.AreFaceWeightsForFaceCenters());
940
941 ConstIndexArray vFaces = parentLevel.getVertexFaces(vert);
942
943 for (int i = 0; i < vFaces.size(); ++i) {
944
945 Vtr::Index cVertOfFace = refinement.getFaceChildVertex(vFaces[i]);
946 assert(Vtr::IndexIsValid(cVertOfFace));
947
948 Vtr::Index cValueOfFace = childFVar.getVertexValueOffset(cVertOfFace);
949 dst[cVertValue].AddWithWeight(dst[cValueOfFace], vFaceWeights[i]);
950 }
951 }
952 if (vMask.GetNumEdgeWeights() > 0) {
953
954 parentFVar.getVertexEdgeValues(vert, vEdgeValues);
955
956 for (int i = 0; i < vEdges.size(); ++i) {
957 dst[cVertValue].AddWithWeight(src[vEdgeValues[i]], vEdgeWeights[i]);
958 }
959 }
960 dst[cVertValue].AddWithWeight(src[pVertValue], vVertWeight);
961 } else {
962 //
963 // Each FVar value associated with a vertex will be either a corner or a crease,
964 // or potentially in transition from corner to crease:
965 // - if the CHILD is a corner, there can be no transition so we have a corner
966 // - otherwise if the PARENT is a crease, both will be creases (no transition)
967 // - otherwise the parent must be a corner and the child a crease (transition)
968 //
969 Vtr::internal::FVarLevel::ConstValueTagArray pValueTags = parentFVar.getVertexValueTags(vert);
970 Vtr::internal::FVarLevel::ConstValueTagArray cValueTags = childFVar.getVertexValueTags(cVert);
971
972 for (int cSibling = 0; cSibling < cVertValues.size(); ++cSibling) {
973 int pSibling = refineFVar.getChildValueParentSource(cVert, cSibling);
974 assert(pSibling == cSibling);
975
976 Vtr::Index pVertValue = pVertValues[pSibling];
977 Vtr::Index cVertValue = cVertValues[cSibling];
978
979 dst[cVertValue].Clear();
980 if (isLinearFVar || cValueTags[cSibling].isCorner()) {
981 dst[cVertValue].AddWithWeight(src[pVertValue], 1.0f);
982 } else {
983 //
984 // We have either a crease or a transition from corner to crease -- in
985 // either case, we need the end values for the full/fractional crease:
986 //
987 Index pEndValues[2];
988 parentFVar.getVertexCreaseEndValues(vert, pSibling, pEndValues);
989
990 Weight vWeight = 0.75f;
991 Weight eWeight = 0.125f;
992
993 //
994 // If semi-sharp we need to apply fractional weighting -- if made sharp because
995 // of the other sibling (dependent-sharp) use the fractional weight from that
996 // other sibling (should only occur when there are 2):
997 //
998 if (pValueTags[pSibling].isSemiSharp()) {
999 Weight wCorner = pValueTags[pSibling].isDepSharp()
1000 ? refineFVar.getFractionalWeight(vert, !pSibling, cVert, !cSibling)
1001 : refineFVar.getFractionalWeight(vert, pSibling, cVert, cSibling);
1002 Weight wCrease = 1.0f - wCorner;
1003
1004 vWeight = wCrease * 0.75f + wCorner;
1005 eWeight = wCrease * 0.125f;
1006 }
1007 dst[cVertValue].AddWithWeight(src[pEndValues[0]], eWeight);
1008 dst[cVertValue].AddWithWeight(src[pEndValues[1]], eWeight);
1009 dst[cVertValue].AddWithWeight(src[pVertValue], vWeight);
1010 }
1011 }
1012 }
1013 }
1014 }
1015
1016 template <typename REAL>
1017 template <Sdc::SchemeType SCHEME, class T, class U, class U1, class U2>
1018 inline void
1019 PrimvarRefinerReal<REAL>::limit(T const & src, U & dstPos, U1 * dstTan1Ptr, U2 * dstTan2Ptr) const {
1020
1021 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
1022
1023 Vtr::internal::Level const & level = _refiner.getLevel(_refiner.GetMaxLevel());
1024
1025 int maxWeightsPerMask = 1 + 2 * level.getMaxValence();
1026 bool hasTangents = (dstTan1Ptr && dstTan2Ptr);
1027 int numMasks = 1 + (hasTangents ? 2 : 0);
1028
1029 Vtr::internal::StackBuffer<Index,33> indexBuffer(maxWeightsPerMask);
1030 Vtr::internal::StackBuffer<Weight,99> weightBuffer(numMasks * maxWeightsPerMask);
1031
1032 Weight * vPosWeights = weightBuffer,
1033 * ePosWeights = vPosWeights + 1,
1034 * fPosWeights = ePosWeights + level.getMaxValence();
1035 Weight * vTan1Weights = vPosWeights + maxWeightsPerMask,
1036 * eTan1Weights = ePosWeights + maxWeightsPerMask,
1037 * fTan1Weights = fPosWeights + maxWeightsPerMask;
1038 Weight * vTan2Weights = vTan1Weights + maxWeightsPerMask,
1039 * eTan2Weights = eTan1Weights + maxWeightsPerMask,
1040 * fTan2Weights = fTan1Weights + maxWeightsPerMask;
1041
1042 Mask posMask( vPosWeights, ePosWeights, fPosWeights);
1043 Mask tan1Mask(vTan1Weights, eTan1Weights, fTan1Weights);
1044 Mask tan2Mask(vTan2Weights, eTan2Weights, fTan2Weights);
1045
1046 // This is a bit obscure -- assigning both parent and child as last level -- but
1047 // this mask type was intended for another purpose. Consider one for the limit:
1048 Vtr::internal::VertexInterface vHood(level, level);
1049
1050 for (int vert = 0; vert < level.getNumVertices(); ++vert) {
1051 ConstIndexArray vEdges = level.getVertexEdges(vert);
1052
1053 // Incomplete vertices (present in sparse refinement) do not have their full
1054 // topological neighborhood to determine a proper limit -- just leave the
1055 // vertex at the refined location and continue to the next:
1056 if (level.getVertexTag(vert)._incomplete || (vEdges.size() == 0)) {
1057 dstPos[vert].Clear();
1058 dstPos[vert].AddWithWeight(src[vert], 1.0);
1059 if (hasTangents) {
1060 (*dstTan1Ptr)[vert].Clear();
1061 (*dstTan2Ptr)[vert].Clear();
1062 }
1063 continue;
1064 }
1065
1066 //
1067 // Limit masks require the subdivision Rule for the vertex in order to deal
1068 // with infinitely sharp features correctly -- including boundaries and corners.
1069 // The vertex neighborhood is minimally defined with vertex and edge counts.
1070 //
1071 Sdc::Crease::Rule vRule = level.getVertexRule(vert);
1072
1073 // This is a bit obscure -- child vertex index will be ignored here
1074 vHood.SetIndex(vert, vert);
1075
1076 if (hasTangents) {
1077 scheme.ComputeVertexLimitMask(vHood, posMask, tan1Mask, tan2Mask, vRule);
1078 } else {
1079 scheme.ComputeVertexLimitMask(vHood, posMask, vRule);
1080 }
1081
1082 //
1083 // Gather the neighboring vertices of this vertex -- the vertices opposite its
1084 // incident edges, and the opposite vertices of its incident faces:
1085 //
1086 Index * eIndices = indexBuffer;
1087 Index * fIndices = indexBuffer + vEdges.size();
1088
1089 for (int i = 0; i < vEdges.size(); ++i) {
1090 ConstIndexArray eVerts = level.getEdgeVertices(vEdges[i]);
1091
1092 eIndices[i] = (eVerts[0] == vert) ? eVerts[1] : eVerts[0];
1093 }
1094 if (posMask.GetNumFaceWeights() || (hasTangents && tan1Mask.GetNumFaceWeights())) {
1095 ConstIndexArray vFaces = level.getVertexFaces(vert);
1096 ConstLocalIndexArray vInFace = level.getVertexFaceLocalIndices(vert);
1097
1098 for (int i = 0; i < vFaces.size(); ++i) {
1099 ConstIndexArray fVerts = level.getFaceVertices(vFaces[i]);
1100
1101 LocalIndex vOppInFace = (vInFace[i] + 2);
1102 if (vOppInFace >= fVerts.size()) vOppInFace -= (LocalIndex)fVerts.size();
1103
1104 fIndices[i] = level.getFaceVertices(vFaces[i])[vOppInFace];
1105 }
1106 }
1107
1108 //
1109 // Combine the weights and indices for position and tangents. As with applying
1110 // refinement masks to vertex data, in order to improve numerical precision, it's
1111 // better to apply smaller weights first, so begin with the face-weights followed
1112 // by the edge-weights and the vertex weight last.
1113 //
1114 dstPos[vert].Clear();
1115 for (int i = 0; i < posMask.GetNumFaceWeights(); ++i) {
1116 dstPos[vert].AddWithWeight(src[fIndices[i]], fPosWeights[i]);
1117 }
1118 for (int i = 0; i < posMask.GetNumEdgeWeights(); ++i) {
1119 dstPos[vert].AddWithWeight(src[eIndices[i]], ePosWeights[i]);
1120 }
1121 dstPos[vert].AddWithWeight(src[vert], vPosWeights[0]);
1122
1123 //
1124 // Apply the tangent masks -- both will have the same number of weights and
1125 // indices (one tangent may be "padded" to accommodate the other), but these
1126 // may differ from those of the position:
1127 //
1128 if (hasTangents) {
1129 assert(tan1Mask.GetNumFaceWeights() == tan2Mask.GetNumFaceWeights());
1130 assert(tan1Mask.GetNumEdgeWeights() == tan2Mask.GetNumEdgeWeights());
1131
1132 U1 & dstTan1 = *dstTan1Ptr;
1133 U2 & dstTan2 = *dstTan2Ptr;
1134
1135 dstTan1[vert].Clear();
1136 dstTan2[vert].Clear();
1137 for (int i = 0; i < tan1Mask.GetNumFaceWeights(); ++i) {
1138 dstTan1[vert].AddWithWeight(src[fIndices[i]], fTan1Weights[i]);
1139 dstTan2[vert].AddWithWeight(src[fIndices[i]], fTan2Weights[i]);
1140 }
1141 for (int i = 0; i < tan1Mask.GetNumEdgeWeights(); ++i) {
1142 dstTan1[vert].AddWithWeight(src[eIndices[i]], eTan1Weights[i]);
1143 dstTan2[vert].AddWithWeight(src[eIndices[i]], eTan2Weights[i]);
1144 }
1145 dstTan1[vert].AddWithWeight(src[vert], vTan1Weights[0]);
1146 dstTan2[vert].AddWithWeight(src[vert], vTan2Weights[0]);
1147 }
1148 }
1149 }
1150
1151 template <typename REAL>
1152 template <Sdc::SchemeType SCHEME, class T, class U>
1153 inline void
1154 PrimvarRefinerReal<REAL>::limitFVar(T const & src, U & dst, int channel) const {
1155
1156 Sdc::Scheme<SCHEME> scheme(_refiner._subdivOptions);
1157
1158 Vtr::internal::Level const & level = _refiner.getLevel(_refiner.GetMaxLevel());
1159 Vtr::internal::FVarLevel const & fvarChannel = level.getFVarLevel(channel);
1160
1161 int maxWeightsPerMask = 1 + 2 * level.getMaxValence();
1162
1163 Vtr::internal::StackBuffer<Weight,33> weightBuffer(maxWeightsPerMask);
1164 Vtr::internal::StackBuffer<Index,16> vEdgeBuffer(level.getMaxValence());
1165
1166 // This is a bit obscure -- assign both parent and child as last level
1167 Vtr::internal::VertexInterface vHood(level, level);
1168
1169 for (int vert = 0; vert < level.getNumVertices(); ++vert) {
1170
1171 ConstIndexArray vEdges = level.getVertexEdges(vert);
1172 ConstIndexArray vValues = fvarChannel.getVertexValues(vert);
1173
1174 // Incomplete vertices (present in sparse refinement) do not have their full
1175 // topological neighborhood to determine a proper limit -- just leave the
1176 // values (perhaps more than one per vertex) at the refined location.
1177 //
1178 // The same can be done if the face-varying channel is purely linear.
1179 //
1180 bool isIncomplete = (level.getVertexTag(vert)._incomplete || (vEdges.size() == 0));
1181 if (isIncomplete || fvarChannel.isLinear()) {
1182 for (int i = 0; i < vValues.size(); ++i) {
1183 Vtr::Index vValue = vValues[i];
1184
1185 dst[vValue].Clear();
1186 dst[vValue].AddWithWeight(src[vValue], 1.0f);
1187 }
1188 continue;
1189 }
1190
1191 bool fvarVertMatchesVertex = fvarChannel.valueTopologyMatches(vValues[0]);
1192 if (fvarVertMatchesVertex) {
1193
1194 // Assign the mask weights to the common buffer and compute the mask:
1195 //
1196 Weight * vWeights = weightBuffer,
1197 * eWeights = vWeights + 1,
1198 * fWeights = eWeights + vEdges.size();
1199
1200 Mask vMask(vWeights, eWeights, fWeights);
1201
1202 vHood.SetIndex(vert, vert);
1203
1204 scheme.ComputeVertexLimitMask(vHood, vMask, level.getVertexRule(vert));
1205
1206 //
1207 // Apply mask to corresponding FVar values for neighboring vertices:
1208 //
1209 Vtr::Index vValue = vValues[0];
1210
1211 dst[vValue].Clear();
1212 if (vMask.GetNumFaceWeights() > 0) {
1213 assert(!vMask.AreFaceWeightsForFaceCenters());
1214
1215 ConstIndexArray vFaces = level.getVertexFaces(vert);
1216 ConstLocalIndexArray vInFace = level.getVertexFaceLocalIndices(vert);
1217
1218 for (int i = 0; i < vFaces.size(); ++i) {
1219 ConstIndexArray faceValues = fvarChannel.getFaceValues(vFaces[i]);
1220 LocalIndex vOppInFace = vInFace[i] + 2;
1221 if (vOppInFace >= faceValues.size()) vOppInFace -= faceValues.size();
1222
1223 Index vValueOppositeFace = faceValues[vOppInFace];
1224
1225 dst[vValue].AddWithWeight(src[vValueOppositeFace], fWeights[i]);
1226 }
1227 }
1228 if (vMask.GetNumEdgeWeights() > 0) {
1229 Index * vEdgeValues = vEdgeBuffer;
1230 fvarChannel.getVertexEdgeValues(vert, vEdgeValues);
1231
1232 for (int i = 0; i < vEdges.size(); ++i) {
1233 dst[vValue].AddWithWeight(src[vEdgeValues[i]], eWeights[i]);
1234 }
1235 }
1236 dst[vValue].AddWithWeight(src[vValue], vWeights[0]);
1237 } else {
1238 //
1239 // Sibling FVar values associated with a vertex will be either a corner or a crease:
1240 //
1241 for (int i = 0; i < vValues.size(); ++i) {
1242 Vtr::Index vValue = vValues[i];
1243
1244 dst[vValue].Clear();
1245 if (fvarChannel.getValueTag(vValue).isCorner()) {
1246 dst[vValue].AddWithWeight(src[vValue], 1.0f);
1247 } else {
1248 Index vEndValues[2];
1249 fvarChannel.getVertexCreaseEndValues(vert, i, vEndValues);
1250
1251 dst[vValue].AddWithWeight(src[vEndValues[0]], 1.0f/6.0f);
1252 dst[vValue].AddWithWeight(src[vEndValues[1]], 1.0f/6.0f);
1253 dst[vValue].AddWithWeight(src[vValue], 2.0f/3.0f);
1254 }
1255 }
1256 }
1257 }
1258 }
1259
1260 class PrimvarRefiner : public PrimvarRefinerReal<float> {
1261 public:
1262 PrimvarRefiner(TopologyRefiner const & refiner)
1263 : PrimvarRefinerReal<float>(refiner) { }
1264 };
1265
1266 } // end namespace Far
1267
1268 } // end namespace OPENSUBDIV_VERSION
1269 using namespace OPENSUBDIV_VERSION;
1270 } // end namespace OpenSubdiv
1271
1272 #endif /* OPENSUBDIV3_FAR_PRIMVAR_REFINER_H */
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::Limit
void Limit(T const &src, U &dstPos) const
Apply limit weights to a primvar buffer.
Definition: primvarRefiner.h:319
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::getFaceVertices
ConstIndexArray getFaceVertices(Index faceIndex) const
Definition: level.h:548
OpenSubdiv
Definition: error.h:30
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::IndexIsValid
bool IndexIsValid(Index index)
Definition: types.h:58
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::InterpolateFaceUniform
void InterpolateFaceUniform(int level, T const &src, U &dst) const
Refine uniform (per-face) primvar data between levels.
Definition: primvarRefiner.h:394
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::FaceInterface
Definition: componentInterfaces.h:56
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Crease::RULE_SMOOTH
Definition: crease.h:84
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::GetTopologyRefiner
const TopologyRefiner & GetTopologyRefiner() const
Definition: primvarRefiner.h:62
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Refinement::getFaceChildVertex
Index getFaceChildVertex(Index f) const
Definition: refinement.h:144
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal
Applies refinement operations to generic primvar data.
Definition: primvarRefiner.h:56
OpenSubdiv::OPENSUBDIV_VERSION::Far::FAR_RUNTIME_ERROR
Issue a generic runtime error, but continue execution.
Definition: error.h:40
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefiner
Stores topology data for a specified set of refinement options.
Definition: topologyRefiner.h:51
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::getNumEdges
int getNumEdges() const
Definition: level.h:204
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::StackBuffer
Definition: stackBuffer.h:50
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Refinement::parent
Level const & parent() const
Definition: refinement.h:75
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefiner
Definition: primvarRefiner.h:1260
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::ConstArray< Index >
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme
Scheme is a class template which provides all implementation for the subdivision schemes supported by...
Definition: scheme.h:66
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::getNumFaces
int getNumFaces() const
Definition: level.h:203
OpenSubdiv::OPENSUBDIV_VERSION::Far::ConstLocalIndexArray
Vtr::ConstLocalIndexArray ConstLocalIndexArray
Definition: types.h:48
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::ConstArray::size
size_type size() const
Definition: array.h:72
OpenSubdiv::OPENSUBDIV_VERSION::Far::Error
void Error(ErrorType err, const char *format,...)
Sends an OSD error with a message (internal use only)
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::InterpolateVarying
void InterpolateVarying(int level, T const &src, U &dst) const
Apply only varying interpolation weights to a primvar buffer for a single level of refinement.
Definition: primvarRefiner.h:412
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::InterpolateFaceVarying
void InterpolateFaceVarying(int level, T const &src, U &dst, int channel=0) const
Apply face-varying interpolation weights to a primvar buffer associated with a particular face-varyin...
Definition: primvarRefiner.h:293
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::getEdgeVertices
ConstIndexArray getEdgeVertices(Index edgeIndex) const
Definition: level.h:673
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Refinement
Definition: refinement.h:69
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::PrimvarRefinerReal
PrimvarRefinerReal(TopologyRefiner const &refiner)
Definition: primvarRefiner.h:59
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefiner::PrimvarRefiner
PrimvarRefiner(TopologyRefiner const &refiner)
Definition: primvarRefiner.h:1262
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::FVarLevel::ConstValueTagArray
Vtr::ConstArray< ValueTag > ConstValueTagArray
Definition: fvarLevel.h:140
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::LimitFaceVarying
void LimitFaceVarying(T const &src, U &dst, int channel=0) const
Definition: primvarRefiner.h:369
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::SCHEME_LOOP
Definition: types.h:40
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Crease::Rule
Rule
Definition: crease.h:82
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::~PrimvarRefinerReal
~PrimvarRefinerReal()
Definition: primvarRefiner.h:60
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::getMaxValence
int getMaxValence() const
Definition: level.h:214
OpenSubdiv::OPENSUBDIV_VERSION::Far::LocalIndex
Vtr::LocalIndex LocalIndex
Definition: types.h:42
OpenSubdiv::OPENSUBDIV_VERSION::Far::Index
Vtr::Index Index
Definition: types.h:41
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::Index
int Index
Definition: types.h:54
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::SCHEME_BILINEAR
Definition: types.h:38
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::SCHEME_CATMARK
Definition: types.h:39
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Refinement::getNumChildVerticesFromFaces
int getNumChildVerticesFromFaces() const
Definition: refinement.h:133
OpenSubdiv::OPENSUBDIV_VERSION::Far::ConstIndexArray
Vtr::ConstIndexArray ConstIndexArray
Definition: types.h:47
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::getNumVertices
int getNumVertices() const
Definition: level.h:202
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Crease::RULE_CREASE
Definition: crease.h:86
OpenSubdiv::OPENSUBDIV_VERSION::Far::PrimvarRefinerReal::Interpolate
void Interpolate(int level, T const &src, U &dst) const
Apply vertex interpolation weights to a primvar buffer for a single level of refinement.
Definition: primvarRefiner.h:267
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level
Definition: level.h:83