1.. _screen: 2 3Screen 4====== 5 6A screen is an object representing the context-independent part of a device. 7 8Flags and enumerations 9---------------------- 10 11XXX some of these don't belong in this section. 12 13 14.. _pipe_cap: 15 16PIPE_CAP_* 17^^^^^^^^^^ 18 19Capability queries return information about the features and limits of the 20driver/GPU. For floating-point values, use :ref:`get_paramf`, and for boolean 21or integer values, use :ref:`get_param`. 22 23The integer capabilities: 24 25* ``PIPE_CAP_GRAPHICS``: Whether graphics is supported. If not, contexts can 26 only be created with PIPE_CONTEXT_COMPUTE_ONLY. 27* ``PIPE_CAP_NPOT_TEXTURES``: Whether :term:`NPOT` textures may have repeat modes, 28 normalized coordinates, and mipmaps. 29* ``PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS``: How many dual-source blend RTs are support. 30 :ref:`Blend` for more information. 31* ``PIPE_CAP_ANISOTROPIC_FILTER``: Whether textures can be filtered anisotropically. 32* ``PIPE_CAP_MAX_RENDER_TARGETS``: The maximum number of render targets that may be 33 bound. 34* ``PIPE_CAP_OCCLUSION_QUERY``: Whether occlusion queries are available. 35* ``PIPE_CAP_QUERY_TIME_ELAPSED``: Whether PIPE_QUERY_TIME_ELAPSED queries are available. 36* ``PIPE_CAP_TEXTURE_SHADOW_MAP``: indicates whether the fragment shader hardware 37 can do the depth texture / Z comparison operation in TEX instructions 38 for shadow testing. 39* ``PIPE_CAP_TEXTURE_SWIZZLE``: Whether swizzling through sampler views is 40 supported. 41* ``PIPE_CAP_MAX_TEXTURE_2D_SIZE``: The maximum size of 2D (and 1D) textures. 42* ``PIPE_CAP_MAX_TEXTURE_3D_LEVELS``: The maximum number of mipmap levels available 43 for a 3D texture. 44* ``PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS``: The maximum number of mipmap levels available 45 for a cubemap. 46* ``PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE``: Whether mirrored texture coordinates are 47 supported with the clamp-to-edge wrap mode. 48* ``PIPE_CAP_TEXTURE_MIRROR_CLAMP``: Whether mirrored texture coordinates are supported 49 with clamp or clamp-to-border wrap modes. 50* ``PIPE_CAP_BLEND_EQUATION_SEPARATE``: Whether alpha blend equations may be different 51 from color blend equations, in :ref:`Blend` state. 52* ``PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS``: The maximum number of stream buffers. 53* ``PIPE_CAP_PRIMITIVE_RESTART``: Whether primitive restart is supported. 54* ``PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX``: Subset of 55 PRIMITIVE_RESTART where the restart index is always the fixed maximum 56 value for the index type. 57* ``PIPE_CAP_INDEP_BLEND_ENABLE``: Whether per-rendertarget blend enabling and channel 58 masks are supported. If 0, then the first rendertarget's blend mask is 59 replicated across all MRTs. 60* ``PIPE_CAP_INDEP_BLEND_FUNC``: Whether per-rendertarget blend functions are 61 available. If 0, then the first rendertarget's blend functions affect all 62 MRTs. 63* ``PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS``: The maximum number of texture array 64 layers supported. If 0, the array textures are not supported at all and 65 the ARRAY texture targets are invalid. 66* ``PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT``: Whether the upper-left origin 67 fragment convention is supported. 68* ``PIPE_CAP_FS_COORD_ORIGIN_LOWER_LEFT``: Whether the lower-left origin 69 fragment convention is supported. 70* ``PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER``: Whether the half-integer 71 pixel-center fragment convention is supported. 72* ``PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER``: Whether the integer 73 pixel-center fragment convention is supported. 74* ``PIPE_CAP_DEPTH_CLIP_DISABLE``: Whether the driver is capable of disabling 75 depth clipping (through pipe_rasterizer_state). 76* ``PIPE_CAP_DEPTH_CLIP_DISABLE_SEPARATE``: Whether the driver is capable of 77 disabling depth clipping (through pipe_rasterizer_state) separately for 78 the near and far plane. If not, depth_clip_near and depth_clip_far will be 79 equal. 80 ``PIPE_CAP_DEPTH_CLAMP_ENABLE``: Whether the driver is capable of 81 enabling depth clamping (through pipe_rasterizer_state) separately from depth 82 clipping. If not, depth_clamp will be the inverse of depth_clip_far. 83* ``PIPE_CAP_SHADER_STENCIL_EXPORT``: Whether a stencil reference value can be 84 written from a fragment shader. 85* ``PIPE_CAP_VS_INSTANCEID``: Whether ``SYSTEM_VALUE_INSTANCE_ID`` is 86 supported in the vertex shader. 87* ``PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR``: Whether the driver supports 88 per-instance vertex attribs. 89* ``PIPE_CAP_FRAGMENT_COLOR_CLAMPED``: Whether fragment color clamping is 90 supported. That is, is the pipe_rasterizer_state::clamp_fragment_color 91 flag supported by the driver? If not, gallium frontends will insert 92 clamping code into the fragment shaders when needed. 93 94* ``PIPE_CAP_MIXED_COLORBUFFER_FORMATS``: Whether mixed colorbuffer formats are 95 supported, e.g. RGBA8 and RGBA32F as the first and second colorbuffer, resp. 96* ``PIPE_CAP_VERTEX_COLOR_UNCLAMPED``: Whether the driver is capable of 97 outputting unclamped vertex colors from a vertex shader. If unsupported, 98 the vertex colors are always clamped. This is the default for DX9 hardware. 99* ``PIPE_CAP_VERTEX_COLOR_CLAMPED``: Whether the driver is capable of 100 clamping vertex colors when they come out of a vertex shader, as specified 101 by the pipe_rasterizer_state::clamp_vertex_color flag. If unsupported, 102 the vertex colors are never clamped. This is the default for DX10 hardware. 103 If both clamped and unclamped CAPs are supported, the clamping can be 104 controlled through pipe_rasterizer_state. If the driver cannot do vertex 105 color clamping, gallium frontends may insert clamping code into the vertex 106 shader. 107* ``PIPE_CAP_GLSL_FEATURE_LEVEL``: Whether the driver supports features 108 equivalent to a specific GLSL version. E.g. for GLSL 1.3, report 130. 109* ``PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY``: Whether the driver supports 110 features equivalent to a specific GLSL version including all legacy OpenGL 111 features only present in the OpenGL compatibility profile. 112 The only legacy features that Gallium drivers must implement are 113 the legacy shader inputs and outputs (colors, texcoords, fog, clipvertex, 114 edgeflag). 115* ``PIPE_CAP_ESSL_FEATURE_LEVEL``: An optional cap to allow drivers to 116 report a higher GLSL version for GLES contexts. This is useful when a 117 driver does not support all the required features for a higher GL version, 118 but does support the required features for a higher GLES version. A driver 119 is allowed to return ``0`` in which case ``PIPE_CAP_GLSL_FEATURE_LEVEL`` is 120 used. 121 Note that simply returning the same value as the GLSL feature level cap is 122 incorrect. For example, GLSL version 3.30 does not require 123 :ext:`GL_EXT_gpu_shader5`, but ESSL version 3.20 es does require 124 :ext:`GL_EXT_gpu_shader5` 125* ``PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION``: Whether quads adhere to 126 the flatshade_first setting in ``pipe_rasterizer_state``. 127* ``PIPE_CAP_USER_VERTEX_BUFFERS``: Whether the driver supports user vertex 128 buffers. If not, gallium frontends must upload all data which is not in HW 129 resources. If user-space buffers are supported, the driver must also still 130 accept HW resource buffers. 131* ``PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY``: This CAP describes a HW 132 limitation. If true, pipe_vertex_buffer::buffer_offset must always be aligned 133 to 4. If false, there are no restrictions on the offset. 134* ``PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY``: This CAP describes a HW 135 limitation. If true, pipe_vertex_buffer::stride must always be aligned to 4. 136 If false, there are no restrictions on the stride. 137* ``PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY``: This CAP describes 138 a HW limitation. If true, pipe_vertex_element::src_offset must always be 139 aligned to 4. If false, there are no restrictions on src_offset. 140* ``PIPE_CAP_VERTEX_ATTRIB_ELEMENT_ALIGNED_ONLY``: This CAP describes 141 a HW limitation. If true, the sum of 142 ``pipe_vertex_element::src_offset + pipe_vertex_buffer::buffer_offset + pipe_vertex_buffer::stride`` 143 must always be aligned to the component size for the vertex attributes 144 which access that buffer. If false, there are no restrictions on these values. 145 This CAP cannot be used with any other alignment-requiring CAPs. 146* ``PIPE_CAP_COMPUTE``: Whether the implementation supports the 147 compute entry points defined in pipe_context and pipe_screen. 148* ``PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT``: Describes the required 149 alignment of pipe_constant_buffer::buffer_offset. 150* ``PIPE_CAP_START_INSTANCE``: Whether the driver supports 151 pipe_draw_info::start_instance. 152* ``PIPE_CAP_QUERY_TIMESTAMP``: Whether PIPE_QUERY_TIMESTAMP and 153 the pipe_screen::get_timestamp hook are implemented. 154* ``PIPE_CAP_QUERY_TIMESTAMP_BITS``: How many bits the driver uses for the 155 results of GL_TIMESTAMP queries. 156* ``PIPE_CAP_TIMER_RESOLUTION``: The resolution of the timer in nanos. 157* ``PIPE_CAP_TEXTURE_MULTISAMPLE``: Whether all MSAA resources supported 158 for rendering are also supported for texturing. 159* ``PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT``: The minimum alignment that should be 160 expected for a pointer returned by transfer_map if the resource is 161 PIPE_BUFFER. In other words, the pointer returned by transfer_map is 162 always aligned to this value. 163* ``PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT``: Describes the required 164 alignment for pipe_sampler_view::u.buf.offset, in bytes. 165 If a driver does not support offset/size, it should return 0. 166* ``PIPE_CAP_LINEAR_IMAGE_PITCH_ALIGNMENT``: Describes the row pitch alignment 167 size that pipe_sampler_view::u.tex2d_from_buf must be multiple of, in pixels. 168 If a driver does not support images created from buffers, it should return 0. 169* ``PIPE_CAP_LINEAR_IMAGE_BASE_ADDRESS_ALIGNMENT``: Describes the minimum alignment 170 in pixels of the offset of a host pointer for images created from buffers. 171 If a driver does not support images created from buffers, it should return 0. 172* ``PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY``: Whether the driver only 173 supports R, RG, RGB and RGBA formats for PIPE_BUFFER sampler views. 174 When this is the case it should be assumed that the swizzle parameters 175 in the sampler view have no effect. 176* ``PIPE_CAP_TGSI_TEXCOORD``: This CAP describes a HW limitation. 177 If true, the hardware cannot replace arbitrary shader inputs with sprite 178 coordinates and hence the inputs that are desired to be replaceable must 179 be declared with TGSI_SEMANTIC_TEXCOORD instead of TGSI_SEMANTIC_GENERIC. 180 The rasterizer's sprite_coord_enable state therefore also applies to the 181 TEXCOORD semantic. 182 Also, TGSI_SEMANTIC_PCOORD becomes available, which labels a fragment shader 183 input that will always be replaced with sprite coordinates. 184* ``PIPE_CAP_TEXTURE_TRANSFER_MODES``: The ``pipe_texture_transfer_mode`` modes 185 that are supported for implementing a texture transfer which needs format conversions 186 and swizzling in gallium frontends. Generally, all hardware drivers with 187 dedicated memory should return PIPE_TEXTURE_TRANSFER_BLIT and all software rasterizers 188 should return PIPE_TEXTURE_TRANSFER_DEFAULT. PIPE_TEXTURE_TRANSFER_COMPUTE requires drivers 189 to support 8bit and 16bit shader storage buffer writes and to implement 190 pipe_screen::is_compute_copy_faster. 191* ``PIPE_CAP_QUERY_PIPELINE_STATISTICS``: Whether PIPE_QUERY_PIPELINE_STATISTICS 192 is supported. 193* ``PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK``: Bitmask indicating whether special 194 considerations have to be given to the interaction between the border color 195 in the sampler object and the sampler view used with it. 196 If PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600 is set, the border color 197 may be affected in undefined ways for any kind of permutational swizzle 198 (any swizzle XYZW where X/Y/Z/W are not ZERO, ONE, or R/G/B/A respectively) 199 in the sampler view. 200 If PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_NV50 is set, the border color 201 state should be swizzled manually according to the swizzle in the sampler 202 view it is intended to be used with, or herein undefined results may occur 203 for permutational swizzles. 204* ``PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT``: The maximum accessible number of 205 elements within a sampler buffer view and image buffer view. This is unsigned 206 integer with the maximum of 4G - 1. 207* ``PIPE_CAP_MAX_VIEWPORTS``: The maximum number of viewports (and scissors 208 since they are linked) a driver can support. Returning 0 is equivalent 209 to returning 1 because every driver has to support at least a single 210 viewport/scissor combination. 211* ``PIPE_CAP_ENDIANNESS``:: The endianness of the device. Either 212 PIPE_ENDIAN_BIG or PIPE_ENDIAN_LITTLE. 213* ``PIPE_CAP_MIXED_FRAMEBUFFER_SIZES``: Whether it is allowed to have 214 different sizes for fb color/zs attachments. This controls whether 215 :ext:`GL_ARB_framebuffer_object` is provided. 216* ``PIPE_CAP_VS_LAYER_VIEWPORT``: Whether ``VARYING_SLOT_LAYER`` and 217 ``VARYING_SLOT_VIEWPORT`` are supported as vertex shader outputs. Note that 218 the viewport will only be used if multiple viewports are exposed. 219* ``PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES``: The maximum number of vertices 220 output by a single invocation of a geometry shader. 221* ``PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS``: The maximum number of 222 vertex components output by a single invocation of a geometry shader. 223 This is the product of the number of attribute components per vertex and 224 the number of output vertices. 225* ``PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS``: Max number of components 226 in format that texture gather can operate on. 1 == RED, ALPHA etc, 227 4 == All formats. 228* ``PIPE_CAP_TEXTURE_GATHER_SM5``: Whether the texture gather 229 hardware implements the SM5 features, component selection, 230 shadow comparison, and run-time offsets. 231* ``PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT``: Whether 232 PIPE_MAP_PERSISTENT and PIPE_MAP_COHERENT are supported 233 for buffers. 234* ``PIPE_CAP_TEXTURE_QUERY_LOD``: Whether the ``LODQ`` instruction is 235 supported. 236* ``PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET``: The minimum offset that can be used 237 in conjunction with a texture gather opcode. 238* ``PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET``: The maximum offset that can be used 239 in conjunction with a texture gather opcode. 240* ``PIPE_CAP_SAMPLE_SHADING``: Whether there is support for per-sample 241 shading. The context->set_min_samples function will be expected to be 242 implemented. 243* ``PIPE_CAP_TEXTURE_GATHER_OFFSETS``: Whether the ``TG4`` instruction can 244 accept 4 offsets. 245* ``PIPE_CAP_VS_WINDOW_SPACE_POSITION``: Whether window-space position is 246 supported, which disables clipping and viewport transformation. 247* ``PIPE_CAP_MAX_VERTEX_STREAMS``: The maximum number of vertex streams 248 supported by the geometry shader. If stream-out is supported, this should be 249 at least 1. If stream-out is not supported, this should be 0. 250* ``PIPE_CAP_DRAW_INDIRECT``: Whether the driver supports taking draw arguments 251 { count, instance_count, start, index_bias } from a PIPE_BUFFER resource. 252 See pipe_draw_info. 253* ``PIPE_CAP_MULTI_DRAW_INDIRECT``: Whether the driver supports 254 pipe_draw_info::indirect_stride and ::indirect_count 255* ``PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS``: Whether the driver supports 256 taking the number of indirect draws from a separate parameter 257 buffer, see pipe_draw_indirect_info::indirect_draw_count. 258* ``PIPE_CAP_MULTI_DRAW_INDIRECT_PARTIAL_STRIDE``: Whether the driver supports 259 indirect draws with an arbitrary stride. 260* ``PIPE_CAP_FS_FINE_DERIVATIVE``: Whether the fragment shader supports 261 the FINE versions of DDX/DDY. 262* ``PIPE_CAP_VENDOR_ID``: The vendor ID of the underlying hardware. If it's 263 not available one should return 0xFFFFFFFF. 264* ``PIPE_CAP_DEVICE_ID``: The device ID (PCI ID) of the underlying hardware. 265 0xFFFFFFFF if not available. 266* ``PIPE_CAP_ACCELERATED``: Whether the renderer is hardware accelerated. 0 means 267 not accelerated (i.e. CPU rendering), 1 means accelerated (i.e. GPU rendering), 268 -1 means unknown (i.e. an API translation driver which doesn't known what kind of 269 hardware it's running above). 270* ``PIPE_CAP_VIDEO_MEMORY``: The amount of video memory in megabytes. 271* ``PIPE_CAP_UMA``: If the device has a unified memory architecture or on-card 272 memory and GART. 273* ``PIPE_CAP_CONDITIONAL_RENDER_INVERTED``: Whether the driver supports inverted 274 condition for conditional rendering. 275* ``PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE``: The maximum supported vertex stride. 276* ``PIPE_CAP_SAMPLER_VIEW_TARGET``: Whether the sampler view's target can be 277 different than the underlying resource's, as permitted by 278 :ext:`GL_ARB_texture_view`. For example a 2d array texture may be reinterpreted as a 279 cube (array) texture and vice-versa. 280* ``PIPE_CAP_CLIP_HALFZ``: Whether the driver supports the 281 pipe_rasterizer_state::clip_halfz being set to true. This is required 282 for enabling :ext:`GL_ARB_clip_control`. 283* ``PIPE_CAP_POLYGON_OFFSET_CLAMP``: If true, the driver implements support 284 for ``pipe_rasterizer_state::offset_clamp``. 285* ``PIPE_CAP_MULTISAMPLE_Z_RESOLVE``: Whether the driver supports blitting 286 a multisampled depth buffer into a single-sampled texture (or depth buffer). 287 Only the first sampled should be copied. 288* ``PIPE_CAP_RESOURCE_FROM_USER_MEMORY``: Whether the driver can create 289 a pipe_resource where an already-existing piece of (malloc'd) user memory 290 is used as its backing storage. In other words, whether the driver can map 291 existing user memory into the device address space for direct device access. 292 The create function is pipe_screen::resource_from_user_memory. The address 293 and size must be page-aligned. 294* ``PIPE_CAP_RESOURCE_FROM_USER_MEMORY_COMPUTE_ONLY``: Same as 295 ``PIPE_CAP_RESOURCE_FROM_USER_MEMORY`` but indicates it is only supported from 296 the compute engines. 297* ``PIPE_CAP_DEVICE_RESET_STATUS_QUERY``: 298 Whether pipe_context::get_device_reset_status is implemented. 299* ``PIPE_CAP_MAX_SHADER_PATCH_VARYINGS``: 300 How many per-patch outputs and inputs are supported between tessellation 301 control and tessellation evaluation shaders, not counting in TESSINNER and 302 TESSOUTER. The minimum allowed value for OpenGL is 30. 303* ``PIPE_CAP_TEXTURE_FLOAT_LINEAR``: Whether the linear minification and 304 magnification filters are supported with single-precision floating-point 305 textures. 306* ``PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR``: Whether the linear minification and 307 magnification filters are supported with half-precision floating-point 308 textures. 309* ``PIPE_CAP_DEPTH_BOUNDS_TEST``: Whether bounds_test, bounds_min, and 310 bounds_max states of pipe_depth_stencil_alpha_state behave according 311 to the :ext:`GL_EXT_depth_bounds_test` specification. 312* ``PIPE_CAP_TEXTURE_QUERY_SAMPLES``: Whether the ``TXQS`` opcode is supported 313* ``PIPE_CAP_FORCE_PERSAMPLE_INTERP``: If the driver can force per-sample 314 interpolation for all fragment shader inputs if 315 pipe_rasterizer_state::force_persample_interp is set. This is only used 316 by GL3-level sample shading (:ext:`GL_ARB_sample_shading`). GL4-level sample 317 shading (:ext:`GL_ARB_gpu_shader5`) doesn't use this. While GL3 hardware has a 318 state for it, GL4 hardware will likely need to emulate it with a shader 319 variant, or by selecting the interpolation weights with a conditional 320 assignment in the shader. 321* ``PIPE_CAP_SHAREABLE_SHADERS``: Whether shader CSOs can be used by any 322 pipe_context. Important for reducing jank at draw time by letting GL shaders 323 linked in one thread be used in another thread without recompiling. 324* ``PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS``: 325 Whether copying between compressed and plain formats is supported where 326 a compressed block is copied to/from a plain pixel of the same size. 327* ``PIPE_CAP_CLEAR_SCISSORED``: Whether ``clear`` can accept a scissored 328 bounding box. 329* ``PIPE_CAP_DRAW_PARAMETERS``: Whether ``TGSI_SEMANTIC_BASEVERTEX``, 330 ``TGSI_SEMANTIC_BASEINSTANCE``, and ``TGSI_SEMANTIC_DRAWID`` are 331 supported in vertex shaders. 332* ``PIPE_CAP_SHADER_PACK_HALF_FLOAT``: Whether packed 16-bit float 333 packing/unpacking opcodes are supported. 334* ``PIPE_CAP_FS_POSITION_IS_SYSVAL``: If gallium frontends should use a 335 system value for the POSITION fragment shader input. 336* ``PIPE_CAP_FS_POINT_IS_SYSVAL``: If gallium frontends should use a system 337 value for the POINT fragment shader input. 338* ``PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL``: If gallium frontends should use 339 a system value for the FACE fragment shader input. 340 Also, the FACE system value is integer, not float. 341* ``PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT``: Describes the required 342 alignment for pipe_shader_buffer::buffer_offset, in bytes. Maximum 343 value allowed is 256 (for GL conformance). 0 is only allowed if 344 shader buffers are not supported. 345* ``PIPE_CAP_INVALIDATE_BUFFER``: Whether the use of ``invalidate_resource`` 346 for buffers is supported. 347* ``PIPE_CAP_GENERATE_MIPMAP``: Indicates whether pipe_context::generate_mipmap 348 is supported. 349* ``PIPE_CAP_STRING_MARKER``: Whether pipe->emit_string_marker() is supported. 350* ``PIPE_CAP_SURFACE_REINTERPRET_BLOCKS``: Indicates whether 351 pipe_context::create_surface supports reinterpreting a texture as a surface 352 of a format with different block width/height (but same block size in bits). 353 For example, a compressed texture image can be interpreted as a 354 non-compressed surface whose texels are the same number of bits as the 355 compressed blocks, and vice versa. The width and height of the surface is 356 adjusted appropriately. 357* ``PIPE_CAP_QUERY_BUFFER_OBJECT``: Driver supports 358 context::get_query_result_resource callback. 359* ``PIPE_CAP_PCI_GROUP``: Return the PCI segment group number. 360* ``PIPE_CAP_PCI_BUS``: Return the PCI bus number. 361* ``PIPE_CAP_PCI_DEVICE``: Return the PCI device number. 362* ``PIPE_CAP_PCI_FUNCTION``: Return the PCI function number. 363* ``PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT``: 364 If non-zero, rendering to framebuffers with no surface attachments 365 is supported. The context->is_format_supported function will be expected 366 to be implemented with PIPE_FORMAT_NONE yielding the MSAA modes the hardware 367 supports. N.B., The maximum number of layers supported for rasterizing a 368 primitive on a layer is obtained from ``PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS`` 369 even though it can be larger than the number of layers supported by either 370 rendering or textures. 371* ``PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR``: Implementation uses bounds 372 checking on resource accesses by shader if the context is created with 373 PIPE_CONTEXT_ROBUST_BUFFER_ACCESS. See the 374 :ext:`GL_ARB_robust_buffer_access_behavior` extension for information on the 375 required behavior for out of bounds accesses and accesses to unbound 376 resources. 377* ``PIPE_CAP_CULL_DISTANCE``: Whether the driver supports the 378 :ext:`GL_ARB_cull_distance` extension and thus implements proper support for 379 culling planes. 380* ``PIPE_CAP_CULL_DISTANCE_NOCOMBINE``: Whether the driver wants to skip 381 running the ``nir_lower_clip_cull_distance_arrays`` pass in order to get 382 VARYING_SLOT_CULL_DIST0 slot variables. 383* ``PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES``: Whether primitive restart is 384 supported for patch primitives. 385* ``PIPE_CAP_SHADER_GROUP_VOTE``: Whether the ``VOTE_*`` ops can be used in 386 shaders. 387* ``PIPE_CAP_MAX_WINDOW_RECTANGLES``: The maximum number of window rectangles 388 supported in ``set_window_rectangles``. 389* ``PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED``: If true, the driver implements support 390 for ``pipe_rasterizer_state::offset_units_unscaled``. 391* ``PIPE_CAP_VIEWPORT_SUBPIXEL_BITS``: Number of bits of subpixel precision for 392 floating point viewport bounds. 393* ``PIPE_CAP_RASTERIZER_SUBPIXEL_BITS``: Number of bits of subpixel precision used 394 by the rasterizer. 395* ``PIPE_CAP_MIXED_COLOR_DEPTH_BITS``: Whether there is non-fallback 396 support for color/depth format combinations that use a different 397 number of bits. For the purpose of this cap, Z24 is treated as 398 32-bit. If set to off, that means that a B5G6R5 + Z24 or RGBA8 + Z16 399 combination will require a driver fallback, and should not be 400 advertised in the GLX/EGL config list. 401* ``PIPE_CAP_SHADER_ARRAY_COMPONENTS``: If true, the driver interprets the 402 UsageMask of input and output declarations and allows declaring arrays 403 in overlapping ranges. The components must be a contiguous range, e.g. a 404 UsageMask of xy or yzw is allowed, but xz or yw isn't. Declarations with 405 overlapping locations must have matching semantic names and indices, and 406 equal interpolation qualifiers. 407 Components may overlap, notably when the gaps in an array of dvec3 are 408 filled in. 409* ``PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME``: Whether 410 :ext:`GL_ARB_transform_feedback2` is supported, including pausing/resuming 411 queries and having ``count_from_stream_output`` set on indirect draws to 412 implement glDrawTransformFeedback. Required for OpenGL 4.0. 413* ``PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS``: Whether interleaved stream 414 output mode is able to interleave across buffers. This is required for 415 :ext:`GL_ARB_transform_feedback3`. 416* ``PIPE_CAP_SHADER_CAN_READ_OUTPUTS``: Whether every TGSI shader stage can read 417 from the output file. 418* ``PIPE_CAP_FBFETCH``: The number of render targets whose value in the 419 current framebuffer can be read in the shader. 0 means framebuffer fetch 420 is not supported. 1 means that only the first render target can be read, 421 and a larger value would mean that multiple render targets are supported. 422* ``PIPE_CAP_FBFETCH_COHERENT``: Whether framebuffer fetches from the fragment 423 shader can be guaranteed to be coherent with framebuffer writes. 424* ``PIPE_CAP_FBFETCH_ZS``: Whether fragment shader can fetch current values of 425 Z/S attachments. These fetches are always coherent with framebuffer writes. 426* ``PIPE_CAP_LEGACY_MATH_RULES``: Whether NIR shaders support the 427 ``shader_info.use_legacy_math_rules`` flag (see documentation there), and 428 TGSI shaders support the corresponding ``TGSI_PROPERTY_LEGACY_MATH_RULES``. 429* ``PIPE_CAP_FP16``: Whether 16-bit float operations are supported. 430* ``PIPE_CAP_DOUBLES``: Whether double precision floating-point operations 431 are supported. 432* ``PIPE_CAP_INT64``: Whether 64-bit integer operations are supported. 433* ``PIPE_CAP_TGSI_TEX_TXF_LZ``: Whether TEX_LZ and TXF_LZ opcodes are 434 supported. 435* ``PIPE_CAP_SHADER_CLOCK``: Whether the CLOCK opcode is supported. 436* ``PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE``: Whether the 437 PIPE_POLYGON_MODE_FILL_RECTANGLE mode is supported for 438 ``pipe_rasterizer_state::fill_front`` and 439 ``pipe_rasterizer_state::fill_back``. 440* ``PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE``: The page size of sparse buffers in 441 bytes, or 0 if sparse buffers are not supported. The page size must be at 442 most 64KB. 443* ``PIPE_CAP_SHADER_BALLOT``: Whether the BALLOT and READ_* opcodes as well as 444 the SUBGROUP_* semantics are supported. 445* ``PIPE_CAP_TES_LAYER_VIEWPORT``: Whether ``VARYING_SLOT_LAYER`` and 446 ``VARYING_SLOT_VIEWPORT`` are supported as tessellation evaluation 447 shader outputs. 448* ``PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX``: Whether a buffer with just 449 PIPE_BIND_CONSTANT_BUFFER can be legally passed to set_vertex_buffers. 450* ``PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION``: As the name says. 451* ``PIPE_CAP_POST_DEPTH_COVERAGE``: whether 452 ``TGSI_PROPERTY_FS_POST_DEPTH_COVERAGE`` is supported. 453* ``PIPE_CAP_BINDLESS_TEXTURE``: Whether bindless texture operations are 454 supported. 455* ``PIPE_CAP_NIR_SAMPLERS_AS_DEREF``: Whether NIR tex instructions should 456 reference texture and sampler as NIR derefs instead of by indices. 457* ``PIPE_CAP_QUERY_SO_OVERFLOW``: Whether the 458 ``PIPE_QUERY_SO_OVERFLOW_PREDICATE`` and 459 ``PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE`` query types are supported. Note that 460 for a driver that does not support multiple output streams (i.e., 461 ``PIPE_CAP_MAX_VERTEX_STREAMS`` is 1), both query types are identical. 462* ``PIPE_CAP_MEMOBJ``: Whether operations on memory objects are supported. 463* ``PIPE_CAP_LOAD_CONSTBUF``: True if the driver supports ``TGSI_OPCODE_LOAD`` use 464 with constant buffers. 465* ``PIPE_CAP_TILE_RASTER_ORDER``: Whether the driver supports 466 :ext:`GL_MESA_tile_raster_order`, using the tile_raster_order_* fields in 467 pipe_rasterizer_state. 468* ``PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES``: Limit on combined shader 469 output resources (images + buffers + fragment outputs). If 0 the state 470 tracker works it out. 471* ``PIPE_CAP_FRAMEBUFFER_MSAA_CONSTRAINTS``: This determines limitations 472 on the number of samples that framebuffer attachments can have. 473 Possible values: 474 475 0. color.nr_samples == zs.nr_samples == color.nr_storage_samples 476 (standard MSAA quality) 477 1. color.nr_samples >= zs.nr_samples == color.nr_storage_samples 478 (enhanced MSAA quality) 479 2. color.nr_samples >= zs.nr_samples >= color.nr_storage_samples 480 (full flexibility in tuning MSAA quality and performance) 481 482 All color attachments must have the same number of samples and the same 483 number of storage samples. 484* ``PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET``: 485 Whether pipe_vertex_buffer::buffer_offset is treated as signed. The u_vbuf 486 module needs this for optimal performance in workstation applications. 487* ``PIPE_CAP_CONTEXT_PRIORITY_MASK``: For drivers that support per-context 488 priorities, this returns a bitmask of ``PIPE_CONTEXT_PRIORITY_x`` for the 489 supported priority levels. A driver that does not support prioritized 490 contexts can return 0. 491* ``PIPE_CAP_FENCE_SIGNAL``: True if the driver supports signaling semaphores 492 using fence_server_signal(). 493* ``PIPE_CAP_CONSTBUF0_FLAGS``: The bits of pipe_resource::flags that must be 494 set when binding that buffer as constant buffer 0. If the buffer doesn't have 495 those bits set, pipe_context::set_constant_buffer(.., 0, ..) is ignored 496 by the driver, and the driver can throw assertion failures. 497* ``PIPE_CAP_PACKED_UNIFORMS``: True if the driver supports packed uniforms 498 as opposed to padding to vec4s. Requires ``PIPE_SHADER_CAP_INTEGERS`` if 499 ``lower_uniforms_to_ubo`` is set. 500* ``PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_TRIANGLES``: Whether the 501 ``PIPE_CONSERVATIVE_RASTER_POST_SNAP`` mode is supported for triangles. 502 The post-snap mode means the conservative rasterization occurs after 503 the conversion from floating-point to fixed-point coordinates 504 on the subpixel grid. 505* ``PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_POINTS_LINES``: Whether the 506 ``PIPE_CONSERVATIVE_RASTER_POST_SNAP`` mode is supported for points and lines. 507* ``PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_TRIANGLES``: Whether the 508 ``PIPE_CONSERVATIVE_RASTER_PRE_SNAP`` mode is supported for triangles. 509 The pre-snap mode means the conservative rasterization occurs before 510 the conversion from floating-point to fixed-point coordinates. 511* ``PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_POINTS_LINES``: Whether the 512 ``PIPE_CONSERVATIVE_RASTER_PRE_SNAP`` mode is supported for points and lines. 513* ``PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE``: Whether 514 ``PIPE_CAP_POST_DEPTH_COVERAGE`` works with conservative rasterization. 515* ``PIPE_CAP_CONSERVATIVE_RASTER_INNER_COVERAGE``: Whether 516 inner_coverage from :ext:`GL_INTEL_conservative_rasterization` is supported. 517* ``PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS``: The maximum 518 subpixel precision bias in bits during conservative rasterization. 519* ``PIPE_CAP_PROGRAMMABLE_SAMPLE_LOCATIONS``: True is the driver supports 520 programmable sample location through ```get_sample_pixel_grid``` and 521 ```set_sample_locations```. 522* ``PIPE_CAP_MAX_GS_INVOCATIONS``: Maximum supported value of 523 TGSI_PROPERTY_GS_INVOCATIONS. 524* ``PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT``: Maximum supported size for binding 525 with set_shader_buffers. This is unsigned integer with the maximum of 4GB - 1. 526* ``PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS``: Maximum total number of shader 527 buffers. A value of 0 means the sum of all per-shader stage maximums (see 528 ``PIPE_SHADER_CAP_MAX_SHADER_BUFFERS``). 529* ``PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTERS``: Maximum total number of atomic 530 counters. A value of 0 means the default value (MAX_ATOMIC_COUNTERS = 4096). 531* ``PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTER_BUFFERS``: Maximum total number of 532 atomic counter buffers. A value of 0 means the sum of all per-shader stage 533 maximums (see ``PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS``). 534* ``PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET``: Maximum recommend memory size 535 for all active texture uploads combined. This is a performance hint. 536 0 means no limit. 537* ``PIPE_CAP_MAX_VERTEX_ELEMENT_SRC_OFFSET``: The maximum supported value for 538 of pipe_vertex_element::src_offset. 539* ``PIPE_CAP_SURFACE_SAMPLE_COUNT``: Whether the driver 540 supports pipe_surface overrides of resource nr_samples. If set, will 541 enable :ext:`GL_EXT_multisampled_render_to_texture`. 542* ``PIPE_CAP_IMAGE_ATOMIC_FLOAT_ADD``: Atomic floating point adds are 543 supported on images, buffers, and shared memory. 544* ``PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS``: True if the driver wants TESSINNER and TESSOUTER to be inputs (rather than system values) for tessellation evaluation shaders. 545* ``PIPE_CAP_DEST_SURFACE_SRGB_CONTROL``: Indicates whether the drivers 546 supports switching the format between sRGB and linear for a surface that is 547 used as destination in draw and blit calls. 548* ``PIPE_CAP_NIR_COMPACT_ARRAYS``: True if the compiler backend supports NIR's compact array feature, for all shader stages. 549* ``PIPE_CAP_MAX_VARYINGS``: The maximum number of fragment shader 550 varyings. This will generally correspond to 551 ``PIPE_SHADER_CAP_MAX_INPUTS`` for the fragment shader, but in some 552 cases may be a smaller number. 553* ``PIPE_CAP_COMPUTE_GRID_INFO_LAST_BLOCK``: Whether pipe_grid_info::last_block 554 is implemented by the driver. See struct pipe_grid_info for more details. 555* ``PIPE_CAP_COMPUTE_SHADER_DERIVATIVE``: True if the driver supports derivatives (and texture lookups with implicit derivatives) in compute shaders. 556* ``PIPE_CAP_IMAGE_LOAD_FORMATTED``: True if a format for image loads does not need to be specified in the shader IR 557* ``PIPE_CAP_IMAGE_STORE_FORMATTED``: True if a format for image stores does not need to be specified in the shader IR 558* ``PIPE_CAP_THROTTLE``: Whether or not gallium frontends should throttle pipe_context 559 execution. 0 = throttling is disabled. 560* ``PIPE_CAP_DMABUF``: Whether Linux DMABUF handles are supported by 561 resource_from_handle and resource_get_handle. 562 Possible bit field values: 563 564 1. ``DRM_PRIME_CAP_IMPORT``: resource_from_handle is supported 565 2. ``DRM_PRIME_CAP_EXPORT``: resource_get_handle is supported 566 567* ``PIPE_CAP_CL_GL_SHARING``: True if driver supports everything required by a frontend implementing the CL extension, and 568 also supports importing/exporting all of pipe_texture_target via dma buffers. 569* ``PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA``: Whether VDPAU, VAAPI, and 570 OpenMAX should use a compute-based blit instead of pipe_context::blit and compute pipeline for compositing images. 571* ``PIPE_CAP_FRAGMENT_SHADER_INTERLOCK``: True if fragment shader interlock 572 functionality is supported. 573* ``PIPE_CAP_ATOMIC_FLOAT_MINMAX``: Atomic float point minimum, 574 maximum, exchange and compare-and-swap support to buffer and shared variables. 575* ``PIPE_CAP_TGSI_DIV``: Whether opcode DIV is supported 576* ``PIPE_CAP_DITHERING``: Whether dithering is supported 577* ``PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD``: Whether texture lookups with 578 explicit LOD is supported in the fragment shader. 579* ``PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES``: True if the driver supports 580 derivatives in fragment shaders. 581* ``PIPE_CAP_TEXTURE_SHADOW_LOD``: True if the driver supports shadow sampler 582 types with texture functions having interaction with LOD of texture lookup. 583* ``PIPE_CAP_SHADER_SAMPLES_IDENTICAL``: True if the driver supports a shader query to tell whether all samples of a multisampled surface are definitely identical. 584* ``PIPE_CAP_IMAGE_ATOMIC_INC_WRAP``: Atomic increment/decrement + wrap around 585 are supported. 586* ``PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF``: True if gallium frontends should 587 turn arrays whose contents can be deduced at compile time into constant 588 buffer loads, or false if the driver can handle such arrays itself in a more 589 efficient manner (such as through nir_opt_large_constants() and nir->constant_data). 590* ``PIPE_CAP_GL_SPIRV``: True if the driver supports :ext:`GL_ARB_gl_spirv` extension. 591* ``PIPE_CAP_GL_SPIRV_VARIABLE_POINTERS``: True if the driver supports Variable Pointers in SPIR-V shaders. 592* ``PIPE_CAP_DEMOTE_TO_HELPER_INVOCATION``: True if driver supports demote keyword in GLSL programs. 593* ``PIPE_CAP_TGSI_TG4_COMPONENT_IN_SWIZZLE``: True if driver wants the TG4 component encoded in sampler swizzle rather than as a separate source. 594* ``PIPE_CAP_FLATSHADE``: Driver supports pipe_rasterizer_state::flatshade. Must be 1 595 for non-NIR drivers or gallium nine. 596* ``PIPE_CAP_ALPHA_TEST``: Driver supports alpha-testing. Must be 1 597 for non-NIR drivers or gallium nine. If set, frontend may set 598 ``pipe_depth_stencil_alpha_state->alpha_enabled`` and ``alpha_func``. 599 Otherwise, alpha test will be lowered to a comparison and discard_if in the 600 fragment shader. 601* ``PIPE_CAP_POINT_SIZE_FIXED``: Driver supports point-sizes that are fixed, 602 as opposed to writing gl_PointSize for every point. 603* ``PIPE_CAP_TWO_SIDED_COLOR``: Driver supports two-sided coloring. Must be 1 604 for non-NIR drivers. If set, pipe_rasterizer_state may be set to indicate 605 that back-facing primitives should use the back-side color as the FS input 606 color. If unset, mesa/st will lower it to gl_FrontFacing reads in the 607 fragment shader. 608* ``PIPE_CAP_CLIP_PLANES``: Driver supports user-defined clip-planes. 0 denotes none, 1 denotes MAX_CLIP_PLANES. > 1 overrides MAX. When is 0, pipe_rasterizer_state::clip_plane_enable is unused. 609* ``PIPE_CAP_MAX_VERTEX_BUFFERS``: Number of supported vertex buffers. 610* ``PIPE_CAP_OPENCL_INTEGER_FUNCTIONS``: Driver supports extended OpenCL-style integer functions. This includes average, saturating addition, saturating subtraction, absolute difference, count leading zeros, and count trailing zeros. 611* ``PIPE_CAP_INTEGER_MULTIPLY_32X16``: Driver supports integer multiplication between a 32-bit integer and a 16-bit integer. If the second operand is 32-bits, the upper 16-bits are ignored, and the low 16-bits are possibly sign extended as necessary. 612* ``PIPE_CAP_NIR_IMAGES_AS_DEREF``: Whether NIR image load/store intrinsics should be nir_intrinsic_image_deref_* instead of nir_intrinsic_image_*. Defaults to true. 613* ``PIPE_CAP_PACKED_STREAM_OUTPUT``: Driver supports packing optimization for stream output (e.g. GL transform feedback captured variables). Defaults to true. 614* ``PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED``: Driver needs the nir_lower_viewport_transform pass to be enabled. This also means that the gl_Position value is modified and should be lowered for transform feedback, if needed. Defaults to false. 615* ``PIPE_CAP_PSIZ_CLAMPED``: Driver needs for the point size to be clamped. Additionally, the gl_PointSize has been modified and its value should be lowered for transform feedback, if needed. Defaults to false. 616* ``PIPE_CAP_GL_BEGIN_END_BUFFER_SIZE``: Buffer size used to upload vertices for glBegin/glEnd. 617* ``PIPE_CAP_VIEWPORT_SWIZZLE``: Whether pipe_viewport_state::swizzle can be used to specify pre-clipping swizzling of coordinates (see :ext:`GL_NV_viewport_swizzle`). 618* ``PIPE_CAP_SYSTEM_SVM``: True if all application memory can be shared with the GPU without explicit mapping. 619* ``PIPE_CAP_VIEWPORT_MASK``: Whether ``TGSI_SEMANTIC_VIEWPORT_MASK`` and ``TGSI_PROPERTY_LAYER_VIEWPORT_RELATIVE`` are supported (see :ext:`GL_NV_viewport_array2`). 620* ``PIPE_CAP_MAP_UNSYNCHRONIZED_THREAD_SAFE``: Whether mapping a buffer as unsynchronized from any thread is safe. 621* ``PIPE_CAP_GLSL_ZERO_INIT``: Choose a default zero initialization some GLSL variables. If ``1``, then all GLSL shader variables and gl_FragColor are initialized to zero. If ``2``, then shader out variables are not initialized but function out variables are. 622* ``PIPE_CAP_BLEND_EQUATION_ADVANCED``: Driver supports blend equation advanced without necessarily supporting FBFETCH. 623* ``PIPE_CAP_NIR_ATOMICS_AS_DEREF``: Whether NIR atomics instructions should reference atomics as NIR derefs instead of by indices. 624* ``PIPE_CAP_NO_CLIP_ON_COPY_TEX``: Driver doesn't want x/y/width/height clipped based on src size when doing a copy texture operation (e.g.: may want out-of-bounds reads that produce 0 instead of leaving the texture content undefined) 625* ``PIPE_CAP_MAX_TEXTURE_MB``: Maximum texture size in MB (default is 1024) 626* ``PIPE_CAP_DEVICE_PROTECTED_SURFACE``: Whether the device support protected / encrypted content. 627* ``PIPE_CAP_PREFER_REAL_BUFFER_IN_CONSTBUF0``: The state tracker is encouraged to upload constants into a real buffer and bind it into constant buffer 0 instead of binding a user pointer. This may enable a faster code-path in a gallium frontend for drivers that really prefer a real buffer. 628* ``PIPE_CAP_GL_CLAMP``: Driver natively supports GL_CLAMP. Required for non-NIR drivers with the GL frontend. NIR drivers with the cap unavailable will have GL_CLAMP lowered to txd/txl with a saturate on the coordinates. 629* ``PIPE_CAP_TEXRECT``: Driver supports rectangle textures. Required for OpenGL on ``!prefers_nir`` drivers. If this cap is not present, st/mesa will lower the NIR to use normal 2D texture sampling by using either ``txs`` or ``nir_intrinsic_load_texture_scaling`` to normalize the texture coordinates. 630* ``PIPE_CAP_SAMPLER_REDUCTION_MINMAX``: Driver supports EXT min/max sampler reduction. 631* ``PIPE_CAP_SAMPLER_REDUCTION_MINMAX_ARB``: Driver supports ARB min/max sampler reduction with format queries. 632* ``PIPE_CAP_EMULATE_NONFIXED_PRIMITIVE_RESTART``: Driver requests all draws using a non-fixed restart index to be rewritten to use a fixed restart index. 633* ``PIPE_CAP_SUPPORTED_PRIM_MODES``: A bitmask of the ``mesa_prim`` enum values that the driver can natively support. 634* ``PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART``: A bitmask of the ``mesa_prim`` enum values that the driver can natively support for primitive restart. Only useful if ``PIPE_CAP_PRIMITIVE_RESTART`` is also exported. 635* ``PIPE_CAP_PREFER_BACK_BUFFER_REUSE``: Only applies to DRI_PRIME. If 1, the driver prefers that DRI3 tries to use the same back buffer each frame. If 0, this means DRI3 will at least use 2 back buffers and ping-pong between them to allow the tiled->linear copy to run in parallel. 636* ``PIPE_CAP_DRAW_VERTEX_STATE``: Driver supports ``pipe_screen::create_vertex_state/vertex_state_destroy`` and ``pipe_context::draw_vertex_state``. Only used by display lists and designed to serve vbo_save. 637* ``PIPE_CAP_PREFER_POT_ALIGNED_VARYINGS``: Driver prefers varyings to be aligned to power of two in a slot. If this cap is enabled, vec4 varying will be placed in .xyzw components of the varying slot, vec3 in .xyz and vec2 in .xy or .zw 638* ``PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE``: Maximum 1D/2D/rectangle texture image dimension for a sparse texture. 639* ``PIPE_CAP_MAX_SPARSE_3D_TEXTURE_SIZE``: Maximum 3D texture image dimension for a sparse texture. 640* ``PIPE_CAP_MAX_SPARSE_ARRAY_TEXTURE_LAYERS``: Maximum number of layers in a sparse array texture. 641* ``PIPE_CAP_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS``: TRUE if there are no restrictions on the allocation of mipmaps in sparse textures and FALSE otherwise. See SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB description in :ext:`GL_ARB_sparse_texture` extension spec. 642* ``PIPE_CAP_QUERY_SPARSE_TEXTURE_RESIDENCY``: TRUE if shader sparse texture sample instruction could also return the residency information. 643* ``PIPE_CAP_CLAMP_SPARSE_TEXTURE_LOD``: TRUE if shader sparse texture sample instruction support clamp the minimal lod to prevent read from uncommitted pages. 644* ``PIPE_CAP_ALLOW_DRAW_OUT_OF_ORDER``: TRUE if the driver allows the "draw out of order" optimization to be enabled. See _mesa_update_allow_draw_out_of_order for more details. 645* ``PIPE_CAP_MAX_CONSTANT_BUFFER_SIZE_UINT``: Maximum bound constant buffer size in bytes. This is unsigned integer with the maximum of 4GB - 1. This applies to all constant buffers used by UBOs, unlike ``PIPE_SHADER_CAP_MAX_CONST_BUFFER0_SIZE``, which is specifically for GLSL uniforms. 646* ``PIPE_CAP_HARDWARE_GL_SELECT``: Enable hardware accelerated GL_SELECT for this driver. 647* ``PIPE_CAP_DEVICE_PROTECTED_CONTEXT``: Whether the device supports protected / encrypted context which can manipulate protected / encrypted content (some devices might need protected contexts to access protected content, whereas ``PIPE_CAP_DEVICE_PROTECTED_SURFACE`` does not require any particular context to do so). 648* ``PIPE_CAP_ALLOW_GLTHREAD_BUFFER_SUBDATA_OPT``: Whether to allow glthread to convert glBufferSubData to glCopyBufferSubData. This may improve or worsen performance depending on your driver. 649* ``PIPE_CAP_NULL_TEXTURES`` : Whether the driver supports sampling from NULL textures. 650* ``PIPE_CAP_ASTC_VOID_EXTENTS_NEED_DENORM_FLUSH`` : True if the driver/hardware needs denormalized values in ASTC void extent blocks flushed to zero. 651* ``PIPE_CAP_VALIDATE_ALL_DIRTY_STATES`` : Whether state validation must also validate the state changes for resources types used in the previous shader but not in the current shader. 652* ``PIPE_CAP_HAS_CONST_BW``: Whether the driver only supports non-data-dependent layouts (ie. not bandwidth compressed formats like AFBC, UBWC, etc), or supports ``PIPE_BIND_CONST_BW`` to disable data-dependent layouts on requested resources. 653* ``PIPE_CAP_PERFORMANCE_MONITOR``: Whether GL_AMD_performance_monitor should be exposed. 654 655 656.. _pipe_capf: 657 658PIPE_CAPF_* 659^^^^^^^^^^^^^^^^ 660 661The floating-point capabilities are: 662 663* ``PIPE_CAPF_MIN_LINE_WIDTH``: The minimum width of a regular line. 664* ``PIPE_CAPF_MIN_LINE_WIDTH_AA``: The minimum width of a smoothed line. 665* ``PIPE_CAPF_MAX_LINE_WIDTH``: The maximum width of a regular line. 666* ``PIPE_CAPF_MAX_LINE_WIDTH_AA``: The maximum width of a smoothed line. 667* ``PIPE_CAPF_LINE_WIDTH_GRANULARITY``: The line width is rounded to a multiple of this number. 668* ``PIPE_CAPF_MIN_POINT_SIZE``: The minimum width and height of a point. 669* ``PIPE_CAPF_MIN_POINT_SIZE_AA``: The minimum width and height of a smoothed point. 670* ``PIPE_CAPF_MAX_POINT_SIZE``: The maximum width and height of a point. 671* ``PIPE_CAPF_MAX_POINT_SIZE_AA``: The maximum width and height of a smoothed point. 672* ``PIPE_CAPF_POINT_SIZE_GRANULARITY``: The point size is rounded to a multiple of this number. 673* ``PIPE_CAPF_MAX_TEXTURE_ANISOTROPY``: The maximum level of anisotropy that can be 674 applied to anisotropically filtered textures. 675* ``PIPE_CAPF_MAX_TEXTURE_LOD_BIAS``: The maximum :term:`LOD` bias that may be applied 676 to filtered textures. 677* ``PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE``: The minimum conservative rasterization 678 dilation. 679* ``PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE``: The maximum conservative rasterization 680 dilation. 681* ``PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY``: The conservative rasterization 682 dilation granularity for values relative to the minimum dilation. 683 684 685.. _pipe_shader_cap: 686 687PIPE_SHADER_CAP_* 688^^^^^^^^^^^^^^^^^ 689 690These are per-shader-stage capabitity queries. Different shader stages may 691support different features. 692 693* ``PIPE_SHADER_CAP_MAX_INSTRUCTIONS``: The maximum number of instructions. 694* ``PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS``: The maximum number of arithmetic instructions. 695* ``PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS``: The maximum number of texture instructions. 696* ``PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS``: The maximum number of texture indirections. 697* ``PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH``: The maximum nested control flow depth. 698* ``PIPE_SHADER_CAP_MAX_INPUTS``: The maximum number of input registers. 699* ``PIPE_SHADER_CAP_MAX_OUTPUTS``: The maximum number of output registers. 700 This is valid for all shaders except the fragment shader. 701* ``PIPE_SHADER_CAP_MAX_CONST_BUFFER0_SIZE``: The maximum size of constant buffer 0 in bytes. 702* ``PIPE_SHADER_CAP_MAX_CONST_BUFFERS``: Maximum number of constant buffers that can be bound 703 to any shader stage using ``set_constant_buffer``. If 0 or 1, the pipe will 704 only permit binding one constant buffer per shader. 705 706 If a value greater than 0 is returned, the driver can have multiple 707 constant buffers bound to shader stages. The CONST register file is 708 accessed with two-dimensional indices, like in the example below. 709 710 :: 711 712 DCL CONST[0][0..7] # declare first 8 vectors of constbuf 0 713 DCL CONST[3][0] # declare first vector of constbuf 3 714 MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 715 716* ``PIPE_SHADER_CAP_MAX_TEMPS``: The maximum number of temporary registers. 717* ``PIPE_SHADER_CAP_CONT_SUPPORTED``: Whether continue is supported. 718* ``PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR``: Whether indirect addressing 719 of the input file is supported. 720* ``PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR``: Whether indirect addressing 721 of the output file is supported. 722* ``PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR``: Whether indirect addressing 723 of the temporary file is supported. 724* ``PIPE_SHADER_CAP_INDIRECT_CONST_ADDR``: Whether indirect addressing 725 of the constant file is supported. 726* ``PIPE_SHADER_CAP_SUBROUTINES``: Whether subroutines are supported, i.e. 727 BGNSUB, ENDSUB, CAL, and RET, including RET in the main block. 728* ``PIPE_SHADER_CAP_INTEGERS``: Whether integer opcodes are supported. 729 If unsupported, only float opcodes are supported. 730* ``PIPE_SHADER_CAP_INT64_ATOMICS``: Whether int64 atomic opcodes are supported. The device needs to support add, sub, swap, cmpswap, and, or, xor, min, and max. 731* ``PIPE_SHADER_CAP_FP16``: Whether half precision floating-point opcodes are supported. 732 If unsupported, half precision ops need to be lowered to full precision. 733* ``PIPE_SHADER_CAP_FP16_DERIVATIVES``: Whether half precision floating-point 734 DDX and DDY opcodes are supported. 735* ``PIPE_SHADER_CAP_FP16_CONST_BUFFERS``: Whether half precision floating-point 736 constant buffer loads are supported. Drivers are recommended to report 0 737 if x86 F16C is not supported by the CPU (or an equivalent instruction set 738 on other CPU architectures), otherwise they could be impacted by emulated 739 FP16 conversions in glUniform. 740* ``PIPE_SHADER_CAP_INT16``: Whether 16-bit signed and unsigned integer types 741 are supported. 742* ``PIPE_SHADER_CAP_GLSL_16BIT_CONSTS``: Lower mediump constants to 16-bit. 743 Note that 16-bit constants are not lowered to uniforms in GLSL. 744* ``PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS``: The maximum number of texture 745 samplers. 746* ``PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS``: The maximum number of texture 747 sampler views. Must not be lower than PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS. 748* ``PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE``: Whether the driver doesn't 749 ignore tgsi_declaration_range::Last for shader inputs and outputs. 750* ``PIPE_SHADER_CAP_MAX_SHADER_BUFFERS``: Maximum number of memory buffers 751 (also used to implement atomic counters). Having this be non-0 also 752 implies support for the ``LOAD``, ``STORE``, and ``ATOM*`` TGSI 753 opcodes. 754* ``PIPE_SHADER_CAP_SUPPORTED_IRS``: Supported representations of the 755 program. It should be a mask of ``pipe_shader_ir`` bits. 756* ``PIPE_SHADER_CAP_MAX_SHADER_IMAGES``: Maximum number of image units. 757* ``PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS``: If atomic counters are separate, 758 how many HW counters are available for this stage. (0 uses SSBO atomics). 759* ``PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS``: If atomic counters are 760 separate, how many atomic counter buffers are available for this stage. 761 762.. _pipe_compute_cap: 763 764PIPE_COMPUTE_CAP_* 765^^^^^^^^^^^^^^^^^^ 766 767Compute-specific capabilities. They can be queried using 768pipe_screen::get_compute_param. 769 770* ``PIPE_COMPUTE_CAP_IR_TARGET``: A description of the target of the form 771 ``processor-arch-manufacturer-os`` that will be passed on to the compiler. 772 This CAP is only relevant for drivers that specify PIPE_SHADER_IR_NATIVE for 773 their preferred IR. 774 Value type: null-terminated string. Shader IR type dependent. 775* ``PIPE_COMPUTE_CAP_GRID_DIMENSION``: Number of supported dimensions 776 for grid and block coordinates. Value type: ``uint64_t``. Shader IR type dependent. 777* ``PIPE_COMPUTE_CAP_MAX_GRID_SIZE``: Maximum grid size in block 778 units. Value type: ``uint64_t []``. Shader IR type dependent. 779* ``PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE``: Maximum block size in thread 780 units. Value type: ``uint64_t []``. Shader IR type dependent. 781* ``PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK``: Maximum number of threads that 782 a single block can contain. Value type: ``uint64_t``. Shader IR type dependent. 783 This may be less than the product of the components of MAX_BLOCK_SIZE and is 784 usually limited by the number of threads that can be resident simultaneously 785 on a compute unit. 786* ``PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE``: Maximum size of the GLOBAL 787 resource. Value type: ``uint64_t``. Shader IR type dependent. 788* ``PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE``: Maximum size of the LOCAL 789 resource. Value type: ``uint64_t``. Shader IR type dependent. 790* ``PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE``: Maximum size of the PRIVATE 791 resource. Value type: ``uint64_t``. Shader IR type dependent. 792* ``PIPE_COMPUTE_CAP_MAX_INPUT_SIZE``: Maximum size of the INPUT 793 resource. Value type: ``uint64_t``. Shader IR type dependent. 794* ``PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE``: Maximum size of a memory object 795 allocation in bytes. Value type: ``uint64_t``. 796* ``PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY``: Maximum frequency of the GPU 797 clock in MHz. Value type: ``uint32_t`` 798* ``PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS``: Maximum number of compute units 799 Value type: ``uint32_t`` 800* ``PIPE_COMPUTE_CAP_MAX_SUBGROUPS``: The max amount of subgroups there can be 801 inside a block. Non 0 indicates support for OpenCL subgroups including 802 implementing ``get_compute_state_subgroup_size`` if multiple subgroup sizes 803 are supported. 804* ``PIPE_COMPUTE_CAP_IMAGES_SUPPORTED``: Whether images are supported 805 non-zero means yes, zero means no. Value type: ``uint32_t`` 806* ``PIPE_COMPUTE_CAP_SUBGROUP_SIZES``: Ored power of two sizes of a basic execution 807 unit in threads. Also known as wavefront size, warp size or SIMD width. 808 E.g. `64 | 32`. 809* ``PIPE_COMPUTE_CAP_ADDRESS_BITS``: The default compute device address space 810 size specified as an unsigned integer value in bits. 811* ``PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK``: Maximum variable number 812 of threads that a single block can contain. This is similar to 813 PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK, except that the variable size is not 814 known a compile-time but at dispatch-time. 815 816.. _pipe_bind: 817 818PIPE_BIND_* 819^^^^^^^^^^^ 820 821These flags indicate how a resource will be used and are specified at resource 822creation time. Resources may be used in different roles 823during their life cycle. Bind flags are cumulative and may be combined to create 824a resource which can be used for multiple things. 825Depending on the pipe driver's memory management and these bind flags, 826resources might be created and handled quite differently. 827 828* ``PIPE_BIND_RENDER_TARGET``: A color buffer or pixel buffer which will be 829 rendered to. Any surface/resource attached to pipe_framebuffer_state::cbufs 830 must have this flag set. 831* ``PIPE_BIND_DEPTH_STENCIL``: A depth (Z) buffer and/or stencil buffer. Any 832 depth/stencil surface/resource attached to pipe_framebuffer_state::zsbuf must 833 have this flag set. 834* ``PIPE_BIND_BLENDABLE``: Used in conjunction with PIPE_BIND_RENDER_TARGET to 835 query whether a device supports blending for a given format. 836 If this flag is set, surface creation may fail if blending is not supported 837 for the specified format. If it is not set, a driver may choose to ignore 838 blending on surfaces with formats that would require emulation. 839* ``PIPE_BIND_DISPLAY_TARGET``: A surface that can be presented to screen. Arguments to 840 pipe_screen::flush_front_buffer must have this flag set. 841* ``PIPE_BIND_SAMPLER_VIEW``: A texture that may be sampled from in a fragment 842 or vertex shader. 843* ``PIPE_BIND_VERTEX_BUFFER``: A vertex buffer. 844* ``PIPE_BIND_INDEX_BUFFER``: An vertex index/element buffer. 845* ``PIPE_BIND_CONSTANT_BUFFER``: A buffer of shader constants. 846* ``PIPE_BIND_STREAM_OUTPUT``: A stream output buffer. 847* ``PIPE_BIND_CUSTOM``: 848* ``PIPE_BIND_SCANOUT``: A front color buffer or scanout buffer. 849* ``PIPE_BIND_SHARED``: A shareable buffer that can be given to another 850 process. 851* ``PIPE_BIND_GLOBAL``: A buffer that can be mapped into the global 852 address space of a compute program. 853* ``PIPE_BIND_SHADER_BUFFER``: A buffer without a format that can be bound 854 to a shader and can be used with load, store, and atomic instructions. 855* ``PIPE_BIND_SHADER_IMAGE``: A buffer or texture with a format that can be 856 bound to a shader and can be used with load, store, and atomic instructions. 857* ``PIPE_BIND_COMPUTE_RESOURCE``: A buffer or texture that can be 858 bound to the compute program as a shader resource. 859* ``PIPE_BIND_COMMAND_ARGS_BUFFER``: A buffer that may be sourced by the 860 GPU command processor. It can contain, for example, the arguments to 861 indirect draw calls. 862 863.. _pipe_usage: 864 865PIPE_USAGE_* 866^^^^^^^^^^^^ 867 868The PIPE_USAGE enums are hints about the expected usage pattern of a resource. 869Note that drivers must always support read and write CPU access at any time 870no matter which hint they got. 871 872* ``PIPE_USAGE_DEFAULT``: Optimized for fast GPU access. 873* ``PIPE_USAGE_IMMUTABLE``: Optimized for fast GPU access and the resource is 874 not expected to be mapped or changed (even by the GPU) after the first upload. 875* ``PIPE_USAGE_DYNAMIC``: Expect frequent write-only CPU access. What is 876 uploaded is expected to be used at least several times by the GPU. 877* ``PIPE_USAGE_STREAM``: Expect frequent write-only CPU access. What is 878 uploaded is expected to be used only once by the GPU. 879* ``PIPE_USAGE_STAGING``: Optimized for fast CPU access. 880 881 882Methods 883------- 884 885XXX to-do 886 887get_name 888^^^^^^^^ 889 890Returns an identifying name for the screen. 891 892The returned string should remain valid and immutable for the lifetime of 893pipe_screen. 894 895get_vendor 896^^^^^^^^^^ 897 898Returns the screen vendor. 899 900The returned string should remain valid and immutable for the lifetime of 901pipe_screen. 902 903get_device_vendor 904^^^^^^^^^^^^^^^^^ 905 906Returns the actual vendor of the device driving the screen 907(as opposed to the driver vendor). 908 909The returned string should remain valid and immutable for the lifetime of 910pipe_screen. 911 912.. _get_param: 913 914get_param 915^^^^^^^^^ 916 917Get an integer/boolean screen parameter. 918 919**param** is one of the :ref:`PIPE_CAP` names. 920 921.. _get_paramf: 922 923get_paramf 924^^^^^^^^^^ 925 926Get a floating-point screen parameter. 927 928**param** is one of the :ref:`PIPE_CAPF` names. 929 930context_create 931^^^^^^^^^^^^^^ 932 933Create a pipe_context. 934 935**priv** is private data of the caller, which may be put to various 936unspecified uses, typically to do with implementing swapbuffers 937and/or front-buffer rendering. 938 939is_format_supported 940^^^^^^^^^^^^^^^^^^^ 941 942Determine if a resource in the given format can be used in a specific manner. 943 944**format** the resource format 945 946**target** one of the PIPE_TEXTURE_x flags 947 948**sample_count** the number of samples. 0 and 1 mean no multisampling, 949the maximum allowed legal value is 32. 950 951**storage_sample_count** the number of storage samples. This must be <= 952sample_count. See the documentation of ``pipe_resource::nr_storage_samples``. 953 954**bindings** is a bitmask of :ref:`PIPE_BIND` flags. 955 956Returns TRUE if all usages can be satisfied. 957 958 959can_create_resource 960^^^^^^^^^^^^^^^^^^^ 961 962Check if a resource can actually be created (but don't actually allocate any 963memory). This is used to implement OpenGL's proxy textures. Typically, a 964driver will simply check if the total size of the given resource is less than 965some limit. 966 967For PIPE_TEXTURE_CUBE, the pipe_resource::array_size field should be 6. 968 969 970.. _resource_create: 971 972resource_create 973^^^^^^^^^^^^^^^ 974 975Create a new resource from a template. 976The following fields of the pipe_resource must be specified in the template: 977 978**target** one of the pipe_texture_target enums. 979Note that PIPE_BUFFER and PIPE_TEXTURE_X are not really fundamentally different. 980Modern APIs allow using buffers as shader resources. 981 982**format** one of the pipe_format enums. 983 984**width0** the width of the base mip level of the texture or size of the buffer. 985 986**height0** the height of the base mip level of the texture 987(1 for 1D or 1D array textures). 988 989**depth0** the depth of the base mip level of the texture 990(1 for everything else). 991 992**array_size** the array size for 1D and 2D array textures. 993For cube maps this must be 6, for other textures 1. 994 995**last_level** the last mip map level present. 996 997**nr_samples**: Number of samples determining quality, driving the rasterizer, 998shading, and framebuffer. It is the number of samples seen by the whole 999graphics pipeline. 0 and 1 specify a resource which isn't multisampled. 1000 1001**nr_storage_samples**: Only color buffers can set this lower than nr_samples. 1002Multiple samples within a pixel can have the same color. ``nr_storage_samples`` 1003determines how many slots for different colors there are per pixel. 1004If there are not enough slots to store all sample colors, some samples will 1005have an undefined color (called "undefined samples"). 1006 1007The resolve blit behavior is driver-specific, but can be one of these two: 1008 10091. Only defined samples will be averaged. Undefined samples will be ignored. 10102. Undefined samples will be approximated by looking at surrounding defined 1011 samples (even in different pixels). 1012 1013Blits and MSAA texturing: If the sample being fetched is undefined, one of 1014the defined samples is returned instead. 1015 1016Sample shading (``set_min_samples``) will operate at a sample frequency that 1017is at most ``nr_storage_samples``. Greater ``min_samples`` values will be 1018replaced by ``nr_storage_samples``. 1019 1020**usage** one of the :ref:`PIPE_USAGE` flags. 1021 1022**bind** bitmask of the :ref:`PIPE_BIND` flags. 1023 1024**flags** bitmask of PIPE_RESOURCE_FLAG flags. 1025 1026**next**: Pointer to the next plane for resources that consist of multiple 1027memory planes. 1028 1029As a corollary, this mean resources for an image with multiple planes have 1030to be created starting from the highest plane. 1031 1032resource_changed 1033^^^^^^^^^^^^^^^^ 1034 1035Mark a resource as changed so derived internal resources will be recreated 1036on next use. 1037 1038When importing external images that can't be directly used as texture sampler 1039source, internal copies may have to be created that the hardware can sample 1040from. When those resources are reimported, the image data may have changed, and 1041the previously derived internal resources must be invalidated to avoid sampling 1042from old copies. 1043 1044 1045 1046resource_destroy 1047^^^^^^^^^^^^^^^^ 1048 1049Destroy a resource. A resource is destroyed if it has no more references. 1050 1051 1052 1053get_timestamp 1054^^^^^^^^^^^^^ 1055 1056Query a timestamp in nanoseconds. The returned value should match 1057PIPE_QUERY_TIMESTAMP. This function returns immediately and doesn't 1058wait for rendering to complete (which cannot be achieved with queries). 1059 1060 1061 1062get_driver_query_info 1063^^^^^^^^^^^^^^^^^^^^^ 1064 1065Return a driver-specific query. If the **info** parameter is NULL, 1066the number of available queries is returned. Otherwise, the driver 1067query at the specified **index** is returned in **info**. 1068The function returns non-zero on success. 1069The driver-specific query is described with the pipe_driver_query_info 1070structure. 1071 1072get_driver_query_group_info 1073^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1074 1075Return a driver-specific query group. If the **info** parameter is NULL, 1076the number of available groups is returned. Otherwise, the driver 1077query group at the specified **index** is returned in **info**. 1078The function returns non-zero on success. 1079The driver-specific query group is described with the 1080pipe_driver_query_group_info structure. 1081 1082 1083 1084get_disk_shader_cache 1085^^^^^^^^^^^^^^^^^^^^^ 1086 1087Returns a pointer to a driver-specific on-disk shader cache. If the driver 1088failed to create the cache or does not support an on-disk shader cache NULL is 1089returned. The callback itself may also be NULL if the driver doesn't support 1090an on-disk shader cache. 1091 1092 1093is_dmabuf_modifier_supported 1094^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1095 1096Query whether the driver supports a **modifier** in combination with a 1097**format**, and whether it is only supported with "external" texture targets. 1098If the combination is supported in any fashion, true is returned. If the 1099**external_only** parameter is not NULL, the bool it points to is set to 1100false if non-external texture targets are supported with the specified modifier+ 1101format, or true if only external texture targets are supported. 1102 1103 1104get_dmabuf_modifier_planes 1105^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1106 1107Query the number of planes required by the image layout specified by the 1108**modifier** and **format** parameters. The value returned includes both planes 1109dictated by **format** and any additional planes required for driver-specific 1110auxiliary data necessary for the layout defined by **modifier**. 1111If the proc is NULL, no auxiliary planes are required for any layout supported by 1112**screen** and the number of planes can be derived directly from **format**. 1113 1114 1115Thread safety 1116------------- 1117 1118Screen methods are required to be thread safe. While gallium rendering 1119contexts are not required to be thread safe, it is required to be safe to use 1120different contexts created with the same screen in different threads without 1121locks. It is also required to be safe using screen methods in a thread, while 1122using one of its contexts in another (without locks). 1123