?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / System / State / Shader / Chunks / OSGShaderExecutableChunkBase.cpp
blob9f5d8b42bac7534dc7339f92e26f8d9001b2243b
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 ShaderExecutableChunk!
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 #include "OSGGL.h" // GeometryInputType default header
65 #include "OSGGL.h" // GeometryOutputType default header
66
67 #include "OSGShaderProgram.h" // VertexShader Class
68 #include "OSGShaderProgramVariables.h" // Variables Class
69
70 #include "OSGShaderExecutableChunkBase.h"
71 #include "OSGShaderExecutableChunk.h"
72
73 #include <boost/bind.hpp>
74
75 OSG_BEGIN_NAMESPACE
76
77 /***************************************************************************\
78 * Description *
79 \***************************************************************************/
80
81 /*! \class OSG::ShaderExecutableChunk
82
83 */
84
85 /***************************************************************************\
86 * Field Documentation *
87 \***************************************************************************/
88
89 /*! \var ShaderProgram * ShaderExecutableChunkBase::_mfVertexShader
90 fragment program object
91 */
92
93 /*! \var ShaderProgram * ShaderExecutableChunkBase::_mfTessControlShader
94 fragment program object
95 */
96
97 /*! \var ShaderProgram * ShaderExecutableChunkBase::_mfTessEvaluationShader
98 fragment program object
99 */
100
101 /*! \var ShaderProgram * ShaderExecutableChunkBase::_mfGeometryShader
102 fragment program object
103 */
104
105 /*! \var ShaderProgram * ShaderExecutableChunkBase::_mfFragmentShader
106 fragment program object
107 */
108
109 /*! \var ShaderProgramVariables * ShaderExecutableChunkBase::_sfVariables
110 fragment program object
111 */
112
113 /*! \var Int32 ShaderExecutableChunkBase::_mfVariableLocations
114 fragment program object
115 */
116
117 /*! \var Int32 ShaderExecutableChunkBase::_mfProceduralVariableLocations
118 fragment program object
119 */
120
121 /*! \var UInt32 ShaderExecutableChunkBase::_sfGeometryVerticesOut
122
123 */
124
125 /*! \var GLenum ShaderExecutableChunkBase::_sfGeometryInputType
126
127 */
128
129 /*! \var GLenum ShaderExecutableChunkBase::_sfGeometryOutputType
130
131 */
132
133 /*! \var ShaderAttribute ShaderExecutableChunkBase::_mfAttributes
134
135 */
136
137 /*! \var UInt32 ShaderExecutableChunkBase::_sfGLId
138
139 */
140
141 /*! \var bool ShaderExecutableChunkBase::_sfPointSize
142 Flag to set whether the shader can change the point size.
143 */
144
145
146 /***************************************************************************\
147 * FieldType/FieldTrait Instantiation *
148 \***************************************************************************/
149
150 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
151 PointerType FieldTraits<ShaderExecutableChunk *, nsOSG>::_type(
152 "ShaderExecutableChunkPtr",
153 "StateChunkPtr",
154 ShaderExecutableChunk::getClassType(),
155 nsOSG);
156 #endif
157
158 OSG_FIELDTRAITS_GETTYPE_NS(ShaderExecutableChunk *, nsOSG)
159
160 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
161 ShaderExecutableChunk *,
162 nsOSG)
163
164 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
165 ShaderExecutableChunk *,
166 nsOSG)
167
168 /***************************************************************************\
169 * Field Description *
170 \***************************************************************************/
171
172 void ShaderExecutableChunkBase::classDescInserter(TypeObject &oType)
173 {
174 FieldDescriptionBase *pDesc = NULL;
175
176
177 pDesc = new MFUncountedShaderProgramPtr::Description(
178 MFUncountedShaderProgramPtr::getClassType(),
179 "vertexShader",
180 "fragment program object\n",
181 VertexShaderFieldId, VertexShaderFieldMask,
182 false,
183 (Field::MFDefaultFlags | Field::FStdAccess),
184 static_cast <FieldEditMethodSig>(&ShaderExecutableChunk::invalidEditField),
185 static_cast <FieldGetMethodSig >(&ShaderExecutableChunk::invalidGetField));
186
187 oType.addInitialDesc(pDesc);
188
189 pDesc = new MFUncountedShaderProgramPtr::Description(
190 MFUncountedShaderProgramPtr::getClassType(),
191 "tessControlShader",
192 "fragment program object\n",
193 TessControlShaderFieldId, TessControlShaderFieldMask,
194 false,
195 (Field::MFDefaultFlags | Field::FStdAccess),
196 static_cast <FieldEditMethodSig>(&ShaderExecutableChunk::invalidEditField),
197 static_cast <FieldGetMethodSig >(&ShaderExecutableChunk::invalidGetField));
198
199 oType.addInitialDesc(pDesc);
200
201 pDesc = new MFUncountedShaderProgramPtr::Description(
202 MFUncountedShaderProgramPtr::getClassType(),
203 "tessEvaluationShader",
204 "fragment program object\n",
205 TessEvaluationShaderFieldId, TessEvaluationShaderFieldMask,
206 false,
207 (Field::MFDefaultFlags | Field::FStdAccess),
208 static_cast <FieldEditMethodSig>(&ShaderExecutableChunk::invalidEditField),
209 static_cast <FieldGetMethodSig >(&ShaderExecutableChunk::invalidGetField));
210
211 oType.addInitialDesc(pDesc);
212
213 pDesc = new MFUncountedShaderProgramPtr::Description(
214 MFUncountedShaderProgramPtr::getClassType(),
215 "geometryShader",
216 "fragment program object\n",
217 GeometryShaderFieldId, GeometryShaderFieldMask,
218 false,
219 (Field::MFDefaultFlags | Field::FStdAccess),
220 static_cast <FieldEditMethodSig>(&ShaderExecutableChunk::invalidEditField),
221 static_cast <FieldGetMethodSig >(&ShaderExecutableChunk::invalidGetField));
222
223 oType.addInitialDesc(pDesc);
224
225 pDesc = new MFUncountedShaderProgramPtr::Description(
226 MFUncountedShaderProgramPtr::getClassType(),
227 "fragmentShader",
228 "fragment program object\n",
229 FragmentShaderFieldId, FragmentShaderFieldMask,
230 false,
231 (Field::MFDefaultFlags | Field::FStdAccess),
232 static_cast <FieldEditMethodSig>(&ShaderExecutableChunk::invalidEditField),
233 static_cast <FieldGetMethodSig >(&ShaderExecutableChunk::invalidGetField));
234
235 oType.addInitialDesc(pDesc);
236
237 pDesc = new SFUnrecChildShaderProgramVariablesPtr::Description(
238 SFUnrecChildShaderProgramVariablesPtr::getClassType(),
239 "variables",
240 "fragment program object\n",
241 VariablesFieldId, VariablesFieldMask,
242 false,
243 (Field::SFDefaultFlags | Field::FStdAccess),
244 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleVariables),
245 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleVariables));
246
247 oType.addInitialDesc(pDesc);
248
249 pDesc = new MFInt32::Description(
250 MFInt32::getClassType(),
251 "variableLocations",
252 "fragment program object\n",
253 VariableLocationsFieldId, VariableLocationsFieldMask,
254 true,
255 (Field::MFDefaultFlags | Field::FStdAccess),
256 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleVariableLocations),
257 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleVariableLocations));
258
259 oType.addInitialDesc(pDesc);
260
261 pDesc = new MFInt32::Description(
262 MFInt32::getClassType(),
263 "proceduralVariableLocations",
264 "fragment program object\n",
265 ProceduralVariableLocationsFieldId, ProceduralVariableLocationsFieldMask,
266 true,
267 (Field::MFDefaultFlags | Field::FStdAccess),
268 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleProceduralVariableLocations),
269 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleProceduralVariableLocations));
270
271 oType.addInitialDesc(pDesc);
272
273 pDesc = new SFUInt32::Description(
274 SFUInt32::getClassType(),
275 "geometryVerticesOut",
276 "",
277 GeometryVerticesOutFieldId, GeometryVerticesOutFieldMask,
278 false,
279 (Field::SFDefaultFlags | Field::FStdAccess),
280 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleGeometryVerticesOut),
281 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleGeometryVerticesOut));
282
283 oType.addInitialDesc(pDesc);
284
285 pDesc = new SFGLenum::Description(
286 SFGLenum::getClassType(),
287 "geometryInputType",
288 "",
289 GeometryInputTypeFieldId, GeometryInputTypeFieldMask,
290 false,
291 (Field::SFDefaultFlags | Field::FStdAccess),
292 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleGeometryInputType),
293 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleGeometryInputType));
294
295 oType.addInitialDesc(pDesc);
296
297 pDesc = new SFGLenum::Description(
298 SFGLenum::getClassType(),
299 "geometryOutputType",
300 "",
301 GeometryOutputTypeFieldId, GeometryOutputTypeFieldMask,
302 false,
303 (Field::SFDefaultFlags | Field::FStdAccess),
304 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleGeometryOutputType),
305 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleGeometryOutputType));
306
307 oType.addInitialDesc(pDesc);
308
309 pDesc = new MFShaderAttribute::Description(
310 MFShaderAttribute::getClassType(),
311 "attributes",
312 "",
313 AttributesFieldId, AttributesFieldMask,
314 false,
315 (Field::MFDefaultFlags | Field::FStdAccess),
316 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleAttributes),
317 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleAttributes));
318
319 oType.addInitialDesc(pDesc);
320
321 pDesc = new SFUInt32::Description(
322 SFUInt32::getClassType(),
323 "GLId",
324 "",
325 GLIdFieldId, GLIdFieldMask,
326 true,
327 (Field::FClusterLocal),
328 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandleGLId),
329 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandleGLId));
330
331 oType.addInitialDesc(pDesc);
332
333 pDesc = new SFBool::Description(
334 SFBool::getClassType(),
335 "pointSize",
336 "Flag to set whether the shader can change the point size.\n",
337 PointSizeFieldId, PointSizeFieldMask,
338 false,
339 (Field::SFDefaultFlags | Field::FStdAccess),
340 static_cast<FieldEditMethodSig>(&ShaderExecutableChunk::editHandlePointSize),
341 static_cast<FieldGetMethodSig >(&ShaderExecutableChunk::getHandlePointSize));
342
343 oType.addInitialDesc(pDesc);
344 }
345
346
347 ShaderExecutableChunkBase::TypeObject ShaderExecutableChunkBase::_type(
348 ShaderExecutableChunkBase::getClassname(),
349 Inherited::getClassname(),
350 "NULL",
351 nsOSG, //Namespace
352 reinterpret_cast<PrototypeCreateF>(&ShaderExecutableChunkBase::createEmptyLocal),
353 reinterpret_cast<InitContainerF>(&ShaderExecutableChunk::initMethod),
354 reinterpret_cast<ExitContainerF>(&ShaderExecutableChunk::exitMethod),
355 reinterpret_cast<InitalInsertDescFunc>(
356 reinterpret_cast<void *>(&ShaderExecutableChunk::classDescInserter)),
357 false,
358 0,
359 "<?xml version=\"1.0\"?>\n"
360 "\n"
361 "<FieldContainer\n"
362 " name=\"ShaderExecutableChunk\"\n"
363 " parent=\"StateChunk\"\n"
364 " library=\"System\"\n"
365 " pointerfieldtypes=\"both\"\n"
366 " structure=\"concrete\"\n"
367 " systemcomponent=\"true\"\n"
368 " parentsystemcomponent=\"true\"\n"
369 " decoratable=\"false\"\n"
370 " useLocalIncludes=\"false\"\n"
371 " docGroupBase=\"GrpSystemShader\"\n"
372 " >\n"
373 " <Field\n"
374 " name=\"vertexShader\"\n"
375 " type=\"ShaderProgram\"\n"
376 " cardinality=\"multi\"\n"
377 " visibility=\"external\"\n"
378 " access=\"none\"\n"
379 " category=\"uncountedpointer\"\n"
380 " >\n"
381 " <!--- \n"
382 " pushToFieldAs=\"addVertexShader\"\n"
383 " removeFromMFieldIndexAs=\"subVertexShader\"\n"
384 " clearFieldAs=\"clearVertexShaders\" -->\n"
385 " \n"
386 "\tfragment program object\n"
387 " </Field>\n"
388 " <Field\n"
389 " name=\"tessControlShader\"\n"
390 " type=\"ShaderProgram\"\n"
391 " cardinality=\"multi\"\n"
392 " visibility=\"external\"\n"
393 " access=\"none\"\n"
394 " category=\"uncountedpointer\"\n"
395 " >\n"
396 "\n"
397 " <!-- \n"
398 " pushToFieldAs=\"addGeometryShader\"\n"
399 " removeFromMFieldIndexAs=\"subGeometryShader\"\n"
400 " clearFieldAs=\"clearGeometryShaders\" -->\n"
401 "\tfragment program object\n"
402 " </Field>\n"
403 " <Field\n"
404 " name=\"tessEvaluationShader\"\n"
405 " type=\"ShaderProgram\"\n"
406 " cardinality=\"multi\"\n"
407 " visibility=\"external\"\n"
408 " access=\"none\"\n"
409 " category=\"uncountedpointer\"\n"
410 " >\n"
411 "\n"
412 " <!-- \n"
413 " pushToFieldAs=\"addGeometryShader\"\n"
414 " removeFromMFieldIndexAs=\"subGeometryShader\"\n"
415 " clearFieldAs=\"clearGeometryShaders\" -->\n"
416 "\tfragment program object\n"
417 " </Field>\n"
418 " <Field\n"
419 " name=\"geometryShader\"\n"
420 " type=\"ShaderProgram\"\n"
421 " cardinality=\"multi\"\n"
422 " visibility=\"external\"\n"
423 " access=\"none\"\n"
424 " category=\"uncountedpointer\"\n"
425 " >\n"
426 "\n"
427 " <!-- \n"
428 " pushToFieldAs=\"addGeometryShader\"\n"
429 " removeFromMFieldIndexAs=\"subGeometryShader\"\n"
430 " clearFieldAs=\"clearGeometryShaders\" -->\n"
431 "\tfragment program object\n"
432 " </Field>\n"
433 " <Field\n"
434 " name=\"fragmentShader\"\n"
435 " type=\"ShaderProgram\"\n"
436 " cardinality=\"multi\"\n"
437 " visibility=\"external\"\n"
438 " access=\"none\"\n"
439 " category=\"uncountedpointer\"\n"
440 " >\n"
441 "\n"
442 " <!-- \n"
443 " pushToFieldAs=\"addFragmentShader\"\n"
444 " removeFromMFieldIndexAs=\"subFragmentShader\"\n"
445 " clearFieldAs=\"clearFragmentShaders\" -->\n"
446 "\tfragment program object\n"
447 " </Field>\n"
448 "\n"
449 " <Field\n"
450 " name=\"variables\"\n"
451 " type=\"ShaderProgramVariables\"\n"
452 " cardinality=\"single\"\n"
453 " visibility=\"external\"\n"
454 " access=\"public\"\n"
455 " category=\"childpointer\"\n"
456 " childParentType=\"FieldContainer\"\n"
457 " linkParentField=\"Parents\"\n"
458 " >\n"
459 "\tfragment program object\n"
460 " </Field>\n"
461 " <Field\n"
462 " name=\"variableLocations\"\n"
463 " type=\"Int32\"\n"
464 " cardinality=\"multi\"\n"
465 " visibility=\"internal\"\n"
466 " access=\"protected\"\n"
467 " >\n"
468 "\tfragment program object\n"
469 " </Field>\n"
470 " <Field\n"
471 " name=\"proceduralVariableLocations\"\n"
472 " type=\"Int32\"\n"
473 " cardinality=\"multi\"\n"
474 " visibility=\"internal\"\n"
475 " access=\"protected\"\n"
476 " >\n"
477 "\tfragment program object\n"
478 " </Field>\n"
479 " \n"
480 " <Field\n"
481 " name=\"geometryVerticesOut\"\n"
482 " type=\"UInt32\"\n"
483 " cardinality=\"single\"\n"
484 " visibility=\"external\"\n"
485 " defaultValue=\"0\"\n"
486 " >\n"
487 " </Field>\n"
488 " <Field\n"
489 " name=\"geometryInputType\"\n"
490 " type=\"GLenum\"\n"
491 " cardinality=\"single\"\n"
492 " visibility=\"external\"\n"
493 " defaultValue=\"GL_TRIANGLES\"\n"
494 " defaultHeader=\"&quot;OSGGL.h&quot;\"\n"
495 " >\n"
496 " </Field>\n"
497 " <Field\n"
498 " name=\"geometryOutputType\"\n"
499 " type=\"GLenum\"\n"
500 " cardinality=\"single\"\n"
501 " visibility=\"external\"\n"
502 " defaultValue=\"GL_TRIANGLE_STRIP\"\n"
503 " defaultHeader=\"&quot;OSGGL.h&quot;\"\n"
504 " >\n"
505 " </Field>\n"
506 "\n"
507 " <Field\n"
508 " name=\"attributes\"\n"
509 " type=\"ShaderAttribute\"\n"
510 " cardinality=\"multi\"\n"
511 " visibility=\"external\"\n"
512 " access=\"public\"\n"
513 " >\n"
514 " </Field>\n"
515 "\n"
516 " <Field\n"
517 " name=\"GLId\"\n"
518 " type=\"UInt32\"\n"
519 " cardinality=\"single\"\n"
520 " visibility=\"internal\"\n"
521 " access=\"public\"\n"
522 " defaultValue=\"0\"\n"
523 " fieldFlags=\"FClusterLocal\"\n"
524 " >\n"
525 " </Field>\n"
526 "\n"
527 " <Field\n"
528 " name=\"pointSize\"\n"
529 " type=\"bool\"\n"
530 " cardinality=\"single\"\n"
531 " visibility=\"external\"\n"
532 " defaultValue=\"false\"\n"
533 " access=\"public\"\n"
534 " >\n"
535 "\tFlag to set whether the shader can change the point size.\n"
536 " </Field>\n"
537 "\n"
538 "</FieldContainer>\n",
539 ""
540 );
541
542 /*------------------------------ get -----------------------------------*/
543
544 FieldContainerType &ShaderExecutableChunkBase::getType(void)
545 {
546 return _type;
547 }
548
549 const FieldContainerType &ShaderExecutableChunkBase::getType(void) const
550 {
551 return _type;
552 }
553
554 UInt32 ShaderExecutableChunkBase::getContainerSize(void) const
555 {
556 return sizeof(ShaderExecutableChunk);
557 }
558
559 /*------------------------- decorator get ------------------------------*/
560
561
562
563
564
565
566
567 //! Get the ShaderExecutableChunk::_sfVariables field.
568 const SFUnrecChildShaderProgramVariablesPtr *ShaderExecutableChunkBase::getSFVariables(void) const
569 {
570 return &_sfVariables;
571 }
572
573 SFUnrecChildShaderProgramVariablesPtr *ShaderExecutableChunkBase::editSFVariables (void)
574 {
575 editSField(VariablesFieldMask);
576
577 return &_sfVariables;
578 }
579
580 //! Get the value of the ShaderExecutableChunk::_sfVariables field.
581 ShaderProgramVariables * ShaderExecutableChunkBase::getVariables(void) const
582 {
583 return _sfVariables.getValue();
584 }
585
586 //! Set the value of the ShaderExecutableChunk::_sfVariables field.
587 void ShaderExecutableChunkBase::setVariables(ShaderProgramVariables * const value)
588 {
589 editSField(VariablesFieldMask);
590
591 _sfVariables.setValue(value);
592 }
593
594
595 MFInt32 *ShaderExecutableChunkBase::editMFVariableLocations(void)
596 {
597 editMField(VariableLocationsFieldMask, _mfVariableLocations);
598
599 return &_mfVariableLocations;
600 }
601
602 const MFInt32 *ShaderExecutableChunkBase::getMFVariableLocations(void) const
603 {
604 return &_mfVariableLocations;
605 }
606
607
608 MFInt32 *ShaderExecutableChunkBase::editMFProceduralVariableLocations(void)
609 {
610 editMField(ProceduralVariableLocationsFieldMask, _mfProceduralVariableLocations);
611
612 return &_mfProceduralVariableLocations;
613 }
614
615 const MFInt32 *ShaderExecutableChunkBase::getMFProceduralVariableLocations(void) const
616 {
617 return &_mfProceduralVariableLocations;
618 }
619
620
621 SFUInt32 *ShaderExecutableChunkBase::editSFGeometryVerticesOut(void)
622 {
623 editSField(GeometryVerticesOutFieldMask);
624
625 return &_sfGeometryVerticesOut;
626 }
627
628 const SFUInt32 *ShaderExecutableChunkBase::getSFGeometryVerticesOut(void) const
629 {
630 return &_sfGeometryVerticesOut;
631 }
632
633
634 SFGLenum *ShaderExecutableChunkBase::editSFGeometryInputType(void)
635 {
636 editSField(GeometryInputTypeFieldMask);
637
638 return &_sfGeometryInputType;
639 }
640
641 const SFGLenum *ShaderExecutableChunkBase::getSFGeometryInputType(void) const
642 {
643 return &_sfGeometryInputType;
644 }
645
646
647 SFGLenum *ShaderExecutableChunkBase::editSFGeometryOutputType(void)
648 {
649 editSField(GeometryOutputTypeFieldMask);
650
651 return &_sfGeometryOutputType;
652 }
653
654 const SFGLenum *ShaderExecutableChunkBase::getSFGeometryOutputType(void) const
655 {
656 return &_sfGeometryOutputType;
657 }
658
659
660 MFShaderAttribute *ShaderExecutableChunkBase::editMFAttributes(void)
661 {
662 editMField(AttributesFieldMask, _mfAttributes);
663
664 return &_mfAttributes;
665 }
666
667 const MFShaderAttribute *ShaderExecutableChunkBase::getMFAttributes(void) const
668 {
669 return &_mfAttributes;
670 }
671
672
673 SFUInt32 *ShaderExecutableChunkBase::editSFGLId(void)
674 {
675 editSField(GLIdFieldMask);
676
677 return &_sfGLId;
678 }
679
680 const SFUInt32 *ShaderExecutableChunkBase::getSFGLId(void) const
681 {
682 return &_sfGLId;
683 }
684
685
686 SFBool *ShaderExecutableChunkBase::editSFPointSize(void)
687 {
688 editSField(PointSizeFieldMask);
689
690 return &_sfPointSize;
691 }
692
693 const SFBool *ShaderExecutableChunkBase::getSFPointSize(void) const
694 {
695 return &_sfPointSize;
696 }
697
698
699
700
701
702
703 /*------------------------------ access -----------------------------------*/
704
705 SizeT ShaderExecutableChunkBase::getBinSize(ConstFieldMaskArg whichField)
706 {
707 SizeT returnValue = Inherited::getBinSize(whichField);
708
709 if(FieldBits::NoField != (VertexShaderFieldMask & whichField))
710 {
711 returnValue += _mfVertexShader.getBinSize();
712 }
713 if(FieldBits::NoField != (TessControlShaderFieldMask & whichField))
714 {
715 returnValue += _mfTessControlShader.getBinSize();
716 }
717 if(FieldBits::NoField != (TessEvaluationShaderFieldMask & whichField))
718 {
719 returnValue += _mfTessEvaluationShader.getBinSize();
720 }
721 if(FieldBits::NoField != (GeometryShaderFieldMask & whichField))
722 {
723 returnValue += _mfGeometryShader.getBinSize();
724 }
725 if(FieldBits::NoField != (FragmentShaderFieldMask & whichField))
726 {
727 returnValue += _mfFragmentShader.getBinSize();
728 }
729 if(FieldBits::NoField != (VariablesFieldMask & whichField))
730 {
731 returnValue += _sfVariables.getBinSize();
732 }
733 if(FieldBits::NoField != (VariableLocationsFieldMask & whichField))
734 {
735 returnValue += _mfVariableLocations.getBinSize();
736 }
737 if(FieldBits::NoField != (ProceduralVariableLocationsFieldMask & whichField))
738 {
739 returnValue += _mfProceduralVariableLocations.getBinSize();
740 }
741 if(FieldBits::NoField != (GeometryVerticesOutFieldMask & whichField))
742 {
743 returnValue += _sfGeometryVerticesOut.getBinSize();
744 }
745 if(FieldBits::NoField != (GeometryInputTypeFieldMask & whichField))
746 {
747 returnValue += _sfGeometryInputType.getBinSize();
748 }
749 if(FieldBits::NoField != (GeometryOutputTypeFieldMask & whichField))
750 {
751 returnValue += _sfGeometryOutputType.getBinSize();
752 }
753 if(FieldBits::NoField != (AttributesFieldMask & whichField))
754 {
755 returnValue += _mfAttributes.getBinSize();
756 }
757 if(FieldBits::NoField != (GLIdFieldMask & whichField))
758 {
759 returnValue += _sfGLId.getBinSize();
760 }
761 if(FieldBits::NoField != (PointSizeFieldMask & whichField))
762 {
763 returnValue += _sfPointSize.getBinSize();
764 }
765
766 return returnValue;
767 }
768
769 void ShaderExecutableChunkBase::copyToBin(BinaryDataHandler &pMem,
770 ConstFieldMaskArg whichField)
771 {
772 Inherited::copyToBin(pMem, whichField);
773
774 if(FieldBits::NoField != (VertexShaderFieldMask & whichField))
775 {
776 _mfVertexShader.copyToBin(pMem);
777 }
778 if(FieldBits::NoField != (TessControlShaderFieldMask & whichField))
779 {
780 _mfTessControlShader.copyToBin(pMem);
781 }
782 if(FieldBits::NoField != (TessEvaluationShaderFieldMask & whichField))
783 {
784 _mfTessEvaluationShader.copyToBin(pMem);
785 }
786 if(FieldBits::NoField != (GeometryShaderFieldMask & whichField))
787 {
788 _mfGeometryShader.copyToBin(pMem);
789 }
790 if(FieldBits::NoField != (FragmentShaderFieldMask & whichField))
791 {
792 _mfFragmentShader.copyToBin(pMem);
793 }
794 if(FieldBits::NoField != (VariablesFieldMask & whichField))
795 {
796 _sfVariables.copyToBin(pMem);
797 }
798 if(FieldBits::NoField != (VariableLocationsFieldMask & whichField))
799 {
800 _mfVariableLocations.copyToBin(pMem);
801 }
802 if(FieldBits::NoField != (ProceduralVariableLocationsFieldMask & whichField))
803 {
804 _mfProceduralVariableLocations.copyToBin(pMem);
805 }
806 if(FieldBits::NoField != (GeometryVerticesOutFieldMask & whichField))
807 {
808 _sfGeometryVerticesOut.copyToBin(pMem);
809 }
810 if(FieldBits::NoField != (GeometryInputTypeFieldMask & whichField))
811 {
812 _sfGeometryInputType.copyToBin(pMem);
813 }
814 if(FieldBits::NoField != (GeometryOutputTypeFieldMask & whichField))
815 {
816 _sfGeometryOutputType.copyToBin(pMem);
817 }
818 if(FieldBits::NoField != (AttributesFieldMask & whichField))
819 {
820 _mfAttributes.copyToBin(pMem);
821 }
822 if(FieldBits::NoField != (GLIdFieldMask & whichField))
823 {
824 _sfGLId.copyToBin(pMem);
825 }
826 if(FieldBits::NoField != (PointSizeFieldMask & whichField))
827 {
828 _sfPointSize.copyToBin(pMem);
829 }
830 }
831
832 void ShaderExecutableChunkBase::copyFromBin(BinaryDataHandler &pMem,
833 ConstFieldMaskArg whichField)
834 {
835 Inherited::copyFromBin(pMem, whichField);
836
837 if(FieldBits::NoField != (VertexShaderFieldMask & whichField))
838 {
839 editMField(VertexShaderFieldMask, _mfVertexShader);
840 _mfVertexShader.copyFromBin(pMem);
841 }
842 if(FieldBits::NoField != (TessControlShaderFieldMask & whichField))
843 {
844 editMField(TessControlShaderFieldMask, _mfTessControlShader);
845 _mfTessControlShader.copyFromBin(pMem);
846 }
847 if(FieldBits::NoField != (TessEvaluationShaderFieldMask & whichField))
848 {
849 editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
850 _mfTessEvaluationShader.copyFromBin(pMem);
851 }
852 if(FieldBits::NoField != (GeometryShaderFieldMask & whichField))
853 {
854 editMField(GeometryShaderFieldMask, _mfGeometryShader);
855 _mfGeometryShader.copyFromBin(pMem);
856 }
857 if(FieldBits::NoField != (FragmentShaderFieldMask & whichField))
858 {
859 editMField(FragmentShaderFieldMask, _mfFragmentShader);
860 _mfFragmentShader.copyFromBin(pMem);
861 }
862 if(FieldBits::NoField != (VariablesFieldMask & whichField))
863 {
864 editSField(VariablesFieldMask);
865 _sfVariables.copyFromBin(pMem);
866 }
867 if(FieldBits::NoField != (VariableLocationsFieldMask & whichField))
868 {
869 editMField(VariableLocationsFieldMask, _mfVariableLocations);
870 _mfVariableLocations.copyFromBin(pMem);
871 }
872 if(FieldBits::NoField != (ProceduralVariableLocationsFieldMask & whichField))
873 {
874 editMField(ProceduralVariableLocationsFieldMask, _mfProceduralVariableLocations);
875 _mfProceduralVariableLocations.copyFromBin(pMem);
876 }
877 if(FieldBits::NoField != (GeometryVerticesOutFieldMask & whichField))
878 {
879 editSField(GeometryVerticesOutFieldMask);
880 _sfGeometryVerticesOut.copyFromBin(pMem);
881 }
882 if(FieldBits::NoField != (GeometryInputTypeFieldMask & whichField))
883 {
884 editSField(GeometryInputTypeFieldMask);
885 _sfGeometryInputType.copyFromBin(pMem);
886 }
887 if(FieldBits::NoField != (GeometryOutputTypeFieldMask & whichField))
888 {
889 editSField(GeometryOutputTypeFieldMask);
890 _sfGeometryOutputType.copyFromBin(pMem);
891 }
892 if(FieldBits::NoField != (AttributesFieldMask & whichField))
893 {
894 editMField(AttributesFieldMask, _mfAttributes);
895 _mfAttributes.copyFromBin(pMem);
896 }
897 if(FieldBits::NoField != (GLIdFieldMask & whichField))
898 {
899 editSField(GLIdFieldMask);
900 _sfGLId.copyFromBin(pMem);
901 }
902 if(FieldBits::NoField != (PointSizeFieldMask & whichField))
903 {
904 editSField(PointSizeFieldMask);
905 _sfPointSize.copyFromBin(pMem);
906 }
907 }
908
909 //! create a new instance of the class
910 ShaderExecutableChunkTransitPtr ShaderExecutableChunkBase::createLocal(BitVector bFlags)
911 {
912 ShaderExecutableChunkTransitPtr fc;
913
914 if(getClassType().getPrototype() != NULL)
915 {
916 FieldContainerTransitPtr tmpPtr =
917 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
918
919 fc = dynamic_pointer_cast<ShaderExecutableChunk>(tmpPtr);
920 }
921
922 return fc;
923 }
924
925 //! create a new instance of the class, copy the container flags
926 ShaderExecutableChunkTransitPtr ShaderExecutableChunkBase::createDependent(BitVector bFlags)
927 {
928 ShaderExecutableChunkTransitPtr fc;
929
930 if(getClassType().getPrototype() != NULL)
931 {
932 FieldContainerTransitPtr tmpPtr =
933 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
934
935 fc = dynamic_pointer_cast<ShaderExecutableChunk>(tmpPtr);
936 }
937
938 return fc;
939 }
940
941 //! create a new instance of the class
942 ShaderExecutableChunkTransitPtr ShaderExecutableChunkBase::create(void)
943 {
944 ShaderExecutableChunkTransitPtr fc;
945
946 if(getClassType().getPrototype() != NULL)
947 {
948 FieldContainerTransitPtr tmpPtr =
949 getClassType().getPrototype()-> shallowCopy();
950
951 fc = dynamic_pointer_cast<ShaderExecutableChunk>(tmpPtr);
952 }
953
954 return fc;
955 }
956
957 ShaderExecutableChunk *ShaderExecutableChunkBase::createEmptyLocal(BitVector bFlags)
958 {
959 ShaderExecutableChunk *returnValue;
960
961 newPtr<ShaderExecutableChunk>(returnValue, bFlags);
962
963 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
964
965 return returnValue;
966 }
967
968 //! create an empty new instance of the class, do not copy the prototype
969 ShaderExecutableChunk *ShaderExecutableChunkBase::createEmpty(void)
970 {
971 ShaderExecutableChunk *returnValue;
972
973 newPtr<ShaderExecutableChunk>(returnValue, Thread::getCurrentLocalFlags());
974
975 returnValue->_pFieldFlags->_bNamespaceMask &=
976 ~Thread::getCurrentLocalFlags();
977
978 return returnValue;
979 }
980
981
982 FieldContainerTransitPtr ShaderExecutableChunkBase::shallowCopyLocal(
983 BitVector bFlags) const
984 {
985 ShaderExecutableChunk *tmpPtr;
986
987 newPtr(tmpPtr, dynamic_cast<const ShaderExecutableChunk *>(this), bFlags);
988
989 FieldContainerTransitPtr returnValue(tmpPtr);
990
991 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
992
993 return returnValue;
994 }
995
996 FieldContainerTransitPtr ShaderExecutableChunkBase::shallowCopyDependent(
997 BitVector bFlags) const
998 {
999 ShaderExecutableChunk *tmpPtr;
1000
1001 newPtr(tmpPtr, dynamic_cast<const ShaderExecutableChunk *>(this), ~bFlags);
1002
1003 FieldContainerTransitPtr returnValue(tmpPtr);
1004
1005 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
1006
1007 return returnValue;
1008 }
1009
1010 FieldContainerTransitPtr ShaderExecutableChunkBase::shallowCopy(void) const
1011 {
1012 ShaderExecutableChunk *tmpPtr;
1013
1014 newPtr(tmpPtr,
1015 dynamic_cast<const ShaderExecutableChunk *>(this),
1016 Thread::getCurrentLocalFlags());
1017
1018 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
1019
1020 FieldContainerTransitPtr returnValue(tmpPtr);
1021
1022 return returnValue;
1023 }
1024
1025
1026
1027
1028 /*------------------------- constructors ----------------------------------*/
1029
1030 ShaderExecutableChunkBase::ShaderExecutableChunkBase(void) :
1031 Inherited(),
1032 _mfVertexShader (),
1033 _mfTessControlShader (),
1034 _mfTessEvaluationShader (),
1035 _mfGeometryShader (),
1036 _mfFragmentShader (),
1037 _sfVariables (this,
1038 VariablesFieldId,
1039 ShaderProgramVariables::ParentsFieldId),
1040 _mfVariableLocations (),
1041 _mfProceduralVariableLocations(),
1042 _sfGeometryVerticesOut (UInt32(0)),
1043 _sfGeometryInputType (GLenum(GL_TRIANGLES)),
1044 _sfGeometryOutputType (GLenum(GL_TRIANGLE_STRIP)),
1045 _mfAttributes (),
1046 _sfGLId (UInt32(0)),
1047 _sfPointSize (bool(false))
1048 {
1049 }
1050
1051 ShaderExecutableChunkBase::ShaderExecutableChunkBase(const ShaderExecutableChunkBase &source) :
1052 Inherited(source),
1053 _mfVertexShader (),
1054 _mfTessControlShader (),
1055 _mfTessEvaluationShader (),
1056 _mfGeometryShader (),
1057 _mfFragmentShader (),
1058 _sfVariables (this,
1059 VariablesFieldId,
1060 ShaderProgramVariables::ParentsFieldId),
1061 _mfVariableLocations (source._mfVariableLocations ),
1062 _mfProceduralVariableLocations(source._mfProceduralVariableLocations),
1063 _sfGeometryVerticesOut (source._sfGeometryVerticesOut ),
1064 _sfGeometryInputType (source._sfGeometryInputType ),
1065 _sfGeometryOutputType (source._sfGeometryOutputType ),
1066 _mfAttributes (source._mfAttributes ),
1067 _sfGLId (source._sfGLId ),
1068 _sfPointSize (source._sfPointSize )
1069 {
1070 }
1071
1072
1073 /*-------------------------- destructors ----------------------------------*/
1074
1075 ShaderExecutableChunkBase::~ShaderExecutableChunkBase(void)
1076 {
1077 }
1078
1079 /*-------------------------------------------------------------------------*/
1080 /* Child linking */
1081
1082 bool ShaderExecutableChunkBase::unlinkChild(
1083 FieldContainer * const pChild,
1084 UInt16 const childFieldId)
1085 {
1086 if(childFieldId == VariablesFieldId)
1087 {
1088 ShaderProgramVariables * pTypedChild =
1089 dynamic_cast<ShaderProgramVariables *>(pChild);
1090
1091 if(pTypedChild != NULL)
1092 {
1093 if(_sfVariables.getValue() == pTypedChild)
1094 {
1095 editSField(VariablesFieldMask);
1096
1097 _sfVariables.setValue(NULL);
1098
1099 return true;
1100 }
1101
1102 SWARNING << "Parent ([" << this
1103 << "] id [" << this->getId()
1104 << "] type [" << this->getType().getCName()
1105 << "] childFieldId [" << childFieldId
1106 << "]) - Child ([" << pChild
1107 << "] id [" << pChild->getId()
1108 << "] type [" << pChild->getType().getCName()
1109 << "]): link inconsistent!"
1110 << std::endl;
1111
1112 return false;
1113 }
1114
1115 return false;
1116 }
1117
1118
1119 return Inherited::unlinkChild(pChild, childFieldId);
1120 }
1121
1122 void ShaderExecutableChunkBase::onCreate(const ShaderExecutableChunk *source)
1123 {
1124 Inherited::onCreate(source);
1125
1126 if(source != NULL)
1127 {
1128 ShaderExecutableChunk *pThis = static_cast<ShaderExecutableChunk *>(this);
1129
1130 pThis->setVariables(source->getVariables());
1131 }
1132 }
1133
1134 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleVertexShader (void) const
1135 {
1136 MFUncountedShaderProgramPtr::GetHandlePtr returnValue;
1137
1138 return returnValue;
1139 }
1140
1141 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleVertexShader (void)
1142 {
1143 EditFieldHandlePtr returnValue;
1144
1145 return returnValue;
1146 }
1147
1148 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleTessControlShader (void) const
1149 {
1150 MFUncountedShaderProgramPtr::GetHandlePtr returnValue;
1151
1152 return returnValue;
1153 }
1154
1155 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleTessControlShader(void)
1156 {
1157 EditFieldHandlePtr returnValue;
1158
1159 return returnValue;
1160 }
1161
1162 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleTessEvaluationShader (void) const
1163 {
1164 MFUncountedShaderProgramPtr::GetHandlePtr returnValue;
1165
1166 return returnValue;
1167 }
1168
1169 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleTessEvaluationShader(void)
1170 {
1171 EditFieldHandlePtr returnValue;
1172
1173 return returnValue;
1174 }
1175
1176 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleGeometryShader (void) const
1177 {
1178 MFUncountedShaderProgramPtr::GetHandlePtr returnValue;
1179
1180 return returnValue;
1181 }
1182
1183 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleGeometryShader (void)
1184 {
1185 EditFieldHandlePtr returnValue;
1186
1187 return returnValue;
1188 }
1189
1190 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleFragmentShader (void) const
1191 {
1192 MFUncountedShaderProgramPtr::GetHandlePtr returnValue;
1193
1194 return returnValue;
1195 }
1196
1197 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleFragmentShader (void)
1198 {
1199 EditFieldHandlePtr returnValue;
1200
1201 return returnValue;
1202 }
1203
1204 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleVariables (void) const
1205 {
1206 SFUnrecChildShaderProgramVariablesPtr::GetHandlePtr returnValue(
1207 new SFUnrecChildShaderProgramVariablesPtr::GetHandle(
1208 &_sfVariables,
1209 this->getType().getFieldDesc(VariablesFieldId),
1210 const_cast<ShaderExecutableChunkBase *>(this)));
1211
1212 return returnValue;
1213 }
1214
1215 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleVariables (void)
1216 {
1217 SFUnrecChildShaderProgramVariablesPtr::EditHandlePtr returnValue(
1218 new SFUnrecChildShaderProgramVariablesPtr::EditHandle(
1219 &_sfVariables,
1220 this->getType().getFieldDesc(VariablesFieldId),
1221 this));
1222
1223 returnValue->setSetMethod(
1224 boost::bind(&ShaderExecutableChunk::setVariables,
1225 static_cast<ShaderExecutableChunk *>(this), _1));
1226
1227 editSField(VariablesFieldMask);
1228
1229 return returnValue;
1230 }
1231
1232 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleVariableLocations (void) const
1233 {
1234 MFInt32::GetHandlePtr returnValue(
1235 new MFInt32::GetHandle(
1236 &_mfVariableLocations,
1237 this->getType().getFieldDesc(VariableLocationsFieldId),
1238 const_cast<ShaderExecutableChunkBase *>(this)));
1239
1240 return returnValue;
1241 }
1242
1243 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleVariableLocations(void)
1244 {
1245 MFInt32::EditHandlePtr returnValue(
1246 new MFInt32::EditHandle(
1247 &_mfVariableLocations,
1248 this->getType().getFieldDesc(VariableLocationsFieldId),
1249 this));
1250
1251
1252 editMField(VariableLocationsFieldMask, _mfVariableLocations);
1253
1254 return returnValue;
1255 }
1256
1257 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleProceduralVariableLocations (void) const
1258 {
1259 MFInt32::GetHandlePtr returnValue(
1260 new MFInt32::GetHandle(
1261 &_mfProceduralVariableLocations,
1262 this->getType().getFieldDesc(ProceduralVariableLocationsFieldId),
1263 const_cast<ShaderExecutableChunkBase *>(this)));
1264
1265 return returnValue;
1266 }
1267
1268 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleProceduralVariableLocations(void)
1269 {
1270 MFInt32::EditHandlePtr returnValue(
1271 new MFInt32::EditHandle(
1272 &_mfProceduralVariableLocations,
1273 this->getType().getFieldDesc(ProceduralVariableLocationsFieldId),
1274 this));
1275
1276
1277 editMField(ProceduralVariableLocationsFieldMask, _mfProceduralVariableLocations);
1278
1279 return returnValue;
1280 }
1281
1282 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleGeometryVerticesOut (void) const
1283 {
1284 SFUInt32::GetHandlePtr returnValue(
1285 new SFUInt32::GetHandle(
1286 &_sfGeometryVerticesOut,
1287 this->getType().getFieldDesc(GeometryVerticesOutFieldId),
1288 const_cast<ShaderExecutableChunkBase *>(this)));
1289
1290 return returnValue;
1291 }
1292
1293 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleGeometryVerticesOut(void)
1294 {
1295 SFUInt32::EditHandlePtr returnValue(
1296 new SFUInt32::EditHandle(
1297 &_sfGeometryVerticesOut,
1298 this->getType().getFieldDesc(GeometryVerticesOutFieldId),
1299 this));
1300
1301
1302 editSField(GeometryVerticesOutFieldMask);
1303
1304 return returnValue;
1305 }
1306
1307 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleGeometryInputType (void) const
1308 {
1309 SFGLenum::GetHandlePtr returnValue(
1310 new SFGLenum::GetHandle(
1311 &_sfGeometryInputType,
1312 this->getType().getFieldDesc(GeometryInputTypeFieldId),
1313 const_cast<ShaderExecutableChunkBase *>(this)));
1314
1315 return returnValue;
1316 }
1317
1318 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleGeometryInputType(void)
1319 {
1320 SFGLenum::EditHandlePtr returnValue(
1321 new SFGLenum::EditHandle(
1322 &_sfGeometryInputType,
1323 this->getType().getFieldDesc(GeometryInputTypeFieldId),
1324 this));
1325
1326
1327 editSField(GeometryInputTypeFieldMask);
1328
1329 return returnValue;
1330 }
1331
1332 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleGeometryOutputType (void) const
1333 {
1334 SFGLenum::GetHandlePtr returnValue(
1335 new SFGLenum::GetHandle(
1336 &_sfGeometryOutputType,
1337 this->getType().getFieldDesc(GeometryOutputTypeFieldId),
1338 const_cast<ShaderExecutableChunkBase *>(this)));
1339
1340 return returnValue;
1341 }
1342
1343 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleGeometryOutputType(void)
1344 {
1345 SFGLenum::EditHandlePtr returnValue(
1346 new SFGLenum::EditHandle(
1347 &_sfGeometryOutputType,
1348 this->getType().getFieldDesc(GeometryOutputTypeFieldId),
1349 this));
1350
1351
1352 editSField(GeometryOutputTypeFieldMask);
1353
1354 return returnValue;
1355 }
1356
1357 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleAttributes (void) const
1358 {
1359 MFShaderAttribute::GetHandlePtr returnValue(
1360 new MFShaderAttribute::GetHandle(
1361 &_mfAttributes,
1362 this->getType().getFieldDesc(AttributesFieldId),
1363 const_cast<ShaderExecutableChunkBase *>(this)));
1364
1365 return returnValue;
1366 }
1367
1368 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleAttributes (void)
1369 {
1370 MFShaderAttribute::EditHandlePtr returnValue(
1371 new MFShaderAttribute::EditHandle(
1372 &_mfAttributes,
1373 this->getType().getFieldDesc(AttributesFieldId),
1374 this));
1375
1376
1377 editMField(AttributesFieldMask, _mfAttributes);
1378
1379 return returnValue;
1380 }
1381
1382 GetFieldHandlePtr ShaderExecutableChunkBase::getHandleGLId (void) const
1383 {
1384 SFUInt32::GetHandlePtr returnValue(
1385 new SFUInt32::GetHandle(
1386 &_sfGLId,
1387 this->getType().getFieldDesc(GLIdFieldId),
1388 const_cast<ShaderExecutableChunkBase *>(this)));
1389
1390 return returnValue;
1391 }
1392
1393 EditFieldHandlePtr ShaderExecutableChunkBase::editHandleGLId (void)
1394 {
1395 SFUInt32::EditHandlePtr returnValue(
1396 new SFUInt32::EditHandle(
1397 &_sfGLId,
1398 this->getType().getFieldDesc(GLIdFieldId),
1399 this));
1400
1401
1402 editSField(GLIdFieldMask);
1403
1404 return returnValue;
1405 }
1406
1407 GetFieldHandlePtr ShaderExecutableChunkBase::getHandlePointSize (void) const
1408 {
1409 SFBool::GetHandlePtr returnValue(
1410 new SFBool::GetHandle(
1411 &_sfPointSize,
1412 this->getType().getFieldDesc(PointSizeFieldId),
1413 const_cast<ShaderExecutableChunkBase *>(this)));
1414
1415 return returnValue;
1416 }
1417
1418 EditFieldHandlePtr ShaderExecutableChunkBase::editHandlePointSize (void)
1419 {
1420 SFBool::EditHandlePtr returnValue(
1421 new SFBool::EditHandle(
1422 &_sfPointSize,
1423 this->getType().getFieldDesc(PointSizeFieldId),
1424 this));
1425
1426
1427 editSField(PointSizeFieldMask);
1428
1429 return returnValue;
1430 }
1431
1432
1433 #ifdef OSG_MT_CPTR_ASPECT
1434 void ShaderExecutableChunkBase::execSyncV( FieldContainer &oFrom,
1435 ConstFieldMaskArg whichField,
1436 AspectOffsetStore &oOffsets,
1437 ConstFieldMaskArg syncMode,
1438 const UInt32 uiSyncInfo)
1439 {
1440 ShaderExecutableChunk *pThis = static_cast<ShaderExecutableChunk *>(this);
1441
1442 pThis->execSync(static_cast<ShaderExecutableChunk *>(&oFrom),
1443 whichField,
1444 oOffsets,
1445 syncMode,
1446 uiSyncInfo);
1447 }
1448 #endif
1449
1450
1451 #ifdef OSG_MT_CPTR_ASPECT
1452 FieldContainer *ShaderExecutableChunkBase::createAspectCopy(
1453 const FieldContainer *pRefAspect) const
1454 {
1455 ShaderExecutableChunk *returnValue;
1456
1457 newAspectCopy(returnValue,
1458 dynamic_cast<const ShaderExecutableChunk *>(pRefAspect),
1459 dynamic_cast<const ShaderExecutableChunk *>(this));
1460
1461 return returnValue;
1462 }
1463 #endif
1464
1465 void ShaderExecutableChunkBase::resolveLinks(void)
1466 {
1467 Inherited::resolveLinks();
1468
1469 static_cast<ShaderExecutableChunk *>(this)->setVariables(NULL);
1470
1471 #ifdef OSG_MT_CPTR_ASPECT
1472 AspectOffsetStore oOffsets;
1473
1474 _pAspectStore->fillOffsetArray(oOffsets, this);
1475 #endif
1476
1477 #ifdef OSG_MT_CPTR_ASPECT
1478 _mfVariableLocations.terminateShare(Thread::getCurrentAspect(),
1479 oOffsets);
1480 #endif
1481 #ifdef OSG_MT_CPTR_ASPECT
1482 _mfProceduralVariableLocations.terminateShare(Thread::getCurrentAspect(),
1483 oOffsets);
1484 #endif
1485 #ifdef OSG_MT_CPTR_ASPECT
1486 _mfAttributes.terminateShare(Thread::getCurrentAspect(),
1487 oOffsets);
1488 #endif
1489 }
1490
1491
1492 OSG_END_NAMESPACE