---

Vector2C.h

//-------------------------------------------------------------------------
//
// File:        Vector2C.h
// Desc:        2D vector class.
// Author:      memon <memon@inside.org>
//
//-------------------------------------------------------------------------
//  Copyright (c) 2000-2002 Moppi Productions. All Rights Reserved.
//  This file is part of Moppi Demopaja SDK. For conditions of 
//  distribution and use, see the accompanying license.txt file.
//  http://moppi.inside.org/demopaja/
//-------------------------------------------------------------------------

#ifndef __DEMOPAJA_VECTOR2_H__
#define __DEMOPAJA_VECTOR2_H__


#include "PajaTypes.h"
#include <math.h>
#include <assert.h>

namespace PajaTypes {


    class Vector2C {

    public:
        Vector2C( float32 f32X = 0, float32 f32Y = 0 );
        
        Vector2C( const Vector2C& rVec );
        
        Vector2C( const float32 f32A[2] );

        virtual ~Vector2C();


        float32&            operator[]( int32 i );


        const float32&      operator[]( int32 i ) const;

        Vector2C            operator-() const;

        bool                operator==( const Vector2C& rVec ) const;

        bool                operator!=( const Vector2C& rVec ) const;

        Vector2C&           operator-=( const Vector2C& rVec );

        Vector2C&           operator+=( const Vector2C& rVec );

        Vector2C&           operator*=( float32 f32S );

        Vector2C&           operator/=( float32 f32S );

        Vector2C            operator*( float32 f32S ) const;

        Vector2C            operator/( float32 f32S ) const;

        Vector2C            operator-( const Vector2C& rVec ) const;

        Vector2C            operator+( const Vector2C& rVec ) const;


        Vector2C            operator*( const Vector2C& rVec ) const;

        friend Vector2C     operator*( float32 s, const Vector2C& rVec );

        Vector2C            normalize() const;

        float32             length() const;

        float32             dot( const Vector2C& rVec ) const;


    private:
        float32 m_vec[2];
    };

    //
    //
    // Inlines
    //
    //

    inline
    float32&
    Vector2C::operator[]( int32 i )
    {
        assert( i >= 0 && i < 2 );
        return m_vec[i];
    }

    inline
    const float32&
    Vector2C::operator[]( int32 i ) const
    {
        assert( i >= 0 && i < 2 );
        return m_vec[i];
    }

    inline
    Vector2C
    Vector2C::operator-() const
    {
        return Vector2C( -m_vec[0], -m_vec[1] );
    }

    inline
    Vector2C&
    Vector2C::operator-=( const Vector2C& a )
    {
        m_vec[0] -= a.m_vec[0];
        m_vec[1] -= a.m_vec[1];
  
        return *this;
    }

    inline
    Vector2C&
    Vector2C::operator+=( const Vector2C& a )
    {
        m_vec[0] += a.m_vec[0];
        m_vec[1] += a.m_vec[1];
  
        return *this;
    }

    inline
    Vector2C&
    Vector2C::operator*=( float32 s )
    {
        m_vec[0] *= s;
        m_vec[1] *= s;
  
        return *this;
    }

    inline
    Vector2C&
    Vector2C::operator/=( float32 s )
    {
        s = 1.0f / s;
        m_vec[0] *= s;
        m_vec[1] *= s;
  
        return *this;
    }

    inline
    Vector2C
    Vector2C::operator*( float32 s ) const
    {
        return Vector2C( m_vec[0] * s, m_vec[1] * s );
    }


    inline
    Vector2C
    Vector2C::operator/( float32 s ) const
    {
        s = 1.0f / s;
        return Vector2C( m_vec[0] * s, m_vec[1] * s );
    }

    inline
    Vector2C
    Vector2C::operator-( const Vector2C& a ) const
    {
        return Vector2C( m_vec[0] - a.m_vec[0], m_vec[1] - a.m_vec[1] );
    }

    inline
    Vector2C
    Vector2C::operator+( const Vector2C& a ) const
    {
        return Vector2C( m_vec[0] + a.m_vec[0], m_vec[1] + a.m_vec[1] );
    }

    inline
    Vector2C
    Vector2C::operator*( const Vector2C& a ) const
    {
        return Vector2C( m_vec[0] * a.m_vec[0], m_vec[1] * a.m_vec[1] );
    }

    inline
    float32
    Vector2C::length() const
    {
        return (float32)sqrt( (m_vec[0] * m_vec[0]) + (m_vec[1] * m_vec[1]) );
    }

    inline
    float32
    Vector2C::dot( const Vector2C& v ) const
    {
        return (m_vec[0] * v.m_vec[0]) + (m_vec[1] * v.m_vec[1]);
    }

    inline
    Vector2C
    operator*( float32 s, const Vector2C& v )
    {
        return Vector2C( v.m_vec[0] * s, v.m_vec[1] * s );
    }


};  // namespace PajaTypes


#endif

---