PxVec4.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  


#ifndef PX_FOUNDATION_PX_VEC4_H
#define PX_FOUNDATION_PX_VEC4_H

#include "foundation/PxMath.h"
#include "foundation/PxVec3.h"
#include "foundation/PxAssert.h"


#ifndef PX_DOXYGEN
namespace physx
{
#endif

class PxVec4
{
public:

    PX_CUDA_CALLABLE PX_INLINE PxVec4() {}

    PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec4(PxZERO r): x(0.0f), y(0.0f), z(0.0f), w(0.0f) 
    {
        PX_UNUSED(r);
    }

    explicit PX_CUDA_CALLABLE PX_INLINE PxVec4(PxReal a): x(a), y(a), z(a), w(a) {}

    PX_CUDA_CALLABLE PX_INLINE PxVec4(PxReal nx, PxReal ny, PxReal nz, PxReal nw): x(nx), y(ny), z(nz), w(nw) {}


    PX_CUDA_CALLABLE PX_INLINE PxVec4(const PxVec3& v, PxReal nw): x(v.x), y(v.y), z(v.z), w(nw) {}


    explicit PX_CUDA_CALLABLE PX_INLINE PxVec4(const PxReal v[]): x(v[0]), y(v[1]), z(v[2]), w(v[3]) {}

    PX_CUDA_CALLABLE PX_INLINE PxVec4(const PxVec4& v): x(v.x), y(v.y), z(v.z), w(v.w) {}

    //Operators

    PX_CUDA_CALLABLE PX_INLINE  PxVec4& operator=(const PxVec4& p)          { x = p.x; y = p.y; z = p.z; w = p.w;   return *this;       }

    PX_DEPRECATED PX_CUDA_CALLABLE PX_INLINE PxReal& operator[](int index)
    {
        PX_ASSERT(index>=0 && index<=3);

        return reinterpret_cast<PxReal*>(this)[index];
    }
    
    PX_CUDA_CALLABLE PX_INLINE PxReal& operator[](unsigned int index)
    {
        PX_ASSERT(index<=3);

        return reinterpret_cast<PxReal*>(this)[index];
    }

    PX_DEPRECATED PX_CUDA_CALLABLE PX_INLINE const PxReal& operator[](int index) const
    {
        PX_ASSERT(index>=0 && index<=3);

        return reinterpret_cast<const PxReal*>(this)[index];
    }

    PX_CUDA_CALLABLE PX_INLINE const PxReal& operator[](unsigned int index) const
    {
        PX_ASSERT(index<=3);

        return reinterpret_cast<const PxReal*>(this)[index];
    }

    PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxVec4&v) const    { return x == v.x && y == v.y && z == v.z && w == v.w; }

    PX_CUDA_CALLABLE PX_INLINE bool operator!=(const PxVec4&v) const    { return x != v.x || y != v.y || z != v.z || w!= v.w; }

    PX_CUDA_CALLABLE PX_INLINE bool isZero()    const                   { return x==0 && y==0 && z == 0 && w == 0;          }

    PX_CUDA_CALLABLE PX_INLINE bool isFinite() const
    {
        return PxIsFinite(x) && PxIsFinite(y) && PxIsFinite(z) && PxIsFinite(w);
    }

    PX_CUDA_CALLABLE PX_INLINE bool isNormalized() const
    {
        const float unitTolerance = 1e-4f;
        return isFinite() && PxAbs(magnitude()-1)<unitTolerance;
    }


    PX_CUDA_CALLABLE PX_INLINE PxReal magnitudeSquared() const      {   return x * x + y * y + z * z + w * w;       }

    PX_CUDA_CALLABLE PX_INLINE PxReal magnitude() const             {   return PxSqrt(magnitudeSquared());      }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 operator -() const
    {
        return PxVec4(-x, -y, -z, -w);
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 operator +(const PxVec4& v) const     {   return PxVec4(x + v.x, y + v.y, z + v.z, w + v.w);  }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 operator -(const PxVec4& v) const     {   return PxVec4(x - v.x, y - v.y, z - v.z, w - v.w);  }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 operator *(PxReal f) const                {   return PxVec4(x * f, y * f, z * f, w * f);      }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 operator /(PxReal f) const
    {
        f = 1.0f / f; 
        return PxVec4(x * f, y * f, z * f, w * f);
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4& operator +=(const PxVec4& v)
    {
        x += v.x;
        y += v.y;
        z += v.z;
        w += v.w;
        return *this;
    }
    
    PX_CUDA_CALLABLE PX_INLINE PxVec4& operator -=(const PxVec4& v)
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        w -= v.w;
        return *this;
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4& operator *=(PxReal f)
    {
        x *= f;
        y *= f;
        z *= f;
        w *= f;
        return *this;
    }
    PX_CUDA_CALLABLE PX_INLINE PxVec4& operator /=(PxReal f)
    {
        f = 1.0f/f;
        x *= f;
        y *= f;
        z *= f;
        w *= f;
        return *this;
    }

    PX_CUDA_CALLABLE PX_INLINE PxReal dot(const PxVec4& v) const        
    {   
        return x * v.x + y * v.y + z * v.z + w * v.w;               
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 getNormalized() const
    {
        PxReal m = magnitudeSquared();
        return m>0.0f ? *this * PxRecipSqrt(m) : PxVec4(0,0,0,0);
    }


    PX_CUDA_CALLABLE PX_INLINE PxReal normalize()
    {
        PxReal m = magnitude();
        if (m>0.0f) 
            *this /= m;
        return m;
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 multiply(const PxVec4& a) const
    {
        return PxVec4(x*a.x, y*a.y, z*a.z, w*a.w);
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 minimum(const PxVec4& v) const
    { 
        return PxVec4(PxMin(x, v.x), PxMin(y,v.y), PxMin(z,v.z), PxMin(w,v.w)); 
    }

    PX_CUDA_CALLABLE PX_INLINE PxVec4 maximum(const PxVec4& v) const
    { 
        return PxVec4(PxMax(x, v.x), PxMax(y,v.y), PxMax(z,v.z), PxMax(w,v.w)); 
    } 

    PX_CUDA_CALLABLE PX_INLINE PxVec3 getXYZ() const
    {
        return PxVec3(x,y,z);
    }

    PX_CUDA_CALLABLE PX_INLINE void setZero() { x = y = z = w = 0.0f; }

    PxReal x,y,z,w;
};


PX_CUDA_CALLABLE static PX_INLINE PxVec4 operator *(PxReal f, const PxVec4& v)
{
    return PxVec4(f * v.x, f * v.y, f * v.z, f * v.w);
}

#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif // PX_FOUNDATION_PX_VEC4_H