Tuple2.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. Kenji Hiranabe's license apply.
*/
#ifndef base_vecmath_Tuple2_hpp
#define base_vecmath_Tuple2_hpp

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

namespace se_core {

    class _SeCoreExport Tuple2 {
    public:
        enum { DIMENSION = 2 };

        coor_t x_;

        coor_t y_;

        Tuple2(coor_t xvalue, coor_t yvalue): x_(xvalue), y_(yvalue) { }

        Tuple2(const coor_t t[]): x_(t[0]), y_(t[1]) { }


        Tuple2(): x_(0), y_(0) { }

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

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

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

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

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

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

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

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

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

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

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

        void scale(scale_t s, const Tuple2& t1) {
            x_ = CoorT::scale(s, t1.x_);
            y_ = CoorT::scale(s, t1.y_);
        }

        void scale(scale_t s) {
            x_ = CoorT::scale(s, x_);
            y_ = CoorT::scale(s, y_);
        }

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

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

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

        bool isNan() const;

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

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

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

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


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

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

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

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

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

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


        void interpolate(const Tuple2& t1, scale_t alpha) {
            scale_t beta = SCALE_RES - alpha;
            x_ = CoorT::fromScale(beta*x_ + alpha*t1.x_);
            y_ = CoorT::fromScale(beta*y_ + alpha*t1.y_);
        }

        char* toString(char* buffer) const;

        // copy constructor and operator = is made by complier

        bool operator==(const Tuple2& 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_;
            default:
                // error !
                return 0;
            }
        }
        coor_t& operator[](short index) {
            static coor_t dummy;
            Assert(index < (short)DIMENSION);
            switch (index) {
            case 0:
                return x_;
            case 1:
                return y_;
            default:
                // error !
                return dummy;
            }
        }

        Tuple2& operator=(const Tuple2& t1) {
            set(t1);
            return *this;
        }

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

    };

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

} // Namespace

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

#endif /* TUPLE2_H */

---

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