Show
Ignore:
Timestamp:
05/05/08 06:39:01 (3 months ago)
Author:
vossg
Message:

changed: base rebuild

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/Source/Contrib/VTK/OSGVTKMapperBase.cpp

    r1178 r1193  
    402402} 
    403403 
     404SFUnrecNodePtr      *VTKMapperBase::editSFRoot           (void) 
     405{ 
     406    editSField(RootFieldMask); 
     407 
     408    return &_sfRoot; 
     409} 
     410 
    404411//! Get the VTKMapper::_mfGeoRoots field. 
    405412const MFUnrecNodePtr *VTKMapperBase::getMFGeoRoots(void) const 
    …… 
    408415} 
    409416 
     417MFUnrecNodePtr      *VTKMapperBase::editMFGeoRoots       (void) 
     418{ 
     419    editMField(GeoRootsFieldMask, _mfGeoRoots); 
     420 
     421    return &_mfGeoRoots; 
     422} 
     423 
    410424//! Get the VTKMapper::_mfGeometries field. 
    411425const MFUnrecGeometryPtr *VTKMapperBase::getMFGeometries(void) const 
    …… 
    414428} 
    415429 
     430MFUnrecGeometryPtr  *VTKMapperBase::editMFGeometries     (void) 
     431{ 
     432    editMField(GeometriesFieldMask, _mfGeometries); 
     433 
     434    return &_mfGeometries; 
     435} 
     436 
    416437//! Get the VTKMapper::_mfMaterials field. 
    417438const MFUnrecChunkMaterialPtr *VTKMapperBase::getMFMaterials(void) const 
    …… 
    420441} 
    421442 
     443MFUnrecChunkMaterialPtr *VTKMapperBase::editMFMaterials      (void) 
     444{ 
     445    editMField(MaterialsFieldMask, _mfMaterials); 
     446 
     447    return &_mfMaterials; 
     448} 
     449 
    422450//! Get the VTKMapper::_mfMaterialChunks field. 
    423451const MFUnrecMaterialChunkPtr *VTKMapperBase::getMFMaterialChunks(void) const 
    …… 
    426454} 
    427455 
     456MFUnrecMaterialChunkPtr *VTKMapperBase::editMFMaterialChunks (void) 
     457{ 
     458    editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
     459 
     460    return &_mfMaterialChunks; 
     461} 
     462 
    428463//! Get the VTKMapper::_mfPositions field. 
    429464const MFUnrecGeoPnt3fPropertyPtr *VTKMapperBase::getMFPositions(void) const 
    …… 
    432467} 
    433468 
     469MFUnrecGeoPnt3fPropertyPtr *VTKMapperBase::editMFPositions      (void) 
     470{ 
     471    editMField(PositionsFieldMask, _mfPositions); 
     472 
     473    return &_mfPositions; 
     474} 
     475 
    434476//! Get the VTKMapper::_mfLength field. 
    435477const MFUnrecGeoUInt32PropertyPtr *VTKMapperBase::getMFLength(void) const 
    …… 
    438480} 
    439481 
     482MFUnrecGeoUInt32PropertyPtr *VTKMapperBase::editMFLength         (void) 
     483{ 
     484    editMField(LengthFieldMask, _mfLength); 
     485 
     486    return &_mfLength; 
     487} 
     488 
    440489//! Get the VTKMapper::_mfTypes field. 
    441490const MFUnrecGeoUInt8PropertyPtr *VTKMapperBase::getMFTypes(void) const 
    …… 
    444493} 
    445494 
     495MFUnrecGeoUInt8PropertyPtr *VTKMapperBase::editMFTypes          (void) 
     496{ 
     497    editMField(TypesFieldMask, _mfTypes); 
     498 
     499    return &_mfTypes; 
     500} 
     501 
    446502//! Get the VTKMapper::_mfColors field. 
    447503const MFUnrecGeoColor4fPropertyPtr *VTKMapperBase::getMFColors(void) const 
    …… 
    450506} 
    451507 
     508MFUnrecGeoColor4fPropertyPtr *VTKMapperBase::editMFColors         (void) 
     509{ 
     510    editMField(ColorsFieldMask, _mfColors); 
     511 
     512    return &_mfColors; 
     513} 
     514 
    452515//! Get the VTKMapper::_mfNormals field. 
    453516const MFUnrecGeoVec3fPropertyPtr *VTKMapperBase::getMFNormals(void) const 
    …… 
    456519} 
    457520 
     521MFUnrecGeoVec3fPropertyPtr *VTKMapperBase::editMFNormals        (void) 
     522{ 
     523    editMField(NormalsFieldMask, _mfNormals); 
     524 
     525    return &_mfNormals; 
     526} 
     527 
    458528 
    459529 
    460530void VTKMapperBase::pushToGeoRoots(const NodePtr value) 
    461531{ 
    462     if(value == NullFC) 
    463         return; 
    464  
    465532    editMField(GeoRootsFieldMask, _mfGeoRoots); 
    466  
    467     //addRef(value); 
    468533 
    469534    _mfGeoRoots.push_back(value); 
    …… 
    487552} 
    488553 
    489 void VTKMapperBase::insertIntoGeoRoots(      UInt32         uiIndex, 
    490                                                    const NodePtr value   ) 
    491 { 
    492     if(value == NullFC) 
    493         return; 
    494  
     554void VTKMapperBase::removeFromGeoRoots(UInt32 uiIndex) 
     555{ 
     556    if(uiIndex < _mfGeoRoots.size()) 
     557    { 
     558        editMField(GeoRootsFieldMask, _mfGeoRoots); 
     559 
     560        MFUnrecNodePtr::iterator fieldIt = _mfGeoRoots.begin_nc(); 
     561 
     562        fieldIt += uiIndex; 
     563 
     564        _mfGeoRoots.erase(fieldIt); 
     565    } 
     566} 
     567 
     568void VTKMapperBase::removeFromGeoRoots(const NodePtr value) 
     569{ 
     570    Int32 iElemIdx = _mfGeoRoots.findIndex(value); 
     571 
     572    if(iElemIdx != -1) 
     573    { 
     574        editMField(GeoRootsFieldMask, _mfGeoRoots); 
     575 
     576        MFUnrecNodePtr::iterator fieldIt = _mfGeoRoots.begin_nc(); 
     577 
     578        fieldIt += iElemIdx; 
     579 
     580        _mfGeoRoots.erase(fieldIt); 
     581    } 
     582} 
     583void VTKMapperBase::clearGeoRoots(void) 
     584{ 
    495585    editMField(GeoRootsFieldMask, _mfGeoRoots); 
    496586 
    497     MFUnrecNodePtr::iterator fieldIt = _mfGeoRoots.begin_nc(); 
    498  
    499     //addRef(value); 
    500  
    501     fieldIt += uiIndex; 
    502  
    503     _mfGeoRoots.insert(fieldIt, value); 
    504 } 
    505  
    506 void VTKMapperBase::replaceInGeoRoots(      UInt32         uiIndex, 
    507                                                        const NodePtr value   ) 
    508 { 
    509     if(value == NullFC) 
    510         return; 
    511  
    512     if(uiIndex >= _mfGeoRoots.size()) 
    513         return; 
    514  
    515     editMField(GeoRootsFieldMask, _mfGeoRoots); 
    516  
    517  
    518 //    addRef(value); 
    519 //    subRef(_mfGeoRoots[uiIndex]); 
    520  
    521 //    _mfGeoRoots[uiIndex] = value; 
    522  
    523       _mfGeoRoots.replace(uiIndex, value); 
    524 } 
    525  
    526 void VTKMapperBase::replaceInGeoRoots(const NodePtr pOldElem, 
    527                                                         const NodePtr pNewElem) 
    528 { 
    529     if(pNewElem == NullFC) 
    530         return; 
    531  
    532     Int32  elemIdx = _mfGeoRoots.findIndex(pOldElem); 
    533  
    534     if(elemIdx != -1) 
    535     { 
    536         editMField(GeoRootsFieldMask, _mfGeoRoots); 
    537  
    538 //        MFNodePtr::iterator fieldIt = _mfGeoRoots.begin(); 
    539  
    540 //        fieldIt += elemIdx; 
    541 //        addRef(pNewElem); 
    542 //        subRef(pOldElem); 
    543  
    544 //        (*fieldIt) = pNewElem; 
    545           _mfGeoRoots.replace(elemIdx, pNewElem); 
    546     } 
    547 } 
    548  
    549 void VTKMapperBase::removeFromGeoRoots(UInt32 uiIndex) 
    550 { 
    551     if(uiIndex < _mfGeoRoots.size()) 
    552     { 
    553         editMField(GeoRootsFieldMask, _mfGeoRoots); 
    554  
    555         MFUnrecNodePtr::iterator fieldIt = _mfGeoRoots.begin_nc(); 
    556  
    557         fieldIt += uiIndex; 
    558  
    559         //subRef(*fieldIt); 
    560  
    561         _mfGeoRoots.erase(fieldIt); 
    562     } 
    563 } 
    564  
    565 void VTKMapperBase::removeFromGeoRoots(const NodePtr value) 
    566 { 
    567     Int32 iElemIdx = _mfGeoRoots.findIndex(value); 
    568  
    569     if(iElemIdx != -1) 
    570     { 
    571         editMField(GeoRootsFieldMask, _mfGeoRoots); 
    572  
    573         MFUnrecNodePtr::iterator fieldIt = _mfGeoRoots.begin_nc(); 
    574  
    575         fieldIt += iElemIdx; 
    576  
    577         //subRef(*fieldIt); 
    578  
    579         _mfGeoRoots.erase(fieldIt); 
    580     } 
    581 } 
    582 void VTKMapperBase::clearGeoRoots(void) 
    583 { 
    584     editMField(GeoRootsFieldMask, _mfGeoRoots); 
    585  
    586587 
    587588    _mfGeoRoots.clear(); 
    …… 
    590591void VTKMapperBase::pushToGeometries(const GeometryPtr value) 
    591592{ 
    592     if(value == NullFC) 
    593         return; 
    594  
    595593    editMField(GeometriesFieldMask, _mfGeometries); 
    596  
    597     //addRef(value); 
    598594 
    599595    _mfGeometries.push_back(value); 
    …… 
    617613} 
    618614 
    619 void VTKMapperBase::insertIntoGeometries(      UInt32         uiIndex, 
    620                                                    const GeometryPtr value   ) 
    621 { 
    622     if(value == NullFC) 
    623         return; 
    624  
     615void VTKMapperBase::removeFromGeometries(UInt32 uiIndex) 
     616{ 
     617    if(uiIndex < _mfGeometries.size()) 
     618    { 
     619        editMField(GeometriesFieldMask, _mfGeometries); 
     620 
     621        MFUnrecGeometryPtr::iterator fieldIt = _mfGeometries.begin_nc(); 
     622 
     623        fieldIt += uiIndex; 
     624 
     625        _mfGeometries.erase(fieldIt); 
     626    } 
     627} 
     628 
     629void VTKMapperBase::removeFromGeometries(const GeometryPtr value) 
     630{ 
     631    Int32 iElemIdx = _mfGeometries.findIndex(value); 
     632 
     633    if(iElemIdx != -1) 
     634    { 
     635        editMField(GeometriesFieldMask, _mfGeometries); 
     636 
     637        MFUnrecGeometryPtr::iterator fieldIt = _mfGeometries.begin_nc(); 
     638 
     639        fieldIt += iElemIdx; 
     640 
     641        _mfGeometries.erase(fieldIt); 
     642    } 
     643} 
     644void VTKMapperBase::clearGeometries(void) 
     645{ 
    625646    editMField(GeometriesFieldMask, _mfGeometries); 
    626647 
    627     MFUnrecGeometryPtr::iterator fieldIt = _mfGeometries.begin_nc(); 
    628  
    629     //addRef(value); 
    630  
    631     fieldIt += uiIndex; 
    632  
    633     _mfGeometries.insert(fieldIt, value); 
    634 } 
    635  
    636 void VTKMapperBase::replaceInGeometries(      UInt32         uiIndex, 
    637                                                        const GeometryPtr value   ) 
    638 { 
    639     if(value == NullFC) 
    640         return; 
    641  
    642     if(uiIndex >= _mfGeometries.size()) 
    643         return; 
    644  
    645     editMField(GeometriesFieldMask, _mfGeometries); 
    646  
    647  
    648 //    addRef(value); 
    649 //    subRef(_mfGeometries[uiIndex]); 
    650  
    651 //    _mfGeometries[uiIndex] = value; 
    652  
    653       _mfGeometries.replace(uiIndex, value); 
    654 } 
    655  
    656 void VTKMapperBase::replaceInGeometries(const GeometryPtr pOldElem, 
    657                                                         const GeometryPtr pNewElem) 
    658 { 
    659     if(pNewElem == NullFC) 
    660         return; 
    661  
    662     Int32  elemIdx = _mfGeometries.findIndex(pOldElem); 
    663  
    664     if(elemIdx != -1) 
    665     { 
    666         editMField(GeometriesFieldMask, _mfGeometries); 
    667  
    668 //        MFGeometryPtr::iterator fieldIt = _mfGeometries.begin(); 
    669  
    670 //        fieldIt += elemIdx; 
    671 //        addRef(pNewElem); 
    672 //        subRef(pOldElem); 
    673  
    674 //        (*fieldIt) = pNewElem; 
    675           _mfGeometries.replace(elemIdx, pNewElem); 
    676     } 
    677 } 
    678  
    679 void VTKMapperBase::removeFromGeometries(UInt32 uiIndex) 
    680 { 
    681     if(uiIndex < _mfGeometries.size()) 
    682     { 
    683         editMField(GeometriesFieldMask, _mfGeometries); 
    684  
    685         MFUnrecGeometryPtr::iterator fieldIt = _mfGeometries.begin_nc(); 
    686  
    687         fieldIt += uiIndex; 
    688  
    689         //subRef(*fieldIt); 
    690  
    691         _mfGeometries.erase(fieldIt); 
    692     } 
    693 } 
    694  
    695 void VTKMapperBase::removeFromGeometries(const GeometryPtr value) 
    696 { 
    697     Int32 iElemIdx = _mfGeometries.findIndex(value); 
    698  
    699     if(iElemIdx != -1) 
    700     { 
    701         editMField(GeometriesFieldMask, _mfGeometries); 
    702  
    703         MFUnrecGeometryPtr::iterator fieldIt = _mfGeometries.begin_nc(); 
    704  
    705         fieldIt += iElemIdx; 
    706  
    707         //subRef(*fieldIt); 
    708  
    709         _mfGeometries.erase(fieldIt); 
    710     } 
    711 } 
    712 void VTKMapperBase::clearGeometries(void) 
    713 { 
    714     editMField(GeometriesFieldMask, _mfGeometries); 
    715  
    716648 
    717649    _mfGeometries.clear(); 
    …… 
    720652void VTKMapperBase::pushToMaterials(const ChunkMaterialPtr value) 
    721653{ 
    722     if(value == NullFC) 
    723         return; 
    724  
    725654    editMField(MaterialsFieldMask, _mfMaterials); 
    726  
    727     //addRef(value); 
    728655 
    729656    _mfMaterials.push_back(value); 
    …… 
    747674} 
    748675 
    749 void VTKMapperBase::insertIntoMaterials(      UInt32         uiIndex, 
    750                                                    const ChunkMaterialPtr value   ) 
    751 { 
    752     if(value == NullFC) 
    753         return; 
    754  
     676void VTKMapperBase::removeFromMaterials(UInt32 uiIndex) 
     677{ 
     678    if(uiIndex < _mfMaterials.size()) 
     679    { 
     680        editMField(MaterialsFieldMask, _mfMaterials); 
     681 
     682        MFUnrecChunkMaterialPtr::iterator fieldIt = _mfMaterials.begin_nc(); 
     683 
     684        fieldIt += uiIndex; 
     685 
     686        _mfMaterials.erase(fieldIt); 
     687    } 
     688} 
     689 
     690void VTKMapperBase::removeFromMaterials(const ChunkMaterialPtr value) 
     691{ 
     692    Int32 iElemIdx = _mfMaterials.findIndex(value); 
     693 
     694    if(iElemIdx != -1) 
     695    { 
     696        editMField(MaterialsFieldMask, _mfMaterials); 
     697 
     698        MFUnrecChunkMaterialPtr::iterator fieldIt = _mfMaterials.begin_nc(); 
     699 
     700        fieldIt += iElemIdx; 
     701 
     702        _mfMaterials.erase(fieldIt); 
     703    } 
     704} 
     705void VTKMapperBase::clearMaterials(void) 
     706{ 
    755707    editMField(MaterialsFieldMask, _mfMaterials); 
    756708 
    757     MFUnrecChunkMaterialPtr::iterator fieldIt = _mfMaterials.begin_nc(); 
    758  
    759     //addRef(value); 
    760  
    761     fieldIt += uiIndex; 
    762  
    763     _mfMaterials.insert(fieldIt, value); 
    764 } 
    765  
    766 void VTKMapperBase::replaceInMaterials(      UInt32         uiIndex, 
    767                                                        const ChunkMaterialPtr value   ) 
    768 { 
    769     if(value == NullFC) 
    770         return; 
    771  
    772     if(uiIndex >= _mfMaterials.size()) 
    773         return; 
    774  
    775     editMField(MaterialsFieldMask, _mfMaterials); 
    776  
    777  
    778 //    addRef(value); 
    779 //    subRef(_mfMaterials[uiIndex]); 
    780  
    781 //    _mfMaterials[uiIndex] = value; 
    782  
    783       _mfMaterials.replace(uiIndex, value); 
    784 } 
    785  
    786 void VTKMapperBase::replaceInMaterials(const ChunkMaterialPtr pOldElem, 
    787                                                         const ChunkMaterialPtr pNewElem) 
    788 { 
    789     if(pNewElem == NullFC) 
    790         return; 
    791  
    792     Int32  elemIdx = _mfMaterials.findIndex(pOldElem); 
    793  
    794     if(elemIdx != -1) 
    795     { 
    796         editMField(MaterialsFieldMask, _mfMaterials); 
    797  
    798 //        MFChunkMaterialPtr::iterator fieldIt = _mfMaterials.begin(); 
    799  
    800 //        fieldIt += elemIdx; 
    801 //        addRef(pNewElem); 
    802 //        subRef(pOldElem); 
    803  
    804 //        (*fieldIt) = pNewElem; 
    805           _mfMaterials.replace(elemIdx, pNewElem); 
    806     } 
    807 } 
    808  
    809 void VTKMapperBase::removeFromMaterials(UInt32 uiIndex) 
    810 { 
    811     if(uiIndex < _mfMaterials.size()) 
    812     { 
    813         editMField(MaterialsFieldMask, _mfMaterials); 
    814  
    815         MFUnrecChunkMaterialPtr::iterator fieldIt = _mfMaterials.begin_nc(); 
    816  
    817         fieldIt += uiIndex; 
    818  
    819         //subRef(*fieldIt); 
    820  
    821         _mfMaterials.erase(fieldIt); 
    822     } 
    823 } 
    824  
    825 void VTKMapperBase::removeFromMaterials(const ChunkMaterialPtr value) 
    826 { 
    827     Int32 iElemIdx = _mfMaterials.findIndex(value); 
    828  
    829     if(iElemIdx != -1) 
    830     { 
    831         editMField(MaterialsFieldMask, _mfMaterials); 
    832  
    833         MFUnrecChunkMaterialPtr::iterator fieldIt = _mfMaterials.begin_nc(); 
    834  
    835         fieldIt += iElemIdx; 
    836  
    837         //subRef(*fieldIt); 
    838  
    839         _mfMaterials.erase(fieldIt); 
    840     } 
    841 } 
    842 void VTKMapperBase::clearMaterials(void) 
    843 { 
    844     editMField(MaterialsFieldMask, _mfMaterials); 
    845  
    846709 
    847710    _mfMaterials.clear(); 
    …… 
    850713void VTKMapperBase::pushToMaterialChunks(const MaterialChunkPtr value) 
    851714{ 
    852     if(value == NullFC) 
    853         return; 
    854  
    855715    editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    856  
    857     //addRef(value); 
    858716 
    859717    _mfMaterialChunks.push_back(value); 
    …… 
    877735} 
    878736 
    879 void VTKMapperBase::insertIntoMaterialChunks(      UInt32         uiIndex, 
    880                                                    const MaterialChunkPtr value   ) 
    881 { 
    882     if(value == NullFC) 
    883         return; 
    884  
     737void VTKMapperBase::removeFromMaterialChunks(UInt32 uiIndex) 
     738{ 
     739    if(uiIndex < _mfMaterialChunks.size()) 
     740    { 
     741        editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
     742 
     743        MFUnrecMaterialChunkPtr::iterator fieldIt = _mfMaterialChunks.begin_nc(); 
     744 
     745        fieldIt += uiIndex; 
     746 
     747        _mfMaterialChunks.erase(fieldIt); 
     748    } 
     749} 
     750 
     751void VTKMapperBase::removeFromMaterialChunks(const MaterialChunkPtr value) 
     752{ 
     753    Int32 iElemIdx = _mfMaterialChunks.findIndex(value); 
     754 
     755    if(iElemIdx != -1) 
     756    { 
     757        editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
     758 
     759        MFUnrecMaterialChunkPtr::iterator fieldIt = _mfMaterialChunks.begin_nc(); 
     760 
     761        fieldIt += iElemIdx; 
     762 
     763        _mfMaterialChunks.erase(fieldIt); 
     764    } 
     765} 
     766void VTKMapperBase::clearMaterialChunks(void) 
     767{ 
    885768    editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    886769 
    887     MFUnrecMaterialChunkPtr::iterator fieldIt = _mfMaterialChunks.begin_nc(); 
    888  
    889     //addRef(value); 
    890  
    891     fieldIt += uiIndex; 
    892  
    893     _mfMaterialChunks.insert(fieldIt, value); 
    894 } 
    895  
    896 void VTKMapperBase::replaceInMaterialChunks(      UInt32         uiIndex, 
    897                                                        const MaterialChunkPtr value   ) 
    898 { 
    899     if(value == NullFC) 
    900         return; 
    901  
    902     if(uiIndex >= _mfMaterialChunks.size()) 
    903         return; 
    904  
    905     editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    906  
    907  
    908 //    addRef(value); 
    909 //    subRef(_mfMaterialChunks[uiIndex]); 
    910  
    911 //    _mfMaterialChunks[uiIndex] = value; 
    912  
    913       _mfMaterialChunks.replace(uiIndex, value); 
    914 } 
    915  
    916 void VTKMapperBase::replaceInMaterialChunks(const MaterialChunkPtr pOldElem, 
    917                                                         const MaterialChunkPtr pNewElem) 
    918 { 
    919     if(pNewElem == NullFC) 
    920         return; 
    921  
    922     Int32  elemIdx = _mfMaterialChunks.findIndex(pOldElem); 
    923  
    924     if(elemIdx != -1) 
    925     { 
    926         editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    927  
    928 //        MFMaterialChunkPtr::iterator fieldIt = _mfMaterialChunks.begin(); 
    929  
    930 //        fieldIt += elemIdx; 
    931 //        addRef(pNewElem); 
    932 //        subRef(pOldElem); 
    933  
    934 //        (*fieldIt) = pNewElem; 
    935           _mfMaterialChunks.replace(elemIdx, pNewElem); 
    936     } 
    937 } 
    938  
    939 void VTKMapperBase::removeFromMaterialChunks(UInt32 uiIndex) 
    940 { 
    941     if(uiIndex < _mfMaterialChunks.size()) 
    942     { 
    943         editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    944  
    945         MFUnrecMaterialChunkPtr::iterator fieldIt = _mfMaterialChunks.begin_nc(); 
    946  
    947         fieldIt += uiIndex; 
    948  
    949         //subRef(*fieldIt); 
    950  
    951         _mfMaterialChunks.erase(fieldIt); 
    952     } 
    953 } 
    954  
    955 void VTKMapperBase::removeFromMaterialChunks(const MaterialChunkPtr value) 
    956 { 
    957     Int32 iElemIdx = _mfMaterialChunks.findIndex(value); 
    958  
    959     if(iElemIdx != -1) 
    960     { 
    961         editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    962  
    963         MFUnrecMaterialChunkPtr::iterator fieldIt = _mfMaterialChunks.begin_nc(); 
    964  
    965         fieldIt += iElemIdx; 
    966  
    967         //subRef(*fieldIt); 
    968  
    969         _mfMaterialChunks.erase(fieldIt); 
    970     } 
    971 } 
    972 void VTKMapperBase::clearMaterialChunks(void) 
    973 { 
    974     editMField(MaterialChunksFieldMask, _mfMaterialChunks); 
    975  
    976770 
    977771    _mfMaterialChunks.clear(); 
    …… 
    980774void VTKMapperBase::pushToPositions(const GeoPnt3fPropertyPtr value) 
    981775{ 
    982     if(value == NullFC) 
    983         return; 
    984  
    985776    editMField(PositionsFieldMask, _mfPositions); 
    986  
    987     //addRef(value); 
    988777 
    989778    _mfPositions.push_back(value); 
    …… 
    1007796} 
    1008797 
    1009 void VTKMapperBase::insertIntoPositions(      UInt32         uiIndex, 
    1010                                                    const GeoPnt3fPropertyPtr value   ) 
    1011 { 
    1012     if(value == NullFC) 
    1013         return; 
    1014  
     798void VTKMapperBase::removeFromPositions(UInt32 uiIndex) 
     799{ 
     800    if(uiIndex < _mfPositions.size()) 
     801    { 
     802        editMField(PositionsFieldMask, _mfPositions); 
     803 
     804        MFUnrecGeoPnt3fPropertyPtr::iterator fieldIt = _mfPositions.begin_nc(); 
     805 
     806        fieldIt += uiIndex; 
     807 
     808        _mfPositions.erase(fieldIt); 
     809    } 
     810} 
     811 
     812void VTKMapperBase::removeFromPositions(const GeoPnt3fPropertyPtr value) 
     813{ 
     814    Int32 iElemIdx = _mfPositions.findIndex(value); 
     815 
     816    if(iElemIdx != -1) 
     817    { 
     818        editMField(PositionsFieldMask, _mfPositions); 
     819 
     820        MFUnrecGeoPnt3fPropertyPtr::iterator fieldIt = _mfPositions.begin_nc(); 
     821 
     822        fieldIt += iElemIdx; 
     823 
     824        _mfPositions.erase(fieldIt); 
     825    } 
     826} 
     827void VTKMapperBase::clearPositions(void) 
     828{ 
    1015829    editMField(PositionsFieldMask, _mfPositions); 
    1016830 
    1017     MFUnrecGeoPnt3fPropertyPtr::iterator fieldIt = _mfPositions.begin_nc(); 
    1018  
    1019     //addRef(value); 
    1020  
    1021     fieldIt += uiIndex; 
    1022  
    1023     _mfPositions.insert(fieldIt, value); 
    1024 } 
    1025  
    1026 void VTKMapperBase::replaceInPositions(      UInt32         uiIndex, 
    1027                                                        const GeoPnt3fPropertyPtr value   ) 
    1028 { 
    1029     if(value == NullFC) 
    1030         return; 
    1031  
    1032     if(uiIndex >= _mfPositions.size()) 
    1033         return; 
    1034  
    1035     editMField(PositionsFieldMask, _mfPositions); 
    1036  
    1037  
    1038 //    addRef(value); 
    1039 //    subRef(_mfPositions[uiIndex]); 
    1040  
    1041 //    _mfPositions[uiIndex] = value; 
    1042  
    1043       _mfPositions.replace(uiIndex, value); 
    1044 } 
    1045  
    1046 void VTKMapperBase::replaceInPositions(const GeoPnt3fPropertyPtr pOldElem, 
    1047                                                         const GeoPnt3fPropertyPtr pNewElem) 
    1048 { 
    1049     if(pNewElem == NullFC) 
    1050         return; 
    1051  
    1052     Int32  elemIdx = _mfPositions.findIndex(pOldElem); 
    1053  
    1054     if(elemIdx != -1) 
    1055     { 
    1056         editMField(PositionsFieldMask, _mfPositions); 
    1057  
    1058 //        MFGeoPnt3fPropertyPtr::iterator fieldIt = _mfPositions.begin(); 
    1059  
    1060 //        fieldIt += elemIdx; 
    1061 //        addRef(pNewElem); 
    1062 //        subRef(pOldElem); 
    1063  
    1064 //        (*fieldIt) = pNewElem; 
    1065           _mfPositions.replace(elemIdx, pNewElem); 
    1066     } 
    1067 } 
    1068  
    1069 void VTKMapperBase::removeFromPositions(UInt32 uiIndex) 
    1070 { 
    1071     if(uiIndex < _mfPositions.size()) 
    1072     { 
    1073         editMField(PositionsFieldMask, _mfPositions); 
    1074  
    1075         MFUnrecGeoPnt3fPropertyPtr::iterator fieldIt = _mfPositions.begin_nc(); 
    1076  
    1077         fieldIt += uiIndex; 
    1078  
    1079         //subRef(*fieldIt); 
    1080  
    1081         _mfPositions.erase(fieldIt); 
    1082     } 
    1083 } 
    1084  
    1085 void VTKMapperBase::removeFromPositions(const GeoPnt3fPropertyPtr value) 
    1086 { 
    1087     Int32 iElemIdx = _mfPositions.findIndex(value); 
    1088  
    1089     if(iElemIdx != -1) 
    1090     { 
    1091         editMField(PositionsFieldMask, _mfPositions); 
    1092  
    1093         MFUnrecGeoPnt3fPropertyPtr::iterator fieldIt = _mfPositions.begin_nc(); 
    1094  
    1095         fieldIt += iElemIdx; 
    1096  
    1097         //subRef(*fieldIt); 
    1098  
    1099         _mfPositions.erase(fieldIt); 
    1100     } 
    1101 } 
    1102 void VTKMapperBase::clearPositions(void) 
    1103 { 
    1104     editMField(PositionsFieldMask, _mfPositions); 
    1105  
    1106831 
    1107832    _mfPositions.clear(); 
    …… 
    1110835void VTKMapperBase::pushToLength(const GeoUInt32PropertyPtr value) 
    1111836{ 
    1112     if(value == NullFC) 
    1113         return; 
    1114  
    1115837    editMField(LengthFieldMask, _mfLength); 
    1116  
    1117     //addRef(value); 
    1118838 
    1119839    _mfLength.push_back(value); 
    …… 
    1137857} 
    1138858 
    1139 void VTKMapperBase::insertIntoLength(      UInt32         uiIndex, 
    1140                                                    const GeoUInt32PropertyPtr value   ) 
    1141 { 
    1142     if(value == NullFC) 
    1143         return; 
    1144  
     859void VTKMapperBase::removeFromLength(UInt32 uiIndex) 
     860{ 
     861    if(uiIndex < _mfLength.size()) 
     862    { 
     863        editMField(LengthFieldMask, _mfLength); 
     864 
     865        MFUnrecGeoUInt32PropertyPtr::iterator fieldIt = _mfLength.begin_nc(); 
     866 
     867        fieldIt += uiIndex; 
     868 
     869        _mfLength.erase(fieldIt); 
     870    } 
     871} 
     872 
     873void VTKMapperBase::removeFromLength(const GeoUInt32PropertyPtr value) 
     874{ 
     875    Int32 iElemIdx = _mfLength.findIndex(value); 
     876 
     877    if(iElemIdx != -1) 
     878    { 
     879        editMField(LengthFieldMask, _mfLength); 
     880 
     881        MFUnrecGeoUInt32PropertyPtr::iterator fieldIt = _mfLength.begin_nc(); 
     882 
     883        fieldIt += iElemIdx; 
     884 
     885        _mfLength.erase(fieldIt); 
     886    } 
     887} 
     888void VTKMapperBase::clearLength(void) 
     889{ 
    1145890    editMField(LengthFieldMask, _mfLength); 
    1146891 
    1147     MFUnrecGeoUInt32PropertyPtr::iterator fieldIt = _mfLength.begin_nc(); 
    1148  
    1149     //addRef(value); 
    1150  
    1151     fieldIt += uiIndex; 
    1152  
    1153     _mfLength.insert(fieldIt, value); 
    1154 } 
    1155  
    1156 void VTKMapperBase::replaceInLength(      UInt32         uiIndex, 
    1157                                                        const GeoUInt32PropertyPtr value   ) 
    1158 { 
    1159     if(value == NullFC) 
    1160         return; 
    1161  
    1162     if(uiIndex >= _mfLength.size()) 
    1163         return; 
    1164  
    1165     editMField(LengthFieldMask, _mfLength); 
    1166  
    1167  
    1168 //    addRef(value); 
    1169 //    subRef(_mfLength[uiIndex]); 
    1170  
    1171 //    _mfLength[uiIndex] = value; 
    1172  
    1173       _mfLength.replace(uiIndex, value); 
    1174 } 
    1175  
    1176 void VTKMapperBase::replaceInLength(const GeoUInt32PropertyPtr pOldElem, 
    1177                                                         const GeoUInt32PropertyPtr pNewElem) 
    1178 { 
    1179     if(pNewElem == NullFC) 
    1180         return; 
    1181  
    1182     Int32  elemIdx = _mfLength.findIndex(pOldElem); 
    1183  
    1184     if(elemIdx != -1) 
    1185     { 
    1186         editMField(LengthFieldMask, _mfLength); 
    1187  
    1188 //        MFGeoUInt32PropertyPtr::iterator fieldIt = _mfLength.begin(); 
    1189  
    1190 //        fieldIt += elemIdx; 
    1191 //        addRef(pNewElem); 
    1192 //        subRef(pOldElem); 
    1193  
    1194 //        (*fieldIt) = pNewElem; 
    1195           _mfLength.replace(elemIdx, pNewElem); 
    1196     } 
    1197 } 
    1198  
    1199 void VTKMapperBase::removeFromLength(UInt32 uiIndex) 
    1200 { 
    1201     if(uiIndex < _mfLength.size()) 
    1202     { 
    1203         editMField(LengthFieldMask, _mfLength); 
    1204  
    1205         MFUnrecGeoUInt32PropertyPtr::iterator fieldIt = _mfLength.begin_nc(); 
    1206  
    1207         fieldIt += uiIndex; 
    1208  
    1209         //subRef(*fieldIt); 
    1210  
    1211         _mfLength.erase(fieldIt); 
    1212     } 
    1213 } 
    1214  
    1215 void VTKMapperBase::removeFromLength(const GeoUInt32PropertyPtr value) 
    1216 { 
    1217     Int32 iElemIdx = _mfLength.findIndex(value); 
    1218  
    1219     if(iElemIdx != -1) 
    1220     { 
    1221         editMField(LengthFieldMask, _mfLength); 
    1222  
    1223         MFUnrecGeoUInt32PropertyPtr::iterator fieldIt = _mfLength.begin_nc(); 
    1224  
    1225         fieldIt += iElemIdx; 
    1226  
    1227         //subRef(*fieldIt); 
    1228  
    1229         _mfLength.erase(fieldIt); 
    1230     } 
    1231 } 
    1232 void VTKMapperBase::clearLength(void) 
    1233 { 
    1234     editMField(LengthFieldMask, _mfLength); 
    1235  
    1236892 
    1237893    _mfLength.clear(); 
    …… 
    1240896void VTKMapperBase::pushToTypes(const GeoUInt8PropertyPtr value) 
    1241897{ 
    1242     if(value == NullFC) 
    1243         return; 
    1244  
    1245898    editMField(TypesFieldMask, _mfTypes); 
    1246  
    1247     //addRef(value); 
    1248899 
    1249900    _mfTypes.push_back(value); 
    …… 
    1267918} 
    1268919 
    1269 void VTKMapperBase::insertIntoTypes(      UInt32         uiIndex, 
    1270                                                    const GeoUInt8PropertyPtr value   ) 
    1271 { 
    1272     if(value == NullFC) 
    1273         return; 
    1274  
     920void VTKMapperBase::removeFromTypes(UInt32 uiIndex) 
     921{ 
     922    if(uiIndex < _mfTypes.size()) 
     923    { 
     924        editMField(TypesFieldMask, _mfTypes); 
     925 
     926        MFUnrecGeoUInt8PropertyPtr::iterator fieldIt = _mfTypes.begin_nc(); 
     927 
     928        fieldIt += uiIndex; 
     929 
     930        _mfTypes.erase(fieldIt); 
     931    } 
     932} 
     933 
     934void VTKMapperBase::removeFromTypes(const GeoUInt8PropertyPtr value) 
     935{ 
     936    Int32 iElemIdx = _mfTypes.findIndex(value); 
     937 
     938    if(iElemIdx != -1) 
     939    { 
     940        editMField(TypesFieldMask, _mfTypes); 
     941 
     942        MFUnrecGeoUInt8PropertyPtr::iterator fieldIt = _mfTypes.begin_nc(); 
     943 
     944        fieldIt += iElemIdx; 
     945 
     946        _mfTypes.erase(fieldIt); 
     947    } 
     948} 
     949void VTKMapperBase::clearTypes(void) 
     950{ 
    1275951    editMField(TypesFieldMask, _mfTypes); 
    1276952 
    1277     MFUnrecGeoUInt8PropertyPtr::iterator fieldIt = _mfTypes.begin_nc(); 
    1278  
    1279     //addRef(value); 
    1280  
    1281     fieldIt += uiIndex; 
    1282  
    1283     _mfTypes.insert(fieldIt, value); 
    1284 } 
    1285  
    1286 void VTKMapperBase::replaceInTypes(      UInt32         uiIndex, 
    1287                                                        const GeoUInt8PropertyPtr value   ) 
    1288 { 
    1289     if(value == NullFC) 
    1290         return; 
    1291  
    1292     if(uiIndex >= _mfTypes.size()) 
    1293         return; 
    1294  
    1295     editMField(TypesFieldMask, _mfTypes); 
    1296  
    1297  
    1298 //    addRef(value); 
    1299 //    subRef(_mfTypes[uiIndex]); 
    1300  
    1301 //    _mfTypes[uiIndex] = value; 
    1302  
    1303       _mfTypes.replace(uiIndex, value); 
    1304 } 
    1305  
    1306 void VTKMapperBase::replaceInTypes(const GeoUInt8PropertyPtr pOldElem, 
    1307                                                         const GeoUInt8PropertyPtr pNewElem) 
    1308 { 
    1309     if(pNewElem == NullFC) 
    1310         return; 
    1311  
    1312     Int32  elemIdx = _mfTypes.findIndex(pOldElem); 
    1313  
    1314     if(elemIdx != -1) 
    1315     { 
    1316         editMField(TypesFieldMask, _mfTypes); 
    1317  
    1318 //        MFGeoUInt8PropertyPtr::iterator fieldIt = _mfTypes.begin(); 
    1319  
    1320 //        fieldIt += elemIdx; 
    1321 //        addRef(pNewElem); 
    1322 //        subRef(pOldElem); 
    1323  
    1324 //        (*fieldIt) = pNewElem; 
    1325           _mfTypes.replace(elemIdx, pNewElem); 
    1326     } 
    1327 } 
    1328  
    1329 void VTKMapperBase::removeFromTypes(UInt32 uiIndex) 
    1330 { 
    1331     if(uiIndex < _mfTypes.size()) 
    1332     { 
    1333         editMField(TypesFieldMask, _mfTypes); 
    1334  
    1335         MFUnrecGeoUInt8PropertyPtr::iterator fieldIt = _mfTypes.begin_nc(); 
    1336  
    1337         fieldIt += uiIndex; 
    1338  
    1339         //subRef(*fieldIt); 
    1340  
    1341         _mfTypes.erase(fieldIt); 
    1342     } 
    1343 } 
    1344  
    1345 void VTKMapperBase::removeFromTypes(const GeoUInt8PropertyPtr value) 
    1346 { 
    1347     Int32 iElemIdx = _mfTypes.findIndex(value); 
    1348  
    1349     if(iElemIdx != -1) 
    1350     { 
    1351         editMField(TypesFieldMask, _mfTypes); 
    1352  
    1353         MFUnrecGeoUInt8PropertyPtr::iterator fieldIt = _mfTypes.begin_nc(); 
    1354  
    1355         fieldIt += iElemIdx; 
    1356  
    1357         //subRef(*fieldIt); 
    1358  
    1359         _mfTypes.erase(fieldIt); 
    1360     } 
    1361 } 
    1362 void VTKMapperBase::clearTypes(void) 
    1363 { 
    1364     editMField(TypesFieldMask, _mfTypes); 
    1365  
    1366953 
    1367954    _mfTypes.clear(); 
    …… 
    1370957void VTKMapperBase::pushToColors(const GeoColor4fPropertyPtr value) 
    1371958{ 
    1372     if(value == NullFC) 
    1373         return; 
    1374  
    1375959    editMField(ColorsFieldMask, _mfColors); 
    1376  
    1377     //addRef(value); 
    1378960 
    1379961    _mfColors.push_back(value); 
    …… 
    1397979} 
    1398980 
    1399 void VTKMapperBase::insertIntoColors(      UInt32         uiIndex, 
    1400                                                    const GeoColor4fPropertyPtr value   ) 
    1401 { 
    1402     if(value == NullFC) 
    1403         return; 
    1404  
     981void VTKMapperBase::removeFromColors(UInt32 uiIndex) 
     982{ 
     983    if(uiIndex < _mfColors.size()) 
     984    { 
     985        editMField(ColorsFieldMask, _mfColors); 
     986 
     987        MFUnrecGeoColor4fPropertyPtr::iterator fieldIt = _mfColors.begin_nc(); 
     988 
     989        fieldIt += uiIndex; 
     990 
     991        _mfColors.erase(fieldIt); 
     992    } 
     993} 
     994 
     995void VTKMapperBase::removeFromColors(const GeoColor4fPropertyPtr value) 
     996{ 
     997    Int32 iElemIdx = _mfColors.findIndex(value); 
     998 
     999    if(iElemIdx != -1) 
     1000    { 
     1001        editMField(ColorsFieldMask, _mfColors); 
     1002 
     1003        MFUnrecGeoColor4fPropertyPtr::iterator fieldIt = _mfColors.begin_nc();