?  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 / OSGComputeShaderChunkBase.cpp
blob55e06b184f8448bf83e4de6e422b280e60d27b08
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 ComputeShaderChunk!
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 "OSGShaderProgram.h" // ComputeShader Class
66 #include "OSGShaderProgramVariables.h" // Variables Class
67
68 #include "OSGComputeShaderChunkBase.h"
69 #include "OSGComputeShaderChunk.h"
70
71 #include <boost/bind.hpp>
72
73 OSG_BEGIN_NAMESPACE
74
75 /***************************************************************************\
76 * Description *
77 \***************************************************************************/
78
79 /*! \class OSG::ComputeShaderChunk
80
81 */
82
83 /***************************************************************************\
84 * Field Documentation *
85 \***************************************************************************/
86
87 /*! \var ShaderProgram * ComputeShaderChunkBase::_mfComputeShader
88 fragment program object
89 */
90
91 /*! \var std::string ComputeShaderChunkBase::_sfComputeProgram
92 vertex program source
93 */
94
95 /*! \var ShaderProgramVariables * ComputeShaderChunkBase::_sfVariables
96 fragment program object
97 */
98
99 /*! \var Int32 ComputeShaderChunkBase::_mfVariableLocations
100 fragment program object
101 */
102
103 /*! \var Int32 ComputeShaderChunkBase::_mfProceduralVariableLocations
104 fragment program object
105 */
106
107 /*! \var UInt32 ComputeShaderChunkBase::_sfGLId
108
109 */
110
111
112 /***************************************************************************\
113 * FieldType/FieldTrait Instantiation *
114 \***************************************************************************/
115
116 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
117 PointerType FieldTraits<ComputeShaderChunk *, nsOSG>::_type(
118 "ComputeShaderChunkPtr",
119 "StateChunkPtr",
120 ComputeShaderChunk::getClassType(),
121 nsOSG);
122 #endif
123
124 OSG_FIELDTRAITS_GETTYPE_NS(ComputeShaderChunk *, nsOSG)
125
126 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
127 ComputeShaderChunk *,
128 nsOSG)
129
130 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
131 ComputeShaderChunk *,
132 nsOSG)
133
134 /***************************************************************************\
135 * Field Description *
136 \***************************************************************************/
137
138 void ComputeShaderChunkBase::classDescInserter(TypeObject &oType)
139 {
140 FieldDescriptionBase *pDesc = NULL;
141
142
143 pDesc = new MFUnrecShaderProgramPtr::Description(
144 MFUnrecShaderProgramPtr::getClassType(),
145 "computeShader",
146 "fragment program object\n",
147 ComputeShaderFieldId, ComputeShaderFieldMask,
148 false,
149 (Field::MFDefaultFlags | Field::FStdAccess),
150 static_cast<FieldEditMethodSig>(&ComputeShaderChunk::editHandleComputeShader),
151 static_cast<FieldGetMethodSig >(&ComputeShaderChunk::getHandleComputeShader));
152
153 oType.addInitialDesc(pDesc);
154
155 pDesc = new SFString::Description(
156 SFString::getClassType(),
157 "computeProgram",
158 "vertex program source\n",
159 ComputeProgramFieldId, ComputeProgramFieldMask,
160 false,
161 (Field::SFDefaultFlags | Field::FStdAccess),
162 static_cast<FieldEditMethodSig>(&ComputeShaderChunk::editHandleComputeProgram),
163 static_cast<FieldGetMethodSig >(&ComputeShaderChunk::getHandleComputeProgram));
164
165 oType.addInitialDesc(pDesc);
166
167 pDesc = new SFUnrecChildShaderProgramVariablesPtr::Description(
168 SFUnrecChildShaderProgramVariablesPtr::getClassType(),
169 "variables",
170 "fragment program object\n",
171 VariablesFieldId, VariablesFieldMask,
172 false,
173 (Field::SFDefaultFlags | Field::FStdAccess),
174 static_cast<FieldEditMethodSig>(&ComputeShaderChunk::editHandleVariables),
175 static_cast<FieldGetMethodSig >(&ComputeShaderChunk::getHandleVariables));
176
177 oType.addInitialDesc(pDesc);
178
179 pDesc = new MFInt32::Description(
180 MFInt32::getClassType(),
181 "variableLocations",
182 "fragment program object\n",
183 VariableLocationsFieldId, VariableLocationsFieldMask,
184 true,
185 (Field::MFDefaultFlags | Field::FStdAccess),
186 static_cast<FieldEditMethodSig>(&ComputeShaderChunk::editHandleVariableLocations),
187 static_cast<FieldGetMethodSig >(&ComputeShaderChunk::getHandleVariableLocations));
188
189 oType.addInitialDesc(pDesc);
190
191 pDesc = new MFInt32::Description(
192 MFInt32::getClassType(),
193 "proceduralVariableLocations",
194 "fragment program object\n",
195 ProceduralVariableLocationsFieldId, ProceduralVariableLocationsFieldMask,
196 true,
197 (Field::MFDefaultFlags | Field::FStdAccess),
198 static_cast<FieldEditMethodSig>(&ComputeShaderChunk::editHandleProceduralVariableLocations),
199 static_cast<FieldGetMethodSig >(&ComputeShaderChunk::getHandleProceduralVariableLocations));
200
201 oType.addInitialDesc(pDesc);
202
203 pDesc = new SFUInt32::Description(
204 SFUInt32::getClassType(),
205 "GLId",
206 "",
207 GLIdFieldId, GLIdFieldMask,
208 true,
209 (Field::FClusterLocal),
210 static_cast<FieldEditMethodSig>(&ComputeShaderChunk::editHandleGLId),
211 static_cast<FieldGetMethodSig >(&ComputeShaderChunk::getHandleGLId));
212
213 oType.addInitialDesc(pDesc);
214 }
215
216
217 ComputeShaderChunkBase::TypeObject ComputeShaderChunkBase::_type(
218 ComputeShaderChunkBase::getClassname(),
219 Inherited::getClassname(),
220 "NULL",
221 nsOSG, //Namespace
222 reinterpret_cast<PrototypeCreateF>(&ComputeShaderChunkBase::createEmptyLocal),
223 reinterpret_cast<InitContainerF>(&ComputeShaderChunk::initMethod),
224 reinterpret_cast<ExitContainerF>(&ComputeShaderChunk::exitMethod),
225 reinterpret_cast<InitalInsertDescFunc>(
226 reinterpret_cast<void *>(&ComputeShaderChunk::classDescInserter)),
227 false,
228 ComputeProgramFieldMask,
229 "<?xml version=\"1.0\"?>\n"
230 "\n"
231 "<FieldContainer\n"
232 " name=\"ComputeShaderChunk\"\n"
233 " parent=\"StateChunk\"\n"
234 " library=\"ContribComputeBase\"\n"
235 " pointerfieldtypes=\"both\"\n"
236 " structure=\"concrete\"\n"
237 " systemcomponent=\"true\"\n"
238 " parentsystemcomponent=\"true\"\n"
239 " decoratable=\"false\"\n"
240 " useLocalIncludes=\"false\"\n"
241 " fieldsUnmarkedOnCreate=\"ComputeProgramFieldMask\"\n"
242 " docGroupBase=\"GrpSystemShader\"\n"
243 " >\n"
244 " <Field\n"
245 "\t name=\"computeShader\"\n"
246 "\t type=\"ShaderProgram\"\n"
247 "\t cardinality=\"multi\"\n"
248 "\t visibility=\"external\"\n"
249 "\t access=\"public\"\n"
250 " category=\"pointer\"\n"
251 " \n"
252 " pushToFieldAs=\"addComputeShader\"\n"
253 " removeFromMFieldIndexAs=\"subComputeShader\"\n"
254 " clearFieldAs=\"clearComputeShaders\" \n"
255 "\t >\n"
256 "\tfragment program object\n"
257 " </Field>\n"
258 " <Field\n"
259 " name=\"computeProgram\"\n"
260 " type=\"std::string\"\n"
261 " cardinality=\"single\"\n"
262 " visibility=\"external\"\n"
263 " access=\"public\"\n"
264 " >\n"
265 "\tvertex program source\n"
266 " </Field>\n"
267 "\n"
268 " <Field\n"
269 " name=\"variables\"\n"
270 " type=\"ShaderProgramVariables\"\n"
271 " cardinality=\"single\"\n"
272 " visibility=\"external\"\n"
273 " access=\"public\"\n"
274 " category=\"childpointer\"\n"
275 " childParentType=\"FieldContainer\"\n"
276 " linkParentField=\"Parents\"\n"
277 " >\n"
278 "\tfragment program object\n"
279 " </Field>\n"
280 " <Field\n"
281 " name=\"variableLocations\"\n"
282 " type=\"Int32\"\n"
283 " cardinality=\"multi\"\n"
284 " visibility=\"internal\"\n"
285 " access=\"protected\"\n"
286 " >\n"
287 "\tfragment program object\n"
288 " </Field>\n"
289 " <Field\n"
290 " name=\"proceduralVariableLocations\"\n"
291 " type=\"Int32\"\n"
292 " cardinality=\"multi\"\n"
293 " visibility=\"internal\"\n"
294 " access=\"protected\"\n"
295 " >\n"
296 "\tfragment program object\n"
297 " </Field>\n"
298 " \n"
299 " <Field\n"
300 " name=\"GLId\"\n"
301 " type=\"UInt32\"\n"
302 " cardinality=\"single\"\n"
303 " visibility=\"internal\"\n"
304 " access=\"public\"\n"
305 " defaultValue=\"0\"\n"
306 " fieldFlags=\"FClusterLocal\"\n"
307 " >\n"
308 " </Field>\n"
309 "\n"
310 "</FieldContainer>\n",
311 ""
312 );
313
314 /*------------------------------ get -----------------------------------*/
315
316 FieldContainerType &ComputeShaderChunkBase::getType(void)
317 {
318 return _type;
319 }
320
321 const FieldContainerType &ComputeShaderChunkBase::getType(void) const
322 {
323 return _type;
324 }
325
326 UInt32 ComputeShaderChunkBase::getContainerSize(void) const
327 {
328 return sizeof(ComputeShaderChunk);
329 }
330
331 /*------------------------- decorator get ------------------------------*/
332
333
334 //! Get the ComputeShaderChunk::_mfComputeShader field.
335 const MFUnrecShaderProgramPtr *ComputeShaderChunkBase::getMFComputeShader(void) const
336 {
337 return &_mfComputeShader;
338 }
339
340 MFUnrecShaderProgramPtr *ComputeShaderChunkBase::editMFComputeShader (void)
341 {
342 editMField(ComputeShaderFieldMask, _mfComputeShader);
343
344 return &_mfComputeShader;
345 }
346 ShaderProgram * ComputeShaderChunkBase::getComputeShader(const UInt32 index) const
347 {
348 return _mfComputeShader[index];
349 }
350
351 SFString *ComputeShaderChunkBase::editSFComputeProgram(void)
352 {
353 editSField(ComputeProgramFieldMask);
354
355 return &_sfComputeProgram;
356 }
357
358 const SFString *ComputeShaderChunkBase::getSFComputeProgram(void) const
359 {
360 return &_sfComputeProgram;
361 }
362
363
364 //! Get the ComputeShaderChunk::_sfVariables field.
365 const SFUnrecChildShaderProgramVariablesPtr *ComputeShaderChunkBase::getSFVariables(void) const
366 {
367 return &_sfVariables;
368 }
369
370 SFUnrecChildShaderProgramVariablesPtr *ComputeShaderChunkBase::editSFVariables (void)
371 {
372 editSField(VariablesFieldMask);
373
374 return &_sfVariables;
375 }
376
377 //! Get the value of the ComputeShaderChunk::_sfVariables field.
378 ShaderProgramVariables * ComputeShaderChunkBase::getVariables(void) const
379 {
380 return _sfVariables.getValue();
381 }
382
383 //! Set the value of the ComputeShaderChunk::_sfVariables field.
384 void ComputeShaderChunkBase::setVariables(ShaderProgramVariables * const value)
385 {
386 editSField(VariablesFieldMask);
387
388 _sfVariables.setValue(value);
389 }
390
391
392 MFInt32 *ComputeShaderChunkBase::editMFVariableLocations(void)
393 {
394 editMField(VariableLocationsFieldMask, _mfVariableLocations);
395
396 return &_mfVariableLocations;
397 }
398
399 const MFInt32 *ComputeShaderChunkBase::getMFVariableLocations(void) const
400 {
401 return &_mfVariableLocations;
402 }
403
404
405 MFInt32 *ComputeShaderChunkBase::editMFProceduralVariableLocations(void)
406 {
407 editMField(ProceduralVariableLocationsFieldMask, _mfProceduralVariableLocations);
408
409 return &_mfProceduralVariableLocations;
410 }
411
412 const MFInt32 *ComputeShaderChunkBase::getMFProceduralVariableLocations(void) const
413 {
414 return &_mfProceduralVariableLocations;
415 }
416
417
418 SFUInt32 *ComputeShaderChunkBase::editSFGLId(void)
419 {
420 editSField(GLIdFieldMask);
421
422 return &_sfGLId;
423 }
424
425 const SFUInt32 *ComputeShaderChunkBase::getSFGLId(void) const
426 {
427 return &_sfGLId;
428 }
429
430
431
432
433 void ComputeShaderChunkBase::addComputeShader(ShaderProgram * const value)
434 {
435 editMField(ComputeShaderFieldMask, _mfComputeShader);
436
437 _mfComputeShader.push_back(value);
438 }
439
440 void ComputeShaderChunkBase::assignComputeShader(const MFUnrecShaderProgramPtr &value)
441 {
442 MFUnrecShaderProgramPtr::const_iterator elemIt =
443 value.begin();
444 MFUnrecShaderProgramPtr::const_iterator elemEnd =
445 value.end ();
446
447 static_cast<ComputeShaderChunk *>(this)->clearComputeShaders();
448
449 while(elemIt != elemEnd)
450 {
451 this->addComputeShader(*elemIt);
452
453 ++elemIt;
454 }
455 }
456
457 void ComputeShaderChunkBase::subComputeShader(UInt32 uiIndex)
458 {
459 if(uiIndex < _mfComputeShader.size())
460 {
461 editMField(ComputeShaderFieldMask, _mfComputeShader);
462
463 _mfComputeShader.erase(uiIndex);
464 }
465 }
466
467 void ComputeShaderChunkBase::removeObjFromComputeShader(ShaderProgram * const value)
468 {
469 Int32 iElemIdx = _mfComputeShader.findIndex(value);
470
471 if(iElemIdx != -1)
472 {
473 editMField(ComputeShaderFieldMask, _mfComputeShader);
474
475 _mfComputeShader.erase(iElemIdx);
476 }
477 }
478 void ComputeShaderChunkBase::clearComputeShaders(void)
479 {
480 editMField(ComputeShaderFieldMask, _mfComputeShader);
481
482
483 _mfComputeShader.clear();
484 }
485
486
487
488 /*------------------------------ access -----------------------------------*/
489
490 SizeT ComputeShaderChunkBase::getBinSize(ConstFieldMaskArg whichField)
491 {
492 SizeT returnValue = Inherited::getBinSize(whichField);
493
494 if(FieldBits::NoField != (ComputeShaderFieldMask & whichField))
495 {
496 returnValue += _mfComputeShader.getBinSize();
497 }
498 if(FieldBits::NoField != (ComputeProgramFieldMask & whichField))
499 {
500 returnValue += _sfComputeProgram.getBinSize();
501 }
502 if(FieldBits::NoField != (VariablesFieldMask & whichField))
503 {
504 returnValue += _sfVariables.getBinSize();
505 }
506 if(FieldBits::NoField != (VariableLocationsFieldMask & whichField))
507 {
508 returnValue += _mfVariableLocations.getBinSize();
509 }
510 if(FieldBits::NoField != (ProceduralVariableLocationsFieldMask & whichField))
511 {
512 returnValue += _mfProceduralVariableLocations.getBinSize();
513 }
514 if(FieldBits::NoField != (GLIdFieldMask & whichField))
515 {
516 returnValue += _sfGLId.getBinSize();
517 }
518
519 return returnValue;
520 }
521
522 void ComputeShaderChunkBase::copyToBin(BinaryDataHandler &pMem,
523 ConstFieldMaskArg whichField)
524 {
525 Inherited::copyToBin(pMem, whichField);
526
527 if(FieldBits::NoField != (ComputeShaderFieldMask & whichField))
528 {
529 _mfComputeShader.copyToBin(pMem);
530 }
531 if(FieldBits::NoField != (ComputeProgramFieldMask & whichField))
532 {
533 _sfComputeProgram.copyToBin(pMem);
534 }
535 if(FieldBits::NoField != (VariablesFieldMask & whichField))
536 {
537 _sfVariables.copyToBin(pMem);
538 }
539 if(FieldBits::NoField != (VariableLocationsFieldMask & whichField))
540 {
541 _mfVariableLocations.copyToBin(pMem);
542 }
543 if(FieldBits::NoField != (ProceduralVariableLocationsFieldMask & whichField))
544 {
545 _mfProceduralVariableLocations.copyToBin(pMem);
546 }
547 if(FieldBits::NoField != (GLIdFieldMask & whichField))
548 {
549 _sfGLId.copyToBin(pMem);
550 }
551 }
552
553 void ComputeShaderChunkBase::copyFromBin(BinaryDataHandler &pMem,
554 ConstFieldMaskArg whichField)
555 {
556 Inherited::copyFromBin(pMem, whichField);
557
558 if(FieldBits::NoField != (ComputeShaderFieldMask & whichField))
559 {
560 editMField(ComputeShaderFieldMask, _mfComputeShader);
561 _mfComputeShader.copyFromBin(pMem);
562 }
563 if(FieldBits::NoField != (ComputeProgramFieldMask & whichField))
564 {
565 editSField(ComputeProgramFieldMask);
566 _sfComputeProgram.copyFromBin(pMem);
567 }
568 if(FieldBits::NoField != (VariablesFieldMask & whichField))
569 {
570 editSField(VariablesFieldMask);
571 _sfVariables.copyFromBin(pMem);
572 }
573 if(FieldBits::NoField != (VariableLocationsFieldMask & whichField))
574 {
575 editMField(VariableLocationsFieldMask, _mfVariableLocations);
576 _mfVariableLocations.copyFromBin(pMem);
577 }
578 if(FieldBits::NoField != (ProceduralVariableLocationsFieldMask & whichField))
579 {
580 editMField(ProceduralVariableLocationsFieldMask, _mfProceduralVariableLocations);
581 _mfProceduralVariableLocations.copyFromBin(pMem);
582 }
583 if(FieldBits::NoField != (GLIdFieldMask & whichField))
584 {
585 editSField(GLIdFieldMask);
586 _sfGLId.copyFromBin(pMem);
587 }
588 }
589
590 //! create a new instance of the class
591 ComputeShaderChunkTransitPtr ComputeShaderChunkBase::createLocal(BitVector bFlags)
592 {
593 ComputeShaderChunkTransitPtr fc;
594
595 if(getClassType().getPrototype() != NULL)
596 {
597 FieldContainerTransitPtr tmpPtr =
598 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
599
600 fc = dynamic_pointer_cast<ComputeShaderChunk>(tmpPtr);
601 }
602
603 return fc;
604 }
605
606 //! create a new instance of the class, copy the container flags
607 ComputeShaderChunkTransitPtr ComputeShaderChunkBase::createDependent(BitVector bFlags)
608 {
609 ComputeShaderChunkTransitPtr fc;
610
611 if(getClassType().getPrototype() != NULL)
612 {
613 FieldContainerTransitPtr tmpPtr =
614 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
615
616 fc = dynamic_pointer_cast<ComputeShaderChunk>(tmpPtr);
617 }
618
619 return fc;
620 }
621
622 //! create a new instance of the class
623 ComputeShaderChunkTransitPtr ComputeShaderChunkBase::create(void)
624 {
625 ComputeShaderChunkTransitPtr fc;
626
627 if(getClassType().getPrototype() != NULL)
628 {
629 FieldContainerTransitPtr tmpPtr =
630 getClassType().getPrototype()-> shallowCopy();
631
632 fc = dynamic_pointer_cast<ComputeShaderChunk>(tmpPtr);
633 }
634
635 return fc;
636 }
637
638 ComputeShaderChunk *ComputeShaderChunkBase::createEmptyLocal(BitVector bFlags)
639 {
640 ComputeShaderChunk *returnValue;
641
642 newPtr<ComputeShaderChunk>(returnValue, bFlags);
643
644 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
645
646 return returnValue;
647 }
648
649 //! create an empty new instance of the class, do not copy the prototype
650 ComputeShaderChunk *ComputeShaderChunkBase::createEmpty(void)
651 {
652 ComputeShaderChunk *returnValue;
653
654 newPtr<ComputeShaderChunk>(returnValue, Thread::getCurrentLocalFlags());
655
656 returnValue->_pFieldFlags->_bNamespaceMask &=
657 ~Thread::getCurrentLocalFlags();
658
659 return returnValue;
660 }
661
662
663 FieldContainerTransitPtr ComputeShaderChunkBase::shallowCopyLocal(
664 BitVector bFlags) const
665 {
666 ComputeShaderChunk *tmpPtr;
667
668 newPtr(tmpPtr, dynamic_cast<const ComputeShaderChunk *>(this), bFlags);
669
670 FieldContainerTransitPtr returnValue(tmpPtr);
671
672 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
673
674 return returnValue;
675 }
676
677 FieldContainerTransitPtr ComputeShaderChunkBase::shallowCopyDependent(
678 BitVector bFlags) const
679 {
680 ComputeShaderChunk *tmpPtr;
681
682 newPtr(tmpPtr, dynamic_cast<const ComputeShaderChunk *>(this), ~bFlags);
683
684 FieldContainerTransitPtr returnValue(tmpPtr);
685
686 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
687
688 return returnValue;
689 }
690
691 FieldContainerTransitPtr ComputeShaderChunkBase::shallowCopy(void) const
692 {
693 ComputeShaderChunk *tmpPtr;
694
695 newPtr(tmpPtr,
696 dynamic_cast<const ComputeShaderChunk *>(this),
697 Thread::getCurrentLocalFlags());
698
699 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
700
701 FieldContainerTransitPtr returnValue(tmpPtr);
702
703 return returnValue;
704 }
705
706
707
708
709 /*------------------------- constructors ----------------------------------*/
710
711 ComputeShaderChunkBase::ComputeShaderChunkBase(void) :
712 Inherited(),
713 _mfComputeShader (),
714 _sfComputeProgram (),
715 _sfVariables (this,
716 VariablesFieldId,
717 ShaderProgramVariables::ParentsFieldId),
718 _mfVariableLocations (),
719 _mfProceduralVariableLocations(),
720 _sfGLId (UInt32(0))
721 {
722 }
723
724 ComputeShaderChunkBase::ComputeShaderChunkBase(const ComputeShaderChunkBase &source) :
725 Inherited(source),
726 _mfComputeShader (),
727 _sfComputeProgram (source._sfComputeProgram ),
728 _sfVariables (this,
729 VariablesFieldId,
730 ShaderProgramVariables::ParentsFieldId),
731 _mfVariableLocations (source._mfVariableLocations ),
732 _mfProceduralVariableLocations(source._mfProceduralVariableLocations),
733 _sfGLId (source._sfGLId )
734 {
735 }
736
737
738 /*-------------------------- destructors ----------------------------------*/
739
740 ComputeShaderChunkBase::~ComputeShaderChunkBase(void)
741 {
742 }
743
744 /*-------------------------------------------------------------------------*/
745 /* Child linking */
746
747 bool ComputeShaderChunkBase::unlinkChild(
748 FieldContainer * const pChild,
749 UInt16 const childFieldId)
750 {
751 if(childFieldId == VariablesFieldId)
752 {
753 ShaderProgramVariables * pTypedChild =
754 dynamic_cast<ShaderProgramVariables *>(pChild);
755
756 if(pTypedChild != NULL)
757 {
758 if(_sfVariables.getValue() == pTypedChild)
759 {
760 editSField(VariablesFieldMask);
761
762 _sfVariables.setValue(NULL);
763
764 return true;
765 }
766
767 SWARNING << "Parent ([" << this
768 << "] id [" << this->getId()
769 << "] type [" << this->getType().getCName()
770 << "] childFieldId [" << childFieldId
771 << "]) - Child ([" << pChild
772 << "] id [" << pChild->getId()
773 << "] type [" << pChild->getType().getCName()
774 << "]): link inconsistent!"
775 << std::endl;
776
777 return false;
778 }
779
780 return false;
781 }
782
783
784 return Inherited::unlinkChild(pChild, childFieldId);
785 }
786
787 void ComputeShaderChunkBase::onCreate(const ComputeShaderChunk *source)
788 {
789 Inherited::onCreate(source);
790
791 if(source != NULL)
792 {
793 ComputeShaderChunk *pThis = static_cast<ComputeShaderChunk *>(this);
794
795 MFUnrecShaderProgramPtr::const_iterator ComputeShaderIt =
796 source->_mfComputeShader.begin();
797 MFUnrecShaderProgramPtr::const_iterator ComputeShaderEnd =
798 source->_mfComputeShader.end ();
799
800 while(ComputeShaderIt != ComputeShaderEnd)
801 {
802 pThis->addComputeShader(*ComputeShaderIt);
803
804 ++ComputeShaderIt;
805 }
806
807 pThis->setVariables(source->getVariables());
808 }
809 }
810
811 GetFieldHandlePtr ComputeShaderChunkBase::getHandleComputeShader (void) const
812 {
813 MFUnrecShaderProgramPtr::GetHandlePtr returnValue(
814 new MFUnrecShaderProgramPtr::GetHandle(
815 &_mfComputeShader,
816 this->getType().getFieldDesc(ComputeShaderFieldId),
817 const_cast<ComputeShaderChunkBase *>(this)));
818
819 return returnValue;
820 }
821
822 EditFieldHandlePtr ComputeShaderChunkBase::editHandleComputeShader (void)
823 {
824 MFUnrecShaderProgramPtr::EditHandlePtr returnValue(
825 new MFUnrecShaderProgramPtr::EditHandle(
826 &_mfComputeShader,
827 this->getType().getFieldDesc(ComputeShaderFieldId),
828 this));
829
830 returnValue->setAddMethod(
831 boost::bind(&ComputeShaderChunk::addComputeShader,
832 static_cast<ComputeShaderChunk *>(this), _1));
833 returnValue->setRemoveMethod(
834 boost::bind(&ComputeShaderChunk::subComputeShader,
835 static_cast<ComputeShaderChunk *>(this), _1));
836 returnValue->setRemoveObjMethod(
837 boost::bind(&ComputeShaderChunk::removeObjFromComputeShader,
838 static_cast<ComputeShaderChunk *>(this), _1));
839 returnValue->setClearMethod(
840 boost::bind(&ComputeShaderChunk::clearComputeShaders,
841 static_cast<ComputeShaderChunk *>(this)));
842
843 editMField(ComputeShaderFieldMask, _mfComputeShader);
844
845 return returnValue;
846 }
847
848 GetFieldHandlePtr ComputeShaderChunkBase::getHandleComputeProgram (void) const
849 {
850 SFString::GetHandlePtr returnValue(
851 new SFString::GetHandle(
852 &_sfComputeProgram,
853 this->getType().getFieldDesc(ComputeProgramFieldId),
854 const_cast<ComputeShaderChunkBase *>(this)));
855
856 return returnValue;
857 }
858
859 EditFieldHandlePtr ComputeShaderChunkBase::editHandleComputeProgram (void)
860 {
861 SFString::EditHandlePtr returnValue(
862 new SFString::EditHandle(
863 &_sfComputeProgram,
864 this->getType().getFieldDesc(ComputeProgramFieldId),
865 this));
866
867
868 editSField(ComputeProgramFieldMask);
869
870 return returnValue;
871 }
872
873 GetFieldHandlePtr ComputeShaderChunkBase::getHandleVariables (void) const
874 {
875 SFUnrecChildShaderProgramVariablesPtr::GetHandlePtr returnValue(
876 new SFUnrecChildShaderProgramVariablesPtr::GetHandle(
877 &_sfVariables,
878 this->getType().getFieldDesc(VariablesFieldId),
879 const_cast<ComputeShaderChunkBase *>(this)));
880
881 return returnValue;
882 }
883
884 EditFieldHandlePtr ComputeShaderChunkBase::editHandleVariables (void)
885 {
886 SFUnrecChildShaderProgramVariablesPtr::EditHandlePtr returnValue(
887 new SFUnrecChildShaderProgramVariablesPtr::EditHandle(
888 &_sfVariables,
889 this->getType().getFieldDesc(VariablesFieldId),
890 this));
891
892 returnValue->setSetMethod(
893 boost::bind(&ComputeShaderChunk::setVariables,
894 static_cast<ComputeShaderChunk *>(this), _1));
895
896 editSField(VariablesFieldMask);
897
898 return returnValue;
899 }
900
901 GetFieldHandlePtr ComputeShaderChunkBase::getHandleVariableLocations (void) const
902 {
903 MFInt32::GetHandlePtr returnValue(
904 new MFInt32::GetHandle(
905 &_mfVariableLocations,
906 this->getType().getFieldDesc(VariableLocationsFieldId),
907 const_cast<ComputeShaderChunkBase *>(this)));
908
909 return returnValue;
910 }
911
912 EditFieldHandlePtr ComputeShaderChunkBase::editHandleVariableLocations(void)
913 {
914 MFInt32::EditHandlePtr returnValue(
915 new MFInt32::EditHandle(
916 &_mfVariableLocations,
917 this->getType().getFieldDesc(VariableLocationsFieldId),
918 this));
919
920
921 editMField(VariableLocationsFieldMask, _mfVariableLocations);
922
923 return returnValue;
924 }
925
926 GetFieldHandlePtr ComputeShaderChunkBase::getHandleProceduralVariableLocations (void) const
927 {
928 MFInt32::GetHandlePtr returnValue(
929 new MFInt32::GetHandle(
930 &_mfProceduralVariableLocations,
931 this->getType().getFieldDesc(ProceduralVariableLocationsFieldId),
932 const_cast<ComputeShaderChunkBase *>(this)));
933
934 return returnValue;
935 }
936
937 EditFieldHandlePtr ComputeShaderChunkBase::editHandleProceduralVariableLocations(void)
938 {
939 MFInt32::EditHandlePtr returnValue(
940 new MFInt32::EditHandle(
941 &_mfProceduralVariableLocations,
942 this->getType().getFieldDesc(ProceduralVariableLocationsFieldId),
943 this));
944
945
946 editMField(ProceduralVariableLocationsFieldMask, _mfProceduralVariableLocations);
947
948 return returnValue;
949 }
950
951 GetFieldHandlePtr ComputeShaderChunkBase::getHandleGLId (void) const
952 {
953 SFUInt32::GetHandlePtr returnValue(
954 new SFUInt32::GetHandle(
955 &_sfGLId,
956 this->getType().getFieldDesc(GLIdFieldId),
957 const_cast<ComputeShaderChunkBase *>(this)));
958
959 return returnValue;
960 }
961
962 EditFieldHandlePtr ComputeShaderChunkBase::editHandleGLId (void)
963 {
964 SFUInt32::EditHandlePtr returnValue(
965 new SFUInt32::EditHandle(
966 &_sfGLId,
967 this->getType().getFieldDesc(GLIdFieldId),
968 this));
969
970
971 editSField(GLIdFieldMask);
972
973 return returnValue;
974 }
975
976
977 #ifdef OSG_MT_CPTR_ASPECT
978 void ComputeShaderChunkBase::execSyncV( FieldContainer &oFrom,
979 ConstFieldMaskArg whichField,
980 AspectOffsetStore &oOffsets,
981 ConstFieldMaskArg syncMode,
982 const UInt32 uiSyncInfo)
983 {
984 ComputeShaderChunk *pThis = static_cast<ComputeShaderChunk *>(this);
985
986 pThis->execSync(static_cast<ComputeShaderChunk *>(&oFrom),
987 whichField,
988 oOffsets,
989 syncMode,
990 uiSyncInfo);
991 }
992 #endif
993
994
995 #ifdef OSG_MT_CPTR_ASPECT
996 FieldContainer *ComputeShaderChunkBase::createAspectCopy(
997 const FieldContainer *pRefAspect) const
998 {
999 ComputeShaderChunk *returnValue;
1000
1001 newAspectCopy(returnValue,
1002 dynamic_cast<const ComputeShaderChunk *>(pRefAspect),
1003 dynamic_cast<const ComputeShaderChunk *>(this));
1004
1005 return returnValue;
1006 }
1007 #endif
1008
1009 void ComputeShaderChunkBase::resolveLinks(void)
1010 {
1011 Inherited::resolveLinks();
1012
1013 static_cast<ComputeShaderChunk *>(this)->clearComputeShaders();
1014
1015 static_cast<ComputeShaderChunk *>(this)->setVariables(NULL);
1016
1017 #ifdef OSG_MT_CPTR_ASPECT
1018 AspectOffsetStore oOffsets;
1019
1020 _pAspectStore->fillOffsetArray(oOffsets, this);
1021 #endif
1022
1023 #ifdef OSG_MT_CPTR_ASPECT
1024 _mfVariableLocations.terminateShare(Thread::getCurrentAspect(),
1025 oOffsets);
1026 #endif
1027 #ifdef OSG_MT_CPTR_ASPECT
1028 _mfProceduralVariableLocations.terminateShare(Thread::getCurrentAspect(),
1029 oOffsets);
1030 #endif
1031 }
1032
1033
1034 OSG_END_NAMESPACE