[Mesa-dev] [PATCH v2] radv: implement VK_EXT_sample_locations
Samuel Pitoiset
samuel.pitoiset at gmail.com
Mon Jun 24 09:02:32 UTC 2019
Thanks for the head-up Marek, I will update once I have hardware access.
On 6/21/19 7:33 PM, Marek Olšák wrote:
> Gfx10 remembers sample positions in compressed Z/S memory, so the hw
> doesn't need the decompress pass for shader loads.
>
> Marek
>
> On Wed, May 22, 2019 at 4:20 PM Marek Olšák <maraeo at gmail.com
> <mailto:maraeo at gmail.com>> wrote:
>
> The depth decompress pass needs to know the sample locations.
>
> If shader loads read from compressed depth, the texture hardware
> will always use the standard locations for decompression.
>
> Marek
>
> On Tue, May 21, 2019 at 8:17 PM Bas Nieuwenhuizen
> <bas at basnieuwenhuizen.nl <mailto:bas at basnieuwenhuizen.nl>> wrote:
>
> So this does not seem to use the sample locations during
> layout transitions?
>
> AFAIK those are needed for e.g. HTILE decompression as it is
> based on
> equations somehow.
>
> On Thu, May 16, 2019 at 11:51 AM Samuel Pitoiset
> <samuel.pitoiset at gmail.com <mailto:samuel.pitoiset at gmail.com>>
> wrote:
> >
> > Basically, this extension allows applications to use custom
> > sample locations. It doesn't support variable sample locations
> > during subpass. Note that we don't have to upload the user
> > sample locations because the spec doesn't allow this.
> >
> > Only enabled on VI+ because it's untested on older chips.
> >
> > v2: - change sampleLocationCoordinateRange[1] to 0.9375
> > - compute and emit PA_SC_CENTROID_PRIORITY_{0,1}
> > - rebased on top of master
> > - some cleanups
> >
> > Signed-off-by: Samuel Pitoiset <samuel.pitoiset at gmail.com
> <mailto:samuel.pitoiset at gmail.com>>
> > ---
> > src/amd/vulkan/radv_cmd_buffer.c | 223
> ++++++++++++++++++++++++++++++
> > src/amd/vulkan/radv_device.c | 27 ++++
> > src/amd/vulkan/radv_extensions.py | 1 +
> > src/amd/vulkan/radv_pipeline.c | 30 ++++
> > src/amd/vulkan/radv_private.h | 26 +++-
> > 5 files changed, 300 insertions(+), 7 deletions(-)
> >
> > diff --git a/src/amd/vulkan/radv_cmd_buffer.c
> b/src/amd/vulkan/radv_cmd_buffer.c
> > index 4f592bc7f68..fb79c1c6713 100644
> > --- a/src/amd/vulkan/radv_cmd_buffer.c
> > +++ b/src/amd/vulkan/radv_cmd_buffer.c
> > @@ -105,6 +105,7 @@ radv_bind_dynamic_state(struct
> radv_cmd_buffer *cmd_buffer,
> > dest->viewport.count = src->viewport.count;
> > dest->scissor.count = src->scissor.count;
> > dest->discard_rectangle.count =
> src->discard_rectangle.count;
> > + dest->sample_location.count =
> src->sample_location.count;
> >
> > if (copy_mask & RADV_DYNAMIC_VIEWPORT) {
> > if (memcmp(&dest->viewport.viewports,
> &src->viewport.viewports,
> > @@ -192,6 +193,22 @@ radv_bind_dynamic_state(struct
> radv_cmd_buffer *cmd_buffer,
> > }
> > }
> >
> > + if (copy_mask & RADV_DYNAMIC_SAMPLE_LOCATIONS) {
> > + if (dest->sample_location.per_pixel !=
> src->sample_location.per_pixel ||
> > + dest->sample_location.grid_size.width !=
> src->sample_location.grid_size.width ||
> > + dest->sample_location.grid_size.height !=
> src->sample_location.grid_size.height ||
> > + memcmp(&dest->sample_location.locations,
> > + &src->sample_location.locations,
> > + src->sample_location.count * sizeof(VkSampleLocationEXT))) {
> > + dest->sample_location.per_pixel =
> src->sample_location.per_pixel;
> > + dest->sample_location.grid_size =
> src->sample_location.grid_size;
> > + typed_memcpy(dest->sample_location.locations,
> > + src->sample_location.locations,
> > + src->sample_location.count);
> > + dest_mask |=
> RADV_DYNAMIC_SAMPLE_LOCATIONS;
> > + }
> > + }
> > +
> > cmd_buffer->state.dirty |= dest_mask;
> > }
> >
> > @@ -632,6 +649,190 @@ radv_emit_descriptor_pointers(struct
> radv_cmd_buffer *cmd_buffer,
> > }
> > }
> >
> > +/**
> > + * Convert the user sample locations to hardware sample
> locations (the values
> > + * that will be emitted by PA_SC_AA_SAMPLE_LOCS_PIXEL_*).
> > + */
> > +static void
> > +radv_convert_user_sample_locs(struct
> radv_sample_locations_state *state,
> > + uint32_t x, uint32_t y,
> VkOffset2D *sample_locs)
> > +{
> > + uint32_t x_offset = x % state->grid_size.width;
> > + uint32_t y_offset = y % state->grid_size.height;
> > + uint32_t num_samples = (uint32_t)state->per_pixel;
> > + VkSampleLocationEXT *user_locs;
> > + uint32_t pixel_offset;
> > +
> > + pixel_offset = (x_offset + y_offset *
> state->grid_size.width) * num_samples;
> > +
> > + assert(pixel_offset <= MAX_SAMPLE_LOCATIONS);
> > + user_locs = &state->locations[pixel_offset];
> > +
> > + for (uint32_t i = 0; i < num_samples; i++) {
> > + float shifted_pos_x = user_locs[i].x - 0.5;
> > + float shifted_pos_y = user_locs[i].y - 0.5;
> > +
> > + int32_t scaled_pos_x = floor(shifted_pos_x *
> 16);
> > + int32_t scaled_pos_y = floor(shifted_pos_y *
> 16);
> > +
> > + sample_locs[i].x = CLAMP(scaled_pos_x, -8, 7);
> > + sample_locs[i].y = CLAMP(scaled_pos_y, -8, 7);
> > + }
> > +}
> > +
> > +/**
> > + * Compute the PA_SC_AA_SAMPLE_LOCS_PIXEL_* mask based on
> hardware sample
> > + * locations.
> > + */
> > +static void
> > +radv_compute_sample_locs_pixel(uint32_t num_samples,
> VkOffset2D *sample_locs,
> > + uint32_t *sample_locs_pixel)
> > +{
> > + for (uint32_t i = 0; i < num_samples; i++) {
> > + uint32_t sample_reg_idx = i / 4;
> > + uint32_t sample_loc_idx = i % 4;
> > + int32_t pos_x = sample_locs[i].x;
> > + int32_t pos_y = sample_locs[i].y;
> > +
> > + uint32_t shift_x = 8 * sample_loc_idx;
> > + uint32_t shift_y = shift_x + 4;
> > +
> > + sample_locs_pixel[sample_reg_idx] |= (pos_x
> & 0xf) << shift_x;
> > + sample_locs_pixel[sample_reg_idx] |= (pos_y
> & 0xf) << shift_y;
> > + }
> > +}
> > +
> > +/**
> > + * Compute the PA_SC_CENTROID_PRIORITY_* mask based on the
> top left hardware
> > + * sample locations.
> > + */
> > +static uint64_t
> > +radv_compute_centroid_priority(struct radv_cmd_buffer
> *cmd_buffer,
> > + VkOffset2D *sample_locs,
> > + uint32_t num_samples)
> > +{
> > + uint32_t centroid_priorities[num_samples];
> > + uint32_t sample_mask = num_samples - 1;
> > + uint32_t distances[num_samples];
> > + uint64_t centroid_priority = 0;
> > +
> > + /* Compute the distances from center for each sample. */
> > + for (int i = 0; i < num_samples; i++) {
> > + distances[i] = (sample_locs[i].x *
> sample_locs[i].x) +
> > + (sample_locs[i].y *
> sample_locs[i].y);
> > + }
> > +
> > + /* Compute the centroid priorities by looking at the
> distances array. */
> > + for (int i = 0; i < num_samples; i++) {
> > + uint32_t min_idx = 0;
> > +
> > + for (int j = 1; j < num_samples; j++) {
> > + if (distances[j] < distances[min_idx])
> > + min_idx = j;
> > + }
> > +
> > + centroid_priorities[i] = min_idx;
> > + distances[min_idx] = 0xffffffff;
> > + }
> > +
> > + /* Compute the final centroid priority. */
> > + for (int i = 0; i < 8; i++) {
> > + centroid_priority |=
> > + centroid_priorities[i & sample_mask]
> << (i * 4);
> > + }
> > +
> > + return centroid_priority << 32 | centroid_priority;
> > +}
> > +
> > +/**
> > + * Emit the sample locations that are specified with
> VK_EXT_sample_locations.
> > + */
> > +static void
> > +radv_emit_sample_locations(struct radv_cmd_buffer *cmd_buffer)
> > +{
> > + struct radv_pipeline *pipeline =
> cmd_buffer->state.pipeline;
> > + struct radv_multisample_state *ms =
> &pipeline->graphics.ms <http://graphics.ms>;
> > + struct radv_sample_locations_state *sample_location =
> > + &cmd_buffer->state.dynamic.sample_location;
> > + uint32_t num_samples =
> (uint32_t)sample_location->per_pixel;
> > + struct radeon_cmdbuf *cs = cmd_buffer->cs;
> > + uint32_t sample_locs_pixel[4][2] = {};
> > + VkOffset2D sample_locs[4][8]; /* 8 is the max.
> sample count supported */
> > + uint32_t max_sample_dist = 0;
> > + uint64_t centroid_priority;
> > +
> > + if (!cmd_buffer->state.dynamic.sample_location.count)
> > + return;
> > +
> > + /* Convert the user sample locations to hardware
> sample locations. */
> > + radv_convert_user_sample_locs(sample_location, 0, 0,
> sample_locs[0]);
> > + radv_convert_user_sample_locs(sample_location, 1, 0,
> sample_locs[1]);
> > + radv_convert_user_sample_locs(sample_location, 0, 1,
> sample_locs[2]);
> > + radv_convert_user_sample_locs(sample_location, 1, 1,
> sample_locs[3]);
> > +
> > + /* Compute the PA_SC_AA_SAMPLE_LOCS_PIXEL_* mask. */
> > + for (uint32_t i = 0; i < 4; i++) {
> > + radv_compute_sample_locs_pixel(num_samples, sample_locs[i],
> > + sample_locs_pixel[i]);
> > + }
> > +
> > + /* Compute the PA_SC_CENTROID_PRIORITY_* mask. */
> > + centroid_priority =
> > + radv_compute_centroid_priority(cmd_buffer, sample_locs[0],
> > + num_samples);
> > +
> > + /* Compute the maximum sample distance from the
> specified locations. */
> > + for (uint32_t i = 0; i < num_samples; i++) {
> > + VkOffset2D offset = sample_locs[0][i];
> > + max_sample_dist = MAX2(max_sample_dist,
> > + MAX2(abs(offset.x), abs(offset.y)));
> > + }
> > +
> > + /* Emit the specified user sample locations. */
> > + switch (num_samples) {
> > + case 2:
> > + case 4:
> > + radeon_set_context_reg(cs,
> R_028BF8_PA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y0_0,
> sample_locs_pixel[0][0]);
> > + radeon_set_context_reg(cs,
> R_028C08_PA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y0_0,
> sample_locs_pixel[1][0]);
> > + radeon_set_context_reg(cs,
> R_028C18_PA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y1_0,
> sample_locs_pixel[2][0]);
> > + radeon_set_context_reg(cs,
> R_028C28_PA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y1_0,
> sample_locs_pixel[3][0]);
> > + break;
> > + case 8:
> > + radeon_set_context_reg(cs,
> R_028BF8_PA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y0_0,
> sample_locs_pixel[0][0]);
> > + radeon_set_context_reg(cs,
> R_028C08_PA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y0_0,
> sample_locs_pixel[1][0]);
> > + radeon_set_context_reg(cs,
> R_028C18_PA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y1_0,
> sample_locs_pixel[2][0]);
> > + radeon_set_context_reg(cs,
> R_028C28_PA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y1_0,
> sample_locs_pixel[3][0]);
> > + radeon_set_context_reg(cs,
> R_028BFC_PA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y0_1,
> sample_locs_pixel[0][1]);
> > + radeon_set_context_reg(cs,
> R_028C0C_PA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y0_1,
> sample_locs_pixel[1][1]);
> > + radeon_set_context_reg(cs,
> R_028C1C_PA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y1_1,
> sample_locs_pixel[2][1]);
> > + radeon_set_context_reg(cs,
> R_028C2C_PA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y1_1,
> sample_locs_pixel[3][1]);
> > + break;
> > + default:
> > + unreachable("invalid number of samples");
> > + }
> > +
> > + /* Emit the maximum sample distance and the centroid
> priority. */
> > + uint32_t pa_sc_aa_config = ms->pa_sc_aa_config;
> > +
> > + pa_sc_aa_config &= C_028BE0_MAX_SAMPLE_DIST;
> > + pa_sc_aa_config |=
> S_028BE0_MAX_SAMPLE_DIST(max_sample_dist);
> > +
> > + radeon_set_context_reg_seq(cs,
> R_028BE0_PA_SC_AA_CONFIG, 1);
> > + radeon_emit(cs, pa_sc_aa_config);
> > +
> > + radeon_set_context_reg_seq(cs,
> R_028BD4_PA_SC_CENTROID_PRIORITY_0, 2);
> > + radeon_emit(cs, centroid_priority);
> > + radeon_emit(cs, centroid_priority >> 32);
> > +
> > + /* GFX9: Flush DFSM when the AA mode changes. */
> > + if (cmd_buffer->device->dfsm_allowed) {
> > + radeon_emit(cs, PKT3(PKT3_EVENT_WRITE, 0, 0));
> > + radeon_emit(cs,
> EVENT_TYPE(V_028A90_FLUSH_DFSM) | EVENT_INDEX(0));
> > + }
> > +
> > + cmd_buffer->state.context_roll_without_scissor_emitted =
> true;
> > +}
> > +
> > static void
> > radv_emit_inline_push_consts(struct radv_cmd_buffer
> *cmd_buffer,
> > struct radv_pipeline *pipeline,
> > @@ -1775,6 +1976,9 @@
> radv_cmd_buffer_flush_dynamic_state(struct radv_cmd_buffer
> *cmd_buffer)
> > if (states & RADV_CMD_DIRTY_DYNAMIC_DISCARD_RECTANGLE)
> > radv_emit_discard_rectangle(cmd_buffer);
> >
> > + if (states & RADV_CMD_DIRTY_DYNAMIC_SAMPLE_LOCATIONS)
> > + radv_emit_sample_locations(cmd_buffer);
> > +
> > cmd_buffer->state.dirty &= ~states;
> > }
> >
> > @@ -3266,6 +3470,25 @@ void radv_CmdSetDiscardRectangleEXT(
> > state->dirty |=
> RADV_CMD_DIRTY_DYNAMIC_DISCARD_RECTANGLE;
> > }
> >
> > +void radv_CmdSetSampleLocationsEXT(
> > + VkCommandBuffer commandBuffer,
> > + const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
> > +{
> > + RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer,
> commandBuffer);
> > + struct radv_cmd_state *state = &cmd_buffer->state;
> > +
> > + assert(pSampleLocationsInfo->sampleLocationsCount <=
> MAX_SAMPLE_LOCATIONS);
> > +
> > + state->dynamic.sample_location.per_pixel =
> pSampleLocationsInfo->sampleLocationsPerPixel;
> > + state->dynamic.sample_location.grid_size =
> pSampleLocationsInfo->sampleLocationGridSize;
> > + state->dynamic.sample_location.count =
> pSampleLocationsInfo->sampleLocationsCount;
> > + typed_memcpy(&state->dynamic.sample_location.locations[0],
> > + pSampleLocationsInfo->pSampleLocations,
> > + pSampleLocationsInfo->sampleLocationsCount);
> > +
> > + state->dirty |= RADV_CMD_DIRTY_DYNAMIC_SAMPLE_LOCATIONS;
> > +}
> > +
> > void radv_CmdExecuteCommands(
> > VkCommandBuffer commandBuffer,
> > uint32_t commandBufferCount,
> > diff --git a/src/amd/vulkan/radv_device.c
> b/src/amd/vulkan/radv_device.c
> > index c0e317a97e5..e523bba1223 100644
> > --- a/src/amd/vulkan/radv_device.c
> > +++ b/src/amd/vulkan/radv_device.c
> > @@ -1360,6 +1360,19 @@ void radv_GetPhysicalDeviceProperties2(
> > props->maxDescriptorSetUpdateAfterBindInlineUniformBlocks =
> MAX_INLINE_UNIFORM_BLOCK_COUNT;
> > break;
> > }
> > + case
> VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
> {
> > + VkPhysicalDeviceSampleLocationsPropertiesEXT *properties =
> > + (VkPhysicalDeviceSampleLocationsPropertiesEXT *)ext;
> > + properties->sampleLocationSampleCounts =
> VK_SAMPLE_COUNT_2_BIT |
> > + VK_SAMPLE_COUNT_4_BIT |
> > + VK_SAMPLE_COUNT_8_BIT;
> > + properties->maxSampleLocationGridSize = (VkExtent2D){ 2 ,
> 2 };
> > + properties->sampleLocationCoordinateRange[0] = 0.0f;
> > + properties->sampleLocationCoordinateRange[1] = 0.9375f;
> > + properties->sampleLocationSubPixelBits = 4;
> > + properties->variableSampleLocations = VK_FALSE;
> > + break;
> > + }
> > default:
> > break;
> > }
> > @@ -5361,3 +5374,17 @@ VkResult radv_GetCalibratedTimestampsEXT(
> >
> > return VK_SUCCESS;
> > }
> > +
> > +void radv_GetPhysicalDeviceMultisamplePropertiesEXT(
> > + VkPhysicalDevice physicalDevice,
> > + VkSampleCountFlagBits samples,
> > + VkMultisamplePropertiesEXT* pMultisampleProperties)
> > +{
> > + if (samples & (VK_SAMPLE_COUNT_2_BIT |
> > + VK_SAMPLE_COUNT_4_BIT |
> > + VK_SAMPLE_COUNT_8_BIT)) {
> > + pMultisampleProperties->maxSampleLocationGridSize =
> (VkExtent2D){ 2, 2 };
> > + } else {
> > + pMultisampleProperties->maxSampleLocationGridSize =
> (VkExtent2D){ 0, 0 };
> > + }
> > +}
> > diff --git a/src/amd/vulkan/radv_extensions.py
> b/src/amd/vulkan/radv_extensions.py
> > index 0b5af56a435..2c2c4dc74d2 100644
> > --- a/src/amd/vulkan/radv_extensions.py
> > +++ b/src/amd/vulkan/radv_extensions.py
> > @@ -119,6 +119,7 @@ EXTENSIONS = [
> > Extension('VK_EXT_memory_priority', 1, True),
> > Extension('VK_EXT_pci_bus_info', 2, True),
> > Extension('VK_EXT_pipeline_creation_feedback', 1, True),
> > + Extension('VK_EXT_sample_locations', 1,
> 'device->rad_info.chip_class >= GFX8'),
> > Extension('VK_EXT_sampler_filter_minmax', 1,
> 'device->rad_info.chip_class >= GFX7'),
> > Extension('VK_EXT_scalar_block_layout', 1,
> 'device->rad_info.chip_class >= GFX7'),
> > Extension('VK_EXT_shader_viewport_index_layer', 1, True),
> > diff --git a/src/amd/vulkan/radv_pipeline.c
> b/src/amd/vulkan/radv_pipeline.c
> > index 56fd65bec29..7f8e00b5c3c 100644
> > --- a/src/amd/vulkan/radv_pipeline.c
> > +++ b/src/amd/vulkan/radv_pipeline.c
> > @@ -1267,6 +1267,8 @@ static unsigned
> radv_dynamic_state_mask(VkDynamicState state)
> > return RADV_DYNAMIC_STENCIL_REFERENCE;
> > case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
> > return RADV_DYNAMIC_DISCARD_RECTANGLE;
> > + case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
> > + return RADV_DYNAMIC_SAMPLE_LOCATIONS;
> > default:
> > unreachable("Unhandled dynamic state");
> > }
> > @@ -1297,6 +1299,11 @@ static uint32_t
> radv_pipeline_needed_dynamic_state(const VkGraphicsPipelineCreat
> > if (!vk_find_struct_const(pCreateInfo->pNext,
> PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT))
> > states &= ~RADV_DYNAMIC_DISCARD_RECTANGLE;
> >
> > + if (!pCreateInfo->pMultisampleState ||
> > + !vk_find_struct_const(pCreateInfo->pMultisampleState->pNext,
> > + PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT))
> > + states &= ~RADV_DYNAMIC_SAMPLE_LOCATIONS;
> > +
> > /* TODO: blend constants & line width. */
> >
> > return states;
> > @@ -1426,6 +1433,29 @@
> radv_pipeline_init_dynamic_state(struct radv_pipeline *pipeline,
> > }
> > }
> >
> > + if (needed_states & RADV_DYNAMIC_SAMPLE_LOCATIONS) {
> > + const
> VkPipelineSampleLocationsStateCreateInfoEXT
> *sample_location_info =
> > + vk_find_struct_const(pCreateInfo->pMultisampleState->pNext,
> > + PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT);
> > + /* If sampleLocationsEnable is VK_FALSE, the
> default sample
> > + * locations are used and the values
> specified in
> > + * sampleLocationsInfo are ignored.
> > + */
> > + if
> (sample_location_info->sampleLocationsEnable) {
> > + const VkSampleLocationsInfoEXT
> *pSampleLocationsInfo =
> > + &sample_location_info->sampleLocationsInfo;
> > +
> > + assert(pSampleLocationsInfo->sampleLocationsCount <=
> MAX_SAMPLE_LOCATIONS);
> > +
> > + dynamic->sample_location.per_pixel =
> pSampleLocationsInfo->sampleLocationsPerPixel;
> > + dynamic->sample_location.grid_size =
> pSampleLocationsInfo->sampleLocationGridSize;
> > + dynamic->sample_location.count =
> pSampleLocationsInfo->sampleLocationsCount;
> > + typed_memcpy(&dynamic->sample_location.locations[0],
> > + pSampleLocationsInfo->pSampleLocations,
> > + pSampleLocationsInfo->sampleLocationsCount);
> > + }
> > + }
> > +
> > pipeline->dynamic_state.mask = states;
> > }
> >
> > diff --git a/src/amd/vulkan/radv_private.h
> b/src/amd/vulkan/radv_private.h
> > index 7834a505562..5c84bf74352 100644
> > --- a/src/amd/vulkan/radv_private.h
> > +++ b/src/amd/vulkan/radv_private.h
> > @@ -91,6 +91,7 @@ typedef uint32_t xcb_window_t;
> > #define MAX_VIEWPORTS 16
> > #define MAX_SCISSORS 16
> > #define MAX_DISCARD_RECTANGLES 4
> > +#define MAX_SAMPLE_LOCATIONS 32
> > #define MAX_PUSH_CONSTANTS_SIZE 128
> > #define MAX_PUSH_DESCRIPTORS 32
> > #define MAX_DYNAMIC_UNIFORM_BUFFERS 16
> > @@ -852,7 +853,8 @@ enum radv_dynamic_state_bits {
> > RADV_DYNAMIC_STENCIL_WRITE_MASK = 1 << 7,
> > RADV_DYNAMIC_STENCIL_REFERENCE = 1 << 8,
> > RADV_DYNAMIC_DISCARD_RECTANGLE = 1 << 9,
> > - RADV_DYNAMIC_ALL = (1 << 10) - 1,
> > + RADV_DYNAMIC_SAMPLE_LOCATIONS = 1 << 10,
> > + RADV_DYNAMIC_ALL = (1 << 11) - 1,
> > };
> >
> > enum radv_cmd_dirty_bits {
> > @@ -868,12 +870,13 @@ enum radv_cmd_dirty_bits {
> > RADV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK = 1 << 7,
> > RADV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE = 1
> << 8,
> > RADV_CMD_DIRTY_DYNAMIC_DISCARD_RECTANGLE = 1
> << 9,
> > - RADV_CMD_DIRTY_DYNAMIC_ALL = (1 << 10) - 1,
> > - RADV_CMD_DIRTY_PIPELINE = 1 << 10,
> > - RADV_CMD_DIRTY_INDEX_BUFFER = 1 << 11,
> > - RADV_CMD_DIRTY_FRAMEBUFFER = 1 << 12,
> > - RADV_CMD_DIRTY_VERTEX_BUFFER = 1 << 13,
> > - RADV_CMD_DIRTY_STREAMOUT_BUFFER = 1 << 14,
> > + RADV_CMD_DIRTY_DYNAMIC_SAMPLE_LOCATIONS = 1
> << 10,
> > + RADV_CMD_DIRTY_DYNAMIC_ALL = (1 << 11) - 1,
> > + RADV_CMD_DIRTY_PIPELINE = 1 << 11,
> > + RADV_CMD_DIRTY_INDEX_BUFFER = 1 << 12,
> > + RADV_CMD_DIRTY_FRAMEBUFFER = 1 << 13,
> > + RADV_CMD_DIRTY_VERTEX_BUFFER = 1 << 14,
> > + RADV_CMD_DIRTY_STREAMOUT_BUFFER = 1 << 15,
> > };
> >
> > enum radv_cmd_flush_bits {
> > @@ -950,6 +953,13 @@ struct radv_discard_rectangle_state {
> > VkRect2D rectangles[MAX_DISCARD_RECTANGLES];
> > };
> >
> > +struct radv_sample_locations_state {
> > + VkSampleCountFlagBits per_pixel;
> > + VkExtent2D grid_size;
> > + uint32_t count;
> > + VkSampleLocationEXT locations[MAX_SAMPLE_LOCATIONS];
> > +};
> > +
> > struct radv_dynamic_state {
> > /**
> > * Bitmask of (1 << VK_DYNAMIC_STATE_*).
> > @@ -992,6 +1002,8 @@ struct radv_dynamic_state {
> > } stencil_reference;
> >
> > struct radv_discard_rectangle_state
> discard_rectangle;
> > +
> > + struct radv_sample_locations_state
> sample_location;
> > };
> >
> > extern const struct radv_dynamic_state default_dynamic_state;
> > --
> > 2.21.0
> >
> > _______________________________________________
> > mesa-dev mailing list
> > mesa-dev at lists.freedesktop.org
> <mailto:mesa-dev at lists.freedesktop.org>
> > https://lists.freedesktop.org/mailman/listinfo/mesa-dev
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> <mailto:mesa-dev at lists.freedesktop.org>
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.freedesktop.org/archives/mesa-dev/attachments/20190624/5ee509cc/attachment-0001.html>
More information about the mesa-dev
mailing list