#include "c11/threads.h"
#include "main/glheader.h"
+#include "main/menums.h"
#include "main/config.h"
#include "glapi/glapi.h"
#include "math/m_matrix.h" /* GLmatrix */
extern "C" {
#endif
-
-/** Set a single bit */
-#define BITFIELD_BIT(b) ((GLbitfield)1 << (b))
-/** Set all bits up to excluding bit b */
-#define BITFIELD_MASK(b) \
- ((b) == 32 ? (~(GLbitfield)0) : BITFIELD_BIT(b) - 1)
-/** Set count bits starting from bit b */
-#define BITFIELD_RANGE(b, count) \
- (BITFIELD_MASK((b) + (count)) & ~BITFIELD_MASK(b))
-
-
-/**
- * \name 64-bit extension of GLbitfield.
- */
-/*@{*/
-typedef GLuint64 GLbitfield64;
-
-/** Set a single bit */
-#define BITFIELD64_BIT(b) ((GLbitfield64)1 << (b))
-/** Set all bits up to excluding bit b */
-#define BITFIELD64_MASK(b) \
- ((b) == 64 ? (~(GLbitfield64)0) : BITFIELD64_BIT(b) - 1)
-/** Set count bits starting from bit b */
-#define BITFIELD64_RANGE(b, count) \
- (BITFIELD64_MASK((b) + (count)) & ~BITFIELD64_MASK(b))
+#define GET_COLORMASK_BIT(mask, buf, chan) (((mask) >> (4 * (buf) + (chan))) & 0x1)
+#define GET_COLORMASK(mask, buf) (((mask) >> (4 * (buf))) & 0xf)
/**
struct gl_program_parameter_list;
struct gl_shader_spirv_data;
struct set;
+struct shader_includes;
struct vbo_context;
/*@}*/
}
}
-/**
- * Indexes for all renderbuffers
- */
-typedef enum
-{
- /* the four standard color buffers */
- BUFFER_FRONT_LEFT,
- BUFFER_BACK_LEFT,
- BUFFER_FRONT_RIGHT,
- BUFFER_BACK_RIGHT,
- BUFFER_DEPTH,
- BUFFER_STENCIL,
- BUFFER_ACCUM,
- /* optional aux buffer */
- BUFFER_AUX0,
- /* generic renderbuffers */
- BUFFER_COLOR0,
- BUFFER_COLOR1,
- BUFFER_COLOR2,
- BUFFER_COLOR3,
- BUFFER_COLOR4,
- BUFFER_COLOR5,
- BUFFER_COLOR6,
- BUFFER_COLOR7,
- BUFFER_COUNT,
- BUFFER_NONE = -1,
-} gl_buffer_index;
-
/**
* Bit flags for all renderbuffers
*/
*/
struct gl_config
{
- GLboolean rgbMode;
GLboolean floatMode;
GLuint doubleBufferMode;
GLuint stereoMode;
- GLboolean haveAccumBuffer;
- GLboolean haveDepthBuffer;
- GLboolean haveStencilBuffer;
-
GLint redBits, greenBits, blueBits, alphaBits; /* bits per comp */
GLuint redMask, greenMask, blueMask, alphaMask;
+ GLint redShift, greenShift, blueShift, alphaShift;
GLint rgbBits; /* total bits for rgb */
- GLint indexBits; /* total bits for colorindex */
GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
GLint depthBits;
/* EXT_framebuffer_sRGB */
GLint sRGBCapable;
+
+ /* EGL_KHR_mutable_render_buffer */
+ GLuint mutableRenderBuffer; /* bool */
};
GLfloat Ambient[4]; /**< ambient color */
GLboolean LocalViewer; /**< Local (or infinite) view point? */
GLboolean TwoSide; /**< Two (or one) sided lighting? */
- GLenum ColorControl; /**< either GL_SINGLE_COLOR
+ GLenum16 ColorControl; /**< either GL_SINGLE_COLOR
or GL_SEPARATE_SPECULAR_COLOR */
};
GLuint ClearIndex; /**< Index for glClear */
union gl_color_union ClearColor; /**< Color for glClear, unclamped */
GLuint IndexMask; /**< Color index write mask */
- GLubyte ColorMask[MAX_DRAW_BUFFERS][4]; /**< Each flag is 0xff or 0x0 */
- GLenum DrawBuffer[MAX_DRAW_BUFFERS]; /**< Which buffer to draw into */
+ /** 4 colormask bits per draw buffer, max 8 draw buffers. 4*8 = 32 bits */
+ GLbitfield ColorMask;
+
+ GLenum16 DrawBuffer[MAX_DRAW_BUFFERS]; /**< Which buffer to draw into */
/**
* \name alpha testing
*/
/*@{*/
GLboolean AlphaEnabled; /**< Alpha test enabled flag */
- GLenum AlphaFunc; /**< Alpha test function */
+ GLenum16 AlphaFunc; /**< Alpha test function */
GLfloat AlphaRefUnclamped;
GLclampf AlphaRef; /**< Alpha reference value */
/*@}*/
* control, only on the fixed-pointness of the render target.
* The query does however depend on fragment color clamping.
*/
- GLfloat BlendColorUnclamped[4]; /**< Blending color */
+ GLfloat BlendColorUnclamped[4]; /**< Blending color */
GLfloat BlendColor[4]; /**< Blending color */
struct
{
- GLenum SrcRGB; /**< RGB blend source term */
- GLenum DstRGB; /**< RGB blend dest term */
- GLenum SrcA; /**< Alpha blend source term */
- GLenum DstA; /**< Alpha blend dest term */
- GLenum EquationRGB; /**< GL_ADD, GL_SUBTRACT, etc. */
- GLenum EquationA; /**< GL_ADD, GL_SUBTRACT, etc. */
+ GLenum16 SrcRGB; /**< RGB blend source term */
+ GLenum16 DstRGB; /**< RGB blend dest term */
+ GLenum16 SrcA; /**< Alpha blend source term */
+ GLenum16 DstA; /**< Alpha blend dest term */
+ GLenum16 EquationRGB; /**< GL_ADD, GL_SUBTRACT, etc. */
+ GLenum16 EquationA; /**< GL_ADD, GL_SUBTRACT, etc. */
/**
* Set if any blend factor uses SRC1. Computed at the time blend factors
* get set.
/*@{*/
GLboolean IndexLogicOpEnabled; /**< Color index logic op enabled flag */
GLboolean ColorLogicOpEnabled; /**< RGBA logic op enabled flag */
- GLenum LogicOp; /**< Logic operator */
-
+ GLenum16 LogicOp; /**< Logic operator */
+ enum gl_logicop_mode _LogicOp;
/*@}*/
- GLboolean DitherFlag; /**< Dither enable flag */
+ GLboolean DitherFlag; /**< Dither enable flag */
- GLboolean _ClampFragmentColor; /** < with GL_FIXED_ONLY_ARB resolved */
- GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
- GLenum ClampReadColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
+ GLboolean _ClampFragmentColor; /** < with GL_FIXED_ONLY_ARB resolved */
+ GLenum16 ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
+ GLenum16 ClampReadColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
- GLboolean sRGBEnabled; /**< Framebuffer sRGB blending/updating requested */
+ GLboolean sRGBEnabled; /**< Framebuffer sRGB blending/updating requested */
+};
+
+
+/**
+ * Vertex format to describe a vertex element.
+ */
+struct gl_vertex_format
+{
+ GLenum16 Type; /**< datatype: GL_FLOAT, GL_INT, etc */
+ GLenum16 Format; /**< default: GL_RGBA, but may be GL_BGRA */
+ GLubyte Size:5; /**< components per element (1,2,3,4) */
+ GLubyte Normalized:1; /**< GL_ARB_vertex_program */
+ GLubyte Integer:1; /**< Integer-valued? */
+ GLubyte Doubles:1; /**< double values are not converted to floats */
+ GLubyte _ElementSize; /**< Size of each element in bytes */
};
*/
struct gl_depthbuffer_attrib
{
- GLenum Func; /**< Function for depth buffer compare */
+ GLenum16 Func; /**< Function for depth buffer compare */
GLclampd Clear; /**< Value to clear depth buffer to */
GLboolean Test; /**< Depth buffering enabled flag */
GLboolean Mask; /**< Depth buffer writable? */
GLfloat Start; /**< Start distance in eye coords */
GLfloat End; /**< End distance in eye coords */
GLfloat Index; /**< Fog index */
- GLenum Mode; /**< Fog mode */
- GLenum FogCoordinateSource; /**< GL_EXT_fog_coord */
- GLfloat _Scale; /**< (End == Start) ? 1.0 : 1.0 / (End - Start) */
- GLenum FogDistanceMode; /**< GL_NV_fog_distance */
+ GLenum16 Mode; /**< Fog mode */
+ GLenum16 FogCoordinateSource;/**< GL_EXT_fog_coord */
+ GLenum16 FogDistanceMode; /**< GL_NV_fog_distance */
};
*/
struct gl_hint_attrib
{
- GLenum PerspectiveCorrection;
- GLenum PointSmooth;
- GLenum LineSmooth;
- GLenum PolygonSmooth;
- GLenum Fog;
- GLenum TextureCompression; /**< GL_ARB_texture_compression */
- GLenum GenerateMipmap; /**< GL_SGIS_generate_mipmap */
- GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */
+ GLenum16 PerspectiveCorrection;
+ GLenum16 PointSmooth;
+ GLenum16 LineSmooth;
+ GLenum16 PolygonSmooth;
+ GLenum16 Fog;
+ GLenum16 TextureCompression; /**< GL_ARB_texture_compression */
+ GLenum16 GenerateMipmap; /**< GL_SGIS_generate_mipmap */
+ GLenum16 FragmentShaderDerivative; /**< GL_ARB_fragment_shader */
+ GLuint MaxShaderCompilerThreads; /**< GL_ARB_parallel_shader_compile */
};
GLboolean Enabled; /**< Lighting enabled flag */
GLboolean ColorMaterialEnabled;
- GLenum ShadeModel; /**< GL_FLAT or GL_SMOOTH */
- GLenum ProvokingVertex; /**< GL_EXT_provoking_vertex */
- GLenum ColorMaterialFace; /**< GL_FRONT, BACK or FRONT_AND_BACK */
- GLenum ColorMaterialMode; /**< GL_AMBIENT, GL_DIFFUSE, etc */
+ GLenum16 ShadeModel; /**< GL_FLAT or GL_SMOOTH */
+ GLenum16 ProvokingVertex; /**< GL_EXT_provoking_vertex */
+ GLenum16 ColorMaterialFace; /**< GL_FRONT, BACK or FRONT_AND_BACK */
+ GLenum16 ColorMaterialMode; /**< GL_AMBIENT, GL_DIFFUSE, etc */
GLbitfield _ColorMaterialBitmask; /**< bitmask formed from Face and Mode */
GLboolean _ClampVertexColor;
- GLenum ClampVertexColor; /**< GL_TRUE, GL_FALSE, GL_FIXED_ONLY */
+ GLenum16 ClampVertexColor; /**< GL_TRUE, GL_FALSE, GL_FIXED_ONLY */
/**
* Derived state for optimizations:
*/
struct gl_pixel_attrib
{
- GLenum ReadBuffer; /**< source buffer for glRead/CopyPixels() */
+ GLenum16 ReadBuffer; /**< source buffer for glRead/CopyPixels() */
/*--- Begin Pixel Transfer State ---*/
/* Fields are in the order in which they're applied... */
GLboolean _Attenuated; /**< True if Params != [1, 0, 0] */
GLboolean PointSprite; /**< GL_NV/ARB_point_sprite */
GLbitfield CoordReplace; /**< GL_ARB_point_sprite*/
- GLenum SpriteRMode; /**< GL_NV_point_sprite (only!) */
- GLenum SpriteOrigin; /**< GL_ARB_point_sprite */
+ GLenum16 SpriteRMode; /**< GL_NV_point_sprite (only!) */
+ GLenum16 SpriteOrigin; /**< GL_ARB_point_sprite */
};
*/
struct gl_polygon_attrib
{
- GLenum FrontFace; /**< Either GL_CW or GL_CCW */
+ GLenum16 FrontFace; /**< Either GL_CW or GL_CCW */
GLenum FrontMode; /**< Either GL_POINT, GL_LINE or GL_FILL */
GLenum BackMode; /**< Either GL_POINT, GL_LINE or GL_FILL */
GLboolean CullFlag; /**< Culling on/off flag */
GLboolean SmoothFlag; /**< True if GL_POLYGON_SMOOTH is enabled */
GLboolean StippleFlag; /**< True if GL_POLYGON_STIPPLE is enabled */
- GLenum CullFaceMode; /**< Culling mode GL_FRONT or GL_BACK */
+ GLenum16 CullFaceMode; /**< Culling mode GL_FRONT or GL_BACK */
GLfloat OffsetFactor; /**< Polygon offset factor, from user */
GLfloat OffsetUnits; /**< Polygon offset units, from user */
GLfloat OffsetClamp; /**< Polygon offset clamp, from user */
GLbitfield EnableFlags; /**< Scissor test enabled? */
struct gl_scissor_rect ScissorArray[MAX_VIEWPORTS];
GLint NumWindowRects; /**< Count of enabled window rectangles */
- GLenum WindowRectMode; /**< Whether to include or exclude the rects */
+ GLenum16 WindowRectMode; /**< Whether to include or exclude the rects */
struct gl_scissor_rect WindowRects[MAX_WINDOW_RECTANGLES];
};
GLboolean TestTwoSide; /**< GL_EXT_stencil_two_side */
GLubyte ActiveFace; /**< GL_EXT_stencil_two_side (0 or 2) */
GLubyte _BackFace; /**< Current back stencil state (1 or 2) */
- GLenum Function[3]; /**< Stencil function */
- GLenum FailFunc[3]; /**< Fail function */
- GLenum ZPassFunc[3]; /**< Depth buffer pass function */
- GLenum ZFailFunc[3]; /**< Depth buffer fail function */
+ GLenum16 Function[3]; /**< Stencil function */
+ GLenum16 FailFunc[3]; /**< Fail function */
+ GLenum16 ZPassFunc[3]; /**< Depth buffer pass function */
+ GLenum16 ZFailFunc[3]; /**< Depth buffer fail function */
GLint Ref[3]; /**< Reference value */
GLuint ValueMask[3]; /**< Value mask */
GLuint WriteMask[3]; /**< Write mask */
};
-/**
- * An index for each type of texture object. These correspond to the GL
- * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.
- * Note: the order is from highest priority to lowest priority.
- */
-typedef enum
-{
- TEXTURE_2D_MULTISAMPLE_INDEX,
- TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX,
- TEXTURE_CUBE_ARRAY_INDEX,
- TEXTURE_BUFFER_INDEX,
- TEXTURE_2D_ARRAY_INDEX,
- TEXTURE_1D_ARRAY_INDEX,
- TEXTURE_EXTERNAL_INDEX,
- TEXTURE_CUBE_INDEX,
- TEXTURE_3D_INDEX,
- TEXTURE_RECT_INDEX,
- TEXTURE_2D_INDEX,
- TEXTURE_1D_INDEX,
- NUM_TEXTURE_TARGETS
-} gl_texture_index;
-
-
/**
* Bit flags for each type of texture object
*/
struct gl_texture_image
{
GLint InternalFormat; /**< Internal format as given by the user */
- GLenum _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_ALPHA,
- * GL_LUMINANCE, GL_LUMINANCE_ALPHA,
- * GL_INTENSITY, GL_DEPTH_COMPONENT or
- * GL_DEPTH_STENCIL_EXT only. Used for
- * choosing TexEnv arithmetic.
- */
+ GLenum16 _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_ALPHA,
+ * GL_LUMINANCE, GL_LUMINANCE_ALPHA,
+ * GL_INTENSITY, GL_DEPTH_COMPONENT or
+ * GL_DEPTH_STENCIL_EXT only. Used for
+ * choosing TexEnv arithmetic.
+ */
mesa_format TexFormat; /**< The actual texture memory format */
GLuint Border; /**< 0 or 1 */
{
simple_mtx_t Mutex;
GLuint Name;
- GLint RefCount;
GLchar *Label; /**< GL_KHR_debug */
+ GLint RefCount;
- GLenum WrapS; /**< S-axis texture image wrap mode */
- GLenum WrapT; /**< T-axis texture image wrap mode */
- GLenum WrapR; /**< R-axis texture image wrap mode */
- GLenum MinFilter; /**< minification filter */
- GLenum MagFilter; /**< magnification filter */
+ GLenum16 WrapS; /**< S-axis texture image wrap mode */
+ GLenum16 WrapT; /**< T-axis texture image wrap mode */
+ GLenum16 WrapR; /**< R-axis texture image wrap mode */
+ GLenum16 MinFilter; /**< minification filter */
+ GLenum16 MagFilter; /**< magnification filter */
+ GLenum16 sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
union gl_color_union BorderColor; /**< Interpreted according to texture format */
GLfloat MinLod; /**< min lambda, OpenGL 1.2 */
GLfloat MaxLod; /**< max lambda, OpenGL 1.2 */
GLfloat LodBias; /**< OpenGL 1.4 */
GLfloat MaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */
- GLenum CompareMode; /**< GL_ARB_shadow */
- GLenum CompareFunc; /**< GL_ARB_shadow */
- GLenum sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
+ GLenum16 CompareMode; /**< GL_ARB_shadow */
+ GLenum16 CompareFunc; /**< GL_ARB_shadow */
GLboolean CubeMapSeamless; /**< GL_AMD_seamless_cubemap_per_texture */
/** GL_ARB_bindless_texture */
*/
struct gl_texture_object
{
- simple_mtx_t Mutex; /**< for thread safety */
+ simple_mtx_t Mutex; /**< for thread safety */
GLint RefCount; /**< reference count */
GLuint Name; /**< the user-visible texture object ID */
- GLchar *Label; /**< GL_KHR_debug */
- GLenum Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
- gl_texture_index TargetIndex; /**< The gl_texture_unit::CurrentTex index.
- Only valid when Target is valid. */
+ GLenum16 Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
+ GLenum16 DepthMode; /**< GL_ARB_depth_texture */
+ GLchar *Label; /**< GL_KHR_debug */
struct gl_sampler_object Sampler;
- GLenum DepthMode; /**< GL_ARB_depth_texture */
-
+ gl_texture_index TargetIndex; /**< The gl_texture_unit::CurrentTex index.
+ Only valid when Target is valid. */
GLfloat Priority; /**< in [0,1] */
- GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */
- GLint MaxLevel; /**< max mipmap level, OpenGL 1.2 */
- GLint ImmutableLevels; /**< ES 3.0 / ARB_texture_view */
- GLint _MaxLevel; /**< actual max mipmap level (q in the spec) */
+ GLint MaxLevel; /**< max mipmap level (max=1000), OpenGL 1.2 */
+ GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */
+ GLbyte _MaxLevel; /**< actual max mipmap level (q in the spec) */
GLfloat _MaxLambda; /**< = _MaxLevel - BaseLevel (q - p in spec) */
GLint CropRect[4]; /**< GL_OES_draw_texture */
GLenum Swizzle[4]; /**< GL_EXT_texture_swizzle */
- GLuint _Swizzle; /**< same as Swizzle, but SWIZZLE_* format */
+ GLushort _Swizzle; /**< same as Swizzle, but SWIZZLE_* format */
+ GLbyte ImmutableLevels; /**< ES 3.0 / ARB_texture_view */
GLboolean GenerateMipmap; /**< GL_SGIS_generate_mipmap */
GLboolean _BaseComplete; /**< Is the base texture level valid? */
GLboolean _MipmapComplete; /**< Is the whole mipmap valid? */
bool StencilSampling; /**< Should we sample stencil instead of depth? */
bool HandleAllocated; /**< GL_ARB_bindless_texture */
- GLuint MinLevel; /**< GL_ARB_texture_view */
- GLuint MinLayer; /**< GL_ARB_texture_view */
- GLuint NumLevels; /**< GL_ARB_texture_view */
- GLuint NumLayers; /**< GL_ARB_texture_view */
+ /** GL_OES_EGL_image_external */
+ GLubyte RequiredTextureImageUnits;
+
+ GLubyte MinLevel; /**< GL_ARB_texture_view */
+ GLubyte NumLevels; /**< GL_ARB_texture_view */
+ GLushort MinLayer; /**< GL_ARB_texture_view */
+ GLushort NumLayers; /**< GL_ARB_texture_view */
/** GL_EXT_memory_object */
- GLenum TextureTiling;
+ GLenum16 TextureTiling;
- /** Actual texture images, indexed by [cube face] and [mipmap level] */
- struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
+ /** GL_ARB_shader_image_load_store */
+ GLenum16 ImageFormatCompatibilityType;
/** GL_ARB_texture_buffer_object */
- struct gl_buffer_object *BufferObject;
- GLenum BufferObjectFormat;
+ GLenum16 BufferObjectFormat;
/** Equivalent Mesa format for BufferObjectFormat. */
mesa_format _BufferObjectFormat;
+ struct gl_buffer_object *BufferObject;
+
/** GL_ARB_texture_buffer_range */
GLintptr BufferOffset;
GLsizeiptr BufferSize; /**< if this is -1, use BufferObject->Size instead */
- /** GL_OES_EGL_image_external */
- GLint RequiredTextureImageUnits;
-
- /** GL_ARB_shader_image_load_store */
- GLenum ImageFormatCompatibilityType;
+ /** Actual texture images, indexed by [cube face] and [mipmap level] */
+ struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
/** GL_ARB_bindless_texture */
struct util_dynarray SamplerHandles;
*/
struct gl_tex_env_combine_state
{
- GLenum ModeRGB; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
- GLenum ModeA; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
+ GLenum16 ModeRGB; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
+ GLenum16 ModeA; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
/** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */
- GLenum SourceRGB[MAX_COMBINER_TERMS];
- GLenum SourceA[MAX_COMBINER_TERMS];
+ GLenum16 SourceRGB[MAX_COMBINER_TERMS];
+ GLenum16 SourceA[MAX_COMBINER_TERMS];
/** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */
- GLenum OperandRGB[MAX_COMBINER_TERMS];
- GLenum OperandA[MAX_COMBINER_TERMS];
- GLuint ScaleShiftRGB; /**< 0, 1 or 2 */
- GLuint ScaleShiftA; /**< 0, 1 or 2 */
- GLuint _NumArgsRGB; /**< Number of inputs used for the RGB combiner */
- GLuint _NumArgsA; /**< Number of inputs used for the A combiner */
+ GLenum16 OperandRGB[MAX_COMBINER_TERMS];
+ GLenum16 OperandA[MAX_COMBINER_TERMS];
+ GLubyte ScaleShiftRGB; /**< 0, 1 or 2 */
+ GLubyte ScaleShiftA; /**< 0, 1 or 2 */
+ GLubyte _NumArgsRGB; /**< Number of inputs used for the RGB combiner */
+ GLubyte _NumArgsA; /**< Number of inputs used for the A combiner */
};
*/
struct gl_tex_env_combine_packed
{
- uint32_t ModeRGB:4; /**< Effective mode for RGB as 4 bits */
- uint32_t ModeA:4; /**< Effective mode for RGB as 4 bits */
- uint32_t ScaleShiftRGB:2; /**< 0, 1 or 2 */
- uint32_t ScaleShiftA:2; /**< 0, 1 or 2 */
- uint32_t NumArgsRGB:3; /**< Number of inputs used for the RGB combiner */
- uint32_t NumArgsA:3; /**< Number of inputs used for the A combiner */
+ uint32_t ModeRGB:4; /**< Effective mode for RGB as 4 bits */
+ uint32_t ModeA:4; /**< Effective mode for RGB as 4 bits */
+ uint32_t ScaleShiftRGB:2; /**< 0, 1 or 2 */
+ uint32_t ScaleShiftA:2; /**< 0, 1 or 2 */
+ uint32_t NumArgsRGB:3; /**< Number of inputs used for the RGB combiner */
+ uint32_t NumArgsA:3; /**< Number of inputs used for the A combiner */
/** Source arguments in a packed manner */
struct gl_tex_env_argument ArgsRGB[MAX_COMBINER_TERMS];
struct gl_tex_env_argument ArgsA[MAX_COMBINER_TERMS];
*/
struct gl_texgen
{
- GLenum Mode; /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
- GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
+ GLenum16 Mode; /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
+ GLbitfield8 _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
GLfloat ObjectPlane[4];
GLfloat EyePlane[4];
};
/**
- * Texture unit state. Contains enable flags, texture environment/function/
- * combiners, texgen state, and pointers to current texture objects.
+ * Sampler-related subset of a texture unit, like current texture objects.
*/
struct gl_texture_unit
{
- GLbitfield Enabled; /**< bitmask of TEXTURE_*_BIT flags */
+ GLfloat LodBias; /**< for biasing mipmap levels */
+
+ /** Texture targets that have a non-default texture bound */
+ GLbitfield _BoundTextures;
+
+ /** Current sampler object (GL_ARB_sampler_objects) */
+ struct gl_sampler_object *Sampler;
+
+ /** Current texture object pointers */
+ struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
+
+ /** Points to highest priority, complete and enabled texture object */
+ struct gl_texture_object *_Current;
+};
+
+
+/**
+ * Fixed-function-related subset of a texture unit, like enable flags,
+ * texture environment/function/combiners, and texgen state.
+ */
+struct gl_fixedfunc_texture_unit
+{
+ GLbitfield16 Enabled; /**< bitmask of TEXTURE_*_BIT flags */
- GLenum EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
+ GLenum16 EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
GLclampf EnvColor[4];
GLfloat EnvColorUnclamped[4];
struct gl_texgen GenT;
struct gl_texgen GenR;
struct gl_texgen GenQ;
- GLbitfield TexGenEnabled; /**< Bitwise-OR of [STRQ]_BIT values */
- GLbitfield _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */
-
- GLfloat LodBias; /**< for biasing mipmap levels */
-
- /** Texture targets that have a non-default texture bound */
- GLbitfield _BoundTextures;
-
- /** Current sampler object (GL_ARB_sampler_objects) */
- struct gl_sampler_object *Sampler;
+ GLbitfield8 TexGenEnabled; /**< Bitwise-OR of [STRQ]_BIT values */
+ GLbitfield8 _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */
/**
* \name GL_EXT_texture_env_combine
*/
struct gl_tex_env_combine_state _EnvMode;
+ /** Current compressed TexEnv & Combine state */
+ struct gl_tex_env_combine_packed _CurrentCombinePacked;
+
/**
* Currently enabled combiner state. This will point to either
* \c Combine or \c _EnvMode.
*/
struct gl_tex_env_combine_state *_CurrentCombine;
-
- /** Current texture object pointers */
- struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
-
- /** Points to highest priority, complete and enabled texture object */
- struct gl_texture_object *_Current;
-
- /** Current compressed TexEnv & Combine state */
- struct gl_tex_env_combine_packed _CurrentCombinePacked;
};
*/
struct gl_texture_attrib
{
- GLuint CurrentUnit; /**< GL_ACTIVE_TEXTURE */
-
- /** GL_ARB_seamless_cubemap */
- GLboolean CubeMapSeamless;
-
struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];
/** GL_ARB_texture_buffer_object */
struct gl_buffer_object *BufferObject;
+ GLuint CurrentUnit; /**< GL_ACTIVE_TEXTURE */
+
/** Texture coord units/sets used for fragment texturing */
- GLbitfield _EnabledCoordUnits;
+ GLbitfield8 _EnabledCoordUnits;
/** Texture coord units that have texgen enabled */
- GLbitfield _TexGenEnabled;
+ GLbitfield8 _TexGenEnabled;
/** Texture coord units that have non-identity matrices */
- GLbitfield _TexMatEnabled;
+ GLbitfield8 _TexMatEnabled;
/** Bitwise-OR of all Texture.Unit[i]._GenFlags */
- GLbitfield _GenFlags;
+ GLbitfield8 _GenFlags;
/** Largest index of a texture unit with _Current != NULL. */
- GLint _MaxEnabledTexImageUnit;
+ GLshort _MaxEnabledTexImageUnit;
/** Largest index + 1 of texture units that have had any CurrentTex set. */
- GLint NumCurrentTexUsed;
+ GLubyte NumCurrentTexUsed;
+
+ /** GL_ARB_seamless_cubemap */
+ GLboolean CubeMapSeamless;
struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+ struct gl_fixedfunc_texture_unit FixedFuncUnit[MAX_TEXTURE_COORD_UNITS];
};
*/
struct gl_transform_attrib
{
- GLenum MatrixMode; /**< Matrix mode */
+ GLenum16 MatrixMode; /**< Matrix mode */
gl_clip_plane EyeUserPlane[MAX_CLIP_PLANES]; /**< User clip planes */
gl_clip_plane _ClipUserPlane[MAX_CLIP_PLANES]; /**< derived */
GLbitfield ClipPlanesEnabled; /**< on/off bitmask */
GLboolean Normalize; /**< Normalize all normals? */
GLboolean RescaleNormals; /**< GL_EXT_rescale_normal */
GLboolean RasterPositionUnclipped; /**< GL_IBM_rasterpos_clip */
- GLboolean DepthClamp; /**< GL_ARB_depth_clamp */
+ GLboolean DepthClampNear; /**< GL_AMD_depth_clamp_separate */
+ GLboolean DepthClampFar; /**< GL_AMD_depth_clamp_separate */
/** GL_ARB_clip_control */
- GLenum ClipOrigin; /**< GL_LOWER_LEFT or GL_UPPER_LEFT */
- GLenum ClipDepthMode; /**< GL_NEGATIVE_ONE_TO_ONE or GL_ZERO_TO_ONE */
+ GLenum16 ClipOrigin; /**< GL_LOWER_LEFT or GL_UPPER_LEFT */
+ GLenum16 ClipDepthMode;/**< GL_NEGATIVE_ONE_TO_ONE or GL_ZERO_TO_ONE */
};
{
GLfloat X, Y; /**< position */
GLfloat Width, Height; /**< size */
- GLdouble Near, Far; /**< Depth buffer range */
+ GLfloat Near, Far; /**< Depth buffer range */
};
-typedef enum
-{
- MAP_USER,
- MAP_INTERNAL,
- MAP_COUNT
-} gl_map_buffer_index;
-
-
/**
* Fields describing a mapped buffer range.
*/
struct gl_buffer_mapping
{
GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */
- GLvoid *Pointer; /**< User-space address of mapping */
- GLintptr Offset; /**< Mapped offset */
- GLsizeiptr Length; /**< Mapped length */
+ GLvoid *Pointer; /**< User-space address of mapping */
+ GLintptr Offset; /**< Mapped offset */
+ GLsizeiptr Length; /**< Mapped length */
};
USAGE_SHADER_STORAGE_BUFFER = 0x8,
USAGE_TRANSFORM_FEEDBACK_BUFFER = 0x10,
USAGE_PIXEL_PACK_BUFFER = 0x20,
- USAGE_DISABLE_MINMAX_CACHE = 0x40,
+ USAGE_ARRAY_BUFFER = 0x40,
+ USAGE_ELEMENT_ARRAY_BUFFER = 0x80,
+ USAGE_DISABLE_MINMAX_CACHE = 0x100,
} gl_buffer_usage;
*/
struct gl_buffer_object
{
- simple_mtx_t Mutex;
GLint RefCount;
GLuint Name;
GLchar *Label; /**< GL_KHR_debug */
- GLenum Usage; /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
+ GLenum16 Usage; /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
GLbitfield StorageFlags; /**< GL_MAP_PERSISTENT_BIT, etc. */
GLsizeiptrARB Size; /**< Size of buffer storage in bytes */
GLubyte *Data; /**< Location of storage either in RAM or VRAM. */
struct gl_buffer_mapping Mappings[MAP_COUNT];
/** Memoization of min/max index computations for static index buffers */
+ simple_mtx_t MinMaxCacheMutex;
struct hash_table *MinMaxCache;
unsigned MinMaxCacheHitIndices;
unsigned MinMaxCacheMissIndices;
/**
- * Vertex array information which is derived from gl_array_attributes
- * and gl_vertex_buffer_binding information. Used by the VBO module and
- * device drivers.
+ * Enum for defining the mapping for the position/generic0 attribute.
+ *
+ * Do not change the order of the values as these are used as
+ * array indices.
*/
-struct gl_vertex_array
+typedef enum
{
- GLint Size; /**< components per element (1,2,3,4) */
- GLenum Type; /**< datatype: GL_FLOAT, GL_INT, etc */
- GLenum Format; /**< default: GL_RGBA, but may be GL_BGRA */
- GLsizei StrideB; /**< actual stride in bytes */
- GLuint _ElementSize; /**< size of each element in bytes */
- const GLubyte *Ptr; /**< Points to array data */
- GLboolean Normalized; /**< GL_ARB_vertex_program */
- GLboolean Integer; /**< Integer-valued? */
- GLboolean Doubles; /**< double precision values are not converted to floats */
- GLuint InstanceDivisor; /**< GL_ARB_instanced_arrays */
-
- struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */
-};
+ ATTRIBUTE_MAP_MODE_IDENTITY, /**< 1:1 mapping */
+ ATTRIBUTE_MAP_MODE_POSITION, /**< get position and generic0 from position */
+ ATTRIBUTE_MAP_MODE_GENERIC0, /**< get position and generic0 from generic0 */
+ ATTRIBUTE_MAP_MODE_MAX /**< for sizing arrays */
+} gl_attribute_map_mode;
/**
*/
struct gl_array_attributes
{
- GLint Size; /**< Components per element (1,2,3,4) */
- GLenum Type; /**< Datatype: GL_FLOAT, GL_INT, etc */
- GLenum Format; /**< Default: GL_RGBA, but may be GL_BGRA */
- GLsizei Stride; /**< Stride as specified with gl*Pointer() */
- const GLubyte *Ptr; /**< Points to client array data. Not used when a VBO is bound */
- GLintptr RelativeOffset; /**< Offset of the first element relative to the binding offset */
- GLboolean Enabled; /**< Whether the array is enabled */
- GLboolean Normalized; /**< Fixed-point values are normalized when converted to floats */
- GLboolean Integer; /**< Fixed-point values are not converted to floats */
- GLboolean Doubles; /**< double precision values are not converted to floats */
- GLuint _ElementSize; /**< Size of each element in bytes */
- GLuint BufferBindingIndex; /**< Vertex buffer binding */
+ /** Points to client array data. Not used when a VBO is bound */
+ const GLubyte *Ptr;
+ /** Offset of the first element relative to the binding offset */
+ GLuint RelativeOffset;
+ /** Vertex format */
+ struct gl_vertex_format Format;
+ /** Stride as specified with gl*Pointer() */
+ GLshort Stride;
+ /** Index into gl_vertex_array_object::BufferBinding[] array */
+ GLubyte BufferBindingIndex;
+
+ /**
+ * Derived effective buffer binding index
+ *
+ * Index into the gl_vertex_buffer_binding array of the vao.
+ * Similar to BufferBindingIndex, but with the mapping of the
+ * position/generic0 attributes applied and with identical
+ * gl_vertex_buffer_binding entries collapsed to a single
+ * entry within the vao.
+ *
+ * The value is valid past calling _mesa_update_vao_derived_arrays.
+ * Note that _mesa_update_vao_derived_arrays is called when binding
+ * the VAO to Array._DrawVAO.
+ */
+ GLubyte _EffBufferBindingIndex;
+ /**
+ * Derived effective relative offset.
+ *
+ * Relative offset to the effective buffers offset in
+ * gl_vertex_buffer_binding::_EffOffset.
+ *
+ * The value is valid past calling _mesa_update_vao_derived_arrays.
+ * Note that _mesa_update_vao_derived_arrays is called when binding
+ * the VAO to Array._DrawVAO.
+ */
+ GLushort _EffRelativeOffset;
};
GLuint InstanceDivisor; /**< GL_ARB_instanced_arrays */
struct gl_buffer_object *BufferObj; /**< GL_ARB_vertex_buffer_object */
GLbitfield _BoundArrays; /**< Arrays bound to this binding point */
+
+ /**
+ * Derived effective bound arrays.
+ *
+ * The effective binding handles enabled arrays past the
+ * position/generic0 attribute mapping and reduces the refered
+ * gl_vertex_buffer_binding entries to a unique subset.
+ *
+ * The value is valid past calling _mesa_update_vao_derived_arrays.
+ * Note that _mesa_update_vao_derived_arrays is called when binding
+ * the VAO to Array._DrawVAO.
+ */
+ GLbitfield _EffBoundArrays;
+ /**
+ * Derived offset.
+ *
+ * The absolute offset to that we can collapse some attributes
+ * to this unique effective binding.
+ * For user space array bindings this contains the smallest pointer value
+ * in the bound and interleaved arrays.
+ * For VBO bindings this contains an offset that lets the attributes
+ * _EffRelativeOffset stay positive and in bounds with
+ * Const.MaxVertexAttribRelativeOffset
+ *
+ * The value is valid past calling _mesa_update_vao_derived_arrays.
+ * Note that _mesa_update_vao_derived_arrays is called when binding
+ * the VAO to Array._DrawVAO.
+ */
+ GLintptr _EffOffset;
};
GLboolean EverBound;
/**
- * Derived vertex attribute arrays
- *
- * This is a legacy data structure created from gl_vertex_attrib_array and
- * gl_vertex_buffer_binding, for compatibility with existing driver code.
+ * Marked to true if the object is shared between contexts and immutable.
+ * Then reference counting is done using atomics and thread safe.
+ * Is used for dlist VAOs.
*/
- struct gl_vertex_array _VertexAttrib[VERT_ATTRIB_MAX];
+ bool SharedAndImmutable;
/** Vertex attribute arrays */
struct gl_array_attributes VertexAttrib[VERT_ATTRIB_MAX];
GLbitfield VertexAttribBufferMask;
/** Mask of VERT_BIT_* values indicating which arrays are enabled */
- GLbitfield _Enabled;
+ GLbitfield Enabled;
+
+ /**
+ * Mask of VERT_BIT_* enabled arrays past position/generic0 mapping
+ *
+ * The value is valid past calling _mesa_update_vao_derived_arrays.
+ * Note that _mesa_update_vao_derived_arrays is called when binding
+ * the VAO to Array._DrawVAO.
+ */
+ GLbitfield _EffEnabledVBO;
+
+ /** Denotes the way the position/generic0 attribute is mapped */
+ gl_attribute_map_mode _AttributeMapMode;
/** Mask of VERT_BIT_* values indicating changed/dirty arrays */
GLbitfield NewArrays;
};
-/**
- * Used to signal when transitioning from one kind of drawing method
- * to another.
- */
-typedef enum
-{
- DRAW_NONE, /**< Initial value only */
- DRAW_BEGIN_END,
- DRAW_DISPLAY_LIST,
- DRAW_ARRAYS
-} gl_draw_method;
-
-
-/**
- * Enum for the OpenGL APIs we know about and may support.
- *
- * NOTE: This must match the api_enum table in
- * src/mesa/main/get_hash_generator.py
- */
-typedef enum
-{
- API_OPENGL_COMPAT, /* legacy / compatibility contexts */
- API_OPENGLES,
- API_OPENGLES2,
- API_OPENGL_CORE,
- API_OPENGL_LAST = API_OPENGL_CORE
-} gl_api;
-
-
/**
* Vertex array state
*/
GLuint RestartIndex;
/*@}*/
- /** One of the DRAW_xxx flags, not consumed by drivers */
- gl_draw_method DrawMethod;
-
/* GL_ARB_vertex_buffer_object */
struct gl_buffer_object *ArrayBufferObj;
/**
- * Vertex arrays as consumed by a driver.
- * The array pointer is set up only by the VBO module.
+ * Vertex array object that is used with the currently active draw command.
+ * The _DrawVAO is either set to the currently bound VAO for array type
+ * draws or to internal VAO's set up by the vbo module to execute immediate
+ * mode or display list draws.
+ */
+ struct gl_vertex_array_object *_DrawVAO;
+ /**
+ * The VERT_BIT_* bits effectively enabled from the current _DrawVAO.
+ * This is always a subset of _mesa_get_vao_vp_inputs(_DrawVAO)
+ * but may omit those arrays that shall not be referenced by the current
+ * gl_vertex_program_state::_VPMode. For example the generic attributes are
+ * maked out form the _DrawVAO's enabled arrays when a fixed function
+ * array draw is executed.
*/
- const struct gl_vertex_array **_DrawArrays; /**< 0..VERT_ATTRIB_MAX-1 */
+ GLbitfield _DrawVAOEnabledAttribs;
+ /**
+ * Initially or if the VAO referenced by _DrawVAO is deleted the _DrawVAO
+ * pointer is set to the _EmptyVAO which is just an empty VAO all the time.
+ */
+ struct gl_vertex_array_object *_EmptyVAO;
/** Legal array datatypes and the API for which they have been computed */
GLbitfield LegalTypesMask;
*/
struct gl_feedback
{
- GLenum Type;
+ GLenum16 Type;
GLbitfield _Mask; /**< FB_* bits */
GLfloat *Buffer;
GLuint BufferSize;
struct gl_transform_feedback_varying_info
{
char *Name;
- GLenum Type;
+ GLenum16 Type;
GLint BufferIndex;
GLint Size;
GLint Offset;
/** Post-link transform feedback info. */
struct gl_transform_feedback_info
{
- /* Was xfb enabled via the api or in shader layout qualifiers */
- bool api_enabled;
-
unsigned NumOutputs;
/* Bitmask of active buffer indices. */
*/
struct gl_transform_feedback_state
{
- GLenum Mode; /**< GL_POINTS, GL_LINES or GL_TRIANGLES */
+ GLenum16 Mode; /**< GL_POINTS, GL_LINES or GL_TRIANGLES */
/** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */
struct gl_buffer_object *CurrentBuffer;
* Data type of the counter. Valid values are FLOAT, UNSIGNED_INT,
* UNSIGNED_INT64_AMD, and PERCENTAGE_AMD.
*/
- GLenum Type;
+ GLenum16 Type;
/** Minimum counter value. */
union gl_perf_monitor_counter_value Minimum;
/** Whether this bindless image is bound to a unit. */
GLboolean bound;
- /** Access qualifier (GL_READ_WRITE, GL_READ_ONLY, GL_WRITE_ONLY) */
- GLenum access;
+ /** Access qualifier (GL_READ_WRITE, GL_READ_ONLY, GL_WRITE_ONLY, or
+ * GL_NONE to indicate both read-only and write-only)
+ */
+ GLenum16 access;
/** Pointer to the base of the data. */
GLvoid *data;
/**
- * Names of the various vertex/fragment program register files, etc.
- *
- * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)
- * All values should fit in a 4-bit field.
- *
- * NOTE: PROGRAM_STATE_VAR, PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be
- * considered to be "uniform" variables since they can only be set outside
- * glBegin/End. They're also all stored in the same Parameters array.
+ * Current vertex processing mode: fixed function vs. shader.
+ * In reality, fixed function is probably implemented by a shader but that's
+ * not what we care about here.
*/
typedef enum
{
- PROGRAM_TEMPORARY, /**< machine->Temporary[] */
- PROGRAM_ARRAY, /**< Arrays & Matrixes */
- PROGRAM_INPUT, /**< machine->Inputs[] */
- PROGRAM_OUTPUT, /**< machine->Outputs[] */
- PROGRAM_STATE_VAR, /**< gl_program->Parameters[] */
- PROGRAM_CONSTANT, /**< gl_program->Parameters[] */
- PROGRAM_UNIFORM, /**< gl_program->Parameters[] */
- PROGRAM_WRITE_ONLY, /**< A dummy, write-only register */
- PROGRAM_ADDRESS, /**< machine->AddressReg */
- PROGRAM_SAMPLER, /**< for shader samplers, compile-time only */
- PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */
- PROGRAM_UNDEFINED, /**< Invalid/TBD value */
- PROGRAM_IMMEDIATE, /**< Immediate value, used by TGSI */
- PROGRAM_BUFFER, /**< for shader buffers, compile-time only */
- PROGRAM_MEMORY, /**< for shared, global and local memory */
- PROGRAM_IMAGE, /**< for shader images, compile-time only */
- PROGRAM_HW_ATOMIC, /**< for hw atomic counters, compile-time only */
- PROGRAM_FILE_MAX
-} gl_register_file;
+ VP_MODE_FF, /**< legacy / fixed function */
+ VP_MODE_SHADER, /**< ARB vertex program or GLSL vertex shader */
+ VP_MODE_MAX /**< for sizing arrays */
+} gl_vertex_processing_mode;
/**
GLint RefCount;
GLubyte *String; /**< Null-terminated program text */
- GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_GEOMETRY_PROGRAM_NV */
- GLenum Format; /**< String encoding format */
+ /** GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_GEOMETRY_PROGRAM_NV */
+ GLenum16 Target;
+ GLenum16 Format; /**< String encoding format */
GLboolean _Used; /**< Ever used for drawing? Used for debugging */
/** Is this program written to on disk shader cache */
bool program_written_to_cache;
- GLbitfield64 SecondaryOutputsWritten; /**< Subset of OutputsWritten outputs written with non-zero index. */
- GLbitfield TexturesUsed[MAX_COMBINED_TEXTURE_IMAGE_UNITS]; /**< TEXTURE_x_BIT bitmask */
- GLbitfield SamplersUsed; /**< Bitfield of which samplers are used */
- GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */
- GLbitfield ExternalSamplersUsed; /**< Texture units used for samplerExternalOES */
-
- /* Fragement shader only fields */
- GLboolean OriginUpperLeft;
- GLboolean PixelCenterInteger;
+ /** A bitfield indicating which vertex shader inputs consume two slots
+ *
+ * This is used for mapping from single-slot input locations in the GL API
+ * to dual-slot double input locations in the shader. This field is set
+ * once as part of linking and never updated again to ensure the mapping
+ * remains consistent.
+ *
+ * Note: There may be dual-slot variables in the original shader source
+ * which do not appear in this bitfield due to having been eliminated by
+ * the compiler prior to DualSlotInputs being calculated. There may also
+ * be bits set in this bitfield which are set but which the shader never
+ * reads due to compiler optimizations eliminating such variables after
+ * DualSlotInputs is calculated.
+ */
+ GLbitfield64 DualSlotInputs;
+ /** Subset of OutputsWritten outputs written with non-zero index. */
+ GLbitfield64 SecondaryOutputsWritten;
+ /** TEXTURE_x_BIT bitmask */
+ GLbitfield16 TexturesUsed[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+ /** Bitfield of which samplers are used */
+ GLbitfield SamplersUsed;
+ /** Texture units used for shadow sampling. */
+ GLbitfield ShadowSamplers;
+ /** Texture units used for samplerExternalOES */
+ GLbitfield ExternalSamplersUsed;
/** Named parameters, constants, etc. from program text */
struct gl_program_parameter_list *Parameters;
/**
* Access qualifier specified in the shader for each image uniform
- * index. Either \c GL_READ_ONLY, \c GL_WRITE_ONLY or \c
- * GL_READ_WRITE.
+ * index. Either \c GL_READ_ONLY, \c GL_WRITE_ONLY, \c
+ * GL_READ_WRITE, or \c GL_NONE to indicate both read-only and
+ * write-only.
*
* It may be different, though only more strict than the value of
* \c gl_image_unit::Access for the corresponding image unit.
*/
- GLenum ImageAccess[MAX_IMAGE_UNIFORMS];
+ GLenum16 ImageAccess[MAX_IMAGE_UNIFORMS];
struct gl_uniform_block **UniformBlocks;
struct gl_uniform_block **ShaderStorageBlocks;
+ /**
+ * Bitmask of shader storage blocks not declared as read-only.
+ */
+ unsigned ShaderStorageBlocksWriteAccess;
+
/** Which texture target is being sampled
* (TEXTURE_1D/2D/3D/etc_INDEX)
*/
- gl_texture_index SamplerTargets[MAX_SAMPLERS];
+ GLubyte SamplerTargets[MAX_SAMPLERS];
/**
* Number of samplers declared with the bindless_sampler layout
struct gl_program_cache *Cache;
GLboolean _Overriden;
+
+ /**
+ * If we have a vertex program, a TNL program or no program at all.
+ * Note that this value should be kept up to date all the time,
+ * nevertheless its correctness is asserted in _mesa_update_state.
+ * The reason is to avoid calling _mesa_update_state twice we need
+ * this value on draw *before* actually calling _mesa_update_state.
+ * Also it should need to get recomputed only on changes to the
+ * vertex program which are heavyweight already.
+ */
+ gl_vertex_processing_mode _VPMode;
};
/**
*/
struct gl_geometry_program_state
{
- /** Currently enabled and valid program (including internal programs
+ /**
+ * Currently enabled and valid program (including internal programs
* and compiled shader programs).
*/
struct gl_program *_Current;
struct gl_program *Current; /**< User-bound fragment program */
- /** Currently enabled and valid fragment program (including internal
+ /**
+ * Currently enabled and valid fragment program (including internal
* programs, user-defined fragment programs and GLSL fragment shaders).
* This is the program we must use when rendering.
*/
GLubyte numArithInstr[2];
GLubyte regsAssigned[2];
GLubyte NumPasses; /**< 1 or 2 */
- /** Current compile stage: 0 setup pass1, 1 arith pass1, 2 setup pass2, 3 arith pass2 */
+ /**
+ * Current compile stage: 0 setup pass1, 1 arith pass1,
+ * 2 setup pass2, 3 arith pass2.
+ */
GLubyte cur_pass;
GLubyte last_optype;
GLboolean interpinp1;
GLboolean isValid;
- /** Array of 2 bit values for each tex unit to remember whether
+ /**
+ * Array of 2 bit values for each tex unit to remember whether
* STR or STQ swizzle was used
*/
GLuint swizzlerq;
* GL_TRIANGLES, GL_QUADS, GL_ISOLINES or PRIM_UNKNOWN if it's not set
* in this shader.
*/
- GLenum PrimitiveMode;
+ GLenum16 PrimitiveMode;
enum gl_tess_spacing Spacing;
/**
* GL_CW, GL_CCW, or 0 if it's not set in this shader.
*/
- GLenum VertexOrder;
+ GLenum16 VertexOrder;
/**
* 1, 0, or -1 if it's not set in this shader.
*/
GLint VerticesOut;
/**
* 0 - Invocations count not declared in shader, or
- * 1 .. MAX_GEOMETRY_SHADER_INVOCATIONS
+ * 1 .. Const.MaxGeometryShaderInvocations
*/
GLint Invocations;
/**
* GL_TRIANGLES_ADJACENCY, or PRIM_UNKNOWN if it's not set in this
* shader.
*/
- GLenum InputType;
+ GLenum16 InputType;
/**
* GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP, or PRIM_UNKNOWN if
* it's not set in this shader.
*/
- GLenum OutputType;
+ GLenum16 OutputType;
} Geom;
/**
* ARB_compute_variable_group_size.
*/
bool LocalSizeVariable;
+
+ /*
+ * Arrangement of invocations used to calculate derivatives in a compute
+ * shader. From NV_compute_shader_derivatives.
+ */
+ enum gl_derivative_group DerivativeGroup;
} Comp;
};
struct exec_list *packed_varyings;
struct exec_list *fragdata_arrays;
struct glsl_symbol_table *symbols;
+
+ /**
+ * ARB_gl_spirv related data.
+ *
+ * This is actually a reference to the gl_shader::spirv_data, which
+ * stores information that is also needed during linking.
+ */
+ struct gl_shader_spirv_data *spirv_data;
};
/**
- * Compile status enum. compile_skipped is used to indicate the compile
+ * Compile status enum. COMPILE_SKIPPED is used to indicate the compile
* was skipped due to the shader matching one that's been seen before by
* the on-disk cache.
*/
enum gl_compile_status
{
- compile_failure = 0,
- compile_success,
- compile_skipped,
- compiled_no_opts
+ COMPILE_FAILURE = 0,
+ COMPILE_SUCCESS,
+ COMPILE_SKIPPED
};
/**
* GL_TESS_CONTROL_SHADER || GL_TESS_EVALUATION_SHADER.
* Must be the first field.
*/
- GLenum Type;
+ GLenum16 Type;
gl_shader_stage Stage;
GLuint Name; /**< AKA the handle */
GLint RefCount; /**< Reference count */
bool uses_gl_fragcoord;
bool PostDepthCoverage;
+ bool PixelInterlockOrdered;
+ bool PixelInterlockUnordered;
+ bool SampleInterlockOrdered;
+ bool SampleInterlockUnordered;
bool InnerCoverage;
/**
*/
struct gl_program_resource
{
- GLenum Type; /** Program interface type. */
+ GLenum16 Type; /** Program interface type. */
const void *Data; /** Pointer to resource associated data structure. */
uint8_t StageReferences; /** Bitmask of shader stage references. */
};
/**
- * Link status enum. linking_skipped is used to indicate linking
+ * Link status enum. LINKING_SKIPPED is used to indicate linking
* was skipped due to the shader being loaded from the on-disk cache.
*/
enum gl_link_status
{
- linking_failure = 0,
- linking_success,
- linking_skipped
+ LINKING_FAILURE = 0,
+ LINKING_SUCCESS,
+ LINKING_SKIPPED
};
/**
*/
union gl_constant_value *UniformDataDefaults;
+ /** Hash for quick search by name. */
+ struct hash_table_u64 *ProgramResourceHash;
+
GLboolean Validated;
/** List of all active resources after linking. */
/* Mask of stages this program was linked against */
unsigned linked_stages;
+
+ /* Whether the shaders of this program are loaded from SPIR-V binaries
+ * (all have the SPIR_V_BINARY_ARB state). This was introduced by the
+ * ARB_gl_spirv extension.
+ */
+ bool spirv;
};
/**
*/
struct gl_shader_program
{
- GLenum Type; /**< Always GL_SHADER_PROGRAM (internal token) */
+ GLenum16 Type; /**< Always GL_SHADER_PROGRAM (internal token) */
GLuint Name; /**< aka handle or ID */
GLchar *Label; /**< GL_KHR_debug */
GLint RefCount; /**< Reference count */
/**
* Is the application intending to glGetProgramBinary this program?
+ *
+ * BinaryRetrievableHint is the currently active hint that gets set
+ * during initialization and after linking and BinaryRetrievableHintPending
+ * is the hint set by the user to be active when program is linked next time.
*/
- GLboolean BinaryRetreivableHint;
+ GLboolean BinaryRetrievableHint;
+ GLboolean BinaryRetrievableHintPending;
/**
* Indicates whether program can be bound for individual pipeline stages
* feedback output, see LinkedTransformFeedback.
*/
struct {
- GLenum BufferMode;
+ GLenum16 BufferMode;
/** Global xfb_stride out qualifier if any */
GLuint BufferStride[MAX_FEEDBACK_BUFFERS];
GLuint NumVarying;
*/
struct gl_linked_shader *_LinkedShaders[MESA_SHADER_STAGES];
- /* True if any of the fragment shaders attached to this program use:
+ /**
+ * True if any of the fragment shaders attached to this program use:
* #extension ARB_fragment_coord_conventions: enable
*/
GLboolean ARB_fragment_coord_conventions_enable;
*/
struct gl_shader_program *ActiveProgram;
- GLbitfield Flags; /**< Mask of GLSL_x flags */
-
- GLboolean EverBound; /**< Has the pipeline object been created */
-
- GLboolean Validated; /**< Pipeline Validation status */
+ GLbitfield Flags; /**< Mask of GLSL_x flags */
+ GLboolean EverBound; /**< Has the pipeline object been created */
+ GLboolean Validated; /**< Pipeline Validation status */
GLchar *InfoLog;
};
/** Currently bound pipeline object. See _mesa_BindProgramPipeline() */
struct gl_pipeline_object *Current;
- /* Default Object to ensure that _Shader is never NULL */
+ /** Default Object to ensure that _Shader is never NULL */
struct gl_pipeline_object *Default;
/** Pipeline objects */
*/
GLboolean OptimizeForAOS;
- GLboolean LowerBufferInterfaceBlocks; /**< Lower UBO and SSBO access to intrinsics. */
+ /** Lower UBO and SSBO access to intrinsics. */
+ GLboolean LowerBufferInterfaceBlocks;
/** Clamp UBO and SSBO block indices so they don't go out-of-bounds. */
GLboolean ClampBlockIndicesToArrayBounds;
+ /** (driconf) Force gl_Position to be considered invariant */
+ GLboolean PositionAlwaysInvariant;
+
const struct nir_shader_compiler_options *NirOptions;
};
*/
struct gl_query_object
{
- GLenum Target; /**< The query target, when active */
+ GLenum16 Target; /**< The query target, when active */
GLuint Id; /**< hash table ID/name */
- GLchar *Label; /**< GL_KHR_debug */
+ GLchar *Label; /**< GL_KHR_debug */
GLuint64EXT Result; /**< the counter */
GLboolean Active; /**< inside Begin/EndQuery */
GLboolean Ready; /**< result is ready? */
/** GL_ARB_pipeline_statistics_query */
struct gl_query_object *pipeline_stats[MAX_PIPELINE_STATISTICS];
- GLenum CondRenderMode;
+ GLenum16 CondRenderMode;
};
GLboolean DeletePending; /**< Object was deleted while there were still
* live references (e.g., sync not yet finished)
*/
- GLenum SyncCondition;
+ GLenum16 SyncCondition;
GLbitfield Flags; /**< Flags passed to glFenceSync */
GLuint StatusFlag:1; /**< Has the sync object been signaled? */
};
struct hash_table_u64 *ImageHandles;
mtx_t HandlesMutex; /**< For texture/image handles safety */
+ /* GL_ARB_shading_language_include */
+ struct shader_includes *ShaderIncludes;
+ /* glCompileShaderInclude expects ShaderIncludes not to change while it is
+ * in progress.
+ */
+ mtx_t ShaderIncludeMutex;
+
/**
* Some context in this share group was affected by a GPU reset
*
/** EXT_external_objects */
struct _mesa_HashTable *MemoryObjects;
+ /** EXT_semaphore */
+ struct _mesa_HashTable *SemaphoreObjects;
+
/**
* Some context in this share group was affected by a disjoint
* operation. This operation can be anything that has effects on
*/
GLboolean NeedsFinishRenderTexture;
GLubyte NumSamples; /**< zero means not multisampled */
- GLenum InternalFormat; /**< The user-specified format */
- GLenum _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
+ GLubyte NumStorageSamples; /**< for AMD_framebuffer_multisample_advanced */
+ GLenum16 InternalFormat; /**< The user-specified format */
+ GLenum16 _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
GL_STENCIL_INDEX. */
mesa_format Format; /**< The actual renderbuffer memory format */
/**
*/
struct gl_renderbuffer_attachment
{
- GLenum Type; /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */
+ GLenum16 Type; /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */
GLboolean Complete;
/**
*/
struct gl_texture_object *Texture;
GLuint TextureLevel; /**< Attached mipmap level. */
+ GLsizei NumSamples; /**< from FramebufferTexture2DMultisampleEXT */
GLuint CubeMapFace; /**< 0 .. 5, for cube map textures. */
GLuint Zoffset; /**< Slice for 3D textures, or layer for both 1D
* and 2D array textures */
/*@}*/
/** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
- GLenum _Status;
+ GLenum16 _Status;
/** Whether one of Attachment has Type != GL_NONE
* NOTE: the values for Width and Height are set to 0 in case of having
bool _HasAttachments;
GLbitfield _IntegerBuffers; /**< Which color buffers are integer valued */
+ GLbitfield _RGBBuffers; /**< Which color buffers have baseformat == RGB */
+ GLbitfield _FP32Buffers; /**< Which color buffers are FP32 */
/* ARB_color_buffer_float */
GLboolean _AllColorBuffersFixedPoint; /* no integer, no float */
/* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
* attribute group and GL_PIXEL attribute group, respectively.
*/
- GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];
- GLenum ColorReadBuffer;
+ GLenum16 ColorDrawBuffer[MAX_DRAW_BUFFERS];
+ GLenum16 ColorReadBuffer;
+
+ /* GL_ARB_sample_locations */
+ GLfloat *SampleLocationTable; /**< If NULL, no table has been specified */
+ GLboolean ProgrammableSampleLocations;
+ GLboolean SampleLocationPixelGrid;
/** Computed from ColorDraw/ReadBuffer above */
GLuint _NumColorDrawBuffers;
struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];
struct gl_renderbuffer *_ColorReadBuffer;
+ /* GL_MESA_framebuffer_flip_y */
+ bool FlipY;
+
/** Delete this framebuffer */
void (*Delete)(struct gl_framebuffer *fb);
};
struct gl_precision LowInt, MediumInt, HighInt;
/* GL_ARB_uniform_buffer_object */
GLuint MaxUniformBlocks;
- GLuint MaxCombinedUniformComponents;
+ uint64_t MaxCombinedUniformComponents;
GLuint MaxTextureImageUnits;
/* GL_ARB_shader_atomic_counters */
struct gl_constants
{
GLuint MaxTextureMbytes; /**< Max memory per image, in MB */
- GLuint MaxTextureLevels; /**< Max mipmap levels. */
+ GLuint MaxTextureSize; /**< Max 1D/2D texture size, in pixels*/
GLuint Max3DTextureLevels; /**< Max mipmap levels for 3D textures */
GLuint MaxCubeTextureLevels; /**< Max mipmap levels for cube textures */
GLuint MaxArrayTextureLayers; /**< Max layers in array textures */
/** geometry shader */
GLuint MaxGeometryOutputVertices;
GLuint MaxGeometryTotalOutputComponents;
+ GLuint MaxGeometryShaderInvocations;
GLuint GLSLVersion; /**< Desktop GLSL version supported (ex: 120 = 1.20) */
+ GLuint GLSLVersionCompat; /**< Desktop compat GLSL version supported */
/**
* Changes default GLSL extension behavior from "error" to "warn". It's out
*/
GLboolean AllowGLSLExtensionDirectiveMidShader;
+ /**
+ * Allow builtins as part of constant expressions. This was not allowed
+ * until GLSL 1.20 this allows it everywhere.
+ */
+ GLboolean AllowGLSLBuiltinConstantExpression;
+
+ /**
+ * Allow some relaxation of GLSL ES shader restrictions. This encompasses
+ * a number of relaxations to the ES shader rules.
+ */
+ GLboolean AllowGLSLRelaxedES;
+
/**
* Allow GLSL built-in variables to be redeclared verbatim
*/
*/
GLboolean AllowHigherCompatVersion;
+ /**
+ * Allow layout qualifiers on function parameters.
+ */
+ GLboolean AllowLayoutQualifiersOnFunctionParameters;
+
/**
* Force computing the absolute value for sqrt() and inversesqrt() to follow
* D3D9 when apps rely on this behaviour.
GLboolean QuadsFollowProvokingVertexConvention;
/** GL_ARB_viewport_array */
- GLenum LayerAndVPIndexProvokingVertex;
+ GLenum16 LayerAndVPIndexProvokingVertex;
/** OpenGL version 3.0 */
GLbitfield ContextFlags; /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
GLuint MaxProgramTextureGatherComponents;
/* GL_ARB_robustness */
- GLenum ResetStrategy;
+ GLenum16 ResetStrategy;
/* GL_KHR_robustness */
GLboolean RobustAccess;
*/
GLboolean GLSLSkipStrictMaxUniformLimitCheck;
- /** Whether gl_FragCoord and gl_FrontFacing are system values. */
+ /**
+ * Whether gl_FragCoord, gl_PointCoord and gl_FrontFacing
+ * are system values.
+ **/
bool GLSLFragCoordIsSysVal;
+ bool GLSLPointCoordIsSysVal;
bool GLSLFrontFacingIsSysVal;
/**
*/
bool GLSLOptimizeConservatively;
+ /**
+ * Whether to call lower_const_arrays_to_uniforms() during linking.
+ */
+ bool GLSLLowerConstArrays;
+
/**
* True if gl_TessLevelInner/Outer[] in the TES should be inputs
* (otherwise, they're system values).
GLint MaxDepthTextureSamples;
GLint MaxIntegerSamples;
+ /** GL_AMD_framebuffer_multisample_advanced */
+ GLint MaxColorFramebufferSamples;
+ GLint MaxColorFramebufferStorageSamples;
+ GLint MaxDepthStencilFramebufferSamples;
+
+ /* An array of supported MSAA modes allowing different sample
+ * counts per attachment type.
+ */
+ struct {
+ GLint NumColorSamples;
+ GLint NumColorStorageSamples;
+ GLint NumDepthStencilSamples;
+ } SupportedMultisampleModes[40];
+ GLint NumSupportedMultisampleModes;
+
/**
* GL_EXT_texture_multisample_blit_scaled implementation assumes that
* samples are laid out in a rectangular grid roughly corresponding to
GLboolean FakeSWMSAA;
/** GL_KHR_context_flush_control */
- GLenum ContextReleaseBehavior;
+ GLenum16 ContextReleaseBehavior;
struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_STAGES];
/** GL_ARB_get_program_binary */
GLuint NumProgramBinaryFormats;
+
+ /** GL_NV_conservative_raster */
+ GLuint MaxSubpixelPrecisionBiasBits;
+
+ /** GL_NV_conservative_raster_dilate */
+ GLfloat ConservativeRasterDilateRange[2];
+ GLfloat ConservativeRasterDilateGranularity;
+
+ /** Is the drivers uniform storage packed or padded to 16 bytes. */
+ bool PackedDriverUniformStorage;
+
+ /** Does the driver make use of the NIR based GLSL linker */
+ bool UseNIRGLSLLinker;
+
+ /** Wether or not glBitmap uses red textures rather than alpha */
+ bool BitmapUsesRed;
+
+ /** GL_ARB_gl_spirv */
+ struct spirv_supported_capabilities SpirVCapabilities;
+
+ /** GL_ARB_spirv_extensions */
+ struct spirv_supported_extensions *SpirVExtensions;
+
+ char *VendorOverride;
};
GLboolean ARB_clear_texture;
GLboolean ARB_clip_control;
GLboolean ARB_color_buffer_float;
+ GLboolean ARB_compatibility;
GLboolean ARB_compute_shader;
GLboolean ARB_compute_variable_group_size;
GLboolean ARB_conditional_render_inverted;
GLboolean ARB_fragment_shader;
GLboolean ARB_framebuffer_no_attachments;
GLboolean ARB_framebuffer_object;
+ GLboolean ARB_fragment_shader_interlock;
GLboolean ARB_enhanced_layouts;
GLboolean ARB_explicit_attrib_location;
GLboolean ARB_explicit_uniform_location;
GLboolean ARB_post_depth_coverage;
GLboolean ARB_query_buffer_object;
GLboolean ARB_robust_buffer_access_behavior;
+ GLboolean ARB_sample_locations;
GLboolean ARB_sample_shading;
GLboolean ARB_seamless_cube_map;
GLboolean ARB_shader_atomic_counter_ops;
GLboolean ARB_shadow;
GLboolean ARB_sparse_buffer;
GLboolean ARB_stencil_texturing;
+ GLboolean ARB_spirv_extensions;
GLboolean ARB_sync;
GLboolean ARB_tessellation_shader;
GLboolean ARB_texture_border_clamp;
GLboolean EXT_blend_equation_separate;
GLboolean EXT_blend_func_separate;
GLboolean EXT_blend_minmax;
+ GLboolean EXT_demote_to_helper_invocation;
GLboolean EXT_depth_bounds_test;
GLboolean EXT_disjoint_timer_query;
GLboolean EXT_draw_buffers2;
+ GLboolean EXT_EGL_image_storage;
+ GLboolean EXT_float_blend;
GLboolean EXT_framebuffer_multisample;
GLboolean EXT_framebuffer_multisample_blit_scaled;
GLboolean EXT_framebuffer_sRGB;
GLboolean EXT_gpu_shader4;
GLboolean EXT_memory_object;
GLboolean EXT_memory_object_fd;
+ GLboolean EXT_multisampled_render_to_texture;
GLboolean EXT_packed_float;
GLboolean EXT_pixel_buffer_object;
GLboolean EXT_point_parameters;
GLboolean EXT_provoking_vertex;
+ GLboolean EXT_render_snorm;
+ GLboolean EXT_semaphore;
+ GLboolean EXT_semaphore_fd;
+ GLboolean EXT_shader_image_load_formatted;
+ GLboolean EXT_shader_image_load_store;
GLboolean EXT_shader_integer_mix;
GLboolean EXT_shader_samples_identical;
+ GLboolean EXT_sRGB;
GLboolean EXT_stencil_two_side;
GLboolean EXT_texture_array;
+ GLboolean EXT_texture_buffer_object;
GLboolean EXT_texture_compression_latc;
GLboolean EXT_texture_compression_s3tc;
+ GLboolean EXT_texture_compression_s3tc_srgb;
GLboolean EXT_texture_env_dot3;
GLboolean EXT_texture_filter_anisotropic;
GLboolean EXT_texture_integer;
GLboolean EXT_texture_mirror_clamp;
+ GLboolean EXT_texture_shadow_lod;
GLboolean EXT_texture_shared_exponent;
GLboolean EXT_texture_snorm;
GLboolean EXT_texture_sRGB;
+ GLboolean EXT_texture_sRGB_R8;
GLboolean EXT_texture_sRGB_decode;
GLboolean EXT_texture_swizzle;
GLboolean EXT_texture_type_2_10_10_10_REV;
GLboolean OES_standard_derivatives;
GLboolean OES_texture_buffer;
GLboolean OES_texture_cube_map_array;
+ GLboolean OES_texture_view;
GLboolean OES_viewport_array;
/* vendor extensions */
+ GLboolean AMD_compressed_ATC_texture;
+ GLboolean AMD_framebuffer_multisample_advanced;
+ GLboolean AMD_depth_clamp_separate;
GLboolean AMD_performance_monitor;
GLboolean AMD_pinned_memory;
GLboolean AMD_seamless_cubemap_per_texture;
GLboolean ATI_texture_mirror_once;
GLboolean ATI_texture_env_combine3;
GLboolean ATI_fragment_shader;
- GLboolean ATI_separate_stencil;
GLboolean GREMEDY_string_marker;
GLboolean INTEL_conservative_rasterization;
GLboolean INTEL_performance_query;
+ GLboolean INTEL_shader_atomic_float_minmax;
GLboolean KHR_blend_equation_advanced;
GLboolean KHR_blend_equation_advanced_coherent;
GLboolean KHR_robustness;
GLboolean KHR_texture_compression_astc_hdr;
GLboolean KHR_texture_compression_astc_ldr;
GLboolean KHR_texture_compression_astc_sliced_3d;
+ GLboolean MESA_framebuffer_flip_y;
GLboolean MESA_tile_raster_order;
GLboolean MESA_pack_invert;
- GLboolean MESA_shader_framebuffer_fetch;
- GLboolean MESA_shader_framebuffer_fetch_non_coherent;
+ GLboolean EXT_shader_framebuffer_fetch;
+ GLboolean EXT_shader_framebuffer_fetch_non_coherent;
GLboolean MESA_shader_integer_functions;
GLboolean MESA_ycbcr_texture;
+ GLboolean NV_compute_shader_derivatives;
GLboolean NV_conditional_render;
GLboolean NV_fill_rectangle;
GLboolean NV_fog_distance;
GLboolean NV_point_sprite;
GLboolean NV_primitive_restart;
+ GLboolean NV_shader_atomic_float;
GLboolean NV_texture_barrier;
GLboolean NV_texture_env_combine4;
GLboolean NV_texture_rectangle;
GLboolean NV_vdpau_interop;
+ GLboolean NV_conservative_raster;
+ GLboolean NV_conservative_raster_dilate;
+ GLboolean NV_conservative_raster_pre_snap_triangles;
+ GLboolean NV_conservative_raster_pre_snap;
GLboolean NVX_gpu_memory_info;
GLboolean TDFX_texture_compression_FXT1;
GLboolean OES_EGL_image;
#define _NEW_TRANSFORM (1u << 17) /**< gl_context::Transform */
#define _NEW_VIEWPORT (1u << 18) /**< gl_context::Viewport */
#define _NEW_TEXTURE_STATE (1u << 19) /**< gl_context::Texture (states only) */
-#define _NEW_ARRAY (1u << 20) /**< gl_context::Array */
+/* gap */
#define _NEW_RENDERMODE (1u << 21) /**< gl_context::RenderMode, etc */
#define _NEW_BUFFERS (1u << 22) /**< gl_context::Visual, DrawBuffer, */
#define _NEW_CURRENT_ATTRIB (1u << 23) /**< gl_context::Current */
GLvertexformat ListVtxfmt;
GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];
- GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];
+ GLfloat CurrentAttrib[VERT_ATTRIB_MAX][8];
GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];
GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];
/* State known to have been set by the currently-compiling display
* list. Used to eliminate some redundant state changes.
*/
- GLenum ShadeModel;
+ GLenum16 ShadeModel;
} Current;
};
-/** @{
- *
- * These are a mapping of the GL_ARB_debug_output/GL_KHR_debug enums
- * to small enums suitable for use as an array index.
- */
-
-enum mesa_debug_source
-{
- MESA_DEBUG_SOURCE_API,
- MESA_DEBUG_SOURCE_WINDOW_SYSTEM,
- MESA_DEBUG_SOURCE_SHADER_COMPILER,
- MESA_DEBUG_SOURCE_THIRD_PARTY,
- MESA_DEBUG_SOURCE_APPLICATION,
- MESA_DEBUG_SOURCE_OTHER,
- MESA_DEBUG_SOURCE_COUNT
-};
-
-enum mesa_debug_type
-{
- MESA_DEBUG_TYPE_ERROR,
- MESA_DEBUG_TYPE_DEPRECATED,
- MESA_DEBUG_TYPE_UNDEFINED,
- MESA_DEBUG_TYPE_PORTABILITY,
- MESA_DEBUG_TYPE_PERFORMANCE,
- MESA_DEBUG_TYPE_OTHER,
- MESA_DEBUG_TYPE_MARKER,
- MESA_DEBUG_TYPE_PUSH_GROUP,
- MESA_DEBUG_TYPE_POP_GROUP,
- MESA_DEBUG_TYPE_COUNT
-};
-
-enum mesa_debug_severity
-{
- MESA_DEBUG_SEVERITY_LOW,
- MESA_DEBUG_SEVERITY_MEDIUM,
- MESA_DEBUG_SEVERITY_HIGH,
- MESA_DEBUG_SEVERITY_NOTIFICATION,
- MESA_DEBUG_SEVERITY_COUNT
-};
-
-/** @} */
-
/**
* Driver-specific state flags.
*
*/
uint64_t NewIntelConservativeRasterization;
+ /**
+ * gl_context::NvConservativeRasterization
+ */
+ uint64_t NewNvConservativeRasterization;
+
+ /**
+ * gl_context::ConservativeRasterMode/ConservativeRasterDilate
+ * gl_context::SubpixelPrecisionBias
+ */
+ uint64_t NewNvConservativeRasterizationParams;
+
/**
* gl_context::Scissor::WindowRects
*/
/** Shader constants (uniforms, program parameters, state constants) */
uint64_t NewShaderConstants[MESA_SHADER_STAGES];
+
+ /** Programmable sample location state for gl_context::DrawBuffer */
+ uint64_t NewSampleLocations;
};
struct gl_buffer_binding
/**
* Level of the texture object bound to this unit.
*/
- GLuint Level;
+ GLubyte Level;
/**
* \c GL_TRUE if the whole level is bound as an array of layers, \c
* Layer of the texture object bound to this unit as specified by the
* application.
*/
- GLuint Layer;
+ GLushort Layer;
/**
- * Layer of the texture object bound to this unit, or zero if the
- * whole level is bound.
+ * Layer of the texture object bound to this unit, or zero if
+ * Layered == false.
*/
- GLuint _Layer;
+ GLushort _Layer;
/**
* Access allowed to this texture image. Either \c GL_READ_ONLY,
* \c GL_WRITE_ONLY or \c GL_READ_WRITE.
*/
- GLenum Access;
+ GLenum16 Access;
/**
* GL internal format that determines the interpretation of the
* image memory when shader image operations are performed through
* this unit.
*/
- GLenum Format;
+ GLenum16 Format;
/**
* Mesa format corresponding to \c Format.
*/
- mesa_format _ActualFormat;
-
+ mesa_format _ActualFormat:16;
};
/**
GLboolean Dedicated; /**< import memory from a dedicated allocation */
};
+struct gl_semaphore_object
+{
+ GLuint Name; /**< hash table ID/name */
+};
+
/**
* Mesa rendering context.
*
struct gl_texture_attrib Texture; /**< Texture attributes */
struct gl_transform_attrib Transform; /**< Transformation attributes */
struct gl_viewport_attrib ViewportArray[MAX_VIEWPORTS]; /**< Viewport attributes */
+ GLuint SubpixelPrecisionBias[2]; /**< Viewport attributes */
/*@}*/
/** \name Client attribute stack */
*/
struct gl_pipeline_object *_Shader;
+ /**
+ * NIR containing the functions that implement software fp64 support.
+ */
+ struct nir_shader *SoftFP64;
+
struct gl_query_state Query; /**< occlusion, timer queries */
struct gl_transform_feedback_state TransformFeedback;
/* GL_EXT_framebuffer_object */
struct gl_renderbuffer *CurrentRenderbuffer;
- GLenum ErrorValue; /**< Last error code */
+ GLenum16 ErrorValue; /**< Last error code */
/**
* Recognize and silence repeated error debug messages in buggy apps.
simple_mtx_t DebugMutex;
struct gl_debug_state *Debug;
- GLenum RenderMode; /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */
+ GLenum16 RenderMode; /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */
GLbitfield NewState; /**< bitwise-or of _NEW_* flags */
uint64_t NewDriverState; /**< bitwise-or of flags from DriverFlags */
GLboolean TextureFormatSupported[MESA_FORMAT_COUNT];
GLboolean RasterDiscard; /**< GL_RASTERIZER_DISCARD */
- GLboolean IntelConservativeRasterization; /**< GL_INTEL_CONSERVATIVE_RASTERIZATION */
+ GLboolean IntelConservativeRasterization; /**< GL_CONSERVATIVE_RASTERIZATION_INTEL */
+ GLboolean ConservativeRasterization; /**< GL_CONSERVATIVE_RASTERIZATION_NV */
+ GLfloat ConservativeRasterDilate;
+ GLenum16 ConservativeRasterMode;
/** Does glVertexAttrib(0) alias glVertex()? */
bool _AttribZeroAliasesVertex;
void *swtnl_context;
struct vbo_context *vbo_context;
struct st_context *st;
- void *aelt_context;
/*@}*/
/**
struct hash_table_u64 *ResidentTextureHandles;
struct hash_table_u64 *ResidentImageHandles;
/*@}*/
+
+ bool shader_builtin_ref;
};
/**
unsigned nr_device_memory_evictions; /**< # of evictions (monotonic counter) */
};
-#ifdef DEBUG
+#ifndef NDEBUG
extern int MESA_VERBOSE;
extern int MESA_DEBUG_FLAGS;
-# define MESA_FUNCTION __func__
#else
# define MESA_VERBOSE 0
# define MESA_DEBUG_FLAGS 0
-# define MESA_FUNCTION "a function"
#endif
projects / mesa.git / blobdiff