?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / System / State / NVidia / OSGRegisterCombinersChunkBase.cpp
blobde9e53695d3ab95c5187561e4679944c45cce0a3
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 RegisterCombinersChunk!
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
66 #include "OSGRegisterCombinersChunkBase.h"
67 #include "OSGRegisterCombinersChunk.h"
68
69 #include <boost/bind.hpp>
70
71 OSG_BEGIN_NAMESPACE
72
73 /***************************************************************************\
74 * Description *
75 \***************************************************************************/
76
77 /*! \class OSG::RegisterCombinersChunk
78 See \ref PageSystemRegisterCombinersChunk for a description.
79
80 Try to avoid using this chunk, as it is very non-portable. Using a shader
81 instead is recommend, and much easier to do.
82
83 This chunk wraps nVidia's register combiners. The
84 OSG::RegisterCombinersChunk::setCombinerRGB and
85 OSG::RegisterCombinersChunk::setCombinerAlpha convenience functions
86 should be used,
87 which set up all the parameters for a single combiner's RGB or alpha part.
88 OSG::RegisterCombinersChunk::setFinalCombiner sets all parameters for the
89 final combiner. The constants are set by
90 OSG::RegisterCombinersChunk::setConstantColors(Color4f &color0, Color4f
91 &color1) for the gloabl constants and
92 OSG::RegisterCombinersChunk::setConstantColors(UInt16 which,
93 Color4f &color0,
94 Color4f &color1) for the per-combiner constants (if supported). To reset a
95 combiner one or all of the combiners use
96 OSG::RegisterCombinersChunk::clearCombiners or
97 OSG::RegisterCombinersChunk::clearCombiner.
98
99 Don't use the direct field access to set the register combiner's parameter
100 unlesss you really have to, as the internal representation is a bit
101 non-intuitive.
102
103 \ext To reduce the number of fields there isn't a field for every parameter,
104 instead they are kept in blocks of three in the fields. Please refer to the
105 source code for details.
106 \endext
107 */
108
109 /***************************************************************************\
110 * Field Documentation *
111 \***************************************************************************/
112
113 /*! \var Color4f RegisterCombinersChunkBase::_sfColor0
114
115 */
116
117 /*! \var Color4f RegisterCombinersChunkBase::_sfColor1
118
119 */
120
121 /*! \var bool RegisterCombinersChunkBase::_sfColorSumClamp
122
123 */
124
125 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableArgb
126 input,mapping,component Usage triples for variable A, RGB part
127 */
128
129 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableBrgb
130
131 */
132
133 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableCrgb
134
135 */
136
137 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableDrgb
138
139 */
140
141 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableAalpha
142
143 */
144
145 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableBalpha
146
147 */
148
149 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableCalpha
150
151 */
152
153 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableDalpha
154
155 */
156
157 /*! \var GLenum RegisterCombinersChunkBase::_mfOutputABrgb
158
159 */
160
161 /*! \var GLenum RegisterCombinersChunkBase::_mfOutputCDrgb
162
163 */
164
165 /*! \var GLenum RegisterCombinersChunkBase::_mfOutputSumrgb
166
167 */
168
169 /*! \var GLenum RegisterCombinersChunkBase::_mfScalergb
170
171 */
172
173 /*! \var GLenum RegisterCombinersChunkBase::_mfBiasrgb
174
175 */
176
177 /*! \var GLenum RegisterCombinersChunkBase::_mfOutputABalpha
178
179 */
180
181 /*! \var GLenum RegisterCombinersChunkBase::_mfOutputCDalpha
182
183 */
184
185 /*! \var GLenum RegisterCombinersChunkBase::_mfOutputSumalpha
186
187 */
188
189 /*! \var UInt8 RegisterCombinersChunkBase::_mfDotABrgb
190
191 */
192
193 /*! \var UInt8 RegisterCombinersChunkBase::_mfDotCDrgb
194
195 */
196
197 /*! \var UInt8 RegisterCombinersChunkBase::_mfMuxSumrgb
198
199 */
200
201 /*! \var GLenum RegisterCombinersChunkBase::_mfScalealpha
202
203 */
204
205 /*! \var GLenum RegisterCombinersChunkBase::_mfBiasalpha
206
207 */
208
209 /*! \var UInt8 RegisterCombinersChunkBase::_mfMuxSumalpha
210
211 */
212
213 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableE
214
215 */
216
217 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableF
218
219 */
220
221 /*! \var GLenum RegisterCombinersChunkBase::_mfVariableG
222
223 */
224
225 /*! \var Color4f RegisterCombinersChunkBase::_mfCombinerColor0
226
227 */
228
229 /*! \var Color4f RegisterCombinersChunkBase::_mfCombinerColor1
230
231 */
232
233 /*! \var UInt8 RegisterCombinersChunkBase::_sfPerStageConstants
234
235 */
236
237
238 /***************************************************************************\
239 * FieldType/FieldTrait Instantiation *
240 \***************************************************************************/
241
242 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
243 PointerType FieldTraits<RegisterCombinersChunk *, nsOSG>::_type(
244 "RegisterCombinersChunkPtr",
245 "StateChunkPtr",
246 RegisterCombinersChunk::getClassType(),
247 nsOSG);
248 #endif
249
250 OSG_FIELDTRAITS_GETTYPE_NS(RegisterCombinersChunk *, nsOSG)
251
252 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
253 RegisterCombinersChunk *,
254 nsOSG)
255
256 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
257 RegisterCombinersChunk *,
258 nsOSG)
259
260 /***************************************************************************\
261 * Field Description *
262 \***************************************************************************/
263
264 void RegisterCombinersChunkBase::classDescInserter(TypeObject &oType)
265 {
266 FieldDescriptionBase *pDesc = NULL;
267
268
269 pDesc = new SFColor4f::Description(
270 SFColor4f::getClassType(),
271 "color0",
272 "",
273 Color0FieldId, Color0FieldMask,
274 false,
275 (Field::SFDefaultFlags | Field::FStdAccess),
276 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleColor0),
277 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleColor0));
278
279 oType.addInitialDesc(pDesc);
280
281 pDesc = new SFColor4f::Description(
282 SFColor4f::getClassType(),
283 "color1",
284 "",
285 Color1FieldId, Color1FieldMask,
286 false,
287 (Field::SFDefaultFlags | Field::FStdAccess),
288 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleColor1),
289 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleColor1));
290
291 oType.addInitialDesc(pDesc);
292
293 pDesc = new SFBool::Description(
294 SFBool::getClassType(),
295 "colorSumClamp",
296 "",
297 ColorSumClampFieldId, ColorSumClampFieldMask,
298 false,
299 (Field::SFDefaultFlags | Field::FStdAccess),
300 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleColorSumClamp),
301 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleColorSumClamp));
302
303 oType.addInitialDesc(pDesc);
304
305 pDesc = new MFGLenum::Description(
306 MFGLenum::getClassType(),
307 "variableArgb",
308 "input,mapping,component Usage triples for variable A, RGB part\n",
309 VariableArgbFieldId, VariableArgbFieldMask,
310 false,
311 (Field::MFDefaultFlags | Field::FStdAccess),
312 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableArgb),
313 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableArgb));
314
315 oType.addInitialDesc(pDesc);
316
317 pDesc = new MFGLenum::Description(
318 MFGLenum::getClassType(),
319 "variableBrgb",
320 "",
321 VariableBrgbFieldId, VariableBrgbFieldMask,
322 false,
323 (Field::MFDefaultFlags | Field::FStdAccess),
324 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableBrgb),
325 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableBrgb));
326
327 oType.addInitialDesc(pDesc);
328
329 pDesc = new MFGLenum::Description(
330 MFGLenum::getClassType(),
331 "variableCrgb",
332 "",
333 VariableCrgbFieldId, VariableCrgbFieldMask,
334 false,
335 (Field::MFDefaultFlags | Field::FStdAccess),
336 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableCrgb),
337 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableCrgb));
338
339 oType.addInitialDesc(pDesc);
340
341 pDesc = new MFGLenum::Description(
342 MFGLenum::getClassType(),
343 "variableDrgb",
344 "",
345 VariableDrgbFieldId, VariableDrgbFieldMask,
346 false,
347 (Field::MFDefaultFlags | Field::FStdAccess),
348 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableDrgb),
349 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableDrgb));
350
351 oType.addInitialDesc(pDesc);
352
353 pDesc = new MFGLenum::Description(
354 MFGLenum::getClassType(),
355 "variableAalpha",
356 "",
357 VariableAalphaFieldId, VariableAalphaFieldMask,
358 false,
359 (Field::MFDefaultFlags | Field::FStdAccess),
360 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableAalpha),
361 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableAalpha));
362
363 oType.addInitialDesc(pDesc);
364
365 pDesc = new MFGLenum::Description(
366 MFGLenum::getClassType(),
367 "variableBalpha",
368 "",
369 VariableBalphaFieldId, VariableBalphaFieldMask,
370 false,
371 (Field::MFDefaultFlags | Field::FStdAccess),
372 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableBalpha),
373 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableBalpha));
374
375 oType.addInitialDesc(pDesc);
376
377 pDesc = new MFGLenum::Description(
378 MFGLenum::getClassType(),
379 "variableCalpha",
380 "",
381 VariableCalphaFieldId, VariableCalphaFieldMask,
382 false,
383 (Field::MFDefaultFlags | Field::FStdAccess),
384 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableCalpha),
385 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableCalpha));
386
387 oType.addInitialDesc(pDesc);
388
389 pDesc = new MFGLenum::Description(
390 MFGLenum::getClassType(),
391 "variableDalpha",
392 "",
393 VariableDalphaFieldId, VariableDalphaFieldMask,
394 false,
395 (Field::MFDefaultFlags | Field::FStdAccess),
396 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableDalpha),
397 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableDalpha));
398
399 oType.addInitialDesc(pDesc);
400
401 pDesc = new MFGLenum::Description(
402 MFGLenum::getClassType(),
403 "outputABrgb",
404 "",
405 OutputABrgbFieldId, OutputABrgbFieldMask,
406 false,
407 (Field::MFDefaultFlags | Field::FStdAccess),
408 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleOutputABrgb),
409 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleOutputABrgb));
410
411 oType.addInitialDesc(pDesc);
412
413 pDesc = new MFGLenum::Description(
414 MFGLenum::getClassType(),
415 "outputCDrgb",
416 "",
417 OutputCDrgbFieldId, OutputCDrgbFieldMask,
418 false,
419 (Field::MFDefaultFlags | Field::FStdAccess),
420 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleOutputCDrgb),
421 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleOutputCDrgb));
422
423 oType.addInitialDesc(pDesc);
424
425 pDesc = new MFGLenum::Description(
426 MFGLenum::getClassType(),
427 "outputSumrgb",
428 "",
429 OutputSumrgbFieldId, OutputSumrgbFieldMask,
430 false,
431 (Field::MFDefaultFlags | Field::FStdAccess),
432 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleOutputSumrgb),
433 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleOutputSumrgb));
434
435 oType.addInitialDesc(pDesc);
436
437 pDesc = new MFGLenum::Description(
438 MFGLenum::getClassType(),
439 "scalergb",
440 "",
441 ScalergbFieldId, ScalergbFieldMask,
442 false,
443 (Field::MFDefaultFlags | Field::FStdAccess),
444 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleScalergb),
445 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleScalergb));
446
447 oType.addInitialDesc(pDesc);
448
449 pDesc = new MFGLenum::Description(
450 MFGLenum::getClassType(),
451 "biasrgb",
452 "",
453 BiasrgbFieldId, BiasrgbFieldMask,
454 false,
455 (Field::MFDefaultFlags | Field::FStdAccess),
456 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleBiasrgb),
457 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleBiasrgb));
458
459 oType.addInitialDesc(pDesc);
460
461 pDesc = new MFGLenum::Description(
462 MFGLenum::getClassType(),
463 "outputABalpha",
464 "",
465 OutputABalphaFieldId, OutputABalphaFieldMask,
466 false,
467 (Field::MFDefaultFlags | Field::FStdAccess),
468 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleOutputABalpha),
469 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleOutputABalpha));
470
471 oType.addInitialDesc(pDesc);
472
473 pDesc = new MFGLenum::Description(
474 MFGLenum::getClassType(),
475 "outputCDalpha",
476 "",
477 OutputCDalphaFieldId, OutputCDalphaFieldMask,
478 false,
479 (Field::MFDefaultFlags | Field::FStdAccess),
480 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleOutputCDalpha),
481 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleOutputCDalpha));
482
483 oType.addInitialDesc(pDesc);
484
485 pDesc = new MFGLenum::Description(
486 MFGLenum::getClassType(),
487 "outputSumalpha",
488 "",
489 OutputSumalphaFieldId, OutputSumalphaFieldMask,
490 false,
491 (Field::MFDefaultFlags | Field::FStdAccess),
492 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleOutputSumalpha),
493 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleOutputSumalpha));
494
495 oType.addInitialDesc(pDesc);
496
497 pDesc = new MFUInt8::Description(
498 MFUInt8::getClassType(),
499 "dotABrgb",
500 "",
501 DotABrgbFieldId, DotABrgbFieldMask,
502 false,
503 (Field::MFDefaultFlags | Field::FStdAccess),
504 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleDotABrgb),
505 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleDotABrgb));
506
507 oType.addInitialDesc(pDesc);
508
509 pDesc = new MFUInt8::Description(
510 MFUInt8::getClassType(),
511 "dotCDrgb",
512 "",
513 DotCDrgbFieldId, DotCDrgbFieldMask,
514 false,
515 (Field::MFDefaultFlags | Field::FStdAccess),
516 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleDotCDrgb),
517 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleDotCDrgb));
518
519 oType.addInitialDesc(pDesc);
520
521 pDesc = new MFUInt8::Description(
522 MFUInt8::getClassType(),
523 "muxSumrgb",
524 "",
525 MuxSumrgbFieldId, MuxSumrgbFieldMask,
526 false,
527 (Field::MFDefaultFlags | Field::FStdAccess),
528 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleMuxSumrgb),
529 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleMuxSumrgb));
530
531 oType.addInitialDesc(pDesc);
532
533 pDesc = new MFGLenum::Description(
534 MFGLenum::getClassType(),
535 "scalealpha",
536 "",
537 ScalealphaFieldId, ScalealphaFieldMask,
538 false,
539 (Field::MFDefaultFlags | Field::FStdAccess),
540 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleScalealpha),
541 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleScalealpha));
542
543 oType.addInitialDesc(pDesc);
544
545 pDesc = new MFGLenum::Description(
546 MFGLenum::getClassType(),
547 "biasalpha",
548 "",
549 BiasalphaFieldId, BiasalphaFieldMask,
550 false,
551 (Field::MFDefaultFlags | Field::FStdAccess),
552 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleBiasalpha),
553 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleBiasalpha));
554
555 oType.addInitialDesc(pDesc);
556
557 pDesc = new MFUInt8::Description(
558 MFUInt8::getClassType(),
559 "muxSumalpha",
560 "",
561 MuxSumalphaFieldId, MuxSumalphaFieldMask,
562 false,
563 (Field::MFDefaultFlags | Field::FStdAccess),
564 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleMuxSumalpha),
565 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleMuxSumalpha));
566
567 oType.addInitialDesc(pDesc);
568
569 pDesc = new MFGLenum::Description(
570 MFGLenum::getClassType(),
571 "variableE",
572 "",
573 VariableEFieldId, VariableEFieldMask,
574 false,
575 (Field::MFDefaultFlags | Field::FStdAccess),
576 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableE),
577 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableE));
578
579 oType.addInitialDesc(pDesc);
580
581 pDesc = new MFGLenum::Description(
582 MFGLenum::getClassType(),
583 "variableF",
584 "",
585 VariableFFieldId, VariableFFieldMask,
586 false,
587 (Field::MFDefaultFlags | Field::FStdAccess),
588 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableF),
589 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableF));
590
591 oType.addInitialDesc(pDesc);
592
593 pDesc = new MFGLenum::Description(
594 MFGLenum::getClassType(),
595 "variableG",
596 "",
597 VariableGFieldId, VariableGFieldMask,
598 false,
599 (Field::MFDefaultFlags | Field::FStdAccess),
600 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleVariableG),
601 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleVariableG));
602
603 oType.addInitialDesc(pDesc);
604
605 pDesc = new MFColor4f::Description(
606 MFColor4f::getClassType(),
607 "combinerColor0",
608 "",
609 CombinerColor0FieldId, CombinerColor0FieldMask,
610 false,
611 (Field::MFDefaultFlags | Field::FStdAccess),
612 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleCombinerColor0),
613 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleCombinerColor0));
614
615 oType.addInitialDesc(pDesc);
616
617 pDesc = new MFColor4f::Description(
618 MFColor4f::getClassType(),
619 "combinerColor1",
620 "",
621 CombinerColor1FieldId, CombinerColor1FieldMask,
622 false,
623 (Field::MFDefaultFlags | Field::FStdAccess),
624 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandleCombinerColor1),
625 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandleCombinerColor1));
626
627 oType.addInitialDesc(pDesc);
628
629 pDesc = new SFUInt8::Description(
630 SFUInt8::getClassType(),
631 "perStageConstants",
632 "",
633 PerStageConstantsFieldId, PerStageConstantsFieldMask,
634 true,
635 (Field::SFDefaultFlags | Field::FStdAccess),
636 static_cast<FieldEditMethodSig>(&RegisterCombinersChunk::editHandlePerStageConstants),
637 static_cast<FieldGetMethodSig >(&RegisterCombinersChunk::getHandlePerStageConstants));
638
639 oType.addInitialDesc(pDesc);
640 }
641
642
643 RegisterCombinersChunkBase::TypeObject RegisterCombinersChunkBase::_type(
644 RegisterCombinersChunkBase::getClassname(),
645 Inherited::getClassname(),
646 "NULL",
647 nsOSG, //Namespace
648 reinterpret_cast<PrototypeCreateF>(&RegisterCombinersChunkBase::createEmptyLocal),
649 reinterpret_cast<InitContainerF>(&RegisterCombinersChunk::initMethod),
650 reinterpret_cast<ExitContainerF>(&RegisterCombinersChunk::exitMethod),
651 reinterpret_cast<InitalInsertDescFunc>(
652 reinterpret_cast<void *>(&RegisterCombinersChunk::classDescInserter)),
653 false,
654 0,
655 "<?xml version=\"1.0\"?>\n"
656 "\n"
657 "<FieldContainer\n"
658 " name=\"RegisterCombinersChunk\"\n"
659 " parent=\"StateChunk\"\n"
660 " library=\"State\"\n"
661 " pointerfieldtypes=\"both\"\n"
662 " structure=\"concrete\"\n"
663 " systemcomponent=\"true\"\n"
664 " parentsystemcomponent=\"true\"\n"
665 " decoratable=\"false\"\n"
666 " docGroupBase=\"GrpStateNVidia\"\n"
667 " ><![CDATA[\n"
668 "See \\ref PageSystemRegisterCombinersChunk for a description.\n"
669 "\n"
670 "Try to avoid using this chunk, as it is very non-portable. Using a shader \n"
671 "instead is recommend, and much easier to do.\n"
672 "\n"
673 "This chunk wraps nVidia's register combiners. The\n"
674 "OSG::RegisterCombinersChunk::setCombinerRGB and\n"
675 "OSG::RegisterCombinersChunk::setCombinerAlpha convenience functions\n"
676 "should be used,\n"
677 "which set up all the parameters for a single combiner's RGB or alpha part.\n"
678 "OSG::RegisterCombinersChunk::setFinalCombiner sets all parameters for the\n"
679 "final combiner. The constants are set by\n"
680 "OSG::RegisterCombinersChunk::setConstantColors(Color4f &color0, Color4f\n"
681 "&color1) for the gloabl constants and \n"
682 "OSG::RegisterCombinersChunk::setConstantColors(UInt16 which, \n"
683 "Color4f &color0,\n"
684 "Color4f &color1) for the per-combiner constants (if supported). To reset a\n"
685 "combiner one or all of the combiners use\n"
686 "OSG::RegisterCombinersChunk::clearCombiners or \n"
687 "OSG::RegisterCombinersChunk::clearCombiner. \n"
688 "\n"
689 "Don't use the direct field access to set the register combiner's parameter\n"
690 "unlesss you really have to, as the internal representation is a bit\n"
691 "non-intuitive.\n"
692 "\n"
693 "\\ext To reduce the number of fields there isn't a field for every parameter,\n"
694 "instead they are kept in blocks of three in the fields. Please refer to the\n"
695 "source code for details.\n"
696 "\\endext]]>\n"
697 " <Field\n"
698 "\t name=\"color0\"\n"
699 "\t type=\"Color4f\"\n"
700 "\t cardinality=\"single\"\n"
701 "\t visibility=\"external\"\n"
702 "\t access=\"public\"\n"
703 "\t >\n"
704 " </Field>\n"
705 " <Field\n"
706 "\t name=\"color1\"\n"
707 "\t type=\"Color4f\"\n"
708 "\t cardinality=\"single\"\n"
709 "\t visibility=\"external\"\n"
710 "\t access=\"public\"\n"
711 "\t >\n"
712 " </Field>\n"
713 " <Field\n"
714 "\t name=\"colorSumClamp\"\n"
715 "\t type=\"bool\"\n"
716 "\t cardinality=\"single\"\n"
717 "\t visibility=\"external\"\n"
718 "\t defaultValue=\"false\"\n"
719 "\t access=\"public\"\n"
720 "\t >\n"
721 " </Field>\n"
722 " <Field\n"
723 "\t name=\"variableArgb\"\n"
724 "\t type=\"GLenum\"\n"
725 "\t cardinality=\"multi\"\n"
726 "\t visibility=\"external\"\n"
727 "\t access=\"public\"\n"
728 "\t >\n"
729 "\tinput,mapping,component Usage triples for variable A, RGB part\n"
730 " </Field>\n"
731 " <Field\n"
732 "\t name=\"variableBrgb\"\n"
733 "\t type=\"GLenum\"\n"
734 "\t cardinality=\"multi\"\n"
735 "\t visibility=\"external\"\n"
736 "\t access=\"public\"\n"
737 "\t >\n"
738 " </Field>\n"
739 " <Field\n"
740 "\t name=\"variableCrgb\"\n"
741 "\t type=\"GLenum\"\n"
742 "\t cardinality=\"multi\"\n"
743 "\t visibility=\"external\"\n"
744 "\t access=\"public\"\n"
745 "\t >\n"
746 " </Field>\n"
747 " <Field\n"
748 "\t name=\"variableDrgb\"\n"
749 "\t type=\"GLenum\"\n"
750 "\t cardinality=\"multi\"\n"
751 "\t visibility=\"external\"\n"
752 "\t access=\"public\"\n"
753 "\t >\n"
754 " </Field>\n"
755 " <Field\n"
756 "\t name=\"variableAalpha\"\n"
757 "\t type=\"GLenum\"\n"
758 "\t cardinality=\"multi\"\n"
759 "\t visibility=\"external\"\n"
760 "\t access=\"public\"\n"
761 "\t >\n"
762 " </Field>\n"
763 " <Field\n"
764 "\t name=\"variableBalpha\"\n"
765 "\t type=\"GLenum\"\n"
766 "\t cardinality=\"multi\"\n"
767 "\t visibility=\"external\"\n"
768 "\t access=\"public\"\n"
769 "\t >\n"
770 " </Field>\n"
771 " <Field\n"
772 "\t name=\"variableCalpha\"\n"
773 "\t type=\"GLenum\"\n"
774 "\t cardinality=\"multi\"\n"
775 "\t visibility=\"external\"\n"
776 "\t access=\"public\"\n"
777 "\t >\n"
778 " </Field>\n"
779 " <Field\n"
780 "\t name=\"variableDalpha\"\n"
781 "\t type=\"GLenum\"\n"
782 "\t cardinality=\"multi\"\n"
783 "\t visibility=\"external\"\n"
784 "\t access=\"public\"\n"
785 "\t >\n"
786 " </Field>\n"
787 " <Field\n"
788 "\t name=\"outputABrgb\"\n"
789 "\t type=\"GLenum\"\n"
790 "\t cardinality=\"multi\"\n"
791 "\t visibility=\"external\"\n"
792 "\t access=\"public\"\n"
793 "\t >\n"
794 " </Field>\n"
795 " <Field\n"
796 "\t name=\"outputCDrgb\"\n"
797 "\t type=\"GLenum\"\n"
798 "\t cardinality=\"multi\"\n"
799 "\t visibility=\"external\"\n"
800 "\t access=\"public\"\n"
801 "\t >\n"
802 " </Field>\n"
803 " <Field\n"
804 "\t name=\"outputSumrgb\"\n"
805 "\t type=\"GLenum\"\n"
806 "\t cardinality=\"multi\"\n"
807 "\t visibility=\"external\"\n"
808 "\t access=\"public\"\n"
809 "\t >\n"
810 " </Field>\n"
811 " <Field\n"
812 "\t name=\"scalergb\"\n"
813 "\t type=\"GLenum\"\n"
814 "\t cardinality=\"multi\"\n"
815 "\t visibility=\"external\"\n"
816 "\t access=\"public\"\n"
817 "\t >\n"
818 " </Field>\n"
819 " <Field\n"
820 "\t name=\"biasrgb\"\n"
821 "\t type=\"GLenum\"\n"
822 "\t cardinality=\"multi\"\n"
823 "\t visibility=\"external\"\n"
824 "\t access=\"public\"\n"
825 "\t >\n"
826 " </Field>\n"
827 " <Field\n"
828 "\t name=\"outputABalpha\"\n"
829 "\t type=\"GLenum\"\n"
830 "\t cardinality=\"multi\"\n"
831 "\t visibility=\"external\"\n"
832 "\t access=\"public\"\n"
833 "\t >\n"
834 " </Field>\n"
835 " <Field\n"
836 "\t name=\"outputCDalpha\"\n"
837 "\t type=\"GLenum\"\n"
838 "\t cardinality=\"multi\"\n"
839 "\t visibility=\"external\"\n"
840 "\t access=\"public\"\n"
841 "\t >\n"
842 " </Field>\n"
843 " <Field\n"
844 "\t name=\"outputSumalpha\"\n"
845 "\t type=\"GLenum\"\n"
846 "\t cardinality=\"multi\"\n"
847 "\t visibility=\"external\"\n"
848 "\t access=\"public\"\n"
849 "\t >\n"
850 " </Field>\n"
851 " <Field\n"
852 "\t name=\"dotABrgb\"\n"
853 "\t type=\"UInt8\"\n"
854 "\t cardinality=\"multi\"\n"
855 "\t visibility=\"external\"\n"
856 "\t access=\"public\"\n"
857 "\t >\n"
858 " </Field>\n"
859 " <Field\n"
860 "\t name=\"dotCDrgb\"\n"
861 "\t type=\"UInt8\"\n"
862 "\t cardinality=\"multi\"\n"
863 "\t visibility=\"external\"\n"
864 "\t access=\"public\"\n"
865 "\t >\n"
866 " </Field>\n"
867 " <Field\n"
868 "\t name=\"muxSumrgb\"\n"
869 "\t type=\"UInt8\"\n"
870 "\t cardinality=\"multi\"\n"
871 "\t visibility=\"external\"\n"
872 "\t access=\"public\"\n"
873 "\t >\n"
874 " </Field>\n"
875 " <Field\n"
876 "\t name=\"scalealpha\"\n"
877 "\t type=\"GLenum\"\n"
878 "\t cardinality=\"multi\"\n"
879 "\t visibility=\"external\"\n"
880 "\t access=\"public\"\n"
881 "\t >\n"
882 " </Field>\n"
883 " <Field\n"
884 "\t name=\"biasalpha\"\n"
885 "\t type=\"GLenum\"\n"
886 "\t cardinality=\"multi\"\n"
887 "\t visibility=\"external\"\n"
888 "\t access=\"public\"\n"
889 "\t >\n"
890 " </Field>\n"
891 " <Field\n"
892 "\t name=\"muxSumalpha\"\n"
893 "\t type=\"UInt8\"\n"
894 "\t cardinality=\"multi\"\n"
895 "\t visibility=\"external\"\n"
896 "\t access=\"public\"\n"
897 "\t >\n"
898 " </Field>\n"
899 " <Field\n"
900 "\t name=\"variableE\"\n"
901 "\t type=\"GLenum\"\n"
902 "\t cardinality=\"multi\"\n"
903 "\t visibility=\"external\"\n"
904 "\t access=\"public\"\n"
905 "\t >\n"
906 " </Field>\n"
907 " <Field\n"
908 "\t name=\"variableF\"\n"
909 "\t type=\"GLenum\"\n"
910 "\t cardinality=\"multi\"\n"
911 "\t visibility=\"external\"\n"
912 "\t access=\"public\"\n"
913 "\t >\n"
914 " </Field>\n"
915 " <Field\n"
916 "\t name=\"variableG\"\n"
917 "\t type=\"GLenum\"\n"
918 "\t cardinality=\"multi\"\n"
919 "\t visibility=\"external\"\n"
920 "\t access=\"public\"\n"
921 "\t >\n"
922 " </Field>\n"
923 " <Field\n"
924 "\t name=\"combinerColor0\"\n"
925 "\t type=\"Color4f\"\n"
926 "\t cardinality=\"multi\"\n"
927 "\t visibility=\"external\"\n"
928 "\t access=\"public\"\n"
929 "\t >\n"
930 " </Field>\n"
931 " <Field\n"
932 "\t name=\"combinerColor1\"\n"
933 "\t type=\"Color4f\"\n"
934 "\t cardinality=\"multi\"\n"
935 "\t visibility=\"external\"\n"
936 "\t access=\"public\"\n"
937 "\t >\n"
938 " </Field>\n"
939 " <Field\n"
940 "\t name=\"perStageConstants\"\n"
941 "\t type=\"UInt8\"\n"
942 "\t cardinality=\"single\"\n"
943 "\t visibility=\"internal\"\n"
944 "\t access=\"public\"\n"
945 "\t >\n"
946 " </Field>\n"
947 "</FieldContainer>\n",
948 "See \\ref PageSystemRegisterCombinersChunk for a description.\n"
949 "\n"
950 "Try to avoid using this chunk, as it is very non-portable. Using a shader \n"
951 "instead is recommend, and much easier to do.\n"
952 "\n"
953 "This chunk wraps nVidia's register combiners. The\n"
954 "OSG::RegisterCombinersChunk::setCombinerRGB and\n"
955 "OSG::RegisterCombinersChunk::setCombinerAlpha convenience functions\n"
956 "should be used,\n"
957 "which set up all the parameters for a single combiner's RGB or alpha part.\n"
958 "OSG::RegisterCombinersChunk::setFinalCombiner sets all parameters for the\n"
959 "final combiner. The constants are set by\n"
960 "OSG::RegisterCombinersChunk::setConstantColors(Color4f &color0, Color4f\n"
961 "&color1) for the gloabl constants and \n"
962 "OSG::RegisterCombinersChunk::setConstantColors(UInt16 which, \n"
963 "Color4f &color0,\n"
964 "Color4f &color1) for the per-combiner constants (if supported). To reset a\n"
965 "combiner one or all of the combiners use\n"
966 "OSG::RegisterCombinersChunk::clearCombiners or \n"
967 "OSG::RegisterCombinersChunk::clearCombiner. \n"
968 "\n"
969 "Don't use the direct field access to set the register combiner's parameter\n"
970 "unlesss you really have to, as the internal representation is a bit\n"
971 "non-intuitive.\n"
972 "\n"
973 "\\ext To reduce the number of fields there isn't a field for every parameter,\n"
974 "instead they are kept in blocks of three in the fields. Please refer to the\n"
975 "source code for details.\n"
976 "\\endext\n"
977 );
978
979 /*------------------------------ get -----------------------------------*/
980
981 FieldContainerType &RegisterCombinersChunkBase::getType(void)
982 {
983 return _type;
984 }
985
986 const FieldContainerType &RegisterCombinersChunkBase::getType(void) const
987 {
988 return _type;
989 }
990
991 UInt32 RegisterCombinersChunkBase::getContainerSize(void) const
992 {
993 return sizeof(RegisterCombinersChunk);
994 }
995
996 /*------------------------- decorator get ------------------------------*/
997
998
999 SFColor4f *RegisterCombinersChunkBase::editSFColor0(void)
1000 {
1001 editSField(Color0FieldMask);
1002
1003 return &_sfColor0;
1004 }
1005
1006 const SFColor4f *RegisterCombinersChunkBase::getSFColor0(void) const
1007 {
1008 return &_sfColor0;
1009 }
1010
1011
1012 SFColor4f *RegisterCombinersChunkBase::editSFColor1(void)
1013 {
1014 editSField(Color1FieldMask);
1015
1016 return &_sfColor1;
1017 }
1018
1019 const SFColor4f *RegisterCombinersChunkBase::getSFColor1(void) const
1020 {
1021 return &_sfColor1;
1022 }
1023
1024
1025 SFBool *RegisterCombinersChunkBase::editSFColorSumClamp(void)
1026 {
1027 editSField(ColorSumClampFieldMask);
1028
1029 return &_sfColorSumClamp;
1030 }
1031
1032 const SFBool *RegisterCombinersChunkBase::getSFColorSumClamp(void) const
1033 {
1034 return &_sfColorSumClamp;
1035 }
1036
1037
1038 MFGLenum *RegisterCombinersChunkBase::editMFVariableArgb(void)
1039 {
1040 editMField(VariableArgbFieldMask, _mfVariableArgb);
1041
1042 return &_mfVariableArgb;
1043 }
1044
1045 const MFGLenum *RegisterCombinersChunkBase::getMFVariableArgb(void) const
1046 {
1047 return &_mfVariableArgb;
1048 }
1049
1050
1051 MFGLenum *RegisterCombinersChunkBase::editMFVariableBrgb(void)
1052 {
1053 editMField(VariableBrgbFieldMask, _mfVariableBrgb);
1054
1055 return &_mfVariableBrgb;
1056 }
1057
1058 const MFGLenum *RegisterCombinersChunkBase::getMFVariableBrgb(void) const
1059 {
1060 return &_mfVariableBrgb;
1061 }
1062
1063
1064 MFGLenum *RegisterCombinersChunkBase::editMFVariableCrgb(void)
1065 {
1066 editMField(VariableCrgbFieldMask, _mfVariableCrgb);
1067
1068 return &_mfVariableCrgb;
1069 }
1070
1071 const MFGLenum *RegisterCombinersChunkBase::getMFVariableCrgb(void) const
1072 {
1073 return &_mfVariableCrgb;
1074 }
1075
1076
1077 MFGLenum *RegisterCombinersChunkBase::editMFVariableDrgb(void)
1078 {
1079 editMField(VariableDrgbFieldMask, _mfVariableDrgb);
1080
1081 return &_mfVariableDrgb;
1082 }
1083
1084 const MFGLenum *RegisterCombinersChunkBase::getMFVariableDrgb(void) const
1085 {
1086 return &_mfVariableDrgb;
1087 }
1088
1089
1090 MFGLenum *RegisterCombinersChunkBase::editMFVariableAalpha(void)
1091 {
1092 editMField(VariableAalphaFieldMask, _mfVariableAalpha);
1093
1094 return &_mfVariableAalpha;
1095 }
1096
1097 const MFGLenum *RegisterCombinersChunkBase::getMFVariableAalpha(void) const
1098 {
1099 return &_mfVariableAalpha;
1100 }
1101
1102
1103 MFGLenum *RegisterCombinersChunkBase::editMFVariableBalpha(void)
1104 {
1105 editMField(VariableBalphaFieldMask, _mfVariableBalpha);
1106
1107 return &_mfVariableBalpha;
1108 }
1109
1110 const MFGLenum *RegisterCombinersChunkBase::getMFVariableBalpha(void) const
1111 {
1112 return &_mfVariableBalpha;
1113 }
1114
1115
1116 MFGLenum *RegisterCombinersChunkBase::editMFVariableCalpha(void)
1117 {
1118 editMField(VariableCalphaFieldMask, _mfVariableCalpha);
1119
1120 return &_mfVariableCalpha;
1121 }
1122
1123 const MFGLenum *RegisterCombinersChunkBase::getMFVariableCalpha(void) const
1124 {
1125 return &_mfVariableCalpha;
1126 }
1127
1128
1129 MFGLenum *RegisterCombinersChunkBase::editMFVariableDalpha(void)
1130 {
1131 editMField(VariableDalphaFieldMask, _mfVariableDalpha);
1132
1133 return &_mfVariableDalpha;
1134 }
1135
1136 const MFGLenum *RegisterCombinersChunkBase::getMFVariableDalpha(void) const
1137 {
1138 return &_mfVariableDalpha;
1139 }
1140
1141
1142 MFGLenum *RegisterCombinersChunkBase::editMFOutputABrgb(void)
1143 {
1144 editMField(OutputABrgbFieldMask, _mfOutputABrgb);
1145
1146 return &_mfOutputABrgb;
1147 }
1148
1149 const MFGLenum *RegisterCombinersChunkBase::getMFOutputABrgb(void) const
1150 {
1151 return &_mfOutputABrgb;
1152 }
1153
1154
1155 MFGLenum *RegisterCombinersChunkBase::editMFOutputCDrgb(void)
1156 {
1157 editMField(OutputCDrgbFieldMask, _mfOutputCDrgb);
1158
1159 return &_mfOutputCDrgb;
1160 }
1161
1162 const MFGLenum *RegisterCombinersChunkBase::getMFOutputCDrgb(void) const
1163 {
1164 return &_mfOutputCDrgb;
1165 }
1166
1167
1168 MFGLenum *RegisterCombinersChunkBase::editMFOutputSumrgb(void)
1169 {
1170 editMField(OutputSumrgbFieldMask, _mfOutputSumrgb);
1171
1172 return &_mfOutputSumrgb;
1173 }
1174
1175 const MFGLenum *RegisterCombinersChunkBase::getMFOutputSumrgb(void) const
1176 {
1177 return &_mfOutputSumrgb;
1178 }
1179
1180
1181 MFGLenum *RegisterCombinersChunkBase::editMFScalergb(void)
1182 {
1183 editMField(ScalergbFieldMask, _mfScalergb);
1184
1185 return &_mfScalergb;
1186 }
1187
1188 const MFGLenum *RegisterCombinersChunkBase::getMFScalergb(void) const
1189 {
1190 return &_mfScalergb;
1191 }
1192
1193
1194 MFGLenum *RegisterCombinersChunkBase::editMFBiasrgb(void)
1195 {
1196 editMField(BiasrgbFieldMask, _mfBiasrgb);
1197
1198 return &_mfBiasrgb;
1199 }
1200
1201 const MFGLenum *RegisterCombinersChunkBase::getMFBiasrgb(void) const
1202 {
1203 return &_mfBiasrgb;
1204 }
1205
1206
1207 MFGLenum *RegisterCombinersChunkBase::editMFOutputABalpha(void)
1208 {
1209 editMField(OutputABalphaFieldMask, _mfOutputABalpha);
1210
1211 return &_mfOutputABalpha;
1212 }
1213
1214 const MFGLenum *RegisterCombinersChunkBase::getMFOutputABalpha(void) const
1215 {
1216 return &_mfOutputABalpha;
1217 }
1218
1219
1220 MFGLenum *RegisterCombinersChunkBase::editMFOutputCDalpha(void)
1221 {
1222 editMField(OutputCDalphaFieldMask, _mfOutputCDalpha);
1223
1224 return &_mfOutputCDalpha;
1225 }
1226
1227 const MFGLenum *RegisterCombinersChunkBase::getMFOutputCDalpha(void) const
1228 {
1229 return &_mfOutputCDalpha;
1230 }
1231
1232
1233 MFGLenum *RegisterCombinersChunkBase::editMFOutputSumalpha(void)
1234 {
1235 editMField(OutputSumalphaFieldMask, _mfOutputSumalpha);
1236
1237 return &_mfOutputSumalpha;
1238 }
1239
1240 const MFGLenum *RegisterCombinersChunkBase::getMFOutputSumalpha(void) const
1241 {
1242 return &_mfOutputSumalpha;
1243 }
1244
1245
1246 MFUInt8 *RegisterCombinersChunkBase::editMFDotABrgb(void)
1247 {
1248 editMField(DotABrgbFieldMask, _mfDotABrgb);
1249
1250 return &_mfDotABrgb;
1251 }
1252
1253 const MFUInt8 *RegisterCombinersChunkBase::getMFDotABrgb(void) const
1254 {
1255 return &_mfDotABrgb;
1256 }
1257
1258
1259 MFUInt8 *RegisterCombinersChunkBase::editMFDotCDrgb(void)
1260 {
1261 editMField(DotCDrgbFieldMask, _mfDotCDrgb);
1262
1263 return &_mfDotCDrgb;
1264 }
1265
1266 const MFUInt8 *RegisterCombinersChunkBase::getMFDotCDrgb(void) const
1267 {
1268 return &_mfDotCDrgb;
1269 }
1270
1271
1272 MFUInt8 *RegisterCombinersChunkBase::editMFMuxSumrgb(void)
1273 {
1274 editMField(MuxSumrgbFieldMask, _mfMuxSumrgb);
1275
1276 return &_mfMuxSumrgb;
1277 }
1278
1279 const MFUInt8 *RegisterCombinersChunkBase::getMFMuxSumrgb(void) const
1280 {
1281 return &_mfMuxSumrgb;
1282 }
1283
1284
1285 MFGLenum *RegisterCombinersChunkBase::editMFScalealpha(void)
1286 {
1287 editMField(ScalealphaFieldMask, _mfScalealpha);
1288
1289 return &_mfScalealpha;
1290 }
1291
1292 const MFGLenum *RegisterCombinersChunkBase::getMFScalealpha(void) const
1293 {
1294 return &_mfScalealpha;
1295 }
1296
1297
1298 MFGLenum *RegisterCombinersChunkBase::editMFBiasalpha(void)
1299 {
1300 editMField(BiasalphaFieldMask, _mfBiasalpha);
1301
1302 return &_mfBiasalpha;
1303 }
1304
1305 const MFGLenum *RegisterCombinersChunkBase::getMFBiasalpha(void) const
1306 {
1307 return &_mfBiasalpha;
1308 }
1309
1310
1311 MFUInt8 *RegisterCombinersChunkBase::editMFMuxSumalpha(void)
1312 {
1313 editMField(MuxSumalphaFieldMask, _mfMuxSumalpha);
1314
1315 return &_mfMuxSumalpha;
1316 }
1317
1318 const MFUInt8 *RegisterCombinersChunkBase::getMFMuxSumalpha(void) const
1319 {
1320 return &_mfMuxSumalpha;
1321 }
1322
1323
1324 MFGLenum *RegisterCombinersChunkBase::editMFVariableE(void)
1325 {
1326 editMField(VariableEFieldMask, _mfVariableE);
1327
1328 return &_mfVariableE;
1329 }
1330
1331 const MFGLenum *RegisterCombinersChunkBase::getMFVariableE(void) const
1332 {
1333 return &_mfVariableE;
1334 }
1335
1336
1337 MFGLenum *RegisterCombinersChunkBase::editMFVariableF(void)
1338 {
1339 editMField(VariableFFieldMask, _mfVariableF);
1340
1341 return &_mfVariableF;
1342 }
1343
1344 const MFGLenum *RegisterCombinersChunkBase::getMFVariableF(void) const
1345 {
1346 return &_mfVariableF;
1347 }
1348
1349
1350 MFGLenum *RegisterCombinersChunkBase::editMFVariableG(void)
1351 {
1352 editMField(VariableGFieldMask, _mfVariableG);
1353
1354 return &_mfVariableG;
1355 }
1356
1357 const MFGLenum *RegisterCombinersChunkBase::getMFVariableG(void) const
1358 {
1359 return &_mfVariableG;
1360 }
1361
1362
1363 MFColor4f *RegisterCombinersChunkBase::editMFCombinerColor0(void)
1364 {
1365 editMField(CombinerColor0FieldMask, _mfCombinerColor0);
1366
1367 return &_mfCombinerColor0;
1368 }
1369
1370 const MFColor4f *RegisterCombinersChunkBase::getMFCombinerColor0(void) const
1371 {
1372 return &_mfCombinerColor0;
1373 }
1374
1375
1376 MFColor4f *RegisterCombinersChunkBase::editMFCombinerColor1(void)
1377 {
1378 editMField(CombinerColor1FieldMask, _mfCombinerColor1);
1379
1380 return &_mfCombinerColor1;
1381 }
1382
1383 const MFColor4f *RegisterCombinersChunkBase::getMFCombinerColor1(void) const
1384 {
1385 return &_mfCombinerColor1;
1386 }
1387
1388
1389 SFUInt8 *RegisterCombinersChunkBase::editSFPerStageConstants(void)
1390 {
1391 editSField(PerStageConstantsFieldMask);
1392
1393 return &_sfPerStageConstants;
1394 }
1395
1396 const SFUInt8 *RegisterCombinersChunkBase::getSFPerStageConstants(void) const
1397 {
1398 return &_sfPerStageConstants;
1399 }
1400
1401
1402
1403
1404
1405
1406 /*------------------------------ access -----------------------------------*/
1407
1408 SizeT RegisterCombinersChunkBase::getBinSize(ConstFieldMaskArg whichField)
1409 {
1410 SizeT returnValue = Inherited::getBinSize(whichField);
1411
1412 if(FieldBits::NoField != (Color0FieldMask & whichField))
1413 {
1414 returnValue += _sfColor0.getBinSize();
1415 }
1416 if(FieldBits::NoField != (Color1FieldMask & whichField))
1417 {
1418 returnValue += _sfColor1.getBinSize();
1419 }
1420 if(FieldBits::NoField != (ColorSumClampFieldMask & whichField))
1421 {
1422 returnValue += _sfColorSumClamp.getBinSize();
1423 }
1424 if(FieldBits::NoField != (VariableArgbFieldMask & whichField))
1425 {
1426 returnValue += _mfVariableArgb.getBinSize();
1427 }
1428 if(FieldBits::NoField != (VariableBrgbFieldMask & whichField))
1429 {
1430 returnValue += _mfVariableBrgb.getBinSize();
1431 }
1432 if(FieldBits::NoField != (VariableCrgbFieldMask & whichField))
1433 {
1434 returnValue += _mfVariableCrgb.getBinSize();
1435 }
1436 if(FieldBits::NoField != (VariableDrgbFieldMask & whichField))
1437 {
1438 returnValue += _mfVariableDrgb.getBinSize();
1439 }
1440 if(FieldBits::NoField != (VariableAalphaFieldMask & whichField))
1441 {
1442 returnValue += _mfVariableAalpha.getBinSize();
1443 }
1444 if(FieldBits::NoField != (VariableBalphaFieldMask & whichField))
1445 {
1446 returnValue += _mfVariableBalpha.getBinSize();
1447 }
1448 if(FieldBits::NoField != (VariableCalphaFieldMask & whichField))
1449 {
1450 returnValue += _mfVariableCalpha.getBinSize();
1451 }
1452 if(FieldBits::NoField != (VariableDalphaFieldMask & whichField))
1453 {
1454 returnValue += _mfVariableDalpha.getBinSize();
1455 }
1456 if(FieldBits::NoField != (OutputABrgbFieldMask & whichField))
1457 {
1458 returnValue += _mfOutputABrgb.getBinSize();
1459 }
1460 if(FieldBits::NoField != (OutputCDrgbFieldMask & whichField))
1461 {
1462 returnValue += _mfOutputCDrgb.getBinSize();
1463 }
1464 if(FieldBits::NoField != (OutputSumrgbFieldMask & whichField))
1465 {
1466 returnValue += _mfOutputSumrgb.getBinSize();
1467 }
1468 if(FieldBits::NoField != (ScalergbFieldMask & whichField))
1469 {
1470 returnValue += _mfScalergb.getBinSize();
1471 }
1472 if(FieldBits::NoField != (BiasrgbFieldMask & whichField))
1473 {
1474 returnValue += _mfBiasrgb.getBinSize();
1475 }
1476 if(FieldBits::NoField != (OutputABalphaFieldMask & whichField))
1477 {
1478 returnValue += _mfOutputABalpha.getBinSize();
1479 }
1480 if(FieldBits::NoField != (OutputCDalphaFieldMask & whichField))
1481 {
1482 returnValue += _mfOutputCDalpha.getBinSize();
1483 }
1484 if(FieldBits::NoField != (OutputSumalphaFieldMask & whichField))
1485 {
1486 returnValue += _mfOutputSumalpha.getBinSize();
1487 }
1488 if(FieldBits::NoField != (DotABrgbFieldMask & whichField))
1489 {
1490 returnValue += _mfDotABrgb.getBinSize();
1491 }
1492 if(FieldBits::NoField != (DotCDrgbFieldMask & whichField))
1493 {
1494 returnValue += _mfDotCDrgb.getBinSize();
1495 }
1496 if(FieldBits::NoField != (MuxSumrgbFieldMask & whichField))
1497 {
1498 returnValue += _mfMuxSumrgb.getBinSize();
1499 }
1500 if(FieldBits::NoField != (ScalealphaFieldMask & whichField))
1501 {
1502 returnValue += _mfScalealpha.getBinSize();
1503 }
1504 if(FieldBits::NoField != (BiasalphaFieldMask & whichField))
1505 {
1506 returnValue += _mfBiasalpha.getBinSize();
1507 }
1508 if(FieldBits::NoField != (MuxSumalphaFieldMask & whichField))
1509 {
1510 returnValue += _mfMuxSumalpha.getBinSize();
1511 }
1512 if(FieldBits::NoField != (VariableEFieldMask & whichField))
1513 {
1514 returnValue += _mfVariableE.getBinSize();
1515 }
1516 if(FieldBits::NoField != (VariableFFieldMask & whichField))
1517 {
1518 returnValue += _mfVariableF.getBinSize();
1519 }
1520 if(FieldBits::NoField != (VariableGFieldMask & whichField))
1521 {
1522 returnValue += _mfVariableG.getBinSize();
1523 }
1524 if(FieldBits::NoField != (CombinerColor0FieldMask & whichField))
1525 {
1526 returnValue += _mfCombinerColor0.getBinSize();
1527 }
1528 if(FieldBits::NoField != (CombinerColor1FieldMask & whichField))
1529 {
1530 returnValue += _mfCombinerColor1.getBinSize();
1531 }
1532 if(FieldBits::NoField != (PerStageConstantsFieldMask & whichField))
1533 {
1534 returnValue += _sfPerStageConstants.getBinSize();
1535 }
1536
1537 return returnValue;
1538 }
1539
1540 void RegisterCombinersChunkBase::copyToBin(BinaryDataHandler &pMem,
1541 ConstFieldMaskArg whichField)
1542 {
1543 Inherited::copyToBin(pMem, whichField);
1544
1545 if(FieldBits::NoField != (Color0FieldMask & whichField))
1546 {
1547 _sfColor0.copyToBin(pMem);
1548 }
1549 if(FieldBits::NoField != (Color1FieldMask & whichField))
1550 {
1551 _sfColor1.copyToBin(pMem);
1552 }
1553 if(FieldBits::NoField != (ColorSumClampFieldMask & whichField))
1554 {
1555 _sfColorSumClamp.copyToBin(pMem);
1556 }
1557 if(FieldBits::NoField != (VariableArgbFieldMask & whichField))
1558 {
1559 _mfVariableArgb.copyToBin(pMem);
1560 }
1561 if(FieldBits::NoField != (VariableBrgbFieldMask & whichField))
1562 {
1563 _mfVariableBrgb.copyToBin(pMem);
1564 }
1565 if(FieldBits::NoField != (VariableCrgbFieldMask & whichField))
1566 {
1567 _mfVariableCrgb.copyToBin(pMem);
1568 }
1569 if(FieldBits::NoField != (VariableDrgbFieldMask & whichField))
1570 {
1571 _mfVariableDrgb.copyToBin(pMem);
1572 }
1573 if(FieldBits::NoField != (VariableAalphaFieldMask & whichField))
1574 {
1575 _mfVariableAalpha.copyToBin(pMem);
1576 }
1577 if(FieldBits::NoField != (VariableBalphaFieldMask & whichField))
1578 {
1579 _mfVariableBalpha.copyToBin(pMem);
1580 }
1581 if(FieldBits::NoField != (VariableCalphaFieldMask & whichField))
1582 {
1583 _mfVariableCalpha.copyToBin(pMem);
1584 }
1585 if(FieldBits::NoField != (VariableDalphaFieldMask & whichField))
1586 {
1587 _mfVariableDalpha.copyToBin(pMem);
1588 }
1589 if(FieldBits::NoField != (OutputABrgbFieldMask & whichField))
1590 {
1591 _mfOutputABrgb.copyToBin(pMem);
1592 }
1593 if(FieldBits::NoField != (OutputCDrgbFieldMask & whichField))
1594 {
1595 _mfOutputCDrgb.copyToBin(pMem);
1596 }
1597 if(FieldBits::NoField != (OutputSumrgbFieldMask & whichField))
1598 {
1599 _mfOutputSumrgb.copyToBin(pMem);
1600 }
1601 if(FieldBits::NoField != (ScalergbFieldMask & whichField))
1602 {
1603 _mfScalergb.copyToBin(pMem);
1604 }
1605 if(FieldBits::NoField != (BiasrgbFieldMask & whichField))
1606 {
1607 _mfBiasrgb.copyToBin(pMem);
1608 }
1609 if(FieldBits::NoField != (OutputABalphaFieldMask & whichField))
1610 {
1611 _mfOutputABalpha.copyToBin(pMem);
1612 }
1613 if(FieldBits::NoField != (OutputCDalphaFieldMask & whichField))
1614 {
1615 _mfOutputCDalpha.copyToBin(pMem);
1616 }
1617 if(FieldBits::NoField != (OutputSumalphaFieldMask & whichField))
1618 {
1619 _mfOutputSumalpha.copyToBin(pMem);
1620 }
1621 if(FieldBits::NoField != (DotABrgbFieldMask & whichField))
1622 {
1623 _mfDotABrgb.copyToBin(pMem);
1624 }
1625 if(FieldBits::NoField != (DotCDrgbFieldMask & whichField))
1626 {
1627 _mfDotCDrgb.copyToBin(pMem);
1628 }
1629 if(FieldBits::NoField != (MuxSumrgbFieldMask & whichField))
1630 {
1631 _mfMuxSumrgb.copyToBin(pMem);
1632 }
1633 if(FieldBits::NoField != (ScalealphaFieldMask & whichField))
1634 {
1635 _mfScalealpha.copyToBin(pMem);
1636 }
1637 if(FieldBits::NoField != (BiasalphaFieldMask & whichField))
1638 {
1639 _mfBiasalpha.copyToBin(pMem);
1640 }
1641 if(FieldBits::NoField != (MuxSumalphaFieldMask & whichField))
1642 {
1643 _mfMuxSumalpha.copyToBin(pMem);
1644 }
1645 if(FieldBits::NoField != (VariableEFieldMask & whichField))
1646 {
1647 _mfVariableE.copyToBin(pMem);
1648 }
1649 if(FieldBits::NoField != (VariableFFieldMask & whichField))
1650 {
1651 _mfVariableF.copyToBin(pMem);
1652 }
1653 if(FieldBits::NoField != (VariableGFieldMask & whichField))
1654 {
1655 _mfVariableG.copyToBin(pMem);
1656 }
1657 if(FieldBits::NoField != (CombinerColor0FieldMask & whichField))
1658 {
1659 _mfCombinerColor0.copyToBin(pMem);
1660 }
1661 if(FieldBits::NoField != (CombinerColor1FieldMask & whichField))
1662 {
1663 _mfCombinerColor1.copyToBin(pMem);
1664 }
1665 if(FieldBits::NoField != (PerStageConstantsFieldMask & whichField))
1666 {
1667 _sfPerStageConstants.copyToBin(pMem);
1668 }
1669 }
1670
1671 void RegisterCombinersChunkBase::copyFromBin(BinaryDataHandler &pMem,
1672 ConstFieldMaskArg whichField)
1673 {
1674 Inherited::copyFromBin(pMem, whichField);
1675
1676 if(FieldBits::NoField != (Color0FieldMask & whichField))
1677 {
1678 editSField(Color0FieldMask);
1679 _sfColor0.copyFromBin(pMem);
1680 }
1681 if(FieldBits::NoField != (Color1FieldMask & whichField))
1682 {
1683 editSField(Color1FieldMask);
1684 _sfColor1.copyFromBin(pMem);
1685 }
1686 if(FieldBits::NoField != (ColorSumClampFieldMask & whichField))
1687 {
1688 editSField(ColorSumClampFieldMask);
1689 _sfColorSumClamp.copyFromBin(pMem);
1690 }
1691 if(FieldBits::NoField != (VariableArgbFieldMask & whichField))
1692 {
1693 editMField(VariableArgbFieldMask, _mfVariableArgb);
1694 _mfVariableArgb.copyFromBin(pMem);
1695 }
1696 if(FieldBits::NoField != (VariableBrgbFieldMask & whichField))
1697 {
1698 editMField(VariableBrgbFieldMask, _mfVariableBrgb);
1699 _mfVariableBrgb.copyFromBin(pMem);
1700 }
1701 if(FieldBits::NoField != (VariableCrgbFieldMask & whichField))
1702 {
1703 editMField(VariableCrgbFieldMask, _mfVariableCrgb);
1704 _mfVariableCrgb.copyFromBin(pMem);
1705 }
1706 if(FieldBits::NoField != (VariableDrgbFieldMask & whichField))
1707 {
1708 editMField(VariableDrgbFieldMask, _mfVariableDrgb);
1709 _mfVariableDrgb.copyFromBin(pMem);
1710 }
1711 if(FieldBits::NoField != (VariableAalphaFieldMask & whichField))
1712 {
1713 editMField(VariableAalphaFieldMask, _mfVariableAalpha);
1714 _mfVariableAalpha.copyFromBin(pMem);
1715 }
1716 if(FieldBits::NoField != (VariableBalphaFieldMask & whichField))
1717 {
1718 editMField(VariableBalphaFieldMask, _mfVariableBalpha);
1719 _mfVariableBalpha.copyFromBin(pMem);
1720 }
1721 if(FieldBits::NoField != (VariableCalphaFieldMask & whichField))
1722 {
1723 editMField(VariableCalphaFieldMask, _mfVariableCalpha);
1724 _mfVariableCalpha.copyFromBin(pMem);
1725 }
1726 if(FieldBits::NoField != (VariableDalphaFieldMask & whichField))
1727 {
1728 editMField(VariableDalphaFieldMask, _mfVariableDalpha);
1729 _mfVariableDalpha.copyFromBin(pMem);
1730 }
1731 if(FieldBits::NoField != (OutputABrgbFieldMask & whichField))
1732 {
1733 editMField(OutputABrgbFieldMask, _mfOutputABrgb);
1734 _mfOutputABrgb.copyFromBin(pMem);
1735 }
1736 if(FieldBits::NoField != (OutputCDrgbFieldMask & whichField))
1737 {
1738 editMField(OutputCDrgbFieldMask, _mfOutputCDrgb);
1739 _mfOutputCDrgb.copyFromBin(pMem);
1740 }
1741 if(FieldBits::NoField != (OutputSumrgbFieldMask & whichField))
1742 {
1743 editMField(OutputSumrgbFieldMask, _mfOutputSumrgb);
1744 _mfOutputSumrgb.copyFromBin(pMem);
1745 }
1746 if(FieldBits::NoField != (ScalergbFieldMask & whichField))
1747 {
1748 editMField(ScalergbFieldMask, _mfScalergb);
1749 _mfScalergb.copyFromBin(pMem);
1750 }
1751 if(FieldBits::NoField != (BiasrgbFieldMask & whichField))
1752 {
1753 editMField(BiasrgbFieldMask, _mfBiasrgb);
1754 _mfBiasrgb.copyFromBin(pMem);
1755 }
1756 if(FieldBits::NoField != (OutputABalphaFieldMask & whichField))
1757 {
1758 editMField(OutputABalphaFieldMask, _mfOutputABalpha);
1759 _mfOutputABalpha.copyFromBin(pMem);
1760 }
1761 if(FieldBits::NoField != (OutputCDalphaFieldMask & whichField))
1762 {
1763 editMField(OutputCDalphaFieldMask, _mfOutputCDalpha);
1764 _mfOutputCDalpha.copyFromBin(pMem);
1765 }
1766 if(FieldBits::NoField != (OutputSumalphaFieldMask & whichField))
1767 {
1768 editMField(OutputSumalphaFieldMask, _mfOutputSumalpha);
1769 _mfOutputSumalpha.copyFromBin(pMem);
1770 }
1771 if(FieldBits::NoField != (DotABrgbFieldMask & whichField))
1772 {
1773 editMField(DotABrgbFieldMask, _mfDotABrgb);
1774 _mfDotABrgb.copyFromBin(pMem);
1775 }
1776 if(FieldBits::NoField != (DotCDrgbFieldMask & whichField))
1777 {
1778 editMField(DotCDrgbFieldMask, _mfDotCDrgb);
1779 _mfDotCDrgb.copyFromBin(pMem);
1780 }
1781 if(FieldBits::NoField != (MuxSumrgbFieldMask & whichField))
1782 {
1783 editMField(MuxSumrgbFieldMask, _mfMuxSumrgb);
1784 _mfMuxSumrgb.copyFromBin(pMem);
1785 }
1786 if(FieldBits::NoField != (ScalealphaFieldMask & whichField))
1787 {
1788 editMField(ScalealphaFieldMask, _mfScalealpha);
1789 _mfScalealpha.copyFromBin(pMem);
1790 }
1791 if(FieldBits::NoField != (BiasalphaFieldMask & whichField))
1792 {
1793 editMField(BiasalphaFieldMask, _mfBiasalpha);
1794 _mfBiasalpha.copyFromBin(pMem);
1795 }
1796 if(FieldBits::NoField != (MuxSumalphaFieldMask & whichField))
1797 {
1798 editMField(MuxSumalphaFieldMask, _mfMuxSumalpha);
1799 _mfMuxSumalpha.copyFromBin(pMem);
1800 }
1801 if(FieldBits::NoField != (VariableEFieldMask & whichField))
1802 {
1803 editMField(VariableEFieldMask, _mfVariableE);
1804 _mfVariableE.copyFromBin(pMem);
1805 }
1806 if(FieldBits::NoField != (VariableFFieldMask & whichField))
1807 {
1808 editMField(VariableFFieldMask, _mfVariableF);
1809 _mfVariableF.copyFromBin(pMem);
1810 }
1811 if(FieldBits::NoField != (VariableGFieldMask & whichField))
1812 {
1813 editMField(VariableGFieldMask, _mfVariableG);
1814 _mfVariableG.copyFromBin(pMem);
1815 }
1816 if(FieldBits::NoField != (CombinerColor0FieldMask & whichField))
1817 {
1818 editMField(CombinerColor0FieldMask, _mfCombinerColor0);
1819 _mfCombinerColor0.copyFromBin(pMem);
1820 }
1821 if(FieldBits::NoField != (CombinerColor1FieldMask & whichField))
1822 {
1823 editMField(CombinerColor1FieldMask, _mfCombinerColor1);
1824 _mfCombinerColor1.copyFromBin(pMem);
1825 }
1826 if(FieldBits::NoField != (PerStageConstantsFieldMask & whichField))
1827 {
1828 editSField(PerStageConstantsFieldMask);
1829 _sfPerStageConstants.copyFromBin(pMem);
1830 }
1831 }
1832
1833 //! create a new instance of the class
1834 RegisterCombinersChunkTransitPtr RegisterCombinersChunkBase::createLocal(BitVector bFlags)
1835 {
1836 RegisterCombinersChunkTransitPtr fc;
1837
1838 if(getClassType().getPrototype() != NULL)
1839 {
1840 FieldContainerTransitPtr tmpPtr =
1841 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
1842
1843 fc = dynamic_pointer_cast<RegisterCombinersChunk>(tmpPtr);
1844 }
1845
1846 return fc;
1847 }
1848
1849 //! create a new instance of the class, copy the container flags
1850 RegisterCombinersChunkTransitPtr RegisterCombinersChunkBase::createDependent(BitVector bFlags)
1851 {
1852 RegisterCombinersChunkTransitPtr fc;
1853
1854 if(getClassType().getPrototype() != NULL)
1855 {
1856 FieldContainerTransitPtr tmpPtr =
1857 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
1858
1859 fc = dynamic_pointer_cast<RegisterCombinersChunk>(tmpPtr);
1860 }
1861
1862 return fc;
1863 }
1864
1865 //! create a new instance of the class
1866 RegisterCombinersChunkTransitPtr RegisterCombinersChunkBase::create(void)
1867 {
1868 RegisterCombinersChunkTransitPtr fc;
1869
1870 if(getClassType().getPrototype() != NULL)
1871 {
1872 FieldContainerTransitPtr tmpPtr =
1873 getClassType().getPrototype()-> shallowCopy();
1874
1875 fc = dynamic_pointer_cast<RegisterCombinersChunk>(tmpPtr);
1876 }
1877
1878 return fc;
1879 }
1880
1881 RegisterCombinersChunk *RegisterCombinersChunkBase::createEmptyLocal(BitVector bFlags)
1882 {
1883 RegisterCombinersChunk *returnValue;
1884
1885 newPtr<RegisterCombinersChunk>(returnValue, bFlags);
1886
1887 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1888
1889 return returnValue;
1890 }
1891
1892 //! create an empty new instance of the class, do not copy the prototype
1893 RegisterCombinersChunk *RegisterCombinersChunkBase::createEmpty(void)
1894 {
1895 RegisterCombinersChunk *returnValue;
1896
1897 newPtr<RegisterCombinersChunk>(returnValue, Thread::getCurrentLocalFlags());
1898
1899 returnValue->_pFieldFlags->_bNamespaceMask &=
1900 ~Thread::getCurrentLocalFlags();
1901
1902 return returnValue;
1903 }
1904
1905
1906 FieldContainerTransitPtr RegisterCombinersChunkBase::shallowCopyLocal(
1907 BitVector bFlags) const
1908 {
1909 RegisterCombinersChunk *tmpPtr;
1910
1911 newPtr(tmpPtr, dynamic_cast<const RegisterCombinersChunk *>(this), bFlags);
1912
1913 FieldContainerTransitPtr returnValue(tmpPtr);
1914
1915 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1916
1917 return returnValue;
1918 }
1919
1920 FieldContainerTransitPtr RegisterCombinersChunkBase::shallowCopyDependent(
1921 BitVector bFlags) const
1922 {
1923 RegisterCombinersChunk *tmpPtr;
1924
1925 newPtr(tmpPtr, dynamic_cast<const RegisterCombinersChunk *>(this), ~bFlags);
1926
1927 FieldContainerTransitPtr returnValue(tmpPtr);
1928
1929 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
1930
1931 return returnValue;
1932 }
1933
1934 FieldContainerTransitPtr RegisterCombinersChunkBase::shallowCopy(void) const
1935 {
1936 RegisterCombinersChunk *tmpPtr;
1937
1938 newPtr(tmpPtr,
1939 dynamic_cast<const RegisterCombinersChunk *>(this),
1940 Thread::getCurrentLocalFlags());
1941
1942 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
1943
1944 FieldContainerTransitPtr returnValue(tmpPtr);
1945
1946 return returnValue;
1947 }
1948
1949
1950
1951
1952 /*------------------------- constructors ----------------------------------*/
1953
1954 RegisterCombinersChunkBase::RegisterCombinersChunkBase(void) :
1955 Inherited(),
1956 _sfColor0 (),
1957 _sfColor1 (),
1958 _sfColorSumClamp (bool(false)),
1959 _mfVariableArgb (),
1960 _mfVariableBrgb (),
1961 _mfVariableCrgb (),
1962 _mfVariableDrgb (),
1963 _mfVariableAalpha (),
1964 _mfVariableBalpha (),
1965 _mfVariableCalpha (),
1966 _mfVariableDalpha (),
1967 _mfOutputABrgb (),
1968 _mfOutputCDrgb (),
1969 _mfOutputSumrgb (),
1970 _mfScalergb (),
1971 _mfBiasrgb (),
1972 _mfOutputABalpha (),
1973 _mfOutputCDalpha (),
1974 _mfOutputSumalpha (),
1975 _mfDotABrgb (),
1976 _mfDotCDrgb (),
1977 _mfMuxSumrgb (),
1978 _mfScalealpha (),
1979 _mfBiasalpha (),
1980 _mfMuxSumalpha (),
1981 _mfVariableE (),
1982 _mfVariableF (),
1983 _mfVariableG (),
1984 _mfCombinerColor0 (),
1985 _mfCombinerColor1 (),
1986 _sfPerStageConstants ()
1987 {
1988 }
1989
1990 RegisterCombinersChunkBase::RegisterCombinersChunkBase(const RegisterCombinersChunkBase &source) :
1991 Inherited(source),
1992 _sfColor0 (source._sfColor0 ),
1993 _sfColor1 (source._sfColor1 ),
1994 _sfColorSumClamp (source._sfColorSumClamp ),
1995 _mfVariableArgb (source._mfVariableArgb ),
1996 _mfVariableBrgb (source._mfVariableBrgb ),
1997 _mfVariableCrgb (source._mfVariableCrgb ),
1998 _mfVariableDrgb (source._mfVariableDrgb ),
1999 _mfVariableAalpha (source._mfVariableAalpha ),
2000 _mfVariableBalpha (source._mfVariableBalpha ),
2001 _mfVariableCalpha (source._mfVariableCalpha ),
2002 _mfVariableDalpha (source._mfVariableDalpha ),
2003 _mfOutputABrgb (source._mfOutputABrgb ),
2004 _mfOutputCDrgb (source._mfOutputCDrgb ),
2005 _mfOutputSumrgb (source._mfOutputSumrgb ),
2006 _mfScalergb (source._mfScalergb ),
2007 _mfBiasrgb (source._mfBiasrgb ),
2008 _mfOutputABalpha (source._mfOutputABalpha ),
2009 _mfOutputCDalpha (source._mfOutputCDalpha ),
2010 _mfOutputSumalpha (source._mfOutputSumalpha ),
2011 _mfDotABrgb (source._mfDotABrgb ),
2012 _mfDotCDrgb (source._mfDotCDrgb ),
2013 _mfMuxSumrgb (source._mfMuxSumrgb ),
2014 _mfScalealpha (source._mfScalealpha ),
2015 _mfBiasalpha (source._mfBiasalpha ),
2016 _mfMuxSumalpha (source._mfMuxSumalpha ),
2017 _mfVariableE (source._mfVariableE ),
2018 _mfVariableF (source._mfVariableF ),
2019 _mfVariableG (source._mfVariableG ),
2020 _mfCombinerColor0 (source._mfCombinerColor0 ),
2021 _mfCombinerColor1 (source._mfCombinerColor1 ),
2022 _sfPerStageConstants (source._sfPerStageConstants )
2023 {
2024 }
2025
2026
2027 /*-------------------------- destructors ----------------------------------*/
2028
2029 RegisterCombinersChunkBase::~RegisterCombinersChunkBase(void)
2030 {
2031 }
2032
2033
2034 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleColor0 (void) const
2035 {
2036 SFColor4f::GetHandlePtr returnValue(
2037 new SFColor4f::GetHandle(
2038 &_sfColor0,
2039 this->getType().getFieldDesc(Color0FieldId),
2040 const_cast<RegisterCombinersChunkBase *>(this)));
2041
2042 return returnValue;
2043 }
2044
2045 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleColor0 (void)
2046 {
2047 SFColor4f::EditHandlePtr returnValue(
2048 new SFColor4f::EditHandle(
2049 &_sfColor0,
2050 this->getType().getFieldDesc(Color0FieldId),
2051 this));
2052
2053
2054 editSField(Color0FieldMask);
2055
2056 return returnValue;
2057 }
2058
2059 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleColor1 (void) const
2060 {
2061 SFColor4f::GetHandlePtr returnValue(
2062 new SFColor4f::GetHandle(
2063 &_sfColor1,
2064 this->getType().getFieldDesc(Color1FieldId),
2065 const_cast<RegisterCombinersChunkBase *>(this)));
2066
2067 return returnValue;
2068 }
2069
2070 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleColor1 (void)
2071 {
2072 SFColor4f::EditHandlePtr returnValue(
2073 new SFColor4f::EditHandle(
2074 &_sfColor1,
2075 this->getType().getFieldDesc(Color1FieldId),
2076 this));
2077
2078
2079 editSField(Color1FieldMask);
2080
2081 return returnValue;
2082 }
2083
2084 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleColorSumClamp (void) const
2085 {
2086 SFBool::GetHandlePtr returnValue(
2087 new SFBool::GetHandle(
2088 &_sfColorSumClamp,
2089 this->getType().getFieldDesc(ColorSumClampFieldId),
2090 const_cast<RegisterCombinersChunkBase *>(this)));
2091
2092 return returnValue;
2093 }
2094
2095 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleColorSumClamp (void)
2096 {
2097 SFBool::EditHandlePtr returnValue(
2098 new SFBool::EditHandle(
2099 &_sfColorSumClamp,
2100 this->getType().getFieldDesc(ColorSumClampFieldId),
2101 this));
2102
2103
2104 editSField(ColorSumClampFieldMask);
2105
2106 return returnValue;
2107 }
2108
2109 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableArgb (void) const
2110 {
2111 MFGLenum::GetHandlePtr returnValue(
2112 new MFGLenum::GetHandle(
2113 &_mfVariableArgb,
2114 this->getType().getFieldDesc(VariableArgbFieldId),
2115 const_cast<RegisterCombinersChunkBase *>(this)));
2116
2117 return returnValue;
2118 }
2119
2120 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableArgb (void)
2121 {
2122 MFGLenum::EditHandlePtr returnValue(
2123 new MFGLenum::EditHandle(
2124 &_mfVariableArgb,
2125 this->getType().getFieldDesc(VariableArgbFieldId),
2126 this));
2127
2128
2129 editMField(VariableArgbFieldMask, _mfVariableArgb);
2130
2131 return returnValue;
2132 }
2133
2134 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableBrgb (void) const
2135 {
2136 MFGLenum::GetHandlePtr returnValue(
2137 new MFGLenum::GetHandle(
2138 &_mfVariableBrgb,
2139 this->getType().getFieldDesc(VariableBrgbFieldId),
2140 const_cast<RegisterCombinersChunkBase *>(this)));
2141
2142 return returnValue;
2143 }
2144
2145 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableBrgb (void)
2146 {
2147 MFGLenum::EditHandlePtr returnValue(
2148 new MFGLenum::EditHandle(
2149 &_mfVariableBrgb,
2150 this->getType().getFieldDesc(VariableBrgbFieldId),
2151 this));
2152
2153
2154 editMField(VariableBrgbFieldMask, _mfVariableBrgb);
2155
2156 return returnValue;
2157 }
2158
2159 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableCrgb (void) const
2160 {
2161 MFGLenum::GetHandlePtr returnValue(
2162 new MFGLenum::GetHandle(
2163 &_mfVariableCrgb,
2164 this->getType().getFieldDesc(VariableCrgbFieldId),
2165 const_cast<RegisterCombinersChunkBase *>(this)));
2166
2167 return returnValue;
2168 }
2169
2170 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableCrgb (void)
2171 {
2172 MFGLenum::EditHandlePtr returnValue(
2173 new MFGLenum::EditHandle(
2174 &_mfVariableCrgb,
2175 this->getType().getFieldDesc(VariableCrgbFieldId),
2176 this));
2177
2178
2179 editMField(VariableCrgbFieldMask, _mfVariableCrgb);
2180
2181 return returnValue;
2182 }
2183
2184 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableDrgb (void) const
2185 {
2186 MFGLenum::GetHandlePtr returnValue(
2187 new MFGLenum::GetHandle(
2188 &_mfVariableDrgb,
2189 this->getType().getFieldDesc(VariableDrgbFieldId),
2190 const_cast<RegisterCombinersChunkBase *>(this)));
2191
2192 return returnValue;
2193 }
2194
2195 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableDrgb (void)
2196 {
2197 MFGLenum::EditHandlePtr returnValue(
2198 new MFGLenum::EditHandle(
2199 &_mfVariableDrgb,
2200 this->getType().getFieldDesc(VariableDrgbFieldId),
2201 this));
2202
2203
2204 editMField(VariableDrgbFieldMask, _mfVariableDrgb);
2205
2206 return returnValue;
2207 }
2208
2209 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableAalpha (void) const
2210 {
2211 MFGLenum::GetHandlePtr returnValue(
2212 new MFGLenum::GetHandle(
2213 &_mfVariableAalpha,
2214 this->getType().getFieldDesc(VariableAalphaFieldId),
2215 const_cast<RegisterCombinersChunkBase *>(this)));
2216
2217 return returnValue;
2218 }
2219
2220 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableAalpha (void)
2221 {
2222 MFGLenum::EditHandlePtr returnValue(
2223 new MFGLenum::EditHandle(
2224 &_mfVariableAalpha,
2225 this->getType().getFieldDesc(VariableAalphaFieldId),
2226 this));
2227
2228
2229 editMField(VariableAalphaFieldMask, _mfVariableAalpha);
2230
2231 return returnValue;
2232 }
2233
2234 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableBalpha (void) const
2235 {
2236 MFGLenum::GetHandlePtr returnValue(
2237 new MFGLenum::GetHandle(
2238 &_mfVariableBalpha,
2239 this->getType().getFieldDesc(VariableBalphaFieldId),
2240 const_cast<RegisterCombinersChunkBase *>(this)));
2241
2242 return returnValue;
2243 }
2244
2245 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableBalpha (void)
2246 {
2247 MFGLenum::EditHandlePtr returnValue(
2248 new MFGLenum::EditHandle(
2249 &_mfVariableBalpha,
2250 this->getType().getFieldDesc(VariableBalphaFieldId),
2251 this));
2252
2253
2254 editMField(VariableBalphaFieldMask, _mfVariableBalpha);
2255
2256 return returnValue;
2257 }
2258
2259 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableCalpha (void) const
2260 {
2261 MFGLenum::GetHandlePtr returnValue(
2262 new MFGLenum::GetHandle(
2263 &_mfVariableCalpha,
2264 this->getType().getFieldDesc(VariableCalphaFieldId),
2265 const_cast<RegisterCombinersChunkBase *>(this)));
2266
2267 return returnValue;
2268 }
2269
2270 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableCalpha (void)
2271 {
2272 MFGLenum::EditHandlePtr returnValue(
2273 new MFGLenum::EditHandle(
2274 &_mfVariableCalpha,
2275 this->getType().getFieldDesc(VariableCalphaFieldId),
2276 this));
2277
2278
2279 editMField(VariableCalphaFieldMask, _mfVariableCalpha);
2280
2281 return returnValue;
2282 }
2283
2284 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableDalpha (void) const
2285 {
2286 MFGLenum::GetHandlePtr returnValue(
2287 new MFGLenum::GetHandle(
2288 &_mfVariableDalpha,
2289 this->getType().getFieldDesc(VariableDalphaFieldId),
2290 const_cast<RegisterCombinersChunkBase *>(this)));
2291
2292 return returnValue;
2293 }
2294
2295 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableDalpha (void)
2296 {
2297 MFGLenum::EditHandlePtr returnValue(
2298 new MFGLenum::EditHandle(
2299 &_mfVariableDalpha,
2300 this->getType().getFieldDesc(VariableDalphaFieldId),
2301 this));
2302
2303
2304 editMField(VariableDalphaFieldMask, _mfVariableDalpha);
2305
2306 return returnValue;
2307 }
2308
2309 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleOutputABrgb (void) const
2310 {
2311 MFGLenum::GetHandlePtr returnValue(
2312 new MFGLenum::GetHandle(
2313 &_mfOutputABrgb,
2314 this->getType().getFieldDesc(OutputABrgbFieldId),
2315 const_cast<RegisterCombinersChunkBase *>(this)));
2316
2317 return returnValue;
2318 }
2319
2320 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleOutputABrgb (void)
2321 {
2322 MFGLenum::EditHandlePtr returnValue(
2323 new MFGLenum::EditHandle(
2324 &_mfOutputABrgb,
2325 this->getType().getFieldDesc(OutputABrgbFieldId),
2326 this));
2327
2328
2329 editMField(OutputABrgbFieldMask, _mfOutputABrgb);
2330
2331 return returnValue;
2332 }
2333
2334 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleOutputCDrgb (void) const
2335 {
2336 MFGLenum::GetHandlePtr returnValue(
2337 new MFGLenum::GetHandle(
2338 &_mfOutputCDrgb,
2339 this->getType().getFieldDesc(OutputCDrgbFieldId),
2340 const_cast<RegisterCombinersChunkBase *>(this)));
2341
2342 return returnValue;
2343 }
2344
2345 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleOutputCDrgb (void)
2346 {
2347 MFGLenum::EditHandlePtr returnValue(
2348 new MFGLenum::EditHandle(
2349 &_mfOutputCDrgb,
2350 this->getType().getFieldDesc(OutputCDrgbFieldId),
2351 this));
2352
2353
2354 editMField(OutputCDrgbFieldMask, _mfOutputCDrgb);
2355
2356 return returnValue;
2357 }
2358
2359 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleOutputSumrgb (void) const
2360 {
2361 MFGLenum::GetHandlePtr returnValue(
2362 new MFGLenum::GetHandle(
2363 &_mfOutputSumrgb,
2364 this->getType().getFieldDesc(OutputSumrgbFieldId),
2365 const_cast<RegisterCombinersChunkBase *>(this)));
2366
2367 return returnValue;
2368 }
2369
2370 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleOutputSumrgb (void)
2371 {
2372 MFGLenum::EditHandlePtr returnValue(
2373 new MFGLenum::EditHandle(
2374 &_mfOutputSumrgb,
2375 this->getType().getFieldDesc(OutputSumrgbFieldId),
2376 this));
2377
2378
2379 editMField(OutputSumrgbFieldMask, _mfOutputSumrgb);
2380
2381 return returnValue;
2382 }
2383
2384 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleScalergb (void) const
2385 {
2386 MFGLenum::GetHandlePtr returnValue(
2387 new MFGLenum::GetHandle(
2388 &_mfScalergb,
2389 this->getType().getFieldDesc(ScalergbFieldId),
2390 const_cast<RegisterCombinersChunkBase *>(this)));
2391
2392 return returnValue;
2393 }
2394
2395 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleScalergb (void)
2396 {
2397 MFGLenum::EditHandlePtr returnValue(
2398 new MFGLenum::EditHandle(
2399 &_mfScalergb,
2400 this->getType().getFieldDesc(ScalergbFieldId),
2401 this));
2402
2403
2404 editMField(ScalergbFieldMask, _mfScalergb);
2405
2406 return returnValue;
2407 }
2408
2409 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleBiasrgb (void) const
2410 {
2411 MFGLenum::GetHandlePtr returnValue(
2412 new MFGLenum::GetHandle(
2413 &_mfBiasrgb,
2414 this->getType().getFieldDesc(BiasrgbFieldId),
2415 const_cast<RegisterCombinersChunkBase *>(this)));
2416
2417 return returnValue;
2418 }
2419
2420 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleBiasrgb (void)
2421 {
2422 MFGLenum::EditHandlePtr returnValue(
2423 new MFGLenum::EditHandle(
2424 &_mfBiasrgb,
2425 this->getType().getFieldDesc(BiasrgbFieldId),
2426 this));
2427
2428
2429 editMField(BiasrgbFieldMask, _mfBiasrgb);
2430
2431 return returnValue;
2432 }
2433
2434 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleOutputABalpha (void) const
2435 {
2436 MFGLenum::GetHandlePtr returnValue(
2437 new MFGLenum::GetHandle(
2438 &_mfOutputABalpha,
2439 this->getType().getFieldDesc(OutputABalphaFieldId),
2440 const_cast<RegisterCombinersChunkBase *>(this)));
2441
2442 return returnValue;
2443 }
2444
2445 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleOutputABalpha (void)
2446 {
2447 MFGLenum::EditHandlePtr returnValue(
2448 new MFGLenum::EditHandle(
2449 &_mfOutputABalpha,
2450 this->getType().getFieldDesc(OutputABalphaFieldId),
2451 this));
2452
2453
2454 editMField(OutputABalphaFieldMask, _mfOutputABalpha);
2455
2456 return returnValue;
2457 }
2458
2459 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleOutputCDalpha (void) const
2460 {
2461 MFGLenum::GetHandlePtr returnValue(
2462 new MFGLenum::GetHandle(
2463 &_mfOutputCDalpha,
2464 this->getType().getFieldDesc(OutputCDalphaFieldId),
2465 const_cast<RegisterCombinersChunkBase *>(this)));
2466
2467 return returnValue;
2468 }
2469
2470 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleOutputCDalpha (void)
2471 {
2472 MFGLenum::EditHandlePtr returnValue(
2473 new MFGLenum::EditHandle(
2474 &_mfOutputCDalpha,
2475 this->getType().getFieldDesc(OutputCDalphaFieldId),
2476 this));
2477
2478
2479 editMField(OutputCDalphaFieldMask, _mfOutputCDalpha);
2480
2481 return returnValue;
2482 }
2483
2484 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleOutputSumalpha (void) const
2485 {
2486 MFGLenum::GetHandlePtr returnValue(
2487 new MFGLenum::GetHandle(
2488 &_mfOutputSumalpha,
2489 this->getType().getFieldDesc(OutputSumalphaFieldId),
2490 const_cast<RegisterCombinersChunkBase *>(this)));
2491
2492 return returnValue;
2493 }
2494
2495 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleOutputSumalpha (void)
2496 {
2497 MFGLenum::EditHandlePtr returnValue(
2498 new MFGLenum::EditHandle(
2499 &_mfOutputSumalpha,
2500 this->getType().getFieldDesc(OutputSumalphaFieldId),
2501 this));
2502
2503
2504 editMField(OutputSumalphaFieldMask, _mfOutputSumalpha);
2505
2506 return returnValue;
2507 }
2508
2509 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleDotABrgb (void) const
2510 {
2511 MFUInt8::GetHandlePtr returnValue(
2512 new MFUInt8::GetHandle(
2513 &_mfDotABrgb,
2514 this->getType().getFieldDesc(DotABrgbFieldId),
2515 const_cast<RegisterCombinersChunkBase *>(this)));
2516
2517 return returnValue;
2518 }
2519
2520 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleDotABrgb (void)
2521 {
2522 MFUInt8::EditHandlePtr returnValue(
2523 new MFUInt8::EditHandle(
2524 &_mfDotABrgb,
2525 this->getType().getFieldDesc(DotABrgbFieldId),
2526 this));
2527
2528
2529 editMField(DotABrgbFieldMask, _mfDotABrgb);
2530
2531 return returnValue;
2532 }
2533
2534 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleDotCDrgb (void) const
2535 {
2536 MFUInt8::GetHandlePtr returnValue(
2537 new MFUInt8::GetHandle(
2538 &_mfDotCDrgb,
2539 this->getType().getFieldDesc(DotCDrgbFieldId),
2540 const_cast<RegisterCombinersChunkBase *>(this)));
2541
2542 return returnValue;
2543 }
2544
2545 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleDotCDrgb (void)
2546 {
2547 MFUInt8::EditHandlePtr returnValue(
2548 new MFUInt8::EditHandle(
2549 &_mfDotCDrgb,
2550 this->getType().getFieldDesc(DotCDrgbFieldId),
2551 this));
2552
2553
2554 editMField(DotCDrgbFieldMask, _mfDotCDrgb);
2555
2556 return returnValue;
2557 }
2558
2559 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleMuxSumrgb (void) const
2560 {
2561 MFUInt8::GetHandlePtr returnValue(
2562 new MFUInt8::GetHandle(
2563 &_mfMuxSumrgb,
2564 this->getType().getFieldDesc(MuxSumrgbFieldId),
2565 const_cast<RegisterCombinersChunkBase *>(this)));
2566
2567 return returnValue;
2568 }
2569
2570 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleMuxSumrgb (void)
2571 {
2572 MFUInt8::EditHandlePtr returnValue(
2573 new MFUInt8::EditHandle(
2574 &_mfMuxSumrgb,
2575 this->getType().getFieldDesc(MuxSumrgbFieldId),
2576 this));
2577
2578
2579 editMField(MuxSumrgbFieldMask, _mfMuxSumrgb);
2580
2581 return returnValue;
2582 }
2583
2584 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleScalealpha (void) const
2585 {
2586 MFGLenum::GetHandlePtr returnValue(
2587 new MFGLenum::GetHandle(
2588 &_mfScalealpha,
2589 this->getType().getFieldDesc(ScalealphaFieldId),
2590 const_cast<RegisterCombinersChunkBase *>(this)));
2591
2592 return returnValue;
2593 }
2594
2595 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleScalealpha (void)
2596 {
2597 MFGLenum::EditHandlePtr returnValue(
2598 new MFGLenum::EditHandle(
2599 &_mfScalealpha,
2600 this->getType().getFieldDesc(ScalealphaFieldId),
2601 this));
2602
2603
2604 editMField(ScalealphaFieldMask, _mfScalealpha);
2605
2606 return returnValue;
2607 }
2608
2609 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleBiasalpha (void) const
2610 {
2611 MFGLenum::GetHandlePtr returnValue(
2612 new MFGLenum::GetHandle(
2613 &_mfBiasalpha,
2614 this->getType().getFieldDesc(BiasalphaFieldId),
2615 const_cast<RegisterCombinersChunkBase *>(this)));
2616
2617 return returnValue;
2618 }
2619
2620 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleBiasalpha (void)
2621 {
2622 MFGLenum::EditHandlePtr returnValue(
2623 new MFGLenum::EditHandle(
2624 &_mfBiasalpha,
2625 this->getType().getFieldDesc(BiasalphaFieldId),
2626 this));
2627
2628
2629 editMField(BiasalphaFieldMask, _mfBiasalpha);
2630
2631 return returnValue;
2632 }
2633
2634 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleMuxSumalpha (void) const
2635 {
2636 MFUInt8::GetHandlePtr returnValue(
2637 new MFUInt8::GetHandle(
2638 &_mfMuxSumalpha,
2639 this->getType().getFieldDesc(MuxSumalphaFieldId),
2640 const_cast<RegisterCombinersChunkBase *>(this)));
2641
2642 return returnValue;
2643 }
2644
2645 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleMuxSumalpha (void)
2646 {
2647 MFUInt8::EditHandlePtr returnValue(
2648 new MFUInt8::EditHandle(
2649 &_mfMuxSumalpha,
2650 this->getType().getFieldDesc(MuxSumalphaFieldId),
2651 this));
2652
2653
2654 editMField(MuxSumalphaFieldMask, _mfMuxSumalpha);
2655
2656 return returnValue;
2657 }
2658
2659 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableE (void) const
2660 {
2661 MFGLenum::GetHandlePtr returnValue(
2662 new MFGLenum::GetHandle(
2663 &_mfVariableE,
2664 this->getType().getFieldDesc(VariableEFieldId),
2665 const_cast<RegisterCombinersChunkBase *>(this)));
2666
2667 return returnValue;
2668 }
2669
2670 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableE (void)
2671 {
2672 MFGLenum::EditHandlePtr returnValue(
2673 new MFGLenum::EditHandle(
2674 &_mfVariableE,
2675 this->getType().getFieldDesc(VariableEFieldId),
2676 this));
2677
2678
2679 editMField(VariableEFieldMask, _mfVariableE);
2680
2681 return returnValue;
2682 }
2683
2684 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableF (void) const
2685 {
2686 MFGLenum::GetHandlePtr returnValue(
2687 new MFGLenum::GetHandle(
2688 &_mfVariableF,
2689 this->getType().getFieldDesc(VariableFFieldId),
2690 const_cast<RegisterCombinersChunkBase *>(this)));
2691
2692 return returnValue;
2693 }
2694
2695 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableF (void)
2696 {
2697 MFGLenum::EditHandlePtr returnValue(
2698 new MFGLenum::EditHandle(
2699 &_mfVariableF,
2700 this->getType().getFieldDesc(VariableFFieldId),
2701 this));
2702
2703
2704 editMField(VariableFFieldMask, _mfVariableF);
2705
2706 return returnValue;
2707 }
2708
2709 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleVariableG (void) const
2710 {
2711 MFGLenum::GetHandlePtr returnValue(
2712 new MFGLenum::GetHandle(
2713 &_mfVariableG,
2714 this->getType().getFieldDesc(VariableGFieldId),
2715 const_cast<RegisterCombinersChunkBase *>(this)));
2716
2717 return returnValue;
2718 }
2719
2720 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleVariableG (void)
2721 {
2722 MFGLenum::EditHandlePtr returnValue(
2723 new MFGLenum::EditHandle(
2724 &_mfVariableG,
2725 this->getType().getFieldDesc(VariableGFieldId),
2726 this));
2727
2728
2729 editMField(VariableGFieldMask, _mfVariableG);
2730
2731 return returnValue;
2732 }
2733
2734 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleCombinerColor0 (void) const
2735 {
2736 MFColor4f::GetHandlePtr returnValue(
2737 new MFColor4f::GetHandle(
2738 &_mfCombinerColor0,
2739 this->getType().getFieldDesc(CombinerColor0FieldId),
2740 const_cast<RegisterCombinersChunkBase *>(this)));
2741
2742 return returnValue;
2743 }
2744
2745 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleCombinerColor0 (void)
2746 {
2747 MFColor4f::EditHandlePtr returnValue(
2748 new MFColor4f::EditHandle(
2749 &_mfCombinerColor0,
2750 this->getType().getFieldDesc(CombinerColor0FieldId),
2751 this));
2752
2753
2754 editMField(CombinerColor0FieldMask, _mfCombinerColor0);
2755
2756 return returnValue;
2757 }
2758
2759 GetFieldHandlePtr RegisterCombinersChunkBase::getHandleCombinerColor1 (void) const
2760 {
2761 MFColor4f::GetHandlePtr returnValue(
2762 new MFColor4f::GetHandle(
2763 &_mfCombinerColor1,
2764 this->getType().getFieldDesc(CombinerColor1FieldId),
2765 const_cast<RegisterCombinersChunkBase *>(this)));
2766
2767 return returnValue;
2768 }
2769
2770 EditFieldHandlePtr RegisterCombinersChunkBase::editHandleCombinerColor1 (void)
2771 {
2772 MFColor4f::EditHandlePtr returnValue(
2773 new MFColor4f::EditHandle(
2774 &_mfCombinerColor1,
2775 this->getType().getFieldDesc(CombinerColor1FieldId),
2776 this));
2777
2778
2779 editMField(CombinerColor1FieldMask, _mfCombinerColor1);
2780
2781 return returnValue;
2782 }
2783
2784 GetFieldHandlePtr RegisterCombinersChunkBase::getHandlePerStageConstants (void) const
2785 {
2786 SFUInt8::GetHandlePtr returnValue(
2787 new SFUInt8::GetHandle(
2788 &_sfPerStageConstants,
2789 this->getType().getFieldDesc(PerStageConstantsFieldId),
2790 const_cast<RegisterCombinersChunkBase *>(this)));
2791
2792 return returnValue;
2793 }
2794
2795 EditFieldHandlePtr RegisterCombinersChunkBase::editHandlePerStageConstants(void)
2796 {
2797 SFUInt8::EditHandlePtr returnValue(
2798 new SFUInt8::EditHandle(
2799 &_sfPerStageConstants,
2800 this->getType().getFieldDesc(PerStageConstantsFieldId),
2801 this));
2802
2803
2804 editSField(PerStageConstantsFieldMask);
2805
2806 return returnValue;
2807 }
2808
2809
2810 #ifdef OSG_MT_CPTR_ASPECT
2811 void RegisterCombinersChunkBase::execSyncV( FieldContainer &oFrom,
2812 ConstFieldMaskArg whichField,
2813 AspectOffsetStore &oOffsets,
2814 ConstFieldMaskArg syncMode,
2815 const UInt32 uiSyncInfo)
2816 {
2817 RegisterCombinersChunk *pThis = static_cast<RegisterCombinersChunk *>(this);
2818
2819 pThis->execSync(static_cast<RegisterCombinersChunk *>(&oFrom),
2820 whichField,
2821 oOffsets,
2822 syncMode,
2823 uiSyncInfo);
2824 }
2825 #endif
2826
2827
2828 #ifdef OSG_MT_CPTR_ASPECT
2829 FieldContainer *RegisterCombinersChunkBase::createAspectCopy(
2830 const FieldContainer *pRefAspect) const
2831 {
2832 RegisterCombinersChunk *returnValue;
2833
2834 newAspectCopy(returnValue,
2835 dynamic_cast<const RegisterCombinersChunk *>(pRefAspect),
2836 dynamic_cast<const RegisterCombinersChunk *>(this));
2837
2838 return returnValue;
2839 }
2840 #endif
2841
2842 void RegisterCombinersChunkBase::resolveLinks(void)
2843 {
2844 Inherited::resolveLinks();
2845
2846 #ifdef OSG_MT_CPTR_ASPECT
2847 AspectOffsetStore oOffsets;
2848
2849 _pAspectStore->fillOffsetArray(oOffsets, this);
2850 #endif
2851
2852 #ifdef OSG_MT_CPTR_ASPECT
2853 _mfVariableArgb.terminateShare(Thread::getCurrentAspect(),
2854 oOffsets);
2855 #endif
2856 #ifdef OSG_MT_CPTR_ASPECT
2857 _mfVariableBrgb.terminateShare(Thread::getCurrentAspect(),
2858 oOffsets);
2859 #endif
2860 #ifdef OSG_MT_CPTR_ASPECT
2861 _mfVariableCrgb.terminateShare(Thread::getCurrentAspect(),
2862 oOffsets);
2863 #endif
2864 #ifdef OSG_MT_CPTR_ASPECT
2865 _mfVariableDrgb.terminateShare(Thread::getCurrentAspect(),
2866 oOffsets);
2867 #endif
2868 #ifdef OSG_MT_CPTR_ASPECT
2869 _mfVariableAalpha.terminateShare(Thread::getCurrentAspect(),
2870 oOffsets);
2871 #endif
2872 #ifdef OSG_MT_CPTR_ASPECT
2873 _mfVariableBalpha.terminateShare(Thread::getCurrentAspect(),
2874 oOffsets);
2875 #endif
2876 #ifdef OSG_MT_CPTR_ASPECT
2877 _mfVariableCalpha.terminateShare(Thread::getCurrentAspect(),
2878 oOffsets);
2879 #endif
2880 #ifdef OSG_MT_CPTR_ASPECT
2881 _mfVariableDalpha.terminateShare(Thread::getCurrentAspect(),
2882 oOffsets);
2883 #endif
2884 #ifdef OSG_MT_CPTR_ASPECT
2885 _mfOutputABrgb.terminateShare(Thread::getCurrentAspect(),
2886 oOffsets);
2887 #endif
2888 #ifdef OSG_MT_CPTR_ASPECT
2889 _mfOutputCDrgb.terminateShare(Thread::getCurrentAspect(),
2890 oOffsets);
2891 #endif
2892 #ifdef OSG_MT_CPTR_ASPECT
2893 _mfOutputSumrgb.terminateShare(Thread::getCurrentAspect(),
2894 oOffsets);
2895 #endif
2896 #ifdef OSG_MT_CPTR_ASPECT
2897 _mfScalergb.terminateShare(Thread::getCurrentAspect(),
2898 oOffsets);
2899 #endif
2900 #ifdef OSG_MT_CPTR_ASPECT
2901 _mfBiasrgb.terminateShare(Thread::getCurrentAspect(),
2902 oOffsets);
2903 #endif
2904 #ifdef OSG_MT_CPTR_ASPECT
2905 _mfOutputABalpha.terminateShare(Thread::getCurrentAspect(),
2906 oOffsets);
2907 #endif
2908 #ifdef OSG_MT_CPTR_ASPECT
2909 _mfOutputCDalpha.terminateShare(Thread::getCurrentAspect(),
2910 oOffsets);
2911 #endif
2912 #ifdef OSG_MT_CPTR_ASPECT
2913 _mfOutputSumalpha.terminateShare(Thread::getCurrentAspect(),
2914 oOffsets);
2915 #endif
2916 #ifdef OSG_MT_CPTR_ASPECT
2917 _mfDotABrgb.terminateShare(Thread::getCurrentAspect(),
2918 oOffsets);
2919 #endif
2920 #ifdef OSG_MT_CPTR_ASPECT
2921 _mfDotCDrgb.terminateShare(Thread::getCurrentAspect(),
2922 oOffsets);
2923 #endif
2924 #ifdef OSG_MT_CPTR_ASPECT
2925 _mfMuxSumrgb.terminateShare(Thread::getCurrentAspect(),
2926 oOffsets);
2927 #endif
2928 #ifdef OSG_MT_CPTR_ASPECT
2929 _mfScalealpha.terminateShare(Thread::getCurrentAspect(),
2930 oOffsets);
2931 #endif
2932 #ifdef OSG_MT_CPTR_ASPECT
2933 _mfBiasalpha.terminateShare(Thread::getCurrentAspect(),
2934 oOffsets);
2935 #endif
2936 #ifdef OSG_MT_CPTR_ASPECT
2937 _mfMuxSumalpha.terminateShare(Thread::getCurrentAspect(),
2938 oOffsets);
2939 #endif
2940 #ifdef OSG_MT_CPTR_ASPECT
2941 _mfVariableE.terminateShare(Thread::getCurrentAspect(),
2942 oOffsets);
2943 #endif
2944 #ifdef OSG_MT_CPTR_ASPECT
2945 _mfVariableF.terminateShare(Thread::getCurrentAspect(),
2946 oOffsets);
2947 #endif
2948 #ifdef OSG_MT_CPTR_ASPECT
2949 _mfVariableG.terminateShare(Thread::getCurrentAspect(),
2950 oOffsets);
2951 #endif
2952 #ifdef OSG_MT_CPTR_ASPECT
2953 _mfCombinerColor0.terminateShare(Thread::getCurrentAspect(),
2954 oOffsets);
2955 #endif
2956 #ifdef OSG_MT_CPTR_ASPECT
2957 _mfCombinerColor1.terminateShare(Thread::getCurrentAspect(),
2958 oOffsets);
2959 #endif
2960 }
2961
2962
2963 OSG_END_NAMESPACE