SHARE
TWEET

Untitled

chrondog Jan 1st, 2013 414 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
  2. //
  3. // Purpose:
  4. //
  5. // $NoKeywords: $
  6. //
  7. //=============================================================================//
  8.  
  9. #ifndef VECTOR2D_H
  10. #define VECTOR2D_H
  11.  
  12. #ifdef _WIN32
  13. #pragma once
  14. #endif
  15.  
  16. #include <math.h>
  17. #include <float.h>
  18.  
  19. // For vec_t, put this somewhere else?
  20. #include "tier0/basetypes.h"
  21.  
  22. // For rand(). We really need a library!
  23. #include <stdlib.h>
  24.  
  25. #include "tier0/dbg.h"
  26. #include "mathlib/math_pfns.h"
  27.  
  28. //=========================================================
  29. // 2D Vector2D
  30. //=========================================================
  31.  
  32. class Vector2D                                 
  33. {
  34. public:
  35.         // Members
  36.         vec_t x, y;
  37.  
  38.         // Construction/destruction
  39.         Vector2D(void);
  40.         Vector2D(vec_t X, vec_t Y);
  41.         Vector2D(const float *pFloat);
  42.  
  43.         // Initialization
  44.         void Init(vec_t ix=0.0f, vec_t iy=0.0f);
  45.  
  46.         // Got any nasty NAN's?
  47.         bool IsValid() const;
  48.  
  49.         // array access...
  50.         vec_t operator[](int i) const;
  51.         vec_t& operator[](int i);
  52.  
  53.         // Base address...
  54.         vec_t* Base();
  55.         vec_t const* Base() const;
  56.  
  57.         // Initialization methods
  58.         void Random( float minVal, float maxVal );
  59.  
  60.         // equality
  61.         bool operator==(const Vector2D& v) const;
  62.         bool operator!=(const Vector2D& v) const;      
  63.  
  64.         // arithmetic operations
  65.         Vector2D&       operator+=(const Vector2D &v);                 
  66.         Vector2D&       operator-=(const Vector2D &v);         
  67.         Vector2D&       operator*=(const Vector2D &v);                 
  68.         Vector2D&       operator*=(float s);
  69.         Vector2D&       operator/=(const Vector2D &v);         
  70.         Vector2D&       operator/=(float s);                                   
  71.  
  72.         // negate the Vector2D components
  73.         void    Negate();
  74.  
  75.         // Get the Vector2D's magnitude.
  76.         vec_t   Length() const;
  77.  
  78.         // Get the Vector2D's magnitude squared.
  79.         vec_t   LengthSqr(void) const;
  80.  
  81.         // return true if this vector is (0,0) within tolerance
  82.         bool IsZero( float tolerance = 0.01f ) const
  83.         {
  84.                 return (x > -tolerance && x < tolerance &&
  85.                                 y > -tolerance && y < tolerance);
  86.         }
  87.  
  88.         // Normalize in place and return the old length.
  89.         vec_t   NormalizeInPlace();
  90.  
  91.         // Compare length.
  92.         bool    IsLengthGreaterThan( float val ) const;
  93.         bool    IsLengthLessThan( float val ) const;
  94.  
  95.         // Get the distance from this Vector2D to the other one.
  96.         vec_t   DistTo(const Vector2D &vOther) const;
  97.  
  98.         // Get the distance from this Vector2D to the other one squared.
  99.         vec_t   DistToSqr(const Vector2D &vOther) const;               
  100.  
  101.         // Copy
  102.         void    CopyToArray(float* rgfl) const;
  103.  
  104.         // Multiply, add, and assign to this (ie: *this = a + b * scalar). This
  105.         // is about 12% faster than the actual Vector2D equation (because it's done per-component
  106.         // rather than per-Vector2D).
  107.         void    MulAdd(const Vector2D& a, const Vector2D& b, float scalar);    
  108.  
  109.         // Dot product.
  110.         vec_t   Dot(const Vector2D& vOther) const;                     
  111.  
  112.         // assignment
  113.         Vector2D& operator=(const Vector2D &vOther);
  114.  
  115. #ifndef VECTOR_NO_SLOW_OPERATIONS
  116.         // copy constructors
  117.         Vector2D(const Vector2D &vOther);
  118.  
  119.         // arithmetic operations
  120.         Vector2D        operator-(void) const;
  121.                                
  122.         Vector2D        operator+(const Vector2D& v) const;    
  123.         Vector2D        operator-(const Vector2D& v) const;    
  124.         Vector2D        operator*(const Vector2D& v) const;    
  125.         Vector2D        operator/(const Vector2D& v) const;    
  126.         Vector2D        operator*(float fl) const;
  127.         Vector2D        operator/(float fl) const;                     
  128.        
  129.         // Cross product between two vectors.
  130.         Vector2D        Cross(const Vector2D &vOther) const;           
  131.  
  132.         // Returns a Vector2D with the min or max in X, Y, and Z.
  133.         Vector2D        Min(const Vector2D &vOther) const;
  134.         Vector2D        Max(const Vector2D &vOther) const;
  135.  
  136. #else
  137.  
  138. private:
  139.         // No copy constructors allowed if we're in optimal mode
  140.         Vector2D(const Vector2D& vOther);
  141. #endif
  142. };
  143.  
  144. //-----------------------------------------------------------------------------
  145.  
  146. const Vector2D vec2_origin(0,0);
  147. const Vector2D vec2_invalid( FLT_MAX, FLT_MAX );
  148.  
  149. //-----------------------------------------------------------------------------
  150. // Vector2D related operations
  151. //-----------------------------------------------------------------------------
  152.  
  153. // Vector2D clear
  154. void Vector2DClear( Vector2D& a );
  155.  
  156. // Copy
  157. void Vector2DCopy( const Vector2D& src, Vector2D& dst );
  158.  
  159. // Vector2D arithmetic
  160. void Vector2DAdd( const Vector2D& a, const Vector2D& b, Vector2D& result );
  161. void Vector2DSubtract( const Vector2D& a, const Vector2D& b, Vector2D& result );
  162. void Vector2DMultiply( const Vector2D& a, vec_t b, Vector2D& result );
  163. void Vector2DMultiply( const Vector2D& a, const Vector2D& b, Vector2D& result );
  164. void Vector2DDivide( const Vector2D& a, vec_t b, Vector2D& result );
  165. void Vector2DDivide( const Vector2D& a, const Vector2D& b, Vector2D& result );
  166. void Vector2DMA( const Vector2D& start, float s, const Vector2D& dir, Vector2D& result );
  167.  
  168. // Store the min or max of each of x, y, and z into the result.
  169. void Vector2DMin( const Vector2D &a, const Vector2D &b, Vector2D &result );
  170. void Vector2DMax( const Vector2D &a, const Vector2D &b, Vector2D &result );
  171.  
  172. #define Vector2DExpand( v ) (v).x, (v).y
  173.  
  174. // Normalization
  175. vec_t Vector2DNormalize( Vector2D& v );
  176.  
  177. // Length
  178. vec_t Vector2DLength( const Vector2D& v );
  179.  
  180. // Dot Product
  181. vec_t DotProduct2D(const Vector2D& a, const Vector2D& b);
  182.  
  183. // Linearly interpolate between two vectors
  184. void Vector2DLerp(const Vector2D& src1, const Vector2D& src2, vec_t t, Vector2D& dest );
  185.  
  186.  
  187. //-----------------------------------------------------------------------------
  188. //
  189. // Inlined Vector2D methods
  190. //
  191. //-----------------------------------------------------------------------------
  192.  
  193.  
  194. //-----------------------------------------------------------------------------
  195. // constructors
  196. //-----------------------------------------------------------------------------
  197.  
  198. inline Vector2D::Vector2D(void)                                                                
  199. {
  200. #ifdef _DEBUG
  201.         // Initialize to NAN to catch errors
  202.         x = y = VEC_T_NAN;
  203. #endif
  204. }
  205.  
  206. inline Vector2D::Vector2D(vec_t X, vec_t Y)                                            
  207. {
  208.         x = X; y = Y;
  209.         Assert( IsValid() );
  210. }
  211.  
  212. inline Vector2D::Vector2D(const float *pFloat)                                 
  213. {
  214.         Assert( pFloat );
  215.         x = pFloat[0]; y = pFloat[1];  
  216.         Assert( IsValid() );
  217. }
  218.  
  219.  
  220. //-----------------------------------------------------------------------------
  221. // copy constructor
  222. //-----------------------------------------------------------------------------
  223.  
  224. inline Vector2D::Vector2D(const Vector2D &vOther)                                      
  225. {
  226.         Assert( vOther.IsValid() );
  227.         x = vOther.x; y = vOther.y;
  228. }
  229.  
  230. //-----------------------------------------------------------------------------
  231. // initialization
  232. //-----------------------------------------------------------------------------
  233.  
  234. inline void Vector2D::Init( vec_t ix, vec_t iy )    
  235. {
  236.         x = ix; y = iy;
  237.         Assert( IsValid() );
  238. }
  239.  
  240. inline void Vector2D::Random( float minVal, float maxVal )
  241. {
  242.         x = minVal + ((float)rand() / RAND_MAX) * (maxVal - minVal);
  243.         y = minVal + ((float)rand() / RAND_MAX) * (maxVal - minVal);
  244. }
  245.  
  246. inline void Vector2DClear( Vector2D& a )
  247. {
  248.         a.x = a.y = 0.0f;
  249. }
  250.  
  251. //-----------------------------------------------------------------------------
  252. // assignment
  253. //-----------------------------------------------------------------------------
  254.  
  255. inline Vector2D& Vector2D::operator=(const Vector2D &vOther)   
  256. {
  257.         Assert( vOther.IsValid() );
  258.         x=vOther.x; y=vOther.y;
  259.         return *this;
  260. }
  261.  
  262. //-----------------------------------------------------------------------------
  263. // Array access
  264. //-----------------------------------------------------------------------------
  265.  
  266. inline vec_t& Vector2D::operator[](int i)
  267. {
  268.         Assert( (i >= 0) && (i < 2) );
  269.         return ((vec_t*)this)[i];
  270. }
  271.  
  272. inline vec_t Vector2D::operator[](int i) const
  273. {
  274.         Assert( (i >= 0) && (i < 2) );
  275.         return ((vec_t*)this)[i];
  276. }
  277.  
  278. //-----------------------------------------------------------------------------
  279. // Base address...
  280. //-----------------------------------------------------------------------------
  281.  
  282. inline vec_t* Vector2D::Base()
  283. {
  284.         return (vec_t*)this;
  285. }
  286.  
  287. inline vec_t const* Vector2D::Base() const
  288. {
  289.         return (vec_t const*)this;
  290. }
  291.  
  292. //-----------------------------------------------------------------------------
  293. // IsValid?
  294. //-----------------------------------------------------------------------------
  295.  
  296. inline bool Vector2D::IsValid() const
  297. {
  298.         return IsFinite(x) && IsFinite(y);
  299. }
  300.  
  301. //-----------------------------------------------------------------------------
  302. // comparison
  303. //-----------------------------------------------------------------------------
  304.  
  305. inline bool Vector2D::operator==( const Vector2D& src ) const
  306. {
  307.         Assert( src.IsValid() && IsValid() );
  308.         return (src.x == x) && (src.y == y);
  309. }
  310.  
  311. inline bool Vector2D::operator!=( const Vector2D& src ) const
  312. {
  313.         Assert( src.IsValid() && IsValid() );
  314.         return (src.x != x) || (src.y != y);
  315. }
  316.  
  317.  
  318. //-----------------------------------------------------------------------------
  319. // Copy
  320. //-----------------------------------------------------------------------------
  321.  
  322. inline void Vector2DCopy( const Vector2D& src, Vector2D& dst )
  323. {
  324.         Assert( src.IsValid() );
  325.         dst.x = src.x;
  326.         dst.y = src.y;
  327. }
  328.  
  329. inline void     Vector2D::CopyToArray(float* rgfl) const               
  330. {
  331.         Assert( IsValid() );
  332.         Assert( rgfl );
  333.         rgfl[0] = x; rgfl[1] = y;
  334. }
  335.  
  336. //-----------------------------------------------------------------------------
  337. // standard math operations
  338. //-----------------------------------------------------------------------------
  339.  
  340. inline void Vector2D::Negate()
  341. {
  342.         Assert( IsValid() );
  343.         x = -x; y = -y;
  344. }
  345.  
  346. inline Vector2D& Vector2D::operator+=(const Vector2D& v)       
  347. {
  348.         Assert( IsValid() && v.IsValid() );
  349.         x+=v.x; y+=v.y;
  350.         return *this;
  351. }
  352.  
  353. inline Vector2D& Vector2D::operator-=(const Vector2D& v)       
  354. {
  355.         Assert( IsValid() && v.IsValid() );
  356.         x-=v.x; y-=v.y;
  357.         return *this;
  358. }
  359.  
  360. inline Vector2D& Vector2D::operator*=(float fl)
  361. {
  362.         x *= fl;
  363.         y *= fl;
  364.         Assert( IsValid() );
  365.         return *this;
  366. }
  367.  
  368. inline Vector2D& Vector2D::operator*=(const Vector2D& v)       
  369. {
  370.         x *= v.x;
  371.         y *= v.y;
  372.         Assert( IsValid() );
  373.         return *this;
  374. }
  375.  
  376. inline Vector2D& Vector2D::operator/=(float fl)
  377. {
  378.         Assert( fl != 0.0f );
  379.         float oofl = 1.0f / fl;
  380.         x *= oofl;
  381.         y *= oofl;
  382.         Assert( IsValid() );
  383.         return *this;
  384. }
  385.  
  386. inline Vector2D& Vector2D::operator/=(const Vector2D& v)       
  387. {
  388.         Assert( v.x != 0.0f && v.y != 0.0f );
  389.         x /= v.x;
  390.         y /= v.y;
  391.         Assert( IsValid() );
  392.         return *this;
  393. }
  394.  
  395. inline void Vector2DAdd( const Vector2D& a, const Vector2D& b, Vector2D& c )
  396. {
  397.         Assert( a.IsValid() && b.IsValid() );
  398.         c.x = a.x + b.x;
  399.         c.y = a.y + b.y;
  400. }
  401.  
  402. inline void Vector2DSubtract( const Vector2D& a, const Vector2D& b, Vector2D& c )
  403. {
  404.         Assert( a.IsValid() && b.IsValid() );
  405.         c.x = a.x - b.x;
  406.         c.y = a.y - b.y;
  407. }
  408.  
  409. inline void Vector2DMultiply( const Vector2D& a, vec_t b, Vector2D& c )
  410. {
  411.         Assert( a.IsValid() && IsFinite(b) );
  412.         c.x = a.x * b;
  413.         c.y = a.y * b;
  414. }
  415.  
  416. inline void Vector2DMultiply( const Vector2D& a, const Vector2D& b, Vector2D& c )
  417. {                                
  418.         Assert( a.IsValid() && b.IsValid() );
  419.         c.x = a.x * b.x;
  420.         c.y = a.y * b.y;
  421. }
  422.  
  423.  
  424. inline void Vector2DDivide( const Vector2D& a, vec_t b, Vector2D& c )
  425. {
  426.         Assert( a.IsValid() );
  427.         Assert( b != 0.0f );
  428.         vec_t oob = 1.0f / b;
  429.         c.x = a.x * oob;
  430.         c.y = a.y * oob;
  431. }
  432.  
  433. inline void Vector2DDivide( const Vector2D& a, const Vector2D& b, Vector2D& c )
  434. {
  435.         Assert( a.IsValid() );
  436.         Assert( (b.x != 0.0f) && (b.y != 0.0f) );
  437.         c.x = a.x / b.x;
  438.         c.y = a.y / b.y;
  439. }
  440.  
  441. inline void Vector2DMA( const Vector2D& start, float s, const Vector2D& dir, Vector2D& result )
  442. {
  443.         Assert( start.IsValid() && IsFinite(s) && dir.IsValid() );
  444.         result.x = start.x + s*dir.x;
  445.         result.y = start.y + s*dir.y;
  446. }
  447.  
  448. // FIXME: Remove
  449. // For backwards compatability
  450. inline void     Vector2D::MulAdd(const Vector2D& a, const Vector2D& b, float scalar)
  451. {
  452.         x = a.x + b.x * scalar;
  453.         y = a.y + b.y * scalar;
  454. }
  455.  
  456. inline void Vector2DLerp(const Vector2D& src1, const Vector2D& src2, vec_t t, Vector2D& dest )
  457. {
  458.         dest[0] = src1[0] + (src2[0] - src1[0]) * t;
  459.         dest[1] = src1[1] + (src2[1] - src1[1]) * t;
  460. }
  461.  
  462. //-----------------------------------------------------------------------------
  463. // dot, cross
  464. //-----------------------------------------------------------------------------
  465. inline vec_t DotProduct2D(const Vector2D& a, const Vector2D& b)
  466. {
  467.         Assert( a.IsValid() && b.IsValid() );
  468.         return( a.x*b.x + a.y*b.y );
  469. }
  470.  
  471. // for backwards compatability
  472. inline vec_t Vector2D::Dot( const Vector2D& vOther ) const
  473. {
  474.         return DotProduct2D( *this, vOther );
  475. }
  476.  
  477.  
  478. //-----------------------------------------------------------------------------
  479. // length
  480. //-----------------------------------------------------------------------------
  481. inline vec_t Vector2DLength( const Vector2D& v )
  482. {
  483.         Assert( v.IsValid() );
  484.         return (vec_t)FastSqrt(v.x*v.x + v.y*v.y);             
  485. }
  486.  
  487. inline vec_t Vector2D::LengthSqr(void) const   
  488. {
  489.         Assert( IsValid() );
  490.         return (x*x + y*y);            
  491. }
  492.  
  493. inline vec_t Vector2D::NormalizeInPlace()
  494. {
  495.         return Vector2DNormalize( *this );
  496. }
  497.  
  498. inline bool Vector2D::IsLengthGreaterThan( float val ) const
  499. {
  500.         return LengthSqr() > val*val;
  501. }
  502.  
  503. inline bool Vector2D::IsLengthLessThan( float val ) const
  504. {
  505.         return LengthSqr() < val*val;
  506. }
  507.  
  508. inline vec_t Vector2D::Length(void) const      
  509. {
  510.         return Vector2DLength( *this );
  511. }
  512.  
  513.  
  514. inline void Vector2DMin( const Vector2D &a, const Vector2D &b, Vector2D &result )
  515. {
  516.         result.x = (a.x < b.x) ? a.x : b.x;
  517.         result.y = (a.y < b.y) ? a.y : b.y;
  518. }
  519.  
  520.  
  521. inline void Vector2DMax( const Vector2D &a, const Vector2D &b, Vector2D &result )
  522. {
  523.         result.x = (a.x > b.x) ? a.x : b.x;
  524.         result.y = (a.y > b.y) ? a.y : b.y;
  525. }
  526.  
  527.  
  528. //-----------------------------------------------------------------------------
  529. // Normalization
  530. //-----------------------------------------------------------------------------
  531. inline vec_t Vector2DNormalize( Vector2D& v )
  532. {
  533.         Assert( v.IsValid() );
  534.         vec_t l = v.Length();
  535.         if (l != 0.0f)
  536.         {
  537.                 v /= l;
  538.         }
  539.         else
  540.         {
  541.                 v.x = v.y = 0.0f;
  542.         }
  543.         return l;
  544. }
  545.  
  546.  
  547. //-----------------------------------------------------------------------------
  548. // Get the distance from this Vector2D to the other one
  549. //-----------------------------------------------------------------------------
  550. inline vec_t Vector2D::DistTo(const Vector2D &vOther) const
  551. {
  552.         Vector2D delta;
  553.         Vector2DSubtract( *this, vOther, delta );
  554.         return delta.Length();
  555. }
  556.  
  557. inline vec_t Vector2D::DistToSqr(const Vector2D &vOther) const
  558. {
  559.         Vector2D delta;
  560.         Vector2DSubtract( *this, vOther, delta );
  561.         return delta.LengthSqr();
  562. }
  563.  
  564.  
  565. //-----------------------------------------------------------------------------
  566. // Computes the closest point to vecTarget no farther than flMaxDist from vecStart
  567. //-----------------------------------------------------------------------------
  568. inline void ComputeClosestPoint2D( const Vector2D& vecStart, float flMaxDist, const Vector2D& vecTarget, Vector2D *pResult )
  569. {
  570.         Vector2D vecDelta;
  571.         Vector2DSubtract( vecTarget, vecStart, vecDelta );
  572.         float flDistSqr = vecDelta.LengthSqr();
  573.         if ( flDistSqr <= flMaxDist * flMaxDist )
  574.         {
  575.                 *pResult = vecTarget;
  576.         }
  577.         else
  578.         {
  579.                 vecDelta /= FastSqrt( flDistSqr );
  580.                 Vector2DMA( vecStart, flMaxDist, vecDelta, *pResult );
  581.         }
  582. }
  583.  
  584.  
  585.  
  586. //-----------------------------------------------------------------------------
  587. //
  588. // Slow methods
  589. //
  590. //-----------------------------------------------------------------------------
  591.  
  592. #ifndef VECTOR_NO_SLOW_OPERATIONS
  593.  
  594. //-----------------------------------------------------------------------------
  595. // Returns a Vector2D with the min or max in X, Y, and Z.
  596. //-----------------------------------------------------------------------------
  597.  
  598. inline Vector2D Vector2D::Min(const Vector2D &vOther) const
  599. {
  600.         return Vector2D(x < vOther.x ? x : vOther.x,
  601.                 y < vOther.y ? y : vOther.y);
  602. }
  603.  
  604. inline Vector2D Vector2D::Max(const Vector2D &vOther) const
  605. {
  606.         return Vector2D(x > vOther.x ? x : vOther.x,
  607.                 y > vOther.y ? y : vOther.y);
  608. }
  609.  
  610.  
  611. //-----------------------------------------------------------------------------
  612. // arithmetic operations
  613. //-----------------------------------------------------------------------------
  614.  
  615. inline Vector2D Vector2D::operator-(void) const
  616. {
  617.         return Vector2D(-x,-y);                        
  618. }
  619.  
  620. inline Vector2D Vector2D::operator+(const Vector2D& v) const   
  621. {
  622.         Vector2D res;
  623.         Vector2DAdd( *this, v, res );
  624.         return res;    
  625. }
  626.  
  627. inline Vector2D Vector2D::operator-(const Vector2D& v) const   
  628. {
  629.         Vector2D res;
  630.         Vector2DSubtract( *this, v, res );
  631.         return res;    
  632. }
  633.  
  634. inline Vector2D Vector2D::operator*(float fl) const    
  635. {
  636.         Vector2D res;
  637.         Vector2DMultiply( *this, fl, res );
  638.         return res;    
  639. }
  640.  
  641. inline Vector2D Vector2D::operator*(const Vector2D& v) const   
  642. {
  643.         Vector2D res;
  644.         Vector2DMultiply( *this, v, res );
  645.         return res;    
  646. }
  647.  
  648. inline Vector2D Vector2D::operator/(float fl) const    
  649. {
  650.         Vector2D res;
  651.         Vector2DDivide( *this, fl, res );
  652.         return res;    
  653. }
  654.  
  655. inline Vector2D Vector2D::operator/(const Vector2D& v) const   
  656. {
  657.         Vector2D res;
  658.         Vector2DDivide( *this, v, res );
  659.         return res;    
  660. }
  661.  
  662. inline Vector2D operator*(float fl, const Vector2D& v) 
  663. {
  664.         return v * fl;
  665. }
  666.  
  667. #endif //slow
  668.  
  669. #endif // VECTOR2D_H
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top