src/vulkan/meta.c

   1 /*
   2  * Copyright © 2015 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include <assert.h>
  25 #include <stdbool.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29
  30 #include "private.h"
  31
  32 #define GLSL(src) "#version 330\n" #src
  33
  34 static void
  35 anv_device_init_meta_clear_state(struct anv_device *device)
  36 {
  37    VkPipelineIaStateCreateInfo ia_create_info = {
  38       .sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO,
  39       .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
  40       .disableVertexReuse = false,
  41       .primitiveRestartEnable = false,
  42       .primitiveRestartIndex = 0
  43    };
  44
  45    /* We don't use a vertex shader for clearing, but instead build and pass
  46     * the VUEs directly to the rasterization backend.
  47     */
  48    static const char fs_source[] = GLSL(
  49       out vec4 f_color;
  50       flat in vec4 v_color;
  51       void main()
  52       {
  53          f_color = v_color;
  54       });
  55
  56    VkShader fs;
  57    vkCreateShader((VkDevice) device,
  58                   &(VkShaderCreateInfo) {
  59                      .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,
  60                      .codeSize = sizeof(fs_source),
  61                      .pCode = fs_source,
  62                      .flags = 0
  63                   },
  64                   &fs);
  65
  66    VkPipelineShaderStageCreateInfo fs_create_info = {
  67       .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
  68       .pNext = &ia_create_info,
  69       .shader = {
  70          .stage = VK_SHADER_STAGE_FRAGMENT,
  71          .shader = fs,
  72          .linkConstBufferCount = 0,
  73          .pLinkConstBufferInfo = NULL,
  74          .pSpecializationInfo = NULL
  75       }
  76    };
  77
  78    /* We use instanced rendering to clear multiple render targets. We have two
  79     * vertex buffers: the first vertex buffer holds per-vertex data and
  80     * provides the vertices for the clear rectangle. The second one holds
  81     * per-instance data, which consists of the VUE header (which selects the
  82     * layer) and the color (Vulkan supports per-RT clear colors).
  83     */
  84    VkPipelineVertexInputCreateInfo vi_create_info = {
  85       .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO,
  86       .pNext = &fs_create_info,
  87       .bindingCount = 2,
  88       .pVertexBindingDescriptions = (VkVertexInputBindingDescription[]) {
  89          {
  90             .binding = 0,
  91             .strideInBytes = 8,
  92             .stepRate = VK_VERTEX_INPUT_STEP_RATE_VERTEX
  93          },
  94          {
  95             .binding = 1,
  96             .strideInBytes = 32,
  97             .stepRate = VK_VERTEX_INPUT_STEP_RATE_INSTANCE
  98          },
  99       },
 100       .attributeCount = 3,
 101       .pVertexAttributeDescriptions = (VkVertexInputAttributeDescription[]) {
 102          {
 103             /* VUE Header */
 104             .location = 0,
 105             .binding = 1,
 106             .format = VK_FORMAT_R32G32B32A32_UINT,
 107             .offsetInBytes = 0
 108          },
 109          {
 110             /* Position */
 111             .location = 1,
 112             .binding = 0,
 113             .format = VK_FORMAT_R32G32_SFLOAT,
 114             .offsetInBytes = 0
 115          },
 116          {
 117             /* Color */
 118             .location = 2,
 119             .binding = 1,
 120             .format = VK_FORMAT_R32G32B32A32_SFLOAT,
 121             .offsetInBytes = 16
 122          }
 123       }
 124    };
 125
 126    VkPipelineRsStateCreateInfo rs_create_info = {
 127       .sType = VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO,
 128       .pNext = &vi_create_info,
 129       .depthClipEnable = true,
 130       .rasterizerDiscardEnable = false,
 131       .fillMode = VK_FILL_MODE_SOLID,
 132       .cullMode = VK_CULL_MODE_NONE,
 133       .frontFace = VK_FRONT_FACE_CCW
 134    };
 135
 136    anv_pipeline_create((VkDevice) device,
 137                        &(VkGraphicsPipelineCreateInfo) {
 138                           .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
 139                           .pNext = &rs_create_info,
 140                           .flags = 0,
 141                           .layout = 0
 142                        },
 143                        &(struct anv_pipeline_create_info) {
 144                           .use_repclear = true,
 145                           .disable_viewport = true,
 146                           .use_rectlist = true
 147                        },
 148                        &device->clear_state.pipeline);
 149
 150    vkDestroyObject((VkDevice) device, VK_OBJECT_TYPE_SHADER, fs);
 151
 152    vkCreateDynamicRasterState((VkDevice) device,
 153                               &(VkDynamicRsStateCreateInfo) {
 154                                  .sType = VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO,
 155                               },
 156                               &device->clear_state.rs_state);
 157 }
 158
 159 struct anv_saved_state {
 160    struct {
 161       struct anv_buffer *buffer;
 162       VkDeviceSize offset;
 163    } vb[2];
 164    struct anv_pipeline *pipeline;
 165 };
 166
 167 static void
 168 anv_cmd_buffer_save(struct anv_cmd_buffer *cmd_buffer, struct anv_saved_state *state)
 169 {
 170    memcpy(state->vb, cmd_buffer->vb, sizeof(state->vb));
 171    state->pipeline = cmd_buffer->pipeline;
 172 }
 173
 174 static void
 175 anv_cmd_buffer_restore(struct anv_cmd_buffer *cmd_buffer, struct anv_saved_state *state)
 176 {
 177    memcpy(cmd_buffer->vb, state->vb, sizeof(state->vb));
 178    cmd_buffer->pipeline = state->pipeline;
 179
 180    cmd_buffer->vb_dirty |= (1 << ARRAY_SIZE(state->vb)) - 1;
 181    cmd_buffer->dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY;
 182 }
 183
 184 void
 185 anv_cmd_buffer_clear(struct anv_cmd_buffer *cmd_buffer,
 186                      struct anv_render_pass *pass)
 187 {
 188    struct anv_device *device = cmd_buffer->device;
 189    struct anv_framebuffer *fb = cmd_buffer->framebuffer;
 190    struct anv_saved_state saved_state;
 191    struct anv_state state;
 192    uint32_t size;
 193
 194    struct instance_data {
 195       struct {
 196          uint32_t Reserved;
 197          uint32_t RTAIndex;
 198          uint32_t ViewportIndex;
 199          float PointWidth;
 200       } vue_header;
 201       float color[4];
 202    } *instance_data;
 203
 204    const float vertex_data[] = {
 205       /* Rect-list coordinates */
 206             0.0,        0.0,
 207       fb->width,        0.0,
 208       fb->width, fb->height,
 209
 210       /* Align to 16 bytes */
 211             0.0,        0.0,
 212    };
 213
 214    size = sizeof(vertex_data) + pass->num_clear_layers * sizeof(instance_data[0]);
 215    state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, size, 16);
 216
 217    memcpy(state.map, vertex_data, sizeof(vertex_data));
 218    instance_data = state.map + sizeof(vertex_data);
 219
 220    for (uint32_t i = 0; i < pass->num_layers; i++) {
 221       if (pass->layers[i].color_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) {
 222          *instance_data++ = (struct instance_data) {
 223             .vue_header = {
 224                .RTAIndex = i,
 225                .ViewportIndex = 0,
 226                .PointWidth = 0.0
 227             },
 228             .color = {
 229                pass->layers[i].clear_color.color.floatColor[0],
 230                pass->layers[i].clear_color.color.floatColor[1],
 231                pass->layers[i].clear_color.color.floatColor[2],
 232                pass->layers[i].clear_color.color.floatColor[3],
 233             }
 234          };
 235       }
 236    }
 237
 238    struct anv_buffer vertex_buffer = {
 239       .device = cmd_buffer->device,
 240       .size = size,
 241       .bo = &device->surface_state_block_pool.bo,
 242       .offset = state.offset
 243    };
 244
 245    anv_cmd_buffer_save(cmd_buffer, &saved_state);
 246
 247    vkCmdBindVertexBuffers((VkCmdBuffer) cmd_buffer, 0, 2,
 248                           (VkBuffer[]) {
 249                              (VkBuffer) &vertex_buffer,
 250                              (VkBuffer) &vertex_buffer
 251                           },
 252                           (VkDeviceSize[]) {
 253                              0,
 254                              sizeof(vertex_data)
 255                           });
 256
 257    if ((VkPipeline) cmd_buffer->pipeline != device->clear_state.pipeline)
 258       vkCmdBindPipeline((VkCmdBuffer) cmd_buffer,
 259                         VK_PIPELINE_BIND_POINT_GRAPHICS, device->clear_state.pipeline);
 260
 261    /* We don't need anything here, only set if not already set. */
 262    if (cmd_buffer->rs_state == NULL)
 263       vkCmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 264                                   VK_STATE_BIND_POINT_RASTER,
 265                                   device->clear_state.rs_state);
 266
 267    if (cmd_buffer->vp_state == NULL)
 268       vkCmdBindDynamicStateObject((VkCmdBuffer) cmd_buffer,
 269                                   VK_STATE_BIND_POINT_VIEWPORT,
 270                                   cmd_buffer->framebuffer->vp_state);
 271
 272    vkCmdDraw((VkCmdBuffer) cmd_buffer, 0, 3, 0, pass->num_clear_layers);
 273
 274    /* Restore API state */
 275    anv_cmd_buffer_restore(cmd_buffer, &saved_state);
 276
 277 }
 278
 279 void VKAPI vkCmdCopyBuffer(
 280     VkCmdBuffer                                 cmdBuffer,
 281     VkBuffer                                    srcBuffer,
 282     VkBuffer                                    destBuffer,
 283     uint32_t                                    regionCount,
 284     const VkBufferCopy*                         pRegions)
 285 {
 286    stub();
 287 }
 288
 289 void VKAPI vkCmdCopyImage(
 290     VkCmdBuffer                                 cmdBuffer,
 291     VkImage                                     srcImage,
 292     VkImageLayout                               srcImageLayout,
 293     VkImage                                     destImage,
 294     VkImageLayout                               destImageLayout,
 295     uint32_t                                    regionCount,
 296     const VkImageCopy*                          pRegions)
 297 {
 298    stub();
 299 }
 300
 301 void VKAPI vkCmdBlitImage(
 302     VkCmdBuffer                                 cmdBuffer,
 303     VkImage                                     srcImage,
 304     VkImageLayout                               srcImageLayout,
 305     VkImage                                     destImage,
 306     VkImageLayout                               destImageLayout,
 307     uint32_t                                    regionCount,
 308     const VkImageBlit*                          pRegions)
 309 {
 310    stub();
 311 }
 312
 313 void VKAPI vkCmdCopyBufferToImage(
 314     VkCmdBuffer                                 cmdBuffer,
 315     VkBuffer                                    srcBuffer,
 316     VkImage                                     destImage,
 317     VkImageLayout                               destImageLayout,
 318     uint32_t                                    regionCount,
 319     const VkBufferImageCopy*                    pRegions)
 320 {
 321    stub();
 322 }
 323
 324 void VKAPI vkCmdCopyImageToBuffer(
 325     VkCmdBuffer                                 cmdBuffer,
 326     VkImage                                     srcImage,
 327     VkImageLayout                               srcImageLayout,
 328     VkBuffer                                    destBuffer,
 329     uint32_t                                    regionCount,
 330     const VkBufferImageCopy*                    pRegions)
 331 {
 332    stub();
 333 }
 334
 335 void VKAPI vkCmdCloneImageData(
 336     VkCmdBuffer                                 cmdBuffer,
 337     VkImage                                     srcImage,
 338     VkImageLayout                               srcImageLayout,
 339     VkImage                                     destImage,
 340     VkImageLayout                               destImageLayout)
 341 {
 342    stub();
 343 }
 344
 345 void VKAPI vkCmdUpdateBuffer(
 346     VkCmdBuffer                                 cmdBuffer,
 347     VkBuffer                                    destBuffer,
 348     VkDeviceSize                                destOffset,
 349     VkDeviceSize                                dataSize,
 350     const uint32_t*                             pData)
 351 {
 352    stub();
 353 }
 354
 355 void VKAPI vkCmdFillBuffer(
 356     VkCmdBuffer                                 cmdBuffer,
 357     VkBuffer                                    destBuffer,
 358     VkDeviceSize                                destOffset,
 359     VkDeviceSize                                fillSize,
 360     uint32_t                                    data)
 361 {
 362    stub();
 363 }
 364
 365 void VKAPI vkCmdClearColorImage(
 366     VkCmdBuffer                                 cmdBuffer,
 367     VkImage                                     image,
 368     VkImageLayout                               imageLayout,
 369     const VkClearColor*                         color,
 370     uint32_t                                    rangeCount,
 371     const VkImageSubresourceRange*              pRanges)
 372 {
 373    stub();
 374 }
 375
 376 void VKAPI vkCmdClearDepthStencil(
 377     VkCmdBuffer                                 cmdBuffer,
 378     VkImage                                     image,
 379     VkImageLayout                               imageLayout,
 380     float                                       depth,
 381     uint32_t                                    stencil,
 382     uint32_t                                    rangeCount,
 383     const VkImageSubresourceRange*              pRanges)
 384 {
 385    stub();
 386 }
 387
 388 void VKAPI vkCmdResolveImage(
 389     VkCmdBuffer                                 cmdBuffer,
 390     VkImage                                     srcImage,
 391     VkImageLayout                               srcImageLayout,
 392     VkImage                                     destImage,
 393     VkImageLayout                               destImageLayout,
 394     uint32_t                                    regionCount,
 395     const VkImageResolve*                       pRegions)
 396 {
 397    stub();
 398 }
 399
 400 void
 401 anv_device_init_meta(struct anv_device *device)
 402 {
 403    anv_device_init_meta_clear_state(device);
 404 }