Tuple3.hpp

Go to the documentation of this file.

/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hiranabe@esm.co.jp),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.

   Copyright (C) 2004
   Rune Myrland, Skalden Studio AS
   SagaEngine adaptions, involving conversion from floating point values to fixed point values.
   Kenji Hiranabe's license apply.
*/
#ifndef base_vecmath_Tuple3_hpp
#define base_vecmath_Tuple3_hpp

#include "util_vecmath.hpp"
#include "../math/CoorT.hpp"
#include "../error/Log.hpp"

namespace se_core {
    class _SeCoreExport Tuple3 {
    public:
        enum { DIMENSION = 3 };

        coor_t x_;

        coor_t y_;

        coor_t z_;

        Tuple3(coor_t xvalue, coor_t yvalue, coor_t zvalue): x_(xvalue), y_(yvalue), z_(zvalue) { }

        Tuple3(const coor_t t[]): x_(t[0]), y_(t[1]), z_(t[2]) { }

        Tuple3() { }

        void set(coor_t xvalue, coor_t yvalue, coor_t zvalue) {
            x_ = xvalue;
            y_ = yvalue;
            z_ = zvalue;
        }

        void set(const coor_t t[]) {
            x_ = t[0];
            y_ = t[1];
            z_ = t[2];
        }

        void set(const Tuple3& t1) {
            x_ = t1.x_;
            y_ = t1.y_;
            z_ = t1.z_;
        }


        void reset() {
            x_ = y_ = z_ = 0;
        }

        bool isZero() const {
            return (x_ == 0 && y_ == 0 && z_ == 0);
        }

        void get(coor_t t[]) const {
            t[0] = x_;
            t[1] = y_;
            t[2] = z_;
        }

        void get(Tuple3* t) const {
            Assert(t);
            t->x_ = x_;
            t->y_ = y_;
            t->z_ = z_;
        }

        void add(const Tuple3& t1, const Tuple3& t2) {
            x_ = t1.x_ + t2.x_;
            y_ = t1.y_ + t2.y_;
            z_ = t1.z_ + t2.z_;
        }

        void add(const Tuple3& t1) {
            x_ += t1.x_;
            y_ += t1.y_;
            z_ += t1.z_;
        }


        inline void add(const coor_t dx, const coor_t dy, const coor_t dz) {
            x_ += dx;
            y_ += dy;
            z_ += dz;
        }


        void sub(const Tuple3& t1, const Tuple3& t2) {
            x_ = t1.x_ - t2.x_;
            y_ = t1.y_ - t2.y_;
            z_ = t1.z_ - t2.z_;
        }

        void sub(const Tuple3& t1) {
            x_ -= t1.x_;
            y_ -= t1.y_;
            z_ -= t1.z_;
        }

        void negate(const Tuple3& t1) {
            x_ = -t1.x_;
            y_ = -t1.y_;
            z_ = -t1.z_;
        }

        void negate() {
            x_ = -x_;
            y_ = -y_;
            z_ = -z_;
        }

        void scale(scale_t s, const Tuple3& t1);

        void scale(scale_t s);

        void scaleAdd(scale_t s, const Tuple3& t1) {
            x_ = CoorT::scale(s, x_) + t1.x_;
            y_ = CoorT::scale(s, y_) + t1.y_;
            z_ = CoorT::scale(s, z_) + t1.z_;
        }

        void scaleAdd(scale_t s, const Tuple3& t1, const Tuple3& t2) {
            x_ = CoorT::scale(s, t1.x_) + t2.x_;
            y_ = CoorT::scale(s, t1.y_) + t2.y_;
            z_ = CoorT::scale(s, t1.z_) + t2.z_;
        }

        bool equals(const Tuple3& t1) const {
            return t1.x_ == x_ && t1.y_ == y_ && t1.z_ == z_;
        }

        bool isNan() const;

        bool epsilonEquals(const Tuple3& t1, coor_t epsilon) const;

        void absolute(const Tuple3& t) {
            set(t);
            absolute();
        }

        void absolute() {
            if (x_ < 0)
                x_ = -x_;
            if (y_ < 0)
                y_ = -y_;
            if (z_ < 0)
                z_ = -z_;
        }

        void clamp(coor_t min, coor_t max) {
            clampMin(min);
            clampMax(max);
        }

        void clamp(coor_t min, coor_t max, const Tuple3& t) {
            set(t);
            clamp(min, max);
        }

        void clampMin(coor_t min) {
            if (x_ < min)
                x_ = min;
            if (y_ < min)
                y_ = min;
            if (z_ < min)
                z_ = min;
        }

        void clampMin(coor_t min, const Tuple3& t) {
            set(t);
            clampMin(min);
        }

        void clampMax(coor_t max, const Tuple3& t) {
            set(t);
            clampMax(max);
        }

        void clampMax(coor_t max) {
            if (x_ > max)
                x_ = max;
            if (y_ > max)
                y_ = max;
            if (z_ > max)
                z_ = max;
        }

        void interpolate(const Tuple3& t1, const Tuple3& t2, scale_t alpha) {
            set(t1);
            interpolate(t2, alpha);
        }

        void interpolate(const Tuple3& t1, scale_t alpha) {
            x_ += CoorT::scale(alpha, t1.x_ - x_);
            y_ += CoorT::scale(alpha, t1.y_ - y_);
            z_ += CoorT::scale(alpha, t1.z_ - z_);
        }

        char* toString(char* buffer) const;
        const char* toLog() const;


        // copy constructor and operator = is made by complier
        bool operator==(const Tuple3& t1) const {
            return equals(t1);
        }

        coor_t operator[](short index) const {
            Assert(index < (short)DIMENSION);
            switch (index) {
            case 0:
                return x_;
            case 1:
                return y_;
            case 2:
                return z_;
            default:
                // error !
                return 0;
            }
        }
        coor_t& operator[](short index) {
            static coor_t dummy = 0;
            Assert(index < (short)DIMENSION);
            switch (index) {
            case 0:
                return x_;
            case 1:
                return y_;
            case 2:
                return z_;
            default:
                // error !
                return dummy;
            }
        }

        Tuple3& operator=(const Tuple3& t1) {
            set(t1);
            return *this;
        }
        Tuple3& operator+=(const Tuple3& t1) {
            add(t1);
            return *this;
        }
        Tuple3& operator-=(const Tuple3& t1) {
            sub(t1);
            return *this;
        }
        Tuple3& operator*=(scale_t s) {
            scale(s);
            return *this;
        }
        Tuple3 operator+(const Tuple3& t1) const {
            return (Tuple3(*this)).operator+=(t1);
        }
        Tuple3 operator-(const Tuple3& t1) const {
            return (Tuple3(*this)).operator-=(t1);
        }
        Tuple3 operator*(coor_t s) const {
            return (Tuple3(*this)).operator*=(s);
        }

    };

    se_err::Log& operator<< (se_err::Log& log, const Tuple3& b);

} // Namespace


inline
se_core::Tuple3 operator*(scale_t s, const se_core::Tuple3& t1) {
    return (se_core::Tuple3(t1)).operator*=(s);
}

#endif /* TUPLE3_H */

---

Home Page | SagaEngine trunk (updated nightly) reference generated Sun Dec 2 20:06:13 2007 by Doxygen version 1.3.9.1.