diff --git a/dtool/src/dtoolbase/cmath.I b/dtool/src/dtoolbase/cmath.I index 501a0ac072..60cfb196bb 100644 --- a/dtool/src/dtoolbase/cmath.I +++ b/dtool/src/dtoolbase/cmath.I @@ -47,49 +47,35 @@ INLINE float ctan(float v) { } INLINE void -sincosf(float v, float *pSinResult, float *pCosResult) { - -// MS VC defines _M_IX86 for x86. gcc should define _X86_ +csincos(float v, float *pSinResult, float *pCosResult) { + // MS VC defines _M_IX86 for x86. gcc should define _X86_ #if defined(_M_IX86) || defined(_X86_) -//#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb - __asm { - mov eax, pSinResult - mov edx, pCosResult - fld v - fsincos - fstp DWORD ptr [edx] - fstp DWORD ptr [eax] - } + //#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb + __asm { + mov eax, pSinResult + mov edx, pCosResult + fld v + fsincos + fstp DWORD ptr [edx] + fstp DWORD ptr [eax] + } #else //!_X86_ - *pSinResult = sinf(v); - *pCosResult = cosf(v); + *pSinResult = sinf(v); + *pCosResult = cosf(v); #endif //!_X86_ } -INLINE void -sincosd(double v, double *pSinResult, double *pCosResult) { -#if defined(_M_IX86) || defined(_X86_) -//#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb - __asm { - mov eax, pSinResult - mov edx, pCosResult - fld v - fsincos - fstp QWORD ptr [edx] - fstp QWORD ptr [eax] - } -#else //!_X86_ - *pSinResult = sin(v); - *pCosResult = cos(v); -#endif //!_X86_ -} - -INLINE void csincos(float v,float *pSinResult, float *pCosResult) { - sincosf(v,pSinResult,pCosResult); -} - -INLINE void csincos(double v,double *pSinResult, double *pCosResult) { - sincosd(v,pSinResult,pCosResult); +//////////////////////////////////////////////////////////////////// +// Function: csin_over_x +// Description: Computes sin(x) / x, well-behaved as x approaches 0. +//////////////////////////////////////////////////////////////////// +INLINE float +csin_over_x(float v) { + if (1.0f + v * v == 1.0f) { + return 1.0f; + } else { + return csin(v) / v; + } } INLINE float cabs(float v) { @@ -104,6 +90,14 @@ INLINE float catan2(float y, float x) { return atan2f(y, x); } +INLINE float casin(float v) { + return asinf(v); +} + +INLINE float cacos(float v) { + return acosf(v); +} + #ifdef __INTEL_COMPILER // see float.h #define FPU_CONTROLWORD_WRITEMASK 0xFFFFF // if you look at defn of _CW_DEFAULT, all settings fall within 0xFFFFF @@ -152,6 +146,37 @@ INLINE double ctan(double v) { return tan(v); } +INLINE void +csincos(double v, double *pSinResult, double *pCosResult) { +#if defined(_M_IX86) || defined(_X86_) + //#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb + __asm { + mov eax, pSinResult + mov edx, pCosResult + fld v + fsincos + fstp QWORD ptr [edx] + fstp QWORD ptr [eax] + } +#else //!_X86_ + *pSinResult = sin(v); + *pCosResult = cos(v); +#endif //!_X86_ +} + +//////////////////////////////////////////////////////////////////// +// Function: csin_over_x +// Description: Computes sin(x) / x, well-behaved as x approaches 0. +//////////////////////////////////////////////////////////////////// +INLINE double +csin_over_x(double v) { + if (1.0 + v * v == 1.0) { + return 1.0; + } else { + return csin(v) / v; + } +} + INLINE double cabs(double v) { return fabs(v); } @@ -164,6 +189,14 @@ INLINE double catan2(double y, double x) { return atan2(y, x); } +INLINE double casin(double v) { + return asin(v); +} + +INLINE double cacos(double v) { + return acos(v); +} + INLINE bool cnan(double v) { #ifndef _WIN32 return (isnan(v) != 0); diff --git a/dtool/src/dtoolbase/cmath.h b/dtool/src/dtoolbase/cmath.h index 1e2a4eddb1..c482b9eeeb 100644 --- a/dtool/src/dtoolbase/cmath.h +++ b/dtool/src/dtoolbase/cmath.h @@ -34,9 +34,11 @@ INLINE float csin(float v); INLINE float ccos(float v); INLINE float ctan(float v); INLINE void csincos(float v, float *pSinResult, float *pCosResult); // does both at once (faster on x86) +INLINE float csin_over_x(float v); INLINE float cabs(float v); INLINE float catan(float v); INLINE float catan2(float y, float x); +INLINE float casin(float v); //INLINE float cfloor(float f); //INLINE float cceil(float f); @@ -46,10 +48,11 @@ INLINE double csqrt(double v); INLINE double csin(double v); INLINE double ccos(double v); INLINE double ctan(double v); +INLINE void csincos(double v, double *pSinResult, double *pCosResult); // does both at once (faster on x86) INLINE double cabs(double v); INLINE double catan(double v); INLINE double catan2(double y, double x); -INLINE void csincos(double v, double *pSinResult, double *pCosResult); // does both at once (faster on x86) +INLINE double casin(double y, double x); // Returns true if the number is nan, false if it's a genuine number // or infinity. diff --git a/panda/src/linmath/Sources.pp b/panda/src/linmath/Sources.pp index cf01b3c467..5a85ac9e8f 100644 --- a/panda/src/linmath/Sources.pp +++ b/panda/src/linmath/Sources.pp @@ -33,7 +33,7 @@ lvecBase4_src.h lvector2.h lvector2_src.I lvector2_src.cxx \ lvector2_src.h lvector3.h lvector3_src.I lvector3_src.cxx \ lvector3_src.h lvector4.h lvector4_src.I lvector4_src.cxx \ - lvector4_src.h mathNumbers.h pta_Colorf.h \ + lvector4_src.h mathNumbers.h mathNumbers.I pta_Colorf.h \ pta_Normalf.h pta_TexCoordf.h pta_Vertexf.h vector_Colorf.h \ vector_LPoint2f.h vector_LVecBase3f.h vector_Normalf.h \ vector_TexCoordf.h vector_Vertexf.h @@ -68,7 +68,7 @@ lvecBase3_src.I lvecBase3_src.h lvecBase4.h lvecBase4_src.I \ lvecBase4_src.h lvector2.h lvector2_src.I lvector2_src.h \ lvector3.h lvector3_src.I lvector3_src.h lvector4.h lvector4_src.I \ - lvector4_src.h mathNumbers.h pta_Colorf.h \ + lvector4_src.h mathNumbers.h mathNumbers.I pta_Colorf.h \ pta_Normalf.h pta_TexCoordf.h pta_Vertexf.h vector_Colorf.h \ vector_LPoint2f.h vector_LVecBase3f.h vector_Normalf.h \ vector_TexCoordf.h vector_Vertexf.h diff --git a/panda/src/linmath/lquaternion_src.I b/panda/src/linmath/lquaternion_src.I index cd6ea4a21e..8ca6bb90e7 100644 --- a/panda/src/linmath/lquaternion_src.I +++ b/panda/src/linmath/lquaternion_src.I @@ -106,6 +106,28 @@ operator - (const FLOATNAME(LQuaternion) &other) const { return FLOATNAME(LVecBase4)::operator - (other); } +//////////////////////////////////////////////////////////////////// +// Function: LVector::angle_rad +// Access: Published +// Description: Returns the angle between this quat and the other +// one, expressed in radians. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LQuaternion):: +angle_rad(const FLOATNAME(LQuaternion) &other) const { + return get_axis().angle_rad(other.get_axis()); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVector::angle_deg +// Access: Published +// Description: Returns the angle between this vector and the other +// one, expressed in degrees. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LQuaternion):: +angle_deg(const FLOATNAME(LQuaternion) &other) const { + return rad_2_deg(angle_rad(other)); +} + //////////////////////////////////////////////////////////////////// // Function: LQuaternion::quaternion * scalar // Access: Public @@ -256,11 +278,12 @@ set_from_matrix(const FLOATNAME(LMatrix4) &m) { // Access: Public // Description: This, along with get_angle(), returns the rotation // represented by the quaternion as an angle about an -// arbitrary axis. This returns the axis. +// arbitrary axis. This returns the axis; it is not +// normalized. //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LQuaternion):: get_axis() const { - return ::normalize(FLOATNAME(LVector3)(_v.data[1], _v.data[2], _v.data[3])); + return FLOATNAME(LVector3)(_v.data[1], _v.data[2], _v.data[3]); } //////////////////////////////////////////////////////////////////// diff --git a/panda/src/linmath/lquaternion_src.h b/panda/src/linmath/lquaternion_src.h index 34e678bf33..08365a99a5 100644 --- a/panda/src/linmath/lquaternion_src.h +++ b/panda/src/linmath/lquaternion_src.h @@ -41,6 +41,9 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LQuaternion) operator - (const FLOATNAME(LQuaternion) &other) const; + INLINE_LINMATH FLOATTYPE angle_rad(const FLOATNAME(LQuaternion) &other) const; + INLINE_LINMATH FLOATTYPE angle_deg(const FLOATNAME(LQuaternion) &other) const; + INLINE_LINMATH FLOATNAME(LQuaternion) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LQuaternion) operator / (FLOATTYPE scalar) const; diff --git a/panda/src/linmath/lvecBase3.h b/panda/src/linmath/lvecBase3.h index 751ddf5783..076fd25ab8 100644 --- a/panda/src/linmath/lvecBase3.h +++ b/panda/src/linmath/lvecBase3.h @@ -25,6 +25,8 @@ #include "datagram.h" #include "datagramIterator.h" #include "checksumHashGenerator.h" +#include "mathNumbers.h" +#include "deg_2_rad.h" #include "cmath.h" #include "nearly_zero.h" diff --git a/panda/src/linmath/lvecBase3_src.I b/panda/src/linmath/lvecBase3_src.I index 7fbc694d3b..de366c29a3 100644 --- a/panda/src/linmath/lvecBase3_src.I +++ b/panda/src/linmath/lvecBase3_src.I @@ -359,7 +359,7 @@ end() const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::fill -// Access: Public +// Access: Published // Description: Sets each element of the vector to the indicated // fill_value. This is particularly useful for // initializing to zero. @@ -373,7 +373,7 @@ fill(FLOATTYPE fill_value) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::set -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: @@ -385,7 +385,7 @@ set(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::dot -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase3):: @@ -395,7 +395,7 @@ dot(const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::cross -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: @@ -407,7 +407,7 @@ cross(const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator < -// Access: Public +// Access: Published // Description: This performs a lexicographical comparison. It's of // questionable mathematical meaning, but sometimes has // a practical purpose for sorting unique vectors, @@ -421,7 +421,7 @@ operator < (const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator == -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH bool FLOATNAME(LVecBase3):: @@ -433,7 +433,7 @@ operator == (const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator != -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH bool FLOATNAME(LVecBase3):: @@ -463,8 +463,8 @@ get_standardized_rotation(FLOATTYPE angle_in_degrees) { } //////////////////////////////////////////////////////////////////// -// Function: LVecBase3::compare_hpr_to -// Access: Public +// Function: LVecBase3::get_standardized_hpr +// Access: Published // Description: Try to un-spin the hpr to a standard form. Like // all standards, someone decides between many // arbitrary posible standards. This function assumes @@ -491,7 +491,7 @@ get_standardized_hpr() const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::compare_to -// Access: Public +// Access: Published // Description: This flavor of compare_to uses a default threshold // value based on the numeric type. //////////////////////////////////////////////////////////////////// @@ -502,7 +502,7 @@ compare_to(const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::compare_to -// Access: Public +// Access: Published // Description: Sorts vectors lexicographically, componentwise. // Returns a number less than 0 if this vector sorts // before the other one, greater than zero if it sorts @@ -525,7 +525,7 @@ compare_to(const FLOATNAME(LVecBase3) &other, FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::get_hash -// Access: Public +// Access: Published // Description: Returns a suitable hash for phash_map. //////////////////////////////////////////////////////////////////// INLINE_LINMATH size_t FLOATNAME(LVecBase3):: @@ -535,7 +535,7 @@ get_hash() const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::get_hash -// Access: Public +// Access: Published // Description: Returns a suitable hash for phash_map. //////////////////////////////////////////////////////////////////// INLINE_LINMATH size_t FLOATNAME(LVecBase3):: @@ -545,7 +545,7 @@ get_hash(FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::add_hash -// Access: Public +// Access: Published // Description: Adds the vector into the running hash. //////////////////////////////////////////////////////////////////// INLINE_LINMATH size_t FLOATNAME(LVecBase3):: @@ -555,7 +555,7 @@ add_hash(size_t hash) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::add_hash -// Access: Public +// Access: Published // Description: Adds the vector into the running hash. //////////////////////////////////////////////////////////////////// INLINE_LINMATH size_t FLOATNAME(LVecBase3):: @@ -569,7 +569,7 @@ add_hash(size_t hash, FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::unary - -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: @@ -579,7 +579,7 @@ operator - () const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::vector + vector -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: @@ -591,7 +591,7 @@ operator + (const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::vector - vector -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: @@ -603,7 +603,7 @@ operator - (const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::vector * scalar -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: @@ -615,7 +615,7 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::vector / scalar -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: @@ -628,7 +628,7 @@ operator / (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator += -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: @@ -640,7 +640,7 @@ operator += (const FLOATNAME(LVecBase3) &other) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator -= -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: @@ -652,7 +652,7 @@ operator -= (const FLOATNAME(LVecBase3) &other) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator *= -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: @@ -664,7 +664,7 @@ operator *= (FLOATTYPE scalar) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator /= -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: @@ -677,7 +677,7 @@ operator /= (FLOATTYPE scalar) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::cross product (with assigment) -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: @@ -687,7 +687,7 @@ cross_into(const FLOATNAME(LVecBase3) &other) { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::almost_equal -// Access: Public +// Access: Published // Description: Returns true if two vectors are memberwise equal // within a specified tolerance. //////////////////////////////////////////////////////////////////// @@ -700,7 +700,7 @@ almost_equal(const FLOATNAME(LVecBase3) &other, FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::almost_equal -// Access: Public +// Access: Published // Description: Returns true if two vectors are memberwise equal // within a default tolerance based on the numeric type. //////////////////////////////////////////////////////////////////// @@ -711,7 +711,7 @@ almost_equal(const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVecBase3::output -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: diff --git a/panda/src/linmath/lvector3_src.I b/panda/src/linmath/lvector3_src.I index 916bc87bf5..7c3d512f22 100644 --- a/panda/src/linmath/lvector3_src.I +++ b/panda/src/linmath/lvector3_src.I @@ -19,7 +19,7 @@ //////////////////////////////////////////////////////////////////// // Function: LVector3::Default Constructor -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3):: @@ -28,7 +28,7 @@ FLOATNAME(LVector3)() { //////////////////////////////////////////////////////////////////// // Function: LVector3::Copy Constructor -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3):: @@ -37,7 +37,7 @@ FLOATNAME(LVector3)(const FLOATNAME(LVecBase3) ©) : FLOATNAME(LVecBase3)(cop //////////////////////////////////////////////////////////////////// // Function: LVector3::Copy Assignment Operator -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) &FLOATNAME(LVector3):: @@ -48,7 +48,7 @@ operator = (const FLOATNAME(LVecBase3) ©) { //////////////////////////////////////////////////////////////////// // Function: LVector3::Copy Fill Operator -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) &FLOATNAME(LVector3):: @@ -59,7 +59,7 @@ operator = (FLOATTYPE fill_value) { //////////////////////////////////////////////////////////////////// // Function: LVector3::Constructor -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3):: @@ -70,7 +70,7 @@ FLOATNAME(LVector3)(FLOATTYPE fill_value) : //////////////////////////////////////////////////////////////////// // Function: LVector3::Constructor -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3):: @@ -81,7 +81,7 @@ FLOATNAME(LVector3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) : //////////////////////////////////////////////////////////////////// // Function: LVector3::zero Named Constructor -// Access: Public +// Access: Published // Description: Returns a zero-length vector. //////////////////////////////////////////////////////////////////// INLINE_LINMATH const FLOATNAME(LVector3) &FLOATNAME(LVector3):: @@ -91,7 +91,7 @@ zero() { //////////////////////////////////////////////////////////////////// // Function: LVector3::unit_x Named Constructor -// Access: Public +// Access: Published // Description: Returns a unit X vector. //////////////////////////////////////////////////////////////////// INLINE_LINMATH const FLOATNAME(LVector3) &FLOATNAME(LVector3):: @@ -101,7 +101,7 @@ unit_x() { //////////////////////////////////////////////////////////////////// // Function: LVector3::unit_y Named Constructor -// Access: Public +// Access: Published // Description: Returns a unit Y vector. //////////////////////////////////////////////////////////////////// INLINE_LINMATH const FLOATNAME(LVector3) &FLOATNAME(LVector3):: @@ -111,7 +111,7 @@ unit_y() { //////////////////////////////////////////////////////////////////// // Function: LVector3::unit_z Named Constructor -// Access: Public +// Access: Published // Description: Returns a unit Z vector. //////////////////////////////////////////////////////////////////// INLINE_LINMATH const FLOATNAME(LVector3) &FLOATNAME(LVector3):: @@ -121,7 +121,7 @@ unit_z() { //////////////////////////////////////////////////////////////////// // Function: LVector3::unary - -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: @@ -131,7 +131,7 @@ operator - () const { //////////////////////////////////////////////////////////////////// // Function: LVector3::vector + vecbase -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVector3):: @@ -141,7 +141,7 @@ operator + (const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVector3::vector + vector -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: @@ -151,7 +151,7 @@ operator + (const FLOATNAME(LVector3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVector3::vector - vecbase -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVector3):: @@ -161,7 +161,7 @@ operator - (const FLOATNAME(LVecBase3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVector3::vector - vector -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: @@ -171,7 +171,7 @@ operator - (const FLOATNAME(LVector3) &other) const { //////////////////////////////////////////////////////////////////// // Function: LVector3::length -// Access: Public +// Access: Published // Description: Returns the length of the vector, by the Pythagorean // theorem. //////////////////////////////////////////////////////////////////// @@ -182,7 +182,7 @@ length() const { //////////////////////////////////////////////////////////////////// // Function: LVector3::length_squared -// Access: Public +// Access: Published // Description: Returns the square of the vector's length, cheap and // easy. //////////////////////////////////////////////////////////////////// @@ -193,7 +193,7 @@ length_squared() const { //////////////////////////////////////////////////////////////////// // Function: LVector3::normalize -// Access: Public +// Access: Published // Description: Normalizes the vector in place. Returns true if the // vector was normalized, false if it was a zero-length // vector. @@ -214,7 +214,7 @@ normalize() { //////////////////////////////////////////////////////////////////// // Function: LVector3::cross -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: @@ -222,9 +222,37 @@ cross(const FLOATNAME(LVecBase3) &other) const { return FLOATNAME(LVecBase3)::cross(other); } +//////////////////////////////////////////////////////////////////// +// Function: LVector::angle_rad +// Access: Published +// Description: Returns the angle between this vector and the other +// one, expressed in radians. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LVector3):: +angle_rad(const FLOATNAME(LVector3) &other) const { + // This algorithm yields better results than acos(dot(other)), which + // behaves poorly as dot(other) approaches 1.0. + if (dot(other) < 0.0f) { + return MathNumbers::cpi((FLOATTYPE)0.0f) - 2.0f * casin((-(*this)-other).length()); + } else { + return 2.0f * casin(((*this)-other).length() / 2.0f); + } +} + +//////////////////////////////////////////////////////////////////// +// Function: LVector::angle_deg +// Access: Published +// Description: Returns the angle between this vector and the other +// one, expressed in degrees. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LVector3):: +angle_deg(const FLOATNAME(LVector3) &other) const { + return rad_2_deg(angle_rad(other)); +} + //////////////////////////////////////////////////////////////////// // Function: LVector3::operator * scalar -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: @@ -234,7 +262,7 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// // Function: LVector3::operator / scalar -// Access: Public +// Access: Published // Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: @@ -245,7 +273,7 @@ operator / (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// // Function: LVector3::up -// Access: Public, Static +// Access: Published, Static // Description: Returns the up vector for the given coordinate // system. //////////////////////////////////////////////////////////////////// @@ -272,7 +300,7 @@ up(CoordinateSystem cs) { //////////////////////////////////////////////////////////////////// // Function: LVector3::right -// Access: Public, Static +// Access: Published, Static // Description: Returns the right vector for the given coordinate // system. //////////////////////////////////////////////////////////////////// @@ -283,7 +311,7 @@ right(CoordinateSystem) { //////////////////////////////////////////////////////////////////// // Function: LVector3::forward -// Access: Public, Static +// Access: Published, Static // Description: Returns the forward vector for the given coordinate // system. //////////////////////////////////////////////////////////////////// @@ -314,7 +342,7 @@ forward(CoordinateSystem cs) { //////////////////////////////////////////////////////////////////// // Function: LVector3::down -// Access: Public, Static +// Access: Published, Static // Description: Returns the down vector for the given coordinate // system. //////////////////////////////////////////////////////////////////// @@ -325,7 +353,7 @@ down(CoordinateSystem cs) { //////////////////////////////////////////////////////////////////// // Function: LVector3::left -// Access: Public, Static +// Access: Published, Static // Description: Returns the left vector for the given coordinate // system. //////////////////////////////////////////////////////////////////// @@ -336,7 +364,7 @@ left(CoordinateSystem cs) { //////////////////////////////////////////////////////////////////// // Function: LVector3::back -// Access: Public, Static +// Access: Published, Static // Description: Returns the back vector for the given coordinate // system. //////////////////////////////////////////////////////////////////// @@ -347,7 +375,7 @@ back(CoordinateSystem cs) { //////////////////////////////////////////////////////////////////// // Function: LVector3::rfu -// Access: Public, Static +// Access: Published, Static // Description: Returns a vector that is described by its right, // forward, and up components, in whatever way the // coordinate system represents that vector. diff --git a/panda/src/linmath/lvector3_src.h b/panda/src/linmath/lvector3_src.h index 6c63a2516c..05bde9188b 100644 --- a/panda/src/linmath/lvector3_src.h +++ b/panda/src/linmath/lvector3_src.h @@ -52,6 +52,9 @@ PUBLISHED: INLINE_LINMATH FLOATTYPE length_squared() const; INLINE_LINMATH bool normalize(); INLINE_LINMATH FLOATNAME(LVector3) cross(const FLOATNAME(LVecBase3) &other) const; + INLINE_LINMATH FLOATTYPE angle_rad(const FLOATNAME(LVector3) &other) const; + INLINE_LINMATH FLOATTYPE angle_deg(const FLOATNAME(LVector3) &other) const; + INLINE_LINMATH FLOATNAME(LVector3) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LVector3) operator / (FLOATTYPE scalar) const; diff --git a/panda/src/linmath/mathNumbers.I b/panda/src/linmath/mathNumbers.I new file mode 100755 index 0000000000..c6ca8f9cd1 --- /dev/null +++ b/panda/src/linmath/mathNumbers.I @@ -0,0 +1,62 @@ +// Filename: mathNumbers.I +// Created by: drose (22Jan05) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://etc.cmu.edu/panda3d/docs/license/ . +// +// To contact the maintainers of this program write to +// panda3d-general@lists.sourceforge.net . +// +//////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////// +// Function: MathNumbers::cpi +// Access: Public, Static +// Description: Returns pi as a single-precision or double-precision +// number, according to the type of the parameter. +//////////////////////////////////////////////////////////////////// +INLINE float MathNumbers:: +cpi(float) { + return pi_f; +} + +//////////////////////////////////////////////////////////////////// +// Function: MathNumbers::cln2 +// Access: Public, Static +// Description: Returns ln(2) as a single-precision or double-precision +// number, according to the type of the parameter. +//////////////////////////////////////////////////////////////////// +INLINE float MathNumbers:: +cln2(float) { + return ln2_f; +} + +//////////////////////////////////////////////////////////////////// +// Function: MathNumbers::cpi +// Access: Public, Static +// Description: Returns pi as a single-precision or double-precision +// number, according to the type of the parameter. +//////////////////////////////////////////////////////////////////// +INLINE double MathNumbers:: +cpi(double) { + return pi; +} + +//////////////////////////////////////////////////////////////////// +// Function: MathNumbers::cln2 +// Access: Public, Static +// Description: Returns ln(2) as a single-precision or double-precision +// number, according to the type of the parameter. +//////////////////////////////////////////////////////////////////// +INLINE double MathNumbers:: +cln2(double) { + return ln2; +} diff --git a/panda/src/linmath/mathNumbers.h b/panda/src/linmath/mathNumbers.h index 71ce4a7f28..160e7d556e 100644 --- a/panda/src/linmath/mathNumbers.h +++ b/panda/src/linmath/mathNumbers.h @@ -31,6 +31,15 @@ PUBLISHED: static const double ln2; static const double rad_2_deg; static const double deg_2_rad; + +public: + INLINE static float cpi(float); + INLINE static float cln2(float); + + INLINE static double cpi(double); + INLINE static double cln2(double); }; +#include "mathNumbers.I" + #endif