C:/development/RenderTools/src/factory/rendernode/AbstractCurve.h

Go to the documentation of this file.

#ifndef ABSTRACTCURVE_H
#define ABSTRACTCURVE_H

#include "Types.h"
#include "Rendernode.h"
#include "UpdateInterface.h"

namespace RenderTools {

using namespace std;

class AbstractCurve : public Rendernode , public UpdateInterface {
public:

        enum InterpolationType {
                LINEAR,
                HERMITE
        };

        AbstractCurve( void );
        virtual ~AbstractCurve( void );

        static PropertyPtr                      create( const XMLNodePtr & xml = XMLNodePtr() );
        virtual void                            createProperties( void );
        virtual const string            getTypeName( bool ofComponent = false ) const;

        virtual void                            onInitialize( void );
        virtual void                            clear( void ) = 0;
        void                                            setInterpolationType( InterpolationType t, bool send = true );
        void                                            setSubdivision( unsigned int s, bool send = true );
        void                                            setClosed( bool state, bool send = true );
        InterpolationType                       getInterpolationType( void ) const { return( m_interpolationType ); }
        unsigned int                            getSubdivision( void ) const { return( m_subdiv ); }
        bool                                            getClosed( void ) const { return( m_closed ); }
protected:
        string                                          m_type;
        InterpolationType                       m_interpolationType;
        unsigned int                            m_subdiv;
        bool                                            m_closed;
};

inline EnumList getInterpolationTypeEnums( void ){
        EnumList r;
        r.push_back("LINEAR");
        r.push_back("HERMITE");
        return( r );
}

struct InterpolationTypeStruct {
        InterpolationTypeStruct( AbstractCurve::InterpolationType * e = 0 ):
                m_value( e ){
        }

        bool operator == ( const InterpolationTypeStruct & v2 ){
                return( m_value == v2.m_value );
        }
        bool operator != ( const InterpolationTypeStruct & v2 ){
                return( ! ( m_value == v2.m_value ) );
        }
        AbstractCurve::InterpolationType operator [] ( const unsigned int i ){
                return( * m_value );
        }
        AbstractCurve::InterpolationType * m_value;
};

inline ostream & operator << ( ostream & s, const InterpolationTypeStruct & v ){
        switch( * v.m_value ){
                case AbstractCurve::LINEAR:
                        s << string( "LINEAR" );
                        break;
                case AbstractCurve::HERMITE:
                        s << string( "HERMITE" );
                        break;
        }
        return( s );
}

inline istream & operator >> ( istream & s, InterpolationTypeStruct & v ){
        string value;
        s >> value;

        if( value == "LINEAR" ){
                * v.m_value = AbstractCurve::LINEAR;
        }
        else if( value == "HERMITE" ){
                * v.m_value = AbstractCurve::HERMITE;
        }

        return( s );
}

}; // namespace rendertools

#endif

---