OSGGeometry.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *                                OpenSG                                     *
 *                                                                           *
 *                                                                           *
 *             Copyright(C) 2000-2002 by the OpenSG Forum                   *
 *                                                                           *
 *                            www.opensg.org                                 *
 *                                                                           *
 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                License                                    *
 *                                                                           *
 * This library is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU Library General Public License as published    *
 * by the Free Software Foundation, version 2.                               *
 *                                                                           *
 * This library is distributed in the hope that it will be useful, but       *
 * WITHOUT ANY WARRANTY; without even the implied warranty of                *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
 * Library General Public License for more details.                          *
 *                                                                           *
 * You should have received a copy of the GNU Library General Public         *
 * License along with this library; if not, write to the Free Software       *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                Changes                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/

//---------------------------------------------------------------------------
 //  Includes
//---------------------------------------------------------------------------

#include <stdlib.h>
#include <stdio.h>

#include "OSGConfig.h"
#include <OSGGL.h>

#include <OSGAction.h>
#include <OSGDrawAction.h>
#include <OSGRenderAction.h>
#include <OSGIntersectAction.h>
#include <OSGRenderAction.h>
#include <OSGMaterial.h>
#include <OSGChunkMaterial.h>
#include <OSGSimpleMaterial.h>
#include <OSGSimpleTexturedMaterial.h>
#include "OSGDrawable.h"
#include "OSGGeometry.h"
#include "OSGGeoFunctions.h"
#include "OSGGeoPumpFactory.h"

#include <OSGIntersectActor.h>

#include "OSGPrimitiveIterator.h"
#include "OSGTriangleIterator.h"
#include "OSGFaceIterator.h"
#include "OSGLineIterator.h"
#include "OSGEdgeIterator.h"

#include "OSGGeoPropPtrs.h"
OSG_USING_NAMESPACE


/***************************************************************************\
 *                            Description                                  *
\***************************************************************************/

/***************************************************************************\
 *                           Class variables                               *
\***************************************************************************/

const UInt16 Geometry::MapPosition       = 1;
const UInt16 Geometry::MapNormal         = Geometry::MapPosition << 1;
const UInt16 Geometry::MapColor          = Geometry::MapNormal << 1;
const UInt16 Geometry::MapSecondaryColor = Geometry::MapColor << 1;
const UInt16 Geometry::MapTexCoords      = Geometry::MapSecondaryColor << 1;
const UInt16 Geometry::MapTexCoords1     = Geometry::MapTexCoords << 1;
const UInt16 Geometry::MapTexCoords2     = Geometry::MapTexCoords1 << 1;
const UInt16 Geometry::MapTexCoords3     = Geometry::MapTexCoords2 << 1;
const UInt16 Geometry::MapEmpty          = Geometry::MapTexCoords3 << 1;


/***************************************************************************\
 *                           Class methods                                 *
\***************************************************************************/

/*-------------------------------------------------------------------------*\
 -  public                                                                 -
\*-------------------------------------------------------------------------*/

const char *Geometry::mapType(UInt8 type)
{
    switch(type)
    {
    case GL_POINTS:         return "Points";
    case GL_LINES:          return "Lines";
    case GL_LINE_LOOP:      return "LineLoop";
    case GL_LINE_STRIP:     return "LineStrip";
    case GL_TRIANGLES:      return "Triangles";
    case GL_TRIANGLE_STRIP: return "TriangleStrip";
    case GL_TRIANGLE_FAN:   return "TriangleFan";
    case GL_QUADS:          return "Quads";
    case GL_QUAD_STRIP:     return "QuadStrip";
    case GL_POLYGON:        return "Polygon";
    }

    return "Unknown Primitive";
}

/*-------------------------------------------------------------------------*\
 -  private                                                                -
\*-------------------------------------------------------------------------*/

void Geometry::initMethod(void)
{
    DrawAction::registerEnterDefault(getClassType(),
        osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, MaterialDrawablePtr,
              CNodePtr, Action *>(&MaterialDrawable::drawActionHandler));

    IntersectAction::registerEnterDefault(getClassType(),
        osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, GeometryPtr,
              CNodePtr, Action *>(&Geometry::intersect));

    IntersectActor::regClassEnter(
        osgTypedMethodFunctor2BaseCPtr<
            NewActionTypes::ResultE,
            GeometryPtr,
            NodeCorePtr,
            ActorBase::FunctorArgumentType &>(&Geometry::intersect),
        getClassType());

    RenderAction::registerEnterDefault(getClassType(),
        osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, MaterialDrawablePtr,
              CNodePtr, Action *>(&MaterialDrawable::renderActionHandler));
}


/***************************************************************************\
 *                           Instance methods                              *
\***************************************************************************/

/*-------------------------------------------------------------------------*\
 -  public                                                                 -
\*-------------------------------------------------------------------------*/


/*------------- constructors & destructors --------------------------------*/

Geometry::Geometry(void) :
    Inherited()
{
}

Geometry::Geometry(const Geometry &source) :
    Inherited(source)
{
}

Geometry::~Geometry(void)
{
    GeometryPtr thisP = getPtr();

    if(_sfTypes.getValue() != NullFC)
    {
        beginEditCP(_sfTypes.getValue(), Attachment::ParentsFieldMask);
        {
            _sfTypes.getValue()->subParent(thisP);
        }
        endEditCP(_sfTypes.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfTypes.getValue());
    }

    if(_sfLengths.getValue() != NullFC)
    {
        beginEditCP(_sfLengths.getValue(), Attachment::ParentsFieldMask);
        {
            _sfLengths.getValue()->subParent(thisP);
        }
        endEditCP(_sfLengths.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfLengths.getValue());
    }

    if(_sfPositions.getValue() != NullFC)
    {
        beginEditCP(_sfPositions.getValue(), Attachment::ParentsFieldMask);
        {
            _sfPositions.getValue()->subParent(thisP);
        }
        endEditCP(_sfPositions.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfPositions.getValue());
    }

    if(_sfNormals.getValue() != NullFC)
    {
        beginEditCP(_sfNormals.getValue(), Attachment::ParentsFieldMask);
        {
            _sfNormals.getValue()->subParent(thisP);
        }
        endEditCP(_sfNormals.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfNormals.getValue());
    }

    if(_sfColors.getValue() != NullFC)
    {
        beginEditCP(_sfColors.getValue(), Attachment::ParentsFieldMask);
        {
            _sfColors.getValue()->subParent(thisP);
        }
        endEditCP(_sfColors.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfColors.getValue());
    }

    if(_sfSecondaryColors.getValue() != NullFC)
    {
        beginEditCP(_sfSecondaryColors.getValue(),
                        Attachment::ParentsFieldMask);
        {
            _sfSecondaryColors.getValue()->subParent(thisP);
        }
        endEditCP(_sfSecondaryColors.getValue(),
                        Attachment::ParentsFieldMask);

        subRefCP(_sfSecondaryColors.getValue());
    }

    if(_sfTexCoords.getValue() != NullFC)
    {
        beginEditCP(_sfTexCoords.getValue(), Attachment::ParentsFieldMask);
        {
            _sfTexCoords.getValue()->subParent(thisP);
        }
        endEditCP(_sfTexCoords.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfTexCoords.getValue());
    }

    if(_sfTexCoords1.getValue() != NullFC)
    {
        beginEditCP(_sfTexCoords1.getValue(), Attachment::ParentsFieldMask);
        {
            _sfTexCoords1.getValue()->subParent(thisP);
        }
        endEditCP(_sfTexCoords1.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfTexCoords1.getValue());
    }

    if(_sfTexCoords2.getValue() != NullFC)
    {
        beginEditCP(_sfTexCoords2.getValue(), Attachment::ParentsFieldMask);
        {
            _sfTexCoords2.getValue()->subParent(thisP);
        }
        endEditCP(_sfTexCoords2.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfTexCoords2.getValue());
    }

    if(_sfTexCoords3.getValue() != NullFC)
    {
        beginEditCP(_sfTexCoords3.getValue(), Attachment::ParentsFieldMask);
        {
            _sfTexCoords3.getValue()->subParent(thisP);
        }
        endEditCP(_sfTexCoords3.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfTexCoords3.getValue());
    }

    if(_sfIndices.getValue() != NullFC)
    {
        beginEditCP(_sfIndices.getValue(), Attachment::ParentsFieldMask);
        {
            _sfIndices.getValue()->subParent(thisP);
        }
        endEditCP(_sfIndices.getValue(), Attachment::ParentsFieldMask);

        subRefCP(_sfIndices.getValue());
    }

    subRefCP(_sfMaterial.getValue());

    if(getGLId() > 0)
        Window::destroyGLObject(getGLId(), 1);
}

void Geometry::onCreate(const Geometry *)
{
    // if we're in startup this is the prototype, which shouldn't have an id
    if(GlobalSystemState == Startup)
        return;

    // !!! this temporary is needed to work around compiler problems(sgi)
    // CHECK CHECK
    //  TextureChunkPtr tmpPtr = FieldContainer::getPtr<TextureChunkPtr>(*this);
    GeometryPtr tmpPtr(*this);

    beginEditCP(tmpPtr, Geometry::GLIdFieldMask);

    setGLId(
          Window::registerGLObject(
            osgTypedMethodVoidFunctor2ObjCPtrPtr<GeometryPtr,
                                                 Window ,
                                                 UInt32>(tmpPtr,
                                                         &Geometry::handleGL),
            1));

    endEditCP(tmpPtr, Geometry::GLIdFieldMask);
}

/*------------------------------ access -----------------------------------*/

void Geometry::adjustVolume(Volume & volume)
{
    GeoPositionsPtr pos = getPositions();

    volume.setValid();
    volume.setEmpty();

    if(pos == NullFC)
        return;                  // Node has no points, no volume

    PrimitiveIterator it;

    for(it = this->beginPrimitives(); it != this->endPrimitives(); ++it)
    {
        for(UInt32 v=0; v < it.getLength(); ++v)
        {
            volume.extendBy(it.getPosition(v));
        }
    }
}

/*---------------------------- pointer ------------------------------------*/

GeometryPtr Geometry::getPtr(void) const
{
    return GeometryPtr(*this);
}


void Geometry::handleGL(Window* win, UInt32 idstatus)
{
    Window::GLObjectStatusE mode;
    UInt32 id;

    Window::unpackIdStatus(idstatus, id, mode);

    if(mode == Window::initialize || mode == Window::needrefresh ||
       mode == Window::reinitialize)
    {
        glNewList(id, GL_COMPILE);

        GeoPumpFactory::Index ind = GeoPumpFactory::the()->getIndex(this);
        GeoPumpFactory::GeoPump p =
            GeoPumpFactory::the()->getGeoPump(win, ind);

        // call the pump

        if(p)
            p(win, this);
        else
        {
            SWARNING << "Geometry::handleGL: no Pump found for geometry "
                     << this
                     << std::endl;
        }

        glEndList();
    }
    else if(mode == Window::destroy)
    {
        glDeleteLists(id, 1);
    }
    else if(mode == Window::finaldestroy)
    {
        //SWARNING << "Last geometry user destroyed" << std::endl;
    }
    else
    {
        SWARNING << "Geometry(" << this << "::handleGL: Illegal mode: "
                 << mode << " for id " << id << std::endl;
    }

}

/*------------------------------- dump ----------------------------------*/

void Geometry::dump(      UInt32    uiIndent,
                    const BitVector bvFlags) const
{
    UInt32 i;

    GeometryPtr thisP = getPtr();

    indentLog(uiIndent, PLOG);

    PLOG << "GeoCore"
         << "("
         << thisP.getFieldContainerId()
         << ") : "
         << getType().getName()
         << " "
         << _attachmentMap.getValue().size()
         << " attachments | "
         << this
         << std::endl;

    indentLog(uiIndent, PLOG);
    PLOG << "[" << std::endl;

    indentLog(uiIndent + 4, PLOG);
    PLOG << "Parents : " << std::endl;

    for(i = 0; i < _parents.size(); i++)
    {
        indentLog(uiIndent + 4, PLOG);
        PLOG << "           " << i << ") " << &(*(_parents[i])) << std::endl;
    }

    indentLog(uiIndent, PLOG);
    PLOG << "]" << std::endl;

    indentLog(uiIndent, PLOG);
    PLOG << "{" << std::endl;

    uiIndent += 4;

    if(getPositions() != NullFC)
    {
        getPositions()->dump(uiIndent, bvFlags);
    }

    if(getIndices() != NullFC)
    {
        getIndices()->dump(uiIndent, bvFlags);
    }

    if(getMaterial() != NullFC)
    {
        getMaterial()->dump(uiIndent, bvFlags);
    }

    if(getTypes() != NullFC)
    {
        getTypes()->dump(uiIndent, bvFlags);
    }

    if(getLengths() != NullFC)
    {
        getLengths()->dump(uiIndent, bvFlags);
    }

    if(getNormals() != NullFC)
    {
        getNormals()->dump(uiIndent, bvFlags);
    }

    if(getColors() != NullFC)
    {
        getColors()->dump(uiIndent, bvFlags);
    }

    if(getTexCoords() != NullFC)
    {
        getTexCoords()->dump(uiIndent, bvFlags);
    }

    if(getTexCoords1() != NullFC)
    {
        getTexCoords1()->dump(uiIndent, bvFlags);
    }

    if(getTexCoords2() != NullFC)
    {
        getTexCoords2()->dump(uiIndent, bvFlags);
    }

    if(getTexCoords3() != NullFC)
    {
        getTexCoords3()->dump(uiIndent, bvFlags);
    }

    uiIndent -= 4;

    AttachmentContainer::dump(uiIndent, bvFlags);

    indentLog(uiIndent, PLOG);
    PLOG << "}" << std::endl;
}

#ifndef OSG_SUPPORT_NO_GEO_INTERFACE

GeoPropertyArrayInterface *Geometry::getProperty(Int32 mapID)
{
    GeoPropertyArrayInterface *pP = 0;

    switch(mapID)
    {
        case 0:
            pP = 0;
            break;
        case MapPosition:
            pP =(getPositions()       == NullFC) ? 0 : &(*getPositions());
            break;
        case MapNormal:
            pP =(getNormals()         == NullFC) ? 0 : &(*getNormals());
            break;
        case MapColor:
            pP =(getColors()          == NullFC) ? 0 : &(*getColors());
            break;
        case MapSecondaryColor:
            pP =(getSecondaryColors() == NullFC) ? 0 : &(*getSecondaryColors());
            break;
        case MapTexCoords:
            pP =(getTexCoords()       == NullFC) ? 0 : &(*getTexCoords());
            break;
        case MapTexCoords1:
            pP =(getTexCoords1()      == NullFC) ? 0 : &(*getTexCoords1());
            break;
        case MapTexCoords2:
            pP =(getTexCoords2()      == NullFC) ? 0 : &(*getTexCoords2());
            break;
        case MapTexCoords3:
            pP =(getTexCoords3()      == NullFC) ? 0 : &(*getTexCoords3());
            break;
        default:
            FFATAL(("Invalid mapID(%d) in Geometry::getProperty()\n",
                    mapID));
          break;
    }

    return pP;
}

#endif

Int16  Geometry::calcMappingIndex(UInt16 attrib) const
{
    UInt16 nmappings = getIndexMapping().size();
    Int16 i;

    for(i = nmappings - 1; i >= 0; i--)
    {
        if(getIndexMapping()[i] & attrib )
            break;
    }

    return i;
}



bool Geometry::isMergeable( const GeometryPtr other )
{
    if (MergeIndex(other)!=-1 || getPositions()==NullFC) return true;
    else return false;
}

bool Geometry::merge( const GeometryPtr other )
{
    if (other == NullFC)
    {
        FDEBUG(("Geometry::merge: other = NullFC!!!\n"));
        return false;
    }
    //first check whethet the current geometry is empty
    //if empty just add everything from the other geometry
    if (getPositions()==NullFC)
    {
        if (other->getPositions()!=NullFC)
            setPositions(other->getPositions()->clone());

        if (other->getTypes()!=NullFC)
            setTypes(other->getTypes()->clone());

        if (other->getLengths()!=NullFC)
            setLengths(other->getLengths()->clone());

        if (other->getNormals()!=NullFC)
            setNormals(other->getNormals()->clone());

        if (other->getColors()!=NullFC)
            setColors(other->getColors()->clone());

        if (other->getSecondaryColors()!=NullFC)
            setSecondaryColors(other->getSecondaryColors()->clone());

        if (other->getTexCoords()!=NullFC)
            setTexCoords(other->getTexCoords()->clone());

        if (other->getTexCoords1()!=NullFC)
            setTexCoords1(other->getTexCoords1()->clone());

        if (other->getTexCoords2()!=NullFC)
            setTexCoords2(other->getTexCoords2()->clone());

        if (other->getTexCoords3()!=NullFC)
            setTexCoords3(other->getTexCoords3()->clone());

        if(other->getIndices()!=NullFC)
            setIndices(other->getIndices()->clone());

        if(other->getMFIndexMapping()!=NULL)
            getMFIndexMapping()->setValues(*(other->getMFIndexMapping()));

        setMaterial(other->getMaterial());
        setDlistCache(other->getDlistCache());

        return true;
    }


    //if not empty continue trying a normal merge
    Int16 mergetype = MergeIndex( other );
    switch ( mergetype )
    {
    case 0: merge0( other ); break;
    case 1: merge1( other ); break;
    case 2: merge2( other ); break;
    case 3: merge3( other ); break;
    case 4: merge4( other ); break;
    case 5: merge5( other ); break;
    case 6: merge6( other ); break;
    default: return false;
    }
    return true;
}

/*-------------------------------------------------------------------------*\
 -  protected                                                              -
\*-------------------------------------------------------------------------*/

Action::ResultE Geometry::drawPrimitives(DrawActionBase * action)
{
    if(getDlistCache() == true)
    {
        action->getWindow()->validateGLObject(getGLId());
        glCallList(getGLId());
    }
    else
    {
        GeoPumpFactory::Index ind = GeoPumpFactory::the()->getIndex(this);
        GeoPumpFactory::GeoPump p =
            GeoPumpFactory::the()->getGeoPump(action->getWindow(), ind);

        // call the pump

        if(p)
            p(action->getWindow(), this);
        else
        {
            SWARNING << "draw: no Pump found for geometry "
                     << this
                     << std::endl;
        }
    }

    StatCollector *coll = action->getStatistics();

    if(coll != NULL)
    {
        StatIntElem *el = coll->getElem(Drawable::statNTriangles,false);
        if(el)
        {
            GeometryPtr geo(this);
            UInt32 ntri,nl,np,is;

            calcPrimitiveCount(geo, ntri, nl, np);
            el->add(ntri);
            coll->getElem(Drawable::statNLines)->add(nl);
            coll->getElem(Drawable::statNLines)->add(np);

            if(getIndices() == NullFC)
            {
                if(getPositions() != NullFC)
                {
                    is = getPositions()->getSize();
                }
                else
                {
                    is = 0;
                }
            }
            else
            {
                is = getIndexMapping().size();
                is = getIndices()->getSize() /(is ? is : 1);
            }
            coll->getElem(Drawable::statNVertices)->add(is);

            UInt32 primitiveCount = 0;
            if (getTypes() != NullFC) {
                primitiveCount = getTypes()->getSize();
            }
            coll->getElem(Drawable::statNPrimitives)->add(primitiveCount);
        }
    }

    return Action::Continue;
}

Action::ResultE Geometry::intersect(Action * action)
{
    IntersectAction     * ia = dynamic_cast<IntersectAction*>(action);
    const DynamicVolume  &dv = ia->getActNode()->getVolume(true);

    if(dv.isValid() && !dv.intersect(ia->getLine()))
    {
        return Action::Skip; //bv missed -> can not hit children
    }

    TriangleIterator it  = this->beginTriangles();
    TriangleIterator end = this->endTriangles  ();
    Real32 t;
    Vec3f norm;

    for(; it != end; ++it)
    {
        if(ia->getLine().intersect(it.getPosition(0),
                                     it.getPosition(1),
                                     it.getPosition(2), t, &norm))
        {
            ia->setHit(t, ia->getActNode(), it.getIndex(), norm);
        }
    }

    return Action::Continue;
}

NewActionTypes::ResultE
Geometry::intersect(ActorBase::FunctorArgumentType &funcArg)
{
    IntersectActor   *pIA         = dynamic_cast<IntersectActor *>(funcArg.getActor());
    Real32            scaleFactor = pIA->getScaleFactor();

    TriangleIterator  itTris      = this->beginTriangles();
    TriangleIterator  endTris     = this->endTriangles  ();

    Real32            hitDist;
    Vec3f             hitNormal;

    for(; itTris != endTris; ++itTris)
    {
        if(pIA->getRay().intersect(itTris.getPosition(0),
                                   itTris.getPosition(1),
                                   itTris.getPosition(2),
                                   hitDist,                &hitNormal) == true)
        {
            pIA->setHit(hitDist * scaleFactor, funcArg.getNode(),
                        itTris.getIndex(),     hitNormal        );
        }
    }

    pIA->setupChildrenPriorities();

    return NewActionTypes::Continue;
}

void Geometry::changed(BitVector whichField,
                       UInt32    origin   )
{
    if(whichField & TypesFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfTypes.getValue()                    != NullFC &&
                   _sfTypes.getValue()->findParent(thisP) ==     -1 )
                {
                    GeoPTypesPtr pType = _sfTypes.getValue();

                    _sfTypes.setValue(NullFC);

                    setTypes(pType);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfTypes.getValue());
            }
            else
            {
                GeoPTypesPtr pType = _sfTypes.getValue();

                _sfTypes.setValue(NullFC);

                setTypes(pType);
            }
        }
    }

    if(whichField & LengthsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfLengths.getValue()                    != NullFC &&
                   _sfLengths.getValue()->findParent(thisP) ==     -1 )
                {
                    GeoPLengthsPtr pLength = _sfLengths.getValue();

                    _sfLengths.setValue(NullFC);

                    setLengths(pLength);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfLengths.getValue());
            }
            else
            {
                GeoPLengthsPtr pLength = _sfLengths.getValue();

                _sfLengths.setValue(NullFC);

                setLengths(pLength);
            }
        }
    }

    if(whichField & PositionsFieldMask)
    {
        for(UInt32 i = 0; i < _parents.size(); i++)
        {
            _parents[i]->invalidateVolume();
        }

        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfPositions.getValue()                    != NullFC &&
                   _sfPositions.getValue()->findParent(thisP) ==     -1 )
                {
                    GeoPositionsPtr pPos = _sfPositions.getValue();

                    _sfPositions.setValue(NullFC);

                    setPositions(pPos);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfPositions.getValue());
            }
            else
            {
                GeoPositionsPtr pPos = _sfPositions.getValue();

                _sfPositions.setValue(NullFC);

                setPositions(pPos);
            }
        }
        else
        {
        }
    }

    if(whichField & NormalsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfNormals.getValue()                    != NullFC &&
                   _sfNormals.getValue()->findParent(thisP) ==     -1 )
                {
                    GeoNormalsPtr pNorm = _sfNormals.getValue();

                    _sfNormals.setValue(NullFC);

                    setNormals(pNorm);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfNormals.getValue());
            }
            else
            {
                GeoNormalsPtr pNorm = _sfNormals.getValue();

                _sfNormals.setValue(NullFC);

                setNormals(pNorm);
            }
        }
    }

    if(whichField & ColorsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfColors.getValue()                    != NullFC &&
                   _sfColors.getValue()->findParent(thisP) ==     -1 )
                {
                    GeoColorsPtr pColor = _sfColors.getValue();

                    _sfColors.setValue(NullFC);

                    setColors(pColor);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfColors.getValue());
            }
            else
            {
                GeoColorsPtr pColor = _sfColors.getValue();

                _sfColors.setValue(NullFC);

                setColors(pColor);
            }
        }
    }

    if(whichField & SecondaryColorsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfSecondaryColors.getValue()                   != NullFC &&
                   _sfSecondaryColors.getValue()->findParent(thisP)==     -1 )
                {
                    GeoColorsPtr pColor = _sfSecondaryColors.getValue();

                    _sfSecondaryColors.setValue(NullFC);

                    setSecondaryColors(pColor);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfSecondaryColors.getValue());
            }
            else
            {
                GeoColorsPtr pColor = _sfSecondaryColors.getValue();

                _sfSecondaryColors.setValue(NullFC);

                setSecondaryColors(pColor);
            }
        }
    }

    if(whichField & TexCoordsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                GeometryPtr thisP = getPtr();

                if(_sfTexCoords.getValue()                    != NullFC &&
                   _sfTexCoords.getValue()->findParent(thisP) ==     -1 )
                {
                    GeoTexCoordsPtr pTexCoord = _sfTexCoords.getValue();

                    _sfTexCoords.setValue(NullFC);

                    setTexCoords(pTexCoord);
                }
            }
            else if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfTexCoords.getValue());
            }
            else
            {
                GeoTexCoordsPtr pTexCoord = _sfTexCoords.getValue();

                _sfTexCoords.setValue(NullFC);

                setTexCoords(pTexCoord);
            }
        }
    }

    if(whichField & TexCoords1FieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {