/* ----------------------------------------------------------------------------- This source file is part of OGRE (Object-oriented Graphics Rendering Engine) For the latest info, see http://www.ogre3d.org/ Copyright (c) 2000-2005 The OGRE Team Also see acknowledgements in Readme.html This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser 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, or go to http://www.gnu.org/copyleft/lesser.txt. ----------------------------------------------------------------------------- */ #ifndef __Vector4_H__ #define __Vector4_H__ #include "OgrePrerequisites.h" #include "OgreVector3.h" namespace Ogre { /** 4-dimensional homogenous vector. */ class _OgreExport Vector4 { public: union { struct { Real x, y, z, w; }; Real val[4]; }; public: inline Vector4() { } inline Vector4( const Real fX, const Real fY, const Real fZ, const Real fW ) : x( fX ), y( fY ), z( fZ ), w( fW) { } inline explicit Vector4( const Real afCoordinate[4] ) : x( afCoordinate[0] ), y( afCoordinate[1] ), z( afCoordinate[2] ), w( afCoordinate[3] ) { } inline explicit Vector4( const int afCoordinate[4] ) { x = (Real)afCoordinate[0]; y = (Real)afCoordinate[1]; z = (Real)afCoordinate[2]; w = (Real)afCoordinate[3]; } inline explicit Vector4( Real* const r ) : x( r[0] ), y( r[1] ), z( r[2] ), w( r[3] ) { } inline explicit Vector4( const Real scaler ) : x( scaler ) , y( scaler ) , z( scaler ) , w( scaler ) { } inline Vector4( const Vector4& rkVector ) : x( rkVector.x ), y( rkVector.y ), z( rkVector.z ), w (rkVector.w) { } inline Real operator [] ( const size_t i ) const { assert( i < 4 ); return *(&x+i); } inline Real& operator [] ( const size_t i ) { assert( i < 4 ); return *(&x+i); } /** Assigns the value of the other vector. @param rkVector The other vector */ inline Vector4& operator = ( const Vector4& rkVector ) { x = rkVector.x; y = rkVector.y; z = rkVector.z; w = rkVector.w; return *this; } inline Vector4& operator = ( const Real fScalar) { x = fScalar; y = fScalar; z = fScalar; w = fScalar; return *this; } inline bool operator == ( const Vector4& rkVector ) const { return ( x == rkVector.x && y == rkVector.y && z == rkVector.z && w == rkVector.w ); } inline bool operator != ( const Vector4& rkVector ) const { return ( x != rkVector.x || y != rkVector.y || z != rkVector.z || w != rkVector.w ); } inline Vector4& operator = (const Vector3& rhs) { x = rhs.x; y = rhs.y; z = rhs.z; w = 1.0f; return *this; } // arithmetic operations inline Vector4 operator + ( const Vector4& rkVector ) const { Vector4 kSum; kSum.x = x + rkVector.x; kSum.y = y + rkVector.y; kSum.z = z + rkVector.z; kSum.w = w + rkVector.w; return kSum; } inline Vector4 operator - ( const Vector4& rkVector ) const { Vector4 kDiff; kDiff.x = x - rkVector.x; kDiff.y = y - rkVector.y; kDiff.z = z - rkVector.z; kDiff.w = w - rkVector.w; return kDiff; } inline Vector4 operator * ( const Real fScalar ) const { Vector4 kProd; kProd.x = fScalar*x; kProd.y = fScalar*y; kProd.z = fScalar*z; kProd.w = fScalar*w; return kProd; } inline Vector4 operator * ( const Vector4& rhs) const { Vector4 kProd; kProd.x = rhs.x * x; kProd.y = rhs.y * y; kProd.z = rhs.z * z; kProd.w = rhs.w * w; return kProd; } inline Vector4 operator / ( const Real fScalar ) const { assert( fScalar != 0.0 ); Vector4 kDiv; Real fInv = 1.0 / fScalar; kDiv.x = x * fInv; kDiv.y = y * fInv; kDiv.z = z * fInv; kDiv.w = w * fInv; return kDiv; } inline Vector4 operator / ( const Vector4& rhs) const { Vector4 kDiv; kDiv.x = x / rhs.x; kDiv.y = y / rhs.y; kDiv.z = z / rhs.z; kDiv.w = w / rhs.w; return kDiv; } inline Vector4 operator - () const { Vector4 kNeg; kNeg.x = -x; kNeg.y = -y; kNeg.z = -z; kNeg.w = -w; return kNeg; } inline friend Vector4 operator * ( const Real fScalar, const Vector4& rkVector ) { Vector4 kProd; kProd.x = fScalar * rkVector.x; kProd.y = fScalar * rkVector.y; kProd.z = fScalar * rkVector.z; kProd.w = fScalar * rkVector.w; return kProd; } inline friend Vector4 operator + (const Vector4& lhs, const Real rhs) { Vector4 ret; ret = rhs; return ret += lhs; } inline friend Vector4 operator + (const Real lhs, const Vector4& rhs) { Vector4 ret; ret = lhs; return ret += rhs; } inline friend Vector4 operator - (const Vector4& lhs, Real rhs) { Vector4 ret; ret = lhs; return ret -= rhs; } inline friend Vector4 operator - (const Real lhs, const Vector4& rhs) { Vector4 ret; ret = lhs; return ret -= rhs; } // arithmetic updates inline Vector4& operator += ( const Vector4& rkVector ) { x += rkVector.x; y += rkVector.y; z += rkVector.z; w += rkVector.w; return *this; } inline Vector4& operator -= ( const Vector4& rkVector ) { x -= rkVector.x; y -= rkVector.y; z -= rkVector.z; w -= rkVector.w; return *this; } inline Vector4& operator *= ( const Real fScalar ) { x *= fScalar; y *= fScalar; z *= fScalar; w *= fScalar; return *this; } inline Vector4& operator += ( const Real fScalar ) { x += fScalar; y += fScalar; z += fScalar; w += fScalar; return *this; } inline Vector4& operator -= ( const Real fScalar ) { x -= fScalar; y -= fScalar; z -= fScalar; w -= fScalar; return *this; } inline Vector4& operator *= ( const Vector4& rkVector ) { x *= rkVector.x; y *= rkVector.y; z *= rkVector.z; w *= rkVector.w; return *this; } inline Vector4& operator /= ( const Real fScalar ) { assert( fScalar != 0.0 ); Real fInv = 1.0 / fScalar; x *= fInv; y *= fInv; z *= fInv; w *= fInv; return *this; } inline Vector4& operator /= ( const Vector4& rkVector ) { x /= rkVector.x; y /= rkVector.y; z /= rkVector.z; w /= rkVector.w; return *this; } /** Calculates the dot (scalar) product of this vector with another. @param vec Vector with which to calculate the dot product (together with this one). @returns A float representing the dot product value. */ inline Real dotProduct(const Vector4& vec) const { return x * vec.x + y * vec.y + z * vec.z + w * vec.w; } /** Function for writing to a stream. */ inline _OgreExport friend std::ostream& operator << ( std::ostream& o, const Vector4& v ) { o << "Vector4(" << v.x << ", " << v.y << ", " << v.z << ", " << v.w << ")"; return o; } // special static const Vector4 ZERO; }; } #endif