X-Git-Url: https://git.libre-soc.org/?p=mesa.git;a=blobdiff_plain;f=src%2Fcompiler%2Fshader_enums.h;h=69240b4cb6cad384edc9a87a1136bbcad8eb0287;hp=a69905cb7d4b8db8ab639ac147ea18825f9a9097;hb=ff124e3fe3e89c594b91e62d3e233cfc2af3ef34;hpb=ac1181ffbef5250cb3b651e047cce5116727c34c diff --git a/src/compiler/shader_enums.h b/src/compiler/shader_enums.h index a69905cb7d4..69240b4cb6c 100644 --- a/src/compiler/shader_enums.h +++ b/src/compiler/shader_enums.h @@ -26,6 +26,11 @@ #ifndef SHADER_ENUMS_H #define SHADER_ENUMS_H +#include + +/* Project-wide (GL and Vulkan) maximum. */ +#define MAX_DRAW_BUFFERS 8 + #ifdef __cplusplus extern "C" { #endif @@ -39,14 +44,31 @@ extern "C" { */ typedef enum { + MESA_SHADER_NONE = -1, MESA_SHADER_VERTEX = 0, MESA_SHADER_TESS_CTRL = 1, MESA_SHADER_TESS_EVAL = 2, MESA_SHADER_GEOMETRY = 3, MESA_SHADER_FRAGMENT = 4, MESA_SHADER_COMPUTE = 5, + /* must be last so it doesn't affect the GL pipeline */ + MESA_SHADER_KERNEL = 6, } gl_shader_stage; +static inline bool +gl_shader_stage_is_compute(gl_shader_stage stage) +{ + return stage == MESA_SHADER_COMPUTE || stage == MESA_SHADER_KERNEL; +} + +/** + * Number of STATE_* values we need to address any GL state. + * Used to dimension arrays. + */ +#define STATE_LENGTH 5 + +typedef short gl_state_index16; /* see enum gl_state_index */ + const char *gl_shader_stage_name(gl_shader_stage stage); /** @@ -61,8 +83,16 @@ const char *_mesa_shader_stage_to_string(unsigned stage); */ const char *_mesa_shader_stage_to_abbrev(unsigned stage); +/** + * GL related stages (not including CL) + */ #define MESA_SHADER_STAGES (MESA_SHADER_COMPUTE + 1) +/** + * All stages + */ +#define MESA_ALL_SHADER_STAGES (MESA_SHADER_KERNEL + 1) + /** * Indexes for vertex program attributes. @@ -73,40 +103,39 @@ const char *_mesa_shader_stage_to_abbrev(unsigned stage); */ typedef enum { - VERT_ATTRIB_POS = 0, - VERT_ATTRIB_WEIGHT = 1, - VERT_ATTRIB_NORMAL = 2, - VERT_ATTRIB_COLOR0 = 3, - VERT_ATTRIB_COLOR1 = 4, - VERT_ATTRIB_FOG = 5, - VERT_ATTRIB_COLOR_INDEX = 6, - VERT_ATTRIB_EDGEFLAG = 7, - VERT_ATTRIB_TEX0 = 8, - VERT_ATTRIB_TEX1 = 9, - VERT_ATTRIB_TEX2 = 10, - VERT_ATTRIB_TEX3 = 11, - VERT_ATTRIB_TEX4 = 12, - VERT_ATTRIB_TEX5 = 13, - VERT_ATTRIB_TEX6 = 14, - VERT_ATTRIB_TEX7 = 15, - VERT_ATTRIB_POINT_SIZE = 16, - VERT_ATTRIB_GENERIC0 = 17, - VERT_ATTRIB_GENERIC1 = 18, - VERT_ATTRIB_GENERIC2 = 19, - VERT_ATTRIB_GENERIC3 = 20, - VERT_ATTRIB_GENERIC4 = 21, - VERT_ATTRIB_GENERIC5 = 22, - VERT_ATTRIB_GENERIC6 = 23, - VERT_ATTRIB_GENERIC7 = 24, - VERT_ATTRIB_GENERIC8 = 25, - VERT_ATTRIB_GENERIC9 = 26, - VERT_ATTRIB_GENERIC10 = 27, - VERT_ATTRIB_GENERIC11 = 28, - VERT_ATTRIB_GENERIC12 = 29, - VERT_ATTRIB_GENERIC13 = 30, - VERT_ATTRIB_GENERIC14 = 31, - VERT_ATTRIB_GENERIC15 = 32, - VERT_ATTRIB_MAX = 33 + VERT_ATTRIB_POS, + VERT_ATTRIB_NORMAL, + VERT_ATTRIB_COLOR0, + VERT_ATTRIB_COLOR1, + VERT_ATTRIB_FOG, + VERT_ATTRIB_COLOR_INDEX, + VERT_ATTRIB_EDGEFLAG, + VERT_ATTRIB_TEX0, + VERT_ATTRIB_TEX1, + VERT_ATTRIB_TEX2, + VERT_ATTRIB_TEX3, + VERT_ATTRIB_TEX4, + VERT_ATTRIB_TEX5, + VERT_ATTRIB_TEX6, + VERT_ATTRIB_TEX7, + VERT_ATTRIB_POINT_SIZE, + VERT_ATTRIB_GENERIC0, + VERT_ATTRIB_GENERIC1, + VERT_ATTRIB_GENERIC2, + VERT_ATTRIB_GENERIC3, + VERT_ATTRIB_GENERIC4, + VERT_ATTRIB_GENERIC5, + VERT_ATTRIB_GENERIC6, + VERT_ATTRIB_GENERIC7, + VERT_ATTRIB_GENERIC8, + VERT_ATTRIB_GENERIC9, + VERT_ATTRIB_GENERIC10, + VERT_ATTRIB_GENERIC11, + VERT_ATTRIB_GENERIC12, + VERT_ATTRIB_GENERIC13, + VERT_ATTRIB_GENERIC14, + VERT_ATTRIB_GENERIC15, + VERT_ATTRIB_MAX } gl_vert_attrib; const char *gl_vert_attrib_name(gl_vert_attrib attrib); @@ -124,6 +153,11 @@ const char *gl_vert_attrib_name(gl_vert_attrib attrib); * VERT_ATTRIB_GENERIC * include the OpenGL 2.0+ GLSL generic shader attributes. * These alias the generic GL_ARB_vertex_shader attributes. + * VERT_ATTRIB_MAT + * include the generic shader attributes used to alias + * varying material values for the TNL shader programs. + * They are located at the end of the generic attribute + * block not to overlap with the generic 0 attribute. */ #define VERT_ATTRIB_FF(i) (VERT_ATTRIB_POS + (i)) #define VERT_ATTRIB_FF_MAX VERT_ATTRIB_GENERIC0 @@ -134,44 +168,54 @@ const char *gl_vert_attrib_name(gl_vert_attrib attrib); #define VERT_ATTRIB_GENERIC(i) (VERT_ATTRIB_GENERIC0 + (i)) #define VERT_ATTRIB_GENERIC_MAX MAX_VERTEX_GENERIC_ATTRIBS +#define VERT_ATTRIB_MAT0 \ + (VERT_ATTRIB_GENERIC_MAX - VERT_ATTRIB_MAT_MAX) +#define VERT_ATTRIB_MAT(i) \ + VERT_ATTRIB_GENERIC((i) + VERT_ATTRIB_MAT0) +#define VERT_ATTRIB_MAT_MAX MAT_ATTRIB_MAX + /** * Bitflags for vertex attributes. * These are used in bitfields in many places. */ /*@{*/ -#define VERT_BIT_POS BITFIELD64_BIT(VERT_ATTRIB_POS) -#define VERT_BIT_WEIGHT BITFIELD64_BIT(VERT_ATTRIB_WEIGHT) -#define VERT_BIT_NORMAL BITFIELD64_BIT(VERT_ATTRIB_NORMAL) -#define VERT_BIT_COLOR0 BITFIELD64_BIT(VERT_ATTRIB_COLOR0) -#define VERT_BIT_COLOR1 BITFIELD64_BIT(VERT_ATTRIB_COLOR1) -#define VERT_BIT_FOG BITFIELD64_BIT(VERT_ATTRIB_FOG) -#define VERT_BIT_COLOR_INDEX BITFIELD64_BIT(VERT_ATTRIB_COLOR_INDEX) -#define VERT_BIT_EDGEFLAG BITFIELD64_BIT(VERT_ATTRIB_EDGEFLAG) -#define VERT_BIT_TEX0 BITFIELD64_BIT(VERT_ATTRIB_TEX0) -#define VERT_BIT_TEX1 BITFIELD64_BIT(VERT_ATTRIB_TEX1) -#define VERT_BIT_TEX2 BITFIELD64_BIT(VERT_ATTRIB_TEX2) -#define VERT_BIT_TEX3 BITFIELD64_BIT(VERT_ATTRIB_TEX3) -#define VERT_BIT_TEX4 BITFIELD64_BIT(VERT_ATTRIB_TEX4) -#define VERT_BIT_TEX5 BITFIELD64_BIT(VERT_ATTRIB_TEX5) -#define VERT_BIT_TEX6 BITFIELD64_BIT(VERT_ATTRIB_TEX6) -#define VERT_BIT_TEX7 BITFIELD64_BIT(VERT_ATTRIB_TEX7) -#define VERT_BIT_POINT_SIZE BITFIELD64_BIT(VERT_ATTRIB_POINT_SIZE) -#define VERT_BIT_GENERIC0 BITFIELD64_BIT(VERT_ATTRIB_GENERIC0) - -#define VERT_BIT(i) BITFIELD64_BIT(i) -#define VERT_BIT_ALL BITFIELD64_RANGE(0, VERT_ATTRIB_MAX) +#define VERT_BIT_POS BITFIELD_BIT(VERT_ATTRIB_POS) +#define VERT_BIT_NORMAL BITFIELD_BIT(VERT_ATTRIB_NORMAL) +#define VERT_BIT_COLOR0 BITFIELD_BIT(VERT_ATTRIB_COLOR0) +#define VERT_BIT_COLOR1 BITFIELD_BIT(VERT_ATTRIB_COLOR1) +#define VERT_BIT_FOG BITFIELD_BIT(VERT_ATTRIB_FOG) +#define VERT_BIT_COLOR_INDEX BITFIELD_BIT(VERT_ATTRIB_COLOR_INDEX) +#define VERT_BIT_EDGEFLAG BITFIELD_BIT(VERT_ATTRIB_EDGEFLAG) +#define VERT_BIT_TEX0 BITFIELD_BIT(VERT_ATTRIB_TEX0) +#define VERT_BIT_TEX1 BITFIELD_BIT(VERT_ATTRIB_TEX1) +#define VERT_BIT_TEX2 BITFIELD_BIT(VERT_ATTRIB_TEX2) +#define VERT_BIT_TEX3 BITFIELD_BIT(VERT_ATTRIB_TEX3) +#define VERT_BIT_TEX4 BITFIELD_BIT(VERT_ATTRIB_TEX4) +#define VERT_BIT_TEX5 BITFIELD_BIT(VERT_ATTRIB_TEX5) +#define VERT_BIT_TEX6 BITFIELD_BIT(VERT_ATTRIB_TEX6) +#define VERT_BIT_TEX7 BITFIELD_BIT(VERT_ATTRIB_TEX7) +#define VERT_BIT_POINT_SIZE BITFIELD_BIT(VERT_ATTRIB_POINT_SIZE) +#define VERT_BIT_GENERIC0 BITFIELD_BIT(VERT_ATTRIB_GENERIC0) + +#define VERT_BIT(i) BITFIELD_BIT(i) +#define VERT_BIT_ALL BITFIELD_RANGE(0, VERT_ATTRIB_MAX) #define VERT_BIT_FF(i) VERT_BIT(i) -#define VERT_BIT_FF_ALL BITFIELD64_RANGE(0, VERT_ATTRIB_FF_MAX) +#define VERT_BIT_FF_ALL BITFIELD_RANGE(0, VERT_ATTRIB_FF_MAX) #define VERT_BIT_TEX(i) VERT_BIT(VERT_ATTRIB_TEX(i)) #define VERT_BIT_TEX_ALL \ - BITFIELD64_RANGE(VERT_ATTRIB_TEX(0), VERT_ATTRIB_TEX_MAX) + BITFIELD_RANGE(VERT_ATTRIB_TEX(0), VERT_ATTRIB_TEX_MAX) #define VERT_BIT_GENERIC(i) VERT_BIT(VERT_ATTRIB_GENERIC(i)) #define VERT_BIT_GENERIC_ALL \ - BITFIELD64_RANGE(VERT_ATTRIB_GENERIC(0), VERT_ATTRIB_GENERIC_MAX) + BITFIELD_RANGE(VERT_ATTRIB_GENERIC(0), VERT_ATTRIB_GENERIC_MAX) + +#define VERT_BIT_MAT(i) VERT_BIT(VERT_ATTRIB_MAT(i)) +#define VERT_BIT_MAT_ALL \ + BITFIELD_RANGE(VERT_ATTRIB_MAT(0), VERT_ATTRIB_MAT_MAX) /*@}*/ +#define MAX_VARYING 32 /**< number of float[4] vectors */ /** * Indexes for vertex shader outputs, geometry shader inputs/outputs, and @@ -214,6 +258,10 @@ typedef enum VARYING_SLOT_PNTC, /* FS only */ VARYING_SLOT_TESS_LEVEL_OUTER, /* Only appears as TCS output. */ VARYING_SLOT_TESS_LEVEL_INNER, /* Only appears as TCS output. */ + VARYING_SLOT_BOUNDING_BOX0, /* Only appears as TCS output. */ + VARYING_SLOT_BOUNDING_BOX1, /* Only appears as TCS output. */ + VARYING_SLOT_VIEW_INDEX, + VARYING_SLOT_VIEWPORT_MASK, /* Does not appear in FS */ VARYING_SLOT_VAR0, /* First generic varying slot */ /* the remaining are simply for the benefit of gl_varying_slot_name() * and not to be construed as an upper bound: @@ -281,6 +329,10 @@ const char *gl_varying_slot_name(gl_varying_slot slot); #define VARYING_BIT_PSIZ BITFIELD64_BIT(VARYING_SLOT_PSIZ) #define VARYING_BIT_BFC0 BITFIELD64_BIT(VARYING_SLOT_BFC0) #define VARYING_BIT_BFC1 BITFIELD64_BIT(VARYING_SLOT_BFC1) +#define VARYING_BITS_COLOR (VARYING_BIT_COL0 | \ + VARYING_BIT_COL1 | \ + VARYING_BIT_BFC0 | \ + VARYING_BIT_BFC1) #define VARYING_BIT_EDGE BITFIELD64_BIT(VARYING_SLOT_EDGE) #define VARYING_BIT_CLIP_VERTEX BITFIELD64_BIT(VARYING_SLOT_CLIP_VERTEX) #define VARYING_BIT_CLIP_DIST0 BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST0) @@ -294,6 +346,9 @@ const char *gl_varying_slot_name(gl_varying_slot slot); #define VARYING_BIT_PNTC BITFIELD64_BIT(VARYING_SLOT_PNTC) #define VARYING_BIT_TESS_LEVEL_OUTER BITFIELD64_BIT(VARYING_SLOT_TESS_LEVEL_OUTER) #define VARYING_BIT_TESS_LEVEL_INNER BITFIELD64_BIT(VARYING_SLOT_TESS_LEVEL_INNER) +#define VARYING_BIT_BOUNDING_BOX0 BITFIELD64_BIT(VARYING_SLOT_BOUNDING_BOX0) +#define VARYING_BIT_BOUNDING_BOX1 BITFIELD64_BIT(VARYING_SLOT_BOUNDING_BOX1) +#define VARYING_BIT_VIEWPORT_MASK BITFIELD64_BIT(VARYING_SLOT_VIEWPORT_MASK) #define VARYING_BIT_VAR(V) BITFIELD64_BIT(VARYING_SLOT_VAR0 + (V)) /*@}*/ @@ -312,6 +367,73 @@ const char *gl_varying_slot_name(gl_varying_slot slot); */ typedef enum { + /** + * \name System values applicable to all shaders + */ + /*@{*/ + + /** + * Builtin variables added by GL_ARB_shader_ballot. + */ + /*@{*/ + + /** + * From the GL_ARB_shader-ballot spec: + * + * "A sub-group is a collection of invocations which execute in lockstep. + * The variable is the maximum number of + * invocations in a sub-group. The maximum + * supported in this extension is 64." + * + * The spec defines this as a uniform. However, it's highly unlikely that + * implementations actually treat it as a uniform (which is loaded from a + * constant buffer). Most likely, this is an implementation-wide constant, + * or perhaps something that depends on the shader stage. + */ + SYSTEM_VALUE_SUBGROUP_SIZE, + + /** + * From the GL_ARB_shader_ballot spec: + * + * "The variable holds the index of the + * invocation within sub-group. This variable is in the range 0 to + * -1, where is the total + * number of invocations in a sub-group." + */ + SYSTEM_VALUE_SUBGROUP_INVOCATION, + + /** + * From the GL_ARB_shader_ballot spec: + * + * "The variables provide a bitmask for all + * invocations, with one bit per invocation starting with the least + * significant bit, according to the following table, + * + * variable equation for bit values + * -------------------- ------------------------------------ + * gl_SubGroupEqMaskARB bit index == gl_SubGroupInvocationARB + * gl_SubGroupGeMaskARB bit index >= gl_SubGroupInvocationARB + * gl_SubGroupGtMaskARB bit index > gl_SubGroupInvocationARB + * gl_SubGroupLeMaskARB bit index <= gl_SubGroupInvocationARB + * gl_SubGroupLtMaskARB bit index < gl_SubGroupInvocationARB + */ + SYSTEM_VALUE_SUBGROUP_EQ_MASK, + SYSTEM_VALUE_SUBGROUP_GE_MASK, + SYSTEM_VALUE_SUBGROUP_GT_MASK, + SYSTEM_VALUE_SUBGROUP_LE_MASK, + SYSTEM_VALUE_SUBGROUP_LT_MASK, + /*@}*/ + + /** + * Builtin variables added by VK_KHR_subgroups + */ + /*@{*/ + SYSTEM_VALUE_NUM_SUBGROUPS, + SYSTEM_VALUE_SUBGROUP_ID, + /*@}*/ + + /*@}*/ + /** * \name Vertex shader system values */ @@ -408,6 +530,27 @@ typedef enum */ SYSTEM_VALUE_BASE_VERTEX, + /** + * Depending on the type of the draw call (indexed or non-indexed), + * is the value of \c basevertex passed to \c glDrawElementsBaseVertex and + * similar, or is the value of \c first passed to \c glDrawArrays and + * similar. + * + * \note + * It can be used to calculate the \c SYSTEM_VALUE_VERTEX_ID as + * \c SYSTEM_VALUE_VERTEX_ID_ZERO_BASE plus \c SYSTEM_VALUE_FIRST_VERTEX. + * + * \sa SYSTEM_VALUE_VERTEX_ID_ZERO_BASE, SYSTEM_VALUE_VERTEX_ID + */ + SYSTEM_VALUE_FIRST_VERTEX, + + /** + * If the Draw command used to start the rendering was an indexed draw + * or not (~0/0). Useful to calculate \c SYSTEM_VALUE_BASE_VERTEX as + * \c SYSTEM_VALUE_IS_INDEXED_DRAW & \c SYSTEM_VALUE_FIRST_VERTEX. + */ + SYSTEM_VALUE_IS_INDEXED_DRAW, + /** * Value of \c baseinstance passed to instanced draw entry points * @@ -441,11 +584,15 @@ typedef enum */ /*@{*/ SYSTEM_VALUE_FRAG_COORD, + SYSTEM_VALUE_POINT_COORD, + SYSTEM_VALUE_LINE_COORD, /**< Coord along axis perpendicular to line */ SYSTEM_VALUE_FRONT_FACE, SYSTEM_VALUE_SAMPLE_ID, SYSTEM_VALUE_SAMPLE_POS, SYSTEM_VALUE_SAMPLE_MASK_IN, SYSTEM_VALUE_HELPER_INVOCATION, + SYSTEM_VALUE_COLOR0, + SYSTEM_VALUE_COLOR1, /*@}*/ /** @@ -457,6 +604,8 @@ typedef enum SYSTEM_VALUE_PRIMITIVE_ID, SYSTEM_VALUE_TESS_LEVEL_OUTER, /**< TES input */ SYSTEM_VALUE_TESS_LEVEL_INNER, /**< TES input */ + SYSTEM_VALUE_TESS_LEVEL_OUTER_DEFAULT, /**< TCS input for passthru TCS */ + SYSTEM_VALUE_TESS_LEVEL_INNER_DEFAULT, /**< TCS input for passthru TCS */ /*@}*/ /** @@ -466,16 +615,52 @@ typedef enum SYSTEM_VALUE_LOCAL_INVOCATION_ID, SYSTEM_VALUE_LOCAL_INVOCATION_INDEX, SYSTEM_VALUE_GLOBAL_INVOCATION_ID, + SYSTEM_VALUE_BASE_GLOBAL_INVOCATION_ID, + SYSTEM_VALUE_GLOBAL_INVOCATION_INDEX, SYSTEM_VALUE_WORK_GROUP_ID, SYSTEM_VALUE_NUM_WORK_GROUPS, + SYSTEM_VALUE_LOCAL_GROUP_SIZE, + SYSTEM_VALUE_GLOBAL_GROUP_SIZE, + SYSTEM_VALUE_WORK_DIM, + SYSTEM_VALUE_USER_DATA_AMD, /*@}*/ + /** Required for VK_KHR_device_group */ + SYSTEM_VALUE_DEVICE_INDEX, + + /** Required for VK_KHX_multiview */ + SYSTEM_VALUE_VIEW_INDEX, + /** * Driver internal vertex-count, used (for example) for drivers to * calculate stride for stream-out outputs. Not externally visible. */ SYSTEM_VALUE_VERTEX_CNT, + /** + * Required for AMD_shader_explicit_vertex_parameter and also used for + * varying-fetch instructions. + * + * The _SIZE value is "primitive size", used to scale i/j in primitive + * space to pixel space. + */ + SYSTEM_VALUE_BARYCENTRIC_PERSP_PIXEL, + SYSTEM_VALUE_BARYCENTRIC_PERSP_SAMPLE, + SYSTEM_VALUE_BARYCENTRIC_PERSP_CENTROID, + SYSTEM_VALUE_BARYCENTRIC_PERSP_SIZE, + SYSTEM_VALUE_BARYCENTRIC_LINEAR_PIXEL, + SYSTEM_VALUE_BARYCENTRIC_LINEAR_CENTROID, + SYSTEM_VALUE_BARYCENTRIC_LINEAR_SAMPLE, + SYSTEM_VALUE_BARYCENTRIC_PULL_MODEL, + + /** + * IR3 specific geometry shader and tesselation control shader system + * values that packs invocation id, thread id and vertex id. Having this + * as a nir level system value lets us do the unpacking in nir. + */ + SYSTEM_VALUE_GS_HEADER_IR3, + SYSTEM_VALUE_TCS_HEADER_IR3, + SYSTEM_VALUE_MAX /**< Number of values */ } gl_system_value; @@ -486,7 +671,7 @@ const char *gl_system_value_name(gl_system_value sysval); * shader input in GLSL. * * Note: INTERP_MODE_NONE must be 0 so that memsetting the - * gl_fragment_program data structure to 0 causes the default behavior. + * ir_variable data structure to 0 causes the default behavior. */ enum glsl_interp_mode { @@ -494,9 +679,17 @@ enum glsl_interp_mode INTERP_MODE_SMOOTH, INTERP_MODE_FLAT, INTERP_MODE_NOPERSPECTIVE, + INTERP_MODE_EXPLICIT, INTERP_MODE_COUNT /**< Number of interpolation qualifiers */ }; +enum glsl_interface_packing { + GLSL_INTERFACE_PACKING_STD140, + GLSL_INTERFACE_PACKING_SHARED, + GLSL_INTERFACE_PACKING_PACKED, + GLSL_INTERFACE_PACKING_STD430 +}; + const char *glsl_interp_mode_name(enum glsl_interp_mode qual); /** @@ -552,11 +745,176 @@ enum gl_frag_depth_layout /** * \brief Buffer access qualifiers */ -enum gl_buffer_access_qualifier +enum gl_access_qualifier +{ + ACCESS_COHERENT = (1 << 0), + ACCESS_RESTRICT = (1 << 1), + ACCESS_VOLATILE = (1 << 2), + ACCESS_NON_READABLE = (1 << 3), + ACCESS_NON_WRITEABLE = (1 << 4), + + /** The access may use a non-uniform buffer or image index */ + ACCESS_NON_UNIFORM = (1 << 5), + + /* This has the same semantics as NIR_INTRINSIC_CAN_REORDER, only to be + * used with loads. In other words, it means that the load can be + * arbitrarily reordered, or combined with other loads to the same address. + * It is implied by ACCESS_NON_WRITEABLE together with ACCESS_RESTRICT, and + * a lack of ACCESS_COHERENT and ACCESS_VOLATILE. + */ + ACCESS_CAN_REORDER = (1 << 6), + + /** Use as little cache space as possible. */ + ACCESS_STREAM_CACHE_POLICY = (1 << 7), +}; + +/** + * \brief Blend support qualifiers + */ +enum gl_advanced_blend_mode +{ + BLEND_NONE = 0, + BLEND_MULTIPLY, + BLEND_SCREEN, + BLEND_OVERLAY, + BLEND_DARKEN, + BLEND_LIGHTEN, + BLEND_COLORDODGE, + BLEND_COLORBURN, + BLEND_HARDLIGHT, + BLEND_SOFTLIGHT, + BLEND_DIFFERENCE, + BLEND_EXCLUSION, + BLEND_HSL_HUE, + BLEND_HSL_SATURATION, + BLEND_HSL_COLOR, + BLEND_HSL_LUMINOSITY, +}; + +enum blend_func +{ + BLEND_FUNC_ADD, + BLEND_FUNC_SUBTRACT, + BLEND_FUNC_REVERSE_SUBTRACT, + BLEND_FUNC_MIN, + BLEND_FUNC_MAX, +}; + +enum blend_factor +{ + BLEND_FACTOR_ZERO, + BLEND_FACTOR_SRC_COLOR, + BLEND_FACTOR_SRC1_COLOR, + BLEND_FACTOR_DST_COLOR, + BLEND_FACTOR_SRC_ALPHA, + BLEND_FACTOR_SRC1_ALPHA, + BLEND_FACTOR_DST_ALPHA, + BLEND_FACTOR_CONSTANT_COLOR, + BLEND_FACTOR_CONSTANT_ALPHA, + BLEND_FACTOR_SRC_ALPHA_SATURATE, +}; + +enum gl_tess_spacing { - ACCESS_COHERENT = 1, - ACCESS_RESTRICT = 2, - ACCESS_VOLATILE = 4, + TESS_SPACING_UNSPECIFIED, + TESS_SPACING_EQUAL, + TESS_SPACING_FRACTIONAL_ODD, + TESS_SPACING_FRACTIONAL_EVEN, +}; + +/** + * A compare function enum for use in compiler lowering passes. This is in + * the same order as GL's compare functions (shifted down by GL_NEVER), and is + * exactly the same as gallium's PIPE_FUNC_*. + */ +enum compare_func +{ + COMPARE_FUNC_NEVER, + COMPARE_FUNC_LESS, + COMPARE_FUNC_EQUAL, + COMPARE_FUNC_LEQUAL, + COMPARE_FUNC_GREATER, + COMPARE_FUNC_NOTEQUAL, + COMPARE_FUNC_GEQUAL, + COMPARE_FUNC_ALWAYS, +}; + +/** + * Arrangements for grouping invocations from NV_compute_shader_derivatives. + * + * The extension provides new layout qualifiers that support two different + * arrangements of compute shader invocations for the purpose of derivative + * computation. When specifying + * + * layout(derivative_group_quadsNV) in; + * + * compute shader invocations are grouped into 2x2x1 arrays whose four local + * invocation ID values follow the pattern: + * + * +-----------------+------------------+ + * | (2x+0, 2y+0, z) | (2x+1, 2y+0, z) | + * +-----------------+------------------+ + * | (2x+0, 2y+1, z) | (2x+1, 2y+1, z) | + * +-----------------+------------------+ + * + * where Y increases from bottom to top. When specifying + * + * layout(derivative_group_linearNV) in; + * + * compute shader invocations are grouped into 2x2x1 arrays whose four local + * invocation index values follow the pattern: + * + * +------+------+ + * | 4n+0 | 4n+1 | + * +------+------+ + * | 4n+2 | 4n+3 | + * +------+------+ + * + * If neither layout qualifier is specified, derivatives in compute shaders + * return zero, which is consistent with the handling of built-in texture + * functions like texture() in GLSL 4.50 compute shaders. + */ +enum gl_derivative_group { + DERIVATIVE_GROUP_NONE = 0, + DERIVATIVE_GROUP_QUADS, + DERIVATIVE_GROUP_LINEAR, +}; + +enum float_controls +{ + FLOAT_CONTROLS_DEFAULT_FLOAT_CONTROL_MODE = 0x0000, + FLOAT_CONTROLS_DENORM_PRESERVE_FP16 = 0x0001, + FLOAT_CONTROLS_DENORM_PRESERVE_FP32 = 0x0002, + FLOAT_CONTROLS_DENORM_PRESERVE_FP64 = 0x0004, + FLOAT_CONTROLS_DENORM_FLUSH_TO_ZERO_FP16 = 0x0008, + FLOAT_CONTROLS_DENORM_FLUSH_TO_ZERO_FP32 = 0x0010, + FLOAT_CONTROLS_DENORM_FLUSH_TO_ZERO_FP64 = 0x0020, + FLOAT_CONTROLS_SIGNED_ZERO_INF_NAN_PRESERVE_FP16 = 0x0040, + FLOAT_CONTROLS_SIGNED_ZERO_INF_NAN_PRESERVE_FP32 = 0x0080, + FLOAT_CONTROLS_SIGNED_ZERO_INF_NAN_PRESERVE_FP64 = 0x0100, + FLOAT_CONTROLS_ROUNDING_MODE_RTE_FP16 = 0x0200, + FLOAT_CONTROLS_ROUNDING_MODE_RTE_FP32 = 0x0400, + FLOAT_CONTROLS_ROUNDING_MODE_RTE_FP64 = 0x0800, + FLOAT_CONTROLS_ROUNDING_MODE_RTZ_FP16 = 0x1000, + FLOAT_CONTROLS_ROUNDING_MODE_RTZ_FP32 = 0x2000, + FLOAT_CONTROLS_ROUNDING_MODE_RTZ_FP64 = 0x4000, +}; + +/** +* Enums to describe sampler properties used by OpenCL's inline constant samplers. +* These values match the meanings described in the SPIR-V spec. +*/ +enum cl_sampler_addressing_mode { + SAMPLER_ADDRESSING_MODE_NONE = 0, + SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE = 1, + SAMPLER_ADDRESSING_MODE_CLAMP = 2, + SAMPLER_ADDRESSING_MODE_REPEAT = 3, + SAMPLER_ADDRESSING_MODE_REPEAT_MIRRORED = 4, +}; + +enum cl_sampler_filter_mode { + SAMPLER_FILTER_MODE_NEAREST = 0, + SAMPLER_FILTER_MODE_LINEAR = 1, }; #ifdef __cplusplus