开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
fttrigon.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：11k
源码类别：

其他游戏

开发平台：

Visual C++

fttrigon.c：源码内容
  2. /***************************************************************************/
  3. /*                                                                         */
  4. /*  fttrigon.c                                                             */
  5. /*                                                                         */
  6. /*    FreeType trigonometric functions (body).                             */
  7. /*                                                                         */
  8. /*  Copyright 2001, 2002, 2003, 2004, 2005 by                              */
  9. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  10. /*                                                                         */
  11. /*  This file is part of the FreeType project, and may only be used,       */
  12. /*  modified, and distributed under the terms of the FreeType project      */
  13. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  14. /*  this file you indicate that you have read the license and              */
  15. /*  understand and accept it fully.                                        */
  16. /*                                                                         */
  17. /***************************************************************************/
  20. #include <ft2build.h>
  21. #include FT_INTERNAL_OBJECTS_H
  22. #include FT_TRIGONOMETRY_H
  25.   /* the following is 0.2715717684432231 * 2^30 */
  26. #define FT_TRIG_COSCALE  0x11616E8EUL
  28.   /* this table was generated for FT_PI = 180L << 16, i.e. degrees */
  29. #define FT_TRIG_MAX_ITERS  23
  31.   static const FT_Fixed
  32.   ft_trig_arctan_table[24] =
  33.   {
  34.     4157273L, 2949120L, 1740967L, 919879L, 466945L, 234379L, 117304L,
  35.     58666L, 29335L, 14668L, 7334L, 3667L, 1833L, 917L, 458L, 229L, 115L,
  36.     57L, 29L, 14L, 7L, 4L, 2L, 1L
  37.   };
  39.   /* the Cordic shrink factor, multiplied by 2^32 */
  40. #define FT_TRIG_SCALE    1166391785UL  /* 0x4585BA38UL */
  43. #ifdef FT_CONFIG_HAS_INT64
  45.   /* multiply a given value by the CORDIC shrink factor */
  46.   static FT_Fixed
  47.   ft_trig_downscale( FT_Fixed  val )
  48.   {
  49.     FT_Fixed  s;
  50.     FT_Int64  v;
  53.     s   = val;
  54.     val = ( val >= 0 ) ? val : -val;
  56.     v   = ( val * (FT_Int64)FT_TRIG_SCALE ) + 0x100000000UL;
  57.     val = (FT_Fixed)( v >> 32 );
  59.     return ( s >= 0 ) ? val : -val;
  60.   }
  62. #else /* !FT_CONFIG_HAS_INT64 */
  64.   /* multiply a given value by the CORDIC shrink factor */
  65.   static FT_Fixed
  66.   ft_trig_downscale( FT_Fixed  val )
  67.   {
  68.     FT_Fixed   s;
  69.     FT_UInt32  v1, v2, k1, k2, hi, lo1, lo2, lo3;
  72.     s   = val;
  73.     val = ( val >= 0 ) ? val : -val;
  75.     v1 = (FT_UInt32)val >> 16;
  76.     v2 = (FT_UInt32)val & 0xFFFFL;
  78.     k1 = FT_TRIG_SCALE >> 16;       /* constant */
  79.     k2 = FT_TRIG_SCALE & 0xFFFFL;   /* constant */
  81.     hi   = k1 * v1;
  82.     lo1  = k1 * v2 + k2 * v1;       /* can't overflow */
  84.     lo2  = ( k2 * v2 ) >> 16;
  85.     lo3  = ( lo1 >= lo2 ) ? lo1 : lo2;
  86.     lo1 += lo2;
  88.     hi  += lo1 >> 16;
  89.     if ( lo1 < lo3 )
  90.       hi += 0x10000UL;
  92.     val  = (FT_Fixed)hi;
  94.     return ( s >= 0 ) ? val : -val;
  95.   }
  97. #endif /* !FT_CONFIG_HAS_INT64 */
  100.   static FT_Int
  101.   ft_trig_prenorm( FT_Vector*  vec )
  102.   {
  103.     FT_Fixed  x, y, z;
  104.     FT_Int    shift;
  107.     x = vec->x;
  108.     y = vec->y;
  110.     z     = ( ( x >= 0 ) ? x : - x ) | ( (y >= 0) ? y : -y );
  111.     shift = 0;
  113. #if 1
  114.     /* determine msb bit index in `shift' */
  115.     if ( z >= ( 1L << 16 ) )
  116.     {
  117.       z     >>= 16;
  118.       shift  += 16;
  119.     }
  120.     if ( z >= ( 1L << 8 ) )
  121.     {
  122.       z     >>= 8;
  123.       shift  += 8;
  124.     }
  125.     if ( z >= ( 1L << 4 ) )
  126.     {
  127.       z     >>= 4;
  128.       shift  += 4;
  129.     }
  130.     if ( z >= ( 1L << 2 ) )
  131.     {
  132.       z     >>= 2;
  133.       shift  += 2;
  134.     }
  135.     if ( z >= ( 1L << 1 ) )
  136.     {
  137.       z    >>= 1;
  138.       shift += 1;
  139.     }
  141.     if ( shift <= 27 )
  142.     {
  143.       shift  = 27 - shift;
  144.       vec->x = x << shift;
  145.       vec->y = y << shift;
  146.     }
  147.     else
  148.     {
  149.       shift -= 27;
  150.       vec->x = x >> shift;
  151.       vec->y = y >> shift;
  152.       shift  = -shift;
  153.     }
  155. #else /* 0 */
  157.     if ( z < ( 1L << 27 ) )
  158.     {
  159.       do
  160.       {
  161.         shift++;
  162.         z <<= 1;
  163.       } while ( z < ( 1L << 27 ) );
  164.       vec->x = x << shift;
  165.       vec->y = y << shift;
  166.     }
  167.     else if ( z > ( 1L << 28 ) )
  168.     {
  169.       do
  170.       {
  171.         shift++;
  172.         z >>= 1;
  173.       } while ( z > ( 1L << 28 ) );
  175.       vec->x = x >> shift;
  176.       vec->y = y >> shift;
  177.       shift  = -shift;
  178.     }
  180. #endif /* 0 */
  182.     return shift;
  183.   }
  186.   static void
  187.   ft_trig_pseudo_rotate( FT_Vector*  vec,
  188.                          FT_Angle    theta )
  189.   {
  190.     FT_Int           i;
  191.     FT_Fixed         x, y, xtemp;
  192.     const FT_Fixed  *arctanptr;
  195.     x = vec->x;
  196.     y = vec->y;
  198.     /* Get angle between -90 and 90 degrees */
  199.     while ( theta <= -FT_ANGLE_PI2 )
  200.     {
  201.       x = -x;
  202.       y = -y;
  203.       theta += FT_ANGLE_PI;
  204.     }
  206.     while ( theta > FT_ANGLE_PI2 )
  207.     {
  208.       x = -x;
  209.       y = -y;
  210.       theta -= FT_ANGLE_PI;
  211.     }
  213.     /* Initial pseudorotation, with left shift */
  214.     arctanptr = ft_trig_arctan_table;
  216.     if ( theta < 0 )
  217.     {
  218.       xtemp  = x + ( y << 1 );
  219.       y      = y - ( x << 1 );
  220.       x      = xtemp;
  221.       theta += *arctanptr++;
  222.     }
  223.     else
  224.     {
  225.       xtemp  = x - ( y << 1 );
  226.       y      = y + ( x << 1 );
  227.       x      = xtemp;
  228.       theta -= *arctanptr++;
  229.     }
  231.     /* Subsequent pseudorotations, with right shifts */
  232.     i = 0;
  233.     do
  234.     {
  235.       if ( theta < 0 )
  236.       {
  237.         xtemp  = x + ( y >> i );
  238.         y      = y - ( x >> i );
  239.         x      = xtemp;
  240.         theta += *arctanptr++;
  241.       }
  242.       else
  243.       {
  244.         xtemp  = x - ( y >> i );
  245.         y      = y + ( x >> i );
  246.         x      = xtemp;
  247.         theta -= *arctanptr++;
  248.       }
  249.     } while ( ++i < FT_TRIG_MAX_ITERS );
  251.     vec->x = x;
  252.     vec->y = y;
  253.   }
  256.   static void
  257.   ft_trig_pseudo_polarize( FT_Vector*  vec )
  258.   {
  259.     FT_Fixed         theta;
  260.     FT_Fixed         yi, i;
  261.     FT_Fixed         x, y;
  262.     const FT_Fixed  *arctanptr;
  265.     x = vec->x;
  266.     y = vec->y;
  268.     /* Get the vector into the right half plane */
  269.     theta = 0;
  270.     if ( x < 0 )
  271.     {
  272.       x = -x;
  273.       y = -y;
  274.       theta = 2 * FT_ANGLE_PI2;
  275.     }
  277.     if ( y > 0 )
  278.       theta = - theta;
  280.     arctanptr = ft_trig_arctan_table;
  282.     if ( y < 0 )
  283.     {
  284.       /* Rotate positive */
  285.       yi     = y + ( x << 1 );
  286.       x      = x - ( y << 1 );
  287.       y      = yi;
  288.       theta -= *arctanptr++;  /* Subtract angle */
  289.     }
  290.     else
  291.     {
  292.       /* Rotate negative */
  293.       yi     = y - ( x << 1 );
  294.       x      = x + ( y << 1 );
  295.       y      = yi;
  296.       theta += *arctanptr++;  /* Add angle */
  297.     }
  299.     i = 0;
  300.     do
  301.     {
  302.       if ( y < 0 )
  303.       {
  304.         /* Rotate positive */
  305.         yi     = y + ( x >> i );
  306.         x      = x - ( y >> i );
  307.         y      = yi;
  308.         theta -= *arctanptr++;
  309.       }
  310.       else
  311.       {
  312.         /* Rotate negative */
  313.         yi     = y - ( x >> i );
  314.         x      = x + ( y >> i );
  315.         y      = yi;
  316.         theta += *arctanptr++;
  317.       }
  318.     } while ( ++i < FT_TRIG_MAX_ITERS );
  320.     /* round theta */
  321.     if ( theta >= 0 )
  322.       theta = FT_PAD_ROUND( theta, 32 );
  323.     else
  324.       theta = -FT_PAD_ROUND( -theta, 32 );
  326.     vec->x = x;
  327.     vec->y = theta;
  328.   }
  331.   /* documentation is in fttrigon.h */
  333.   FT_EXPORT_DEF( FT_Fixed )
  334.   FT_Cos( FT_Angle  angle )
  335.   {
  336.     FT_Vector  v;
  339.     v.x = FT_TRIG_COSCALE >> 2;
  340.     v.y = 0;
  341.     ft_trig_pseudo_rotate( &v, angle );
  343.     return v.x / ( 1 << 12 );
  344.   }
  347.   /* documentation is in fttrigon.h */
  349.   FT_EXPORT_DEF( FT_Fixed )
  350.   FT_Sin( FT_Angle  angle )
  351.   {
  352.     return FT_Cos( FT_ANGLE_PI2 - angle );
  353.   }
  356.   /* documentation is in fttrigon.h */
  358.   FT_EXPORT_DEF( FT_Fixed )
  359.   FT_Tan( FT_Angle  angle )
  360.   {
  361.     FT_Vector  v;
  364.     v.x = FT_TRIG_COSCALE >> 2;
  365.     v.y = 0;
  366.     ft_trig_pseudo_rotate( &v, angle );
  368.     return FT_DivFix( v.y, v.x );
  369.   }
  372.   /* documentation is in fttrigon.h */
  374.   FT_EXPORT_DEF( FT_Angle )
  375.   FT_Atan2( FT_Fixed  dx,
  376.             FT_Fixed  dy )
  377.   {
  378.     FT_Vector  v;
  381.     if ( dx == 0 && dy == 0 )
  382.       return 0;
  384.     v.x = dx;
  385.     v.y = dy;
  386.     ft_trig_prenorm( &v );
  387.     ft_trig_pseudo_polarize( &v );
  389.     return v.y;
  390.   }
  393.   /* documentation is in fttrigon.h */
  395.   FT_EXPORT_DEF( void )
  396.   FT_Vector_Unit( FT_Vector*  vec,
  397.                   FT_Angle    angle )
  398.   {
  399.     vec->x = FT_TRIG_COSCALE >> 2;
  400.     vec->y = 0;
  401.     ft_trig_pseudo_rotate( vec, angle );
  402.     vec->x >>= 12;
  403.     vec->y >>= 12;
  404.   }
  407.   /* these macros return 0 for positive numbers,
  408.      and -1 for negative ones */
  409. #define FT_SIGN_LONG( x )   ( (x) >> ( FT_SIZEOF_LONG * 8 - 1 ) )
  410. #define FT_SIGN_INT( x )    ( (x) >> ( FT_SIZEOF_INT * 8 - 1 ) )
  411. #define FT_SIGN_INT32( x )  ( (x) >> 31 )
  412. #define FT_SIGN_INT16( x )  ( (x) >> 15 )
  415.   /* documentation is in fttrigon.h */
  417.   FT_EXPORT_DEF( void )
  418.   FT_Vector_Rotate( FT_Vector*  vec,
  419.                     FT_Angle    angle )
  420.   {
  421.     FT_Int     shift;
  422.     FT_Vector  v;
  425.     v.x   = vec->x;
  426.     v.y   = vec->y;
  428.     if ( angle && ( v.x != 0 || v.y != 0 ) )
  429.     {
  430.       shift = ft_trig_prenorm( &v );
  431.       ft_trig_pseudo_rotate( &v, angle );
  432.       v.x = ft_trig_downscale( v.x );
  433.       v.y = ft_trig_downscale( v.y );
  435.       if ( shift > 0 )
  436.       {
  437.         FT_Int32  half = 1L << ( shift - 1 );
  440.         vec->x = ( v.x + half + FT_SIGN_LONG( v.x ) ) >> shift;
  441.         vec->y = ( v.y + half + FT_SIGN_LONG( v.y ) ) >> shift;
  442.       }
  443.       else
  444.       {
  445.         shift  = -shift;
  446.         vec->x = v.x << shift;
  447.         vec->y = v.y << shift;
  448.       }
  449.     }
  450.   }
  453.   /* documentation is in fttrigon.h */
  455.   FT_EXPORT_DEF( FT_Fixed )
  456.   FT_Vector_Length( FT_Vector*  vec )
  457.   {
  458.     FT_Int     shift;
  459.     FT_Vector  v;
  462.     v = *vec;
  464.     /* handle trivial cases */
  465.     if ( v.x == 0 )
  466.     {
  467.       return ( v.y >= 0 ) ? v.y : -v.y;
  468.     }
  469.     else if ( v.y == 0 )
  470.     {
  471.       return ( v.x >= 0 ) ? v.x : -v.x;
  472.     }
  474.     /* general case */
  475.     shift = ft_trig_prenorm( &v );
  476.     ft_trig_pseudo_polarize( &v );
  478.     v.x = ft_trig_downscale( v.x );
  480.     if ( shift > 0 )
  481.       return ( v.x + ( 1 << ( shift - 1 ) ) ) >> shift;
  483.     return v.x << -shift;
  484.   }
  487.   /* documentation is in fttrigon.h */
  489.   FT_EXPORT_DEF( void )
  490.   FT_Vector_Polarize( FT_Vector*  vec,
  491.                       FT_Fixed   *length,
  492.                       FT_Angle   *angle )
  493.   {
  494.     FT_Int     shift;
  495.     FT_Vector  v;
  498.     v = *vec;
  500.     if ( v.x == 0 && v.y == 0 )
  501.       return;
  503.     shift = ft_trig_prenorm( &v );
  504.     ft_trig_pseudo_polarize( &v );
  506.     v.x = ft_trig_downscale( v.x );
  508.     *length = ( shift >= 0 ) ? ( v.x >> shift ) : ( v.x << -shift );
  509.     *angle  = v.y;
  510.   }
  513.   /* documentation is in fttrigon.h */
  515.   FT_EXPORT_DEF( void )
  516.   FT_Vector_From_Polar( FT_Vector*  vec,
  517.                         FT_Fixed    length,
  518.                         FT_Angle    angle )
  519.   {
  520.     vec->x = length;
  521.     vec->y = 0;
  523.     FT_Vector_Rotate( vec, angle );
  524.   }
  527.   /* documentation is in fttrigon.h */
  529.   FT_EXPORT_DEF( FT_Angle )
  530.   FT_Angle_Diff( FT_Angle  angle1,
  531.                  FT_Angle  angle2 )
  532.   {
  533.     FT_Angle  delta = angle2 - angle1;
  536.     delta %= FT_ANGLE_2PI;
  537.     if ( delta < 0 )
  538.       delta += FT_ANGLE_2PI;
  540.     if ( delta > FT_ANGLE_PI )
  541.       delta -= FT_ANGLE_2PI;
  543.     return delta;
  544.   }
  547. /* END */