nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_VECTOR_2S_H
+00027 #define NL_VECTOR_2S_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "nel/misc/file.h"
+00031 #include "nel/misc/vector_2f.h"
+00032 #include "nel/misc/vector.h"
+00033 
+00034 
+00035 namespace NLPACS {
+00036 
+00037 
+00038 const float             Vector2sAccuracy = 128.0f;
+00039 
+00046 class CVector2s
+00047 {
+00048 private:
+00049         // safely cast a fixed64 into a fixed16
+00050         static sint16   safeCastSint16(sint64 s)
+00051         {
+00052 #ifdef NL_DEBUG
+00053                 if (s>32767 || s<-32768)
+00054                         nlerror("in CVector2s::safeCastSint16(sint64): value doesn't fit sint16 (value=%" NL_I64 "d)", s);
+00055 #endif
+00056                 return (sint16)s;
+00057         }
+00058 
+00059         // safely cast a premuled float into a fixed16
+00060         static sint16   safeCastSint16(float f)
+00061         {
+00062 #ifdef NL_DEBUG
+00063                 sint64  s = (sint64)f;
+00064                 if (s>32767 || s<-32768)
+00065                         nlerror("in CVector2s::safeCastSint16(float): value doesn't fit sint16 (value=%f)", f);
+00066                 return (sint16)s;
+00067 #else
+00068                 return (sint16)f;
+00069 #endif
+00070         }
+00071 
+00072         // check the cast into fixed16
+00073         static bool             checkCastSint16(sint64 s)
+00074         {
+00075                 return (s<=32767 && s>=-32768);
+00076         }
+00077 
+00078         // check the cast into fixed16
+00079         static bool             checkCastSint16(float f)
+00080         {
+00081                 sint64  s = (sint64)f;
+00082                 return (s<=32767 && s>=-32768);
+00083         }
+00084 
+00085 
+00086         // pack a float into a fixed16
+00087         static sint16   pack(float f)
+00088         {
+00089                 return safeCastSint16(f*Vector2sAccuracy);
+00090         }
+00091 
+00092         // unpack a fixed16 into a float
+00093         static float    unpack(sint16 s)
+00094         {
+00095                 return (float)s/Vector2sAccuracy;
+00096         }
+00097 
+00098 public:         // Attributes.
+00099         sint16  x, y;
+00100 
+00101 public:         // Methods.
+00103 
+00104 
+00105         CVector2s() {}
+00107         CVector2s(sint16 _x, sint16 _y) : x(_x), y(_y) {}
+00109         CVector2s(const CVector2s &v) : x(v.x), y(v.y) {}
+00110         CVector2s(const NLMISC::CVector &v) { pack(v); }
+00112 
+00113 
+00115 
+00116         CVector2s       &operator+=(const CVector2s &v)         {x=safeCastSint16((sint64)v.x+(sint64)x); y=safeCastSint16((sint64)v.y+(sint64)y); return *this;}
+00117         CVector2s       &operator-=(const CVector2s &v)         {x=safeCastSint16((sint64)v.x-(sint64)x); y=safeCastSint16((sint64)v.y-(sint64)y); return *this;}
+00118         CVector2s       operator+(const CVector2s &v) const     {return CVector2s(safeCastSint16((sint64)v.x+(sint64)x), safeCastSint16((sint64)v.y+(sint64)y));}
+00119         CVector2s       operator-(const CVector2s &v) const     {return CVector2s(safeCastSint16((sint64)v.x-(sint64)x), safeCastSint16((sint64)v.y-(sint64)y));}
+00120         CVector2s       operator-() const                                       {return CVector2s(safeCastSint16(-(sint64)x), safeCastSint16(-(sint64)y));}
+00121 
+00122         CVector2s       &operator*=(float f)                            { x = safeCastSint16(f*x); y = safeCastSint16(f*y); return *this; }
+00123         CVector2s       &operator/=(float f)                            { x = safeCastSint16(f/x); y = safeCastSint16(f/y); return *this; }
+00124         CVector2s       operator*(float f) const                        {return CVector2s(safeCastSint16(x*f), safeCastSint16(y*f));}
+00125         CVector2s       operator/(float f) const                        {return CVector2s(safeCastSint16(x/f), safeCastSint16(y/f));}
+00127 
+00129 
+00130 
+00131         float   operator*(const CVector2s &v) const             {return ((float)x*(float)v.x + (float)y*(float)v.y)/(Vector2sAccuracy*Vector2sAccuracy);}
+00133         float   norm() const                                                    {return (float)sqrt(sqrnorm());}
+00135         float   sqrnorm() const                                                 {return ((float)x*(float)x + (float)y*(float)y)/(Vector2sAccuracy*Vector2sAccuracy);}
+00137         void    normalize()
+00138         {
+00139                 float   f= norm();
+00140                 if(f>0)
+00141                         *this/=f;
+00142         }
+00144         CVector2s       normed() const
+00145         {
+00146                 CVector2s       v= *this;
+00147                 v.normalize();
+00148                 return v;
+00149         }
+00151 
+00153 
+00154         void    set(sint16 _x, sint16 _y)                               {x= _x; y=_y;}
+00155         bool    operator==(const CVector2s &v) const    {return x==v.x && y==v.y;}
+00156         bool    operator!=(const CVector2s &v) const    {return !(*this==v);}
+00157         bool    isNull() const                                                  {return x==0.0f && y==0.0f;}
+00159         void    minof(const CVector2s &a, const CVector2s &b)
+00160         {
+00161                 x= std::min(a.x, b.x);
+00162                 y= std::min(a.y, b.y);
+00163         }
+00165         void    maxof(const CVector2s &a, const CVector2s &b)
+00166         {
+00167                 x= std::max(a.x, b.x);
+00168                 y= std::max(a.y, b.y);
+00169         }
+00171         void    serial(NLMISC::IStream &f)                              {f.serial(x,y);}
+00173 
+00174         void                            pack(const NLMISC::CVector &v)          { x = pack(v.x); y = pack(v.y); }
+00175         void                            pack(const NLMISC::CVector2f &v)        { x = pack(v.x); y = pack(v.y); }
+00176         NLMISC::CVector2f       unpack() const                                          { return NLMISC::CVector2f(unpack(x), unpack(y)); }
+00177         NLMISC::CVector         unpack3f(float hintz=0.0f) const        { return NLMISC::CVector(unpack(x), unpack(y), hintz); }
+00178 };
+00179 
+00180 } // NLPACS
+00181 
+00182 
+00183 #endif // NL_VECTOR_2S_H
+00184 
+00185 /* End of vector_2s.h */
+