/** * @file enums.h * @brief GPU enumeration values. */ #pragma once /// Creates a texture magnification filter parameter from a @ref GPU_TEXTURE_FILTER_PARAM #define GPU_TEXTURE_MAG_FILTER(v) (((v)&0x1)<<1) /// Creates a texture minification filter parameter from a @ref GPU_TEXTURE_FILTER_PARAM #define GPU_TEXTURE_MIN_FILTER(v) (((v)&0x1)<<2) /// Creates a texture mipmap filter parameter from a @ref GPU_TEXTURE_FILTER_PARAM #define GPU_TEXTURE_MIP_FILTER(v) (((v)&0x1)<<24) /// Creates a texture wrap S parameter from a @ref GPU_TEXTURE_WRAP_PARAM #define GPU_TEXTURE_WRAP_S(v) (((v)&0x3)<<12) /// Creates a texture wrap T parameter from a @ref GPU_TEXTURE_WRAP_PARAM #define GPU_TEXTURE_WRAP_T(v) (((v)&0x3)<<8) /// Creates a texture mode parameter from a @ref GPU_TEXTURE_MODE_PARAM #define GPU_TEXTURE_MODE(v) (((v)&0x7)<<28) /// Texture parameter indicating ETC1 texture. #define GPU_TEXTURE_ETC1_PARAM BIT(5) /// Texture parameter indicating shadow texture. #define GPU_TEXTURE_SHADOW_PARAM BIT(20) /// Creates a combiner buffer write configuration. #define GPU_TEV_BUFFER_WRITE_CONFIG(stage0, stage1, stage2, stage3) ((stage0) | ((stage1) << 1) | ((stage2) << 2) | ((stage3) << 3)) /// Texture filters. typedef enum { GPU_NEAREST = 0x0, ///< Nearest-neighbor interpolation. GPU_LINEAR = 0x1, ///< Linear interpolation. } GPU_TEXTURE_FILTER_PARAM; /// Texture wrap modes. typedef enum { GPU_CLAMP_TO_EDGE = 0x0, ///< Clamps to edge. GPU_CLAMP_TO_BORDER = 0x1, ///< Clamps to border. GPU_REPEAT = 0x2, ///< Repeats texture. GPU_MIRRORED_REPEAT = 0x3, ///< Repeats with mirrored texture. } GPU_TEXTURE_WRAP_PARAM; /// Texture modes. typedef enum { GPU_TEX_2D = 0x0, ///< 2D texture GPU_TEX_CUBE_MAP = 0x1, ///< Cube map GPU_TEX_SHADOW_2D = 0x2, ///< 2D Shadow texture GPU_TEX_PROJECTION = 0x3, ///< Projection texture GPU_TEX_SHADOW_CUBE = 0x4, ///< Shadow cube map GPU_TEX_DISABLED = 0x5, ///< Disabled } GPU_TEXTURE_MODE_PARAM; /// Supported texture units. typedef enum { GPU_TEXUNIT0 = 0x1, ///< Texture unit 0. GPU_TEXUNIT1 = 0x2, ///< Texture unit 1. GPU_TEXUNIT2 = 0x4, ///< Texture unit 2. } GPU_TEXUNIT; /// Supported texture formats. typedef enum { GPU_RGBA8 = 0x0, ///< 8-bit Red + 8-bit Green + 8-bit Blue + 8-bit Alpha GPU_RGB8 = 0x1, ///< 8-bit Red + 8-bit Green + 8-bit Blue GPU_RGBA5551 = 0x2, ///< 5-bit Red + 5-bit Green + 5-bit Blue + 1-bit Alpha GPU_RGB565 = 0x3, ///< 5-bit Red + 6-bit Green + 5-bit Blue GPU_RGBA4 = 0x4, ///< 4-bit Red + 4-bit Green + 4-bit Blue + 4-bit Alpha GPU_LA8 = 0x5, ///< 8-bit Luminance + 8-bit Alpha GPU_HILO8 = 0x6, ///< 8-bit Hi + 8-bit Lo GPU_L8 = 0x7, ///< 8-bit Luminance GPU_A8 = 0x8, ///< 8-bit Alpha GPU_LA4 = 0x9, ///< 4-bit Luminance + 4-bit Alpha GPU_L4 = 0xA, ///< 4-bit Luminance GPU_A4 = 0xB, ///< 4-bit Alpha GPU_ETC1 = 0xC, ///< ETC1 texture compression GPU_ETC1A4 = 0xD, ///< ETC1 texture compression + 4-bit Alpha } GPU_TEXCOLOR; /// Texture faces. typedef enum { GPU_TEXFACE_2D = 0, ///< 2D face GPU_POSITIVE_X = 0, ///< +X face GPU_NEGATIVE_X = 1, ///< -X face GPU_POSITIVE_Y = 2, ///< +Y face GPU_NEGATIVE_Y = 3, ///< -Y face GPU_POSITIVE_Z = 4, ///< +Z face GPU_NEGATIVE_Z = 5, ///< -Z face } GPU_TEXFACE; /// Procedural texture clamp modes. typedef enum { GPU_PT_CLAMP_TO_ZERO = 0, ///< Clamp to zero. GPU_PT_CLAMP_TO_EDGE = 1, ///< Clamp to edge. GPU_PT_REPEAT = 2, ///< Symmetrical repeat. GPU_PT_MIRRORED_REPEAT = 3, ///< Mirrored repeat. GPU_PT_PULSE = 4, ///< Pulse. } GPU_PROCTEX_CLAMP; /// Procedural texture mapping functions. typedef enum { GPU_PT_U = 0, ///< U GPU_PT_U2 = 1, ///< U2 GPU_PT_V = 2, ///< V GPU_PT_V2 = 3, ///< V2 GPU_PT_ADD = 4, ///< U+V GPU_PT_ADD2 = 5, ///< U2+V2 GPU_PT_SQRT2 = 6, ///< sqrt(U2+V2) GPU_PT_MIN = 7, ///< min GPU_PT_MAX = 8, ///< max GPU_PT_RMAX = 9, ///< rmax } GPU_PROCTEX_MAPFUNC; /// Procedural texture shift values. typedef enum { GPU_PT_NONE = 0, ///< No shift. GPU_PT_ODD = 1, ///< Odd shift. GPU_PT_EVEN = 2, ///< Even shift. } GPU_PROCTEX_SHIFT; /// Procedural texture filter values. typedef enum { GPU_PT_NEAREST = 0, ///< Nearest-neighbor GPU_PT_LINEAR = 1, ///< Linear interpolation GPU_PT_NEAREST_MIP_NEAREST = 2, ///< Nearest-neighbor with mipmap using nearest-neighbor GPU_PT_LINEAR_MIP_NEAREST = 3, ///< Linear interpolation with mipmap using nearest-neighbor GPU_PT_NEAREST_MIP_LINEAR = 4, ///< Nearest-neighbor with mipmap using linear interpolation GPU_PT_LINEAR_MIP_LINEAR = 5, ///< Linear interpolation with mipmap using linear interpolation } GPU_PROCTEX_FILTER; /// Procedural texture LUT IDs. typedef enum { GPU_LUT_NOISE = 0, ///< Noise table GPU_LUT_RGBMAP = 2, ///< RGB mapping function table GPU_LUT_ALPHAMAP = 3, ///< Alpha mapping function table GPU_LUT_COLOR = 4, ///< Color table GPU_LUT_COLORDIF = 5, ///< Color difference table } GPU_PROCTEX_LUTID; /// Supported color buffer formats. typedef enum { GPU_RB_RGBA8 = 0, ///< 8-bit Red + 8-bit Green + 8-bit Blue + 8-bit Alpha GPU_RB_RGB8 = 1, ///< 8-bit Red + 8-bit Green + 8-bit Blue GPU_RB_RGBA5551 = 2, ///< 5-bit Red + 5-bit Green + 5-bit Blue + 1-bit Alpha GPU_RB_RGB565 = 3, ///< 5-bit Red + 6-bit Green + 5-bit Blue GPU_RB_RGBA4 = 4, ///< 4-bit Red + 4-bit Green + 4-bit Blue + 4-bit Alpha } GPU_COLORBUF; /// Supported depth buffer formats. typedef enum { GPU_RB_DEPTH16 = 0, ///< 16-bit Depth GPU_RB_DEPTH24 = 2, ///< 24-bit Depth GPU_RB_DEPTH24_STENCIL8 = 3, ///< 24-bit Depth + 8-bit Stencil } GPU_DEPTHBUF; /// Test functions. typedef enum { GPU_NEVER = 0, ///< Never pass. GPU_ALWAYS = 1, ///< Always pass. GPU_EQUAL = 2, ///< Pass if equal. GPU_NOTEQUAL = 3, ///< Pass if not equal. GPU_LESS = 4, ///< Pass if less than. GPU_LEQUAL = 5, ///< Pass if less than or equal. GPU_GREATER = 6, ///< Pass if greater than. GPU_GEQUAL = 7, ///< Pass if greater than or equal. } GPU_TESTFUNC; /// Early depth test functions. typedef enum { GPU_EARLYDEPTH_GEQUAL = 0, ///< Pass if greater than or equal. GPU_EARLYDEPTH_GREATER = 1, ///< Pass if greater than. GPU_EARLYDEPTH_LEQUAL = 2, ///< Pass if less than or equal. GPU_EARLYDEPTH_LESS = 3, ///< Pass if less than. } GPU_EARLYDEPTHFUNC; /// Gas depth functions. typedef enum { GPU_GAS_NEVER = 0, ///< Never pass (0). GPU_GAS_ALWAYS = 1, ///< Always pass (1). GPU_GAS_GREATER = 2, ///< Pass if greater than (1-X). GPU_GAS_LESS = 3, ///< Pass if less than (X). } GPU_GASDEPTHFUNC; /// Converts \ref GPU_TESTFUNC into \ref GPU_GASDEPTHFUNC. #define GPU_MAKEGASDEPTHFUNC(n) (GPU_GASDEPTHFUNC)((0xAF02>>((int)(n)<<1))&3) /// Scissor test modes. typedef enum { GPU_SCISSOR_DISABLE = 0, ///< Disable. GPU_SCISSOR_INVERT = 1, ///< Exclude pixels inside the scissor box. // 2 is the same as 0 GPU_SCISSOR_NORMAL = 3, ///< Exclude pixels outside of the scissor box. } GPU_SCISSORMODE; /// Stencil operations. typedef enum { GPU_STENCIL_KEEP = 0, ///< Keep old value. (old_stencil) GPU_STENCIL_ZERO = 1, ///< Zero. (0) GPU_STENCIL_REPLACE = 2, ///< Replace value. (ref) GPU_STENCIL_INCR = 3, ///< Increment value. (old_stencil + 1 saturated to [0, 255]) GPU_STENCIL_DECR = 4, ///< Decrement value. (old_stencil - 1 saturated to [0, 255]) GPU_STENCIL_INVERT = 5, ///< Invert value. (~old_stencil) GPU_STENCIL_INCR_WRAP = 6, ///< Increment value. (old_stencil + 1) GPU_STENCIL_DECR_WRAP = 7, ///< Decrement value. (old_stencil - 1) } GPU_STENCILOP; /// Pixel write mask. typedef enum { GPU_WRITE_RED = 0x01, ///< Write red. GPU_WRITE_GREEN = 0x02, ///< Write green. GPU_WRITE_BLUE = 0x04, ///< Write blue. GPU_WRITE_ALPHA = 0x08, ///< Write alpha. GPU_WRITE_DEPTH = 0x10, ///< Write depth. GPU_WRITE_COLOR = 0x0F, ///< Write all color components. GPU_WRITE_ALL = 0x1F, ///< Write all components. } GPU_WRITEMASK; /// Blend modes. typedef enum { GPU_BLEND_ADD = 0, ///< Add colors. GPU_BLEND_SUBTRACT = 1, ///< Subtract colors. GPU_BLEND_REVERSE_SUBTRACT = 2, ///< Reverse-subtract colors. GPU_BLEND_MIN = 3, ///< Use the minimum color. GPU_BLEND_MAX = 4, ///< Use the maximum color. } GPU_BLENDEQUATION; /// Blend factors. typedef enum { GPU_ZERO = 0, ///< Zero. GPU_ONE = 1, ///< One. GPU_SRC_COLOR = 2, ///< Source color. GPU_ONE_MINUS_SRC_COLOR = 3, ///< Source color - 1. GPU_DST_COLOR = 4, ///< Destination color. GPU_ONE_MINUS_DST_COLOR = 5, ///< Destination color - 1. GPU_SRC_ALPHA = 6, ///< Source alpha. GPU_ONE_MINUS_SRC_ALPHA = 7, ///< Source alpha - 1. GPU_DST_ALPHA = 8, ///< Destination alpha. GPU_ONE_MINUS_DST_ALPHA = 9, ///< Destination alpha - 1. GPU_CONSTANT_COLOR = 10, ///< Constant color. GPU_ONE_MINUS_CONSTANT_COLOR = 11, ///< Constant color - 1. GPU_CONSTANT_ALPHA = 12, ///< Constant alpha. GPU_ONE_MINUS_CONSTANT_ALPHA = 13, ///< Constant alpha - 1. GPU_SRC_ALPHA_SATURATE = 14, ///< Saturated alpha. } GPU_BLENDFACTOR; /// Logical operations. typedef enum { GPU_LOGICOP_CLEAR = 0, ///< Clear. GPU_LOGICOP_AND = 1, ///< Bitwise AND. GPU_LOGICOP_AND_REVERSE = 2, ///< Reverse bitwise AND. GPU_LOGICOP_COPY = 3, ///< Copy. GPU_LOGICOP_SET = 4, ///< Set. GPU_LOGICOP_COPY_INVERTED = 5, ///< Inverted copy. GPU_LOGICOP_NOOP = 6, ///< No operation. GPU_LOGICOP_INVERT = 7, ///< Invert. GPU_LOGICOP_NAND = 8, ///< Bitwise NAND. GPU_LOGICOP_OR = 9, ///< Bitwise OR. GPU_LOGICOP_NOR = 10, ///< Bitwise NOR. GPU_LOGICOP_XOR = 11, ///< Bitwise XOR. GPU_LOGICOP_EQUIV = 12, ///< Equivalent. GPU_LOGICOP_AND_INVERTED = 13, ///< Inverted bitwise AND. GPU_LOGICOP_OR_REVERSE = 14, ///< Reverse bitwise OR. GPU_LOGICOP_OR_INVERTED = 15, ///< Inverted bitwize OR. } GPU_LOGICOP; /// Fragment operation modes. typedef enum { GPU_FRAGOPMODE_GL = 0, ///< OpenGL mode. GPU_FRAGOPMODE_GAS_ACC = 1, ///< Gas mode (?). GPU_FRAGOPMODE_SHADOW = 3, ///< Shadow mode (?). } GPU_FRAGOPMODE; /// Supported component formats. typedef enum { GPU_BYTE = 0, ///< 8-bit byte. GPU_UNSIGNED_BYTE = 1, ///< 8-bit unsigned byte. GPU_SHORT = 2, ///< 16-bit short. GPU_FLOAT = 3, ///< 32-bit float. } GPU_FORMATS; /// Cull modes. typedef enum { GPU_CULL_NONE = 0, ///< Disabled. GPU_CULL_FRONT_CCW = 1, ///< Front, counter-clockwise. GPU_CULL_BACK_CCW = 2, ///< Back, counter-clockwise. } GPU_CULLMODE; /// Creates a VBO attribute parameter from its index, size, and format. #define GPU_ATTRIBFMT(i, n, f) (((((n)-1)<<2)|((f)&3))<<((i)*4)) /// Texture combiner sources. typedef enum { GPU_PRIMARY_COLOR = 0x00, ///< Primary color. GPU_FRAGMENT_PRIMARY_COLOR = 0x01, ///< Primary fragment color. GPU_FRAGMENT_SECONDARY_COLOR = 0x02, ///< Secondary fragment color. GPU_TEXTURE0 = 0x03, ///< Texture unit 0. GPU_TEXTURE1 = 0x04, ///< Texture unit 1. GPU_TEXTURE2 = 0x05, ///< Texture unit 2. GPU_TEXTURE3 = 0x06, ///< Texture unit 3. GPU_PREVIOUS_BUFFER = 0x0D, ///< Previous buffer. GPU_CONSTANT = 0x0E, ///< Constant value. GPU_PREVIOUS = 0x0F, ///< Previous value. } GPU_TEVSRC; /// Texture RGB combiner operands. typedef enum { GPU_TEVOP_RGB_SRC_COLOR = 0x00, ///< Source color. GPU_TEVOP_RGB_ONE_MINUS_SRC_COLOR = 0x01, ///< Source color - 1. GPU_TEVOP_RGB_SRC_ALPHA = 0x02, ///< Source alpha. GPU_TEVOP_RGB_ONE_MINUS_SRC_ALPHA = 0x03, ///< Source alpha - 1. GPU_TEVOP_RGB_SRC_R = 0x04, ///< Source red. GPU_TEVOP_RGB_ONE_MINUS_SRC_R = 0x05, ///< Source red - 1. GPU_TEVOP_RGB_0x06 = 0x06, ///< Unknown. GPU_TEVOP_RGB_0x07 = 0x07, ///< Unknown. GPU_TEVOP_RGB_SRC_G = 0x08, ///< Source green. GPU_TEVOP_RGB_ONE_MINUS_SRC_G = 0x09, ///< Source green - 1. GPU_TEVOP_RGB_0x0A = 0x0A, ///< Unknown. GPU_TEVOP_RGB_0x0B = 0x0B, ///< Unknown. GPU_TEVOP_RGB_SRC_B = 0x0C, ///< Source blue. GPU_TEVOP_RGB_ONE_MINUS_SRC_B = 0x0D, ///< Source blue - 1. GPU_TEVOP_RGB_0x0E = 0x0E, ///< Unknown. GPU_TEVOP_RGB_0x0F = 0x0F, ///< Unknown. } GPU_TEVOP_RGB; /// Texture Alpha combiner operands. typedef enum { GPU_TEVOP_A_SRC_ALPHA = 0x00, ///< Source alpha. GPU_TEVOP_A_ONE_MINUS_SRC_ALPHA = 0x01, ///< Source alpha - 1. GPU_TEVOP_A_SRC_R = 0x02, ///< Source red. GPU_TEVOP_A_ONE_MINUS_SRC_R = 0x03, ///< Source red - 1. GPU_TEVOP_A_SRC_G = 0x04, ///< Source green. GPU_TEVOP_A_ONE_MINUS_SRC_G = 0x05, ///< Source green - 1. GPU_TEVOP_A_SRC_B = 0x06, ///< Source blue. GPU_TEVOP_A_ONE_MINUS_SRC_B = 0x07, ///< Source blue - 1. } GPU_TEVOP_A; /// Texture combiner functions. typedef enum { GPU_REPLACE = 0x00, ///< Replace. GPU_MODULATE = 0x01, ///< Modulate. GPU_ADD = 0x02, ///< Add. GPU_ADD_SIGNED = 0x03, ///< Signed add. GPU_INTERPOLATE = 0x04, ///< Interpolate. GPU_SUBTRACT = 0x05, ///< Subtract. GPU_DOT3_RGB = 0x06, ///< Dot3. Scalar result is written to RGB only. GPU_DOT3_RGBA = 0x07, ///< Dot3. Scalar result is written to RGBA. GPU_MULTIPLY_ADD = 0x08, ///< Multiply then add. GPU_ADD_MULTIPLY = 0x09, ///< Add then multiply. } GPU_COMBINEFUNC; /// Texture scale factors. typedef enum { GPU_TEVSCALE_1 = 0x0, ///< 1x GPU_TEVSCALE_2 = 0x1, ///< 2x GPU_TEVSCALE_4 = 0x2, ///< 4x } GPU_TEVSCALE; /// Creates a texture combiner source parameter from three sources. #define GPU_TEVSOURCES(a,b,c) (((a))|((b)<<4)|((c)<<8)) /// Creates a texture combiner operand parameter from three operands. #define GPU_TEVOPERANDS(a,b,c) (((a))|((b)<<4)|((c)<<8)) /// Creates a light environment layer configuration parameter. #define GPU_LIGHT_ENV_LAYER_CONFIG(n) ((n)+((n)==7)) /// Light shadow disable bits in GPUREG_LIGHT_CONFIG1. #define GPU_LC1_SHADOWBIT(n) BIT(n) /// Light spot disable bits in GPUREG_LIGHT_CONFIG1. #define GPU_LC1_SPOTBIT(n) BIT((n)+8) /// LUT disable bits in GPUREG_LIGHT_CONFIG1. #define GPU_LC1_LUTBIT(n) BIT((n)+16) /// Light distance attenuation disable bits in GPUREG_LIGHT_CONFIG1. #define GPU_LC1_ATTNBIT(n) BIT((n)+24) /// Creates a light permutation parameter. #define GPU_LIGHTPERM(i,n) ((n) << ((i)*4)) /// Creates a light LUT input parameter. #define GPU_LIGHTLUTINPUT(i,n) ((n) << ((i)*4)) /// Creates a light LUT index parameter. #define GPU_LIGHTLUTIDX(c,i,o) ((o) | ((i) << 8) | ((c) << 11)) /// Creates a light color parameter from red, green, and blue components. #define GPU_LIGHTCOLOR(r,g,b) (((b) & 0xFF) | (((g) << 10) & 0xFF) | (((r) << 20) & 0xFF)) /// Fresnel options. typedef enum { GPU_NO_FRESNEL = 0, ///< None. GPU_PRI_ALPHA_FRESNEL = 1, ///< Primary alpha. GPU_SEC_ALPHA_FRESNEL = 2, ///< Secondary alpha. GPU_PRI_SEC_ALPHA_FRESNEL = 3, ///< Primary and secondary alpha. } GPU_FRESNELSEL; /// Bump map modes. typedef enum { GPU_BUMP_NOT_USED = 0, ///< Disabled. GPU_BUMP_AS_BUMP = 1, ///< Bump as bump mapping. GPU_BUMP_AS_TANG = 2, ///< Bump as tangent/normal mapping. } GPU_BUMPMODE; /// LUT IDs. typedef enum { GPU_LUT_D0 = 0, ///< D0 LUT. GPU_LUT_D1 = 1, ///< D1 LUT. GPU_LUT_SP = 2, ///< Spotlight LUT. GPU_LUT_FR = 3, ///< Fresnel LUT. GPU_LUT_RB = 4, ///< Reflection-Blue LUT. GPU_LUT_RG = 5, ///< Reflection-Green LUT. GPU_LUT_RR = 6, ///< Reflection-Red LUT. GPU_LUT_DA = 7, ///< Distance attenuation LUT. } GPU_LIGHTLUTID; /// LUT inputs. typedef enum { GPU_LUTINPUT_NH = 0, ///< Normal*HalfVector GPU_LUTINPUT_VH = 1, ///< View*HalfVector GPU_LUTINPUT_NV = 2, ///< Normal*View GPU_LUTINPUT_LN = 3, ///< LightVector*Normal GPU_LUTINPUT_SP = 4, ///< -LightVector*SpotlightVector GPU_LUTINPUT_CP = 5, ///< cosine of phi } GPU_LIGHTLUTINPUT; /// LUT scalers. typedef enum { GPU_LUTSCALER_1x = 0, ///< 1x scale. GPU_LUTSCALER_2x = 1, ///< 2x scale. GPU_LUTSCALER_4x = 2, ///< 4x scale. GPU_LUTSCALER_8x = 3, ///< 8x scale. GPU_LUTSCALER_0_25x = 6, ///< 0.25x scale. GPU_LUTSCALER_0_5x = 7, ///< 0.5x scale. } GPU_LIGHTLUTSCALER; /// LUT selection. typedef enum { GPU_LUTSELECT_COMMON = 0, ///< LUTs that are common to all lights. GPU_LUTSELECT_SP = 1, ///< Spotlight LUT. GPU_LUTSELECT_DA = 2, ///< Distance attenuation LUT. } GPU_LIGHTLUTSELECT; /// Fog modes. typedef enum { GPU_NO_FOG = 0, ///< Fog/Gas unit disabled. GPU_FOG = 5, ///< Fog/Gas unit configured in Fog mode. GPU_GAS = 7, ///< Fog/Gas unit configured in Gas mode. } GPU_FOGMODE; /// Gas shading density source values. typedef enum { GPU_PLAIN_DENSITY = 0, ///< Plain density. GPU_DEPTH_DENSITY = 1, ///< Depth density. } GPU_GASMODE; /// Gas color LUT inputs. typedef enum { GPU_GAS_DENSITY = 0, ///< Gas density used as input. GPU_GAS_LIGHT_FACTOR = 1, ///< Light factor used as input. } GPU_GASLUTINPUT; /// Supported primitives. typedef enum { GPU_TRIANGLES = 0x0000, ///< Triangles. GPU_TRIANGLE_STRIP = 0x0100, ///< Triangle strip. GPU_TRIANGLE_FAN = 0x0200, ///< Triangle fan. GPU_GEOMETRY_PRIM = 0x0300, ///< Geometry shader primitive. } GPU_Primitive_t; /// Shader types. typedef enum { GPU_VERTEX_SHADER = 0x0, ///< Vertex shader. GPU_GEOMETRY_SHADER = 0x1, ///< Geometry shader. } GPU_SHADER_TYPE;