---

Vector3C.h

//-------------------------------------------------------------------------
//
// File:        Vector3C.h
// Desc:        3D 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_VECTOR3_H__
#define __DEMOPAJA_VECTOR3_H__


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

namespace PajaTypes {


    class Vector3C {

    public:
        Vector3C( float32 f32X = 0, float32 f32Y = 0, float32 f32Z = 0 );

        Vector3C( const Vector3C& rVec );

        Vector3C( float32 f32A[3] );

        virtual ~Vector3C();


        float32&            operator[]( int32 i );


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

        Vector3C            operator-() const;

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

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

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

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

        Vector3C&           operator*=( float32 f32S );

        Vector3C&           operator/=( float32 f32S );

        Vector3C            operator*( float32 f32S );

        Vector3C            operator/( float32 f32S );

        Vector3C            operator-( const Vector3C& rVec ) const;

        Vector3C            operator+( const Vector3C& rVec ) const;


        Vector3C            operator*( const Vector3C& rVec ) const;                // component vice mult

        friend Vector3C     operator*( float32 f32S, const Vector3C& rVec );

        Vector3C            normalize() const;

        float32             length() const;

        float32             dot( const Vector3C& v ) const;

        Vector3C            cross( const Vector3C& v ) const;

    private:
        float32 m_vec[3];
    };



    //
    //
    // Inlines
    //
    //

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


};  // namespace PajaTypes


#endif

---