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

Go to the documentation of this file.

#pragma once
#ifndef SUPERELLIPSOID_H
#define SUPERELLIPSOID_H

#include "Quadric.h"

namespace RenderTools {

class Ellipsoid : public Quadric {
public:

        enum EllipsoidType {
                SPHERE,
                CYLINDER,
                STAR,
                DOUBLEPYRAMID,
                PILLOW,
                ROUNDCUBE,
                CUSTOM
        };

        class Patch{
                public:
                        Patch( int sx, int sy ){
                                m_subdiv[0] = sx;
                                m_subdiv[1] = sy;
                                m_vtx = new Mat4[m_subdiv[0] * m_subdiv[1]];
                                m_uv = new Vec2[m_subdiv[0] * m_subdiv[1]];
                        }
                        virtual ~Patch(){
                                delete [] m_vtx;
                                delete [] m_uv;
                        }
                        void setVertex( int x, int y, const Mat4 & m, const Vec2 & uv ){
                                m_vtx[ y * m_subdiv[0] + x ] = m;
                                m_uv[ y * m_subdiv[0] + x ] = uv;
                        }
                        void getVertex( int x, int y, Mat4 & m, Vec2 & uv ) const {
                                m = m_vtx[ y * m_subdiv[0] + x ];
                                uv = m_uv[ y * m_subdiv[0] + x ];
                        }
                private:
                        int m_subdiv[2];
                        Mat4 * m_vtx;
                        Vec2 * m_uv;
        };

        Ellipsoid( void );
        virtual ~Ellipsoid( 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 Mat4                    findSurfaceGlobal( const Vec3 & global, int iterations = 10 ) const;
        virtual Mat4                    findSurfaceLocal( const Vec3 & local, int iterations = 10 ) const;
        EllipsoidType                   getEllipsoidType( void ) const;
        void                                    setEllipsoidType( EllipsoidType t, bool send = true );

protected:
        EllipsoidType                   m_ellipsoidType;
private:
        void                                    ellipsoid( double u, double v, double n, double e, Vec3 & pos, Vec3 & nor );
        void                                    solidEllipsoid();
        void                                    solidEllipsoidWithUV();
        void                                    solidEllipsoidLowRes( );
        double                                  ellipsoidInsideOut( double x, double y, double z );

};

inline EnumList getEllipsoidTypeEnums( void ){
        EnumList r;
        r.push_back("SPHERE");
        r.push_back("CYLINDER");
        r.push_back("STAR");
        r.push_back("DOUBLEPYRAMID");
        r.push_back("PILLOW");
        r.push_back("ROUNDCUBE");
        r.push_back("CUSTOM");
        return( r );
}

struct EllipsoidTypeStruct {
        EllipsoidTypeStruct( Ellipsoid::EllipsoidType * e = 0 ):
                m_value( e ){
        }

        bool operator == ( const EllipsoidTypeStruct & v2 ){
                return( m_value == v2.m_value );
        }
        bool operator != ( const EllipsoidTypeStruct & v2 ){
                return( ! ( m_value == v2.m_value ) );
        }
        Ellipsoid::EllipsoidType operator [] ( const unsigned int i ){
                return( * m_value );
        }
        Ellipsoid::EllipsoidType * m_value;
};


inline ostream & operator << ( ostream & s, const EllipsoidTypeStruct & v ){
        switch( * v.m_value ){
                case Ellipsoid::SPHERE:
                        s << string( "SPHERE" );
                        break;
                case Ellipsoid::CYLINDER:
                        s << string( "CYLINDER" );
                        break;
                case Ellipsoid::STAR:
                        s << string( "STAR" );
                        break;
                case Ellipsoid::DOUBLEPYRAMID:
                        s << string( "DOUBLEPYRAMID" );
                        break;
                case Ellipsoid::PILLOW:
                        s << string( "PILLOW" );
                        break;
                case Ellipsoid::ROUNDCUBE:
                        s << string( "ROUNDCUBE" );
                        break;
                case Ellipsoid::CUSTOM:
                        s << string( "CUSTOM" );
                        break;
        }
        return( s );
}

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

        if( value == "SPHERE" ){
                * v.m_value = Ellipsoid::SPHERE;
        }
        else if( value == "CYLINDER" ){
                * v.m_value = Ellipsoid::CYLINDER;
        }
        else if( value == "STAR" ){
                * v.m_value = Ellipsoid::STAR;
        }
        else if( value == "DOUBLEPYRAMID" ){
                * v.m_value = Ellipsoid::DOUBLEPYRAMID;
        }
        else if( value == "PILLOW" ){
                * v.m_value = Ellipsoid::PILLOW;
        }
        else if( value == "ROUNDCUBE" ){
                * v.m_value = Ellipsoid::ROUNDCUBE;
        }
        else if( value == "CUSTOM" ){
                * v.m_value = Ellipsoid::CUSTOM;
        }

        return( s );
}


}; // namespace RenderTools


#endif

---