SHARE
TWEET

gx2Enum.h

a guest Aug 6th, 2014 1,157 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // gx2Enum.h
  2. //
  3. // Declares enums for gx2 library.
  4.  
  5. #ifndef _CAFE_GX2_ENUM_H_
  6. #define _CAFE_GX2_ENUM_H_
  7.  
  8. #ifdef __cplusplus
  9. extern "C"
  10. {
  11. #endif // __cplusplus
  12.  
  13. #if defined _WIN32 || defined _WIN64
  14. #include <assert.h>
  15. #include <string.h>
  16. #ifndef ASSERT
  17. #define ASSERT  assert
  18. #endif // ASSERT
  19. #ifndef GX2_INLINE
  20. #define GX2_INLINE inline
  21. #endif // GX2_INLINE
  22. #else
  23. #ifndef GX2_INLINE
  24. #define GX2_INLINE static inline
  25. #endif // GX2_INLINE
  26. #endif // _WIN32 || defined _WIN64
  27.  
  28. // This define is used as a tag to mark function prototypes that
  29. // are exported from gx2.rpl.
  30. #define GX2API
  31.  
  32. #define GX2_CHECK_ENUM_RANGE(value, type) \
  33.     ASSERT(value>=type##_FIRST && value<=type##_LAST);
  34.  
  35. /*
  36.  * These are aliases for the MOV enums which are deprecated
  37.  */
  38. #define GX2MOVMode                      GX2DRCMode
  39. #define GX2_MOV_NONE                    GX2_DRC_NONE
  40. #define GX2_MOV_SINGLE                  GX2_DRC_SINGLE
  41. #define GX2_MOV_DOUBLE                  GX2_DRC_DOUBLE
  42. #define GX2_MOV_FIRST                   GX2_DRC_FIRST
  43. #define GX2_MOV_LAST                    GX2_DRC_LAST
  44. #define GX2_SCAN_TARGET_MOV_FIRST       GX2_SCAN_TARGET_DRC_FIRST
  45. #define GX2_SCAN_TARGET_MOV_SECOND      GX2_SCAN_TARGET_DRC_SECOND
  46.  
  47. /// @addtogroup GX2EnumGroup
  48. /// @{
  49.  
  50. // -----------------------------------------------------------------------------
  51. // Enums - general
  52.  
  53. /// \brief GX2's version of bool-type values.
  54. ///
  55. typedef enum _GX2Boolean
  56. {
  57.     GX2_FALSE                      = 0,
  58.     GX2_TRUE                       = 1,
  59.     GX2_DISABLE                    = 0,
  60.     GX2_ENABLE                     = 1
  61. } GX2Boolean;
  62.  
  63. /// \brief GX2's initialize attributes
  64. ///
  65. typedef enum _GX2InitAttrib {
  66.     GX2_INIT_ATTRIB_NULL,              ///< list terminator
  67.     GX2_INIT_ATTRIB_CB_BASE,           ///< command buffer pool base address
  68.     GX2_INIT_ATTRIB_CB_SIZE,           ///< command buffer pool size
  69.     GX2_INIT_ATTRIB_UDA_LEVEL,         ///< (Temporary Placeholder) set uda alert level
  70.     GX2_INIT_ATTRIB_UDA_TESTMODE,      ///< (Temporary Placeholder) enable uda test mode
  71.     GX2_INIT_ATTRIB_UDA_DISABLE_ALERT, ///< (Temporary Placeholder) disable specific uda alert
  72.     GX2_INIT_ATTRIB_UDA_MAXFIRECOUNT,  ///< (Temporary Placeholder) max number of times an alert will be reported
  73.     GX2_INIT_ATTRIB_ARGC,              ///< argc from main()
  74.     GX2_INIT_ATTRIB_ARGV,              ///< argv from main()
  75.     GX2_INIT_ATTRIB_PROFILE_MODE,      ///< Profiling mode
  76.     GX2_INIT_ATTRIB_TOSS_STAGE,        ///< Toss stage
  77.     GX2_INIT_ATTRIB_LAST = GX2_INIT_ATTRIB_TOSS_STAGE
  78. } GX2InitAttrib;
  79.  
  80. // -----------------------------------------------------------------------------
  81. // Enums - Render State
  82.  
  83. /// \brief Describes the vertex order of front-facing polygons.
  84. ///
  85. typedef enum _GX2FrontFaceMode
  86. {
  87.     GX2_FRONT_FACE_CCW             = 0,
  88.     GX2_FRONT_FACE_CW              = 1,
  89.     GX2_FRONT_FACE_FIRST           = GX2_FRONT_FACE_CCW,
  90.     GX2_FRONT_FACE_LAST            = GX2_FRONT_FACE_CW
  91. } GX2FrontFaceMode;
  92.  
  93. /// \brief When dual-sided polygon mode is enabled, describes the
  94. /// base primitive used to draw each side of the polygon.
  95. ///
  96. typedef enum _GX2PolygonMode
  97. {
  98.     GX2_POLYGON_MODE_POINT         = 0,
  99.     GX2_POLYGON_MODE_LINE          = 1,
  100.     GX2_POLYGON_MODE_TRIANGLE      = 2,
  101.     GX2_POLYGON_MODE_FIRST         = GX2_POLYGON_MODE_POINT,
  102.     GX2_POLYGON_MODE_LAST          = GX2_POLYGON_MODE_TRIANGLE
  103. } GX2PolygonMode;
  104.  
  105. /// \brief Compare function used for depth & stencil tests.
  106. ///
  107. typedef enum _GX2CompareFunction
  108. {
  109.     GX2_COMPARE_NEVER              = 0,
  110.     GX2_COMPARE_LESS               = 1,
  111.     GX2_COMPARE_EQUAL              = 2,
  112.     GX2_COMPARE_LEQUAL             = 3,
  113.     GX2_COMPARE_GREATER            = 4,
  114.     GX2_COMPARE_NOTEQUAL           = 5,
  115.     GX2_COMPARE_GEQUAL             = 6,
  116.     GX2_COMPARE_ALWAYS             = 7,
  117.     GX2_COMPARE_FIRST              = GX2_COMPARE_NEVER,
  118.     GX2_COMPARE_LAST               = GX2_COMPARE_ALWAYS
  119. } GX2CompareFunction;
  120.  
  121. /// \brief Stencil function to be performed if stencil tests pass.
  122. ///
  123. typedef enum _GX2StencilFunction
  124. {
  125.     GX2_STENCIL_KEEP               = 0,
  126.     GX2_STENCIL_ZERO               = 1,
  127.     GX2_STENCIL_REPLACE            = 2,
  128.     GX2_STENCIL_INCR               = 3,
  129.     GX2_STENCIL_DECR               = 4,
  130.     GX2_STENCIL_INVERT             = 5,
  131.     GX2_STENCIL_INCR_WRAP          = 6,
  132.     GX2_STENCIL_DECR_WRAP          = 7,
  133.     GX2_STENCIL_FIRST              = GX2_STENCIL_KEEP,
  134.     GX2_STENCIL_LAST               = GX2_STENCIL_DECR_WRAP
  135. } GX2StencilFunction;
  136.  
  137. /// \brief RGBA color channel mask values.
  138. ///
  139. typedef enum _GX2ChannelMask
  140. {
  141.     GX2_CHANNEL_MASK_NONE          = 0x0, ///< 0000
  142.     GX2_CHANNEL_MASK_R             = 0x1, ///< 0001
  143.     GX2_CHANNEL_MASK_G             = 0x2, ///< 0010
  144.     GX2_CHANNEL_MASK_RG            = 0x3, ///< 0011
  145.     GX2_CHANNEL_MASK_B             = 0x4, ///< 0100
  146.     GX2_CHANNEL_MASK_RB            = 0x5, ///< 0101
  147.     GX2_CHANNEL_MASK_GB            = 0x6, ///< 0110
  148.     GX2_CHANNEL_MASK_RGB           = 0x7, ///< 0111
  149.     GX2_CHANNEL_MASK_A             = 0x8, ///< 1000
  150.     GX2_CHANNEL_MASK_RA            = 0x9, ///< 1001
  151.     GX2_CHANNEL_MASK_GA            = 0xA, ///< 1010
  152.     GX2_CHANNEL_MASK_RGA           = 0xB, ///< 1011
  153.     GX2_CHANNEL_MASK_BA            = 0xC, ///< 1100
  154.     GX2_CHANNEL_MASK_RBA           = 0xD, ///< 1101
  155.     GX2_CHANNEL_MASK_GBA           = 0xE, ///< 1110
  156.     GX2_CHANNEL_MASK_RGBA          = 0xF, ///< 1111
  157.     GX2_CHANNEL_MASK_FIRST         = GX2_CHANNEL_MASK_NONE,
  158.     GX2_CHANNEL_MASK_LAST          = GX2_CHANNEL_MASK_RGBA
  159. } GX2ChannelMask;
  160.  
  161. /// \brief Describes the logic op function to perform.
  162. ///
  163. /// \note  Always specify GX2_LOGIC_OP_COPY when logic op is not used.
  164. ///
  165. typedef enum _GX2LogicOp
  166. {
  167.     GX2_LOGIC_OP_CLEAR             = 0x00, ///<   0x00 (BLACKNESS)
  168.     GX2_LOGIC_OP_SET               = 0xFF, ///<   0xff (WHITNESS)
  169.     GX2_LOGIC_OP_COPY              = 0xCC, ///<   Source (Default)
  170.     GX2_LOGIC_OP_INVCOPY           = 0x33, ///<  ~Source
  171.     GX2_LOGIC_OP_NOOP              = 0xAA, ///<   Destination
  172.     GX2_LOGIC_OP_INV               = 0x55, ///<  ~Destination
  173.     GX2_LOGIC_OP_AND               = 0x88, ///<   Source  &  Destination
  174.     GX2_LOGIC_OP_NAND              = 0x77, ///< ~(Source  &  Destination)
  175.     GX2_LOGIC_OP_OR                = 0xEE, ///<   Source  |  Destination
  176.     GX2_LOGIC_OP_NOR               = 0x11, ///< ~(Source  |  Destination)
  177.     GX2_LOGIC_OP_XOR               = 0x66, ///<   Source  ^  Destination
  178.     GX2_LOGIC_OP_EQUIV             = 0x99, ///< ~(Source  ^  Destination)
  179.     GX2_LOGIC_OP_REVAND            = 0x44, ///<   Source  & ~Destination
  180.     GX2_LOGIC_OP_INVAND            = 0x22, ///<  ~Source  &  Destination
  181.     GX2_LOGIC_OP_REVOR             = 0xDD, ///<   Source  | ~Destination
  182.     GX2_LOGIC_OP_INVOR             = 0xBB, ///<  ~Source  |  Destination
  183.  
  184.     GX2_LOGIC_OP_NONE = GX2_LOGIC_OP_COPY, ///< Useful synonym
  185.     GX2_LOGIC_OP_FIRST             = GX2_LOGIC_OP_CLEAR,
  186.     GX2_LOGIC_OP_LAST              = GX2_LOGIC_OP_SET
  187. } GX2LogicOp;
  188.  
  189. /// \brief Describes the factors used in the blend function.
  190. ///
  191. /// In the descriptions below, the first column describes color blend
  192. /// functions, while the second column describes alpha blend functions.
  193. /// The codes are:
  194. /// - s0 = source 0
  195. /// - s1 = source 1 (see note below)
  196. /// - d  = destination
  197. /// - c  = constant
  198. /// - f  = min(s0:A, 1-d:A).
  199. ///
  200. /// \note Using source 1 implies dual-source blending.  This is
  201. ///       mutually exclusive with MRTs.  It is also not compatible
  202. ///       with multiwriteEnable (\ref GX2SetColorControl).
  203. ///       It requires a pixel shader with 2 color output channels
  204. ///       (gl_FragData[0] and gl_FragData[1]).
  205. ///
  206. typedef enum _GX2BlendFunction
  207. {
  208.     GX2_BLEND_ZERO                     = 0,  ///<    (0,0,0)       |    (0)
  209.     GX2_BLEND_ONE                      = 1,  ///<    (1,1,1)       |    (1)
  210.     GX2_BLEND_SRC_COLOR                = 2,  ///< s0:(R,G,B)       | s0:(A)
  211.     GX2_BLEND_ONE_MINUS_SRC_COLOR      = 3,  ///< s0:(1-R,1-G,1-B) | s0:(1-A)
  212.     GX2_BLEND_SRC_ALPHA                = 4,  ///< s0:(A,A,A)       | s0:(A)
  213.     GX2_BLEND_ONE_MINUS_SRC_ALPHA      = 5,  ///< s0:(1-A,1-A,1-A) | s0:(1-A)
  214.     GX2_BLEND_DST_ALPHA                = 6,  ///< d :(A,A,A)       | d :(A)
  215.     GX2_BLEND_ONE_MINUS_DST_ALPHA      = 7,  ///< d :(1-A,1-A,1-A) | d :(1-A)
  216.     GX2_BLEND_DST_COLOR                = 8,  ///< d :(R,G,B)       | d :(A)
  217.     GX2_BLEND_ONE_MINUS_DST_COLOR      = 9,  ///< d :(1-R,1-G,1-B) | d :(1-A)
  218.     GX2_BLEND_SRC_ALPHA_SATURATE       = 10, ///<    (f,f,f)       |    (1)
  219.     GX2_BLEND_CONSTANT_COLOR           = 13, ///< c :(R,G,B)       | c :(A)
  220.     GX2_BLEND_ONE_MINUS_CONSTANT_COLOR = 14, ///< c :(1-R,1-G,1-B) | c :(1-A)
  221.     GX2_BLEND_SRC1_COLOR               = 15, ///< s1:(R,G,B)       | s1:(A)
  222.     GX2_BLEND_ONE_MINUS_SRC1_COLOR     = 16, ///< s1:(1-R,1-G,1-B) | s1:(1-A)
  223.     GX2_BLEND_SRC1_ALPHA               = 17, ///< s1:(A,A,A)       | s1:(A)
  224.     GX2_BLEND_ONE_MINUS_SRC1_ALPHA     = 18, ///< s1:(1-A,1-A,1-A) | s1:(1-A)
  225.     GX2_BLEND_CONSTANT_ALPHA           = 19, ///< c :(A,A,A)       | c :(A)
  226.     GX2_BLEND_ONE_MINUS_CONSTANT_ALPHA = 20, ///< c :(1-A,1-A,1-A) | c :(1-A)
  227.     GX2_BLEND_FIRST                    = GX2_BLEND_ZERO,
  228.     GX2_BLEND_LAST                     = GX2_BLEND_ONE_MINUS_CONSTANT_ALPHA
  229. } GX2BlendFunction;
  230.  
  231. /// \brief Describes how the terms of the blend function are combined.
  232. ///
  233. typedef enum _GX2BlendCombine
  234. {
  235.     GX2_BLEND_COMBINE_ADD              = 0,
  236.     GX2_BLEND_COMBINE_SRC_MINUS_DST    = 1,
  237.     GX2_BLEND_COMBINE_MIN              = 2,
  238.     GX2_BLEND_COMBINE_MAX              = 3,
  239.     GX2_BLEND_COMBINE_DST_MINUS_SRC    = 4,
  240.     GX2_BLEND_COMBINE_FIRST            = GX2_BLEND_COMBINE_ADD,
  241.     GX2_BLEND_COMBINE_LAST             = GX2_BLEND_COMBINE_DST_MINUS_SRC
  242. } GX2BlendCombine;
  243.  
  244. /// \brief Used to tweak the AlphaToMask operation.
  245. ///
  246. typedef enum _GX2AlphaToMaskMode
  247. {
  248.     GX2_ALPHA_TO_MASK_0                = 0, ///< non-dithered
  249.     GX2_ALPHA_TO_MASK_1                = 1, ///< dithered, rotation 0
  250.     GX2_ALPHA_TO_MASK_2                = 2, ///< dithered, rotation 90
  251.     GX2_ALPHA_TO_MASK_3                = 3, ///< dithered, rotation 180
  252.     GX2_ALPHA_TO_MASK_4                = 4, ///< dithered, rotation 270
  253.     GX2_ALPHA_TO_MASK_FIRST            = GX2_ALPHA_TO_MASK_0,
  254.     GX2_ALPHA_TO_MASK_LAST             = GX2_ALPHA_TO_MASK_4
  255. } GX2AlphaToMaskMode;
  256.  
  257. /// \brief Used to specify a destination render target.
  258. ///
  259. typedef enum _GX2RenderTarget
  260. {
  261.     GX2_RENDER_TARGET_0                = 0,
  262.     GX2_RENDER_TARGET_1                = 1,
  263.     GX2_RENDER_TARGET_2                = 2,
  264.     GX2_RENDER_TARGET_3                = 3,
  265.     GX2_RENDER_TARGET_4                = 4,
  266.     GX2_RENDER_TARGET_5                = 5,
  267.     GX2_RENDER_TARGET_6                = 6,
  268.     GX2_RENDER_TARGET_7                = 7,
  269.     GX2_RENDER_TARGET_FIRST            = GX2_RENDER_TARGET_0,
  270.     GX2_RENDER_TARGET_LAST             = GX2_RENDER_TARGET_7
  271. } GX2RenderTarget;
  272.  
  273. // -----------------------------------------------------------------------------
  274. // Enums - Vertex Streams
  275.  
  276. /// \brief Describes the overall format of a vertex attribute entry.
  277. ///
  278. /// Please refer to \ref GX2FormatPage for more details.
  279. ///
  280. /// Type conversion options:
  281. /// - UNORM : attrib unsigned integer is converted to/from [0.0, 1.0] in shader
  282. /// - UINT  : attrib unsigned integer is copied to/from shader as unsigned int
  283. /// - SNORM : attrib signed integer is converted to/from [-1.0, 1.0] in shader
  284. /// - SINT  : attrib signed integer is copied to/from shader as signed int
  285. /// - FLOAT : attrib float is copied to/from shader as float
  286. /// - UINT_TO_FLOAT : attrib unsigned integer is converted float in shader
  287. /// - SINT_TO_FLOAT : attrib signed integer is converted float in shader
  288. /// (32 bit integers cannot be converted to float during fetch)
  289. typedef enum _GX2AttribFormat
  290. {
  291.   // 8 bits (8 x 1):
  292.     GX2_ATTRIB_FORMAT_8_UNORM             = 0x00000000,
  293.     GX2_ATTRIB_FORMAT_8_UINT              = 0x00000100,
  294.     GX2_ATTRIB_FORMAT_8_SNORM             = 0x00000200,
  295.     GX2_ATTRIB_FORMAT_8_SINT              = 0x00000300,
  296.     GX2_ATTRIB_FORMAT_8_UINT_TO_FLOAT     = 0x00000800,
  297.     GX2_ATTRIB_FORMAT_8_SINT_TO_FLOAT     = 0x00000a00,
  298.   // 8 bits (4 x 2):
  299.     GX2_ATTRIB_FORMAT_4_4_UNORM           = 0x00000001,
  300.   // 16 bits (16 x 1):
  301.     GX2_ATTRIB_FORMAT_16_UNORM            = 0x00000002,
  302.     GX2_ATTRIB_FORMAT_16_UINT             = 0x00000102,
  303.     GX2_ATTRIB_FORMAT_16_SNORM            = 0x00000202,
  304.     GX2_ATTRIB_FORMAT_16_SINT             = 0x00000302,
  305.     GX2_ATTRIB_FORMAT_16_FLOAT            = 0x00000803,
  306.     GX2_ATTRIB_FORMAT_16_UINT_TO_FLOAT    = 0x00000802,
  307.     GX2_ATTRIB_FORMAT_16_SINT_TO_FLOAT    = 0x00000a02,
  308.   // 16 bits (8 x 2):
  309.     GX2_ATTRIB_FORMAT_8_8_UNORM           = 0x00000004,
  310.     GX2_ATTRIB_FORMAT_8_8_UINT            = 0x00000104,
  311.     GX2_ATTRIB_FORMAT_8_8_SNORM           = 0x00000204,
  312.     GX2_ATTRIB_FORMAT_8_8_SINT            = 0x00000304,
  313.     GX2_ATTRIB_FORMAT_8_8_UINT_TO_FLOAT   = 0x00000804,
  314.     GX2_ATTRIB_FORMAT_8_8_SINT_TO_FLOAT   = 0x00000a04,
  315.   // 32 bits (32 x 1):
  316.     GX2_ATTRIB_FORMAT_32_UINT             = 0x00000105,
  317.     GX2_ATTRIB_FORMAT_32_SINT             = 0x00000305,
  318.     GX2_ATTRIB_FORMAT_32_FLOAT            = 0x00000806,
  319.   // 32 bits (16 x 2):
  320.     GX2_ATTRIB_FORMAT_16_16_UNORM         = 0x00000007,
  321.     GX2_ATTRIB_FORMAT_16_16_UINT          = 0x00000107,
  322.     GX2_ATTRIB_FORMAT_16_16_SNORM         = 0x00000207,
  323.     GX2_ATTRIB_FORMAT_16_16_SINT          = 0x00000307,
  324.     GX2_ATTRIB_FORMAT_16_16_FLOAT         = 0x00000808,
  325.     GX2_ATTRIB_FORMAT_16_16_UINT_TO_FLOAT = 0x00000807,
  326.     GX2_ATTRIB_FORMAT_16_16_SINT_TO_FLOAT = 0x00000a07,
  327.   // 32 bits (10/11 x 3):
  328.     GX2_ATTRIB_FORMAT_10_11_11_FLOAT      = 0x00000809,
  329.   // 32 bits (8 x 4):
  330.     GX2_ATTRIB_FORMAT_8_8_8_8_UNORM         = 0x0000000a,
  331.     GX2_ATTRIB_FORMAT_8_8_8_8_UINT          = 0x0000010a,
  332.     GX2_ATTRIB_FORMAT_8_8_8_8_SNORM         = 0x0000020a,
  333.     GX2_ATTRIB_FORMAT_8_8_8_8_SINT          = 0x0000030a,
  334.     GX2_ATTRIB_FORMAT_8_8_8_8_UINT_TO_FLOAT = 0x0000080a,
  335.     GX2_ATTRIB_FORMAT_8_8_8_8_SINT_TO_FLOAT = 0x00000a0a,
  336.   // 32 bits (10 x 3 + 2):
  337.     GX2_ATTRIB_FORMAT_10_10_10_2_UNORM      = 0x0000000b,
  338.     GX2_ATTRIB_FORMAT_10_10_10_2_UINT       = 0x0000010b,
  339.     GX2_ATTRIB_FORMAT_10_10_10_2_SNORM      = 0x0000020b, // "2" part is UNORM
  340.     GX2_ATTRIB_FORMAT_10_10_10_2_SINT       = 0x0000030b,
  341.   // 64 bits (32 x 2):
  342.     GX2_ATTRIB_FORMAT_32_32_UINT            = 0x0000010c,
  343.     GX2_ATTRIB_FORMAT_32_32_SINT            = 0x0000030c,
  344.     GX2_ATTRIB_FORMAT_32_32_FLOAT           = 0x0000080d,
  345.   // 64 bits (16 x 4):
  346.     GX2_ATTRIB_FORMAT_16_16_16_16_UNORM         = 0x0000000e,
  347.     GX2_ATTRIB_FORMAT_16_16_16_16_UINT          = 0x0000010e,
  348.     GX2_ATTRIB_FORMAT_16_16_16_16_SNORM         = 0x0000020e,
  349.     GX2_ATTRIB_FORMAT_16_16_16_16_SINT          = 0x0000030e,
  350.     GX2_ATTRIB_FORMAT_16_16_16_16_FLOAT         = 0x0000080f,
  351.     GX2_ATTRIB_FORMAT_16_16_16_16_UINT_TO_FLOAT = 0x0000080e,
  352.     GX2_ATTRIB_FORMAT_16_16_16_16_SINT_TO_FLOAT = 0x00000a0e,
  353.   // 96 bits (32 x 3):
  354.     GX2_ATTRIB_FORMAT_32_32_32_UINT             = 0x00000110,
  355.     GX2_ATTRIB_FORMAT_32_32_32_SINT             = 0x00000310,
  356.     GX2_ATTRIB_FORMAT_32_32_32_FLOAT            = 0x00000811,
  357.   // 128 bits (32 x 4):
  358.     GX2_ATTRIB_FORMAT_32_32_32_32_UINT          = 0x00000112,
  359.     GX2_ATTRIB_FORMAT_32_32_32_32_SINT          = 0x00000312,
  360.     GX2_ATTRIB_FORMAT_32_32_32_32_FLOAT         = 0x00000813,
  361.   //
  362.     GX2_ATTRIB_FORMAT_FIRST = GX2_ATTRIB_FORMAT_8_UNORM,
  363.     GX2_ATTRIB_FORMAT_LAST  = GX2_ATTRIB_FORMAT_16_16_16_16_SINT_TO_FLOAT
  364. } GX2AttribFormat;
  365.  
  366. /// \brief Describes the index used to look up vertex attributes.
  367. ///
  368. typedef enum _GX2AttribIndexType
  369. {
  370.     /// per-vertex index
  371.     GX2_ATTRIB_INDEX_VERTEX_ID             = 0x00000000,
  372.     /// per-instance index
  373.     GX2_ATTRIB_INDEX_INSTANCE_ID           = 0x00000001,
  374.     GX2_ATTRIB_INDEX_FIRST                 = GX2_ATTRIB_INDEX_VERTEX_ID,
  375.     GX2_ATTRIB_INDEX_LAST                  = GX2_ATTRIB_INDEX_INSTANCE_ID
  376. } GX2AttribIndexType;
  377.  
  378. /// \brief Used to control attribute and texture component swizzling
  379. /// as well as specifying values for elements not present in the format.
  380. ///
  381. typedef enum _GX2Component
  382. {
  383.     GX2_COMPONENT_X_R             = 0x00000000, // X or red
  384.     GX2_COMPONENT_Y_G             = 0x00000001, // Y or green
  385.     GX2_COMPONENT_Z_B             = 0x00000002, // Z or blue
  386.     GX2_COMPONENT_W_A             = 0x00000003, // W or alpha
  387.     GX2_COMPONENT_C_0             = 0x00000004, // constant 0
  388.     GX2_COMPONENT_C_1             = 0x00000005, // constant 1
  389.     GX2_COMPONENT_FIRST           = GX2_COMPONENT_X_R,
  390.     GX2_COMPONENT_LAST            = GX2_COMPONENT_C_1
  391. } GX2Component;
  392.  
  393. // -----------------------------------------------------------------------------
  394. // Enums - Shaders
  395.  
  396. /// \brief Used to indicate the desired shader mode of operation
  397. ///
  398. /// \note: Changing the mode invokes a full pipeline flush (affects performance)
  399. /// \note: GX2_SHADER_MODE_GEOMETRY_SHADER - Enable full geometry shader support.
  400. ///        When this mode is enabled UNIFORM_BLOCKS will automatically be enabled.
  401. typedef enum _GX2ShaderMode
  402. {
  403.     GX2_SHADER_MODE_UNIFORM_REGISTER,
  404.     GX2_SHADER_MODE_UNIFORM_BLOCK,
  405.     GX2_SHADER_MODE_GEOMETRY_SHADER,
  406.     GX2_SHADER_MODE_FIRST               = GX2_SHADER_MODE_UNIFORM_REGISTER,
  407.     GX2_SHADER_MODE_LAST                = GX2_SHADER_MODE_GEOMETRY_SHADER
  408. } GX2ShaderMode;
  409.  
  410. /// \brief Type for shader variables (attribs, uniforms, etc.)
  411. ///
  412. typedef enum _GX2VarType
  413. {
  414.     GX2_VAR_TYPE_VOID,
  415.     GX2_VAR_TYPE_BOOL,
  416.     GX2_VAR_TYPE_INT,
  417.     GX2_VAR_TYPE_UINT,
  418.     GX2_VAR_TYPE_FLOAT,
  419.     GX2_VAR_TYPE_DOUBLE,
  420.     GX2_VAR_TYPE_DVEC2,
  421.     GX2_VAR_TYPE_DVEC3,
  422.     GX2_VAR_TYPE_DVEC4,
  423.     GX2_VAR_TYPE_VEC2,
  424.     GX2_VAR_TYPE_VEC3,
  425.     GX2_VAR_TYPE_VEC4,
  426.     GX2_VAR_TYPE_BVEC2,
  427.     GX2_VAR_TYPE_BVEC3,
  428.     GX2_VAR_TYPE_BVEC4,
  429.     GX2_VAR_TYPE_IVEC2,
  430.     GX2_VAR_TYPE_IVEC3,
  431.     GX2_VAR_TYPE_IVEC4,
  432.     GX2_VAR_TYPE_UVEC2,
  433.     GX2_VAR_TYPE_UVEC3,
  434.     GX2_VAR_TYPE_UVEC4,
  435.     GX2_VAR_TYPE_MAT2,
  436.     GX2_VAR_TYPE_MAT2X3,
  437.     GX2_VAR_TYPE_MAT2X4,
  438.     GX2_VAR_TYPE_MAT3X2,
  439.     GX2_VAR_TYPE_MAT3,
  440.     GX2_VAR_TYPE_MAT3X4,
  441.     GX2_VAR_TYPE_MAT4X2,
  442.     GX2_VAR_TYPE_MAT4X3,
  443.     GX2_VAR_TYPE_MAT4,
  444.     GX2_VAR_TYPE_DMAT2,
  445.     GX2_VAR_TYPE_DMAT2X3,
  446.     GX2_VAR_TYPE_DMAT2X4,
  447.     GX2_VAR_TYPE_DMAT3X2,
  448.     GX2_VAR_TYPE_DMAT3,
  449.     GX2_VAR_TYPE_DMAT3X4,
  450.     GX2_VAR_TYPE_DMAT4X2,
  451.     GX2_VAR_TYPE_DMAT4X3,
  452.     GX2_VAR_TYPE_DMAT4,
  453.     GX2_VAR_TYPE_FIRST = GX2_VAR_TYPE_VOID,
  454.     GX2_VAR_TYPE_LAST = GX2_VAR_TYPE_DMAT4
  455. } GX2VarType;
  456.  
  457. /// \brief Type for shader samplers.
  458. /// If it's not "INT", then it's float.
  459. ///
  460. /// This can be used for verification.
  461. /// It can also indicate when to set depth-sampling filter option.
  462. ///
  463. typedef enum _GX2SamplerType
  464. {
  465.     GX2_SAMPLER_TYPE_1D,
  466.     GX2_SAMPLER_TYPE_2D,
  467.     GX2_SAMPLER_TYPE_2D_RECT,
  468.     GX2_SAMPLER_TYPE_3D,
  469.     GX2_SAMPLER_TYPE_CUBE,
  470.     GX2_SAMPLER_TYPE_1D_SHADOW,
  471.     GX2_SAMPLER_TYPE_2D_SHADOW,
  472.     GX2_SAMPLER_TYPE_2D_RECT_SHADOW,
  473.     GX2_SAMPLER_TYPE_CUBE_SHADOW,
  474.     GX2_SAMPLER_TYPE_1D_ARRAY,
  475.     GX2_SAMPLER_TYPE_2D_ARRAY,
  476.     GX2_SAMPLER_TYPE_1D_ARRAY_SHADOW,
  477.     GX2_SAMPLER_TYPE_2D_ARRAY_SHADOW,
  478.     GX2_SAMPLER_TYPE_CUBE_ARRAY,
  479.     GX2_SAMPLER_TYPE_CUBE_ARRAY_SHADOW,
  480.     GX2_SAMPLER_TYPE_BUFFER,
  481.     GX2_SAMPLER_TYPE_RESERVED_1,
  482.     GX2_SAMPLER_TYPE_2D_MS,
  483.     GX2_SAMPLER_TYPE_2D_MS_ARRAY,
  484.     GX2_SAMPLER_TYPE_INT_1D,
  485.     GX2_SAMPLER_TYPE_INT_2D,
  486.     GX2_SAMPLER_TYPE_INT_2D_RECT,
  487.     GX2_SAMPLER_TYPE_INT_3D,
  488.     GX2_SAMPLER_TYPE_INT_CUBE,
  489.     GX2_SAMPLER_TYPE_INT_1D_ARRAY,
  490.     GX2_SAMPLER_TYPE_INT_2D_ARRAY,
  491.     GX2_SAMPLER_TYPE_INT_CUBE_ARRAY,
  492.     GX2_SAMPLER_TYPE_INT_BUFFER,
  493.     GX2_SAMPLER_TYPE_RESERVED_2,
  494.     GX2_SAMPLER_TYPE_INT_2D_MS,
  495.     GX2_SAMPLER_TYPE_INT_2D_MS_ARRAY,
  496.     GX2_SAMPLER_TYPE_UNSIGNED_INT_1D,
  497.     GX2_SAMPLER_TYPE_UNSIGNED_INT_2D,
  498.     GX2_SAMPLER_TYPE_UNSIGNED_INT_2D_RECT,
  499.     GX2_SAMPLER_TYPE_UNSIGNED_INT_3D,
  500.     GX2_SAMPLER_TYPE_UNSIGNED_INT_CUBE,
  501.     GX2_SAMPLER_TYPE_UNSIGNED_INT_1D_ARRAY,
  502.     GX2_SAMPLER_TYPE_UNSIGNED_INT_2D_ARRAY,
  503.     GX2_SAMPLER_TYPE_UNSIGNED_INT_CUBE_ARRAY,
  504.     GX2_SAMPLER_TYPE_UNSIGNED_INT_BUFFER,
  505.     GX2_SAMPLER_TYPE_RESERVED_3,
  506.     GX2_SAMPLER_TYPE_UNSIGNED_INT_2D_MS,
  507.     GX2_SAMPLER_TYPE_UNSIGNED_INT_2D_MS_ARRAY,
  508.     GX2_SAMPLER_TYPE_FIRST = GX2_SAMPLER_TYPE_1D,
  509.     GX2_SAMPLER_TYPE_LAST  = GX2_SAMPLER_TYPE_UNSIGNED_INT_2D_MS_ARRAY
  510. } GX2SamplerType;
  511.  
  512. // -----------------------------------------------------------------------------
  513. // Enums - Drawing
  514.  
  515. /// \brief Indicates whether vertex indices are 16-bit or 32-bit.
  516. ///
  517. typedef enum _GX2IndexFormat
  518. {
  519.     GX2_INDEX_FORMAT_U16_LE = 0, // indices are u16, little-endian
  520.     GX2_INDEX_FORMAT_U32_LE = 1, // indices are u32, little-endian
  521.     GX2_INDEX_FORMAT_U16 = 4, // indices are u16, big-endian
  522.     GX2_INDEX_FORMAT_U32 = 9, // indices are u32, big-endian
  523.     GX2_INDEX_FORMAT_FIRST  = GX2_INDEX_FORMAT_U16_LE,
  524.     GX2_INDEX_FORMAT_LAST   = GX2_INDEX_FORMAT_U32
  525. } GX2IndexFormat;
  526.  
  527. /// \brief Indicates type of primitive to draw.
  528. ///
  529. /// Below, "min" is the minimum number of vertices to draw a single primitive.
  530. /// The "incr" is how many more vertices are needed to draw the next primitive.
  531. ///
  532. typedef enum _GX2PrimitiveType
  533. {
  534.     GX2_PRIMITIVE_POINTS                      = 0x01, ///< min = 1; incr = 1
  535.     GX2_PRIMITIVE_LINES                       = 0x02, ///< min = 2; incr = 2
  536.     GX2_PRIMITIVE_LINE_STRIP                  = 0x03, ///< min = 2; incr = 1
  537.     GX2_PRIMITIVE_TRIANGLES                   = 0x04, ///< min = 3; incr = 3
  538.     GX2_PRIMITIVE_TRIANGLE_FAN                = 0x05, ///< min = 3; incr = 1
  539.     GX2_PRIMITIVE_TRIANGLE_STRIP              = 0x06, ///< min = 3; incr = 1
  540.     GX2_PRIMITIVE_LINES_ADJACENCY             = 0x0a, ///< min = 4; incr = 4
  541.     GX2_PRIMITIVE_LINE_STRIP_ADJACENCY        = 0x0b, ///< min = 4; incr = 1
  542.     GX2_PRIMITIVE_TRIANGLES_ADJACENCY         = 0x0c, ///< min = 6; incr = 6
  543.     GX2_PRIMITIVE_TRIANGLE_STRIP_ADJACENCY    = 0x0d, ///< min = 6; incr = 2
  544.     GX2_PRIMITIVE_RECTS                       = 0x11, ///< min = 3; incr = 3
  545.     GX2_PRIMITIVE_LINE_LOOP                   = 0x12, ///< min = 2; incr = 1
  546.     GX2_PRIMITIVE_QUADS                       = 0x13, ///< min = 4; incr = 4
  547.     GX2_PRIMITIVE_QUAD_STRIP                  = 0x14, ///< min = 4; incr = 2
  548.     GX2_PRIMITIVE_TESSELLATE_LINES            = 0x82, ///< min = 2; incr = 2
  549.     GX2_PRIMITIVE_TESSELLATE_LINE_STRIP       = 0x83, ///< min = 2; incr = 1
  550.     GX2_PRIMITIVE_TESSELLATE_TRIANGLES        = 0x84, ///< min = 3; incr = 3
  551.     GX2_PRIMITIVE_TESSELLATE_TRIANGLE_STRIP   = 0x86, ///< min = 3; incr = 1
  552.     GX2_PRIMITIVE_TESSELLATE_QUADS            = 0x93, ///< min = 4; incr = 4
  553.     GX2_PRIMITIVE_TESSELLATE_QUAD_STRIP       = 0x94, ///< min = 4; incr = 2
  554.     GX2_PRIMITIVE_FIRST                    = GX2_PRIMITIVE_POINTS,
  555.     GX2_PRIMITIVE_LAST                        = GX2_PRIMITIVE_TESSELLATE_QUAD_STRIP
  556. } GX2PrimitiveType;
  557.  
  558. // -----------------------------------------------------------------------------
  559. // Enums - Clear
  560.  
  561. /// \brief Describes which buffers to clear for depth/stencil clear
  562. ///
  563. typedef enum _GX2ClearMode
  564. {
  565.     GX2_CLEAR_NONE    = 0, // No-op
  566.     GX2_CLEAR_DEPTH   = 1, // clear depth buffer
  567.     GX2_CLEAR_STENCIL = 2, // clear stencil buffer
  568.     GX2_CLEAR_D_REG   = 4, // Set depth clear value into the current context
  569.                            // register. The depth buffer values are not actually
  570.                            // changed. This register value needs to match the
  571.                            // clear value of the buffer for correct HiZ operation.
  572.     GX2_CLEAR_S_REG   = 8, // Set stencil clear value into the current context
  573.                            // register. The stencil buffer values are not
  574.                            // actually changed.  This register value needs to
  575.                            // match clear value of the buffer for correct HiZ
  576.                            // operation.
  577.     GX2_CLEAR_BOTH          = GX2_CLEAR_DEPTH   | GX2_CLEAR_STENCIL,
  578.     GX2_CLEAR_D_S_REG       = GX2_CLEAR_D_REG   | GX2_CLEAR_S_REG,
  579.     GX2_CLEAR_DEPTH_D_REG   = GX2_CLEAR_DEPTH   | GX2_CLEAR_D_REG,
  580.     GX2_CLEAR_STENCIL_S_REG = GX2_CLEAR_STENCIL | GX2_CLEAR_S_REG,
  581.     GX2_CLEAR_BOTH_D_S_REG  = GX2_CLEAR_DEPTH_D_REG | GX2_CLEAR_STENCIL_S_REG,
  582.     GX2_CLEAR_FIRST         = GX2_CLEAR_NONE,
  583.     GX2_CLEAR_LAST          = GX2_CLEAR_BOTH_D_S_REG
  584. } GX2ClearMode;
  585.  
  586. // -----------------------------------------------------------------------------
  587. // Enums - Textures & other surfaces
  588.  
  589. /// \brief Indicates desired texture, color-buffer, depth-buffer, or scan-buffer format.
  590. ///
  591. /// After the word "format", the following letters indicate the possible uses:
  592. /// T=texture, C=color-buffer, D=depth/stencil-buffer, S=scan-buffer.
  593. ///
  594. /// There are some formats with the same enum value, but different use labels.
  595. /// These are provided as a convenience to explain the type information for each use.
  596. ///
  597. /// Type conversion options:
  598. /// - UNORM (0): surface unsigned integer is converted to/from [0.0, 1.0] in shader
  599. /// - UINT  (1): surface unsigned integer is copied to/from shader as unsigned int
  600. /// - SNORM (2): surface signed integer is converted to/from [-1.0, 1.0] in shader
  601. /// - SINT  (3): surface signed integer is copied to/from shader as signed int
  602. /// - SRGB  (4): SRGB degamma performed on surface read, then treated as UNORM;
  603. ///              SRGB gamma is performed on surface write
  604. /// - FLOAT (8): surface float is copied to/from shader as float
  605. ///
  606. /// Note: As textures, all UINT/SINT formats may be point-sampled only!
  607. ///
  608. /// The numbers in the names indicate the number of bits per channel, as well as
  609. /// how many channels are present.  An "X" in front of a number indicates padding
  610. /// bits that are present, but do not map to any channel.
  611. ///
  612. /// Texture color channel mappings:
  613. /// - 1-channel formats map to R [GBA are undefined]
  614. /// - 2-channel formats map to RG [BA are undefined]
  615. /// - 3-channel formats map to RGB [A is undefined]
  616. /// - 4-channel formats map to RGBA
  617. ///
  618. /// Channel mapping can be changed using the GX2InitTextureCompSel API.
  619. /// We advise you avoid referring to channels that don't exist in the format.
  620. /// You should use the component select to choose constant values in those cases.
  621. /// The default component selectors in GX2InitTexture map:
  622. /// - 1-channel formats to R001
  623. /// - 2-channel formats to RG01
  624. /// - 3-channel formats to RGB1
  625. /// - 4-channel formats to RGBA
  626. ///
  627. /// To understand exact component bit placement, you must first understand the
  628. /// basic machine unit that the components are packed into.  If each component
  629. /// fits into a single unit, then the order is simply R,G,B,A.  If multiple
  630. /// components are packed into a single unit, then the components are packed
  631. /// in order starting from the LSB end.  In all cases, multi-byte machine units
  632. /// are then written out in little-endian format.
  633. ///
  634. /// Note 1: It is not presently possible to switch between depth and color buffer
  635. /// uses for the same surface.  This requires a retiling, since the tile formats
  636. /// are different and incompatible.  The texture unit can read depth-tiled buffers
  637. /// (except for D24_S8 format).  The D24_S8 format requires tile-conversion before
  638. /// it can be read by the texture unit.  Note that the two components have different
  639. /// number formats, and only the depth part can be sampled with any filter more
  640. /// complex than point-sampling.
  641. /// It is needed to use GX2_SURFACE_FORMAT_T_R24_UNORM_X8 for reading depth buffer as
  642. /// texture and GX2_SURFACE_FORMAT_T_X24_G8_UINT for reading stencil buffer as texture.
  643. /// See \ref GX2ConvertDepthBufferToTextureSurface() for more information.
  644. ///
  645. /// Note 2: Similar to depth format D_D24_S8_UNORM and texture formats T_R24_UNORM_X8
  646. /// and T_X24_G8_UINT, format GX2_SURFACE_FORMAT_D_D32_FLOAT_S8_UINT_X24 is a
  647. /// depth/stencil buffer format while T_R32_FLOAT_X8_X24 and T_X32_G8_UINT_X24 are
  648. /// texture formats used to read the depth and stencil data, respectively.
  649. /// See \ref GX2ConvertDepthBufferToTextureSurface() for more information.
  650. ///
  651. /// Note 3: The NV12 format is a special case for video.  It actually consists of
  652. /// two surfaces (an 8-bit surface & a 1/4-size 16-bit surface).  It is only usable
  653. /// in certain situations.
  654. ///
  655. /// Final note: there may be additional restrictions not yet specified.
  656. ///
  657. typedef enum _GX2SurfaceFormat
  658. {
  659.     /// color write performance relative to hardware peak write (x%)
  660.     /// texture read performance relative to hardware peak read (y%)
  661.     /// these numbers do not consider memory bandwidth limit
  662.     /// there are still some investigations for missing areas
  663.     GX2_SURFACE_FORMAT_INVALID                  = 0x00000000,
  664.     /// color write (100%), texture read (100%)
  665.     GX2_SURFACE_FORMAT_TC_R8_UNORM              = 0x00000001,
  666.     /// color write (50%), texture read (100%)
  667.     GX2_SURFACE_FORMAT_TC_R8_UINT               = 0x00000101,
  668.     /// color write (100%), texture read (100%)
  669.     GX2_SURFACE_FORMAT_TC_R8_SNORM              = 0x00000201,
  670.     /// color write (50%), texture read (100%)
  671.     GX2_SURFACE_FORMAT_TC_R8_SINT               = 0x00000301,
  672.     /// texture read (100%)
  673.     GX2_SURFACE_FORMAT_T_R4_G4_UNORM            = 0x00000002,
  674.     /// color write (50%), texture read (100%)
  675.     GX2_SURFACE_FORMAT_TCD_R16_UNORM            = 0x00000005,
  676.     /// color write (50%), texture read (100%)
  677.     GX2_SURFACE_FORMAT_TC_R16_UINT              = 0x00000105,
  678.     /// color write (50%), texture read (100%)
  679.     GX2_SURFACE_FORMAT_TC_R16_SNORM             = 0x00000205,
  680.     /// color write (50%), texture read (100%)
  681.     GX2_SURFACE_FORMAT_TC_R16_SINT              = 0x00000305,
  682.     /// color write (100%), texture read (100%)
  683.     GX2_SURFACE_FORMAT_TC_R16_FLOAT             = 0x00000806,
  684.     /// color write (100%), texture read (100%)
  685.     GX2_SURFACE_FORMAT_TC_R8_G8_UNORM           = 0x00000007,
  686.     /// color write (50%), texture read (100%)
  687.     GX2_SURFACE_FORMAT_TC_R8_G8_UINT            = 0x00000107,
  688.     /// color write (100%), texture read (100%)
  689.     GX2_SURFACE_FORMAT_TC_R8_G8_SNORM           = 0x00000207,
  690.     /// color write (50%), texture read (100%)
  691.     GX2_SURFACE_FORMAT_TC_R8_G8_SINT            = 0x00000307,
  692.     /// color write (100%), texture read (100%)
  693.     GX2_SURFACE_FORMAT_TCS_R5_G6_B5_UNORM       = 0x00000008,
  694.     /// color write (100%), texture read (100%)
  695.     GX2_SURFACE_FORMAT_TC_R5_G5_B5_A1_UNORM     = 0x0000000a,
  696.     /// color write (100%), texture read (100%)
  697.     GX2_SURFACE_FORMAT_TC_R4_G4_B4_A4_UNORM     = 0x0000000b,
  698.     /// color write (100%), texture read (100%)
  699.     GX2_SURFACE_FORMAT_TC_A1_B5_G5_R5_UNORM     = 0x0000000c, ///< flipped
  700.     /// color write (50%)
  701.     GX2_SURFACE_FORMAT_TC_R32_UINT              = 0x0000010d,
  702.     /// color write (50%)
  703.     GX2_SURFACE_FORMAT_TC_R32_SINT              = 0x0000030d,
  704.     /// color write (50%)
  705.     GX2_SURFACE_FORMAT_TCD_R32_FLOAT            = 0x0000080e,
  706.     /// color write (50%)
  707.     GX2_SURFACE_FORMAT_TC_R16_G16_UNORM         = 0x0000000f,
  708.     /// color write (50%)
  709.     GX2_SURFACE_FORMAT_TC_R16_G16_UINT          = 0x0000010f,
  710.     /// color write (50%)
  711.     GX2_SURFACE_FORMAT_TC_R16_G16_SNORM         = 0x0000020f,
  712.     /// color write (50%)
  713.     GX2_SURFACE_FORMAT_TC_R16_G16_SINT          = 0x0000030f,
  714.     /// color write (100%)
  715.     GX2_SURFACE_FORMAT_TC_R16_G16_FLOAT         = 0x00000810,
  716.     GX2_SURFACE_FORMAT_D_D24_S8_UNORM           = 0x00000011, ///< note: same value as below
  717.     GX2_SURFACE_FORMAT_T_R24_UNORM_X8           = 0x00000011, ///< see Note 1
  718.     GX2_SURFACE_FORMAT_T_X24_G8_UINT            = 0x00000111, ///< see Note 1
  719.     GX2_SURFACE_FORMAT_D_D24_S8_FLOAT           = 0x00000811,
  720.     /// color write (100%)
  721.     GX2_SURFACE_FORMAT_TC_R11_G11_B10_FLOAT     = 0x00000816,
  722.     /// color write (100%)
  723.     GX2_SURFACE_FORMAT_TCS_R10_G10_B10_A2_UNORM = 0x00000019,
  724.     /// color write (50%)
  725.     GX2_SURFACE_FORMAT_TC_R10_G10_B10_A2_UINT   = 0x00000119,
  726.     /// color write (100%)
  727.     GX2_SURFACE_FORMAT_TC_R10_G10_B10_A2_SNORM  = 0x00000219, ///< A2 part is UNORM
  728.     /// color write (50%)
  729.     GX2_SURFACE_FORMAT_TC_R10_G10_B10_A2_SINT   = 0x00000319,
  730.     /// color write (100%)
  731.     GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM    = 0x0000001a,
  732.     /// color write (50%)
  733.     GX2_SURFACE_FORMAT_TC_R8_G8_B8_A8_UINT      = 0x0000011a,
  734.     /// color write (100%)
  735.     GX2_SURFACE_FORMAT_TC_R8_G8_B8_A8_SNORM     = 0x0000021a,
  736.     /// color write (50%)
  737.     GX2_SURFACE_FORMAT_TC_R8_G8_B8_A8_SINT      = 0x0000031a,
  738.     /// color write (100%)
  739.     GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_SRGB     = 0x0000041a,
  740.     /// color write (100%)
  741.     GX2_SURFACE_FORMAT_TCS_A2_B10_G10_R10_UNORM = 0x0000001b, ///< flipped
  742.     /// color write (50%)
  743.     GX2_SURFACE_FORMAT_TC_A2_B10_G10_R10_UINT   = 0x0000011b, ///< flipped
  744.     GX2_SURFACE_FORMAT_D_D32_FLOAT_S8_UINT_X24  = 0x0000081c, ///< note: same value as below
  745.     GX2_SURFACE_FORMAT_T_R32_FLOAT_X8_X24       = 0x0000081c, ///< note: same value as above
  746.     GX2_SURFACE_FORMAT_T_X32_G8_UINT_X24        = 0x0000011c, ///< see Note 2
  747.     /// color write (50%)
  748.     GX2_SURFACE_FORMAT_TC_R32_G32_UINT          = 0x0000011d,
  749.     /// color write (50%)
  750.     GX2_SURFACE_FORMAT_TC_R32_G32_SINT          = 0x0000031d,
  751.     /// color write (50%)
  752.     GX2_SURFACE_FORMAT_TC_R32_G32_FLOAT         = 0x0000081e,
  753.     /// color write (50%)
  754.     GX2_SURFACE_FORMAT_TC_R16_G16_B16_A16_UNORM = 0x0000001f,
  755.     /// color write (50%)
  756.     GX2_SURFACE_FORMAT_TC_R16_G16_B16_A16_UINT  = 0x0000011f,
  757.     /// color write (50%)
  758.     GX2_SURFACE_FORMAT_TC_R16_G16_B16_A16_SNORM = 0x0000021f,
  759.     /// color write (50%)
  760.     GX2_SURFACE_FORMAT_TC_R16_G16_B16_A16_SINT  = 0x0000031f,
  761.     /// color write (50%)
  762.     GX2_SURFACE_FORMAT_TC_R16_G16_B16_A16_FLOAT = 0x00000820,
  763.     /// color write (25%)
  764.     GX2_SURFACE_FORMAT_TC_R32_G32_B32_A32_UINT  = 0x00000122,
  765.     /// color write (25%)
  766.     GX2_SURFACE_FORMAT_TC_R32_G32_B32_A32_SINT  = 0x00000322,
  767.     /// color write (25%)
  768.     GX2_SURFACE_FORMAT_TC_R32_G32_B32_A32_FLOAT = 0x00000823,
  769.     /// texture read (100%)
  770.     GX2_SURFACE_FORMAT_T_BC1_UNORM              = 0x00000031,
  771.     /// texture read (100%)
  772.     GX2_SURFACE_FORMAT_T_BC1_SRGB               = 0x00000431,
  773.     /// texture read (100%)
  774.     GX2_SURFACE_FORMAT_T_BC2_UNORM              = 0x00000032,
  775.     /// texture read (100%)
  776.     GX2_SURFACE_FORMAT_T_BC2_SRGB               = 0x00000432,
  777.     /// texture read (100%)
  778.     GX2_SURFACE_FORMAT_T_BC3_UNORM              = 0x00000033,
  779.     /// texture read (100%)
  780.     GX2_SURFACE_FORMAT_T_BC3_SRGB               = 0x00000433,
  781.     /// texture read (100%)
  782.     GX2_SURFACE_FORMAT_T_BC4_UNORM              = 0x00000034,
  783.     /// texture read (100%)
  784.     GX2_SURFACE_FORMAT_T_BC4_SNORM              = 0x00000234,
  785.     /// texture read (100%)
  786.     GX2_SURFACE_FORMAT_T_BC5_UNORM              = 0x00000035,
  787.     /// texture read (100%)
  788.     GX2_SURFACE_FORMAT_T_BC5_SNORM              = 0x00000235,
  789.     /// texture read (100%)
  790.     GX2_SURFACE_FORMAT_T_NV12_UNORM             = 0x00000081, ///< see Note 3
  791.     GX2_SURFACE_FORMAT_FIRST                    = GX2_SURFACE_FORMAT_TC_R8_UNORM,
  792.     GX2_SURFACE_FORMAT_LAST                     = 0x0000083f
  793. } GX2SurfaceFormat;
  794.  
  795. /// \brief Indicates the desired tiling mode for a surface
  796. ///
  797. /// You should use only DEFAULT in most cases.
  798. /// \note: Don't use other modes unless you know what you're doing!
  799. ///
  800. typedef enum _GX2TileMode
  801. {
  802.     GX2_TILE_MODE_DEFAULT        = 0x00000000, // driver will choose best mode
  803.     GX2_TILE_MODE_LINEAR_SPECIAL = 0x00000010, // typically not supported by HW
  804.     GX2_TILE_MODE_LINEAR_ALIGNED = 0x00000001, // supported by HW, but not fast
  805.     GX2_TILE_MODE_1D_TILED_THIN1 = 0x00000002,
  806.     GX2_TILE_MODE_1D_TILED_THICK = 0x00000003,
  807.     GX2_TILE_MODE_2D_TILED_THIN1 = 0x00000004, // (a typical default, but not always)
  808.     GX2_TILE_MODE_2D_TILED_THIN2 = 0x00000005,
  809.     GX2_TILE_MODE_2D_TILED_THIN4 = 0x00000006,
  810.     GX2_TILE_MODE_2D_TILED_THICK = 0x00000007,
  811.     GX2_TILE_MODE_2B_TILED_THIN1 = 0x00000008,
  812.     GX2_TILE_MODE_2B_TILED_THIN2 = 0x00000009,
  813.     GX2_TILE_MODE_2B_TILED_THIN4 = 0x0000000a,
  814.     GX2_TILE_MODE_2B_TILED_THICK = 0x0000000b,
  815.     GX2_TILE_MODE_3D_TILED_THIN1 = 0x0000000c,
  816.     GX2_TILE_MODE_3D_TILED_THICK = 0x0000000d,
  817.     GX2_TILE_MODE_3B_TILED_THIN1 = 0x0000000e,
  818.     GX2_TILE_MODE_3B_TILED_THICK = 0x0000000f,
  819.     GX2_TILE_MODE_FIRST          = GX2_TILE_MODE_DEFAULT,
  820.     GX2_TILE_MODE_LAST           = GX2_TILE_MODE_LINEAR_SPECIAL
  821. } GX2TileMode;
  822.  
  823. /// \brief Indicates how a given surface may be used.
  824. ///
  825. /// A "final" TV render target is one that will be copied to a TV scan buffer.
  826. /// It needs to be designated to handle certain display corner cases.
  827. /// (When a HD surface must be scaled down to display in NTSC/PAL.)
  828. ///
  829. typedef enum _GX2SurfaceUse
  830. {
  831.     GX2_SURFACE_USE_TEXTURE                  = 0x001,
  832.     GX2_SURFACE_USE_COLOR_BUFFER             = 0x002,
  833.     GX2_SURFACE_USE_DEPTH_BUFFER             = 0x004,
  834.  
  835.     GX2_SURFACE_USE_SCAN_BUFFER              = 0x008,   // internal use only
  836.     GX2_SURFACE_USE_FTV                      = (1<<31), // modifier, designates a final TV render target
  837.     //** If changing or adding flags, ensure they match up / don't clash with GX2RResourceFlags
  838.  
  839.     GX2_SURFACE_USE_COLOR_BUFFER_TEXTURE     = GX2_SURFACE_USE_COLOR_BUFFER | GX2_SURFACE_USE_TEXTURE,
  840.     GX2_SURFACE_USE_DEPTH_BUFFER_TEXTURE     = GX2_SURFACE_USE_DEPTH_BUFFER | GX2_SURFACE_USE_TEXTURE,
  841.  
  842.     GX2_SURFACE_USE_COLOR_BUFFER_FTV         = GX2_SURFACE_USE_COLOR_BUFFER | GX2_SURFACE_USE_FTV,
  843.     GX2_SURFACE_USE_COLOR_BUFFER_TEXTURE_FTV = GX2_SURFACE_USE_COLOR_BUFFER_TEXTURE | GX2_SURFACE_USE_FTV,
  844.  
  845.     GX2_SURFACE_USE_FIRST                    = GX2_SURFACE_USE_TEXTURE,
  846.     GX2_SURFACE_USE_LAST                     = GX2_SURFACE_USE_SCAN_BUFFER // note: without modifiers!
  847. } GX2SurfaceUse;
  848.  
  849. /// \brief Indicates the "shape" of a given surface or texture.
  850. ///
  851. typedef enum _GX2SurfaceDim
  852. {
  853.     GX2_SURFACE_DIM_1D            = 0x000,
  854.     GX2_SURFACE_DIM_2D            = 0x001,
  855.     GX2_SURFACE_DIM_3D            = 0x002,
  856.     GX2_SURFACE_DIM_CUBE          = 0x003,
  857.     GX2_SURFACE_DIM_1D_ARRAY      = 0x004,
  858.     GX2_SURFACE_DIM_2D_ARRAY      = 0x005,
  859.     GX2_SURFACE_DIM_2D_MSAA       = 0x006,
  860.     GX2_SURFACE_DIM_2D_MSAA_ARRAY = 0x007,
  861.     GX2_SURFACE_DIM_FIRST         = GX2_SURFACE_DIM_1D,
  862.     GX2_SURFACE_DIM_LAST          = GX2_SURFACE_DIM_2D_MSAA_ARRAY
  863. } GX2SurfaceDim;
  864.  
  865. /// \brief Indicates the AA mode (number of samples) for a surface.
  866. ///
  867. typedef enum _GX2AAMode
  868. {
  869.     GX2_AA_MODE_1X    = 0x000,
  870.     GX2_AA_MODE_2X    = 0x001,
  871.     GX2_AA_MODE_4X    = 0x002,
  872.     GX2_AA_MODE_8X    = 0x003,
  873.     GX2_AA_MODE_FIRST = GX2_AA_MODE_1X,
  874.     GX2_AA_MODE_LAST  = GX2_AA_MODE_8X
  875. } GX2AAMode;
  876.  
  877. // ----------------------------- //
  878. // Texture Sampler options
  879.  
  880. /// \brief Indicates how to treat texture coordinates outside of [0...1] range.
  881. ///
  882. typedef enum _GX2TexClamp
  883. {
  884.     GX2_TEX_CLAMP_WRAP                    = 0, ///< repeat
  885.     GX2_TEX_CLAMP_MIRROR                  = 1, ///< mirrored repeat
  886.     GX2_TEX_CLAMP_CLAMP                   = 2, ///< clamps at the last texel value
  887.     GX2_TEX_CLAMP_MIRROR_ONCE             = 3, ///< mirrors once, then clamps like previous option
  888.     GX2_TEX_CLAMP_CLAMP_HALF_BORDER       = 4, ///< clamps: values outside are part border, part last texel
  889.     GX2_TEX_CLAMP_MIRROR_ONCE_HALF_BORDER = 5, ///< mirrors once, then clamps like previous option
  890.     GX2_TEX_CLAMP_CLAMP_BORDER            = 6, ///< clamps: values outside may be 100% border
  891.     GX2_TEX_CLAMP_MIRROR_ONCE_BORDER      = 7, ///< mirrors once, then clamps like previous option
  892.     GX2_TEX_CLAMP_FIRST  = GX2_TEX_CLAMP_WRAP,
  893.     GX2_TEX_CLAMP_LAST   = GX2_TEX_CLAMP_MIRROR_ONCE_BORDER
  894. } GX2TexClamp;
  895.  
  896. /// \brief Indicates type of border color to use.
  897. /// \note It's better to avoid using the register color type, as setting
  898. /// those registers requires a pipeline stall.
  899. ///
  900. typedef enum _GX2TexBorderType
  901. {
  902.     GX2_TEX_BORDER_CLEAR_BLACK  = 0, ///< RGBA = (0.0, 0.0, 0.0, 0.0)
  903.     GX2_TEX_BORDER_SOLID_BLACK  = 1, ///< RGBA = (0.0, 0.0, 0.0, 1.0)
  904.     GX2_TEX_BORDER_SOLID_WHITE  = 2, ///< RGBA = (1.0, 1.0, 1.0, 1.0)
  905.     GX2_TEX_BORDER_USE_REGISTER = 3, ///< RGBA specified using register
  906.     GX2_TEX_BORDER_FIRST  = GX2_TEX_BORDER_CLEAR_BLACK,
  907.     GX2_TEX_BORDER_LAST   = GX2_TEX_BORDER_USE_REGISTER
  908. } GX2TexBorderType;
  909.  
  910. /// \brief Indicates desired texture filter option within a plane.
  911. ///
  912. typedef enum _GX2TexXYFilterType
  913. {
  914.     GX2_TEX_XY_FILTER_POINT    = 0,
  915.     GX2_TEX_XY_FILTER_BILINEAR = 1,
  916.     GX2_TEX_XY_FILTER_FIRST    = GX2_TEX_XY_FILTER_POINT,
  917.     GX2_TEX_XY_FILTER_LAST     = GX2_TEX_XY_FILTER_BILINEAR
  918. } GX2TexXYFilterType;
  919.  
  920. /// \brief Indicates desired texture filter option between Z planes.
  921. ///
  922. typedef enum _GX2TexZFilterType
  923. {
  924.     GX2_TEX_Z_FILTER_USE_XY = 0, // use same as XY filter modes
  925.     GX2_TEX_Z_FILTER_POINT  = 1, // (default)
  926.     GX2_TEX_Z_FILTER_LINEAR = 2, // note: slower than POINT
  927.     GX2_TEX_Z_FILTER_FIRST  = GX2_TEX_Z_FILTER_USE_XY,
  928.     GX2_TEX_Z_FILTER_LAST   = GX2_TEX_Z_FILTER_LINEAR
  929. } GX2TexZFilterType;
  930.  
  931. /// \brief Indicates desired texture filter option between mip levels.
  932. ///
  933. typedef enum _GX2TexMipFilterType
  934. {
  935.     GX2_TEX_MIP_FILTER_NO_MIP = 0, // disable mipmapping (use base level only)
  936.     GX2_TEX_MIP_FILTER_POINT  = 1, // (default)
  937.     GX2_TEX_MIP_FILTER_LINEAR = 2, // note: slower than POINT
  938.     GX2_TEX_MIP_FILTER_FIRST  = GX2_TEX_MIP_FILTER_NO_MIP,
  939.     GX2_TEX_MIP_FILTER_LAST   = GX2_TEX_MIP_FILTER_LINEAR
  940. } GX2TexMipFilterType;
  941.  
  942. /// \brief Indicates desired performance option for (linear) Z filtering.
  943. /// If enabled, the Z fractional bits go through a lookup table to adjust
  944. /// the performance/quality trade-off.
  945. ///
  946. typedef enum _GX2TexZPerfType
  947. {
  948.     // TODO: come up with better names to describe trade-offs
  949.     GX2_TEX_Z_PERF_0 = 0, // disabled: no changes (default)
  950.     GX2_TEX_Z_PERF_1 = 1, // use lookup table 1
  951.     GX2_TEX_Z_PERF_2 = 2, // use lookup table 2
  952.     GX2_TEX_Z_PERF_3 = 3, // use lookup table 3
  953.     GX2_TEX_Z_PERF_FIRST = GX2_TEX_Z_PERF_0,
  954.     GX2_TEX_Z_PERF_LAST  = GX2_TEX_Z_PERF_3
  955. } GX2TexZPerfType;
  956.  
  957. /// \brief Indicates desired performance option for (linear) mip filtering.
  958. /// If enabled, the mip LOD fractional bits go through a lookup table to adjust
  959. /// the performance/quality trade-off.
  960. ///
  961. typedef enum _GX2TexMipPerfType
  962. {
  963.     // TODO: come up with better names to describe trade-offs
  964.     GX2_TEX_MIP_PERF_0 = 0, // disabled: no changes (default)
  965.     GX2_TEX_MIP_PERF_1 = 1, // use lookup table 1
  966.     GX2_TEX_MIP_PERF_2 = 2, // use lookup table 2
  967.     GX2_TEX_MIP_PERF_3 = 3, // use lookup table 3
  968.     GX2_TEX_MIP_PERF_4 = 4, // use lookup table 4
  969.     GX2_TEX_MIP_PERF_5 = 5, // use lookup table 5
  970.     GX2_TEX_MIP_PERF_6 = 6, // use lookup table 6
  971.     GX2_TEX_MIP_PERF_7 = 7, // use lookup table 7
  972.     GX2_TEX_MIP_PERF_FIRST = GX2_TEX_MIP_PERF_0,
  973.     GX2_TEX_MIP_PERF_LAST  = GX2_TEX_MIP_PERF_7
  974. } GX2TexMipPerfType;
  975.  
  976. /// \brief Indicates maximum desired anisotropic filter ratio.
  977. /// Higher ratios give better image quality, but slower performance.
  978. ///
  979. typedef enum _GX2TexAnisoRatio
  980. {
  981.     GX2_TEX_ANISO_1_TO_1  = 0, // disables anisotropic filtering
  982.     GX2_TEX_ANISO_2_TO_1  = 1, // 2:1
  983.     GX2_TEX_ANISO_4_TO_1  = 2, // 4:1
  984.     GX2_TEX_ANISO_8_TO_1  = 3, // 8:1
  985.     GX2_TEX_ANISO_16_TO_1 = 4, // 16:1
  986.     GX2_TEX_ANISO_FIRST = GX2_TEX_ANISO_1_TO_1,
  987.     GX2_TEX_ANISO_LAST  = GX2_TEX_ANISO_16_TO_1
  988. } GX2TexAnisoRatio;
  989.  
  990. // -----------------------------------------------------------------------------
  991. // Enums - Display / Scan-out
  992.  
  993. /// \brief Describes actual video output from the TV encoder.
  994. ///
  995. /// This is read-only from the system settings.
  996. ///
  997. typedef enum _GX2TVScanMode
  998. {
  999.     GX2_TV_SCAN_MODE_NONE, // TV output is disabled
  1000.     GX2_TV_SCAN_MODE_576I, // Just to let users know that it is PAL
  1001.     GX2_TV_SCAN_MODE_480I,
  1002.     GX2_TV_SCAN_MODE_480P,
  1003.     GX2_TV_SCAN_MODE_720P,
  1004.     GX2_TV_SCAN_MODE_RESERVED,
  1005.     GX2_TV_SCAN_MODE_1080I,
  1006.     GX2_TV_SCAN_MODE_1080P,
  1007.     GX2_TV_SCAN_MODE_FIRST = GX2_TV_SCAN_MODE_NONE,
  1008.     GX2_TV_SCAN_MODE_LAST  = GX2_TV_SCAN_MODE_1080P
  1009. } GX2TVScanMode;
  1010.  
  1011. /// \brief Describes user-setting for TV aspect ratio.
  1012. /// It should only be relevant for 480I/480P.
  1013. ///
  1014. /// This is read-only from the system settings.
  1015. ///
  1016. typedef enum _GX2AspectRatio
  1017. {
  1018.     GX2_ASPECT_RATIO_4_BY_3,
  1019.     GX2_ASPECT_RATIO_16_BY_9,
  1020.     GX2_ASPECT_RATIO_FIRST = GX2_ASPECT_RATIO_4_BY_3,
  1021.     GX2_ASPECT_RATIO_LAST  = GX2_ASPECT_RATIO_16_BY_9
  1022. } GX2AspectRatio;
  1023.  
  1024. /// \brief Used to describe both the current DRC set up
  1025. /// as well as desired DRC buffering set up.
  1026. ///
  1027. typedef enum _GX2DRCMode
  1028. {
  1029.     GX2_DRC_NONE        = 0,
  1030.     GX2_DRC_SINGLE      = 1, // 60Hz
  1031.     GX2_DRC_DOUBLE      = 2, // 30Hz
  1032.     GX2_DRC_SINGLE_30HZ = 3,
  1033.     GX2_DRC_FIRST       = GX2_DRC_NONE,
  1034.     GX2_DRC_LAST        = GX2_DRC_SINGLE_30HZ
  1035. } GX2DRCMode;
  1036.  
  1037. /// \brief Used to describe scan buffer setup for TV.
  1038. /// (used mainly to reserve framebuffer memory)
  1039. ///
  1040. typedef enum _GX2TVRenderMode
  1041. {
  1042.     GX2_TV_RENDER_NONE,         // TV output is unused
  1043.     GX2_TV_RENDER_480_NARROW,   // 4:3 ratio (640x480)
  1044.     GX2_TV_RENDER_480_WIDE,     // 16:9 ratio (854x480)
  1045.     GX2_TV_RENDER_720,          // 16:9 for all the rest...
  1046.     GX2_TV_RENDER_RESERVED,
  1047.     GX2_TV_RENDER_1080,
  1048.     GX2_TV_RENDER_FIRST = GX2_TV_RENDER_NONE,
  1049.     GX2_TV_RENDER_LAST  = GX2_TV_RENDER_1080
  1050. } GX2TVRenderMode;
  1051.  
  1052. /// \brief Specify the buffering mode.
  1053. ///
  1054. /// \note: Uncertain if this will remain.
  1055. ///
  1056. typedef enum _GX2BufferingMode
  1057. {
  1058.     GX2_BUFFERING_SINGLE = 1,     // Just for debug
  1059.     GX2_BUFFERING_DOUBLE = 2,
  1060.     GX2_BUFFERING_TRIPLE = 3,
  1061.     GX2_BUFFERING_QUAD   = 4,
  1062.     GX2_BUFFERING_FIRST  = GX2_BUFFERING_SINGLE,
  1063.     GX2_BUFFERING_LAST   = GX2_BUFFERING_QUAD
  1064. } GX2BufferingMode;
  1065.  
  1066. /// \brief Used to describe where to copy renderbuffers to.
  1067. ///
  1068. /// \todo Adjust as necessary.
  1069. ///
  1070. typedef enum _GX2ScanTarget
  1071. {
  1072.     GX2_SCAN_TARGET_TV         = 0x1,
  1073.     GX2_SCAN_TARGET_TV_LEFT    = 0x1, // same as above
  1074.     GX2_SCAN_TARGET_TV_RIGHT   = 0x2,
  1075.     GX2_SCAN_TARGET_DRC_FIRST  = 0x4,
  1076.     GX2_SCAN_TARGET_DRC_SECOND = 0x8,
  1077.     GX2_SCAN_TARGET_FIRST      = GX2_SCAN_TARGET_TV,
  1078.     GX2_SCAN_TARGET_LAST       = GX2_SCAN_TARGET_DRC_SECOND
  1079. } GX2ScanTarget;
  1080.  
  1081. /// \brief indicate which hint is valid
  1082. ///
  1083. typedef enum _GX2DRCEncodingHint
  1084. {
  1085.     GX2_DRC_ENCODING_INVALLIDATE        = 0x1, ///< (1) invalidates GX2_DRC_ENCODING_MOTION_VECTOR and refresh DRC screen by I-frame
  1086.     GX2_DRC_ENCODING_MOTION_VECTOR      = 0x4, ///< (4) Motion vector
  1087.     GX2_DRC_ENCODING_FIRST              = GX2_DRC_ENCODING_INVALLIDATE,
  1088.     GX2_DRC_ENCODING_LAST               = GX2_DRC_ENCODING_MOTION_VECTOR
  1089. } GX2DRCEncodingHint;
  1090.  
  1091. // -----------------------------------------------------------------------------
  1092. // Enums - Manage
  1093.  
  1094. /// \brief What point in the graphics pipe should a time-stamp event happen?
  1095. ///
  1096. typedef enum _GX2PipeEvent  {
  1097.     GX2_PIPE_EVENT_TOP,                ///< top of pipe
  1098.     GX2_PIPE_EVENT_BOTTOM,             ///< bottom after reads done, before writes are flushed
  1099.     GX2_PIPE_EVENT_BOTTOM_AFTER_FLUSH, ///< bottom after GPU cache flush & invalidate
  1100.     GX2_PIPE_EVENT_LAST = GX2_PIPE_EVENT_BOTTOM_AFTER_FLUSH
  1101. } GX2PipeEvent;
  1102.  
  1103. /// \brief Type of user callback event for interrupts
  1104. ///
  1105. typedef enum _GX2CallbackEvent {
  1106.     GX2_CB_EVENT_USER_TS_TOP,     ///< results from user timestamp (top of pipe) interrupt
  1107.     GX2_CB_EVENT_USER_TS_BOTTOM,  ///< results from user timestamp (bottom of pipe) interrupt
  1108.     GX2_CB_EVENT_VSYNC,           ///< results from 60hz vsync
  1109.     GX2_CB_EVENT_FLIP,            ///< results from scan buffer flipping
  1110.     GX2_CB_EVENT_LAST = GX2_CB_EVENT_FLIP
  1111. } GX2CallbackEvent;
  1112.  
  1113. /// \brief Type of GX2 semaphore action
  1114. ///
  1115. typedef enum _GX2SemaphoreAction {
  1116.     GX2_SEMAPHORE_WAIT   = 0,   ///< Wait before processing next command
  1117.     GX2_SEMAPHORE_SIGNAL = 1    ///< Signal after all previous work is done
  1118. } GX2SemaphoreAction;
  1119.  
  1120. // -----------------------------------------------------------------------------
  1121. // Enums - Misc
  1122.  
  1123. /// \brief Specifies the type of object being flushed or invalidated.
  1124. ///
  1125. typedef enum _GX2InvalidateType
  1126. {
  1127.     GX2_INVALIDATE_ATTRIB_BUFFER   = 0x01, // invalidate input caches. main memory read is forced next time
  1128.     GX2_INVALIDATE_TEXTURE         = 0x02, // invalidate input caches. main memory read is forced next time
  1129.     GX2_INVALIDATE_UNIFORM_BLOCK    = 0x04, // invalidate input caches. main memory read is forced next time
  1130.     GX2_INVALIDATE_SHADER          = 0x08, // invalidate input caches. main memory read is forced next time
  1131.     GX2_INVALIDATE_COLOR_BUFFER    = 0x10, // flush color buffer 0-7's cache into main memory
  1132.     GX2_INVALIDATE_DEPTH_BUFFER    = 0x20, // flush depth buffer's cache into main memory
  1133.     GX2_INVALIDATE_CPU             = 0x40, // just flush cpu cache into main memory
  1134.     GX2_INVALIDATE_STREAMOUT_BUFFER = 0x80, // flush and invalidate the stream out buffer caches into main memory
  1135.  
  1136.     // For convenience, invalidate CPU cache & GPU (input) item together:
  1137.     GX2_INVALIDATE_CPU_ATTRIB_BUFFER
  1138.         = GX2_INVALIDATE_ATTRIB_BUFFER   | GX2_INVALIDATE_CPU,
  1139.     GX2_INVALIDATE_CPU_TEXTURE
  1140.         = GX2_INVALIDATE_TEXTURE         | GX2_INVALIDATE_CPU,
  1141.     GX2_INVALIDATE_CPU_UNIFORM_BLOCK
  1142.         = GX2_INVALIDATE_UNIFORM_BLOCK   | GX2_INVALIDATE_CPU,
  1143.     GX2_INVALIDATE_CPU_SHADER
  1144.         = GX2_INVALIDATE_SHADER          | GX2_INVALIDATE_CPU,
  1145.  
  1146.     GX2_INVALIDATE_CONSTANT_BUFFER  = 0x04, // deprecated name
  1147.     GX2_INVALIDATE_CPU_CONSTANT_BUFFER      // deprecated name
  1148.         = GX2_INVALIDATE_CONSTANT_BUFFER | GX2_INVALIDATE_CPU,
  1149.  
  1150.     GX2_INVALIDATE_FIRST          = GX2_INVALIDATE_ATTRIB_BUFFER,
  1151.     GX2_INVALIDATE_LAST           = 0xff
  1152. } GX2InvalidateType;
  1153.  
  1154. /// \brief Specify possible debug options for processing graphics commands.
  1155. ///
  1156. typedef enum _GX2DebugMode
  1157. {
  1158.     GX2_DEBUG_MODE_NONE                     = 0x00, // debug off
  1159.     GX2_DEBUG_MODE_FLUSH_PER_DRAW           = 0x01, // perform flush after each draw
  1160.     GX2_DEBUG_MODE_DONE_PER_FLUSH           = 0x02, // perform DrawDone after each flush
  1161.     GX2_DEBUG_MODE_FIRST                    = 0x00,
  1162.     GX2_DEBUG_MODE_LAST                     = 0x03
  1163. } GX2DebugMode;
  1164.  
  1165. /// \brief Specify possible profiling options to force off features in the graphics pipeline
  1166. ///
  1167. typedef enum _GX2ProfileMode
  1168. {
  1169.     GX2_PROFILE_MODE_NONE                     = 0x00000, ///< (0x00000) None of the options below
  1170.     GX2_PROFILE_MODE_INFINITELY_FAST_HARDWARE = 0x00001, ///< (0x00001) Command buffer are built in GX2, but they are not dispatched to the HW
  1171.     GX2_PROFILE_MODE_WIREFRAME                = 0x00002, ///< (0x00002) Render everything in wireframe mode
  1172.     GX2_PROFILE_MODE_DISABLE_ALPHABLEND       = 0x00004, ///< (0x00004) Force off color buffer reads
  1173.     GX2_PROFILE_MODE_DISABLE_COLORWRITES      = 0x00008, ///< (0x00008) Force off color buffer writes
  1174.     GX2_PROFILE_MODE_DISABLE_COLOR            = 0x00010, ///< (0x00010) Disable color buffer reads and writes
  1175.     GX2_PROFILE_MODE_MIN_VERTEX_SHADER        = 0x00020, ///< (0x00020) Always execute a minimal vertex shader
  1176.     GX2_PROFILE_MODE_MIN_GEOMETRY_SHADER      = 0x00040, ///< (0x00040) Always execute a minimal geometry shader
  1177.     GX2_PROFILE_MODE_MIN_PIXEL_SHADER         = 0x00080, ///< (0x00080) Always execute a minimal pixel shader
  1178.     GX2_PROFILE_MODE_MIN_VERTEX_FETCH         = 0x00100, ///< (0x00100) Force all vertex fetches from the cache, the stride is set to 0.
  1179.     GX2_PROFILE_MODE_MIN_TEXTURE_FETCH        = 0x00200, ///< (0x00200) Force all textures to 1 mip level with a 1x1 size
  1180.     GX2_PROFILE_MODE_DISABLE_Z                = 0x00400, ///< (0x00400) Force off Z buffering, no Z buffer reads or writes
  1181.     GX2_PROFILE_MODE_DISABLE_ZWRITES          = 0x00800, ///< (0x00800) Force off Z writes
  1182.     GX2_PROFILE_MODE_DISABLE_STENCIL          = 0x01000, ///< (0x01000) Force off stenciling, no reads or writes from the stencil buffer
  1183.     GX2_PROFILE_MODE_DISABLE_TRILINEAR        = 0x02000, ///< (0x02000) Force off trilinear texture filtering
  1184.     GX2_PROFILE_MODE_DISABLE_ANISO            = 0x04000, ///< (0x04000) Force off anisotropic texture filtering
  1185.     GX2_PROFILE_MODE_DISABLE_COLOR_CLEARS     = 0x08000, ///< (0x08000) Disable color clears
  1186.     GX2_PROFILE_MODE_DISABLE_Z_CLEARS         = 0x10000, ///< (0x10000) Disable Z clears
  1187.     GX2_PROFILE_MODE_DISABLE_STENCIL_CLEARS   = 0x20000, ///< (0x20000) Disable stencil clears
  1188.     GX2_PROFILE_MODE_DISABLE_EARLY_Z          = 0x40000, ///< (0x40000) Only use late Z (when Z is enabled)
  1189.     GX2_PROFILE_MODE_FIRST                    = 0x00000,
  1190.     GX2_PROFILE_MODE_LAST                     = 0x7ffff
  1191. } GX2ProfileMode;
  1192.  
  1193. /// \brief Define different toss points within the graphics pipeline.  A toss point is a stage in
  1194. /// the pipeline were all operations that follow are disabled.
  1195. ///
  1196. typedef enum _GX2TossStage
  1197. {
  1198.     GX2_TOSS_STAGE_NONE                  = 0, ///< (0) Full pipeline is enabled
  1199.     GX2_TOSS_STAGE_AFTER_VERTEX_FETCH    = 1, ///< (1) Vertex fetch only, the rest of the graphics pipeline is disabled
  1200.     GX2_TOSS_STAGE_AFTER_VERTEX_SHADER   = 2, ///< (2) Vertex fetch and vertex shader only
  1201.     GX2_TOSS_STAGE_AFTER_GEOMETRY_SHADER = 3, ///< (3) Vertex fetch, vertex shader, and geometry shader are enabled. The rasterizer (including clipping) is disabled
  1202.     GX2_TOSS_STAGE_AFTER_CLIPPING        = 4, ///< (4) Enable vertex processing, geometry shader and clipping. All primitives will be culled after clipping
  1203.     GX2_TOSS_STAGE_AFTER_PRIMITIVE_SETUP = 5, ///< (5) Enable vertex processing, geometry shader, clipping and primitive setup, but rasterization is disabled
  1204.     GX2_TOSS_STAGE_AFTER_SCAN_CONVERSION = 6, ///< (6) Scan conversion, HiZ, and Early Z, but no parameter interpolation
  1205.     GX2_TOSS_STAGE_AFTER_RASTERIZATION   = 7, ///< (7) Full rasterization, but pixel shader is disabled
  1206.     GX2_TOSS_STAGE_AFTER_PIXEL_SHADER    = 8, ///< (8) Full rasterization and pixel shader, but color buffer reads and writes are disabled
  1207.     GX2_TOSS_STAGE_FIRST              = GX2_TOSS_STAGE_NONE,
  1208.     GX2_TOSS_STAGE_LAST               = GX2_TOSS_STAGE_AFTER_PIXEL_SHADER
  1209. } GX2TossStage;
  1210.  
  1211.  
  1212. /// \brief  Specify the endian swap mode
  1213. typedef enum _GX2EndianSwapMode
  1214. {
  1215.     GX2_ENDIANSWAP_NONE    = 0, ///< No endian swap
  1216.     GX2_ENDIANSWAP_8IN16   = 1, ///< 8 in 16 swap
  1217.     GX2_ENDIANSWAP_8IN32   = 2, ///< 8 in 32 swap
  1218.     GX2_ENDIANSWAP_DEFAULT = 3,  ///< endian swap mode is determined based on the format
  1219.     GX2_ENDIANSWAP_FIRST   = GX2_ENDIANSWAP_NONE,
  1220.     GX2_ENDIANSWAP_LAST    = GX2_ENDIANSWAP_DEFAULT
  1221. } GX2EndianSwapMode;
  1222.  
  1223. /// \brief Specify tessellation type of mesh
  1224. ///
  1225. typedef enum _GX2TessellationMode {
  1226.     GX2_TESSELLATION_MODE_DISCRETE,
  1227.     GX2_TESSELLATION_MODE_CONTINUOUS,
  1228.     GX2_TESSELLATION_MODE_ADAPTIVE,
  1229.     GX2_TESSELLATION_MODE_FIRST      = GX2_TESSELLATION_MODE_DISCRETE,
  1230.     GX2_TESSELLATION_MODE_LAST       = GX2_TESSELLATION_MODE_ADAPTIVE
  1231. } GX2TessellationMode;
  1232.  
  1233. /// \brief Specify fetch shader type.
  1234. ///
  1235. typedef enum GX2FetchShaderType {
  1236.     GX2_FETCH_SHADER_TESSELATION_NONE      =  0x0,
  1237.     GX2_FETCH_SHADER_TESSELATION_LINES     =  0x1,
  1238.     GX2_FETCH_SHADER_TESSELATION_TRIANGLES =  0x2,
  1239.     GX2_FETCH_SHADER_TESSELATION_QUADS     =  0x3,
  1240.     GX2_FETCH_SHADER_TYPE_FIRST     =  GX2_FETCH_SHADER_TESSELATION_NONE,
  1241.     GX2_FETCH_SHADER_TYPE_LAST      =  GX2_FETCH_SHADER_TESSELATION_QUADS
  1242. } GX2FetchShaderType;
  1243.  
  1244. /// \brief Specify the query type.
  1245. ///
  1246. /// The CPU query types will be read by the CPU and are not available to be read by the GPU.
  1247. /// The GPU query types will be read by the GPU and are not available to be read by the CPU.
  1248. typedef enum _GX2QueryType
  1249. {
  1250.     GX2_QUERY_TYPE_OCCLUSION_CPU,        ///< depth-based occlusion CPU query
  1251.     GX2_QUERY_TYPE_STREAMOUT_STATS_CPU,  ///< stream-out buffer stats CPU query
  1252.     GX2_QUERY_TYPE_OCCLUSION_GPU,        ///< depth-based occlusion GPU query
  1253.     GX2_QUERY_TYPE_STREAMOUT_STATS_GPU,  ///< stream-out buffer stats GPU query
  1254.  
  1255.     GX2_QUERY_TYPE_FIRST          = GX2_QUERY_TYPE_OCCLUSION_CPU,
  1256.     GX2_QUERY_TYPE_LAST           = GX2_QUERY_TYPE_STREAMOUT_STATS_GPU
  1257. } GX2QueryType;
  1258.  
  1259. /// \brief Specify method of setting streamout offset.
  1260. ///
  1261. typedef enum _GX2StreamOutOffsetInit {
  1262.     GX2_STREAMOUT_OFFSET_READ_FROM_CONTEXT = 0x0,
  1263.     GX2_STREAMOUT_OFFSET_RESET    =  0x1,
  1264.     GX2_STREAMOUT_OFFSET_EXPLICIT =  0x2,
  1265. } GX2StreamOutOffsetInit;
  1266.  
  1267. // -----------------
  1268. // User Debug Alerts
  1269.  
  1270. /// \brief (Temporary Placeholder) UDA alert ids
  1271. ///
  1272. typedef enum _GX2UDAAlertID {
  1273.     GX2_UDAID_NOALERT               =  -1,
  1274.     GX2_UDAID_ENABLESTATESHADOWING  =   0,
  1275.     GX2_UDAID_LAST                  =   GX2_UDAID_ENABLESTATESHADOWING
  1276. } GX2UDAAlertID;
  1277.  
  1278. /// \brief (Temporary Placeholder) UDA alert levels
  1279. ///
  1280. typedef enum _GX2UDAAlertLevel
  1281. {
  1282.     GX2_UDALEVEL_NONE       = 0,    // Disable monitoring
  1283.     GX2_UDALEVEL_SEVERE     = 1,    // report usage that may cause hang
  1284.     GX2_UDALEVEL_ORDINARY   = 2,    // report usage that may cause incorrect results (includes SEVERE level)
  1285.     GX2_UDALEVEL_PEDANTIC   = 3,    // report usage that is not recommended (includes SEVERE and ORDINARY level)
  1286.     GX2_UDALEVEL_LAST       = GX2_UDALEVEL_PEDANTIC
  1287. } GX2UDAAlertLevel;
  1288.  
  1289. // -----------------
  1290. // GX2 Log
  1291.  
  1292. /// \brief Attributes to control GX2 Log function
  1293. ///
  1294. typedef enum _GXLogAttrib {
  1295.     GX2_LOG_ATTRIB_ENABLE, ///< Turn logging on or off
  1296.     GX2_LOG_ATTRIB_LAST   =   GX2_LOG_ATTRIB_ENABLE
  1297. } GX2LogAttrib;
  1298.  
  1299. // -----------------
  1300. // Capture related
  1301.  
  1302. /// Tag type for \ref GX2DebugTagUserString
  1303. typedef enum _GX2DebugTagUserStringType
  1304. {
  1305.   GX2_DEBUG_TAG_INDENT,
  1306.   GX2_DEBUG_TAG_UNDENT,
  1307.   GX2_DEBUG_TAG_COMMENT,
  1308.   GX2_DEBUG_TAG_BOOKMARK,
  1309.  
  1310.   GX2_DEBUG_TAG_FIRST=GX2_DEBUG_TAG_INDENT,
  1311.   GX2_DEBUG_TAG_LAST=GX2_DEBUG_TAG_BOOKMARK,
  1312. } GX2DebugTagUserStringType;
  1313.  
  1314. #define GX2_DEBUG_TAG_MAX_SIZE    1024
  1315.  
  1316. /// Options for \ref GX2DebugCaptureStart and \ref GX2DebugCaptureEnd
  1317. typedef enum _GX2DebugCaptureOptions
  1318. {
  1319.     GX2_DEBUG_CAPTURE_DEFAULT   =0,    ///< By default \ref GX2DebugCaptureStart calls GX2DrawDone to sync the GPU and flush any
  1320.                                        ///< previous commands before the capture starts, and \ref GX2DebugCaptureEnd calls GX2Flush
  1321.                                        ///< to capture the current CB before the capture finishes.
  1322.     GX2_DEBUG_CAPTURE_NO_FLUSH  =0x01, ///< Suppress GX2DrawDone/GX2Flush calls in \ref GX2DebugCaptureStart and \ref GX2DebugCaptureEnd
  1323. } GX2DebugCaptureOptions;
  1324.  
  1325. // -----------------
  1326. // Misc
  1327.  
  1328. /// Misc param selection
  1329. typedef enum _GX2MiscType
  1330. {
  1331.     GX2_MISC_HANG_STATE,              ///< Is the GPU ok or hung?
  1332.     GX2_MISC_HANG_RESPONSE,           ///< Action to take upon hang
  1333.     GX2_MISC_HANG_RESET_SWAP_TIMEOUT, ///< For auto-hang-detection+reset, time-out value (since last flip happened)
  1334.     GX2_MISC_HANG_RESET_SWAP_COUNT    ///< For auto-hang-detection+reset, max number of pending swaps permitted
  1335. } GX2MiscType;
  1336.  
  1337. /// Misc values for GPU Hang states
  1338. typedef enum _GX2HangState
  1339. {
  1340.     GX2_HANG_STATE_OK = 0,  ///< GPU is ok
  1341.     GX2_HANG_STATE_TS = 1,  ///< time-out waiting for time stamp
  1342.     GX2_HANG_STATE_CB = 2,  ///< time-out waiting for command buffer space
  1343.     GX2_HANG_STATE_RB = 3,  ///< time-out waiting for ring buffer space
  1344.     GX2_HANG_STATE_WF = 4,  ///< time-out waiting for scanbuffer flip
  1345.     GX2_HANG_STATE_ETC = 5, ///< GPU is hung based on other (user-set) condition
  1346. } GX2HangState;
  1347.  
  1348. /// Misc values for GPU Hang response
  1349. typedef enum _GX2HangResponse
  1350. {
  1351.     GX2_HANG_RESPONSE_NONE,  ///< Do nothing automatically
  1352.     GX2_HANG_RESPONSE_DEBUG, ///< Do a GPU state dump & infinite loop
  1353.     GX2_HANG_RESPONSE_RESET  ///< Do a GPU reset during GX2SwapScanBuffers
  1354. } GX2HangResponse;
  1355.  
  1356. /// @}
  1357.  
  1358. #ifdef __cplusplus
  1359. }
  1360. #endif // __cplusplus
  1361.  
  1362. #endif // _CAFE_GX2_ENUM_H_
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top