?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: gcc8 compile issues
[opensg.git] / Source / Contrib / VTK / OSGVTKPolyDataMapperBase.cpp
blobf300b6bfb3084f60f443ddd7fad42cec74e48f58
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 VTKPolyDataMapper!
49 ** **
50 *****************************************************************************
51 \*****************************************************************************/
52
53 #include <cstdlib>
54 #include <cstdio>
55
56 #include "OSGConfig.h"
57
58
59
60 #include "OSGNode.h" // Root Class
61 #include "OSGGeometry.h" // Geometries Class
62 #include "OSGChunkMaterial.h" // Materials Class
63 #include "OSGMaterialChunk.h" // MaterialChunks Class
64 #include "OSGGeoPnt3fProperty.h" // Positions Class
65 #include "OSGGeoUInt32Property.h" // Length Class
66 #include "OSGGeoUInt8Property.h" // Types Class
67 #include "OSGGeoColor4fProperty.h" // Colors Class
68 #include "OSGGeoVec3fProperty.h" // Normals Class
69
70 #include "OSGVTKPolyDataMapperBase.h"
71 #include "OSGVTKPolyDataMapper.h"
72
73 #include <boost/bind.hpp>
74
75 #ifdef WIN32 // turn off 'this' : used in base member initializer list warning
76 #pragma warning(disable:4355)
77 #endif
78
79 OSG_BEGIN_NAMESPACE
80
81 /***************************************************************************\
82 * Description *
83 \***************************************************************************/
84
85 /*! \class OSG::VTKPolyDataMapper
86
87 */
88
89 /***************************************************************************\
90 * Field Documentation *
91 \***************************************************************************/
92
93 /*! \var Node * VTKPolyDataMapperBase::_sfRoot
94
95 */
96
97 /*! \var Node * VTKPolyDataMapperBase::_mfGeoRoots
98
99 */
100
101 /*! \var Geometry * VTKPolyDataMapperBase::_mfGeometries
102
103 */
104
105 /*! \var ChunkMaterial * VTKPolyDataMapperBase::_mfMaterials
106
107 */
108
109 /*! \var MaterialChunk * VTKPolyDataMapperBase::_mfMaterialChunks
110
111 */
112
113 /*! \var GeoPnt3fProperty * VTKPolyDataMapperBase::_mfPositions
114
115 */
116
117 /*! \var GeoUInt32Property * VTKPolyDataMapperBase::_mfLength
118
119 */
120
121 /*! \var GeoUInt8Property * VTKPolyDataMapperBase::_mfTypes
122
123 */
124
125 /*! \var GeoColor4fProperty * VTKPolyDataMapperBase::_mfColors
126
127 */
128
129 /*! \var GeoVec3fProperty * VTKPolyDataMapperBase::_mfNormals
130
131 */
132
133
134 /***************************************************************************\
135 * FieldType/FieldTrait Instantiation *
136 \***************************************************************************/
137
138 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
139 PointerType FieldTraits<VTKPolyDataMapper *, nsOSG>::_type(
140 "VTKPolyDataMapperPtr",
141 "GroupPtr",
142 VTKPolyDataMapper::getClassType(),
143 nsOSG);
144 #endif
145
146 OSG_FIELDTRAITS_GETTYPE_NS(VTKPolyDataMapper *, nsOSG)
147
148 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
149 VTKPolyDataMapper *,
150 nsOSG);
151
152 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
153 VTKPolyDataMapper *,
154 nsOSG);
155
156 /***************************************************************************\
157 * Field Description *
158 \***************************************************************************/
159
160 void VTKPolyDataMapperBase::classDescInserter(TypeObject &oType)
161 {
162 FieldDescriptionBase *pDesc = NULL;
163
164
165 pDesc = new SFUnrecNodePtr::Description(
166 SFUnrecNodePtr::getClassType(),
167 "root",
168 "",
169 RootFieldId, RootFieldMask,
170 false,
171 (Field::SFDefaultFlags | Field::FStdAccess),
172 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleRoot),
173 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleRoot));
174
175 oType.addInitialDesc(pDesc);
176
177 pDesc = new MFUnrecNodePtr::Description(
178 MFUnrecNodePtr::getClassType(),
179 "geoRoots",
180 "",
181 GeoRootsFieldId, GeoRootsFieldMask,
182 false,
183 (Field::FStdAccess | Field::FClusterLocal),
184 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleGeoRoots),
185 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleGeoRoots));
186
187 oType.addInitialDesc(pDesc);
188
189 pDesc = new MFUnrecGeometryPtr::Description(
190 MFUnrecGeometryPtr::getClassType(),
191 "geometries",
192 "",
193 GeometriesFieldId, GeometriesFieldMask,
194 false,
195 (Field::FStdAccess | Field::FClusterLocal),
196 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleGeometries),
197 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleGeometries));
198
199 oType.addInitialDesc(pDesc);
200
201 pDesc = new MFUnrecChunkMaterialPtr::Description(
202 MFUnrecChunkMaterialPtr::getClassType(),
203 "materials",
204 "",
205 MaterialsFieldId, MaterialsFieldMask,
206 false,
207 (Field::FStdAccess | Field::FClusterLocal),
208 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleMaterials),
209 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleMaterials));
210
211 oType.addInitialDesc(pDesc);
212
213 pDesc = new MFUnrecMaterialChunkPtr::Description(
214 MFUnrecMaterialChunkPtr::getClassType(),
215 "materialChunks",
216 "",
217 MaterialChunksFieldId, MaterialChunksFieldMask,
218 false,
219 (Field::FStdAccess | Field::FClusterLocal),
220 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleMaterialChunks),
221 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleMaterialChunks));
222
223 oType.addInitialDesc(pDesc);
224
225 pDesc = new MFUnrecGeoPnt3fPropertyPtr::Description(
226 MFUnrecGeoPnt3fPropertyPtr::getClassType(),
227 "positions",
228 "",
229 PositionsFieldId, PositionsFieldMask,
230 false,
231 (Field::FStdAccess | Field::FClusterLocal),
232 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandlePositions),
233 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandlePositions));
234
235 oType.addInitialDesc(pDesc);
236
237 pDesc = new MFUnrecGeoUInt32PropertyPtr::Description(
238 MFUnrecGeoUInt32PropertyPtr::getClassType(),
239 "length",
240 "",
241 LengthFieldId, LengthFieldMask,
242 false,
243 (Field::FStdAccess | Field::FClusterLocal),
244 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleLength),
245 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleLength));
246
247 oType.addInitialDesc(pDesc);
248
249 pDesc = new MFUnrecGeoUInt8PropertyPtr::Description(
250 MFUnrecGeoUInt8PropertyPtr::getClassType(),
251 "types",
252 "",
253 TypesFieldId, TypesFieldMask,
254 false,
255 (Field::FStdAccess | Field::FClusterLocal),
256 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleTypes),
257 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleTypes));
258
259 oType.addInitialDesc(pDesc);
260
261 pDesc = new MFUnrecGeoColor4fPropertyPtr::Description(
262 MFUnrecGeoColor4fPropertyPtr::getClassType(),
263 "Colors",
264 "",
265 ColorsFieldId, ColorsFieldMask,
266 false,
267 (Field::FStdAccess | Field::FClusterLocal),
268 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleColors),
269 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleColors));
270
271 oType.addInitialDesc(pDesc);
272
273 pDesc = new MFUnrecGeoVec3fPropertyPtr::Description(
274 MFUnrecGeoVec3fPropertyPtr::getClassType(),
275 "normals",
276 "",
277 NormalsFieldId, NormalsFieldMask,
278 false,
279 (Field::FStdAccess | Field::FClusterLocal),
280 static_cast<FieldEditMethodSig>(&VTKPolyDataMapper::editHandleNormals),
281 static_cast<FieldGetMethodSig >(&VTKPolyDataMapper::getHandleNormals));
282
283 oType.addInitialDesc(pDesc);
284 }
285
286
287 VTKPolyDataMapperBase::TypeObject VTKPolyDataMapperBase::_type(
288 VTKPolyDataMapperBase::getClassname(),
289 Inherited::getClassname(),
290 "NULL",
291 nsOSG, //Namespace
292 reinterpret_cast<PrototypeCreateF>(&VTKPolyDataMapperBase::createEmptyLocal),
293 VTKPolyDataMapper::initMethod,
294 VTKPolyDataMapper::exitMethod,
295 reinterpret_cast<InitalInsertDescFunc>(&VTKPolyDataMapper::classDescInserter),
296 false,
297 0,
298 "<?xml version=\"1.0\" ?>\n"
299 "\n"
300 "<FieldContainer\n"
301 " name=\"VTKPolyDataMapper\"\n"
302 " parent=\"Group\"\n"
303 " library=\"ContribVTK\"\n"
304 " structure=\"concrete\"\n"
305 " pointerfieldtypes=\"both\"\n"
306 " systemcomponent=\"true\"\n"
307 " parentsystemcomponent=\"true\"\n"
308 " isNodeCore=\"true\"\n"
309 " >\n"
310 " <Field\n"
311 " name=\"root\"\n"
312 " type=\"NodePtr\"\n"
313 " cardinality=\"single\"\n"
314 " visibility=\"external\"\n"
315 " access=\"public\"\n"
316 "\t>\n"
317 " </Field>\n"
318 " <Field\n"
319 " name=\"geoRoots\"\n"
320 " type=\"NodePtr\"\n"
321 " cardinality=\"multi\"\n"
322 " visibility=\"external\"\n"
323 " access=\"public\"\n"
324 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
325 "\t>\n"
326 " </Field>\n"
327 " <Field\n"
328 " name=\"geometries\"\n"
329 " type=\"GeometryPtr\"\n"
330 " cardinality=\"multi\"\n"
331 " visibility=\"external\"\n"
332 " access=\"public\"\n"
333 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
334 "\t>\n"
335 " </Field>\n"
336 " <Field\n"
337 " name=\"materials\"\n"
338 " type=\"ChunkMaterialPtr\"\n"
339 " cardinality=\"multi\"\n"
340 " visibility=\"external\"\n"
341 " access=\"public\"\n"
342 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
343 "\t>\n"
344 " </Field>\n"
345 " <Field\n"
346 " name=\"materialChunks\"\n"
347 " type=\"MaterialChunkPtr\"\n"
348 " cardinality=\"multi\"\n"
349 " visibility=\"external\"\n"
350 " access=\"public\"\n"
351 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
352 "\t>\n"
353 " </Field>\n"
354 " <Field\n"
355 " name=\"positions\"\n"
356 " type=\"GeoPnt3fPropertyPtr\"\n"
357 " cardinality=\"multi\"\n"
358 " visibility=\"external\"\n"
359 " access=\"public\"\n"
360 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
361 "\t>\n"
362 " </Field>\n"
363 " <Field\n"
364 " name=\"length\"\n"
365 " type=\"GeoUInt32PropertyPtr\"\n"
366 " cardinality=\"multi\"\n"
367 " visibility=\"external\"\n"
368 " access=\"public\"\n"
369 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
370 "\t>\n"
371 " </Field>\n"
372 " <Field\n"
373 " name=\"types\"\n"
374 " type=\"GeoUInt8PropertyPtr\"\n"
375 " cardinality=\"multi\"\n"
376 " visibility=\"external\"\n"
377 " access=\"public\"\n"
378 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
379 "\t>\n"
380 " </Field>\n"
381 " <Field\n"
382 " name=\"Colors\"\n"
383 " type=\"GeoColor4fPropertyPtr\"\n"
384 " cardinality=\"multi\"\n"
385 " visibility=\"external\"\n"
386 " access=\"public\"\n"
387 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
388 "\t>\n"
389 " </Field>\n"
390 " <Field\n"
391 " name=\"normals\"\n"
392 " type=\"GeoVec3fPropertyPtr\"\n"
393 " cardinality=\"multi\"\n"
394 " visibility=\"external\"\n"
395 " access=\"public\"\n"
396 " fieldFlags=\"FStdAccess, FClusterLocal\"\n"
397 "\t>\n"
398 " </Field>\n"
399 "</FieldContainer>\n",
400 ""
401 );
402
403 /*------------------------------ get -----------------------------------*/
404
405 FieldContainerType &VTKPolyDataMapperBase::getType(void)
406 {
407 return _type;
408 }
409
410 const FieldContainerType &VTKPolyDataMapperBase::getType(void) const
411 {
412 return _type;
413 }
414
415 UInt32 VTKPolyDataMapperBase::getContainerSize(void) const
416 {
417 return sizeof(VTKPolyDataMapper);
418 }
419
420 /*------------------------- decorator get ------------------------------*/
421
422
423 //! Get the VTKPolyDataMapper::_sfRoot field.
424 const SFUnrecNodePtr *VTKPolyDataMapperBase::getSFRoot(void) const
425 {
426 return &_sfRoot;
427 }
428
429 SFUnrecNodePtr *VTKPolyDataMapperBase::editSFRoot (void)
430 {
431 editSField(RootFieldMask);
432
433 return &_sfRoot;
434 }
435
436 //! Get the value of the VTKPolyDataMapper::_sfRoot field.
437 Node * VTKPolyDataMapperBase::getRoot(void) const
438 {
439 return _sfRoot.getValue();
440 }
441
442 //! Set the value of the VTKPolyDataMapper::_sfRoot field.
443 void VTKPolyDataMapperBase::setRoot(Node * const value)
444 {
445 editSField(RootFieldMask);
446
447 _sfRoot.setValue(value);
448 }
449
450
451 //! Get the VTKPolyDataMapper::_mfGeoRoots field.
452 const MFUnrecNodePtr *VTKPolyDataMapperBase::getMFGeoRoots(void) const
453 {
454 return &_mfGeoRoots;
455 }
456
457 MFUnrecNodePtr *VTKPolyDataMapperBase::editMFGeoRoots (void)
458 {
459 editMField(GeoRootsFieldMask, _mfGeoRoots);
460
461 return &_mfGeoRoots;
462 }
463 Node * VTKPolyDataMapperBase::getGeoRoots(const UInt32 index) const
464 {
465 return _mfGeoRoots[index];
466 }
467
468 //! Get the VTKPolyDataMapper::_mfGeometries field.
469 const MFUnrecGeometryPtr *VTKPolyDataMapperBase::getMFGeometries(void) const
470 {
471 return &_mfGeometries;
472 }
473
474 MFUnrecGeometryPtr *VTKPolyDataMapperBase::editMFGeometries (void)
475 {
476 editMField(GeometriesFieldMask, _mfGeometries);
477
478 return &_mfGeometries;
479 }
480 Geometry * VTKPolyDataMapperBase::getGeometries(const UInt32 index) const
481 {
482 return _mfGeometries[index];
483 }
484
485 //! Get the VTKPolyDataMapper::_mfMaterials field.
486 const MFUnrecChunkMaterialPtr *VTKPolyDataMapperBase::getMFMaterials(void) const
487 {
488 return &_mfMaterials;
489 }
490
491 MFUnrecChunkMaterialPtr *VTKPolyDataMapperBase::editMFMaterials (void)
492 {
493 editMField(MaterialsFieldMask, _mfMaterials);
494
495 return &_mfMaterials;
496 }
497 ChunkMaterial * VTKPolyDataMapperBase::getMaterials(const UInt32 index) const
498 {
499 return _mfMaterials[index];
500 }
501
502 //! Get the VTKPolyDataMapper::_mfMaterialChunks field.
503 const MFUnrecMaterialChunkPtr *VTKPolyDataMapperBase::getMFMaterialChunks(void) const
504 {
505 return &_mfMaterialChunks;
506 }
507
508 MFUnrecMaterialChunkPtr *VTKPolyDataMapperBase::editMFMaterialChunks (void)
509 {
510 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
511
512 return &_mfMaterialChunks;
513 }
514 MaterialChunk * VTKPolyDataMapperBase::getMaterialChunks(const UInt32 index) const
515 {
516 return _mfMaterialChunks[index];
517 }
518
519 //! Get the VTKPolyDataMapper::_mfPositions field.
520 const MFUnrecGeoPnt3fPropertyPtr *VTKPolyDataMapperBase::getMFPositions(void) const
521 {
522 return &_mfPositions;
523 }
524
525 MFUnrecGeoPnt3fPropertyPtr *VTKPolyDataMapperBase::editMFPositions (void)
526 {
527 editMField(PositionsFieldMask, _mfPositions);
528
529 return &_mfPositions;
530 }
531 GeoPnt3fProperty * VTKPolyDataMapperBase::getPositions(const UInt32 index) const
532 {
533 return _mfPositions[index];
534 }
535
536 //! Get the VTKPolyDataMapper::_mfLength field.
537 const MFUnrecGeoUInt32PropertyPtr *VTKPolyDataMapperBase::getMFLength(void) const
538 {
539 return &_mfLength;
540 }
541
542 MFUnrecGeoUInt32PropertyPtr *VTKPolyDataMapperBase::editMFLength (void)
543 {
544 editMField(LengthFieldMask, _mfLength);
545
546 return &_mfLength;
547 }
548 GeoUInt32Property * VTKPolyDataMapperBase::getLength(const UInt32 index) const
549 {
550 return _mfLength[index];
551 }
552
553 //! Get the VTKPolyDataMapper::_mfTypes field.
554 const MFUnrecGeoUInt8PropertyPtr *VTKPolyDataMapperBase::getMFTypes(void) const
555 {
556 return &_mfTypes;
557 }
558
559 MFUnrecGeoUInt8PropertyPtr *VTKPolyDataMapperBase::editMFTypes (void)
560 {
561 editMField(TypesFieldMask, _mfTypes);
562
563 return &_mfTypes;
564 }
565 GeoUInt8Property * VTKPolyDataMapperBase::getTypes(const UInt32 index) const
566 {
567 return _mfTypes[index];
568 }
569
570 //! Get the VTKPolyDataMapper::_mfColors field.
571 const MFUnrecGeoColor4fPropertyPtr *VTKPolyDataMapperBase::getMFColors(void) const
572 {
573 return &_mfColors;
574 }
575
576 MFUnrecGeoColor4fPropertyPtr *VTKPolyDataMapperBase::editMFColors (void)
577 {
578 editMField(ColorsFieldMask, _mfColors);
579
580 return &_mfColors;
581 }
582 GeoColor4fProperty * VTKPolyDataMapperBase::getColors(const UInt32 index) const
583 {
584 return _mfColors[index];
585 }
586
587 //! Get the VTKPolyDataMapper::_mfNormals field.
588 const MFUnrecGeoVec3fPropertyPtr *VTKPolyDataMapperBase::getMFNormals(void) const
589 {
590 return &_mfNormals;
591 }
592
593 MFUnrecGeoVec3fPropertyPtr *VTKPolyDataMapperBase::editMFNormals (void)
594 {
595 editMField(NormalsFieldMask, _mfNormals);
596
597 return &_mfNormals;
598 }
599 GeoVec3fProperty * VTKPolyDataMapperBase::getNormals(const UInt32 index) const
600 {
601 return _mfNormals[index];
602 }
603
604
605
606 void VTKPolyDataMapperBase::pushToGeoRoots(Node * const value)
607 {
608 editMField(GeoRootsFieldMask, _mfGeoRoots);
609
610 _mfGeoRoots.push_back(value);
611 }
612
613 void VTKPolyDataMapperBase::assignGeoRoots (const MFUnrecNodePtr &value)
614 {
615 MFUnrecNodePtr ::const_iterator elemIt =
616 value.begin();
617 MFUnrecNodePtr ::const_iterator elemEnd =
618 value.end ();
619
620 static_cast<VTKPolyDataMapper *>(this)->clearGeoRoots();
621
622 while(elemIt != elemEnd)
623 {
624 this->pushToGeoRoots(*elemIt);
625
626 ++elemIt;
627 }
628 }
629
630 void VTKPolyDataMapperBase::removeFromGeoRoots(UInt32 uiIndex)
631 {
632 if(uiIndex < _mfGeoRoots.size())
633 {
634 editMField(GeoRootsFieldMask, _mfGeoRoots);
635
636 _mfGeoRoots.erase(uiIndex);
637 }
638 }
639
640 void VTKPolyDataMapperBase::removeObjFromGeoRoots(Node * const value)
641 {
642 Int32 iElemIdx = _mfGeoRoots.findIndex(value);
643
644 if(iElemIdx != -1)
645 {
646 editMField(GeoRootsFieldMask, _mfGeoRoots);
647
648 _mfGeoRoots.erase(iElemIdx);
649 }
650 }
651 void VTKPolyDataMapperBase::clearGeoRoots(void)
652 {
653 editMField(GeoRootsFieldMask, _mfGeoRoots);
654
655
656 _mfGeoRoots.clear();
657 }
658
659 void VTKPolyDataMapperBase::pushToGeometries(Geometry * const value)
660 {
661 editMField(GeometriesFieldMask, _mfGeometries);
662
663 _mfGeometries.push_back(value);
664 }
665
666 void VTKPolyDataMapperBase::assignGeometries(const MFUnrecGeometryPtr &value)
667 {
668 MFUnrecGeometryPtr::const_iterator elemIt =
669 value.begin();
670 MFUnrecGeometryPtr::const_iterator elemEnd =
671 value.end ();
672
673 static_cast<VTKPolyDataMapper *>(this)->clearGeometries();
674
675 while(elemIt != elemEnd)
676 {
677 this->pushToGeometries(*elemIt);
678
679 ++elemIt;
680 }
681 }
682
683 void VTKPolyDataMapperBase::removeFromGeometries(UInt32 uiIndex)
684 {
685 if(uiIndex < _mfGeometries.size())
686 {
687 editMField(GeometriesFieldMask, _mfGeometries);
688
689 _mfGeometries.erase(uiIndex);
690 }
691 }
692
693 void VTKPolyDataMapperBase::removeObjFromGeometries(Geometry * const value)
694 {
695 Int32 iElemIdx = _mfGeometries.findIndex(value);
696
697 if(iElemIdx != -1)
698 {
699 editMField(GeometriesFieldMask, _mfGeometries);
700
701 _mfGeometries.erase(iElemIdx);
702 }
703 }
704 void VTKPolyDataMapperBase::clearGeometries(void)
705 {
706 editMField(GeometriesFieldMask, _mfGeometries);
707
708
709 _mfGeometries.clear();
710 }
711
712 void VTKPolyDataMapperBase::pushToMaterials(ChunkMaterial * const value)
713 {
714 editMField(MaterialsFieldMask, _mfMaterials);
715
716 _mfMaterials.push_back(value);
717 }
718
719 void VTKPolyDataMapperBase::assignMaterials(const MFUnrecChunkMaterialPtr &value)
720 {
721 MFUnrecChunkMaterialPtr::const_iterator elemIt =
722 value.begin();
723 MFUnrecChunkMaterialPtr::const_iterator elemEnd =
724 value.end ();
725
726 static_cast<VTKPolyDataMapper *>(this)->clearMaterials();
727
728 while(elemIt != elemEnd)
729 {
730 this->pushToMaterials(*elemIt);
731
732 ++elemIt;
733 }
734 }
735
736 void VTKPolyDataMapperBase::removeFromMaterials(UInt32 uiIndex)
737 {
738 if(uiIndex < _mfMaterials.size())
739 {
740 editMField(MaterialsFieldMask, _mfMaterials);
741
742 _mfMaterials.erase(uiIndex);
743 }
744 }
745
746 void VTKPolyDataMapperBase::removeObjFromMaterials(ChunkMaterial * const value)
747 {
748 Int32 iElemIdx = _mfMaterials.findIndex(value);
749
750 if(iElemIdx != -1)
751 {
752 editMField(MaterialsFieldMask, _mfMaterials);
753
754 _mfMaterials.erase(iElemIdx);
755 }
756 }
757 void VTKPolyDataMapperBase::clearMaterials(void)
758 {
759 editMField(MaterialsFieldMask, _mfMaterials);
760
761
762 _mfMaterials.clear();
763 }
764
765 void VTKPolyDataMapperBase::pushToMaterialChunks(MaterialChunk * const value)
766 {
767 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
768
769 _mfMaterialChunks.push_back(value);
770 }
771
772 void VTKPolyDataMapperBase::assignMaterialChunks(const MFUnrecMaterialChunkPtr &value)
773 {
774 MFUnrecMaterialChunkPtr::const_iterator elemIt =
775 value.begin();
776 MFUnrecMaterialChunkPtr::const_iterator elemEnd =
777 value.end ();
778
779 static_cast<VTKPolyDataMapper *>(this)->clearMaterialChunks();
780
781 while(elemIt != elemEnd)
782 {
783 this->pushToMaterialChunks(*elemIt);
784
785 ++elemIt;
786 }
787 }
788
789 void VTKPolyDataMapperBase::removeFromMaterialChunks(UInt32 uiIndex)
790 {
791 if(uiIndex < _mfMaterialChunks.size())
792 {
793 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
794
795 _mfMaterialChunks.erase(uiIndex);
796 }
797 }
798
799 void VTKPolyDataMapperBase::removeObjFromMaterialChunks(MaterialChunk * const value)
800 {
801 Int32 iElemIdx = _mfMaterialChunks.findIndex(value);
802
803 if(iElemIdx != -1)
804 {
805 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
806
807 _mfMaterialChunks.erase(iElemIdx);
808 }
809 }
810 void VTKPolyDataMapperBase::clearMaterialChunks(void)
811 {
812 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
813
814
815 _mfMaterialChunks.clear();
816 }
817
818 void VTKPolyDataMapperBase::pushToPositions(GeoPnt3fProperty * const value)
819 {
820 editMField(PositionsFieldMask, _mfPositions);
821
822 _mfPositions.push_back(value);
823 }
824
825 void VTKPolyDataMapperBase::assignPositions(const MFUnrecGeoPnt3fPropertyPtr &value)
826 {
827 MFUnrecGeoPnt3fPropertyPtr::const_iterator elemIt =
828 value.begin();
829 MFUnrecGeoPnt3fPropertyPtr::const_iterator elemEnd =
830 value.end ();
831
832 static_cast<VTKPolyDataMapper *>(this)->clearPositions();
833
834 while(elemIt != elemEnd)
835 {
836 this->pushToPositions(*elemIt);
837
838 ++elemIt;
839 }
840 }
841
842 void VTKPolyDataMapperBase::removeFromPositions(UInt32 uiIndex)
843 {
844 if(uiIndex < _mfPositions.size())
845 {
846 editMField(PositionsFieldMask, _mfPositions);
847
848 _mfPositions.erase(uiIndex);
849 }
850 }
851
852 void VTKPolyDataMapperBase::removeObjFromPositions(GeoPnt3fProperty * const value)
853 {
854 Int32 iElemIdx = _mfPositions.findIndex(value);
855
856 if(iElemIdx != -1)
857 {
858 editMField(PositionsFieldMask, _mfPositions);
859
860 _mfPositions.erase(iElemIdx);
861 }
862 }
863 void VTKPolyDataMapperBase::clearPositions(void)
864 {
865 editMField(PositionsFieldMask, _mfPositions);
866
867
868 _mfPositions.clear();
869 }
870
871 void VTKPolyDataMapperBase::pushToLength(GeoUInt32Property * const value)
872 {
873 editMField(LengthFieldMask, _mfLength);
874
875 _mfLength.push_back(value);
876 }
877
878 void VTKPolyDataMapperBase::assignLength (const MFUnrecGeoUInt32PropertyPtr &value)
879 {
880 MFUnrecGeoUInt32PropertyPtr::const_iterator elemIt =
881 value.begin();
882 MFUnrecGeoUInt32PropertyPtr::const_iterator elemEnd =
883 value.end ();
884
885 static_cast<VTKPolyDataMapper *>(this)->clearLength();
886
887 while(elemIt != elemEnd)
888 {
889 this->pushToLength(*elemIt);
890
891 ++elemIt;
892 }
893 }
894
895 void VTKPolyDataMapperBase::removeFromLength(UInt32 uiIndex)
896 {
897 if(uiIndex < _mfLength.size())
898 {
899 editMField(LengthFieldMask, _mfLength);
900
901 _mfLength.erase(uiIndex);
902 }
903 }
904
905 void VTKPolyDataMapperBase::removeObjFromLength(GeoUInt32Property * const value)
906 {
907 Int32 iElemIdx = _mfLength.findIndex(value);
908
909 if(iElemIdx != -1)
910 {
911 editMField(LengthFieldMask, _mfLength);
912
913 _mfLength.erase(iElemIdx);
914 }
915 }
916 void VTKPolyDataMapperBase::clearLength(void)
917 {
918 editMField(LengthFieldMask, _mfLength);
919
920
921 _mfLength.clear();
922 }
923
924 void VTKPolyDataMapperBase::pushToTypes(GeoUInt8Property * const value)
925 {
926 editMField(TypesFieldMask, _mfTypes);
927
928 _mfTypes.push_back(value);
929 }
930
931 void VTKPolyDataMapperBase::assignTypes (const MFUnrecGeoUInt8PropertyPtr &value)
932 {
933 MFUnrecGeoUInt8PropertyPtr::const_iterator elemIt =
934 value.begin();
935 MFUnrecGeoUInt8PropertyPtr::const_iterator elemEnd =
936 value.end ();
937
938 static_cast<VTKPolyDataMapper *>(this)->clearTypes();
939
940 while(elemIt != elemEnd)
941 {
942 this->pushToTypes(*elemIt);
943
944 ++elemIt;
945 }
946 }
947
948 void VTKPolyDataMapperBase::removeFromTypes(UInt32 uiIndex)
949 {
950 if(uiIndex < _mfTypes.size())
951 {
952 editMField(TypesFieldMask, _mfTypes);
953
954 _mfTypes.erase(uiIndex);
955 }
956 }
957
958 void VTKPolyDataMapperBase::removeObjFromTypes(GeoUInt8Property * const value)
959 {
960 Int32 iElemIdx = _mfTypes.findIndex(value);
961
962 if(iElemIdx != -1)
963 {
964 editMField(TypesFieldMask, _mfTypes);
965
966 _mfTypes.erase(iElemIdx);
967 }
968 }
969 void VTKPolyDataMapperBase::clearTypes(void)
970 {
971 editMField(TypesFieldMask, _mfTypes);
972
973
974 _mfTypes.clear();
975 }
976
977 void VTKPolyDataMapperBase::pushToColors(GeoColor4fProperty * const value)
978 {
979 editMField(ColorsFieldMask, _mfColors);
980
981 _mfColors.push_back(value);
982 }
983
984 void VTKPolyDataMapperBase::assignColors (const MFUnrecGeoColor4fPropertyPtr &value)
985 {
986 MFUnrecGeoColor4fPropertyPtr::const_iterator elemIt =
987 value.begin();
988 MFUnrecGeoColor4fPropertyPtr::const_iterator elemEnd =
989 value.end ();
990
991 static_cast<VTKPolyDataMapper *>(this)->clearColors();
992
993 while(elemIt != elemEnd)
994 {
995 this->pushToColors(*elemIt);
996
997 ++elemIt;
998 }
999 }
1000
1001 void VTKPolyDataMapperBase::removeFromColors(UInt32 uiIndex)
1002 {
1003 if(uiIndex < _mfColors.size())
1004 {
1005 editMField(ColorsFieldMask, _mfColors);
1006
1007 _mfColors.erase(uiIndex);
1008 }
1009 }
1010
1011 void VTKPolyDataMapperBase::removeObjFromColors(GeoColor4fProperty * const value)
1012 {
1013 Int32 iElemIdx = _mfColors.findIndex(value);
1014
1015 if(iElemIdx != -1)
1016 {
1017 editMField(ColorsFieldMask, _mfColors);
1018
1019 _mfColors.erase(iElemIdx);
1020 }
1021 }
1022 void VTKPolyDataMapperBase::clearColors(void)
1023 {
1024 editMField(ColorsFieldMask, _mfColors);
1025
1026
1027 _mfColors.clear();
1028 }
1029
1030 void VTKPolyDataMapperBase::pushToNormals(GeoVec3fProperty * const value)
1031 {
1032 editMField(NormalsFieldMask, _mfNormals);
1033
1034 _mfNormals.push_back(value);
1035 }
1036
1037 void VTKPolyDataMapperBase::assignNormals (const MFUnrecGeoVec3fPropertyPtr &value)
1038 {
1039 MFUnrecGeoVec3fPropertyPtr::const_iterator elemIt =
1040 value.begin();
1041 MFUnrecGeoVec3fPropertyPtr::const_iterator elemEnd =
1042 value.end ();
1043
1044 static_cast<VTKPolyDataMapper *>(this)->clearNormals();
1045
1046 while(elemIt != elemEnd)
1047 {
1048 this->pushToNormals(*elemIt);
1049
1050 ++elemIt;
1051 }
1052 }
1053
1054 void VTKPolyDataMapperBase::removeFromNormals(UInt32 uiIndex)
1055 {
1056 if(uiIndex < _mfNormals.size())
1057 {
1058 editMField(NormalsFieldMask, _mfNormals);
1059
1060 _mfNormals.erase(uiIndex);
1061 }
1062 }
1063
1064 void VTKPolyDataMapperBase::removeObjFromNormals(GeoVec3fProperty * const value)
1065 {
1066 Int32 iElemIdx = _mfNormals.findIndex(value);
1067
1068 if(iElemIdx != -1)
1069 {
1070 editMField(NormalsFieldMask, _mfNormals);
1071
1072 _mfNormals.erase(iElemIdx);
1073 }
1074 }
1075 void VTKPolyDataMapperBase::clearNormals(void)
1076 {
1077 editMField(NormalsFieldMask, _mfNormals);
1078
1079
1080 _mfNormals.clear();
1081 }
1082
1083
1084
1085 /*------------------------------ access -----------------------------------*/
1086
1087 SizeT VTKPolyDataMapperBase::getBinSize(ConstFieldMaskArg whichField)
1088 {
1089 SizeT returnValue = Inherited::getBinSize(whichField);
1090
1091 if(FieldBits::NoField != (RootFieldMask & whichField))
1092 {
1093 returnValue += _sfRoot.getBinSize();
1094 }
1095 if(FieldBits::NoField != (GeoRootsFieldMask & whichField))
1096 {
1097 returnValue += _mfGeoRoots.getBinSize();
1098 }
1099 if(FieldBits::NoField != (GeometriesFieldMask & whichField))
1100 {
1101 returnValue += _mfGeometries.getBinSize();
1102 }
1103 if(FieldBits::NoField != (MaterialsFieldMask & whichField))
1104 {
1105 returnValue += _mfMaterials.getBinSize();
1106 }
1107 if(FieldBits::NoField != (MaterialChunksFieldMask & whichField))
1108 {
1109 returnValue += _mfMaterialChunks.getBinSize();
1110 }
1111 if(FieldBits::NoField != (PositionsFieldMask & whichField))
1112 {
1113 returnValue += _mfPositions.getBinSize();
1114 }
1115 if(FieldBits::NoField != (LengthFieldMask & whichField))
1116 {
1117 returnValue += _mfLength.getBinSize();
1118 }
1119 if(FieldBits::NoField != (TypesFieldMask & whichField))
1120 {
1121 returnValue += _mfTypes.getBinSize();
1122 }
1123 if(FieldBits::NoField != (ColorsFieldMask & whichField))
1124 {
1125 returnValue += _mfColors.getBinSize();
1126 }
1127 if(FieldBits::NoField != (NormalsFieldMask & whichField))
1128 {
1129 returnValue += _mfNormals.getBinSize();
1130 }
1131
1132 return returnValue;
1133 }
1134
1135 void VTKPolyDataMapperBase::copyToBin(BinaryDataHandler &pMem,
1136 ConstFieldMaskArg whichField)
1137 {
1138 Inherited::copyToBin(pMem, whichField);
1139
1140 if(FieldBits::NoField != (RootFieldMask & whichField))
1141 {
1142 _sfRoot.copyToBin(pMem);
1143 }
1144 if(FieldBits::NoField != (GeoRootsFieldMask & whichField))
1145 {
1146 _mfGeoRoots.copyToBin(pMem);
1147 }
1148 if(FieldBits::NoField != (GeometriesFieldMask & whichField))
1149 {
1150 _mfGeometries.copyToBin(pMem);
1151 }
1152 if(FieldBits::NoField != (MaterialsFieldMask & whichField))
1153 {
1154 _mfMaterials.copyToBin(pMem);
1155 }
1156 if(FieldBits::NoField != (MaterialChunksFieldMask & whichField))
1157 {
1158 _mfMaterialChunks.copyToBin(pMem);
1159 }
1160 if(FieldBits::NoField != (PositionsFieldMask & whichField))
1161 {
1162 _mfPositions.copyToBin(pMem);
1163 }
1164 if(FieldBits::NoField != (LengthFieldMask & whichField))
1165 {
1166 _mfLength.copyToBin(pMem);
1167 }
1168 if(FieldBits::NoField != (TypesFieldMask & whichField))
1169 {
1170 _mfTypes.copyToBin(pMem);
1171 }
1172 if(FieldBits::NoField != (ColorsFieldMask & whichField))
1173 {
1174 _mfColors.copyToBin(pMem);
1175 }
1176 if(FieldBits::NoField != (NormalsFieldMask & whichField))
1177 {
1178 _mfNormals.copyToBin(pMem);
1179 }
1180 }
1181
1182 void VTKPolyDataMapperBase::copyFromBin(BinaryDataHandler &pMem,
1183 ConstFieldMaskArg whichField)
1184 {
1185 Inherited::copyFromBin(pMem, whichField);
1186
1187 if(FieldBits::NoField != (RootFieldMask & whichField))
1188 {
1189 editSField(RootFieldMask);
1190 _sfRoot.copyFromBin(pMem);
1191 }
1192 if(FieldBits::NoField != (GeoRootsFieldMask & whichField))
1193 {
1194 editMField(GeoRootsFieldMask, _mfGeoRoots);
1195 _mfGeoRoots.copyFromBin(pMem);
1196 }
1197 if(FieldBits::NoField != (GeometriesFieldMask & whichField))
1198 {
1199 editMField(GeometriesFieldMask, _mfGeometries);
1200 _mfGeometries.copyFromBin(pMem);
1201 }
1202 if(FieldBits::NoField != (MaterialsFieldMask & whichField))
1203 {
1204 editMField(MaterialsFieldMask, _mfMaterials);
1205 _mfMaterials.copyFromBin(pMem);
1206 }
1207 if(FieldBits::NoField != (MaterialChunksFieldMask & whichField))
1208 {
1209 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
1210 _mfMaterialChunks.copyFromBin(pMem);
1211 }
1212 if(FieldBits::NoField != (PositionsFieldMask & whichField))
1213 {
1214 editMField(PositionsFieldMask, _mfPositions);
1215 _mfPositions.copyFromBin(pMem);
1216 }
1217 if(FieldBits::NoField != (LengthFieldMask & whichField))
1218 {
1219 editMField(LengthFieldMask, _mfLength);
1220 _mfLength.copyFromBin(pMem);
1221 }
1222 if(FieldBits::NoField != (TypesFieldMask & whichField))
1223 {
1224 editMField(TypesFieldMask, _mfTypes);
1225 _mfTypes.copyFromBin(pMem);
1226 }
1227 if(FieldBits::NoField != (ColorsFieldMask & whichField))
1228 {
1229 editMField(ColorsFieldMask, _mfColors);
1230 _mfColors.copyFromBin(pMem);
1231 }
1232 if(FieldBits::NoField != (NormalsFieldMask & whichField))
1233 {
1234 editMField(NormalsFieldMask, _mfNormals);
1235 _mfNormals.copyFromBin(pMem);
1236 }
1237 }
1238
1239 //! create a new instance of the class
1240 VTKPolyDataMapperTransitPtr VTKPolyDataMapperBase::createLocal(BitVector bFlags)
1241 {
1242 VTKPolyDataMapperTransitPtr fc;
1243
1244 if(getClassType().getPrototype() != NULL)
1245 {
1246 FieldContainerTransitPtr tmpPtr =
1247 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
1248
1249 fc = dynamic_pointer_cast<VTKPolyDataMapper>(tmpPtr);
1250 }
1251
1252 return fc;
1253 }
1254
1255 //! create a new instance of the class, copy the container flags
1256 VTKPolyDataMapperTransitPtr VTKPolyDataMapperBase::createDependent(BitVector bFlags)
1257 {
1258 VTKPolyDataMapperTransitPtr fc;
1259
1260 if(getClassType().getPrototype() != NULL)
1261 {
1262 FieldContainerTransitPtr tmpPtr =
1263 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
1264
1265 fc = dynamic_pointer_cast<VTKPolyDataMapper>(tmpPtr);
1266 }
1267
1268 return fc;
1269 }
1270
1271 //! create a new instance of the class
1272 VTKPolyDataMapperTransitPtr VTKPolyDataMapperBase::create(void)
1273 {
1274 VTKPolyDataMapperTransitPtr fc;
1275
1276 if(getClassType().getPrototype() != NULL)
1277 {
1278 FieldContainerTransitPtr tmpPtr =
1279 getClassType().getPrototype()-> shallowCopy();
1280
1281 fc = dynamic_pointer_cast<VTKPolyDataMapper>(tmpPtr);
1282 }
1283
1284 return fc;
1285 }
1286
1287 VTKPolyDataMapper *VTKPolyDataMapperBase::createEmptyLocal(BitVector bFlags)
1288 {
1289 VTKPolyDataMapper *returnValue;
1290
1291 newPtr<VTKPolyDataMapper>(returnValue, bFlags);
1292
1293 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1294
1295 return returnValue;
1296 }
1297
1298 //! create an empty new instance of the class, do not copy the prototype
1299 VTKPolyDataMapper *VTKPolyDataMapperBase::createEmpty(void)
1300 {
1301 VTKPolyDataMapper *returnValue;
1302
1303 newPtr<VTKPolyDataMapper>(returnValue, Thread::getCurrentLocalFlags());
1304
1305 returnValue->_pFieldFlags->_bNamespaceMask &=
1306 ~Thread::getCurrentLocalFlags();
1307
1308 return returnValue;
1309 }
1310
1311
1312 FieldContainerTransitPtr VTKPolyDataMapperBase::shallowCopyLocal(
1313 BitVector bFlags) const
1314 {
1315 VTKPolyDataMapper *tmpPtr;
1316
1317 newPtr(tmpPtr, dynamic_cast<const VTKPolyDataMapper *>(this), bFlags);
1318
1319 FieldContainerTransitPtr returnValue(tmpPtr);
1320
1321 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1322
1323 return returnValue;
1324 }
1325
1326 FieldContainerTransitPtr VTKPolyDataMapperBase::shallowCopyDependent(
1327 BitVector bFlags) const
1328 {
1329 VTKPolyDataMapper *tmpPtr;
1330
1331 newPtr(tmpPtr, dynamic_cast<const VTKPolyDataMapper *>(this), ~bFlags);
1332
1333 FieldContainerTransitPtr returnValue(tmpPtr);
1334
1335 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
1336
1337 return returnValue;
1338 }
1339
1340 FieldContainerTransitPtr VTKPolyDataMapperBase::shallowCopy(void) const
1341 {
1342 VTKPolyDataMapper *tmpPtr;
1343
1344 newPtr(tmpPtr,
1345 dynamic_cast<const VTKPolyDataMapper *>(this),
1346 Thread::getCurrentLocalFlags());
1347
1348 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
1349
1350 FieldContainerTransitPtr returnValue(tmpPtr);
1351
1352 return returnValue;
1353 }
1354
1355
1356
1357
1358 /*------------------------- constructors ----------------------------------*/
1359
1360 VTKPolyDataMapperBase::VTKPolyDataMapperBase(void) :
1361 Inherited(),
1362 _sfRoot (NULL),
1363 _mfGeoRoots (),
1364 _mfGeometries (),
1365 _mfMaterials (),
1366 _mfMaterialChunks (),
1367 _mfPositions (),
1368 _mfLength (),
1369 _mfTypes (),
1370 _mfColors (),
1371 _mfNormals ()
1372 {
1373 }
1374
1375 VTKPolyDataMapperBase::VTKPolyDataMapperBase(const VTKPolyDataMapperBase &source) :
1376 Inherited(source),
1377 _sfRoot (NULL),
1378 _mfGeoRoots (),
1379 _mfGeometries (),
1380 _mfMaterials (),
1381 _mfMaterialChunks (),
1382 _mfPositions (),
1383 _mfLength (),
1384 _mfTypes (),
1385 _mfColors (),
1386 _mfNormals ()
1387 {
1388 }
1389
1390
1391 /*-------------------------- destructors ----------------------------------*/
1392
1393 VTKPolyDataMapperBase::~VTKPolyDataMapperBase(void)
1394 {
1395 }
1396
1397 void VTKPolyDataMapperBase::onCreate(const VTKPolyDataMapper *source)
1398 {
1399 Inherited::onCreate(source);
1400
1401 if(source != NULL)
1402 {
1403 VTKPolyDataMapper *pThis = static_cast<VTKPolyDataMapper *>(this);
1404
1405 pThis->setRoot(source->getRoot());
1406
1407 MFUnrecNodePtr::const_iterator GeoRootsIt =
1408 source->_mfGeoRoots.begin();
1409 MFUnrecNodePtr::const_iterator GeoRootsEnd =
1410 source->_mfGeoRoots.end ();
1411
1412 while(GeoRootsIt != GeoRootsEnd)
1413 {
1414 pThis->pushToGeoRoots(*GeoRootsIt);
1415
1416 ++GeoRootsIt;
1417 }
1418
1419 MFUnrecGeometryPtr::const_iterator GeometriesIt =
1420 source->_mfGeometries.begin();
1421 MFUnrecGeometryPtr::const_iterator GeometriesEnd =
1422 source->_mfGeometries.end ();
1423
1424 while(GeometriesIt != GeometriesEnd)
1425 {
1426 pThis->pushToGeometries(*GeometriesIt);
1427
1428 ++GeometriesIt;
1429 }
1430
1431 MFUnrecChunkMaterialPtr::const_iterator MaterialsIt =
1432 source->_mfMaterials.begin();
1433 MFUnrecChunkMaterialPtr::const_iterator MaterialsEnd =
1434 source->_mfMaterials.end ();
1435
1436 while(MaterialsIt != MaterialsEnd)
1437 {
1438 pThis->pushToMaterials(*MaterialsIt);
1439
1440 ++MaterialsIt;
1441 }
1442
1443 MFUnrecMaterialChunkPtr::const_iterator MaterialChunksIt =
1444 source->_mfMaterialChunks.begin();
1445 MFUnrecMaterialChunkPtr::const_iterator MaterialChunksEnd =
1446 source->_mfMaterialChunks.end ();
1447
1448 while(MaterialChunksIt != MaterialChunksEnd)
1449 {
1450 pThis->pushToMaterialChunks(*MaterialChunksIt);
1451
1452 ++MaterialChunksIt;
1453 }
1454
1455 MFUnrecGeoPnt3fPropertyPtr::const_iterator PositionsIt =
1456 source->_mfPositions.begin();
1457 MFUnrecGeoPnt3fPropertyPtr::const_iterator PositionsEnd =
1458 source->_mfPositions.end ();
1459
1460 while(PositionsIt != PositionsEnd)
1461 {
1462 pThis->pushToPositions(*PositionsIt);
1463
1464 ++PositionsIt;
1465 }
1466
1467 MFUnrecGeoUInt32PropertyPtr::const_iterator LengthIt =
1468 source->_mfLength.begin();
1469 MFUnrecGeoUInt32PropertyPtr::const_iterator LengthEnd =
1470 source->_mfLength.end ();
1471
1472 while(LengthIt != LengthEnd)
1473 {
1474 pThis->pushToLength(*LengthIt);
1475
1476 ++LengthIt;
1477 }
1478
1479 MFUnrecGeoUInt8PropertyPtr::const_iterator TypesIt =
1480 source->_mfTypes.begin();
1481 MFUnrecGeoUInt8PropertyPtr::const_iterator TypesEnd =
1482 source->_mfTypes.end ();
1483
1484 while(TypesIt != TypesEnd)
1485 {
1486 pThis->pushToTypes(*TypesIt);
1487
1488 ++TypesIt;
1489 }
1490
1491 MFUnrecGeoColor4fPropertyPtr::const_iterator ColorsIt =
1492 source->_mfColors.begin();
1493 MFUnrecGeoColor4fPropertyPtr::const_iterator ColorsEnd =
1494 source->_mfColors.end ();
1495
1496 while(ColorsIt != ColorsEnd)
1497 {
1498 pThis->pushToColors(*ColorsIt);
1499
1500 ++ColorsIt;
1501 }
1502
1503 MFUnrecGeoVec3fPropertyPtr::const_iterator NormalsIt =
1504 source->_mfNormals.begin();
1505 MFUnrecGeoVec3fPropertyPtr::const_iterator NormalsEnd =
1506 source->_mfNormals.end ();
1507
1508 while(NormalsIt != NormalsEnd)
1509 {
1510 pThis->pushToNormals(*NormalsIt);
1511
1512 ++NormalsIt;
1513 }
1514 }
1515 }
1516
1517 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleRoot (void) const
1518 {
1519 SFUnrecNodePtr::GetHandlePtr returnValue(
1520 new SFUnrecNodePtr::GetHandle(
1521 &_sfRoot,
1522 this->getType().getFieldDesc(RootFieldId),
1523 const_cast<VTKPolyDataMapperBase *>(this)));
1524
1525 return returnValue;
1526 }
1527
1528 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleRoot (void)
1529 {
1530 SFUnrecNodePtr::EditHandlePtr returnValue(
1531 new SFUnrecNodePtr::EditHandle(
1532 &_sfRoot,
1533 this->getType().getFieldDesc(RootFieldId),
1534 this));
1535
1536 returnValue->setSetMethod(
1537 boost::bind(&VTKPolyDataMapper::setRoot,
1538 static_cast<VTKPolyDataMapper *>(this), _1));
1539
1540 editSField(RootFieldMask);
1541
1542 return returnValue;
1543 }
1544
1545 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleGeoRoots (void) const
1546 {
1547 MFUnrecNodePtr::GetHandlePtr returnValue(
1548 new MFUnrecNodePtr::GetHandle(
1549 &_mfGeoRoots,
1550 this->getType().getFieldDesc(GeoRootsFieldId),
1551 const_cast<VTKPolyDataMapperBase *>(this)));
1552
1553 return returnValue;
1554 }
1555
1556 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleGeoRoots (void)
1557 {
1558 MFUnrecNodePtr::EditHandlePtr returnValue(
1559 new MFUnrecNodePtr::EditHandle(
1560 &_mfGeoRoots,
1561 this->getType().getFieldDesc(GeoRootsFieldId),
1562 this));
1563
1564 returnValue->setAddMethod(
1565 boost::bind(&VTKPolyDataMapper::pushToGeoRoots,
1566 static_cast<VTKPolyDataMapper *>(this), _1));
1567 returnValue->setRemoveMethod(
1568 boost::bind(&VTKPolyDataMapper::removeFromGeoRoots,
1569 static_cast<VTKPolyDataMapper *>(this), _1));
1570 returnValue->setRemoveObjMethod(
1571 boost::bind(&VTKPolyDataMapper::removeObjFromGeoRoots,
1572 static_cast<VTKPolyDataMapper *>(this), _1));
1573 returnValue->setClearMethod(
1574 boost::bind(&VTKPolyDataMapper::clearGeoRoots,
1575 static_cast<VTKPolyDataMapper *>(this)));
1576
1577 editMField(GeoRootsFieldMask, _mfGeoRoots);
1578
1579 return returnValue;
1580 }
1581
1582 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleGeometries (void) const
1583 {
1584 MFUnrecGeometryPtr::GetHandlePtr returnValue(
1585 new MFUnrecGeometryPtr::GetHandle(
1586 &_mfGeometries,
1587 this->getType().getFieldDesc(GeometriesFieldId),
1588 const_cast<VTKPolyDataMapperBase *>(this)));
1589
1590 return returnValue;
1591 }
1592
1593 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleGeometries (void)
1594 {
1595 MFUnrecGeometryPtr::EditHandlePtr returnValue(
1596 new MFUnrecGeometryPtr::EditHandle(
1597 &_mfGeometries,
1598 this->getType().getFieldDesc(GeometriesFieldId),
1599 this));
1600
1601 returnValue->setAddMethod(
1602 boost::bind(&VTKPolyDataMapper::pushToGeometries,
1603 static_cast<VTKPolyDataMapper *>(this), _1));
1604 returnValue->setRemoveMethod(
1605 boost::bind(&VTKPolyDataMapper::removeFromGeometries,
1606 static_cast<VTKPolyDataMapper *>(this), _1));
1607 returnValue->setRemoveObjMethod(
1608 boost::bind(&VTKPolyDataMapper::removeObjFromGeometries,
1609 static_cast<VTKPolyDataMapper *>(this), _1));
1610 returnValue->setClearMethod(
1611 boost::bind(&VTKPolyDataMapper::clearGeometries,
1612 static_cast<VTKPolyDataMapper *>(this)));
1613
1614 editMField(GeometriesFieldMask, _mfGeometries);
1615
1616 return returnValue;
1617 }
1618
1619 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleMaterials (void) const
1620 {
1621 MFUnrecChunkMaterialPtr::GetHandlePtr returnValue(
1622 new MFUnrecChunkMaterialPtr::GetHandle(
1623 &_mfMaterials,
1624 this->getType().getFieldDesc(MaterialsFieldId),
1625 const_cast<VTKPolyDataMapperBase *>(this)));
1626
1627 return returnValue;
1628 }
1629
1630 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleMaterials (void)
1631 {
1632 MFUnrecChunkMaterialPtr::EditHandlePtr returnValue(
1633 new MFUnrecChunkMaterialPtr::EditHandle(
1634 &_mfMaterials,
1635 this->getType().getFieldDesc(MaterialsFieldId),
1636 this));
1637
1638 returnValue->setAddMethod(
1639 boost::bind(&VTKPolyDataMapper::pushToMaterials,
1640 static_cast<VTKPolyDataMapper *>(this), _1));
1641 returnValue->setRemoveMethod(
1642 boost::bind(&VTKPolyDataMapper::removeFromMaterials,
1643 static_cast<VTKPolyDataMapper *>(this), _1));
1644 returnValue->setRemoveObjMethod(
1645 boost::bind(&VTKPolyDataMapper::removeObjFromMaterials,
1646 static_cast<VTKPolyDataMapper *>(this), _1));
1647 returnValue->setClearMethod(
1648 boost::bind(&VTKPolyDataMapper::clearMaterials,
1649 static_cast<VTKPolyDataMapper *>(this)));
1650
1651 editMField(MaterialsFieldMask, _mfMaterials);
1652
1653 return returnValue;
1654 }
1655
1656 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleMaterialChunks (void) const
1657 {
1658 MFUnrecMaterialChunkPtr::GetHandlePtr returnValue(
1659 new MFUnrecMaterialChunkPtr::GetHandle(
1660 &_mfMaterialChunks,
1661 this->getType().getFieldDesc(MaterialChunksFieldId),
1662 const_cast<VTKPolyDataMapperBase *>(this)));
1663
1664 return returnValue;
1665 }
1666
1667 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleMaterialChunks (void)
1668 {
1669 MFUnrecMaterialChunkPtr::EditHandlePtr returnValue(
1670 new MFUnrecMaterialChunkPtr::EditHandle(
1671 &_mfMaterialChunks,
1672 this->getType().getFieldDesc(MaterialChunksFieldId),
1673 this));
1674
1675 returnValue->setAddMethod(
1676 boost::bind(&VTKPolyDataMapper::pushToMaterialChunks,
1677 static_cast<VTKPolyDataMapper *>(this), _1));
1678 returnValue->setRemoveMethod(
1679 boost::bind(&VTKPolyDataMapper::removeFromMaterialChunks,
1680 static_cast<VTKPolyDataMapper *>(this), _1));
1681 returnValue->setRemoveObjMethod(
1682 boost::bind(&VTKPolyDataMapper::removeObjFromMaterialChunks,
1683 static_cast<VTKPolyDataMapper *>(this), _1));
1684 returnValue->setClearMethod(
1685 boost::bind(&VTKPolyDataMapper::clearMaterialChunks,
1686 static_cast<VTKPolyDataMapper *>(this)));
1687
1688 editMField(MaterialChunksFieldMask, _mfMaterialChunks);
1689
1690 return returnValue;
1691 }
1692
1693 GetFieldHandlePtr VTKPolyDataMapperBase::getHandlePositions (void) const
1694 {
1695 MFUnrecGeoPnt3fPropertyPtr::GetHandlePtr returnValue(
1696 new MFUnrecGeoPnt3fPropertyPtr::GetHandle(
1697 &_mfPositions,
1698 this->getType().getFieldDesc(PositionsFieldId),
1699 const_cast<VTKPolyDataMapperBase *>(this)));
1700
1701 return returnValue;
1702 }
1703
1704 EditFieldHandlePtr VTKPolyDataMapperBase::editHandlePositions (void)
1705 {
1706 MFUnrecGeoPnt3fPropertyPtr::EditHandlePtr returnValue(
1707 new MFUnrecGeoPnt3fPropertyPtr::EditHandle(
1708 &_mfPositions,
1709 this->getType().getFieldDesc(PositionsFieldId),
1710 this));
1711
1712 returnValue->setAddMethod(
1713 boost::bind(&VTKPolyDataMapper::pushToPositions,
1714 static_cast<VTKPolyDataMapper *>(this), _1));
1715 returnValue->setRemoveMethod(
1716 boost::bind(&VTKPolyDataMapper::removeFromPositions,
1717 static_cast<VTKPolyDataMapper *>(this), _1));
1718 returnValue->setRemoveObjMethod(
1719 boost::bind(&VTKPolyDataMapper::removeObjFromPositions,
1720 static_cast<VTKPolyDataMapper *>(this), _1));
1721 returnValue->setClearMethod(
1722 boost::bind(&VTKPolyDataMapper::clearPositions,
1723 static_cast<VTKPolyDataMapper *>(this)));
1724
1725 editMField(PositionsFieldMask, _mfPositions);
1726
1727 return returnValue;
1728 }
1729
1730 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleLength (void) const
1731 {
1732 MFUnrecGeoUInt32PropertyPtr::GetHandlePtr returnValue(
1733 new MFUnrecGeoUInt32PropertyPtr::GetHandle(
1734 &_mfLength,
1735 this->getType().getFieldDesc(LengthFieldId),
1736 const_cast<VTKPolyDataMapperBase *>(this)));
1737
1738 return returnValue;
1739 }
1740
1741 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleLength (void)
1742 {
1743 MFUnrecGeoUInt32PropertyPtr::EditHandlePtr returnValue(
1744 new MFUnrecGeoUInt32PropertyPtr::EditHandle(
1745 &_mfLength,
1746 this->getType().getFieldDesc(LengthFieldId),
1747 this));
1748
1749 returnValue->setAddMethod(
1750 boost::bind(&VTKPolyDataMapper::pushToLength,
1751 static_cast<VTKPolyDataMapper *>(this), _1));
1752 returnValue->setRemoveMethod(
1753 boost::bind(&VTKPolyDataMapper::removeFromLength,
1754 static_cast<VTKPolyDataMapper *>(this), _1));
1755 returnValue->setRemoveObjMethod(
1756 boost::bind(&VTKPolyDataMapper::removeObjFromLength,
1757 static_cast<VTKPolyDataMapper *>(this), _1));
1758 returnValue->setClearMethod(
1759 boost::bind(&VTKPolyDataMapper::clearLength,
1760 static_cast<VTKPolyDataMapper *>(this)));
1761
1762 editMField(LengthFieldMask, _mfLength);
1763
1764 return returnValue;
1765 }
1766
1767 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleTypes (void) const
1768 {
1769 MFUnrecGeoUInt8PropertyPtr::GetHandlePtr returnValue(
1770 new MFUnrecGeoUInt8PropertyPtr::GetHandle(
1771 &_mfTypes,
1772 this->getType().getFieldDesc(TypesFieldId),
1773 const_cast<VTKPolyDataMapperBase *>(this)));
1774
1775 return returnValue;
1776 }
1777
1778 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleTypes (void)
1779 {
1780 MFUnrecGeoUInt8PropertyPtr::EditHandlePtr returnValue(
1781 new MFUnrecGeoUInt8PropertyPtr::EditHandle(
1782 &_mfTypes,
1783 this->getType().getFieldDesc(TypesFieldId),
1784 this));
1785
1786 returnValue->setAddMethod(
1787 boost::bind(&VTKPolyDataMapper::pushToTypes,
1788 static_cast<VTKPolyDataMapper *>(this), _1));
1789 returnValue->setRemoveMethod(
1790 boost::bind(&VTKPolyDataMapper::removeFromTypes,
1791 static_cast<VTKPolyDataMapper *>(this), _1));
1792 returnValue->setRemoveObjMethod(
1793 boost::bind(&VTKPolyDataMapper::removeObjFromTypes,
1794 static_cast<VTKPolyDataMapper *>(this), _1));
1795 returnValue->setClearMethod(
1796 boost::bind(&VTKPolyDataMapper::clearTypes,
1797 static_cast<VTKPolyDataMapper *>(this)));
1798
1799 editMField(TypesFieldMask, _mfTypes);
1800
1801 return returnValue;
1802 }
1803
1804 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleColors (void) const
1805 {
1806 MFUnrecGeoColor4fPropertyPtr::GetHandlePtr returnValue(
1807 new MFUnrecGeoColor4fPropertyPtr::GetHandle(
1808 &_mfColors,
1809 this->getType().getFieldDesc(ColorsFieldId),
1810 const_cast<VTKPolyDataMapperBase *>(this)));
1811
1812 return returnValue;
1813 }
1814
1815 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleColors (void)
1816 {
1817 MFUnrecGeoColor4fPropertyPtr::EditHandlePtr returnValue(
1818 new MFUnrecGeoColor4fPropertyPtr::EditHandle(
1819 &_mfColors,
1820 this->getType().getFieldDesc(ColorsFieldId),
1821 this));
1822
1823 returnValue->setAddMethod(
1824 boost::bind(&VTKPolyDataMapper::pushToColors,
1825 static_cast<VTKPolyDataMapper *>(this), _1));
1826 returnValue->setRemoveMethod(
1827 boost::bind(&VTKPolyDataMapper::removeFromColors,
1828 static_cast<VTKPolyDataMapper *>(this), _1));
1829 returnValue->setRemoveObjMethod(
1830 boost::bind(&VTKPolyDataMapper::removeObjFromColors,
1831 static_cast<VTKPolyDataMapper *>(this), _1));
1832 returnValue->setClearMethod(
1833 boost::bind(&VTKPolyDataMapper::clearColors,
1834 static_cast<VTKPolyDataMapper *>(this)));
1835
1836 editMField(ColorsFieldMask, _mfColors);
1837
1838 return returnValue;
1839 }
1840
1841 GetFieldHandlePtr VTKPolyDataMapperBase::getHandleNormals (void) const
1842 {
1843 MFUnrecGeoVec3fPropertyPtr::GetHandlePtr returnValue(
1844 new MFUnrecGeoVec3fPropertyPtr::GetHandle(
1845 &_mfNormals,
1846 this->getType().getFieldDesc(NormalsFieldId),
1847 const_cast<VTKPolyDataMapperBase *>(this)));
1848
1849 return returnValue;
1850 }
1851
1852 EditFieldHandlePtr VTKPolyDataMapperBase::editHandleNormals (void)
1853 {
1854 MFUnrecGeoVec3fPropertyPtr::EditHandlePtr returnValue(
1855 new MFUnrecGeoVec3fPropertyPtr::EditHandle(
1856 &_mfNormals,
1857 this->getType().getFieldDesc(NormalsFieldId),
1858 this));
1859
1860 returnValue->setAddMethod(
1861 boost::bind(&VTKPolyDataMapper::pushToNormals,
1862 static_cast<VTKPolyDataMapper *>(this), _1));
1863 returnValue->setRemoveMethod(
1864 boost::bind(&VTKPolyDataMapper::removeFromNormals,
1865 static_cast<VTKPolyDataMapper *>(this), _1));
1866 returnValue->setRemoveObjMethod(
1867 boost::bind(&VTKPolyDataMapper::removeObjFromNormals,
1868 static_cast<VTKPolyDataMapper *>(this), _1));
1869 returnValue->setClearMethod(
1870 boost::bind(&VTKPolyDataMapper::clearNormals,
1871 static_cast<VTKPolyDataMapper *>(this)));
1872
1873 editMField(NormalsFieldMask, _mfNormals);
1874
1875 return returnValue;
1876 }
1877
1878
1879 #ifdef OSG_MT_CPTR_ASPECT
1880 void VTKPolyDataMapperBase::execSyncV( FieldContainer &oFrom,
1881 ConstFieldMaskArg whichField,
1882 AspectOffsetStore &oOffsets,
1883 ConstFieldMaskArg syncMode,
1884 const UInt32 uiSyncInfo)
1885 {
1886 VTKPolyDataMapper *pThis = static_cast<VTKPolyDataMapper *>(this);
1887
1888 pThis->execSync(static_cast<VTKPolyDataMapper *>(&oFrom),
1889 whichField,
1890 oOffsets,
1891 syncMode,
1892 uiSyncInfo);
1893 }
1894 #endif
1895
1896
1897 #ifdef OSG_MT_CPTR_ASPECT
1898 FieldContainer *VTKPolyDataMapperBase::createAspectCopy(
1899 const FieldContainer *pRefAspect) const
1900 {
1901 VTKPolyDataMapper *returnValue;
1902
1903 newAspectCopy(returnValue,
1904 dynamic_cast<const VTKPolyDataMapper *>(pRefAspect),
1905 dynamic_cast<const VTKPolyDataMapper *>(this));
1906
1907 return returnValue;
1908 }
1909 #endif
1910
1911 void VTKPolyDataMapperBase::resolveLinks(void)
1912 {
1913 Inherited::resolveLinks();
1914
1915 static_cast<VTKPolyDataMapper *>(this)->setRoot(NULL);
1916
1917 static_cast<VTKPolyDataMapper *>(this)->clearGeoRoots();
1918
1919 static_cast<VTKPolyDataMapper *>(this)->clearGeometries();
1920
1921 static_cast<VTKPolyDataMapper *>(this)->clearMaterials();
1922
1923 static_cast<VTKPolyDataMapper *>(this)->clearMaterialChunks();
1924
1925 static_cast<VTKPolyDataMapper *>(this)->clearPositions();
1926
1927 static_cast<VTKPolyDataMapper *>(this)->clearLength();
1928
1929 static_cast<VTKPolyDataMapper *>(this)->clearTypes();
1930
1931 static_cast<VTKPolyDataMapper *>(this)->clearColors();
1932
1933 static_cast<VTKPolyDataMapper *>(this)->clearNormals();
1934
1935
1936 }
1937
1938
1939 OSG_END_NAMESPACE