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