OSGParticles.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 <OSGAction.h>
#include <OSGDrawAction.h>
#include <OSGRenderAction.h>
#include <OSGMaterial.h>
#include <OSGGeoPropPtrs.h>
#include <OSGCamera.h>

#include "OSGParticles.h"

#include <algorithm>

OSG_USING_NAMESPACE

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

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

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

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

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

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

Particles::Particles(void) :
    Inherited()
{
}

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

Particles::~Particles(void)
{
    ParticlesPtr thisP(*this);

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

        subRefCP(_sfPositions.getValue());
    }

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

        subRefCP(_sfSecPositions.getValue());
    }

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

        subRefCP(_sfColors.getValue());
    }

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

        subRefCP(_sfNormals.getValue());
    }

    subRefCP(_sfMaterial.getValue());
}

/*------------------------------- Sync -----------------------------------*/

void Particles::changed(BitVector whichField, UInt32 origin)
{
    if(whichField & PositionsFieldMask)
    {
        for(UInt32 i = 0; i < _parents.size(); i++)
        {
            _parents[i]->invalidateVolume();
        }
        getBsp().destroy();

        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                ParticlesPtr thisP(*this);

                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);
            }
        }
    }

    if(whichField & SecPositionsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                ParticlesPtr thisP(*this);

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

                    _sfSecPositions.setValue(NullFC);

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

                _sfSecPositions.setValue(NullFC);

                setSecPositions(pPos);
            }
        }
    }

    if(whichField & ColorsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                ParticlesPtr thisP(*this);

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

                    _sfColors.setValue(NullFC);

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

                _sfColors.setValue(NullFC);

                setColors(pCol);
            }
        }
    }

    if(whichField & NormalsFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrCheckValid)
            {
                ParticlesPtr thisP(*this);

                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 & MaterialFieldMask)
    {
        if(origin & ChangedOrigin::Abstract)
        {
            if(origin & ChangedOrigin::AbstrIncRefCount)
            {
                addRefCP(_sfMaterial.getValue());
            }
            else
            {
                MaterialPtr pMat = _sfMaterial.getValue();
                
                _sfMaterial.setValue(NullFC);
                
                setMaterial(pMat);
            }
        }
    }

    Inherited::changed(whichField, origin);
}

/*------------------------------ Output ----------------------------------*/

void Particles::dump(      UInt32    ,
                         const BitVector ) const
{
    SLOG << "Dump Particles NI" << std::endl;
}


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

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

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

    MFVec3f *sizes = getMFSizes();

    if(sizes->size() == pos->size())
    {
        Vec3f p;
        Real32 s;

        for(UInt32 i = 0; i < pos->size(); i++)
        {
            pos->getValue(p, i);
            // make the size bigger to accomodate rotations
            s=(*sizes)[i][0]*Sqrt2;

            p[0]+=s/2;
            p[1]+=s/2;
            p[2]+=s/2;
            volume.extendBy(p);
            p[0]-=s;
            volume.extendBy(p);
            p[1]-=s;
            volume.extendBy(p);
            p[0]+=s;
            volume.extendBy(p);
            p[2]-=s;
            volume.extendBy(p);
            p[0]-=s;
            volume.extendBy(p);
            p[1]+=s;
            volume.extendBy(p);
            p[0]+=s;
            volume.extendBy(p);
        }

    }
    else if(sizes->size() == 1)
    {
        Vec3f p;
        Real32 s,s2;
        // make the size bigger to accomodate rotations
        s=(*sizes)[0][0]*Sqrt2;
        s2=s/2;

        for(UInt32 i = 0; i < pos->size(); i++)
        {
            pos->getValue(p, i);

            p[0]+=s2;
            p[1]+=s2;
            p[2]+=s2;
            volume.extendBy(p);
            p[0]-=s;
            volume.extendBy(p);
            p[1]-=s;
            volume.extendBy(p);
            p[0]+=s;
            volume.extendBy(p);
            p[2]-=s;
            volume.extendBy(p);
            p[0]-=s;
            volume.extendBy(p);
            p[1]+=s;
            volume.extendBy(p);
            p[0]+=s;
            volume.extendBy(p);
        }

    }
    else
    {
        Vec3f p;

        for(UInt32 i = 0; i < pos->getSize(); i++)
        {
            pos->getValue(p, i);

            volume.extendBy(p);
        }
    }
}

#if !defined(OSG_DO_DOC) || OSG_DOC_LEVEL > 1  // remove from user docu

/*---------------------------- pumps -----------------------------------*/

class ParticleTraits
{
};

struct ColTraitBase : public ParticleTraits
{
    typedef void (OSG_APIENTRY *pumpFunc)( GLubyte * data );
    static const int formatBase;
    enum { numFormats = GL_DOUBLE - GL_BYTE + 1 };

    static char *formatNames[];

    static pumpFunc ColorFuncs[numFormats][4]; 
};

const int ColTraitBase::formatBase = GL_BYTE;

char *ColTraitBase::formatNames[] = 
{   "GL_BYTE", "GL_UNSIGNED_BYTE", "GL_SHORT", "GL_UNSIGNED_SHORT", 
    "GL_INT", "GL_UNSIGNED_INT", "GL_FLOAT", "GL_2_BYTES", 
    "GL_3_BYTES", "GL_4_BYTES", "GL_DOUBLE"
};

ColTraitBase::pumpFunc 
ColTraitBase::ColorFuncs[ColTraitBase::numFormats][4] = {
    { NULL, NULL, 
      (pumpFunc)glColor3bv, (pumpFunc)glColor4bv },   // GL_BYTE
    { NULL, NULL, 
      (pumpFunc)glColor3ubv,(pumpFunc)glColor4ubv },  // GL_UNSIGNED_BYTE
    { NULL, NULL, 
      (pumpFunc)glColor3sv, (pumpFunc)glColor4sv },   // GL_SHORT
    { NULL, NULL,  
      (pumpFunc)glColor3usv,(pumpFunc)glColor4usv },  // GL_UNSIGNED_SHORT
    { NULL, NULL,  
      (pumpFunc)glColor3iv, (pumpFunc)glColor4iv },   // GL_INT
    { NULL, NULL,  
      (pumpFunc)glColor3uiv,(pumpFunc)glColor4uiv },  // GL_UNSIGNED_INT
    { NULL, NULL,  
      (pumpFunc)glColor3fv, (pumpFunc)glColor4fv },   // GL_FLOAT
    { NULL, NULL, NULL, NULL },                       // GL_2_BYTES
    { NULL, NULL, NULL, NULL },                       // GL_3_BYTES
    { NULL, NULL, NULL, NULL },                       // GL_4_BYTES
    { NULL, NULL,  
      (pumpFunc)glColor3dv, (pumpFunc)glColor4dv },   // GL_DOUBLE
};

struct ColTraitNone : public ColTraitBase
{
    typedef UInt8 dataType; // no data needed, but can't instantiate void
    
    static inline void init(Particles *, DrawActionBase *, dataType &)
    {
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline void vertex(dataType &, UInt32, UInt32)
    {
    }
};

struct ColTraitSingle : public ColTraitBase
{
    typedef UInt8 dataType; // no data needed, but can't instantiate void
    
    static inline void init(Particles *part, DrawActionBase *, dataType &)
    {
        GeoColorsPtr col = part->getColors();
 
        if(col != NullFC)
        {
            pumpFunc col_func;

            col_func = ColorFuncs[ col->getFormat() - formatBase ]
                                 [ col->getDimension() - 1 ];

            if(col_func == NULL)
            {
                SWARNING << "Particles " << part << "have illegal "
                         << "colors: " << col->getDimension()
                         << "D " << formatNames[col->getFormat() - formatBase]
                         << "!" << std::endl;
                return;
            }
            else
            {
                col_func((GLubyte*) col->getData());
            }
        }
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }

    static inline void vertex(dataType &, UInt32, UInt32)
    {
    }
};

struct ColTraitParticle : public ColTraitBase
{
    typedef struct
    {
        UInt8    *data;
        UInt32    stride;
        pumpFunc  func;
    } 
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        GeoColorsPtr col = part->getColors();

        data.data = col->getData();
        if((data.stride = col->getStride()) == 0)
            data.stride = col->getFormatSize() * col->getDimension();
        
        data.func = ColorFuncs[ col->getFormat() - formatBase ]
                              [ col->getDimension() - 1 ];
                             
        if(data.func == NULL)
        {
            SWARNING << "Particles " << part << "have illegal "
                     << "colors: " << col->getDimension()
                     << "D " << formatNames[ col->getFormat() - formatBase ]
                     << "!" << std::endl;
            return;
        }
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {   
        data.func((GLubyte*)(data.data + particle * data.stride));
        return false;
    }
    
    static inline void vertex(dataType &, UInt32, UInt32)
    {
    }
};

struct ColTraitGeneric : public ColTraitBase
{
    typedef struct
    {
        UInt8    *data;
        UInt32    stride;
        pumpFunc  func;
        bool      perParticle;
    } 
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        GeoColorsPtr col = part->getColors();
        
        data.perParticle = false;
        
        if(col != NullFC)
        {
            data.data = col->getData();
            if((data.stride = col->getStride()) == 0)
                data.stride = col->getFormatSize() * col->getDimension();

            data.func = ColorFuncs[ col->getFormat() - formatBase ]
                                  [ col->getDimension() - 1 ];

            if(data.func == NULL)
            {
                SWARNING << "Particles " << part << "have illegal "
                         << "colors: " << col->getDimension()
                         << "D " << formatNames[ col->getFormat() - formatBase ]
                         << "!" << std::endl;
                return;
            }
            
            if(col->getSize() == 1)
            {
                data.func((GLubyte*) col->getData());
            }
            else if(col->getSize() == part->getPositions()->getSize())
            {
                data.perParticle = true;
            }
        }
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {   
        if(data.perParticle == true)
            data.func((GLubyte*)(data.data + particle * data.stride));
        return false;
    }
        
    static inline void vertex(dataType &, UInt32, UInt32)
    {
    }
};

struct PosTraitGeneric : public ParticleTraits
{
    typedef struct
    {
        GeoPositionsPtr pos;
        Pnt3f p;
    }
    dataType;
    
    static inline void init(Particles *, DrawActionBase *, dataType &data,
        GeoPositionsPtr &pos)
    {
        data.pos = pos;
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {
        data.pos->getValue(data.p, particle);
             
        return false;
    }
    
    static inline Pnt3f &position(dataType &data)
    {
        return data.p;
    }
    
    static inline void vertex(dataType &data, UInt32 , Vec4f &dir, 
                              Real32 s)
    {
        glVertex3f( data.p[0] + dir[0] * s, 
                    data.p[1] + dir[1] * s, 
                    data.p[2] + dir[2] * s);             
    }
    
    static inline void vertex(dataType &data)
    {
        glVertex3fv( (GLfloat*) data.p.getValues() );             
    }
};

struct PosTrait3f : public ParticleTraits
{
    typedef struct
    {
        MFPnt3f *pos;
        Pnt3f   *p;
    }
    dataType;
    
    static inline void init(Particles *, DrawActionBase *, dataType &data,
        GeoPositionsPtr &pos)
    {
        GeoPositions3fPtr pos3f = GeoPositions3fPtr::dcast(pos);
 
        data.pos  = pos3f->getFieldPtr();
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {
        data.p = & (*(data.pos))[particle];
        return false;
    }
    
    static inline Pnt3f &position(dataType &data)
    {
        return *data.p;
    }
    
    static inline void vertex(dataType &data, UInt32 , Vec4f &dir, Real32 s)
    {
        glVertex3f( (*data.p)[0] + dir[0] * s, 
                    (*data.p)[1] + dir[1] * s, 
                    (*data.p)[2] + dir[2] * s);             
    }
    
    static inline void vertex(dataType &data)
    {
        glVertex3fv( (GLfloat*) (*data.p).getValues() );             
    }
};

struct SizeTraitGeneric : public ParticleTraits
{
    typedef struct
    {
        MFVec3f *sizes;
        Vec3f    s;
        bool     perParticle;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.sizes = part->getMFSizes();
        
        if(data.sizes != NULL)
        {
            if(data.sizes->size() == 1)
            {
                data.s = (*(data.sizes))[0];
                data.perParticle = false;
            }
            else if(data.sizes->size() == part->getPositions()->size())
            {
                data.perParticle = true;
            }
            else
            {
                data.s.setValues(1,1,1);
                data.perParticle = false;
            }           
        }
        else
        {
            data.s.setValues(1,1,1);
            data.perParticle = false;
        }           
    }
   
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline Vec3f &size(dataType &data, UInt32 particle)
    {
        if(data.perParticle)
                return (*(data.sizes))[particle];
        return data.s;
    }
};

struct SizeTraitSingle : public ParticleTraits
{
    typedef struct
    {
        Vec3f    s;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.s = part->getSizes()[0];
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline Vec3f &size(dataType &data, UInt32)
    {
        return data.s;
    }
};

struct SizeTraitParticle : public ParticleTraits
{
    typedef struct
    {
        MFVec3f *sizes;
        Vec3f    s;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.sizes = part->getMFSizes();
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline Vec3f &size(dataType &data, UInt32 particle)
    {
        return (*(data.sizes))[particle];
    }
};

struct SizeTraitNone : public ParticleTraits
{
    typedef UInt8 dataType;
    
    static inline void init(Particles *, DrawActionBase *, dataType &)
    {
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline Vec3f &size(dataType &, UInt32 )
    {
        static Vec3f s(1,1,1);
        return s;
    }
};

struct TexTraitGeneric : public ParticleTraits
{
    typedef struct
    {
        MFReal32 *texzs;
        Real32    z;
        bool      perParticle;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.texzs = part->getMFTextureZs();
        
        data.perParticle = false;
        
        if(data.texzs != NULL)
        {
            if(data.texzs->size() == 1)
            {
                data.z = (*(data.texzs))[0];
             }
            else if(data.texzs->size() == part->getPositions()->size())
            {
                data.perParticle = true;
            }
            else
            {
                data.z = 0;
            }           
        }
        else
        {
            data.z = 0;
        }
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {       
        if(data.perParticle)
        {
            data.z = (*(data.texzs))[particle];
        }
        return false;
    }
    
    static inline void vertex(dataType &data)
    {
        glTexCoord1f(data.z);
    }
    
    static inline void vertex(dataType &data, UInt32 , Real32 u,
                                Real32 v)
    {
        glTexCoord3f(u, v, data.z);
    }
};

struct TexTraitParticle : public ParticleTraits
{
    typedef struct
    {
        MFReal32 *texzs;
        Real32    z;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.texzs = part->getMFTextureZs();
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {       
        data.z = (*(data.texzs))[particle];
        return false;
    }
    
    static inline void vertex(dataType &data)
    {
        glTexCoord1f(data.z);
    }
    
    static inline void vertex(dataType &data, UInt32 , Real32 u,
                                Real32 v)
    {
        glTexCoord3f(u, v, data.z);
    }
};

struct TexTraitSingle : public ParticleTraits
{
    typedef struct
    {
        Real32    z;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.z = (*(part->getMFTextureZs()))[0];
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline void vertex(dataType &data)
    {
        glTexCoord1f(data.z);
    }
    
    static inline void vertex(dataType &data, UInt32 , Real32 u,
                                Real32 v)
    {
        glTexCoord3f(u, v, data.z);
    }
};

struct TexTraitNone : public ParticleTraits
{
    typedef UInt8 dataType;
    
    static inline void init(Particles *, DrawActionBase *, dataType &)
    {
    }
    
    static inline bool particle(dataType &, UInt32)
    {
        return false;
    }
    
    static inline void vertex(dataType &, UInt32 )
    {
        glTexCoord1f(0);
    }
   
    static inline void vertex(dataType &, UInt32, Real32 u, Real32 v)
    {
        glTexCoord2f(u, v);
    }
};


struct NormalTraitGeneric : public ParticleTraits
{
    typedef struct
    {
        GeoNormalsPtr norms;
        Vec3f         n;
        bool          perParticle;
    }
    dataType;
    
    static inline void init(Particles *part, DrawActionBase *, dataType &data)
    {
        data.norms = part->getNormals();
        
        data.perParticle = false;
        
        if(data.norms != NullFC)
        {
            if(data.norms->size() == 1)
            {
                data.n = data.norms->getValue(0);
            }
            else if(data.norms->getSize() == part->getPositions()->getSize())
            {
                data.perParticle = true;
            }
            else
            {
                data.n.setValues(0,1,0);
            }           
        }
        else
        {
            data.n.setValues(0,1,0);
        }
    }
    
    static inline bool particle(dataType &data, UInt32 particle)
    {
        if(data.perParticle)
            data.norms->getValue(data.n, particle);
             
        return false;
    }
    
    static inline Vec3f &normal(dataType &data)
    {
        return data.n;
    }
    
    static inline void normal(dataType &data, UInt32 )
    {
        glNormal3fv( (GLfloat*) data.n.getValues() );            
    }
};

struct NormalTraitGeneric3f : public ParticleTraits
{
    typedef struct
    {
        MFVec3f *norms;
        Vec3f   *n;
        bool     perParticle;
        Vec3f    const_n;