Public API Reference

             

---

vector3.h

/*
 *  AE Engine
 *
 *  Copyright (C) 2003 Riku "Rakkis" Nurminen
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef __AELIB_AEGEOM_VECTOR3_H__
#define __AELIB_AEGEOM_VECTOR3_H__

#define ONLY_INCLUDE_STD
#include <aedefs.h>
#undef ONLY_INCLUDE_STD

class aeVector3 {
 public:
        inline aeVector3() {}

        inline aeVector3(float nx, float ny, float nz) :
                x(nx), y(ny), z(nz) {}

        inline aeVector3(const aeVector3 &v) :
                x(v.x), y(v.y), z(v.z) {}

        inline ~aeVector3() {}

        float x;
        float y;
        float z;

        inline friend aeVector3 operator+(const aeVector3 &v1, const aeVector3 &v2) {
                return aeVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
        }

        inline friend aeVector3 operator-(const aeVector3 &v1, const aeVector3 &v2) {
                return aeVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
        }

        inline friend float operator*(const aeVector3 &v1, const aeVector3 &v2) {
                return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
        }

        inline friend aeVector3 operator%(const aeVector3 &v1, const aeVector3 &v2) {
                return aeVector3((v1.y * v2.z) - (v1.z * v2.y),
                                                 (v1.z * v2.x) - (v1.x * v2.z),
                                                 (v1.x * v2.y) - (v1.y * v2.x));
        }

        inline friend aeVector3 operator*(const aeVector3 &v1, float s) {
                return aeVector3(v1.x * s, v1.y * s, v1.z * s);
        }

        inline friend aeVector3 operator*(float s, const aeVector3 &v1) {
                return aeVector3(v1.x * s, v1.y * s, v1.z * s);
        }

        inline friend aeVector3 operator*(int s, const aeVector3 &v1) {
                return v1 * (float)s;
        }

        inline friend aeVector3 operator/(const aeVector3 &v1, float s) {
                s = 1.0f / s;
                return aeVector3(v1.x * s, v1.y * s, v1.z * s);
        }

        inline friend aeVector3 operator/(const aeVector3 &v1, int s) {
                return (v1 / (float)s);
        }

        inline friend bool operator==(const aeVector3 &v1, const aeVector3 &v2) {
                return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;
        }

        inline friend bool operator!=(const aeVector3 &v1, const aeVector3 &v2) {
                return v1.x != v2.x || v1.y != v2.y || v1.z != v2.z;
        }

        inline float operator[](int n) const { return !n ? x : n & 1 ? y : z; }

        inline float & operator[](int n) { return !n ? x : n & 1 ? y : z; }

        inline aeVector3 & operator+=(const aeVector3 &v1) {
                x += v1.x;
                y += v1.y;
                z += v1.z;
                return *this;
        }

        inline aeVector3 & operator-=(const aeVector3 &v1) {
                x -= v1.x;
                y -= v1.y;
                z -= v1.z;
                return *this;
        }

        inline aeVector3 & operator*=(float s) {
                x *= s;
                y *= s;
                z *= s;
                return *this;
        }

        inline aeVector3 & operator/=(float s) {
                s = 1.0f / s;
                x *= s;
                y *= s;
                z *= s;
                return *this;
        }

        inline aeVector3 operator+() const { return *this; }

        inline aeVector3 operator-() const { return aeVector3(-x, -y, -z); }

        inline void set(float nx, float ny, float nz) {
                x = nx;
                y = ny;
                z = nz;
        }

        inline void set(const aeVector3 &v) {
                x = v.x;
                y = v.y;
                z = v.z;
        }

        void cross(const aeVector3 &v1, const aeVector3 &v2);

        float magnitude() const;

        inline aeVector3 unit() const { return this->normalize(); }

        aeVector3 normalize() const;
};

#endif // __AELIB_AEGEOM_VECTOR3_H__

---

AE Engine Public API Reference
Generated on Wed Apr 9 09:43:40 2003 by Doxygen.