LCOV - code coverage report
Current view: directory - objdir/dist/include/skia - SkScalar.h (source / functions) Found Hit Coverage
Test: app.info Lines: 2 0 0.0 %
Date: 2012-06-02 Functions: 1 0 0.0 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       4                 :  *
       5                 :  * Use of this source code is governed by a BSD-style license that can be
       6                 :  * found in the LICENSE file.
       7                 :  */
       8                 : 
       9                 : 
      10                 : #ifndef SkScalar_DEFINED
      11                 : #define SkScalar_DEFINED
      12                 : 
      13                 : #include "SkFixed.h"
      14                 : #include "SkFloatingPoint.h"
      15                 : 
      16                 : /** \file SkScalar.h
      17                 : 
      18                 :     Types and macros for the data type SkScalar. This is the fractional numeric type
      19                 :     that, depending on the compile-time flag SK_SCALAR_IS_FLOAT, may be implemented
      20                 :     either as an IEEE float, or as a 16.16 SkFixed. The macros in this file are written
      21                 :     to allow the calling code to manipulate SkScalar values without knowing which representation
      22                 :     is in effect.
      23                 : */
      24                 : 
      25                 : #ifdef SK_SCALAR_IS_FLOAT
      26                 : 
      27                 :     /** SkScalar is our type for fractional values and coordinates. Depending on
      28                 :         compile configurations, it is either represented as an IEEE float, or
      29                 :         as a 16.16 fixed point integer.
      30                 :     */
      31                 :     typedef float   SkScalar;
      32                 :     extern const uint32_t gIEEENotANumber;
      33                 :     extern const uint32_t gIEEEInfinity;
      34                 : 
      35                 :     /** SK_Scalar1 is defined to be 1.0 represented as an SkScalar
      36                 :     */
      37                 :     #define SK_Scalar1              (1.0f)
      38                 :     /** SK_Scalar1 is defined to be 1/2 represented as an SkScalar
      39                 :     */
      40                 :     #define SK_ScalarHalf           (0.5f)
      41                 :     /** SK_ScalarInfinity is defined to be infinity as an SkScalar
      42                 :     */
      43                 :     #define SK_ScalarInfinity           (*(const float*)&gIEEEInfinity)
      44                 :     /** SK_ScalarMax is defined to be the largest value representable as an SkScalar
      45                 :     */
      46                 :     #define SK_ScalarMax            (3.402823466e+38f)
      47                 :     /** SK_ScalarMin is defined to be the smallest value representable as an SkScalar
      48                 :     */
      49                 :     #define SK_ScalarMin            (-SK_ScalarMax)
      50                 :     /** SK_ScalarNaN is defined to be 'Not a Number' as an SkScalar
      51                 :     */
      52                 :     #define SK_ScalarNaN      (*(const float*)(const void*)&gIEEENotANumber)
      53                 :     /** SkScalarIsNaN(n) returns true if argument is not a number
      54                 :     */
      55                 :     static inline bool SkScalarIsNaN(float x) { return x != x; }
      56                 :     /** Returns true if x is not NaN and not infinite */
      57                 :     static inline bool SkScalarIsFinite(float x) {
      58                 :         uint32_t bits = SkFloat2Bits(x);    // need unsigned for our shifts
      59                 :         int exponent = bits << 1 >> 24;
      60                 :         return exponent != 0xFF;
      61                 :     }
      62                 : #ifdef SK_DEBUG
      63                 :     /** SkIntToScalar(n) returns its integer argument as an SkScalar
      64                 :      *
      65                 :      * If we're compiling in DEBUG mode, and can thus afford some extra runtime
      66                 :      * cycles, check to make sure that the parameter passed in has not already
      67                 :      * been converted to SkScalar.  (A double conversion like this is harmless
      68                 :      * for SK_SCALAR_IS_FLOAT, but for SK_SCALAR_IS_FIXED this causes trouble.)
      69                 :      *
      70                 :      * Note that we need all of these method signatures to properly handle the
      71                 :      * various types that we pass into SkIntToScalar() to date:
      72                 :      * int, size_t, U8CPU, etc., even though what we really mean is "anything
      73                 :      * but a float".
      74                 :      */
      75               0 :     static inline float SkIntToScalar(signed int param) {
      76               0 :         return (float)param;
      77                 :     }
      78                 :     static inline float SkIntToScalar(unsigned int param) {
      79                 :         return (float)param;
      80                 :     }
      81                 :     static inline float SkIntToScalar(signed long param) {
      82                 :         return (float)param;
      83                 :     }
      84                 :     static inline float SkIntToScalar(unsigned long param) {
      85                 :         return (float)param;
      86                 :     }
      87                 :     static inline float SkIntToScalar(float param) {
      88                 :         /* If the parameter passed into SkIntToScalar is a float,
      89                 :          * one of two things has happened:
      90                 :          * 1. the parameter was an SkScalar (which is typedef'd to float)
      91                 :          * 2. the parameter was a float instead of an int
      92                 :          *
      93                 :          * Either way, it's not good.
      94                 :          */
      95                 :         SkDEBUGFAIL("looks like you passed an SkScalar into SkIntToScalar");
      96                 :         return (float)0;
      97                 :     }
      98                 : #else  // not SK_DEBUG
      99                 :     /** SkIntToScalar(n) returns its integer argument as an SkScalar
     100                 :     */
     101                 :     #define SkIntToScalar(n)        ((float)(n))
     102                 : #endif // not SK_DEBUG
     103                 :     /** SkFixedToScalar(n) returns its SkFixed argument as an SkScalar
     104                 :     */
     105                 :     #define SkFixedToScalar(x)      SkFixedToFloat(x)
     106                 :     /** SkScalarToFixed(n) returns its SkScalar argument as an SkFixed
     107                 :     */
     108                 :     #define SkScalarToFixed(x)      SkFloatToFixed(x)
     109                 : 
     110                 :     #define SkScalarToFloat(n)      (n)
     111                 :     #define SkFloatToScalar(n)      (n)
     112                 : 
     113                 :     #define SkScalarToDouble(n)      (double)(n)
     114                 :     #define SkDoubleToScalar(n)      (float)(n)
     115                 : 
     116                 :     /** SkScalarFraction(x) returns the signed fractional part of the argument
     117                 :     */
     118                 :     #define SkScalarFraction(x)     sk_float_mod(x, 1.0f)
     119                 : 
     120                 :     #define SkScalarFloorToScalar(x)    sk_float_floor(x)
     121                 :     #define SkScalarCeilToScalar(x)     sk_float_ceil(x)
     122                 :     #define SkScalarRoundToScalar(x)    sk_float_floor((x) + 0.5f)
     123                 : 
     124                 :     #define SkScalarFloorToInt(x)       sk_float_floor2int(x)
     125                 :     #define SkScalarCeilToInt(x)        sk_float_ceil2int(x)
     126                 :     #define SkScalarRoundToInt(x)       sk_float_round2int(x)
     127                 : 
     128                 :     /** Returns the absolute value of the specified SkScalar
     129                 :     */
     130                 :     #define SkScalarAbs(x)          sk_float_abs(x)
     131                 :     /** Return x with the sign of y
     132                 :      */
     133                 :     #define SkScalarCopySign(x, y)  sk_float_copysign(x, y)
     134                 :     /** Returns the value pinned between 0 and max inclusive
     135                 :     */
     136                 :     inline SkScalar SkScalarClampMax(SkScalar x, SkScalar max) {
     137                 :         return x < 0 ? 0 : x > max ? max : x;
     138                 :     }
     139                 :     /** Returns the value pinned between min and max inclusive
     140                 :     */
     141                 :     inline SkScalar SkScalarPin(SkScalar x, SkScalar min, SkScalar max) {
     142                 :         return x < min ? min : x > max ? max : x;
     143                 :     }
     144                 :     /** Returns the specified SkScalar squared (x*x)
     145                 :     */
     146                 :     inline SkScalar SkScalarSquare(SkScalar x) { return x * x; }
     147                 :     /** Returns the product of two SkScalars
     148                 :     */
     149                 :     #define SkScalarMul(a, b)       ((float)(a) * (b))
     150                 :     /** Returns the product of two SkScalars plus a third SkScalar
     151                 :     */
     152                 :     #define SkScalarMulAdd(a, b, c) ((float)(a) * (b) + (c))
     153                 :     /** Returns the product of a SkScalar and an int rounded to the nearest integer value
     154                 :     */
     155                 :     #define SkScalarMulRound(a, b) SkScalarRound((float)(a) * (b))
     156                 :     /** Returns the product of a SkScalar and an int promoted to the next larger int
     157                 :     */
     158                 :     #define SkScalarMulCeil(a, b) SkScalarCeil((float)(a) * (b))
     159                 :     /** Returns the product of a SkScalar and an int truncated to the next smaller int
     160                 :     */
     161                 :     #define SkScalarMulFloor(a, b) SkScalarFloor((float)(a) * (b))
     162                 :     /** Returns the quotient of two SkScalars (a/b)
     163                 :     */
     164                 :     #define SkScalarDiv(a, b)       ((float)(a) / (b))
     165                 :     /** Returns the mod of two SkScalars (a mod b)
     166                 :     */
     167                 :     #define SkScalarMod(x,y)        sk_float_mod(x,y)
     168                 :     /** Returns the product of the first two arguments, divided by the third argument
     169                 :     */
     170                 :     #define SkScalarMulDiv(a, b, c) ((float)(a) * (b) / (c))
     171                 :     /** Returns the multiplicative inverse of the SkScalar (1/x)
     172                 :     */
     173                 :     #define SkScalarInvert(x)       (SK_Scalar1 / (x))
     174                 :     #define SkScalarFastInvert(x)   (SK_Scalar1 / (x))
     175                 :     /** Returns the square root of the SkScalar
     176                 :     */
     177                 :     #define SkScalarSqrt(x)         sk_float_sqrt(x)
     178                 :     /** Returns the average of two SkScalars (a+b)/2
     179                 :     */
     180                 :     #define SkScalarAve(a, b)       (((a) + (b)) * 0.5f)
     181                 :     /** Returns the geometric mean of two SkScalars
     182                 :     */
     183                 :     #define SkScalarMean(a, b)      sk_float_sqrt((float)(a) * (b))
     184                 :     /** Returns one half of the specified SkScalar
     185                 :     */
     186                 :     #define SkScalarHalf(a)         ((a) * 0.5f)
     187                 : 
     188                 :     #define SK_ScalarSqrt2          1.41421356f
     189                 :     #define SK_ScalarPI             3.14159265f
     190                 :     #define SK_ScalarTanPIOver8     0.414213562f
     191                 :     #define SK_ScalarRoot2Over2     0.707106781f
     192                 : 
     193                 :     #define SkDegreesToRadians(degrees) ((degrees) * (SK_ScalarPI / 180))
     194                 :     float SkScalarSinCos(SkScalar radians, SkScalar* cosValue);
     195                 :     #define SkScalarSin(radians)    (float)sk_float_sin(radians)
     196                 :     #define SkScalarCos(radians)    (float)sk_float_cos(radians)
     197                 :     #define SkScalarTan(radians)    (float)sk_float_tan(radians)
     198                 :     #define SkScalarASin(val)   (float)sk_float_asin(val)
     199                 :     #define SkScalarACos(val)   (float)sk_float_acos(val)
     200                 :     #define SkScalarATan2(y, x) (float)sk_float_atan2(y,x)
     201                 :     #define SkScalarExp(x)  (float)sk_float_exp(x)
     202                 :     #define SkScalarLog(x)  (float)sk_float_log(x)
     203                 : 
     204                 :     inline SkScalar SkMaxScalar(SkScalar a, SkScalar b) { return a > b ? a : b; }
     205                 :     inline SkScalar SkMinScalar(SkScalar a, SkScalar b) { return a < b ? a : b; }
     206                 : 
     207                 :     static inline bool SkScalarIsInt(SkScalar x) {
     208                 :         return x == (float)(int)x;
     209                 :     }
     210                 : #else
     211                 :     typedef SkFixed SkScalar;
     212                 : 
     213                 :     #define SK_Scalar1              SK_Fixed1
     214                 :     #define SK_ScalarHalf           SK_FixedHalf
     215                 :     #define SK_ScalarInfinity   SK_FixedMax
     216                 :     #define SK_ScalarMax            SK_FixedMax
     217                 :     #define SK_ScalarMin            SK_FixedMin
     218                 :     #define SK_ScalarNaN            SK_FixedNaN
     219                 :     #define SkScalarIsNaN(x)        ((x) == SK_FixedNaN)
     220                 :     #define SkScalarIsFinite(x)     ((x) != SK_FixedNaN)
     221                 : 
     222                 :     #define SkIntToScalar(n)        SkIntToFixed(n)
     223                 :     #define SkFixedToScalar(x)      (x)
     224                 :     #define SkScalarToFixed(x)      (x)
     225                 :     #ifdef SK_CAN_USE_FLOAT
     226                 :         #define SkScalarToFloat(n)  SkFixedToFloat(n)
     227                 :         #define SkFloatToScalar(n)  SkFloatToFixed(n)
     228                 : 
     229                 :         #define SkScalarToDouble(n) SkFixedToDouble(n)
     230                 :         #define SkDoubleToScalar(n) SkDoubleToFixed(n)
     231                 :     #endif
     232                 :     #define SkScalarFraction(x)     SkFixedFraction(x)
     233                 : 
     234                 :     #define SkScalarFloorToScalar(x)    SkFixedFloorToFixed(x)
     235                 :     #define SkScalarCeilToScalar(x)     SkFixedCeilToFixed(x)
     236                 :     #define SkScalarRoundToScalar(x)    SkFixedRoundToFixed(x)
     237                 : 
     238                 :     #define SkScalarFloorToInt(x)       SkFixedFloorToInt(x)
     239                 :     #define SkScalarCeilToInt(x)        SkFixedCeilToInt(x)
     240                 :     #define SkScalarRoundToInt(x)       SkFixedRoundToInt(x)
     241                 : 
     242                 :     #define SkScalarAbs(x)          SkFixedAbs(x)
     243                 :     #define SkScalarCopySign(x, y)  SkCopySign32(x, y)
     244                 :     #define SkScalarClampMax(x, max) SkClampMax(x, max)
     245                 :     #define SkScalarPin(x, min, max) SkPin32(x, min, max)
     246                 :     #define SkScalarSquare(x)       SkFixedSquare(x)
     247                 :     #define SkScalarMul(a, b)       SkFixedMul(a, b)
     248                 :     #define SkScalarMulAdd(a, b, c) SkFixedMulAdd(a, b, c)
     249                 :     #define SkScalarMulRound(a, b)  SkFixedMulCommon(a, b, SK_FixedHalf)
     250                 :     #define SkScalarMulCeil(a, b)   SkFixedMulCommon(a, b, SK_Fixed1 - 1)
     251                 :     #define SkScalarMulFloor(a, b)  SkFixedMulCommon(a, b, 0)
     252                 :     #define SkScalarDiv(a, b)       SkFixedDiv(a, b)
     253                 :     #define SkScalarMod(a, b)       SkFixedMod(a, b)
     254                 :     #define SkScalarMulDiv(a, b, c) SkMulDiv(a, b, c)
     255                 :     #define SkScalarInvert(x)       SkFixedInvert(x)
     256                 :     #define SkScalarFastInvert(x)   SkFixedFastInvert(x)
     257                 :     #define SkScalarSqrt(x)         SkFixedSqrt(x)
     258                 :     #define SkScalarAve(a, b)       SkFixedAve(a, b)
     259                 :     #define SkScalarMean(a, b)      SkFixedMean(a, b)
     260                 :     #define SkScalarHalf(a)         ((a) >> 1)
     261                 : 
     262                 :     #define SK_ScalarSqrt2          SK_FixedSqrt2
     263                 :     #define SK_ScalarPI             SK_FixedPI
     264                 :     #define SK_ScalarTanPIOver8     SK_FixedTanPIOver8
     265                 :     #define SK_ScalarRoot2Over2     SK_FixedRoot2Over2
     266                 : 
     267                 :     #define SkDegreesToRadians(degrees)     SkFractMul(degrees, SK_FractPIOver180)
     268                 :     #define SkScalarSinCos(radians, cosPtr) SkFixedSinCos(radians, cosPtr)
     269                 :     #define SkScalarSin(radians)    SkFixedSin(radians)
     270                 :     #define SkScalarCos(radians)    SkFixedCos(radians)
     271                 :     #define SkScalarTan(val)        SkFixedTan(val)
     272                 :     #define SkScalarASin(val)       SkFixedASin(val)
     273                 :     #define SkScalarACos(val)       SkFixedACos(val)
     274                 :     #define SkScalarATan2(y, x)     SkFixedATan2(y,x)
     275                 :     #define SkScalarExp(x)          SkFixedExp(x)
     276                 :     #define SkScalarLog(x)          SkFixedLog(x)
     277                 : 
     278                 :     #define SkMaxScalar(a, b)       SkMax32(a, b)
     279                 :     #define SkMinScalar(a, b)       SkMin32(a, b)
     280                 : 
     281                 :     static inline bool SkScalarIsInt(SkFixed x) {
     282                 :         return 0 == (x & 0xffff);
     283                 :     }
     284                 : #endif
     285                 : 
     286                 : // DEPRECATED : use ToInt or ToScalar variant
     287                 : #define SkScalarFloor(x)    SkScalarFloorToInt(x)
     288                 : #define SkScalarCeil(x)     SkScalarCeilToInt(x)
     289                 : #define SkScalarRound(x)    SkScalarRoundToInt(x)
     290                 : 
     291                 : /**
     292                 :  *  Returns -1 || 0 || 1 depending on the sign of value:
     293                 :  *  -1 if x < 0
     294                 :  *   0 if x == 0
     295                 :  *   1 if x > 0
     296                 :  */
     297                 : static inline int SkScalarSignAsInt(SkScalar x) {
     298                 :     return x < 0 ? -1 : (x > 0);
     299                 : }
     300                 : 
     301                 : // Scalar result version of above
     302                 : static inline SkScalar SkScalarSignAsScalar(SkScalar x) {
     303                 :     return x < 0 ? -SK_Scalar1 : ((x > 0) ? SK_Scalar1 : 0);
     304                 : }
     305                 : 
     306                 : #define SK_ScalarNearlyZero         (SK_Scalar1 / (1 << 12))
     307                 : 
     308                 : /*  <= is slower than < for floats, so we use < for our tolerance test
     309                 : */
     310                 : 
     311                 : static inline bool SkScalarNearlyZero(SkScalar x,
     312                 :                                     SkScalar tolerance = SK_ScalarNearlyZero) {
     313                 :     SkASSERT(tolerance > 0);
     314                 :     return SkScalarAbs(x) < tolerance;
     315                 : }
     316                 : 
     317                 : static inline bool SkScalarNearlyEqual(SkScalar x, SkScalar y,
     318                 :                                      SkScalar tolerance = SK_ScalarNearlyZero) {
     319                 :     SkASSERT(tolerance > 0);
     320                 :     return SkScalarAbs(x-y) < tolerance;
     321                 : }
     322                 : 
     323                 : /** Linearly interpolate between A and B, based on t.
     324                 :     If t is 0, return A
     325                 :     If t is 1, return B
     326                 :     else interpolate.
     327                 :     t must be [0..SK_Scalar1]
     328                 : */
     329                 : static inline SkScalar SkScalarInterp(SkScalar A, SkScalar B, SkScalar t) {
     330                 :     SkASSERT(t >= 0 && t <= SK_Scalar1);
     331                 :     return A + SkScalarMul(B - A, t);
     332                 : }
     333                 : 
     334                 : /** Interpolate along the function described by (keys[length], values[length])
     335                 :     for the passed searchKey.  SearchKeys outside the range keys[0]-keys[Length]
     336                 :     clamp to the min or max value.  This function was inspired by a desire
     337                 :     to change the multiplier for thickness in fakeBold; therefore it assumes
     338                 :     the number of pairs (length) will be small, and a linear search is used.
     339                 :     Repeated keys are allowed for discontinuous functions (so long as keys is
     340                 :     monotonically increasing), and if key is the value of a repeated scalar in
     341                 :     keys, the first one will be used.  However, that may change if a binary
     342                 :     search is used.
     343                 : */
     344                 : SkScalar SkScalarInterpFunc(SkScalar searchKey, const SkScalar keys[],
     345                 :                             const SkScalar values[], int length);
     346                 : 
     347                 : #endif

Generated by: LCOV version 1.7