opensubdiv/osd/clEvaluator.h Source File

- Main Page
- Namespaces
- Classes
- Files

- File List

clEvaluator.h
Go to the documentation of this file.
1 //
2 // Copyright 2015 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 OPENSUBDIV_OPENSUBDIV3_OSD_CL_EVALUATOR_H
26 #define OPENSUBDIV_OPENSUBDIV3_OSD_CL_EVALUATOR_H
27
28 #include "../version.h"
29
30 #include "../osd/opencl.h"
31 #include "../osd/types.h"
32 #include "../osd/bufferDescriptor.h"
33
34 namespace OpenSubdiv {
35 namespace OPENSUBDIV_VERSION {
36
37 namespace Far {
38 class StencilTable;
39 }
40
41 namespace Osd {
42
50 class CLStencilTable {
51 public:
52 template <typename DEVICE_CONTEXT>
53 static CLStencilTable *Create(Far::StencilTable const *stencilTable,
54 DEVICE_CONTEXT context) {
55 return new CLStencilTable(stencilTable, context->GetContext());
56 }
57
58 template <typename DEVICE_CONTEXT>
59 static CLStencilTable *Create(
60 Far::LimitStencilTable const *limitStencilTable,
61 DEVICE_CONTEXT context) {
62 return new CLStencilTable(limitStencilTable, context->GetContext());
63 }
64
65 CLStencilTable(Far::StencilTable const *stencilTable,
66 cl_context clContext);
67 CLStencilTable(Far::LimitStencilTable const *limitStencilTable,
68 cl_context clContext);
69 ~CLStencilTable();
70
71 // interfaces needed for CLComputeKernel
72 cl_mem GetSizesBuffer() const { return _sizes; }
73 cl_mem GetOffsetsBuffer() const { return _offsets; }
74 cl_mem GetIndicesBuffer() const { return _indices; }
75 cl_mem GetWeightsBuffer() const { return _weights; }
76 cl_mem GetDuWeightsBuffer() const { return _duWeights; }
77 cl_mem GetDvWeightsBuffer() const { return _dvWeights; }
78 int GetNumStencils() const { return _numStencils; }
79
80 private:
81 cl_mem _sizes;
82 cl_mem _offsets;
83 cl_mem _indices;
84 cl_mem _weights;
85 cl_mem _duWeights;
86 cl_mem _dvWeights;
87 int _numStencils;
88 };
89
90 // ---------------------------------------------------------------------------
91
92 class CLEvaluator {
93 public:
94 typedef bool Instantiatable;
96 CLEvaluator(cl_context context, cl_command_queue queue);
97
99 ~CLEvaluator();
100
102 template <typename DEVICE_CONTEXT>
103 static CLEvaluator *Create(BufferDescriptor const &srcDesc,
104 BufferDescriptor const &dstDesc,
105 BufferDescriptor const &duDesc,
106 BufferDescriptor const &dvDesc,
107 DEVICE_CONTEXT deviceContext) {
108 return Create(srcDesc, dstDesc, duDesc, dvDesc,
109 deviceContext->GetContext(),
110 deviceContext->GetCommandQueue());
111 }
112
113 static CLEvaluator * Create(BufferDescriptor const &srcDesc,
114 BufferDescriptor const &dstDesc,
115 BufferDescriptor const &duDesc,
116 BufferDescriptor const &dvDesc,
117 cl_context clContext,
118 cl_command_queue clCommandQueue) {
119 CLEvaluator *kernel = new CLEvaluator(clContext, clCommandQueue);
120 if (kernel->Compile(srcDesc, dstDesc, duDesc, dvDesc)) return kernel;
121 delete kernel;
122 return NULL;
123 }
124
130
174 template <typename SRC_BUFFER, typename DST_BUFFER,
175 typename STENCIL_TABLE, typename DEVICE_CONTEXT>
176 static bool EvalStencils(
177 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
178 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
179 STENCIL_TABLE const *stencilTable,
180 CLEvaluator const *instance,
181 DEVICE_CONTEXT deviceContext,
182 unsigned int numStartEvents=0,
183 const cl_event* startEvents=NULL,
184 cl_event* endEvent=NULL) {
185
186 if (instance) {
187 return instance->EvalStencils(srcBuffer, srcDesc,
188 dstBuffer, dstDesc,
189 stencilTable,
190 numStartEvents, startEvents, endEvent);
191 } else {
192 // Create an instance on demand (slow)
193 instance = Create(srcDesc, dstDesc,
194 BufferDescriptor(),
195 BufferDescriptor(),
196 deviceContext);
197 if (instance) {
198 bool r = instance->EvalStencils(srcBuffer, srcDesc,
199 dstBuffer, dstDesc,
200 stencilTable,
201 numStartEvents, startEvents, endEvent);
202 delete instance;
203 return r;
204 }
205 return false;
206 }
207 }
208
264 template <typename SRC_BUFFER, typename DST_BUFFER,
265 typename STENCIL_TABLE, typename DEVICE_CONTEXT>
266 static bool EvalStencils(
267 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
268 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
269 DST_BUFFER *duBuffer, BufferDescriptor const &duDesc,
270 DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc,
271 STENCIL_TABLE const *stencilTable,
272 CLEvaluator const *instance,
273 DEVICE_CONTEXT deviceContext,
274 unsigned int numStartEvents=0,
275 const cl_event* startEvents=NULL,
276 cl_event* endEvent=NULL) {
277
278 if (instance) {
279 return instance->EvalStencils(srcBuffer, srcDesc,
280 dstBuffer, dstDesc,
281 duBuffer, duDesc,
282 dvBuffer, dvDesc,
283 stencilTable,
284 numStartEvents, startEvents, endEvent);
285 } else {
286 // Create an instance on demand (slow)
287 instance = Create(srcDesc, dstDesc, duDesc, dvDesc,
288 deviceContext);
289 if (instance) {
290 bool r = instance->EvalStencils(srcBuffer, srcDesc,
291 dstBuffer, dstDesc,
292 duBuffer, duDesc,
293 dvBuffer, dvDesc,
294 stencilTable,
295 numStartEvents, startEvents, endEvent);
296 delete instance;
297 return r;
298 }
299 return false;
300 }
301 }
302
306 template <typename SRC_BUFFER, typename DST_BUFFER, typename STENCIL_TABLE>
307 bool EvalStencils(
308 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
309 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
310 STENCIL_TABLE const *stencilTable,
311 unsigned int numStartEvents=0,
312 const cl_event* startEvents=NULL,
313 cl_event* endEvent=NULL) const {
314 return EvalStencils(srcBuffer->BindCLBuffer(_clCommandQueue), srcDesc,
315 dstBuffer->BindCLBuffer(_clCommandQueue), dstDesc,
316 stencilTable->GetSizesBuffer(),
317 stencilTable->GetOffsetsBuffer(),
318 stencilTable->GetIndicesBuffer(),
319 stencilTable->GetWeightsBuffer(),
320 0,
321 stencilTable->GetNumStencils(),
322 numStartEvents, startEvents, endEvent);
323 }
324
328 template <typename SRC_BUFFER, typename DST_BUFFER, typename STENCIL_TABLE>
329 bool EvalStencils(
330 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
331 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
332 DST_BUFFER *duBuffer, BufferDescriptor const &duDesc,
333 DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc,
334 STENCIL_TABLE const *stencilTable,
335 unsigned int numStartEvents=0,
336 const cl_event* startEvents=NULL,
337 cl_event* endEvent=NULL) const {
338 return EvalStencils(srcBuffer->BindCLBuffer(_clCommandQueue), srcDesc,
339 dstBuffer->BindCLBuffer(_clCommandQueue), dstDesc,
340 duBuffer->BindCLBuffer(_clCommandQueue), duDesc,
341 dvBuffer->BindCLBuffer(_clCommandQueue), dvDesc,
342 stencilTable->GetSizesBuffer(),
343 stencilTable->GetOffsetsBuffer(),
344 stencilTable->GetIndicesBuffer(),
345 stencilTable->GetWeightsBuffer(),
346 stencilTable->GetDuWeightsBuffer(),
347 stencilTable->GetDvWeightsBuffer(),
348 0,
349 stencilTable->GetNumStencils(),
350 numStartEvents, startEvents, endEvent);
351 }
352
355 bool EvalStencils(cl_mem src, BufferDescriptor const &srcDesc,
356 cl_mem dst, BufferDescriptor const &dstDesc,
357 cl_mem sizes,
358 cl_mem offsets,
359 cl_mem indices,
360 cl_mem weights,
361 int start,
362 int end,
363 unsigned int numStartEvents=0,
364 const cl_event* startEvents=NULL,
365 cl_event* endEvent=NULL) const;
366
369 bool EvalStencils(cl_mem src, BufferDescriptor const &srcDesc,
370 cl_mem dst, BufferDescriptor const &dstDesc,
371 cl_mem du, BufferDescriptor const &duDesc,
372 cl_mem dv, BufferDescriptor const &dvDesc,
373 cl_mem sizes,
374 cl_mem offsets,
375 cl_mem indices,
376 cl_mem weights,
377 cl_mem duWeights,
378 cl_mem dvWeights,
379 int start,
380 int end,
381 unsigned int numStartEvents=0,
382 const cl_event* startEvents=NULL,
383 cl_event* endEvent=NULL) const;
384
439 template <typename SRC_BUFFER, typename DST_BUFFER,
440 typename PATCHCOORD_BUFFER, typename PATCH_TABLE,
441 typename DEVICE_CONTEXT>
442 static bool EvalPatches(
443 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
444 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
445 int numPatchCoords,
446 PATCHCOORD_BUFFER *patchCoords,
447 PATCH_TABLE *patchTable,
448 CLEvaluator const *instance,
449 DEVICE_CONTEXT deviceContext,
450 unsigned int numStartEvents=0,
451 const cl_event* startEvents=NULL,
452 cl_event* endEvent=NULL) {
453
454 if (instance) {
455 return instance->EvalPatches(srcBuffer, srcDesc,
456 dstBuffer, dstDesc,
457 numPatchCoords, patchCoords,
458 patchTable,
459 numStartEvents, startEvents, endEvent);
460 } else {
461 // Create an instance on demand (slow)
462 (void)deviceContext; // unused
463 instance = Create(srcDesc, dstDesc,
464 BufferDescriptor(),
465 BufferDescriptor(),
466 deviceContext);
467 if (instance) {
468 bool r = instance->EvalPatches(srcBuffer, srcDesc,
469 dstBuffer, dstDesc,
470 numPatchCoords, patchCoords,
471 patchTable,
472 numStartEvents, startEvents, endEvent);
473 delete instance;
474 return r;
475 }
476 return false;
477 }
478 }
479
536 template <typename SRC_BUFFER, typename DST_BUFFER,
537 typename PATCHCOORD_BUFFER, typename PATCH_TABLE,
538 typename DEVICE_CONTEXT>
539 static bool EvalPatches(
540 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
541 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
542 DST_BUFFER *duBuffer, BufferDescriptor const &duDesc,
543 DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc,
544 int numPatchCoords,
545 PATCHCOORD_BUFFER *patchCoords,
546 PATCH_TABLE *patchTable,
547 CLEvaluator const *instance,
548 DEVICE_CONTEXT deviceContext,
549 unsigned int numStartEvents=0,
550 const cl_event* startEvents=NULL,
551 cl_event* endEvent=NULL) {
552
553 if (instance) {
554 return instance->EvalPatches(srcBuffer, srcDesc,
555 dstBuffer, dstDesc,
556 duBuffer, duDesc,
557 dvBuffer, dvDesc,
558 numPatchCoords, patchCoords,
559 patchTable,
560 numStartEvents, startEvents, endEvent);
561 } else {
562 // Create an instance on demand (slow)
563 (void)deviceContext; // unused
564 instance = Create(srcDesc, dstDesc, duDesc, dvDesc, deviceContext);
565 if (instance) {
566 bool r = instance->EvalPatches(srcBuffer, srcDesc,
567 dstBuffer, dstDesc,
568 duBuffer, duDesc,
569 dvBuffer, dvDesc,
570 numPatchCoords, patchCoords,
571 patchTable,
572 numStartEvents, startEvents, endEvent);
573 delete instance;
574 return r;
575 }
576 return false;
577 }
578 }
579
617 template <typename SRC_BUFFER, typename DST_BUFFER,
618 typename PATCHCOORD_BUFFER, typename PATCH_TABLE>
619 bool EvalPatches(
620 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
621 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
622 int numPatchCoords,
623 PATCHCOORD_BUFFER *patchCoords,
624 PATCH_TABLE *patchTable,
625 unsigned int numStartEvents=0,
626 const cl_event* startEvents=NULL,
627 cl_event* endEvent=NULL) const {
628
629 return EvalPatches(srcBuffer->BindCLBuffer(_clCommandQueue), srcDesc,
630 dstBuffer->BindCLBuffer(_clCommandQueue), dstDesc,
631 0, BufferDescriptor(),
632 0, BufferDescriptor(),
633 numPatchCoords,
634 patchCoords->BindCLBuffer(_clCommandQueue),
635 patchTable->GetPatchArrayBuffer(),
636 patchTable->GetPatchIndexBuffer(),
637 patchTable->GetPatchParamBuffer(),
638 numStartEvents, startEvents, endEvent);
639 }
640
688 template <typename SRC_BUFFER, typename DST_BUFFER,
689 typename PATCHCOORD_BUFFER, typename PATCH_TABLE>
690 bool EvalPatches(
691 SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc,
692 DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc,
693 DST_BUFFER *duBuffer, BufferDescriptor const &duDesc,
694 DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc,
695 int numPatchCoords,
696 PATCHCOORD_BUFFER *patchCoords,
697 PATCH_TABLE *patchTable,
698 unsigned int numStartEvents=0,
699 const cl_event* startEvents=NULL,
700 cl_event* endEvent=NULL) const {
701
702 return EvalPatches(srcBuffer->BindCLBuffer(_clCommandQueue), srcDesc,
703 dstBuffer->BindCLBuffer(_clCommandQueue), dstDesc,
704 duBuffer->BindCLBuffer(_clCommandQueue), duDesc,
705 dvBuffer->BindCLBuffer(_clCommandQueue), dvDesc,
706 numPatchCoords,
707 patchCoords->BindCLBuffer(_clCommandQueue),
708 patchTable->GetPatchArrayBuffer(),
709 patchTable->GetPatchIndexBuffer(),
710 patchTable->GetPatchParamBuffer(),
711 numStartEvents, startEvents, endEvent);
712 }
713
714 bool EvalPatches(cl_mem src, BufferDescriptor const &srcDesc,
715 cl_mem dst, BufferDescriptor const &dstDesc,
716 cl_mem du, BufferDescriptor const &duDesc,
717 cl_mem dv, BufferDescriptor const &dvDesc,
718 int numPatchCoords,
719 cl_mem patchCoordsBuffer,
720 cl_mem patchArrayBuffer,
721 cl_mem patchIndexBuffer,
722 cl_mem patchParamsBuffer,
723 unsigned int numStartEvents=0,
724 const cl_event* startEvents=NULL,
725 cl_event* endEvent=NULL) const;
726
732
735 bool Compile(BufferDescriptor const &srcDesc,
736 BufferDescriptor const &dstDesc,
737 BufferDescriptor const &duDesc,
738 BufferDescriptor const &dvDesc);
739
741 template <typename DEVICE_CONTEXT>
742 static void Synchronize(DEVICE_CONTEXT deviceContext) {
743 Synchronize(deviceContext->GetCommandQueue());
744 }
745
746 static void Synchronize(cl_command_queue queue);
747
748 private:
749 cl_context _clContext;
750 cl_command_queue _clCommandQueue;
751 cl_program _program;
752 cl_kernel _stencilKernel;
753 cl_kernel _stencilDerivKernel;
754 cl_kernel _patchKernel;
755 };
756
757
758 } // end namespace Osd
759
760 } // end namespace OPENSUBDIV_VERSION
761 using namespace OPENSUBDIV_VERSION;
762
763 } // end namespace OpenSubdiv
764
765
766 #endif // OPENSUBDIV_OPENSUBDIV3_OSD_CL_EVALUATOR_H
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::Create
static CLStencilTable * Create(Far::LimitStencilTable const *limitStencilTable, DEVICE_CONTEXT context)
Definition: clEvaluator.h:59
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalPatches
static bool EvalPatches(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, int numPatchCoords, PATCHCOORD_BUFFER *patchCoords, PATCH_TABLE *patchTable, CLEvaluator const *instance, DEVICE_CONTEXT deviceContext, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL)
Generic limit eval function. This function has a same signature as other device kernels have so that ...
Definition: clEvaluator.h:442
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalStencils
static bool EvalStencils(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, STENCIL_TABLE const *stencilTable, CLEvaluator const *instance, DEVICE_CONTEXT deviceContext, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL)
Generic static compute function. This function has a same signature as other device kernels have so t...
Definition: clEvaluator.h:176
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::Create
static CLEvaluator * Create(BufferDescriptor const &srcDesc, BufferDescriptor const &dstDesc, BufferDescriptor const &duDesc, BufferDescriptor const &dvDesc, DEVICE_CONTEXT deviceContext)
Generic creator template.
Definition: clEvaluator.h:103
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetSizesBuffer
cl_mem GetSizesBuffer() const
Definition: clEvaluator.h:72
OpenSubdiv::OPENSUBDIV_VERSION::Osd::BufferDescriptor
BufferDescriptor is a struct which describes buffer elements in interleaved data buffers. Almost all Osd Evaluator APIs take BufferDescriptors along with device-specific buffer objects.
Definition: bufferDescriptor.h:61
OpenSubdiv
Definition: error.h:30
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalPatches
static bool EvalPatches(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, DST_BUFFER *duBuffer, BufferDescriptor const &duDesc, DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc, int numPatchCoords, PATCHCOORD_BUFFER *patchCoords, PATCH_TABLE *patchTable, CLEvaluator const *instance, DEVICE_CONTEXT deviceContext, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL)
Generic limit eval function. This function has a same signature as other device kernels have so that ...
Definition: clEvaluator.h:539
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetDuWeightsBuffer
cl_mem GetDuWeightsBuffer() const
Definition: clEvaluator.h:76
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::Instantiatable
bool Instantiatable
Definition: clEvaluator.h:94
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator
Definition: clEvaluator.h:92
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::Create
static CLStencilTable * Create(Far::StencilTable const *stencilTable, DEVICE_CONTEXT context)
Definition: clEvaluator.h:53
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::Synchronize
static void Synchronize(DEVICE_CONTEXT deviceContext)
Wait the OpenCL kernels finish.
Definition: clEvaluator.h:742
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetWeightsBuffer
cl_mem GetWeightsBuffer() const
Definition: clEvaluator.h:75
OpenSubdiv::OPENSUBDIV_VERSION::Far::StencilTable
Table of subdivision stencils.
Definition: stencilTable.h:125
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalStencils
static bool EvalStencils(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, DST_BUFFER *duBuffer, BufferDescriptor const &duDesc, DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc, STENCIL_TABLE const *stencilTable, CLEvaluator const *instance, DEVICE_CONTEXT deviceContext, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL)
Generic static compute function. This function has a same signature as other device kernels have so t...
Definition: clEvaluator.h:266
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::Create
static CLEvaluator * Create(BufferDescriptor const &srcDesc, BufferDescriptor const &dstDesc, BufferDescriptor const &duDesc, BufferDescriptor const &dvDesc, cl_context clContext, cl_command_queue clCommandQueue)
Definition: clEvaluator.h:113
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalStencils
bool EvalStencils(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, STENCIL_TABLE const *stencilTable, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL) const
Definition: clEvaluator.h:307
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable
OpenCL stencil table.
Definition: clEvaluator.h:50
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalPatches
bool EvalPatches(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, int numPatchCoords, PATCHCOORD_BUFFER *patchCoords, PATCH_TABLE *patchTable, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL) const
Generic limit eval function. This function has a same signature as other device kernels have so that ...
Definition: clEvaluator.h:619
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetNumStencils
int GetNumStencils() const
Definition: clEvaluator.h:78
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalPatches
bool EvalPatches(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, DST_BUFFER *duBuffer, BufferDescriptor const &duDesc, DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc, int numPatchCoords, PATCHCOORD_BUFFER *patchCoords, PATCH_TABLE *patchTable, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL) const
Generic limit eval function with derivatives. This function has a same signature as other device kern...
Definition: clEvaluator.h:690
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetDvWeightsBuffer
cl_mem GetDvWeightsBuffer() const
Definition: clEvaluator.h:77
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::Compile
bool Compile(BufferDescriptor const &srcDesc, BufferDescriptor const &dstDesc, BufferDescriptor const &duDesc, BufferDescriptor const &dvDesc)
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetOffsetsBuffer
cl_mem GetOffsetsBuffer() const
Definition: clEvaluator.h:73
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLEvaluator::EvalStencils
bool EvalStencils(SRC_BUFFER *srcBuffer, BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, BufferDescriptor const &dstDesc, DST_BUFFER *duBuffer, BufferDescriptor const &duDesc, DST_BUFFER *dvBuffer, BufferDescriptor const &dvDesc, STENCIL_TABLE const *stencilTable, unsigned int numStartEvents=0, const cl_event *startEvents=NULL, cl_event *endEvent=NULL) const
Definition: clEvaluator.h:329
OpenSubdiv::OPENSUBDIV_VERSION::Far::LimitStencilTable
Table of limit subdivision stencils.
Definition: stencilTable.h:300
OpenSubdiv::OPENSUBDIV_VERSION::Osd::CLStencilTable::GetIndicesBuffer
cl_mem GetIndicesBuffer() const
Definition: clEvaluator.h:74