enums.h

Go to the documentation of this file.

/**
 * @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;