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

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

其他游戏

开发平台：

Visual C++

fttypes.h：源码内容
  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*  fttypes.h                                                              */
  4. /*                                                                         */
  5. /*    FreeType simple types definitions (specification only).              */
  6. /*                                                                         */
  7. /*  Copyright 1996-2001, 2002, 2004, 2006, 2007 by                         */
  8. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  9. /*                                                                         */
  10. /*  This file is part of the FreeType project, and may only be used,       */
  11. /*  modified, and distributed under the terms of the FreeType project      */
  12. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13. /*  this file you indicate that you have read the license and              */
  14. /*  understand and accept it fully.                                        */
  15. /*                                                                         */
  16. /***************************************************************************/
  19. #ifndef __FTTYPES_H__
  20. #define __FTTYPES_H__
  23. #include <ft2build.h>
  24. #include FT_CONFIG_CONFIG_H
  25. #include FT_SYSTEM_H
  26. #include FT_IMAGE_H
  28. #include <stddef.h>
  31. FT_BEGIN_HEADER
  34.   /*************************************************************************/
  35.   /*                                                                       */
  36.   /* <Section>                                                             */
  37.   /*    basic_types                                                        */
  38.   /*                                                                       */
  39.   /* <Title>                                                               */
  40.   /*    Basic Data Types                                                   */
  41.   /*                                                                       */
  42.   /* <Abstract>                                                            */
  43.   /*    The basic data types defined by the library.                       */
  44.   /*                                                                       */
  45.   /* <Description>                                                         */
  46.   /*    This section contains the basic data types defined by FreeType 2,  */
  47.   /*    ranging from simple scalar types to bitmap descriptors.  More      */
  48.   /*    font-specific structures are defined in a different section.       */
  49.   /*                                                                       */
  50.   /* <Order>                                                               */
  51.   /*    FT_Byte                                                            */
  52.   /*    FT_Bytes                                                           */
  53.   /*    FT_Char                                                            */
  54.   /*    FT_Int                                                             */
  55.   /*    FT_UInt                                                            */
  56.   /*    FT_Short                                                           */
  57.   /*    FT_UShort                                                          */
  58.   /*    FT_Long                                                            */
  59.   /*    FT_ULong                                                           */
  60.   /*    FT_Bool                                                            */
  61.   /*    FT_Offset                                                          */
  62.   /*    FT_PtrDist                                                         */
  63.   /*    FT_String                                                          */
  64.   /*    FT_Tag                                                             */
  65.   /*    FT_Error                                                           */
  66.   /*    FT_Fixed                                                           */
  67.   /*    FT_Pointer                                                         */
  68.   /*    FT_Pos                                                             */
  69.   /*    FT_Vector                                                          */
  70.   /*    FT_BBox                                                            */
  71.   /*    FT_Matrix                                                          */
  72.   /*    FT_FWord                                                           */
  73.   /*    FT_UFWord                                                          */
  74.   /*    FT_F2Dot14                                                         */
  75.   /*    FT_UnitVector                                                      */
  76.   /*    FT_F26Dot6                                                         */
  77.   /*                                                                       */
  78.   /*                                                                       */
  79.   /*    FT_Generic                                                         */
  80.   /*    FT_Generic_Finalizer                                               */
  81.   /*                                                                       */
  82.   /*    FT_Bitmap                                                          */
  83.   /*    FT_Pixel_Mode                                                      */
  84.   /*    FT_Palette_Mode                                                    */
  85.   /*    FT_Glyph_Format                                                    */
  86.   /*    FT_IMAGE_TAG                                                       */
  87.   /*                                                                       */
  88.   /*************************************************************************/
  91.   /*************************************************************************/
  92.   /*                                                                       */
  93.   /* <Type>                                                                */
  94.   /*    FT_Bool                                                            */
  95.   /*                                                                       */
  96.   /* <Description>                                                         */
  97.   /*    A typedef of unsigned char, used for simple booleans.  As usual,   */
  98.   /*    values 1 and 0 represent true and false, respectively.             */
  99.   /*                                                                       */
  100.   typedef unsigned char  FT_Bool;
  103.   /*************************************************************************/
  104.   /*                                                                       */
  105.   /* <Type>                                                                */
  106.   /*    FT_FWord                                                           */
  107.   /*                                                                       */
  108.   /* <Description>                                                         */
  109.   /*    A signed 16-bit integer used to store a distance in original font  */
  110.   /*    units.                                                             */
  111.   /*                                                                       */
  112.   typedef signed short  FT_FWord;   /* distance in FUnits */
  115.   /*************************************************************************/
  116.   /*                                                                       */
  117.   /* <Type>                                                                */
  118.   /*    FT_UFWord                                                          */
  119.   /*                                                                       */
  120.   /* <Description>                                                         */
  121.   /*    An unsigned 16-bit integer used to store a distance in original    */
  122.   /*    font units.                                                        */
  123.   /*                                                                       */
  124.   typedef unsigned short  FT_UFWord;  /* unsigned distance */
  127.   /*************************************************************************/
  128.   /*                                                                       */
  129.   /* <Type>                                                                */
  130.   /*    FT_Char                                                            */
  131.   /*                                                                       */
  132.   /* <Description>                                                         */
  133.   /*    A simple typedef for the _signed_ char type.                       */
  134.   /*                                                                       */
  135.   typedef signed char  FT_Char;
  138.   /*************************************************************************/
  139.   /*                                                                       */
  140.   /* <Type>                                                                */
  141.   /*    FT_Byte                                                            */
  142.   /*                                                                       */
  143.   /* <Description>                                                         */
  144.   /*    A simple typedef for the _unsigned_ char type.                     */
  145.   /*                                                                       */
  146.   typedef unsigned char  FT_Byte;
  149.   /*************************************************************************/
  150.   /*                                                                       */
  151.   /* <Type>                                                                */
  152.   /*    FT_Bytes                                                           */
  153.   /*                                                                       */
  154.   /* <Description>                                                         */
  155.   /*    A typedef for constant memory areas.                               */
  156.   /*                                                                       */
  157.   typedef const FT_Byte*  FT_Bytes;
  160.   /*************************************************************************/
  161.   /*                                                                       */
  162.   /* <Type>                                                                */
  163.   /*    FT_Tag                                                             */
  164.   /*                                                                       */
  165.   /* <Description>                                                         */
  166.   /*    A typedef for 32bit tags (as used in the SFNT format).             */
  167.   /*                                                                       */
  168.   typedef FT_UInt32  FT_Tag;
  171.   /*************************************************************************/
  172.   /*                                                                       */
  173.   /* <Type>                                                                */
  174.   /*    FT_String                                                          */
  175.   /*                                                                       */
  176.   /* <Description>                                                         */
  177.   /*    A simple typedef for the char type, usually used for strings.      */
  178.   /*                                                                       */
  179.   typedef char  FT_String;
  182.   /*************************************************************************/
  183.   /*                                                                       */
  184.   /* <Type>                                                                */
  185.   /*    FT_Short                                                           */
  186.   /*                                                                       */
  187.   /* <Description>                                                         */
  188.   /*    A typedef for signed short.                                        */
  189.   /*                                                                       */
  190.   typedef signed short  FT_Short;
  193.   /*************************************************************************/
  194.   /*                                                                       */
  195.   /* <Type>                                                                */
  196.   /*    FT_UShort                                                          */
  197.   /*                                                                       */
  198.   /* <Description>                                                         */
  199.   /*    A typedef for unsigned short.                                      */
  200.   /*                                                                       */
  201.   typedef unsigned short  FT_UShort;
  204.   /*************************************************************************/
  205.   /*                                                                       */
  206.   /* <Type>                                                                */
  207.   /*    FT_Int                                                             */
  208.   /*                                                                       */
  209.   /* <Description>                                                         */
  210.   /*    A typedef for the int type.                                        */
  211.   /*                                                                       */
  212.   typedef signed int  FT_Int;
  215.   /*************************************************************************/
  216.   /*                                                                       */
  217.   /* <Type>                                                                */
  218.   /*    FT_UInt                                                            */
  219.   /*                                                                       */
  220.   /* <Description>                                                         */
  221.   /*    A typedef for the unsigned int type.                               */
  222.   /*                                                                       */
  223.   typedef unsigned int  FT_UInt;
  226.   /*************************************************************************/
  227.   /*                                                                       */
  228.   /* <Type>                                                                */
  229.   /*    FT_Long                                                            */
  230.   /*                                                                       */
  231.   /* <Description>                                                         */
  232.   /*    A typedef for signed long.                                         */
  233.   /*                                                                       */
  234.   typedef signed long  FT_Long;
  237.   /*************************************************************************/
  238.   /*                                                                       */
  239.   /* <Type>                                                                */
  240.   /*    FT_ULong                                                           */
  241.   /*                                                                       */
  242.   /* <Description>                                                         */
  243.   /*    A typedef for unsigned long.                                       */
  244.   /*                                                                       */
  245.   typedef unsigned long  FT_ULong;
  248.   /*************************************************************************/
  249.   /*                                                                       */
  250.   /* <Type>                                                                */
  251.   /*    FT_F2Dot14                                                         */
  252.   /*                                                                       */
  253.   /* <Description>                                                         */
  254.   /*    A signed 2.14 fixed float type used for unit vectors.              */
  255.   /*                                                                       */
  256.   typedef signed short  FT_F2Dot14;
  259.   /*************************************************************************/
  260.   /*                                                                       */
  261.   /* <Type>                                                                */
  262.   /*    FT_F26Dot6                                                         */
  263.   /*                                                                       */
  264.   /* <Description>                                                         */
  265.   /*    A signed 26.6 fixed float type used for vectorial pixel            */
  266.   /*    coordinates.                                                       */
  267.   /*                                                                       */
  268.   typedef signed long  FT_F26Dot6;
  271.   /*************************************************************************/
  272.   /*                                                                       */
  273.   /* <Type>                                                                */
  274.   /*    FT_Fixed                                                           */
  275.   /*                                                                       */
  276.   /* <Description>                                                         */
  277.   /*    This type is used to store 16.16 fixed float values, like scaling  */
  278.   /*    values or matrix coefficients.                                     */
  279.   /*                                                                       */
  280.   typedef signed long  FT_Fixed;
  283.   /*************************************************************************/
  284.   /*                                                                       */
  285.   /* <Type>                                                                */
  286.   /*    FT_Error                                                           */
  287.   /*                                                                       */
  288.   /* <Description>                                                         */
  289.   /*    The FreeType error code type.  A value of 0 is always interpreted  */
  290.   /*    as a successful operation.                                         */
  291.   /*                                                                       */
  292.   typedef int  FT_Error;
  295.   /*************************************************************************/
  296.   /*                                                                       */
  297.   /* <Type>                                                                */
  298.   /*    FT_Pointer                                                         */
  299.   /*                                                                       */
  300.   /* <Description>                                                         */
  301.   /*    A simple typedef for a typeless pointer.                           */
  302.   /*                                                                       */
  303.   typedef void*  FT_Pointer;
  306.   /*************************************************************************/
  307.   /*                                                                       */
  308.   /* <Type>                                                                */
  309.   /*    FT_Offset                                                          */
  310.   /*                                                                       */
  311.   /* <Description>                                                         */
  312.   /*    This is equivalent to the ANSI C `size_t' type, i.e., the largest  */
  313.   /*    _unsigned_ integer type used to express a file size or position,   */
  314.   /*    or a memory block size.                                            */
  315.   /*                                                                       */
  316.   typedef size_t  FT_Offset;
  319.   /*************************************************************************/
  320.   /*                                                                       */
  321.   /* <Type>                                                                */
  322.   /*    FT_PtrDist                                                         */
  323.   /*                                                                       */
  324.   /* <Description>                                                         */
  325.   /*    This is equivalent to the ANSI C `ptrdiff_t' type, i.e., the       */
  326.   /*    largest _signed_ integer type used to express the distance         */
  327.   /*    between two pointers.                                              */
  328.   /*                                                                       */
  329.   typedef ft_ptrdiff_t  FT_PtrDist;
  332.   /*************************************************************************/
  333.   /*                                                                       */
  334.   /* <Struct>                                                              */
  335.   /*    FT_UnitVector                                                      */
  336.   /*                                                                       */
  337.   /* <Description>                                                         */
  338.   /*    A simple structure used to store a 2D vector unit vector.  Uses    */
  339.   /*    FT_F2Dot14 types.                                                  */
  340.   /*                                                                       */
  341.   /* <Fields>                                                              */
  342.   /*    x :: Horizontal coordinate.                                        */
  343.   /*                                                                       */
  344.   /*    y :: Vertical coordinate.                                          */
  345.   /*                                                                       */
  346.   typedef struct  FT_UnitVector_
  347.   {
  348.     FT_F2Dot14  x;
  349.     FT_F2Dot14  y;
  351.   } FT_UnitVector;
  354.   /*************************************************************************/
  355.   /*                                                                       */
  356.   /* <Struct>                                                              */
  357.   /*    FT_Matrix                                                          */
  358.   /*                                                                       */
  359.   /* <Description>                                                         */
  360.   /*    A simple structure used to store a 2x2 matrix.  Coefficients are   */
  361.   /*    in 16.16 fixed float format.  The computation performed is:        */
  362.   /*                                                                       */
  363.   /*       {                                                               */
  364.   /*          x' = x*xx + y*xy                                             */
  365.   /*          y' = x*yx + y*yy                                             */
  366.   /*       }                                                               */
  367.   /*                                                                       */
  368.   /* <Fields>                                                              */
  369.   /*    xx :: Matrix coefficient.                                          */
  370.   /*                                                                       */
  371.   /*    xy :: Matrix coefficient.                                          */
  372.   /*                                                                       */
  373.   /*    yx :: Matrix coefficient.                                          */
  374.   /*                                                                       */
  375.   /*    yy :: Matrix coefficient.                                          */
  376.   /*                                                                       */
  377.   typedef struct  FT_Matrix_
  378.   {
  379.     FT_Fixed  xx, xy;
  380.     FT_Fixed  yx, yy;
  382.   } FT_Matrix;
  385.   /*************************************************************************/
  386.   /*                                                                       */
  387.   /* <Struct>                                                              */
  388.   /*    FT_Data                                                            */
  389.   /*                                                                       */
  390.   /* <Description>                                                         */
  391.   /*    Read-only binary data represented as a pointer and a length.       */
  392.   /*                                                                       */
  393.   /* <Fields>                                                              */
  394.   /*    pointer :: The data.                                               */
  395.   /*                                                                       */
  396.   /*    length  :: The length of the data in bytes.                        */
  397.   /*                                                                       */
  398.   typedef struct  FT_Data_
  399.   {
  400.     const FT_Byte*  pointer;
  401.     FT_Int          length;
  403.   } FT_Data;
  406.   /*************************************************************************/
  407.   /*                                                                       */
  408.   /* <FuncType>                                                            */
  409.   /*    FT_Generic_Finalizer                                               */
  410.   /*                                                                       */
  411.   /* <Description>                                                         */
  412.   /*    Describes a function used to destroy the `client' data of any      */
  413.   /*    FreeType object.  See the description of the @FT_Generic type for  */
  414.   /*    details of usage.                                                  */
  415.   /*                                                                       */
  416.   /* <Input>                                                               */
  417.   /*    The address of the FreeType object which is under finalization.    */
  418.   /*    Its client data is accessed through its `generic' field.           */
  419.   /*                                                                       */
  420.   typedef void  (*FT_Generic_Finalizer)(void*  object);
  423.   /*************************************************************************/
  424.   /*                                                                       */
  425.   /* <Struct>                                                              */
  426.   /*    FT_Generic                                                         */
  427.   /*                                                                       */
  428.   /* <Description>                                                         */
  429.   /*    Client applications often need to associate their own data to a    */
  430.   /*    variety of FreeType core objects.  For example, a text layout API  */
  431.   /*    might want to associate a glyph cache to a given size object.      */
  432.   /*                                                                       */
  433.   /*    Most FreeType object contains a `generic' field, of type           */
  434.   /*    FT_Generic, which usage is left to client applications and font    */
  435.   /*    servers.                                                           */
  436.   /*                                                                       */
  437.   /*    It can be used to store a pointer to client-specific data, as well */
  438.   /*    as the address of a `finalizer' function, which will be called by  */
  439.   /*    FreeType when the object is destroyed (for example, the previous   */
  440.   /*    client example would put the address of the glyph cache destructor */
  441.   /*    in the `finalizer' field).                                         */
  442.   /*                                                                       */
  443.   /* <Fields>                                                              */
  444.   /*    data      :: A typeless pointer to any client-specified data. This */
  445.   /*                 field is completely ignored by the FreeType library.  */
  446.   /*                                                                       */
  447.   /*    finalizer :: A pointer to a `generic finalizer' function, which    */
  448.   /*                 will be called when the object is destroyed.  If this */
  449.   /*                 field is set to NULL, no code will be called.         */
  450.   /*                                                                       */
  451.   typedef struct  FT_Generic_
  452.   {
  453.     void*                 data;
  454.     FT_Generic_Finalizer  finalizer;
  456.   } FT_Generic;
  459.   /*************************************************************************/
  460.   /*                                                                       */
  461.   /* <Macro>                                                               */
  462.   /*    FT_MAKE_TAG                                                        */
  463.   /*                                                                       */
  464.   /* <Description>                                                         */
  465.   /*    This macro converts four-letter tags which are used to label       */
  466.   /*    TrueType tables into an unsigned long to be used within FreeType.  */
  467.   /*                                                                       */
  468.   /* <Note>                                                                */
  469.   /*    The produced values *must* be 32bit integers.  Don't redefine this */
  470.   /*    macro.                                                             */
  471.   /*                                                                       */
  472. #define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) 
  473.           ( ( (FT_ULong)_x1 << 24 ) |     
  474.             ( (FT_ULong)_x2 << 16 ) |     
  475.             ( (FT_ULong)_x3 <<  8 ) |     
  476.               (FT_ULong)_x4         )
  479.   /*************************************************************************/
  480.   /*************************************************************************/
  481.   /*                                                                       */
  482.   /*                    L I S T   M A N A G E M E N T                      */
  483.   /*                                                                       */
  484.   /*************************************************************************/
  485.   /*************************************************************************/
  488.   /*************************************************************************/
  489.   /*                                                                       */
  490.   /* <Section>                                                             */
  491.   /*    list_processing                                                    */
  492.   /*                                                                       */
  493.   /*************************************************************************/
  496.   /*************************************************************************/
  497.   /*                                                                       */
  498.   /* <Type>                                                                */
  499.   /*    FT_ListNode                                                        */
  500.   /*                                                                       */
  501.   /* <Description>                                                         */
  502.   /*     Many elements and objects in FreeType are listed through an       */
  503.   /*     @FT_List record (see @FT_ListRec).  As its name suggests, an      */
  504.   /*     FT_ListNode is a handle to a single list element.                 */
  505.   /*                                                                       */
  506.   typedef struct FT_ListNodeRec_*  FT_ListNode;
  509.   /*************************************************************************/
  510.   /*                                                                       */
  511.   /* <Type>                                                                */
  512.   /*    FT_List                                                            */
  513.   /*                                                                       */
  514.   /* <Description>                                                         */
  515.   /*    A handle to a list record (see @FT_ListRec).                       */
  516.   /*                                                                       */
  517.   typedef struct FT_ListRec_*  FT_List;
  520.   /*************************************************************************/
  521.   /*                                                                       */
  522.   /* <Struct>                                                              */
  523.   /*    FT_ListNodeRec                                                     */
  524.   /*                                                                       */
  525.   /* <Description>                                                         */
  526.   /*    A structure used to hold a single list element.                    */
  527.   /*                                                                       */
  528.   /* <Fields>                                                              */
  529.   /*    prev :: The previous element in the list.  NULL if first.          */
  530.   /*                                                                       */
  531.   /*    next :: The next element in the list.  NULL if last.               */
  532.   /*                                                                       */
  533.   /*    data :: A typeless pointer to the listed object.                   */
  534.   /*                                                                       */
  535.   typedef struct  FT_ListNodeRec_
  536.   {
  537.     FT_ListNode  prev;
  538.     FT_ListNode  next;
  539.     void*        data;
  541.   } FT_ListNodeRec;
  544.   /*************************************************************************/
  545.   /*                                                                       */
  546.   /* <Struct>                                                              */
  547.   /*    FT_ListRec                                                         */
  548.   /*                                                                       */
  549.   /* <Description>                                                         */
  550.   /*    A structure used to hold a simple doubly-linked list.  These are   */
  551.   /*    used in many parts of FreeType.                                    */
  552.   /*                                                                       */
  553.   /* <Fields>                                                              */
  554.   /*    head :: The head (first element) of doubly-linked list.            */
  555.   /*                                                                       */
  556.   /*    tail :: The tail (last element) of doubly-linked list.             */
  557.   /*                                                                       */
  558.   typedef struct  FT_ListRec_
  559.   {
  560.     FT_ListNode  head;
  561.     FT_ListNode  tail;
  563.   } FT_ListRec;
  566.   /* */
  568. #define FT_IS_EMPTY( list )  ( (list).head == 0 )
  570.   /* return base error code (without module-specific prefix) */
  571. #define FT_ERROR_BASE( x )    ( (x) & 0xFF )
  573.   /* return module error code */
  574. #define FT_ERROR_MODULE( x )  ( (x) & 0xFF00U )
  576. #define FT_BOOL( x )  ( (FT_Bool)( x ) )
  578. FT_END_HEADER
  580. #endif /* __FTTYPES_H__ */
  583. /* END */