/[pcsx2_0.9.7]/trunk/common/include/Utilities/FixedPointTypes.h
ViewVC logotype

Diff of /trunk/common/include/Utilities/FixedPointTypes.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 31 by william, Tue Sep 7 03:24:11 2010 UTC revision 62 by william, Tue Sep 7 11:08:22 2010 UTC
# Line 23  struct FixedInt Line 23  struct FixedInt
23  {  {
24          s32 Raw;          s32 Raw;
25    
26          FixedInt()          FixedInt();
27          {          FixedInt( int signedval );
28                  Raw = 0;          FixedInt( double doubval );
29          }          FixedInt( float floval );
30    
31          FixedInt( int signedval )          bool operator ==( const FixedInt<Precision>& right ) const { return Raw == right.Raw; }
32          {          bool operator !=( const FixedInt<Precision>& right ) const { return Raw != right.Raw; }
33                  Raw = signedval * Precision;  
34          }          bool operator>( const FixedInt<Precision>& right ) const        { return Raw > right.Raw; };
35            bool operator>=( const FixedInt<Precision>& right ) const       { return Raw >= right.Raw; };
36          FixedInt( double doubval )          bool operator<( const FixedInt<Precision>& right ) const        { return Raw < right.Raw; };
37          {          bool operator<=( const FixedInt<Precision>& right ) const       { return Raw <= right.Raw; };
38                  Raw = (int)(doubval * (double)Precision);  
39          }          FixedInt<Precision> operator+( const FixedInt<Precision>& right ) const;
40            FixedInt<Precision> operator-( const FixedInt<Precision>& right ) const;
41          FixedInt( float floval )          FixedInt<Precision>& operator+=( const FixedInt<Precision>& right );
42          {          FixedInt<Precision>& operator-=( const FixedInt<Precision>& right );
43                  Raw = (int)(floval * (float)Precision);  
44          }          FixedInt<Precision>& ConfineTo( const FixedInt<Precision>& low, const FixedInt<Precision>& high );
45    
46          bool operator ==( const FixedInt<Precision>& right ) const          FixedInt<Precision> operator*( const FixedInt<Precision>& right ) const;
47          {          FixedInt<Precision> operator/( const FixedInt<Precision>& right ) const;
48                  return Raw == right.Raw;          FixedInt<Precision>& operator*=( const FixedInt<Precision>& right );
49          }          FixedInt<Precision>& operator/=( const FixedInt<Precision>& right );
50    
51          bool operator !=( const FixedInt<Precision>& right ) const          static bool OverflowCheck( int signedval );
52          {          static bool OverflowCheck( double signedval );
53                  return Raw != right.Raw;  
54          }          int GetWhole() const;
55            int GetFraction() const;
56          FixedInt<Precision> operator+( const FixedInt<Precision>& right ) const  
57          {          FixedInt<Precision>& SetRaw( s32 rawsrc );
58                  return FixedInt<Precision>().SetRaw( Raw + right.Raw );          FixedInt<Precision>& Round();
59          }          FixedInt<Precision>& SetWhole( s32 wholepart );
60            FixedInt<Precision>& SetFraction( u32 fracpart );
61          FixedInt<Precision> operator-( const FixedInt<Precision>& right ) const  
62          {          wxString ToString() const;
63                  return FixedInt<Precision>().SetRaw( Raw + right.Raw );          wxString ToString( int fracDigits ) const;
64          }  
65            double ToDouble() const;
66          FixedInt<Precision>& operator+=( const FixedInt<Precision>& right )          float ToFloat() const;
67          {          int ToIntTruncated() const;
68                  return SetRaw( Raw + right.Raw );          int ToIntRounded() const;
69          }  
70            static bool TryFromString( FixedInt<Precision>& dest, const wxString& parseFrom );
71          FixedInt<Precision>& operator-=( const FixedInt<Precision>& right )          static FixedInt<Precision> FromString( const wxString& parseFrom, const FixedInt<Precision>& defval );
72          {          static FixedInt<Precision> FromString( const wxString parseFrom );
                 return SetRaw( Raw + right.Raw );  
         }  
   
         bool operator>( const FixedInt<Precision>& right ) const                { return Raw > right.Raw; }  
         bool operator>=( const FixedInt<Precision>& right ) const       { return Raw >= right.Raw; }  
         bool operator<( const FixedInt<Precision>& right ) const                { return Raw < right.Raw; }  
         bool operator<=( const FixedInt<Precision>& right ) const       { return Raw <= right.Raw; }  
   
         FixedInt<Precision>& ConfineTo( const FixedInt<Precision>& low, const FixedInt<Precision>& high )  
         {  
                 return SetRaw( std::min( std::max( Raw, low.Raw ), high.Raw ) );  
         }  
   
         // Uses 64 bit internally to avoid overflows.  For more precise/optimized 32 bit math  
         // you'll need to use the Raw values directly.  
         FixedInt<Precision> operator*( const FixedInt<Precision>& right ) const  
         {  
                 s64 mulres = (s64)Raw * right.Raw;  
                 return FixedInt<Precision>().SetRaw( (s32)(mulres / Precision) );  
         }  
   
         // Uses 64 bit internally to avoid overflows.  For more precise/optimized 32 bit math  
         // you'll need to use the Raw values directly.  
         FixedInt<Precision> operator/( const FixedInt<Precision>& right ) const  
         {  
                 s64 divres = Raw * Precision;  
                 return FixedInt<Precision>().SetRaw( (s32)(divres / right.Raw) );  
         }  
   
         // Uses 64 bit internally to avoid overflows.  For more precise/optimized 32 bit math  
         // you'll need to use the Raw values directly.  
         FixedInt<Precision>& operator*=( const FixedInt<Precision>& right )  
         {  
                 s64 mulres = (s64)Raw * right.Raw;  
                 return SetRaw( (s32)(mulres / Precision) );  
         }  
   
         // Uses 64 bit internally to avoid overflows.  For more precise/optimized 32 bit math  
         // you'll need to use the Raw values directly.  
         FixedInt<Precision>& operator/=( const FixedInt<Precision>& right )  
         {  
                 s64 divres = Raw * Precision;  
                 return SetRaw( (s32)(divres / right.Raw) );  
         }  
   
         // returns TRUE if the value overflows the legal integer range of this container.  
         static bool OverflowCheck( int signedval )  
         {  
                 return ( signedval >= (INT_MAX / Precision) );  
         }  
   
         // returns TRUE if the value overflows the legal integer range of this container.  
         static bool OverflowCheck( double signedval )  
         {  
                 return ( signedval >= (INT_MAX / Precision) );  
         }  
   
         int GetWhole() const    { return Raw / Precision; }  
         int GetFraction() const { return Raw % Precision; }  
   
         FixedInt<Precision>& SetRaw( s32 rawsrc )  
         {  
                 Raw = rawsrc;  
                 return *this;  
         }  
   
         FixedInt<Precision>& Round()  
         {  
                 Raw = ToIntRounded();  
                 return *this;  
         }  
   
         FixedInt<Precision>& SetWhole( s32 wholepart )  
         {  
                 pxAssert( wholepart < (INT_MAX / Precision) );  
                 Raw = GetFraction() + (wholepart * Precision);  
                 return *this;  
         }  
   
         FixedInt<Precision>& SetFraction( u32 fracpart )  
         {  
                 Raw = (GetWhole() * Precision) + fracpart;  
                 return *this;  
         }  
   
         wxString ToString() const  
         {  
                 return wxsFormat( L"%d.%d", GetWhole(), (GetFraction() * 100) / Precision );  
         }  
   
         wxString ToString( int fracDigits ) const  
         {  
                 if( fracDigits == 0 ) return wxsFormat( L"%d", GetWhole() );  
   
                 pxAssert( fracDigits <= 7 );            // higher numbers would just cause overflows and bad mojo.  
                 int mulby = (int)pow( 10.0, fracDigits );  
                 return wxsFormat( L"%d.%d", GetWhole(), (GetFraction() * mulby) / Precision );  
         }  
   
         double ToDouble() const  
         {  
                 return ((double)Raw / (double)Precision);  
         }  
   
         float ToFloat() const  
         {  
                 return ((float)Raw / (float)Precision);  
         }  
   
         int ToIntTruncated() const  
         {  
                 return Raw / Precision;  
         }  
   
         int ToIntRounded() const  
         {  
                 return (Raw + (Precision/2)) / Precision;  
         }  
   
         static bool TryFromString( FixedInt<Precision>& dest, const wxString& parseFrom )  
         {  
                 long whole=0, frac=0;  
                 const wxString beforeFirst( parseFrom.BeforeFirst( L'.' ) );  
                 const wxString afterFirst( parseFrom.AfterFirst( L'.' ).Mid(0, 5) );  
                 bool success = true;  
   
                 if( !beforeFirst.IsEmpty() )  
                         success = success && beforeFirst.ToLong( &whole );  
   
                 if( !afterFirst.IsEmpty() )  
                         success = success && afterFirst.ToLong( &frac );  
   
                 if( !success ) return false;  
   
                 dest.SetWhole( whole );  
   
                 if( afterFirst.Length() != 0 && frac != 0 )  
                 {  
                         int fracPower = (int)pow( 10.0, (int)afterFirst.Length() );  
                         dest.SetFraction( (frac * Precision) / fracPower );  
                 }  
                 return true;  
         }  
   
         static FixedInt<Precision> FromString( const wxString& parseFrom, const FixedInt<Precision>& defval )  
         {  
                 FixedInt<Precision> dest;  
                 if( !TryFromString( dest, parseFrom ) ) return defval;  
                 return dest;  
         }  
   
         // This version of FromString throws a ParseError exception if the conversion fails.  
         static FixedInt<Precision> FromString( const wxString parseFrom )  
         {  
                 FixedInt<Precision> dest;  
                 if( !TryFromString( dest, parseFrom ) ) throw Exception::ParseError(  
                         wxsFormat(L"Parse error on FixedInt<%d>::FromString", Precision), wxEmptyString  
                 );  
                 return dest;  
         }  
73  };  };
74    
75  typedef FixedInt<256>           Fixed256;  typedef FixedInt<256>           Fixed256;

Legend:
Removed from v.31  
changed lines
  Added in v.62

  ViewVC Help
Powered by ViewVC 1.1.22