diff options
Diffstat (limited to 'docs/gallium/screen.rst')
| -rw-r--r-- | docs/gallium/screen.rst | 343 |
1 files changed, 183 insertions, 160 deletions
diff --git a/docs/gallium/screen.rst b/docs/gallium/screen.rst index 279ef397f10..54fc0778f4b 100644 --- a/docs/gallium/screen.rst +++ b/docs/gallium/screen.rst @@ -29,7 +29,6 @@ The integer capabilities: * ``PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS``: How many dual-source blend RTs are support. :ref:`Blend` for more information. * ``PIPE_CAP_ANISOTROPIC_FILTER``: Whether textures can be filtered anisotropically. -* ``PIPE_CAP_POINT_SPRITE``: Whether point sprites are available. * ``PIPE_CAP_MAX_RENDER_TARGETS``: The maximum number of render targets that may be bound. * ``PIPE_CAP_OCCLUSION_QUERY``: Whether occlusion queries are available. @@ -64,18 +63,16 @@ The integer capabilities: * ``PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS``: The maximum number of texture array layers supported. If 0, the array textures are not supported at all and the ARRAY texture targets are invalid. -* ``PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT``: Whether the TGSI property - FS_COORD_ORIGIN with value UPPER_LEFT is supported. -* ``PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT``: Whether the TGSI property - FS_COORD_ORIGIN with value LOWER_LEFT is supported. -* ``PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER``: Whether the TGSI - property FS_COORD_PIXEL_CENTER with value HALF_INTEGER is supported. -* ``PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER``: Whether the TGSI - property FS_COORD_PIXEL_CENTER with value INTEGER is supported. +* ``PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT``: Whether the upper-left origin + fragment convention is supported. +* ``PIPE_CAP_FS_COORD_ORIGIN_LOWER_LEFT``: Whether the lower-left origin + fragment convention is supported. +* ``PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER``: Whether the half-integer + pixel-center fragment convention is supported. +* ``PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER``: Whether the integer + pixel-center fragment convention is supported. * ``PIPE_CAP_DEPTH_CLIP_DISABLE``: Whether the driver is capable of disabling - depth clipping (=1) (through pipe_rasterizer_state) or supports lowering - depth_clamp in the client shader code (=2), for this the driver must - currently use TGSI. + depth clipping (through pipe_rasterizer_state). * ``PIPE_CAP_DEPTH_CLIP_DISABLE_SEPARATE``: Whether the driver is capable of disabling depth clipping (through pipe_rasterizer_state) separately for the near and far plane. If not, depth_clip_near and depth_clip_far will be @@ -85,8 +82,8 @@ The integer capabilities: clipping. If not, depth_clamp will be the inverse of depth_clip_far. * ``PIPE_CAP_SHADER_STENCIL_EXPORT``: Whether a stencil reference value can be written from a fragment shader. -* ``PIPE_CAP_TGSI_INSTANCEID``: Whether TGSI_SEMANTIC_INSTANCEID is supported - in the vertex shader. +* ``PIPE_CAP_VS_INSTANCEID``: Whether ``SYSTEM_VALUE_INSTANCE_ID`` is + supported in the vertex shader. * ``PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR``: Whether the driver supports per-instance vertex attribs. * ``PIPE_CAP_FRAGMENT_COLOR_CLAMPED``: Whether fragment color clamping is @@ -122,23 +119,30 @@ The integer capabilities: is allowed to return ``0`` in which case ``PIPE_CAP_GLSL_FEATURE_LEVEL`` is used. Note that simply returning the same value as the GLSL feature level cap is - incorrect. For example, GLSL version 3.30 does not require ``ARB_gpu_shader5``, - but ESSL version 3.20 es does require ``EXT_gpu_shader5`` + incorrect. For example, GLSL version 3.30 does not require + :ext:`GL_EXT_gpu_shader5`, but ESSL version 3.20 es does require + :ext:`GL_EXT_gpu_shader5` * ``PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION``: Whether quads adhere to the flatshade_first setting in ``pipe_rasterizer_state``. * ``PIPE_CAP_USER_VERTEX_BUFFERS``: Whether the driver supports user vertex - buffers. If not, gallium frontends must upload all data which is not in hw + buffers. If not, gallium frontends must upload all data which is not in HW resources. If user-space buffers are supported, the driver must also still accept HW resource buffers. -* ``PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY``: This CAP describes a hw +* ``PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY``: This CAP describes a HW limitation. If true, pipe_vertex_buffer::buffer_offset must always be aligned to 4. If false, there are no restrictions on the offset. -* ``PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY``: This CAP describes a hw +* ``PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY``: This CAP describes a HW limitation. If true, pipe_vertex_buffer::stride must always be aligned to 4. If false, there are no restrictions on the stride. * ``PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY``: This CAP describes - a hw limitation. If true, pipe_vertex_element::src_offset must always be + a HW limitation. If true, pipe_vertex_element::src_offset must always be aligned to 4. If false, there are no restrictions on src_offset. +* ``PIPE_CAP_VERTEX_ATTRIB_ELEMENT_ALIGNED_ONLY``: This CAP describes + a HW limitation. If true, the sum of + ``pipe_vertex_element::src_offset + pipe_vertex_buffer::buffer_offset + pipe_vertex_buffer::stride`` + must always be aligned to the component size for the vertex attributes + which access that buffer. If false, there are no restrictions on these values. + This CAP cannot be used with any other alignment-requiring CAPs. * ``PIPE_CAP_COMPUTE``: Whether the implementation supports the compute entry points defined in pipe_context and pipe_screen. * ``PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT``: Describes the required @@ -147,6 +151,9 @@ The integer capabilities: pipe_draw_info::start_instance. * ``PIPE_CAP_QUERY_TIMESTAMP``: Whether PIPE_QUERY_TIMESTAMP and the pipe_screen::get_timestamp hook are implemented. +* ``PIPE_CAP_QUERY_TIMESTAMP_BITS``: How many bits the driver uses for the + results of GL_TIMESTAMP queries. +* ``PIPE_CAP_TIMER_RESOLUTION``: The resolution of the timer in nanos. * ``PIPE_CAP_TEXTURE_MULTISAMPLE``: Whether all MSAA resources supported for rendering are also supported for texturing. * ``PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT``: The minimum alignment that should be @@ -156,11 +163,17 @@ The integer capabilities: * ``PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT``: Describes the required alignment for pipe_sampler_view::u.buf.offset, in bytes. If a driver does not support offset/size, it should return 0. +* ``PIPE_CAP_LINEAR_IMAGE_PITCH_ALIGNMENT``: Describes the row pitch alignment + size that pipe_sampler_view::u.tex2d_from_buf must be multiple of, in pixels. + If a driver does not support images created from buffers, it should return 0. +* ``PIPE_CAP_LINEAR_IMAGE_BASE_ADDRESS_ALIGNMENT``: Describes the minimum alignment + in pixels of the offset of a host pointer for images created from buffers. + If a driver does not support images created from buffers, it should return 0. * ``PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY``: Whether the driver only supports R, RG, RGB and RGBA formats for PIPE_BUFFER sampler views. When this is the case it should be assumed that the swizzle parameters in the sampler view have no effect. -* ``PIPE_CAP_TGSI_TEXCOORD``: This CAP describes a hw limitation. +* ``PIPE_CAP_TGSI_TEXCOORD``: This CAP describes a HW limitation. If true, the hardware cannot replace arbitrary shader inputs with sprite coordinates and hence the inputs that are desired to be replaceable must be declared with TGSI_SEMANTIC_TEXCOORD instead of TGSI_SEMANTIC_GENERIC. @@ -168,13 +181,13 @@ The integer capabilities: TEXCOORD semantic. Also, TGSI_SEMANTIC_PCOORD becomes available, which labels a fragment shader input that will always be replaced with sprite coordinates. -* ``PIPE_CAP_TEXTURE_BUFFER_SAMPLER``: Whether a sampler should still - be used for PIPE_BUFFER resources (normally a sampler is only used - if the texture target is PIPE_TEXTURE_*). -* ``PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER``: Whether it is preferable - to use a blit to implement a texture transfer which needs format conversions +* ``PIPE_CAP_TEXTURE_TRANSFER_MODES``: The ``pipe_texture_transfer_mode`` modes + that are supported for implementing a texture transfer which needs format conversions and swizzling in gallium frontends. Generally, all hardware drivers with - dedicated memory should return 1 and all software rasterizers should return 0. + dedicated memory should return PIPE_TEXTURE_TRANSFER_BLIT and all software rasterizers + should return PIPE_TEXTURE_TRANSFER_DEFAULT. PIPE_TEXTURE_TRANSFER_COMPUTE requires drivers + to support 8bit and 16bit shader storage buffer writes and to implement + pipe_screen::is_compute_copy_faster. * ``PIPE_CAP_QUERY_PIPELINE_STATISTICS``: Whether PIPE_QUERY_PIPELINE_STATISTICS is supported. * ``PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK``: Bitmask indicating whether special @@ -188,8 +201,9 @@ The integer capabilities: state should be swizzled manually according to the swizzle in the sampler view it is intended to be used with, or herein undefined results may occur for permutational swizzles. -* ``PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE``: The maximum accessible size with - a buffer sampler view, in texels. +* ``PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT``: The maximum accessible number of + elements within a sampler buffer view and image buffer view. This is unsigned + integer with the maximum of 4G - 1. * ``PIPE_CAP_MAX_VIEWPORTS``: The maximum number of viewports (and scissors since they are linked) a driver can support. Returning 0 is equivalent to returning 1 because every driver has to support at least a single @@ -198,11 +212,10 @@ The integer capabilities: PIPE_ENDIAN_BIG or PIPE_ENDIAN_LITTLE. * ``PIPE_CAP_MIXED_FRAMEBUFFER_SIZES``: Whether it is allowed to have different sizes for fb color/zs attachments. This controls whether - ARB_framebuffer_object is provided. -* ``PIPE_CAP_TGSI_VS_LAYER_VIEWPORT``: Whether ``TGSI_SEMANTIC_LAYER`` and - ``TGSI_SEMANTIC_VIEWPORT_INDEX`` are supported as vertex shader - outputs. Note that the viewport will only be used if multiple viewports are - exposed. + :ext:`GL_ARB_framebuffer_object` is provided. +* ``PIPE_CAP_VS_LAYER_VIEWPORT``: Whether ``VARYING_SLOT_LAYER`` and + ``VARYING_SLOT_VIEWPORT`` are supported as vertex shader outputs. Note that + the viewport will only be used if multiple viewports are exposed. * ``PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES``: The maximum number of vertices output by a single invocation of a geometry shader. * ``PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS``: The maximum number of @@ -229,9 +242,8 @@ The integer capabilities: implemented. * ``PIPE_CAP_TEXTURE_GATHER_OFFSETS``: Whether the ``TG4`` instruction can accept 4 offsets. -* ``PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION``: Whether - TGSI_PROPERTY_VS_WINDOW_SPACE_POSITION is supported, which disables clipping - and viewport transformation. +* ``PIPE_CAP_VS_WINDOW_SPACE_POSITION``: Whether window-space position is + supported, which disables clipping and viewport transformation. * ``PIPE_CAP_MAX_VERTEX_STREAMS``: The maximum number of vertex streams supported by the geometry shader. If stream-out is supported, this should be at least 1. If stream-out is not supported, this should be 0. @@ -243,13 +255,18 @@ The integer capabilities: * ``PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS``: Whether the driver supports taking the number of indirect draws from a separate parameter buffer, see pipe_draw_indirect_info::indirect_draw_count. -* ``PIPE_CAP_TGSI_FS_FINE_DERIVATIVE``: Whether the fragment shader supports +* ``PIPE_CAP_MULTI_DRAW_INDIRECT_PARTIAL_STRIDE``: Whether the driver supports + indirect draws with an arbitrary stride. +* ``PIPE_CAP_FS_FINE_DERIVATIVE``: Whether the fragment shader supports the FINE versions of DDX/DDY. * ``PIPE_CAP_VENDOR_ID``: The vendor ID of the underlying hardware. If it's not available one should return 0xFFFFFFFF. * ``PIPE_CAP_DEVICE_ID``: The device ID (PCI ID) of the underlying hardware. 0xFFFFFFFF if not available. -* ``PIPE_CAP_ACCELERATED``: Whether the renderer is hardware accelerated. +* ``PIPE_CAP_ACCELERATED``: Whether the renderer is hardware accelerated. 0 means + not accelerated (i.e. CPU rendering), 1 means accelerated (i.e. GPU rendering), + -1 means unknown (i.e. an API translation driver which doesn't known what kind of + hardware it's running above). * ``PIPE_CAP_VIDEO_MEMORY``: The amount of video memory in megabytes. * ``PIPE_CAP_UMA``: If the device has a unified memory architecture or on-card memory and GART. @@ -258,18 +275,11 @@ The integer capabilities: * ``PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE``: The maximum supported vertex stride. * ``PIPE_CAP_SAMPLER_VIEW_TARGET``: Whether the sampler view's target can be different than the underlying resource's, as permitted by - ARB_texture_view. For example a 2d array texture may be reinterpreted as a + :ext:`GL_ARB_texture_view`. For example a 2d array texture may be reinterpreted as a cube (array) texture and vice-versa. * ``PIPE_CAP_CLIP_HALFZ``: Whether the driver supports the pipe_rasterizer_state::clip_halfz being set to true. This is required - for enabling ARB_clip_control. -* ``PIPE_CAP_VERTEXID_NOBASE``: If true, the driver only supports - TGSI_SEMANTIC_VERTEXID_NOBASE (and not TGSI_SEMANTIC_VERTEXID). This means - gallium frontends for APIs whose vertexIDs are offset by basevertex (such as GL) - will need to lower TGSI_SEMANTIC_VERTEXID to TGSI_SEMANTIC_VERTEXID_NOBASE - and TGSI_SEMANTIC_BASEVERTEX, so drivers setting this must handle both these - semantics. Only relevant if geometry shaders are supported. - (BASEVERTEX could be exposed separately too via ``PIPE_CAP_DRAW_PARAMETERS``). + for enabling :ext:`GL_ARB_clip_control`. * ``PIPE_CAP_POLYGON_OFFSET_CLAMP``: If true, the driver implements support for ``pipe_rasterizer_state::offset_clamp``. * ``PIPE_CAP_MULTISAMPLE_Z_RESOLVE``: Whether the driver supports blitting @@ -298,36 +308,34 @@ The integer capabilities: textures. * ``PIPE_CAP_DEPTH_BOUNDS_TEST``: Whether bounds_test, bounds_min, and bounds_max states of pipe_depth_stencil_alpha_state behave according - to the GL_EXT_depth_bounds_test specification. -* ``PIPE_CAP_TGSI_TXQS``: Whether the `TXQS` opcode is supported + to the :ext:`GL_EXT_depth_bounds_test` specification. +* ``PIPE_CAP_TEXTURE_QUERY_SAMPLES``: Whether the ``TXQS`` opcode is supported * ``PIPE_CAP_FORCE_PERSAMPLE_INTERP``: If the driver can force per-sample interpolation for all fragment shader inputs if pipe_rasterizer_state::force_persample_interp is set. This is only used - by GL3-level sample shading (ARB_sample_shading). GL4-level sample shading - (ARB_gpu_shader5) doesn't use this. While GL3 hardware has a state for it, - GL4 hardware will likely need to emulate it with a shader variant, or by - selecting the interpolation weights with a conditional assignment - in the shader. + by GL3-level sample shading (:ext:`GL_ARB_sample_shading`). GL4-level sample + shading (:ext:`GL_ARB_gpu_shader5`) doesn't use this. While GL3 hardware has a + state for it, GL4 hardware will likely need to emulate it with a shader + variant, or by selecting the interpolation weights with a conditional + assignment in the shader. * ``PIPE_CAP_SHAREABLE_SHADERS``: Whether shader CSOs can be used by any pipe_context. Important for reducing jank at draw time by letting GL shaders linked in one thread be used in another thread without recompiling. * ``PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS``: Whether copying between compressed and plain formats is supported where a compressed block is copied to/from a plain pixel of the same size. -* ``PIPE_CAP_CLEAR_TEXTURE``: Whether `clear_texture` will be - available in contexts. -* ``PIPE_CAP_CLEAR_SCISSORED``: Whether `clear` can accept a scissored +* ``PIPE_CAP_CLEAR_SCISSORED``: Whether ``clear`` can accept a scissored bounding box. * ``PIPE_CAP_DRAW_PARAMETERS``: Whether ``TGSI_SEMANTIC_BASEVERTEX``, ``TGSI_SEMANTIC_BASEINSTANCE``, and ``TGSI_SEMANTIC_DRAWID`` are supported in vertex shaders. -* ``PIPE_CAP_TGSI_PACK_HALF_FLOAT``: Whether the ``UP2H`` and ``PK2H`` - TGSI opcodes are supported. -* ``PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL``: If gallium frontends should use - a system value for the POSITION fragment shader input. -* ``PIPE_CAP_TGSI_FS_POINT_IS_SYSVAL``: If gallium frontends should use - a system value for the POINT fragment shader input. -* ``PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL``: If gallium frontends should use +* ``PIPE_CAP_SHADER_PACK_HALF_FLOAT``: Whether packed 16-bit float + packing/unpacking opcodes are supported. +* ``PIPE_CAP_FS_POSITION_IS_SYSVAL``: If gallium frontends should use a + system value for the POSITION fragment shader input. +* ``PIPE_CAP_FS_POINT_IS_SYSVAL``: If gallium frontends should use a system + value for the POINT fragment shader input. +* ``PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL``: If gallium frontends should use a system value for the FACE fragment shader input. Also, the FACE system value is integer, not float. * ``PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT``: Describes the required @@ -355,22 +363,28 @@ The integer capabilities: * ``PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT``: If non-zero, rendering to framebuffers with no surface attachments is supported. The context->is_format_supported function will be expected - to be implemented with PIPE_FORMAT_NONE yeilding the MSAA modes the hardware + to be implemented with PIPE_FORMAT_NONE yielding the MSAA modes the hardware supports. N.B., The maximum number of layers supported for rasterizing a primitive on a layer is obtained from ``PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS`` even though it can be larger than the number of layers supported by either rendering or textures. * ``PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR``: Implementation uses bounds checking on resource accesses by shader if the context is created with - PIPE_CONTEXT_ROBUST_BUFFER_ACCESS. See the ARB_robust_buffer_access_behavior - extension for information on the required behavior for out of bounds accesses - and accesses to unbound resources. -* ``PIPE_CAP_CULL_DISTANCE``: Whether the driver supports the arb_cull_distance - extension and thus implements proper support for culling planes. + PIPE_CONTEXT_ROBUST_BUFFER_ACCESS. See the + :ext:`GL_ARB_robust_buffer_access_behavior` extension for information on the + required behavior for out of bounds accesses and accesses to unbound + resources. +* ``PIPE_CAP_CULL_DISTANCE``: Whether the driver supports the + :ext:`GL_ARB_cull_distance` extension and thus implements proper support for + culling planes. +* ``PIPE_CAP_CULL_DISTANCE_NOCOMBINE``: Whether the driver wants to skip + running the ``nir_lower_clip_cull_distance_arrays`` pass in order to get + VARYING_SLOT_CULL_DIST0 slot variables. * ``PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES``: Whether primitive restart is supported for patch primitives. -* ``PIPE_CAP_TGSI_VOTE``: Whether the ``VOTE_*`` ops can be used in shaders. -* ``PIPE_CAP_MAX_WINDOW_RECTANGLES``: The maxium number of window rectangles +* ``PIPE_CAP_SHADER_GROUP_VOTE``: Whether the ``VOTE_*`` ops can be used in + shaders. +* ``PIPE_CAP_MAX_WINDOW_RECTANGLES``: The maximum number of window rectangles supported in ``set_window_rectangles``. * ``PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED``: If true, the driver implements support for ``pipe_rasterizer_state::offset_units_unscaled``. @@ -384,7 +398,7 @@ The integer capabilities: 32-bit. If set to off, that means that a B5G6R5 + Z24 or RGBA8 + Z16 combination will require a driver fallback, and should not be advertised in the GLX/EGL config list. -* ``PIPE_CAP_TGSI_ARRAY_COMPONENTS``: If true, the driver interprets the +* ``PIPE_CAP_SHADER_ARRAY_COMPONENTS``: If true, the driver interprets the UsageMask of input and output declarations and allows declaring arrays in overlapping ranges. The components must be a contiguous range, e.g. a UsageMask of xy or yzw is allowed, but xz or yw isn't. Declarations with @@ -392,34 +406,33 @@ The integer capabilities: equal interpolation qualifiers. Components may overlap, notably when the gaps in an array of dvec3 are filled in. -* ``PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME``: Whether GL_ARB_transform_feeddback2 - is supported, including pausing/resuming queries and having - `count_from_stream_output` set on indirect draws to implement - glDrawTransformFeedback. Required for OpenGL 4.0. +* ``PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME``: Whether + :ext:`GL_ARB_transform_feedback2` is supported, including pausing/resuming + queries and having ``count_from_stream_output`` set on indirect draws to + implement glDrawTransformFeedback. Required for OpenGL 4.0. * ``PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS``: Whether interleaved stream output mode is able to interleave across buffers. This is required for - ARB_transform_feedback3. -* ``PIPE_CAP_TGSI_CAN_READ_OUTPUTS``: Whether every TGSI shader stage can read + :ext:`GL_ARB_transform_feedback3`. +* ``PIPE_CAP_SHADER_CAN_READ_OUTPUTS``: Whether every TGSI shader stage can read from the output file. -* ``PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY``: Tell the GLSL compiler to use - the minimum amount of optimizations just to be able to do all the linking - and lowering. * ``PIPE_CAP_FBFETCH``: The number of render targets whose value in the current framebuffer can be read in the shader. 0 means framebuffer fetch is not supported. 1 means that only the first render target can be read, and a larger value would mean that multiple render targets are supported. * ``PIPE_CAP_FBFETCH_COHERENT``: Whether framebuffer fetches from the fragment shader can be guaranteed to be coherent with framebuffer writes. -* ``PIPE_CAP_TGSI_MUL_ZERO_WINS``: Whether TGSI shaders support the - ``TGSI_PROPERTY_MUL_ZERO_WINS`` shader property. +* ``PIPE_CAP_FBFETCH_ZS``: Whether fragment shader can fetch current values of + Z/S attachments. These fetches are always coherent with framebuffer writes. +* ``PIPE_CAP_LEGACY_MATH_RULES``: Whether NIR shaders support the + ``shader_info.use_legacy_math_rules`` flag (see documentation there), and + TGSI shaders support the corresponding ``TGSI_PROPERTY_LEGACY_MATH_RULES``. +* ``PIPE_CAP_FP16``: Whether 16-bit float operations are supported. * ``PIPE_CAP_DOUBLES``: Whether double precision floating-point operations are supported. * ``PIPE_CAP_INT64``: Whether 64-bit integer operations are supported. -* ``PIPE_CAP_INT64_DIVMOD``: Whether 64-bit integer division/modulo - operations are supported. * ``PIPE_CAP_TGSI_TEX_TXF_LZ``: Whether TEX_LZ and TXF_LZ opcodes are supported. -* ``PIPE_CAP_TGSI_CLOCK``: Whether the CLOCK opcode is supported. +* ``PIPE_CAP_SHADER_CLOCK``: Whether the CLOCK opcode is supported. * ``PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE``: Whether the PIPE_POLYGON_MODE_FILL_RECTANGLE mode is supported for ``pipe_rasterizer_state::fill_front`` and @@ -427,10 +440,10 @@ The integer capabilities: * ``PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE``: The page size of sparse buffers in bytes, or 0 if sparse buffers are not supported. The page size must be at most 64KB. -* ``PIPE_CAP_TGSI_BALLOT``: Whether the BALLOT and READ_* opcodes as well as +* ``PIPE_CAP_SHADER_BALLOT``: Whether the BALLOT and READ_* opcodes as well as the SUBGROUP_* semantics are supported. -* ``PIPE_CAP_TGSI_TES_LAYER_VIEWPORT``: Whether ``TGSI_SEMANTIC_LAYER`` and - ``TGSI_SEMANTIC_VIEWPORT_INDEX`` are supported as tessellation evaluation +* ``PIPE_CAP_TES_LAYER_VIEWPORT``: Whether ``VARYING_SLOT_LAYER`` and + ``VARYING_SLOT_VIEWPORT`` are supported as tessellation evaluation shader outputs. * ``PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX``: Whether a buffer with just PIPE_BIND_CONSTANT_BUFFER can be legally passed to set_vertex_buffers. @@ -449,10 +462,8 @@ The integer capabilities: * ``PIPE_CAP_MEMOBJ``: Whether operations on memory objects are supported. * ``PIPE_CAP_LOAD_CONSTBUF``: True if the driver supports ``TGSI_OPCODE_LOAD`` use with constant buffers. -* ``PIPE_CAP_TGSI_ANY_REG_AS_ADDRESS``: Any TGSI register can be used as - an address for indirect register indexing. * ``PIPE_CAP_TILE_RASTER_ORDER``: Whether the driver supports - GL_MESA_tile_raster_order, using the tile_raster_order_* fields in + :ext:`GL_MESA_tile_raster_order`, using the tile_raster_order_* fields in pipe_rasterizer_state. * ``PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES``: Limit on combined shader output resources (images + buffers + fragment outputs). If 0 the state @@ -502,7 +513,7 @@ The integer capabilities: * ``PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE``: Whether ``PIPE_CAP_POST_DEPTH_COVERAGE`` works with conservative rasterization. * ``PIPE_CAP_CONSERVATIVE_RASTER_INNER_COVERAGE``: Whether - inner_coverage from GL_INTEL_conservative_rasterization is supported. + inner_coverage from :ext:`GL_INTEL_conservative_rasterization` is supported. * ``PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS``: The maximum subpixel precision bias in bits during conservative rasterization. * ``PIPE_CAP_PROGRAMMABLE_SAMPLE_LOCATIONS``: True is the driver supports @@ -510,8 +521,8 @@ The integer capabilities: ```set_sample_locations```. * ``PIPE_CAP_MAX_GS_INVOCATIONS``: Maximum supported value of TGSI_PROPERTY_GS_INVOCATIONS. -* ``PIPE_CAP_MAX_SHADER_BUFFER_SIZE``: Maximum supported size for binding - with set_shader_buffers. +* ``PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT``: Maximum supported size for binding + with set_shader_buffers. This is unsigned integer with the maximum of 4GB - 1. * ``PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS``: Maximum total number of shader buffers. A value of 0 means the sum of all per-shader stage maximums (see ``PIPE_SHADER_CAP_MAX_SHADER_BUFFERS``). @@ -527,15 +538,13 @@ The integer capabilities: of pipe_vertex_element::src_offset. * ``PIPE_CAP_SURFACE_SAMPLE_COUNT``: Whether the driver supports pipe_surface overrides of resource nr_samples. If set, will - enable EXT_multisampled_render_to_texture. -* ``PIPE_CAP_TGSI_ATOMFADD``: Atomic floating point adds are supported on - images, buffers, and shared memory. -* ``PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND``: True if the driver needs blend state to use zero/one instead of destination alpha for RGB/XRGB formats. + enable :ext:`GL_EXT_multisampled_render_to_texture`. +* ``PIPE_CAP_IMAGE_ATOMIC_FLOAT_ADD``: Atomic floating point adds are + supported on images, buffers, and shared memory. * ``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. * ``PIPE_CAP_DEST_SURFACE_SRGB_CONTROL``: Indicates whether the drivers supports switching the format between sRGB and linear for a surface that is used as destination in draw and blit calls. -* ``PIPE_CAP_NIR_COMPACT_ARRAYS``: True if the compiler backend supports NIR's compact array feature, for all shader stages. * ``PIPE_CAP_MAX_VARYINGS``: The maximum number of fragment shader varyings. This will generally correspond to ``PIPE_SHADER_CAP_MAX_INPUTS`` for the fragment shader, but in some @@ -543,40 +552,41 @@ The integer capabilities: * ``PIPE_CAP_COMPUTE_GRID_INFO_LAST_BLOCK``: Whether pipe_grid_info::last_block is implemented by the driver. See struct pipe_grid_info for more details. * ``PIPE_CAP_COMPUTE_SHADER_DERIVATIVE``: True if the driver supports derivatives (and texture lookups with implicit derivatives) in compute shaders. -* ``PIPE_CAP_TGSI_SKIP_SHRINK_IO_ARRAYS``: Whether the TGSI pass to shrink IO - arrays should be skipped and enforce keeping the declared array sizes instead. - A driver might rely on the input mapping that was defined with the original - GLSL code. * ``PIPE_CAP_IMAGE_LOAD_FORMATTED``: True if a format for image loads does not need to be specified in the shader IR +* ``PIPE_CAP_IMAGE_STORE_FORMATTED``: True if a format for image stores does not need to be specified in the shader IR * ``PIPE_CAP_THROTTLE``: Whether or not gallium frontends should throttle pipe_context execution. 0 = throttling is disabled. * ``PIPE_CAP_DMABUF``: Whether Linux DMABUF handles are supported by resource_from_handle and resource_get_handle. + Possible bit field values: + + 1. ``DRM_PRIME_CAP_IMPORT``: resource_from_handle is supported + 2. ``DRM_PRIME_CAP_EXPORT``: resource_get_handle is supported + +* ``PIPE_CAP_CL_GL_SHARING``: True if driver supports everything required by a frontend implementing the CL extension, and + also supports importing/exporting all of pipe_texture_target via dma buffers. * ``PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA``: Whether VDPAU, VAAPI, and OpenMAX should use a compute-based blit instead of pipe_context::blit and compute pipeline for compositing images. * ``PIPE_CAP_FRAGMENT_SHADER_INTERLOCK``: True if fragment shader interlock functionality is supported. -* ``PIPE_CAP_CS_DERIVED_SYSTEM_VALUES_SUPPORTED``: True if driver handles - gl_LocalInvocationIndex and gl_GlobalInvocationID. Otherwise, gallium frontends will - lower those system values. * ``PIPE_CAP_ATOMIC_FLOAT_MINMAX``: Atomic float point minimum, maximum, exchange and compare-and-swap support to buffer and shared variables. * ``PIPE_CAP_TGSI_DIV``: Whether opcode DIV is supported +* ``PIPE_CAP_DITHERING``: Whether dithering is supported * ``PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD``: Whether texture lookups with explicit LOD is supported in the fragment shader. * ``PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES``: True if the driver supports derivatives in fragment shaders. -* ``PIPE_CAP_VERTEX_SHADER_SATURATE``: True if the driver supports saturate - modifiers in the vertex shader. * ``PIPE_CAP_TEXTURE_SHADOW_LOD``: True if the driver supports shadow sampler types with texture functions having interaction with LOD of texture lookup. * ``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. -* ``PIPE_CAP_TGSI_ATOMINC_WRAP``: Atomic increment/decrement + wrap around are supported. +* ``PIPE_CAP_IMAGE_ATOMIC_INC_WRAP``: Atomic increment/decrement + wrap around + are supported. * ``PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF``: True if gallium frontends should turn arrays whose contents can be deduced at compile time into constant buffer loads, or false if the driver can handle such arrays itself in a more - efficient manner. -* ``PIPE_CAP_GL_SPIRV``: True if the driver supports ARB_gl_spirv extension. + efficient manner (such as through nir_opt_large_constants() and nir->constant_data). +* ``PIPE_CAP_GL_SPIRV``: True if the driver supports :ext:`GL_ARB_gl_spirv` extension. * ``PIPE_CAP_GL_SPIRV_VARIABLE_POINTERS``: True if the driver supports Variable Pointers in SPIR-V shaders. * ``PIPE_CAP_DEMOTE_TO_HELPER_INVOCATION``: True if driver supports demote keyword in GLSL programs. * ``PIPE_CAP_TGSI_TG4_COMPONENT_IN_SWIZZLE``: True if driver wants the TG4 component encoded in sampler swizzle rather than as a separate source. @@ -591,36 +601,56 @@ The integer capabilities: as opposed to writing gl_PointSize for every point. * ``PIPE_CAP_TWO_SIDED_COLOR``: Driver supports two-sided coloring. Must be 1 for non-NIR drivers. If set, pipe_rasterizer_state may be set to indicate - that backfacing primitives should use the back-side color as the FS input + that back-facing primitives should use the back-side color as the FS input color. If unset, mesa/st will lower it to gl_FrontFacing reads in the fragment shader. -* ``PIPE_CAP_CLIP_PLANES``: Driver supports user-defined clip-planes. +* ``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. * ``PIPE_CAP_MAX_VERTEX_BUFFERS``: Number of supported vertex buffers. -* ``PIPE_CAP_OPENCL_INTEGER_FUNCTIONS``: Driver supports extended OpenCL-style integer functions. This includes averge, saturating additiong, saturating subtraction, absolute difference, count leading zeros, and count trailing zeros. +* ``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. * ``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. * ``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. * ``PIPE_CAP_PACKED_STREAM_OUTPUT``: Driver supports packing optimization for stream output (e.g. GL transform feedback captured variables). Defaults to true. * ``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. * ``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. * ``PIPE_CAP_GL_BEGIN_END_BUFFER_SIZE``: Buffer size used to upload vertices for glBegin/glEnd. -* ``PIPE_CAP_VIEWPORT_SWIZZLE``: Whether pipe_viewport_state::swizzle can be used to specify pre-clipping swizzling of coordinates (see GL_NV_viewport_swizzle). +* ``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`). * ``PIPE_CAP_SYSTEM_SVM``: True if all application memory can be shared with the GPU without explicit mapping. -* ``PIPE_CAP_VIEWPORT_MASK``: Whether ``TGSI_SEMANTIC_VIEWPORT_MASK`` and ``TGSI_PROPERTY_LAYER_VIEWPORT_RELATIVE`` are supported (see GL_NV_viewport_array2). +* ``PIPE_CAP_VIEWPORT_MASK``: Whether ``TGSI_SEMANTIC_VIEWPORT_MASK`` and ``TGSI_PROPERTY_LAYER_VIEWPORT_RELATIVE`` are supported (see :ext:`GL_NV_viewport_array2`). * ``PIPE_CAP_MAP_UNSYNCHRONIZED_THREAD_SAFE``: Whether mapping a buffer as unsynchronized from any thread is safe. -* ``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. +* ``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. * ``PIPE_CAP_BLEND_EQUATION_ADVANCED``: Driver supports blend equation advanced without necessarily supporting FBFETCH. * ``PIPE_CAP_NIR_ATOMICS_AS_DEREF``: Whether NIR atomics instructions should reference atomics as NIR derefs instead of by indices. -* ``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 (eg: may want out-of-bounds reads that produce 0 instead of leaving the texture content undefined) +* ``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) * ``PIPE_CAP_MAX_TEXTURE_MB``: Maximum texture size in MB (default is 1024) -* ``PIPE_CAP_DEVICE_PROTECTED_CONTENT``: Whether the device support protected / encrypted content. -* ``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 codepath in a gallium frontend for drivers that really prefer a real buffer. +* ``PIPE_CAP_DEVICE_PROTECTED_SURFACE``: Whether the device support protected / encrypted content. +* ``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. * ``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. -* ``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. +* ``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. * ``PIPE_CAP_SAMPLER_REDUCTION_MINMAX``: Driver supports EXT min/max sampler reduction. * ``PIPE_CAP_SAMPLER_REDUCTION_MINMAX_ARB``: Driver supports ARB min/max sampler reduction with format queries. * ``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. -* ``PIPE_CAP_SUPPORTED_PRIM_MODES``: A bitmask of the ``pipe_prim_type`` enum values that the driver can natively support. -* ``PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART``: A bitmask of the ``pipe_prim_type`` enum values that the driver can natively support for primitive restart. Only useful if ``PIPE_CAP_PRIMITIVE_RESTART`` is also exported. +* ``PIPE_CAP_SUPPORTED_PRIM_MODES``: A bitmask of the ``mesa_prim`` enum values that the driver can natively support. +* ``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. +* ``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. +* ``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. +* ``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 +* ``PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE``: Maximum 1D/2D/rectangle texture image dimension for a sparse texture. +* ``PIPE_CAP_MAX_SPARSE_3D_TEXTURE_SIZE``: Maximum 3D texture image dimension for a sparse texture. +* ``PIPE_CAP_MAX_SPARSE_ARRAY_TEXTURE_LAYERS``: Maximum number of layers in a sparse array texture. +* ``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. +* ``PIPE_CAP_QUERY_SPARSE_TEXTURE_RESIDENCY``: TRUE if shader sparse texture sample instruction could also return the residency information. +* ``PIPE_CAP_CLAMP_SPARSE_TEXTURE_LOD``: TRUE if shader sparse texture sample instruction support clamp the minimal lod to prevent read from uncommitted pages. +* ``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. +* ``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. +* ``PIPE_CAP_HARDWARE_GL_SELECT``: Enable hardware accelerated GL_SELECT for this driver. +* ``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). +* ``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. +* ``PIPE_CAP_NULL_TEXTURES`` : Whether the driver supports sampling from NULL textures. +* ``PIPE_CAP_ASTC_VOID_EXTENTS_NEED_DENORM_FLUSH`` : True if the driver/hardware needs denormalized values in ASTC void extent blocks flushed to zero. +* ``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. +* ``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. +* ``PIPE_CAP_PERFORMANCE_MONITOR``: Whether GL_AMD_performance_monitor should be exposed. + .. _pipe_capf: @@ -629,10 +659,16 @@ PIPE_CAPF_* The floating-point capabilities are: +* ``PIPE_CAPF_MIN_LINE_WIDTH``: The minimum width of a regular line. +* ``PIPE_CAPF_MIN_LINE_WIDTH_AA``: The minimum width of a smoothed line. * ``PIPE_CAPF_MAX_LINE_WIDTH``: The maximum width of a regular line. * ``PIPE_CAPF_MAX_LINE_WIDTH_AA``: The maximum width of a smoothed line. -* ``PIPE_CAPF_MAX_POINT_WIDTH``: The maximum width and height of a point. -* ``PIPE_CAPF_MAX_POINT_WIDTH_AA``: The maximum width and height of a smoothed point. +* ``PIPE_CAPF_LINE_WIDTH_GRANULARITY``: The line width is rounded to a multiple of this number. +* ``PIPE_CAPF_MIN_POINT_SIZE``: The minimum width and height of a point. +* ``PIPE_CAPF_MIN_POINT_SIZE_AA``: The minimum width and height of a smoothed point. +* ``PIPE_CAPF_MAX_POINT_SIZE``: The maximum width and height of a point. +* ``PIPE_CAPF_MAX_POINT_SIZE_AA``: The maximum width and height of a smoothed point. +* ``PIPE_CAPF_POINT_SIZE_GRANULARITY``: The point size is rounded to a multiple of this number. * ``PIPE_CAPF_MAX_TEXTURE_ANISOTROPY``: The maximum level of anisotropy that can be applied to anisotropically filtered textures. * ``PIPE_CAPF_MAX_TEXTURE_LOD_BIAS``: The maximum :term:`LOD` bias that may be applied @@ -661,21 +697,23 @@ support different features. * ``PIPE_SHADER_CAP_MAX_INPUTS``: The maximum number of input registers. * ``PIPE_SHADER_CAP_MAX_OUTPUTS``: The maximum number of output registers. This is valid for all shaders except the fragment shader. -* ``PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE``: The maximum size per constant buffer in bytes. +* ``PIPE_SHADER_CAP_MAX_CONST_BUFFER0_SIZE``: The maximum size of constant buffer 0 in bytes. * ``PIPE_SHADER_CAP_MAX_CONST_BUFFERS``: Maximum number of constant buffers that can be bound to any shader stage using ``set_constant_buffer``. If 0 or 1, the pipe will only permit binding one constant buffer per shader. -If a value greater than 0 is returned, the driver can have multiple -constant buffers bound to shader stages. The CONST register file is -accessed with two-dimensional indices, like in the example below. + If a value greater than 0 is returned, the driver can have multiple + constant buffers bound to shader stages. The CONST register file is + accessed with two-dimensional indices, like in the example below. -DCL CONST[0][0..7] # declare first 8 vectors of constbuf 0 -DCL CONST[3][0] # declare first vector of constbuf 3 -MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 + :: + + DCL CONST[0][0..7] # declare first 8 vectors of constbuf 0 + DCL CONST[3][0] # declare first vector of constbuf 3 + MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 * ``PIPE_SHADER_CAP_MAX_TEMPS``: The maximum number of temporary registers. -* ``PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED``: Whether the continue opcode is supported. +* ``PIPE_SHADER_CAP_CONT_SUPPORTED``: Whether continue is supported. * ``PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR``: Whether indirect addressing of the input file is supported. * ``PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR``: Whether indirect addressing @@ -704,23 +742,10 @@ MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 Note that 16-bit constants are not lowered to uniforms in GLSL. * ``PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS``: The maximum number of texture samplers. -* ``PIPE_SHADER_CAP_PREFERRED_IR``: Preferred representation of the - program. It should be one of the ``pipe_shader_ir`` enum values. * ``PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS``: The maximum number of texture sampler views. Must not be lower than PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS. -* ``PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED``: Whether double precision rounding - is supported. If it is, DTRUNC/DCEIL/DFLR/DROUND opcodes may be used. -* ``PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED``: Whether DFRACEXP and - DLDEXP are supported. -* ``PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED``: Whether LDEXP is supported. -* ``PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED``: Whether FMA and DFMA (doubles only) - are supported. * ``PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE``: Whether the driver doesn't ignore tgsi_declaration_range::Last for shader inputs and outputs. -* ``PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT``: This is the maximum number - of iterations that loops are allowed to have to be unrolled. It is only - a hint to gallium frontends. Whether any loops will be unrolled is not - guaranteed. * ``PIPE_SHADER_CAP_MAX_SHADER_BUFFERS``: Maximum number of memory buffers (also used to implement atomic counters). Having this be non-0 also implies support for the ``LOAD``, ``STORE``, and ``ATOM*`` TGSI @@ -728,13 +753,6 @@ MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 * ``PIPE_SHADER_CAP_SUPPORTED_IRS``: Supported representations of the program. It should be a mask of ``pipe_shader_ir`` bits. * ``PIPE_SHADER_CAP_MAX_SHADER_IMAGES``: Maximum number of image units. -* ``PIPE_SHADER_CAP_LOWER_IF_THRESHOLD``: IF and ELSE branches with a lower - cost than this value should be lowered by gallium frontends for better - performance. This is a tunable for the GLSL compiler and the behavior is - specific to the compiler. -* ``PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS``: Whether the merge registers - TGSI pass is skipped. This might reduce code size and register pressure if - the underlying driver has a real backend compiler. * ``PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS``: If atomic counters are separate, how many HW counters are available for this stage. (0 uses SSBO atomics). * ``PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS``: If atomic counters are @@ -778,10 +796,15 @@ pipe_screen::get_compute_param. clock in MHz. Value type: ``uint32_t`` * ``PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS``: Maximum number of compute units Value type: ``uint32_t`` +* ``PIPE_COMPUTE_CAP_MAX_SUBGROUPS``: The max amount of subgroups there can be + inside a block. Non 0 indicates support for OpenCL subgroups including + implementing ``get_compute_state_subgroup_size`` if multiple subgroup sizes + are supported. * ``PIPE_COMPUTE_CAP_IMAGES_SUPPORTED``: Whether images are supported non-zero means yes, zero means no. Value type: ``uint32_t`` -* ``PIPE_COMPUTE_CAP_SUBGROUP_SIZE``: The size of a basic execution unit in - threads. Also known as wavefront size, warp size or SIMD width. +* ``PIPE_COMPUTE_CAP_SUBGROUP_SIZES``: Ored power of two sizes of a basic execution + unit in threads. Also known as wavefront size, warp size or SIMD width. + E.g. ``64 | 32``. * ``PIPE_COMPUTE_CAP_ADDRESS_BITS``: The default compute device address space size specified as an unsigned integer value in bits. * ``PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK``: Maximum variable number @@ -796,7 +819,7 @@ PIPE_BIND_* These flags indicate how a resource will be used and are specified at resource creation time. Resources may be used in different roles -during their lifecycle. Bind flags are cumulative and may be combined to create +during their life cycle. Bind flags are cumulative and may be combined to create a resource which can be used for multiple things. Depending on the pipe driver's memory management and these bind flags, resources might be created and handled quite differently. @@ -822,7 +845,7 @@ resources might be created and handled quite differently. * ``PIPE_BIND_STREAM_OUTPUT``: A stream output buffer. * ``PIPE_BIND_CUSTOM``: * ``PIPE_BIND_SCANOUT``: A front color buffer or scanout buffer. -* ``PIPE_BIND_SHARED``: A sharable buffer that can be given to another +* ``PIPE_BIND_SHARED``: A shareable buffer that can be given to another process. * ``PIPE_BIND_GLOBAL``: A buffer that can be mapped into the global address space of a compute program. |