anv: Add initial support for cube maps

[mesa.git] / src / vulkan / anv_nir_apply_pipeline_layout.c

diff --git a/src/vulkan/anv_nir_apply_pipeline_layout.c b/src/vulkan/anv_nir_apply_pipeline_layout.c
index fe1702dfda7fca4996234a9bec9512f8d21c3db5..96b9f21fd09dbb00de652557e7c23b6116a81394 100644 (file)
--- a/src/vulkan/anv_nir_apply_pipeline_layout.c
+++ b/src/vulkan/anv_nir_apply_pipeline_layout.c
@@ -22,13 +22,13 @@
  */
 
 #include "anv_nir.h"
+#include "program/prog_parameter.h"
 #include "glsl/nir/nir_builder.h"
 
 struct apply_pipeline_layout_state {
    nir_shader *shader;
    nir_builder builder;
 
-   VkShaderStage stage;
    const struct anv_pipeline_layout *layout;
 
    bool progress;
@@ -42,15 +42,17 @@ get_surface_index(unsigned set, unsigned binding,
    struct anv_descriptor_set_layout *set_layout =
       state->layout->set[set].layout;
 
+   gl_shader_stage stage = state->shader->stage;
+
    assert(binding < set_layout->binding_count);
 
-   assert(set_layout->binding[binding].stage[state->stage].surface_index >= 0);
+   assert(set_layout->binding[binding].stage[stage].surface_index >= 0);
 
    uint32_t surface_index =
-      state->layout->set[set].stage[state->stage].surface_start +
-      set_layout->binding[binding].stage[state->stage].surface_index;
+      state->layout->set[set].stage[stage].surface_start +
+      set_layout->binding[binding].stage[stage].surface_index;
 
-   assert(surface_index < state->layout->stage[state->stage].surface_count);
+   assert(surface_index < state->layout->stage[stage].surface_count);
 
    return surface_index;
 }
@@ -65,20 +67,45 @@ get_sampler_index(unsigned set, unsigned binding, nir_texop tex_op,
 
    assert(binding < set_layout->binding_count);
 
-   if (set_layout->binding[binding].stage[state->stage].sampler_index < 0) {
+   gl_shader_stage stage = state->shader->stage;
+
+   if (set_layout->binding[binding].stage[stage].sampler_index < 0) {
       assert(tex_op == nir_texop_txf);
       return 0;
    }
 
    uint32_t sampler_index =
-      state->layout->set[set].stage[state->stage].sampler_start +
-      set_layout->binding[binding].stage[state->stage].sampler_index;
+      state->layout->set[set].stage[stage].sampler_start +
+      set_layout->binding[binding].stage[stage].sampler_index;
 
-   assert(sampler_index < state->layout->stage[state->stage].sampler_count);
+   assert(sampler_index < state->layout->stage[stage].sampler_count);
 
    return sampler_index;
 }
 
+static uint32_t
+get_image_index(unsigned set, unsigned binding,
+                struct apply_pipeline_layout_state *state)
+{
+   assert(set < state->layout->num_sets);
+   struct anv_descriptor_set_layout *set_layout =
+      state->layout->set[set].layout;
+
+   assert(binding < set_layout->binding_count);
+
+   gl_shader_stage stage = state->shader->stage;
+
+   assert(set_layout->binding[binding].stage[stage].image_index >= 0);
+
+   uint32_t image_index =
+      state->layout->set[set].stage[stage].image_start +
+      set_layout->binding[binding].stage[stage].image_index;
+
+   assert(image_index < state->layout->stage[stage].image_count);
+
+   return image_index;
+}
+
 static void
 lower_res_index_intrinsic(nir_intrinsic_instr *intrin,
                           struct apply_pipeline_layout_state *state)
@@ -211,13 +238,27 @@ apply_pipeline_layout_block(nir_block *block, void *void_state)
    return true;
 }
 
+static void
+setup_vec4_uniform_value(const union gl_constant_value **params,
+                         const union gl_constant_value *values,
+                         unsigned n)
+{
+   static const gl_constant_value zero = { 0 };
+
+   for (unsigned i = 0; i < n; ++i)
+      params[i] = &values[i];
+
+   for (unsigned i = n; i < 4; ++i)
+      params[i] = &zero;
+}
+
 bool
 anv_nir_apply_pipeline_layout(nir_shader *shader,
+                              struct brw_stage_prog_data *prog_data,
                               const struct anv_pipeline_layout *layout)
 {
    struct apply_pipeline_layout_state state = {
       .shader = shader,
-      .stage = anv_vk_shader_stage_for_mesa_stage(shader->stage),
       .layout = layout,
    };
 
@@ -230,5 +271,47 @@ anv_nir_apply_pipeline_layout(nir_shader *shader,
       }
    }
 
+   if (layout->stage[shader->stage].image_count > 0) {
+      nir_foreach_variable(var, &shader->uniforms) {
+         if (glsl_type_is_image(var->type) ||
+             (glsl_type_is_array(var->type) &&
+              glsl_type_is_image(glsl_get_array_element(var->type)))) {
+            /* Images are represented as uniform push constants and the actual
+             * information required for reading/writing to/from the image is
+             * storred in the uniform.
+             */
+            unsigned image_index = get_image_index(var->data.descriptor_set,
+                                                   var->data.binding, &state);
+
+            var->data.driver_location = shader->num_uniforms +
+                                        image_index * BRW_IMAGE_PARAM_SIZE * 4;
+         }
+      }
+
+      struct anv_push_constants *null_data = NULL;
+      const gl_constant_value **param = prog_data->param + shader->num_uniforms;
+      const struct brw_image_param *image_param = null_data->images;
+      for (uint32_t i = 0; i < layout->stage[shader->stage].image_count; i++) {
+         setup_vec4_uniform_value(param + BRW_IMAGE_PARAM_SURFACE_IDX_OFFSET,
+            (const union gl_constant_value *)&image_param->surface_idx, 1);
+         setup_vec4_uniform_value(param + BRW_IMAGE_PARAM_OFFSET_OFFSET,
+            (const union gl_constant_value *)image_param->offset, 2);
+         setup_vec4_uniform_value(param + BRW_IMAGE_PARAM_SIZE_OFFSET,
+            (const union gl_constant_value *)image_param->size, 3);
+         setup_vec4_uniform_value(param + BRW_IMAGE_PARAM_STRIDE_OFFSET,
+            (const union gl_constant_value *)image_param->stride, 4);
+         setup_vec4_uniform_value(param + BRW_IMAGE_PARAM_TILING_OFFSET,
+            (const union gl_constant_value *)image_param->tiling, 3);
+         setup_vec4_uniform_value(param + BRW_IMAGE_PARAM_SWIZZLING_OFFSET,
+            (const union gl_constant_value *)image_param->swizzling, 2);
+
+         param += BRW_IMAGE_PARAM_SIZE;
+         image_param ++;
+      }
+
+      shader->num_uniforms += layout->stage[shader->stage].image_count *
+                              BRW_IMAGE_PARAM_SIZE * 4;
+   }
+
    return state.progress;
 }