math.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.

// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//

//**************************************************************************/                      
// DESCRIPTION:
// CREATED: October 2008
//**************************************************************************/

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4201)
#endif


#include <xmmintrin.h>

#if defined(WIN32) || defined(WIN64)
#include <intrin.h>
#endif

#if (defined(_WIN32) && !defined(_WIN64))
#define OS_32BIT true
#endif


namespace mudbox {

class MBDLL_DECL Vector
{
public:
    inline Vector( void ) throw() { x = y = z = 0.0f; };

    inline Vector( float fX, float fY, float fZ = 0.0f ) throw() 
    { x = fX; y = fY; z = fZ; };

    inline Vector( const Vector &vVector ) throw() 
    { x = vVector.x; y = vVector.y; z = vVector.z; };

    inline Vector( const char *pVector ) throw()
    { x = pVector[0]*(1.0f/127.0f); y = pVector[1]*(1.0f/127.0f); z = pVector[2]*(1.0f/127.0f); };

    inline Vector( const short *pVector ) throw() 
    { x = pVector[0]*(1.0f/32767.0f); y = pVector[1]*(1.0f/32767.0f); z = pVector[2]*(1.0f/32767.0f); };

    inline Vector &Set( float fX, float fY, float fZ ) throw() 
    { x = fX; y = fY; z = fZ; return *this; };

    inline Vector &Clear( void ) throw () 
    { return Set( 0.0f, 0.0f, 0.0f ); };

    Vector &Normalize( void ) throw();

    Vector &NormalizeApprox( void ) throw();

    Vector Normalized( void ) const throw();

    Vector &MakeOrthogonal( const Vector &vBase );

    inline Vector &SetLength( float fLength ) 
    { Normalize(); operator *=( fLength ); return *this; };


    inline Vector &RotateOrthogonal( const Vector &vBase ) 
    { float fLen = Length(); MakeOrthogonal( vBase ); SetLength( fLen ); return *this; };

    
    inline float LengthSquare( void ) const { return x*x+y*y+z*z; };
    
    float Length() const throw();

    float Length2D() const throw();

    inline float DistanceFrom( const Vector &v ) const { return operator -(v).Length(); };

    inline float DistanceSquareFrom( const Vector &v ) const { return operator -(v).LengthSquare(); };

    float DistanceFromLine( const Vector &v0, const Vector &v1 ) const;

    float DistanceFromSegment( const Vector &v0, const Vector &v1 ) const;

    float DistanceFromTriangleSquared( const Vector& v0, const Vector& v1, const Vector& v2, 
                                       float* aBaryCoords = 0 ) const;

    const Vector &Relocate2D( const Vector &v0, const Vector &v1 );

    void Relocate( const Vector &v0, const Vector &v1, const Vector &v2 );


    bool Relocate2DQuad( const Vector &v0, const Vector &v1, 
                         const Vector &v2, const Vector &v3 );

    bool RelocateQuad( const Vector &v0, const Vector &v1, 
                         const Vector &v2, const Vector &v3 );
    
    float AngleCos( const Vector &v1 ) const throw() 
    { return Vector(*this).Normalize()|Vector(v1).Normalize(); };
    

    inline Vector Minimum( const Vector &o ) 
    { return Vector( Min(x, o.x), Min(y, o.y), Min(z, o.z) ); };

    inline Vector Maximum( const Vector &o ) 
    { return Vector( Max(x, o.x), Max(y, o.y), Max(z, o.z) ); };

    inline Vector operator -( void ) const throw() 
    { return Vector( -x, -y, -z ); };

    inline Vector operator +( float f ) const throw() 
    { return Vector( x+f, y+f, z+f ); };

    inline Vector operator +( const Vector &v ) const throw() 
    { return Vector( x+v.x, y+v.y, z+v.z ); };

    inline Vector operator -( const Vector &v ) const throw() 
    { return Vector( x-v.x, y-v.y, z-v.z ); };

    inline Vector operator *( const Vector &v ) const throw() 
    { return Vector( x*v.x, y*v.y, z*v.z ); };

    inline Vector operator *( float f ) const throw() 
    { return Vector( x*f, y*f, z*f ); };
    
    inline Vector operator /( const Vector &v ) const throw() 
    { return Vector( x/v.x, y/v.y, z/v.z ); };

    inline Vector operator /( float f ) const throw() 
    { return operator *( 1.0f/f ); };

    inline Vector operator *( int i ) const throw() 
    { return operator *( float(i) ); };

    inline Vector operator /( int i ) const throw() 
    { return operator /( float(i) ); };

    inline Vector operator /( unsigned int i ) const throw() 
    { return operator /( float(i) ); };

    inline float operator |( const Vector &v ) const throw() 
    { return x*v.x+y*v.y+z*v.z; };

    Vector operator &( const Vector &v ) const
    {
        Vector vR;
        vR.m_fX = m_fY*v.m_fZ-m_fZ*v.m_fY;
        vR.m_fY = m_fZ*v.m_fX-m_fX*v.m_fZ;
        vR.m_fZ = m_fX*v.m_fY-m_fY*v.m_fX;
        return vR;
    };


    inline bool operator ==( const Vector &v ) const throw() 
    { return x == v.x && y == v.y && z == v.z; };

    inline bool operator !=( const Vector &v ) const throw() 
    { return !operator ==( v ); };

    inline operator bool( void ) const throw() { return x || y || z; };
    
    inline bool operator !( void ) const throw() { return !operator bool(); };

    inline Vector &operator =( const Vector &v ) 
    { x = v.x; y = v.y; z = v.z; return *this; };

    inline Vector &operator <<( const Vector &v ) 
    { x = v.x; y = v.y; z = v.z; return *this; };

    inline Vector &operator -=( const Vector &v ) throw() 
    { x-=v.x; y-=v.y; z-=v.z; return *this; };
    
    inline Vector &operator +=( const Vector &v ) throw() 
        { x+=v.x; y+=v.y; z+=v.z; return *this; };

    inline Vector &operator +=( const float f ) throw() 
        { x+=f; y+=f; z+=f; return *this; };

    inline Vector &operator -=( const float f ) throw() 
        { x-=f; y-=f; z-=f; return *this; };

    inline Vector &operator *=( float f ) throw() { x *= f; y *= f; z *= f; return *this; };

    inline Vector &operator *=( const Vector &v ) throw()
        { x *= v.x; y *= v.y; z *= v.z; return *this; };

    inline Vector &operator /=( float f ) { return operator *=( 1.0f/f ); };

    inline float &operator [] (
        int i   
        ) throw() { return m_aCoors[i]; };

    inline float &operator [](
        unsigned int i  
        ) throw() { return m_aCoors[i]; };
        
    inline operator const float *( void ) const { return &x; };
    union 
    {
        struct { float m_fX, m_fY, m_fZ; };
        struct { float x, y, z; };
        float m_aCoors[3];
    };
};



class MBDLL_DECL DblVector
{
public:
    inline DblVector( void ) throw() { x = y = z = 0.0; };


    Vector Vec() const {
        return Vector((float)x, (float)y, (float)z);
    }

    inline DblVector( double fX, double  fY, double  fZ = 0.0 ) throw() 
    { x = fX; y = fY; z = fZ; };

    inline DblVector( const DblVector &vVector ) throw() 
    { x = vVector.x; y = vVector.y; z = vVector.z; };

    inline DblVector( const Vector &vVector ) throw() 
    { x = vVector.x; y = vVector.y; z = vVector.z; };

    inline DblVector( const char *pVector ) throw()
    { x = pVector[0]*(1.0/127.0); y = pVector[1]*(1.0/127.0); z = pVector[2]*(1.0/127.0); };

    inline DblVector( const short *pVector ) throw() 
    { x = pVector[0]*(1.0/32767.0); y = pVector[1]*(1.0/32767.0); z = pVector[2]*(1.0/32767.0); };

    inline DblVector &Set( double fX, double fY, double fZ ) throw() 
    { x = fX; y = fY; z = fZ; return *this; };

    inline DblVector &Clear( void ) throw () 
    { return Set( 0.0, 0.0, 0.0 ); };

    DblVector &Normalize( void ) throw();

    DblVector Normalized( void ) const throw();

    DblVector &MakeOrthogonal( const DblVector &vBase );

    inline DblVector &SetLength( double fLength ) 
    { Normalize(); operator *=( fLength ); return *this; };

    
    inline double LengthSquare( void ) const { return x*x+y*y+z*z; };
    
    double Length() const throw();

    double Length2D() const throw();

    inline double DistanceFrom( const DblVector &v ) const { return operator -(v).Length(); };

    double DistanceFromLine( const DblVector &v0, const DblVector &v1 ) const;

    double DistanceFromSegment( const DblVector &v0, const DblVector &v1 ) const;

    
    double AngleCos( const DblVector &v1 ) const throw() 
    { return DblVector(*this).Normalize()|DblVector(v1).Normalize(); };
    
    inline DblVector Minimum( const DblVector &o ) 
    { return DblVector( Min(x, o.x), Min(y, o.y), Min(z, o.z) ); };

    inline DblVector Maximum( const DblVector &o ) 
    { return DblVector( Max(x, o.x), Max(y, o.y), Max(z, o.z) ); };

    inline DblVector operator -( void ) const throw() 
    { return DblVector( -x, -y, -z ); };

    inline DblVector operator +( double f ) const throw() 
    { return DblVector( x+f, y+f, z+f ); };

    inline DblVector operator +( const DblVector &v ) const throw() 
    { return DblVector( x+v.x, y+v.y, z+v.z ); };

    inline DblVector operator -( const DblVector &v ) const throw() 
    { return DblVector( x-v.x, y-v.y, z-v.z ); };

    inline DblVector operator *( const DblVector &v ) const throw() 
    { return DblVector( x*v.x, y*v.y, z*v.z ); };

    inline DblVector operator *( double f ) const throw() 
    { return DblVector( x*f, y*f, z*f ); };
    
    inline DblVector operator /( const DblVector &v ) const throw() 
    { return DblVector( x/v.x, y/v.y, z/v.z ); };

    inline DblVector operator /( double f ) const throw() 
    { return operator *( 1.0/f ); };

    inline DblVector operator *( int i ) const throw() 
    { return operator *( double(i) ); };

    inline DblVector operator /( int i ) const throw() 
    { return operator /( double(i) ); };

    inline DblVector operator /( unsigned int i ) const throw() 
    { return operator /( double(i) ); };

    inline double operator |( const DblVector &v ) const throw() 
    { return x*v.x+y*v.y+z*v.z; };

    DblVector operator &( const DblVector &v ) const
    {
        DblVector vR;
        vR.m_fX = m_fY*v.m_fZ-m_fZ*v.m_fY;
        vR.m_fY = m_fZ*v.m_fX-m_fX*v.m_fZ;
        vR.m_fZ = m_fX*v.m_fY-m_fY*v.m_fX;
        return vR;
    };

    inline bool operator ==( const DblVector &v ) const throw() 
    { return x == v.x && y == v.y && z == v.z; };

    inline bool operator !=( const DblVector &v ) const throw() 
    { return !operator ==( v ); };

    inline operator bool( void ) const throw() { return x || y || z; };
    
    inline bool operator !( void ) const throw() { return !operator bool(); };

    inline DblVector &operator =( const DblVector &v ) 
    { x = v.x; y = v.y; z = v.z; return *this; };

    inline DblVector &operator <<( const DblVector &v ) 
    { x = v.x; y = v.y; z = v.z; return *this; };

    inline DblVector &operator -=( const DblVector &v ) throw() 
    { x-=v.x; y-=v.y; z-=v.z; return *this; };
    
    inline DblVector &operator +=( const DblVector &v ) throw() 
        { x+=v.x; y+=v.y; z+=v.z; return *this; };

    inline DblVector &operator *=( double f ) { x *= f; y *= f; z *= f; return *this; };

    inline DblVector &operator *=( const DblVector &v ) 
        { x *= v.x; y *= v.y; z *= v.z; return *this; };

    inline DblVector &operator /=( double f ) { return operator *=( 1.0/f ); };

    inline double &operator [] (
        int i   
        ) throw() { return m_aCoors[i]; };

    inline double &operator [](
        unsigned int i  
        ) throw() { return m_aCoors[i]; };
        
    inline operator const double *( void ) const { return &x; };
    union 
    {
        struct { double m_fX, m_fY, m_fZ; };
        struct { double x, y, z; };
        double m_aCoors[3];
    };
};


inline MBDLL_DECL Vector operator *( float f, const Vector &v ) throw() 
{ return v*f; };

inline MBDLL_DECL Vector operator *( int i, const Vector &v ) throw() 
{ return float(i)*v; };

inline MBDLL_DECL DblVector operator *( double f, const DblVector &v ) throw() 
{ return v*f; };

inline MBDLL_DECL DblVector operator *( int i, const DblVector &v ) throw() 
{ return double(i)*v; };

typedef AttributeInstance<Vector> avector;

MBDLL_DECL AttributeWidget *CreateNewVectorWidget( QWidget *pParent, 
                                                   int      iWidth, 
                                                   avector *pAttribute );

template <> inline
AttributeWidget *avector::CreateEditorWidget( QWidget *pParent, int iWidth ) 
{ return CreateNewVectorWidget( pParent, iWidth, this ); };

template <> inline
QString avector::AsString( bool /*bLocalized*/ ) const 
{ return QString("%1 %2 %3").arg(m_cValue.x).arg(m_cValue.y).arg(m_cValue.z); };

template <> inline
void avector::SetFromString( const QString &s, bool /*bInternal*/, bool /*bLocalized*/ ) 
{ 
    m_cValue.x = s.section( ' ', 0,0 ).toFloat();
    m_cValue.y = s.section( ' ', 1,1 ).toFloat(); 
    m_cValue.z = s.section( ' ', 2,2 ).toFloat(); 
};

template <> inline
Attribute::AttributeType avector::Type( void ) const { return typeVector; };


class MBDLL_DECL Vector4
{
public:
    Vector4() { x=y=z=w=0.0f; }

    Vector4(float X, float Y, float Z, float W) {x=X; y=Y; z=Z; w=W;}

    inline bool operator ==( const Vector4 &v ) const throw() 
    { return x == v.x && y == v.y && z == v.z; };

    inline bool operator !=( const Vector4 &v ) const throw() 
    { return !operator ==( v ); };

    union {
        struct {
            float x, y, z, w;
        };
        double  m_dAlignDummy;    // try for 8 byte alignment.
#if !defined  OS_32BIT 
        __m128  m_VecSSE;         // get 16 byte alignment.
#endif
    };
};



typedef AttributeInstance<Vector4> avector4;

MBDLL_DECL AttributeWidget *CreateNewVector4Widget( QWidget *pParent, int iWidth, avector4 *pAttribute );

template <> inline

AttributeWidget *avector4::CreateEditorWidget( QWidget *pParent, int iWidth ) 
{ return CreateNewVector4Widget( pParent, iWidth, this ); };

template <> inline
QString avector4::AsString( bool /*bLocalized*/ ) const 
{ return QString("%1 %2 %3 %4").arg(m_cValue.x).arg(m_cValue.y).arg(m_cValue.z).arg(m_cValue.w); };

template <> inline
void avector4::SetFromString( const QString &s, bool /*bInternal*/, bool /*bLocalized*/ ) 
{
    m_cValue.x = s.section( ' ', 0, 0 ).toFloat(); 
    m_cValue.y = s.section( ' ', 1, 1 ).toFloat(); 
    m_cValue.z = s.section( ' ', 2, 2 ).toFloat(); 
    m_cValue.w = s.section( ' ', 3, 3 ).toFloat();
};

template <> inline
Attribute::AttributeType avector4::Type( void ) const { return typeVector; };




class MBDLL_DECL Color

{
public:

    Color( float fRed = 1.0f, float fGreen = 1.0f, float fBlue = 1.0f, float fAlpha = 1.0f ) 
    { m_fRed = fRed; m_fGreen = fGreen; m_fBlue = fBlue, m_fAlpha = fAlpha; };

#ifdef QT_VERSION

    Color( const QColor &c ) 
    { r = c.redF(); 
      g = c.greenF(); 
      b = c.blueF(); 
      a = 1.0f; };

#endif

    inline void Set( float fRed, float fGreen, float fBlue, float fAlpha = 1.0f ) 
    { r = fRed; g = fGreen; b = fBlue; a = fAlpha; };


    inline operator const float *( void ) const { return &m_fRed; };

    inline float &operator[]( unsigned int iChannel ) 
    { MB_ASSERT( iChannel < 4 ); return m_fData[iChannel]; };

    inline operator unsigned int( void ) const 
        { return (unsigned int)(0xff*m_fRed)+(((unsigned int)(0xff*m_fGreen))<<8)+
            (((unsigned int)(0xff*m_fBlue))<<16)+(((unsigned int)(0xff*m_fAlpha))<<24); };


    Color &operator *=(const float f) { r*=f; g*=f; b*=f; return *this; };

    Color operator *( float f ) const 
        { return Color( r*f, g*f, b*f, a*f ); };

    Color operator /( float f ) const 
        { return operator *( 1/f ); };

    Color operator *( const Color &c ) const 
        { return Color( r*c.r, g*c.g, b*c.b, a*c.a ); };

    Color &operator *=( const Color &c ) 
    { r *= c.r; g *= c.g; b *= c.b; a *= c.a; return *this; };

    Color operator +( const Color &c ) const 
        { return Color( r+c.r, g+c.g, b+c.b, a+c.a ); };

    Color operator -( const Color &c ) const 
        { return Color( r-c.r, g-c.g, b-c.b, a-c.a ); };

    Color &operator +=( const Color &c ) 
    { r += c.r; g += c.g; b += c.b; a += c.a; return *this; };

    bool operator ==( const Color &c ) const 
        { return r == c.r && g == c.g && b == c.b && a == c.a; };

    inline bool operator !=( const Color &c ) const { return !operator ==( c ); };
    

    Color Mix( const Color &c, float f ) const
    { return Color( r*f+c.r*(1-f), g*f+c.g*(1-f), b*f+c.b*(1-f), a*f+c.a*(1-f) ); };

    inline float Luminance() const 
        { return 0.299f * r + 0.587f * g + 0.114f * b; }

    
    void toHSV(float &hue, float &sat, float &val) const;
    void fromHSV(float hue, float sat, float val);

    void toCMYK (float &c, float &m, float &y, float &k) const;
    void fromCMYK (float c, float m, float y, float k);

#ifdef QT_VERSION
    operator QColor( void ) const { QColor col; col.setRgbF( r, g, b ); return col; };
    QColor ToQColor( void ) const { QColor col; col.setRgbF( r, g, b ); return col; };
#endif

    union {
        struct { float m_fRed, m_fGreen, m_fBlue, m_fAlpha; };
        struct { float r, g, b, a; };
        float  m_fData[4];

        double m_dAlignDummy;   // try for 8 byte alignment.
#if !defined  OS_32BIT 
        __m128 m_vAlignDummy;   // try for 16 byte alignment....
#endif
    };


    static Color black;
    static Color white;
    static Color red;
    static Color green;
    static Color blue;
    static Color gray;
    static Color transparent;
};



inline Color operator *( float f, const Color &c ) 
{ return Color( c.r*f, c.g*f, c.b*f, c.a*f ); };


typedef AttributeInstance<Color> acolor;

MBDLL_DECL AttributeWidget *CreateNewColorWidget( QWidget *pParent, int iWidth, acolor *pAttribute );

template <> inline
AttributeWidget *acolor::CreateEditorWidget( QWidget *pParent, int iWidth ) 
{ return CreateNewColorWidget( pParent, iWidth, this ); };

template <> inline
Attribute::AttributeType acolor::Type( void ) const { return typeColor; };

template <> inline
QString acolor::AsString( bool /*bLocalized*/ ) 
const { return QString("%1 %2 %3 %4").arg(m_cValue.r).arg(m_cValue.g).arg(m_cValue.b).arg(m_cValue.a); };

template <> inline
void acolor::SetFromString( const QString &s, bool /*bInternal*/, bool /*bLocalized*/ ) 
{
    m_cValue.r = s.section( ' ', 0, 0 ).toFloat(); 
    m_cValue.g = s.section( ' ', 1, 1 ).toFloat(); 
    m_cValue.b = s.section( ' ', 2, 2 ).toFloat(); 
    m_cValue.a = s.section( ' ', 3, 3 ).toFloat();
};



class MBDLL_DECL AxisAlignedBoundingBox
{
public:
    AxisAlignedBoundingBox( void ) { Reset(); };

    AxisAlignedBoundingBox( const Vector &vStart, const Vector &vEnd ) :
        m_vStart( vStart ),
        m_vEnd( vEnd ) {};

    AxisAlignedBoundingBox( const Vector &vCenter, float fSize )
    {
        Vector v( fSize, fSize, fSize );
        m_vStart = vCenter-v;
        m_vEnd   = vCenter+v;
    };

    AxisAlignedBoundingBox( const AxisAlignedBoundingBox &cA ) :
    m_vStart( cA.m_vStart ),
    m_vEnd( cA.m_vEnd ) {};

    AxisAlignedBoundingBox &operator =( const AxisAlignedBoundingBox &cBB )
    {
        m_vStart = cBB.m_vStart;
        m_vEnd = cBB.m_vEnd;
        return *this;
    };

    AxisAlignedBoundingBox &operator +=( const AxisAlignedBoundingBox &cBB )
    {
        for ( int i = 0; i < 8; i++ ) Extend( cBB[i] );
        return *this;
    };

    bool operator ==( const AxisAlignedBoundingBox &cBB ) const
    {
        return m_vStart == cBB.m_vStart && m_vEnd == cBB.m_vEnd;
    };

    void Reset( void )
    {
        m_vStart.Set( 0, 0, 0 );
        m_vEnd.Set( -1, -1, -1 );
    };

    void Serialize( Stream &s );


    bool operator !=( const AxisAlignedBoundingBox &cBox ) const 
        { return !(operator ==(cBox)); };


    inline void Extend( const Vector & cV) throw()
    {
        if ( IsEmpty() ) {
            m_vStart = m_vEnd = cV;
        } else {
            if ( m_vStart.m_fX > cV.m_fX ) m_vStart.m_fX = cV.m_fX;
            if ( m_vStart.m_fY > cV.m_fY ) m_vStart.m_fY = cV.m_fY;
            if ( m_vStart.m_fZ > cV.m_fZ ) m_vStart.m_fZ = cV.m_fZ;
            if ( m_vEnd.m_fX   < cV.m_fX ) m_vEnd.m_fX   = cV.m_fX;
            if ( m_vEnd.m_fY   < cV.m_fY ) m_vEnd.m_fY   = cV.m_fY;
            if ( m_vEnd.m_fZ   < cV.m_fZ ) m_vEnd.m_fZ   = cV.m_fZ;
        }
    }

    void Extend( const AxisAlignedBoundingBox &bb )
    {
        if ( !bb.IsEmpty() ) {
            Extend( bb.m_vStart );
            Extend( bb.m_vEnd );
        };
    };

    void ExpandBy(float f) throw()
    {
        m_vStart -= f;
        m_vEnd   += f;
    }

    void Transform( const class Matrix &mMatrix );

    Vector operator []( int iCornerIndex ) const;

    float Size( void ) const { return Max( Max( XSize(), YSize() ), ZSize() ); };

    float XSize( void ) const { return m_vEnd.m_fX-m_vStart.m_fX; };

    float YSize( void ) const { return m_vEnd.m_fY-m_vStart.m_fY; };

    float ZSize( void ) const { return m_vEnd.m_fZ-m_vStart.m_fZ; };

    float Volume( void ) const { return XSize()*YSize()*ZSize(); };

    Vector Center( void ) const { return (m_vStart+m_vEnd)*0.5f; };

    bool IsPartOf( const AxisAlignedBoundingBox &cBB ) const
    {
        return (
            m_vStart.m_fX >= cBB.m_vStart.m_fX && m_vEnd.m_fX <= cBB.m_vEnd.m_fX &&
            m_vStart.m_fY >= cBB.m_vStart.m_fY && m_vEnd.m_fY <= cBB.m_vEnd.m_fY &&
            m_vStart.m_fZ >= cBB.m_vStart.m_fZ && m_vEnd.m_fZ <= cBB.m_vEnd.m_fZ );
    };

    bool IsTouching( const AxisAlignedBoundingBox &cBB ) const
    {
        return (
            m_vStart.m_fX < cBB.m_vEnd.m_fX && m_vEnd.m_fX > cBB.m_vStart.m_fX &&
            m_vStart.m_fY < cBB.m_vEnd.m_fY && m_vEnd.m_fY > cBB.m_vStart.m_fY &&
            m_vStart.m_fZ < cBB.m_vEnd.m_fZ && m_vEnd.m_fZ > cBB.m_vStart.m_fZ );
    };
    

    bool IsTouching(
        const Vector &vStart,   
        const Vector &vEnd,     
        float &fPlace           
        ) const;

    bool IsContaining( const Vector &cV ) const
    {
        return (
            m_vStart.m_fX <= cV.m_fX && m_vEnd.m_fX >= cV.m_fX &&
            m_vStart.m_fY <= cV.m_fY && m_vEnd.m_fY >= cV.m_fY &&
            m_vStart.m_fZ <= cV.m_fZ && m_vEnd.m_fZ >= cV.m_fZ );
    };
    

    bool IsContaining( const AxisAlignedBoundingBox &b ) const 
        { return IsContaining( b.m_vStart ) && IsContaining( b.m_vEnd ); };
    
    AxisAlignedBoundingBox Intersection( const AxisAlignedBoundingBox& cOther ) const
    {
        if( !IsTouching( cOther ) ) return AxisAlignedBoundingBox();

        return AxisAlignedBoundingBox(
            Vector( 
                Max( cOther.m_vStart.x, m_vStart.x ), 
                Max( cOther.m_vStart.y, m_vStart.y ), 
                Max( cOther.m_vStart.z, m_vStart.z ) ) ,
            Vector( 
                Min( cOther.m_vEnd.x, m_vEnd.x ), 
                Min( cOther.m_vEnd.y, m_vEnd.y ), 
                Min( cOther.m_vEnd.z, m_vEnd.z ) ) );
    }   

    bool IsEmpty( void ) const { return m_vStart.x > m_vEnd.x; };

    AxisAlignedBoundingBox operator *( float fFactor )
    {
        return AxisAlignedBoundingBox( m_vStart*fFactor, m_vEnd*fFactor );
    };
    
    static AxisAlignedBoundingBox SphereBoundingBox( const Vector& cCenter, float fRadius, const Matrix& mTransform );

    Vector m_vStart;
    Vector m_vEnd;
};



class MBDLL_DECL Base
{

public:
    Base( void );

    Base( const Vector &vA, const Vector &vB, const Vector &vC );

    bool operator !=( const Base &o ) const { return a != o.a || b != o.b || c != o.c; };

    void Derive(
        unsigned int iIndex,    
        bool bRightHand = true  
        );



    void Orthogonalize(
        unsigned int iIndex,        
        unsigned int iSource = (unsigned int)-1   
        );

    void Normalize( void ) { a.Normalize(); b.Normalize(); c.Normalize(); };


    Vector TransformFrom( const Vector &cSource ) const;

    Vector TransformTo( const Vector &cSource ) const;

    Base operator *( float fFactor ) const;

    Base operator +( const Base &bOther ) const;

    Base operator -( const Base &bOther ) const;
    
    Vector& Axis(
        unsigned int iIndex 
        );


    const Vector& Axis(
        unsigned int iIndex 
        ) const;

    Vector a, b, c;
};



class SubSpace : public Node

{
    DECLARE_CLASS;

public:
    virtual void Initialize( const class Mesh *pMesh, Store<unsigned int> aFaceList, float fAClip, float fBClip );
    virtual bool IsOutside( const Vector &vPos, float fRange ) const;
    virtual AxisAlignedBoundingBox BoundingBox( void ) const;
};



class MBDLL_DECL Matrix
{
public:

    Matrix( void ) {};

    Matrix( const Matrix &m ) :
        _11(m._11), _12(m._12), _13(m._13), _14(m._14), 
        _21(m._21), _22(m._22), _23(m._23), _24(m._24), 
        _31(m._31), _32(m._32), _33(m._33), _34(m._34), 
        _41(m._41), _42(m._42), _43(m._43), _44(m._44) {};

    Matrix( float f11, float f12, float f13, float f14,
            float f21, float f22, float f23, float f24,
            float f31, float f32, float f33, float f34,
            float f41, float f42, float f43, float f44 ) :
        _11(f11), _12(f12), _13(f13), _14(f14), 
        _21(f21), _22(f22), _23(f23), _24(f24), 
        _31(f31), _32(f32), _33(f33), _34(f34), 
        _41(f41), _42(f42), _43(f43), _44(f44) {};

    Matrix( const double *pMatrix );

    float &operator()( int iRow, int iColumn ) 
    { 
        return m_fData[iRow*4+iColumn]; 
    };
    
    float operator()( int iRow, int iColumn ) const 
    { 
        return m_fData[iRow*4+iColumn]; 
    };
    
    operator const float *( void ) const { return m_fData; };
    
    operator float *( void ) { return m_fData; };

    Matrix &SetIdentity( void );

    bool IsIdentity( void ) const;

    bool IsRigid( void ) const;
    
    Matrix &operator *=( float );

    Matrix operator *( const Matrix &m ) const;

    Matrix operator *( float ) const;

    Matrix operator +( const Matrix & ) const;

    Matrix &operator *=( const Matrix &m );

    bool operator ==( const Matrix &m ) const;

    void SetRow( int iRowIndex, const Vector &vValue );

    Matrix &Transpose( void );

    Matrix &Invert( bool* pOk = 0 );

    Matrix &FromEuler( const Vector &vAngles );

    Vector ToEuler( void ) const;
    
    Matrix &FromAxisAngle( const Vector &vAxis, float fAngle );

    Vector Transform(
        const Vector &v,    
        float fW = 1.0f     
        ) const
    {
        return Vector( 
            v.m_fX*_11+v.m_fY*_21+v.m_fZ*_31+fW*_41,
            v.m_fX*_12+v.m_fY*_22+v.m_fZ*_32+fW*_42,
            v.m_fX*_13+v.m_fY*_23+v.m_fZ*_33+fW*_43 );
    };

    Vector ProjectedTransform(
        const Vector &v,    
        float fW = 1.0f     
        ) const
    {
        float fRW = v.m_fX*_14+v.m_fY*_24+v.m_fZ*_34+fW*_44;
        return (1/fRW)*Vector( 
            v.m_fX*_11+v.m_fY*_21+v.m_fZ*_31+fW*_41,
            v.m_fX*_12+v.m_fY*_22+v.m_fZ*_32+fW*_42,
            v.m_fX*_13+v.m_fY*_23+v.m_fZ*_33+fW*_43 );
    };


    Vector Transform(
        const Vector &v,    
        float fW,           
        float &fRW          
        ) const
    {
        fRW = v.m_fX*_14+v.m_fY*_24+v.m_fZ*_34+fW*_44;
        return Vector( 
            v.m_fX*_11+v.m_fY*_21+v.m_fZ*_31+fW*_41,
            v.m_fX*_12+v.m_fY*_22+v.m_fZ*_32+fW*_42,
            v.m_fX*_13+v.m_fY*_23+v.m_fZ*_33+fW*_43 );
    };

    Vector TransformDirection( const Vector &v ) const
    {
        return Vector( 
            v.m_fX*_11+v.m_fY*_21+v.m_fZ*_31,
            v.m_fX*_12+v.m_fY*_22+v.m_fZ*_32,
            v.m_fX*_13+v.m_fY*_23+v.m_fZ*_33 );
    };

    union {
        float  m_fData[16];
        struct {
            float _11, _12, _13, _14;
            float _21, _22, _23, _24;
            float _31, _32, _33, _34;
            float _41, _42, _43, _44;
        };
        double  m_fAlignDummy[8];   // at least get it 8 byte aligned.
#if !defined  OS_32BIT 
        __m128  m_vAlignDummy[4];   // try for 16 byte....
#endif
    };
};
typedef AttributeInstance<Matrix> amatrix;
class MBDLL_DECL Quaternion
{
public:
    inline Quaternion( void ) { SetIdentity(); };

    inline Quaternion( 
        float fW, 
        const Vector &vXYZ 
        )
    { m_fW = fW; m_fX = vXYZ.x; m_fY = vXYZ.y; m_fZ = vXYZ.z; };

    inline Quaternion( float fW, float fX, float fY, float fZ )
    { m_fW = fW; m_fX = fX; m_fY = fY; m_fZ = fZ; };

    Quaternion( 
        const Vector &vAxis, 
        float fAngle 
        );

    Quaternion( const Matrix &mRotation );

    float LengthSquare( void ) const;

    float Length( void ) const;

    Matrix ToMatrix( void ) const;

    Vector Transform( 
        const Vector &vPoint 
        ) const;

    inline Quaternion operator *( float fMultiplier ) const
    { return Quaternion( m_fW*fMultiplier, m_fX*fMultiplier, m_fY*fMultiplier, m_fZ*fMultiplier ); };

    inline Quaternion &operator *=( float fMultiplier ) 
    { *this = operator *( fMultiplier ); return *this; };

    inline Quaternion operator -( void ) const 
    { return Quaternion( -m_fW, -m_fX, -m_fY, -m_fZ ); };

    Quaternion operator +( const Quaternion &vAddition ) const;

    Quaternion &operator +=( const Quaternion &vAddition );

    Quaternion operator -( const Quaternion &vAddition ) const;

    Quaternion &operator -=( const Quaternion &vAddition );

    Quaternion operator *( const Quaternion &vMultiplier ) const;

    Quaternion &operator *=( const Quaternion &vMultiplier );

    float operator |( const Quaternion &vMultiplier ) const;

    Quaternion &Normalize( void );

    Quaternion &Conjugate( void );

    Quaternion &Invert( void );

    Quaternion Slerp( const Quaternion &vTarget, float fWeight ) const;

    inline void SetIdentity( void ) 
    { m_fW = 1.0; m_fX = m_fY = m_fZ = 0.0f; };

    void SetZero( void ) { m_fW = m_fX = m_fY = m_fZ = 0.0f; };

    float operator []( 
        int iIndex 
        ) const;

    float m_fW, m_fX, m_fY, m_fZ;
};

class MBDLL_DECL DualQuaternion
{
public:
    inline DualQuaternion( void ) { SetIdentity(); };

    inline DualQuaternion( 
        const Quaternion &vReal, 
        const Quaternion &vDual  
        )
    { m_vReal = vReal; m_vDual = vDual; };

    DualQuaternion( 
        const Vector &vPivot, 
        const Vector &vAxis, 
        float fAngle 
        );

    DualQuaternion(
        float fAngle, 
        float fPitch, 
        const Vector &vDirection,
        const Vector &vMoment 
        );

    DualQuaternion( 
        const Vector &vTranslation, 
        const Quaternion &vRotation 
        );

    DualQuaternion( const Matrix &mRigid );

    Matrix ToMatrix( void ) const;

    Vector Translation( void ) const;

    Vector Transform( const Vector &vPoint ) const;

    DualQuaternion operator +( const DualQuaternion &vAddition ) const;

    DualQuaternion &operator +=( const DualQuaternion &vAddition );

    DualQuaternion operator -( const DualQuaternion &vAddition ) const;

    DualQuaternion &operator -=( const DualQuaternion &vAddition );

    DualQuaternion operator *( const DualQuaternion &vMultiplier ) const;

    DualQuaternion &operator *=( const DualQuaternion &vMultiplier );

    DualQuaternion operator *( float fMultiplier ) const;

    DualQuaternion &Normalize( void );

    void ToScrew( float &fAngle, float &fPitch, Vector &vDirection, Vector &vMoment ) const;

    DualQuaternion &Power( float fExponent );

    DualQuaternion Slerp( const DualQuaternion &vTarget, float fWeight ) const;

    DualQuaternion &Conjugate( void );

    DualQuaternion &DualConjugate( void );

    inline DualQuaternion &DoubleConjugate( void ) { Conjugate(); DualConjugate(); return *this; };

    DualQuaternion &Invert( void );

    void SetIdentity( void ) { m_vReal.SetIdentity(); m_vDual.SetZero(); };

    float operator []( 
        int iIndex 
        ) const;

    Quaternion m_vReal, m_vDual;

private:
    DualQuaternion( const Vector &vPoint );

};

class MBDLL_DECL Line
{
    Vector m_vStart, m_vEnd, m_vDirection;
    float m_fFactor;

public:

    Line( const Vector &vStart, const Vector &vEnd );



    float RangeFrom( const Vector &vPoint );

    enum IntersectionResult
    {
        PARALLEL,
        COINCIDENT,
        NOT_INTERSECTING,
        INTERSECTING
    };

    IntersectionResult Intersection2D( const Line& cOther, Vector &vResult, bool bSegmentOnly = false );
};





class MBDLL_DECL Selector : virtual public Node
{
    DECLARE_CLASS;

public:
    enum EState
    {
        eInside,
        eOutside,
        eTouching
    };

    virtual EState IsTouchedBy( const AxisAlignedBoundingBox &cArea ) const;
};


inline MBDLL_DECL Vector operator *( const Vector &v, const Matrix &m )
{
    return Vector( 
        v.m_fX*m._11+v.m_fY*m._21+v.m_fZ*m._31+m._41,
        v.m_fX*m._12+v.m_fY*m._22+v.m_fZ*m._32+m._42,
        v.m_fX*m._13+v.m_fY*m._23+v.m_fZ*m._33+m._43 );
};

inline MBDLL_DECL Vector operator *( const Matrix &m, const Vector &v ) 
{
    return Vector( 
        v.m_fX*m._11+v.m_fY*m._12+v.m_fZ*m._13+m._14,
        v.m_fX*m._21+v.m_fY*m._22+v.m_fZ*m._23+m._24,
        v.m_fX*m._31+v.m_fY*m._32+v.m_fZ*m._33+m._34 );
};


class CheckableFloat
{
public:
    CheckableFloat( void ) { m_bState = true; m_fValue = 0.0f; };
    CheckableFloat( bool bState, float fValue ) { m_bState = bState; m_fValue = fValue; };
    
    void SetValue( float f ) { m_fValue = f; };
    
    float Value( void ) const { return m_fValue; };
    
    void SetState( bool b ) { m_bState = b; };
    
    bool State( void ) const { return m_bState; };
    
    inline bool operator ==( const CheckableFloat &cf ) const throw() { return State() == cf.State() && Value() == cf.Value(); };
    inline bool operator !=( const CheckableFloat &cf ) const throw() { return !operator ==( cf ); };
    inline CheckableFloat &operator =( const CheckableFloat &cf ) { m_bState = cf.m_bState; m_fValue = cf.m_fValue; return *this; };

    void Serialize( Stream &s )
    {
        s == m_bState == m_fValue;
    };


protected:
    bool m_bState;
    float m_fValue;
};

class AttributeCheckableFloat;

MBDLL_DECL AttributeWidget *CreateNewCheckableFloatWidget( QWidget *pParent, int iWidth, AttributeCheckableFloat *pAttribute );

class AttributeCheckableFloat : public AttributeInstance<CheckableFloat>
{
public:
    AttributeCheckableFloat( Node *pOwner = 0, const QString &sID = "", const QString &sValueName = "" ) : AttributeInstance<CheckableFloat>( pOwner, sID )
        { m_iSize = sizeof(CheckableFloat); m_sValueName = sValueName; };
    void SetValueName( const QString &sValueName ) { m_sValueName = sValueName; };
    QString ValueName( void ) const { return m_sValueName; };

    Attribute::AttributeType Type( void ) const { return typeUnknown; };
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth ) { return CreateNewCheckableFloatWidget( pParent, iWidth, (AttributeCheckableFloat *)this ); };
    QString AsString( bool /*bLocalized*/ ) const { return QString("%1 %2").arg(m_cValue.State() ? "true" : "false").arg(m_cValue.Value()); };
    void SetFromString( const QString &s, bool /*bInternal*/ = true, bool /*bLocalized*/ = false )
    {
        m_cValue.SetState( s.section( ' ', 0, 0 ) == "true" ? true : false );
        m_cValue.SetValue( s.section( ' ', 1, 1 ).toFloat() );
    };

    virtual void SetState( bool bState, bool bInternal = false )
    {
        m_cValue.SetState( bState );
        UpdateTargets();
        if( !bInternal )
            StartEvent( etValueChanged );
    };

protected:
    QString m_sValueName;
};

typedef AttributeCheckableFloat acheckablefloat;
// data structure, references: StampConfiguration and CheckableFloat.
struct MBDLL_DECL CheckableFloatArray  
{

    CheckableFloatArray()
    {
        m_iSize = 2;
        m_aValue[0] = 0; m_aValue[1] = 1;
        m_bComplementary = false;
    }

    void SetState( bool b ) { s_bActive = b; }; 
    bool State( void ) const { return s_bActive; };

    float Value(unsigned int i) const { MB_ASSERT(i < m_iSize); return m_aValue[i]; } 
    void SetValue(unsigned int i, float v) { MB_ASSERT(i < m_iSize); m_aValue[i] = v; }

    void AddElement(unsigned int i, QString sLabel, float fMin, float fMax, float fValue)
    {
        MB_ASSERT(i < m_iSize); 
        MB_ASSERT(fValue > fMin && fValue < fMax); 
        m_aLabel[i] = sLabel;
        m_aMin[i] = fMin;
        m_aMax[i] = fMax;
        m_aValue[i] = fValue; 
    }
    
    unsigned int Size() const { return m_iSize; }

    bool IsComplementary() const { return m_bComplementary; }
    void SetComplementary(bool b) { m_bComplementary = b; }

    inline bool operator ==( const CheckableFloatArray & ) const throw() { return false; };
    inline bool operator !=( const CheckableFloatArray &v ) const throw() { return !operator ==( v ); };

    void Serialize( Stream &s )
    {
        s == s_bActive == m_iSize == m_bComplementary;
        for (unsigned int i = 0; i < m_iSize; ++i)
            s == m_aLabel[i] == m_aMin[i] == m_aMax[i] == m_aValue[i];
    };

    static bool s_bActive;
    unsigned int m_iSize;
    QString m_aLabel[2];
    float m_aMin[2];
    float m_aMax[2];         
    float m_aValue[2];  
    bool m_bComplementary;
};

class AttributeCheckableFloatArray;

MBDLL_DECL AttributeWidget *CreateNewCheckableFloatArrayWidget( QWidget *pParent, int iWidth, class AttributeCheckableFloatArray *pAttribute );

class AttributeCheckableFloatArray : public AttributeInstance<CheckableFloatArray>
{
public:
    AttributeCheckableFloatArray( Node *pOwner = 0, const QString &sID = "" ) 
        : AttributeInstance<CheckableFloatArray>( pOwner, sID )
    { m_iSize = sizeof(CheckableFloat); }; 

    virtual ~AttributeCheckableFloatArray( void ) {}

    Attribute::AttributeType Type( void ) const { return typeUnknown; };
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth ) 
    { 
        return CreateNewCheckableFloatArrayWidget( pParent, iWidth, (AttributeCheckableFloatArray *)this ); 
    };
    // the data structure of this attribute 
    //virtual QString AsString( bool bLocalized = false ) const;
    //virtual void SetFromString( const QString &sValue, bool bInternal = true, bool /*bLocalized*/ = false );

protected:                
};

//-----------------------------------------------------------------------------
static inline bool FloatEqual(float A, float B, const int max_ulps = 4)
{   
    int a = *(int*)&A; // load the float bits into integers
    int b = *(int*)&B;
    // floats have a sign bit, convert to 2's compliment
    if (a < 0) a = 0x80000000 - a; // correctly handles 0 vs -0 and
    if (b < 0) b = 0x80000000 - b; // positive and negative denormals
    return (abs(a - b) <= max_ulps);
}

//-----------------------------------------------------------------------------
static inline bool FloatGreaterOrEqual(float A, float B, const int max_ulps = 4)
{   
    int a = *(int*)&A; // load the float bits into integers
    int b = *(int*)&B;
    // floats have a sign bit, convert to 2's compliment
    if (a < 0) a = 0x80000000 - a; // correctly handles 0 vs -0 and
    if (b < 0) b = 0x80000000 - b; // positive and negative denormals
    return (a - b) >= -max_ulps;
}

//-----------------------------------------------------------------------------
static inline bool FloatLessOrEqual(float A, float B, const int max_ulps = 4)
{   
    return FloatGreaterOrEqual(B, A, max_ulps);
}


}; // end of namespace mudbox


#if defined(_MSC_VER)
#pragma warning(pop)
#endif