Tuple4.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_Tuple4_hpp
#define base_vecmath_Tuple4_hpp

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

namespace se_core {

    class _SeCoreExport Tuple4 {
    public:
        typedef coor_t value_type;
        typedef short size_type;
        enum { DIMENSION = 4 };

        coor_t x_;

        coor_t y_;

        coor_t z_;

        coor_t w_;

        Tuple4(coor_t xvalue, coor_t yvalue, coor_t zvalue, coor_t wvalue):
            x_(xvalue), y_(yvalue), z_(zvalue), w_(wvalue) { }

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

        Tuple4() { }

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

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

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

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

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

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

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


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

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

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

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


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

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

        void scaleAdd(scale_t s, const Tuple4& t1, const Tuple4& 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_;
            w_ = CoorT::scale(s, t1.w_) + t2.w_;
        }

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


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

        bool isNan() const;

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

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

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

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

        void absolute(const Tuple4& 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;
            if (z_ < min)
                z_ = min;
            if (w_ < min)
                w_ = min;
        }

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

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

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

        void interpolate(const Tuple4& 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_);
            z_ = CoorT::fromScale(beta*z_ + alpha*t1.z_);
            w_ = CoorT::fromScale(beta*w_ + alpha*t1.w_);
        }

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


        // copy constructor and operator = is made by complier

        bool operator==(const Tuple4& t1) const {
            return equals(t1);
        }

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

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

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

} // Namespace

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


#endif /* TUPLE4_H */

---

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