?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / Contrib / ComputeBase / ComputeShader / OSGComputeShaderAlgorithmBase.cpp
blob22f66c141781c1ce08be72a4ce967501811be64d
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2013 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 /*****************************************************************************\
40 *****************************************************************************
41 ** **
42 ** This file is automatically generated. **
43 ** **
44 ** Any changes made to this file WILL be lost when it is **
45 ** regenerated, which can become necessary at any time. **
46 ** **
47 ** Do not change this file, changes should be done in the derived **
48 ** class ComputeShaderAlgorithm!
49 ** **
50 *****************************************************************************
51 \*****************************************************************************/
52
53 #include <cstdlib>
54 #include <cstdio>
55
56 #ifdef WIN32
57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
58 #pragma warning(disable: 4290) // disable exception specification warning
59 #endif
60
61 #include "OSGConfig.h"
62
63
64
65 #include "OSGTextureImageChunk.h" // TextureImages Class
66 #include "OSGChunkMaterial.h" // ChunkMaterial Class
67 #include "OSGComputeShaderChunk.h" // ComputeShader Class
68
69 #include "OSGComputeShaderAlgorithmBase.h"
70 #include "OSGComputeShaderAlgorithm.h"
71
72 #include <boost/bind.hpp>
73
74 OSG_BEGIN_NAMESPACE
75
76 /***************************************************************************\
77 * Description *
78 \***************************************************************************/
79
80 /*! \class OSG::ComputeShaderAlgorithm
81 This class allows the operation of a compute shader algorithm. It allows the specification of
82 shader buffers and textures to be used in the computation task and the details of the computational
83 space the compute shader operats on.
84 */
85
86 /***************************************************************************\
87 * Field Documentation *
88 \***************************************************************************/
89
90 /*! \var TextureImageChunk * ComputeShaderAlgorithmBase::_mfTextureImages
91 Texture images to be used for reading/writing in the compute shader.
92 The texture images uses the binding points starting from 0 and then
93 incrementing by 1.
94 */
95
96 /*! \var ChunkMaterial * ComputeShaderAlgorithmBase::_sfChunkMaterial
97 This chunk material allows the usage of texture images, uniform buffer objects
98 and shader storage buffer objects in the compute shader. Only these material
99 chunks are going to be respected, all other will simply omitted. A valid
100 chunk in the chunk material specifies the binding point to be used in the compute
101 shader.
102 */
103
104 /*! \var ComputeShaderChunk * ComputeShaderAlgorithmBase::_sfComputeShader
105 The compute shader abstracts the actual shader code and the variable specifications
106 used in the shader.
107 */
108
109 /*! \var Vec3i ComputeShaderAlgorithmBase::_sfDispatchConfig
110 The number of work groups, i.e. the work group count.
111 */
112
113 /*! \var Vec3i ComputeShaderAlgorithmBase::_sfWorkGroupSize
114 The size of the work groups, i.e. the local_size_var value of the layout specifier.
115 This does need the ARB_compute_variable_group_size GL extension to work.
116 */
117
118 /*! \var bool ComputeShaderAlgorithmBase::_sfUseMemoryBarrier
119 This flag toggles the usage of the memory barrier call after the operation of
120 the compute shader.
121 */
122
123 /*! \var bool ComputeShaderAlgorithmBase::_sfUseVariableWorkGroupSize
124 This flag enables the useage of the variable work group size dispatch API that
125 is specified in the ARB_compute_variable_group_size extension.
126 */
127
128 /*! \var GLenum ComputeShaderAlgorithmBase::_sfMemoryBarrier
129 This bitmask determines the behavior of the memory barrier that is issued after the
130 operation of the compute shader.
131 */
132
133
134 /***************************************************************************\
135 * FieldType/FieldTrait Instantiation *
136 \***************************************************************************/
137
138 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
139 PointerType FieldTraits<ComputeShaderAlgorithm *, nsOSG>::_type(
140 "ComputeShaderAlgorithmPtr",
141 "ComputeAlgorithmPtr",
142 ComputeShaderAlgorithm::getClassType(),
143 nsOSG);
144 #endif
145
146 OSG_FIELDTRAITS_GETTYPE_NS(ComputeShaderAlgorithm *, nsOSG)
147
148 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
149 ComputeShaderAlgorithm *,
150 nsOSG)
151
152 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
153 ComputeShaderAlgorithm *,
154 nsOSG)
155
156 /***************************************************************************\
157 * Field Description *
158 \***************************************************************************/
159
160 void ComputeShaderAlgorithmBase::classDescInserter(TypeObject &oType)
161 {
162 FieldDescriptionBase *pDesc = NULL;
163
164
165 pDesc = new MFUnrecTextureImageChunkPtr::Description(
166 MFUnrecTextureImageChunkPtr::getClassType(),
167 "textureImages",
168 "Texture images to be used for reading/writing in the compute shader.\n"
169 "The texture images uses the binding points starting from 0 and then \n"
170 "incrementing by 1.\n",
171 TextureImagesFieldId, TextureImagesFieldMask,
172 false,
173 (Field::MFDefaultFlags | Field::FStdAccess),
174 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleTextureImages),
175 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleTextureImages));
176
177 oType.addInitialDesc(pDesc);
178
179 pDesc = new SFUnrecChunkMaterialPtr::Description(
180 SFUnrecChunkMaterialPtr::getClassType(),
181 "chunkMaterial",
182 "This chunk material allows the usage of texture images, uniform buffer objects\n"
183 "and shader storage buffer objects in the compute shader. Only these material\n"
184 "chunks are going to be respected, all other will simply omitted. A valid\n"
185 "chunk in the chunk material specifies the binding point to be used in the compute\n"
186 "shader.\n",
187 ChunkMaterialFieldId, ChunkMaterialFieldMask,
188 false,
189 (Field::SFDefaultFlags | Field::FStdAccess),
190 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleChunkMaterial),
191 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleChunkMaterial));
192
193 oType.addInitialDesc(pDesc);
194
195 pDesc = new SFUnrecComputeShaderChunkPtr::Description(
196 SFUnrecComputeShaderChunkPtr::getClassType(),
197 "computeShader",
198 "The compute shader abstracts the actual shader code and the variable specifications\n"
199 "used in the shader.\n",
200 ComputeShaderFieldId, ComputeShaderFieldMask,
201 false,
202 (Field::SFDefaultFlags | Field::FStdAccess),
203 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleComputeShader),
204 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleComputeShader));
205
206 oType.addInitialDesc(pDesc);
207
208 pDesc = new SFVec3i::Description(
209 SFVec3i::getClassType(),
210 "dispatchConfig",
211 "The number of work groups, i.e. the work group count.\n",
212 DispatchConfigFieldId, DispatchConfigFieldMask,
213 false,
214 (Field::SFDefaultFlags | Field::FStdAccess),
215 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleDispatchConfig),
216 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleDispatchConfig));
217
218 oType.addInitialDesc(pDesc);
219
220 pDesc = new SFVec3i::Description(
221 SFVec3i::getClassType(),
222 "workGroupSize",
223 "The size of the work groups, i.e. the local_size_var value of the layout specifier.\n"
224 "This does need the ARB_compute_variable_group_size GL extension to work.\n",
225 WorkGroupSizeFieldId, WorkGroupSizeFieldMask,
226 false,
227 (Field::SFDefaultFlags | Field::FStdAccess),
228 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleWorkGroupSize),
229 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleWorkGroupSize));
230
231 oType.addInitialDesc(pDesc);
232
233 pDesc = new SFBool::Description(
234 SFBool::getClassType(),
235 "useMemoryBarrier",
236 "This flag toggles the usage of the memory barrier call after the operation of\n"
237 "the compute shader.\n",
238 UseMemoryBarrierFieldId, UseMemoryBarrierFieldMask,
239 false,
240 (Field::SFDefaultFlags | Field::FStdAccess),
241 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleUseMemoryBarrier),
242 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleUseMemoryBarrier));
243
244 oType.addInitialDesc(pDesc);
245
246 pDesc = new SFBool::Description(
247 SFBool::getClassType(),
248 "useVariableWorkGroupSize",
249 "This flag enables the useage of the variable work group size dispatch API that\n"
250 "is specified in the ARB_compute_variable_group_size extension.\n",
251 UseVariableWorkGroupSizeFieldId, UseVariableWorkGroupSizeFieldMask,
252 false,
253 (Field::SFDefaultFlags | Field::FStdAccess),
254 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleUseVariableWorkGroupSize),
255 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleUseVariableWorkGroupSize));
256
257 oType.addInitialDesc(pDesc);
258
259 pDesc = new SFGLenum::Description(
260 SFGLenum::getClassType(),
261 "memoryBarrier",
262 "This bitmask determines the behavior of the memory barrier that is issued after the\n"
263 "operation of the compute shader.\n",
264 MemoryBarrierFieldId, MemoryBarrierFieldMask,
265 false,
266 (Field::SFDefaultFlags | Field::FStdAccess),
267 static_cast<FieldEditMethodSig>(&ComputeShaderAlgorithm::editHandleMemoryBarrier),
268 static_cast<FieldGetMethodSig >(&ComputeShaderAlgorithm::getHandleMemoryBarrier));
269
270 oType.addInitialDesc(pDesc);
271 }
272
273
274 ComputeShaderAlgorithmBase::TypeObject ComputeShaderAlgorithmBase::_type(
275 ComputeShaderAlgorithmBase::getClassname(),
276 Inherited::getClassname(),
277 "NULL",
278 nsOSG, //Namespace
279 reinterpret_cast<PrototypeCreateF>(&ComputeShaderAlgorithmBase::createEmptyLocal),
280 reinterpret_cast<InitContainerF>(&ComputeShaderAlgorithm::initMethod),
281 reinterpret_cast<ExitContainerF>(&ComputeShaderAlgorithm::exitMethod),
282 reinterpret_cast<InitalInsertDescFunc>(
283 reinterpret_cast<void *>(&ComputeShaderAlgorithm::classDescInserter)),
284 false,
285 0,
286 "<?xml version=\"1.0\"?>\n"
287 "\n"
288 "<FieldContainer\n"
289 "\tname=\"ComputeShaderAlgorithm\"\n"
290 "\tparent=\"ComputeAlgorithm\"\n"
291 "\tlibrary=\"ContribComputeBase\"\n"
292 "\tpointerfieldtypes=\"both\"\n"
293 "\tstructure=\"concrete\"\n"
294 "\tsystemcomponent=\"true\"\n"
295 "\tparentsystemcomponent=\"true\"\n"
296 "\tdecoratable=\"false\"\n"
297 "\tuseLocalIncludes=\"false\"\n"
298 " isNodeCore=\"false\"\n"
299 " >\n"
300 " This class allows the operation of a compute shader algorithm. It allows the specification of \n"
301 " shader buffers and textures to be used in the computation task and the details of the computational\n"
302 " space the compute shader operats on.\n"
303 " \n"
304 " <Field\n"
305 " name=\"textureImages\"\n"
306 " type=\"TextureImageChunk\"\n"
307 " category=\"pointer\"\n"
308 " cardinality=\"multi\"\n"
309 " visibility=\"external\"\n"
310 " access=\"public\"\n"
311 " >\n"
312 " Texture images to be used for reading/writing in the compute shader.\n"
313 " The texture images uses the binding points starting from 0 and then \n"
314 " incrementing by 1.\n"
315 " </Field>\n"
316 " <Field\n"
317 " name=\"chunkMaterial\"\n"
318 " type=\"ChunkMaterial\"\n"
319 " category=\"pointer\"\n"
320 " cardinality=\"single\"\n"
321 " visibility=\"external\"\n"
322 " access=\"public\"\n"
323 " >\n"
324 " This chunk material allows the usage of texture images, uniform buffer objects\n"
325 " and shader storage buffer objects in the compute shader. Only these material\n"
326 " chunks are going to be respected, all other will simply omitted. A valid\n"
327 " chunk in the chunk material specifies the binding point to be used in the compute\n"
328 " shader.\n"
329 " </Field>\n"
330 " <Field\n"
331 " name=\"computeShader\"\n"
332 " type=\"ComputeShaderChunk\"\n"
333 " category=\"pointer\"\n"
334 " cardinality=\"single\"\n"
335 " visibility=\"external\"\n"
336 " access=\"public\"\n"
337 " >\n"
338 " The compute shader abstracts the actual shader code and the variable specifications\n"
339 " used in the shader.\n"
340 " </Field>\n"
341 " <Field\n"
342 " name=\"dispatchConfig\"\n"
343 " type=\"Vec3i\"\n"
344 " cardinality=\"single\"\n"
345 " visibility=\"external\"\n"
346 " access=\"public\"\n"
347 " defaultValue=\"1, 0, 0\"\n"
348 " >\n"
349 " The number of work groups, i.e. the work group count.\n"
350 " </Field>\n"
351 "<Field\n"
352 " name=\"workGroupSize\"\n"
353 " type=\"Vec3i\"\n"
354 " cardinality=\"single\"\n"
355 " visibility=\"external\"\n"
356 " access=\"public\"\n"
357 " defaultValue=\"1, 1, 1\"\n"
358 " >\n"
359 " The size of the work groups, i.e. the local_size_var value of the layout specifier.\n"
360 " This does need the ARB_compute_variable_group_size GL extension to work.\n"
361 " </Field>\n"
362 "\n"
363 " <Field\n"
364 " name=\"useMemoryBarrier\"\n"
365 " type=\"bool\"\n"
366 " cardinality=\"single\"\n"
367 " visibility=\"external\"\n"
368 " access=\"public\"\n"
369 " defaultValue=\"false\"\n"
370 " >\n"
371 " This flag toggles the usage of the memory barrier call after the operation of\n"
372 " the compute shader.\n"
373 " </Field>\n"
374 "\n"
375 " <Field\n"
376 " name=\"useVariableWorkGroupSize\"\n"
377 " type=\"bool\"\n"
378 " cardinality=\"single\"\n"
379 " visibility=\"external\"\n"
380 " access=\"public\"\n"
381 " defaultValue=\"false\"\n"
382 " >\n"
383 " This flag enables the useage of the variable work group size dispatch API that\n"
384 " is specified in the ARB_compute_variable_group_size extension.\n"
385 " </Field>\n"
386 "\n"
387 " <Field\n"
388 " name=\"memoryBarrier\"\n"
389 " type=\"GLenum\"\n"
390 " cardinality=\"single\"\n"
391 " visibility=\"external\"\n"
392 " access=\"public\"\n"
393 " defaultValue=\"GL_SHADER_STORAGE_BARRIER_BIT\"\n"
394 " >\n"
395 " This bitmask determines the behavior of the memory barrier that is issued after the\n"
396 " operation of the compute shader.\n"
397 " </Field>\n"
398 "\n"
399 "</FieldContainer>\n",
400 "This class allows the operation of a compute shader algorithm. It allows the specification of \n"
401 "shader buffers and textures to be used in the computation task and the details of the computational\n"
402 "space the compute shader operats on.\n"
403 );
404
405 /*------------------------------ get -----------------------------------*/
406
407 FieldContainerType &ComputeShaderAlgorithmBase::getType(void)
408 {
409 return _type;
410 }
411
412 const FieldContainerType &ComputeShaderAlgorithmBase::getType(void) const
413 {
414 return _type;
415 }
416
417 UInt32 ComputeShaderAlgorithmBase::getContainerSize(void) const
418 {
419 return sizeof(ComputeShaderAlgorithm);
420 }
421
422 /*------------------------- decorator get ------------------------------*/
423
424
425 //! Get the ComputeShaderAlgorithm::_mfTextureImages field.
426 const MFUnrecTextureImageChunkPtr *ComputeShaderAlgorithmBase::getMFTextureImages(void) const
427 {
428 return &_mfTextureImages;
429 }
430
431 MFUnrecTextureImageChunkPtr *ComputeShaderAlgorithmBase::editMFTextureImages (void)
432 {
433 editMField(TextureImagesFieldMask, _mfTextureImages);
434
435 return &_mfTextureImages;
436 }
437 TextureImageChunk * ComputeShaderAlgorithmBase::getTextureImages(const UInt32 index) const
438 {
439 return _mfTextureImages[index];
440 }
441
442 //! Get the ComputeShaderAlgorithm::_sfChunkMaterial field.
443 const SFUnrecChunkMaterialPtr *ComputeShaderAlgorithmBase::getSFChunkMaterial(void) const
444 {
445 return &_sfChunkMaterial;
446 }
447
448 SFUnrecChunkMaterialPtr *ComputeShaderAlgorithmBase::editSFChunkMaterial (void)
449 {
450 editSField(ChunkMaterialFieldMask);
451
452 return &_sfChunkMaterial;
453 }
454
455 //! Get the value of the ComputeShaderAlgorithm::_sfChunkMaterial field.
456 ChunkMaterial * ComputeShaderAlgorithmBase::getChunkMaterial(void) const
457 {
458 return _sfChunkMaterial.getValue();
459 }
460
461 //! Set the value of the ComputeShaderAlgorithm::_sfChunkMaterial field.
462 void ComputeShaderAlgorithmBase::setChunkMaterial(ChunkMaterial * const value)
463 {
464 editSField(ChunkMaterialFieldMask);
465
466 _sfChunkMaterial.setValue(value);
467 }
468
469
470 //! Get the ComputeShaderAlgorithm::_sfComputeShader field.
471 const SFUnrecComputeShaderChunkPtr *ComputeShaderAlgorithmBase::getSFComputeShader(void) const
472 {
473 return &_sfComputeShader;
474 }
475
476 SFUnrecComputeShaderChunkPtr *ComputeShaderAlgorithmBase::editSFComputeShader (void)
477 {
478 editSField(ComputeShaderFieldMask);
479
480 return &_sfComputeShader;
481 }
482
483 //! Get the value of the ComputeShaderAlgorithm::_sfComputeShader field.
484 ComputeShaderChunk * ComputeShaderAlgorithmBase::getComputeShader(void) const
485 {
486 return _sfComputeShader.getValue();
487 }
488
489 //! Set the value of the ComputeShaderAlgorithm::_sfComputeShader field.
490 void ComputeShaderAlgorithmBase::setComputeShader(ComputeShaderChunk * const value)
491 {
492 editSField(ComputeShaderFieldMask);
493
494 _sfComputeShader.setValue(value);
495 }
496
497
498 SFVec3i *ComputeShaderAlgorithmBase::editSFDispatchConfig(void)
499 {
500 editSField(DispatchConfigFieldMask);
501
502 return &_sfDispatchConfig;
503 }
504
505 const SFVec3i *ComputeShaderAlgorithmBase::getSFDispatchConfig(void) const
506 {
507 return &_sfDispatchConfig;
508 }
509
510
511 SFVec3i *ComputeShaderAlgorithmBase::editSFWorkGroupSize(void)
512 {
513 editSField(WorkGroupSizeFieldMask);
514
515 return &_sfWorkGroupSize;
516 }
517
518 const SFVec3i *ComputeShaderAlgorithmBase::getSFWorkGroupSize(void) const
519 {
520 return &_sfWorkGroupSize;
521 }
522
523
524 SFBool *ComputeShaderAlgorithmBase::editSFUseMemoryBarrier(void)
525 {
526 editSField(UseMemoryBarrierFieldMask);
527
528 return &_sfUseMemoryBarrier;
529 }
530
531 const SFBool *ComputeShaderAlgorithmBase::getSFUseMemoryBarrier(void) const
532 {
533 return &_sfUseMemoryBarrier;
534 }
535
536
537 SFBool *ComputeShaderAlgorithmBase::editSFUseVariableWorkGroupSize(void)
538 {
539 editSField(UseVariableWorkGroupSizeFieldMask);
540
541 return &_sfUseVariableWorkGroupSize;
542 }
543
544 const SFBool *ComputeShaderAlgorithmBase::getSFUseVariableWorkGroupSize(void) const
545 {
546 return &_sfUseVariableWorkGroupSize;
547 }
548
549
550 SFGLenum *ComputeShaderAlgorithmBase::editSFMemoryBarrier(void)
551 {
552 editSField(MemoryBarrierFieldMask);
553
554 return &_sfMemoryBarrier;
555 }
556
557 const SFGLenum *ComputeShaderAlgorithmBase::getSFMemoryBarrier(void) const
558 {
559 return &_sfMemoryBarrier;
560 }
561
562
563
564
565 void ComputeShaderAlgorithmBase::pushToTextureImages(TextureImageChunk * const value)
566 {
567 editMField(TextureImagesFieldMask, _mfTextureImages);
568
569 _mfTextureImages.push_back(value);
570 }
571
572 void ComputeShaderAlgorithmBase::assignTextureImages(const MFUnrecTextureImageChunkPtr &value)
573 {
574 MFUnrecTextureImageChunkPtr::const_iterator elemIt =
575 value.begin();
576 MFUnrecTextureImageChunkPtr::const_iterator elemEnd =
577 value.end ();
578
579 static_cast<ComputeShaderAlgorithm *>(this)->clearTextureImages();
580
581 while(elemIt != elemEnd)
582 {
583 this->pushToTextureImages(*elemIt);
584
585 ++elemIt;
586 }
587 }
588
589 void ComputeShaderAlgorithmBase::removeFromTextureImages(UInt32 uiIndex)
590 {
591 if(uiIndex < _mfTextureImages.size())
592 {
593 editMField(TextureImagesFieldMask, _mfTextureImages);
594
595 _mfTextureImages.erase(uiIndex);
596 }
597 }
598
599 void ComputeShaderAlgorithmBase::removeObjFromTextureImages(TextureImageChunk * const value)
600 {
601 Int32 iElemIdx = _mfTextureImages.findIndex(value);
602
603 if(iElemIdx != -1)
604 {
605 editMField(TextureImagesFieldMask, _mfTextureImages);
606
607 _mfTextureImages.erase(iElemIdx);
608 }
609 }
610 void ComputeShaderAlgorithmBase::clearTextureImages(void)
611 {
612 editMField(TextureImagesFieldMask, _mfTextureImages);
613
614
615 _mfTextureImages.clear();
616 }
617
618
619
620 /*------------------------------ access -----------------------------------*/
621
622 SizeT ComputeShaderAlgorithmBase::getBinSize(ConstFieldMaskArg whichField)
623 {
624 SizeT returnValue = Inherited::getBinSize(whichField);
625
626 if(FieldBits::NoField != (TextureImagesFieldMask & whichField))
627 {
628 returnValue += _mfTextureImages.getBinSize();
629 }
630 if(FieldBits::NoField != (ChunkMaterialFieldMask & whichField))
631 {
632 returnValue += _sfChunkMaterial.getBinSize();
633 }
634 if(FieldBits::NoField != (ComputeShaderFieldMask & whichField))
635 {
636 returnValue += _sfComputeShader.getBinSize();
637 }
638 if(FieldBits::NoField != (DispatchConfigFieldMask & whichField))
639 {
640 returnValue += _sfDispatchConfig.getBinSize();
641 }
642 if(FieldBits::NoField != (WorkGroupSizeFieldMask & whichField))
643 {
644 returnValue += _sfWorkGroupSize.getBinSize();
645 }
646 if(FieldBits::NoField != (UseMemoryBarrierFieldMask & whichField))
647 {
648 returnValue += _sfUseMemoryBarrier.getBinSize();
649 }
650 if(FieldBits::NoField != (UseVariableWorkGroupSizeFieldMask & whichField))
651 {
652 returnValue += _sfUseVariableWorkGroupSize.getBinSize();
653 }
654 if(FieldBits::NoField != (MemoryBarrierFieldMask & whichField))
655 {
656 returnValue += _sfMemoryBarrier.getBinSize();
657 }
658
659 return returnValue;
660 }
661
662 void ComputeShaderAlgorithmBase::copyToBin(BinaryDataHandler &pMem,
663 ConstFieldMaskArg whichField)
664 {
665 Inherited::copyToBin(pMem, whichField);
666
667 if(FieldBits::NoField != (TextureImagesFieldMask & whichField))
668 {
669 _mfTextureImages.copyToBin(pMem);
670 }
671 if(FieldBits::NoField != (ChunkMaterialFieldMask & whichField))
672 {
673 _sfChunkMaterial.copyToBin(pMem);
674 }
675 if(FieldBits::NoField != (ComputeShaderFieldMask & whichField))
676 {
677 _sfComputeShader.copyToBin(pMem);
678 }
679 if(FieldBits::NoField != (DispatchConfigFieldMask & whichField))
680 {
681 _sfDispatchConfig.copyToBin(pMem);
682 }
683 if(FieldBits::NoField != (WorkGroupSizeFieldMask & whichField))
684 {
685 _sfWorkGroupSize.copyToBin(pMem);
686 }
687 if(FieldBits::NoField != (UseMemoryBarrierFieldMask & whichField))
688 {
689 _sfUseMemoryBarrier.copyToBin(pMem);
690 }
691 if(FieldBits::NoField != (UseVariableWorkGroupSizeFieldMask & whichField))
692 {
693 _sfUseVariableWorkGroupSize.copyToBin(pMem);
694 }
695 if(FieldBits::NoField != (MemoryBarrierFieldMask & whichField))
696 {
697 _sfMemoryBarrier.copyToBin(pMem);
698 }
699 }
700
701 void ComputeShaderAlgorithmBase::copyFromBin(BinaryDataHandler &pMem,
702 ConstFieldMaskArg whichField)
703 {
704 Inherited::copyFromBin(pMem, whichField);
705
706 if(FieldBits::NoField != (TextureImagesFieldMask & whichField))
707 {
708 editMField(TextureImagesFieldMask, _mfTextureImages);
709 _mfTextureImages.copyFromBin(pMem);
710 }
711 if(FieldBits::NoField != (ChunkMaterialFieldMask & whichField))
712 {
713 editSField(ChunkMaterialFieldMask);
714 _sfChunkMaterial.copyFromBin(pMem);
715 }
716 if(FieldBits::NoField != (ComputeShaderFieldMask & whichField))
717 {
718 editSField(ComputeShaderFieldMask);
719 _sfComputeShader.copyFromBin(pMem);
720 }
721 if(FieldBits::NoField != (DispatchConfigFieldMask & whichField))
722 {
723 editSField(DispatchConfigFieldMask);
724 _sfDispatchConfig.copyFromBin(pMem);
725 }
726 if(FieldBits::NoField != (WorkGroupSizeFieldMask & whichField))
727 {
728 editSField(WorkGroupSizeFieldMask);
729 _sfWorkGroupSize.copyFromBin(pMem);
730 }
731 if(FieldBits::NoField != (UseMemoryBarrierFieldMask & whichField))
732 {
733 editSField(UseMemoryBarrierFieldMask);
734 _sfUseMemoryBarrier.copyFromBin(pMem);
735 }
736 if(FieldBits::NoField != (UseVariableWorkGroupSizeFieldMask & whichField))
737 {
738 editSField(UseVariableWorkGroupSizeFieldMask);
739 _sfUseVariableWorkGroupSize.copyFromBin(pMem);
740 }
741 if(FieldBits::NoField != (MemoryBarrierFieldMask & whichField))
742 {
743 editSField(MemoryBarrierFieldMask);
744 _sfMemoryBarrier.copyFromBin(pMem);
745 }
746 }
747
748 //! create a new instance of the class
749 ComputeShaderAlgorithmTransitPtr ComputeShaderAlgorithmBase::createLocal(BitVector bFlags)
750 {
751 ComputeShaderAlgorithmTransitPtr fc;
752
753 if(getClassType().getPrototype() != NULL)
754 {
755 FieldContainerTransitPtr tmpPtr =
756 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
757
758 fc = dynamic_pointer_cast<ComputeShaderAlgorithm>(tmpPtr);
759 }
760
761 return fc;
762 }
763
764 //! create a new instance of the class, copy the container flags
765 ComputeShaderAlgorithmTransitPtr ComputeShaderAlgorithmBase::createDependent(BitVector bFlags)
766 {
767 ComputeShaderAlgorithmTransitPtr fc;
768
769 if(getClassType().getPrototype() != NULL)
770 {
771 FieldContainerTransitPtr tmpPtr =
772 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
773
774 fc = dynamic_pointer_cast<ComputeShaderAlgorithm>(tmpPtr);
775 }
776
777 return fc;
778 }
779
780 //! create a new instance of the class
781 ComputeShaderAlgorithmTransitPtr ComputeShaderAlgorithmBase::create(void)
782 {
783 ComputeShaderAlgorithmTransitPtr fc;
784
785 if(getClassType().getPrototype() != NULL)
786 {
787 FieldContainerTransitPtr tmpPtr =
788 getClassType().getPrototype()-> shallowCopy();
789
790 fc = dynamic_pointer_cast<ComputeShaderAlgorithm>(tmpPtr);
791 }
792
793 return fc;
794 }
795
796 ComputeShaderAlgorithm *ComputeShaderAlgorithmBase::createEmptyLocal(BitVector bFlags)
797 {
798 ComputeShaderAlgorithm *returnValue;
799
800 newPtr<ComputeShaderAlgorithm>(returnValue, bFlags);
801
802 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
803
804 return returnValue;
805 }
806
807 //! create an empty new instance of the class, do not copy the prototype
808 ComputeShaderAlgorithm *ComputeShaderAlgorithmBase::createEmpty(void)
809 {
810 ComputeShaderAlgorithm *returnValue;
811
812 newPtr<ComputeShaderAlgorithm>(returnValue, Thread::getCurrentLocalFlags());
813
814 returnValue->_pFieldFlags->_bNamespaceMask &=
815 ~Thread::getCurrentLocalFlags();
816
817 return returnValue;
818 }
819
820
821 FieldContainerTransitPtr ComputeShaderAlgorithmBase::shallowCopyLocal(
822 BitVector bFlags) const
823 {
824 ComputeShaderAlgorithm *tmpPtr;
825
826 newPtr(tmpPtr, dynamic_cast<const ComputeShaderAlgorithm *>(this), bFlags);
827
828 FieldContainerTransitPtr returnValue(tmpPtr);
829
830 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
831
832 return returnValue;
833 }
834
835 FieldContainerTransitPtr ComputeShaderAlgorithmBase::shallowCopyDependent(
836 BitVector bFlags) const
837 {
838 ComputeShaderAlgorithm *tmpPtr;
839
840 newPtr(tmpPtr, dynamic_cast<const ComputeShaderAlgorithm *>(this), ~bFlags);
841
842 FieldContainerTransitPtr returnValue(tmpPtr);
843
844 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
845
846 return returnValue;
847 }
848
849 FieldContainerTransitPtr ComputeShaderAlgorithmBase::shallowCopy(void) const
850 {
851 ComputeShaderAlgorithm *tmpPtr;
852
853 newPtr(tmpPtr,
854 dynamic_cast<const ComputeShaderAlgorithm *>(this),
855 Thread::getCurrentLocalFlags());
856
857 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
858
859 FieldContainerTransitPtr returnValue(tmpPtr);
860
861 return returnValue;
862 }
863
864
865
866
867 /*------------------------- constructors ----------------------------------*/
868
869 ComputeShaderAlgorithmBase::ComputeShaderAlgorithmBase(void) :
870 Inherited(),
871 _mfTextureImages (),
872 _sfChunkMaterial (NULL),
873 _sfComputeShader (NULL),
874 _sfDispatchConfig (Vec3i(1, 0, 0)),
875 _sfWorkGroupSize (Vec3i(1, 1, 1)),
876 _sfUseMemoryBarrier (bool(false)),
877 _sfUseVariableWorkGroupSize(bool(false)),
878 _sfMemoryBarrier (GLenum(GL_SHADER_STORAGE_BARRIER_BIT))
879 {
880 }
881
882 ComputeShaderAlgorithmBase::ComputeShaderAlgorithmBase(const ComputeShaderAlgorithmBase &source) :
883 Inherited(source),
884 _mfTextureImages (),
885 _sfChunkMaterial (NULL),
886 _sfComputeShader (NULL),
887 _sfDispatchConfig (source._sfDispatchConfig ),
888 _sfWorkGroupSize (source._sfWorkGroupSize ),
889 _sfUseMemoryBarrier (source._sfUseMemoryBarrier ),
890 _sfUseVariableWorkGroupSize(source._sfUseVariableWorkGroupSize),
891 _sfMemoryBarrier (source._sfMemoryBarrier )
892 {
893 }
894
895
896 /*-------------------------- destructors ----------------------------------*/
897
898 ComputeShaderAlgorithmBase::~ComputeShaderAlgorithmBase(void)
899 {
900 }
901
902 void ComputeShaderAlgorithmBase::onCreate(const ComputeShaderAlgorithm *source)
903 {
904 Inherited::onCreate(source);
905
906 if(source != NULL)
907 {
908 ComputeShaderAlgorithm *pThis = static_cast<ComputeShaderAlgorithm *>(this);
909
910 MFUnrecTextureImageChunkPtr::const_iterator TextureImagesIt =
911 source->_mfTextureImages.begin();
912 MFUnrecTextureImageChunkPtr::const_iterator TextureImagesEnd =
913 source->_mfTextureImages.end ();
914
915 while(TextureImagesIt != TextureImagesEnd)
916 {
917 pThis->pushToTextureImages(*TextureImagesIt);
918
919 ++TextureImagesIt;
920 }
921
922 pThis->setChunkMaterial(source->getChunkMaterial());
923
924 pThis->setComputeShader(source->getComputeShader());
925 }
926 }
927
928 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleTextureImages (void) const
929 {
930 MFUnrecTextureImageChunkPtr::GetHandlePtr returnValue(
931 new MFUnrecTextureImageChunkPtr::GetHandle(
932 &_mfTextureImages,
933 this->getType().getFieldDesc(TextureImagesFieldId),
934 const_cast<ComputeShaderAlgorithmBase *>(this)));
935
936 return returnValue;
937 }
938
939 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleTextureImages (void)
940 {
941 MFUnrecTextureImageChunkPtr::EditHandlePtr returnValue(
942 new MFUnrecTextureImageChunkPtr::EditHandle(
943 &_mfTextureImages,
944 this->getType().getFieldDesc(TextureImagesFieldId),
945 this));
946
947 returnValue->setAddMethod(
948 boost::bind(&ComputeShaderAlgorithm::pushToTextureImages,
949 static_cast<ComputeShaderAlgorithm *>(this), _1));
950 returnValue->setRemoveMethod(
951 boost::bind(&ComputeShaderAlgorithm::removeFromTextureImages,
952 static_cast<ComputeShaderAlgorithm *>(this), _1));
953 returnValue->setRemoveObjMethod(
954 boost::bind(&ComputeShaderAlgorithm::removeObjFromTextureImages,
955 static_cast<ComputeShaderAlgorithm *>(this), _1));
956 returnValue->setClearMethod(
957 boost::bind(&ComputeShaderAlgorithm::clearTextureImages,
958 static_cast<ComputeShaderAlgorithm *>(this)));
959
960 editMField(TextureImagesFieldMask, _mfTextureImages);
961
962 return returnValue;
963 }
964
965 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleChunkMaterial (void) const
966 {
967 SFUnrecChunkMaterialPtr::GetHandlePtr returnValue(
968 new SFUnrecChunkMaterialPtr::GetHandle(
969 &_sfChunkMaterial,
970 this->getType().getFieldDesc(ChunkMaterialFieldId),
971 const_cast<ComputeShaderAlgorithmBase *>(this)));
972
973 return returnValue;
974 }
975
976 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleChunkMaterial (void)
977 {
978 SFUnrecChunkMaterialPtr::EditHandlePtr returnValue(
979 new SFUnrecChunkMaterialPtr::EditHandle(
980 &_sfChunkMaterial,
981 this->getType().getFieldDesc(ChunkMaterialFieldId),
982 this));
983
984 returnValue->setSetMethod(
985 boost::bind(&ComputeShaderAlgorithm::setChunkMaterial,
986 static_cast<ComputeShaderAlgorithm *>(this), _1));
987
988 editSField(ChunkMaterialFieldMask);
989
990 return returnValue;
991 }
992
993 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleComputeShader (void) const
994 {
995 SFUnrecComputeShaderChunkPtr::GetHandlePtr returnValue(
996 new SFUnrecComputeShaderChunkPtr::GetHandle(
997 &_sfComputeShader,
998 this->getType().getFieldDesc(ComputeShaderFieldId),
999 const_cast<ComputeShaderAlgorithmBase *>(this)));
1000
1001 return returnValue;
1002 }
1003
1004 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleComputeShader (void)
1005 {
1006 SFUnrecComputeShaderChunkPtr::EditHandlePtr returnValue(
1007 new SFUnrecComputeShaderChunkPtr::EditHandle(
1008 &_sfComputeShader,
1009 this->getType().getFieldDesc(ComputeShaderFieldId),
1010 this));
1011
1012 returnValue->setSetMethod(
1013 boost::bind(&ComputeShaderAlgorithm::setComputeShader,
1014 static_cast<ComputeShaderAlgorithm *>(this), _1));
1015
1016 editSField(ComputeShaderFieldMask);
1017
1018 return returnValue;
1019 }
1020
1021 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleDispatchConfig (void) const
1022 {
1023 SFVec3i::GetHandlePtr returnValue(
1024 new SFVec3i::GetHandle(
1025 &_sfDispatchConfig,
1026 this->getType().getFieldDesc(DispatchConfigFieldId),
1027 const_cast<ComputeShaderAlgorithmBase *>(this)));
1028
1029 return returnValue;
1030 }
1031
1032 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleDispatchConfig (void)
1033 {
1034 SFVec3i::EditHandlePtr returnValue(
1035 new SFVec3i::EditHandle(
1036 &_sfDispatchConfig,
1037 this->getType().getFieldDesc(DispatchConfigFieldId),
1038 this));
1039
1040
1041 editSField(DispatchConfigFieldMask);
1042
1043 return returnValue;
1044 }
1045
1046 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleWorkGroupSize (void) const
1047 {
1048 SFVec3i::GetHandlePtr returnValue(
1049 new SFVec3i::GetHandle(
1050 &_sfWorkGroupSize,
1051 this->getType().getFieldDesc(WorkGroupSizeFieldId),
1052 const_cast<ComputeShaderAlgorithmBase *>(this)));
1053
1054 return returnValue;
1055 }
1056
1057 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleWorkGroupSize (void)
1058 {
1059 SFVec3i::EditHandlePtr returnValue(
1060 new SFVec3i::EditHandle(
1061 &_sfWorkGroupSize,
1062 this->getType().getFieldDesc(WorkGroupSizeFieldId),
1063 this));
1064
1065
1066 editSField(WorkGroupSizeFieldMask);
1067
1068 return returnValue;
1069 }
1070
1071 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleUseMemoryBarrier (void) const
1072 {
1073 SFBool::GetHandlePtr returnValue(
1074 new SFBool::GetHandle(
1075 &_sfUseMemoryBarrier,
1076 this->getType().getFieldDesc(UseMemoryBarrierFieldId),
1077 const_cast<ComputeShaderAlgorithmBase *>(this)));
1078
1079 return returnValue;
1080 }
1081
1082 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleUseMemoryBarrier(void)
1083 {
1084 SFBool::EditHandlePtr returnValue(
1085 new SFBool::EditHandle(
1086 &_sfUseMemoryBarrier,
1087 this->getType().getFieldDesc(UseMemoryBarrierFieldId),
1088 this));
1089
1090
1091 editSField(UseMemoryBarrierFieldMask);
1092
1093 return returnValue;
1094 }
1095
1096 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleUseVariableWorkGroupSize (void) const
1097 {
1098 SFBool::GetHandlePtr returnValue(
1099 new SFBool::GetHandle(
1100 &_sfUseVariableWorkGroupSize,
1101 this->getType().getFieldDesc(UseVariableWorkGroupSizeFieldId),
1102 const_cast<ComputeShaderAlgorithmBase *>(this)));
1103
1104 return returnValue;
1105 }
1106
1107 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleUseVariableWorkGroupSize(void)
1108 {
1109 SFBool::EditHandlePtr returnValue(
1110 new SFBool::EditHandle(
1111 &_sfUseVariableWorkGroupSize,
1112 this->getType().getFieldDesc(UseVariableWorkGroupSizeFieldId),
1113 this));
1114
1115
1116 editSField(UseVariableWorkGroupSizeFieldMask);
1117
1118 return returnValue;
1119 }
1120
1121 GetFieldHandlePtr ComputeShaderAlgorithmBase::getHandleMemoryBarrier (void) const
1122 {
1123 SFGLenum::GetHandlePtr returnValue(
1124 new SFGLenum::GetHandle(
1125 &_sfMemoryBarrier,
1126 this->getType().getFieldDesc(MemoryBarrierFieldId),
1127 const_cast<ComputeShaderAlgorithmBase *>(this)));
1128
1129 return returnValue;
1130 }
1131
1132 EditFieldHandlePtr ComputeShaderAlgorithmBase::editHandleMemoryBarrier (void)
1133 {
1134 SFGLenum::EditHandlePtr returnValue(
1135 new SFGLenum::EditHandle(
1136 &_sfMemoryBarrier,
1137 this->getType().getFieldDesc(MemoryBarrierFieldId),
1138 this));
1139
1140
1141 editSField(MemoryBarrierFieldMask);
1142
1143 return returnValue;
1144 }
1145
1146
1147 #ifdef OSG_MT_CPTR_ASPECT
1148 void ComputeShaderAlgorithmBase::execSyncV( FieldContainer &oFrom,
1149 ConstFieldMaskArg whichField,
1150 AspectOffsetStore &oOffsets,
1151 ConstFieldMaskArg syncMode,
1152 const UInt32 uiSyncInfo)
1153 {
1154 ComputeShaderAlgorithm *pThis = static_cast<ComputeShaderAlgorithm *>(this);
1155
1156 pThis->execSync(static_cast<ComputeShaderAlgorithm *>(&oFrom),
1157 whichField,
1158 oOffsets,
1159 syncMode,
1160 uiSyncInfo);
1161 }
1162 #endif
1163
1164
1165 #ifdef OSG_MT_CPTR_ASPECT
1166 FieldContainer *ComputeShaderAlgorithmBase::createAspectCopy(
1167 const FieldContainer *pRefAspect) const
1168 {
1169 ComputeShaderAlgorithm *returnValue;
1170
1171 newAspectCopy(returnValue,
1172 dynamic_cast<const ComputeShaderAlgorithm *>(pRefAspect),
1173 dynamic_cast<const ComputeShaderAlgorithm *>(this));
1174
1175 return returnValue;
1176 }
1177 #endif
1178
1179 void ComputeShaderAlgorithmBase::resolveLinks(void)
1180 {
1181 Inherited::resolveLinks();
1182
1183 static_cast<ComputeShaderAlgorithm *>(this)->clearTextureImages();
1184
1185 static_cast<ComputeShaderAlgorithm *>(this)->setChunkMaterial(NULL);
1186
1187 static_cast<ComputeShaderAlgorithm *>(this)->setComputeShader(NULL);
1188
1189
1190 }
1191
1192
1193 OSG_END_NAMESPACE