DRW: Change binding APIdrw-manager-next

Using bind() overload is too error prone.

12 files changed, 251 insertions, 244 deletions

diff --git a/source/blender/draw/engines/eevee_next/eevee_depth_of_field.cc b/source/blender/draw/engines/eevee_next/eevee_depth_of_field.cc
index d526aeac0a6..bc0891ceb92 100644
--- a/source/blender/draw/engines/eevee_next/eevee_depth_of_field.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_depth_of_field.cc
@@ -245,10 +245,10 @@ void DepthOfField::bokeh_lut_pass_sync()
   /* Precompute bokeh texture. */
   bokeh_lut_ps_.init();
   bokeh_lut_ps_.shader_set(inst_.shaders.static_shader_get(DOF_BOKEH_LUT));
-  bokeh_lut_ps_.bind("dof_buf", data_);
-  bokeh_lut_ps_.bind("out_gather_lut_img", as_image(&bokeh_gather_lut_tx_));
-  bokeh_lut_ps_.bind("out_scatter_lut_img", as_image(&bokeh_scatter_lut_tx_));
-  bokeh_lut_ps_.bind("out_resolve_lut_img", as_image(&bokeh_resolve_lut_tx_));
+  bokeh_lut_ps_.bind_ubo("dof_buf", data_);
+  bokeh_lut_ps_.bind_image("out_gather_lut_img", &bokeh_gather_lut_tx_);
+  bokeh_lut_ps_.bind_image("out_scatter_lut_img", &bokeh_scatter_lut_tx_);
+  bokeh_lut_ps_.bind_image("out_resolve_lut_img", &bokeh_resolve_lut_tx_);
   bokeh_lut_ps_.dispatch(int3(1, 1, 1));
 }
 
@@ -258,11 +258,11 @@ void DepthOfField::setup_pass_sync()
 
   setup_ps_.init();
   setup_ps_.shader_set(inst_.shaders.static_shader_get(DOF_SETUP));
-  setup_ps_.bind("color_tx", &input_color_tx_, no_filter);
-  setup_ps_.bind("depth_tx", &render_buffers.depth_tx, no_filter);
-  setup_ps_.bind("dof_buf", data_);
-  setup_ps_.bind("out_color_img", as_image(&setup_color_tx_));
-  setup_ps_.bind("out_coc_img", as_image(&setup_coc_tx_));
+  setup_ps_.bind_texture("color_tx", &input_color_tx_, no_filter);
+  setup_ps_.bind_texture("depth_tx", &render_buffers.depth_tx, no_filter);
+  setup_ps_.bind_ubo("dof_buf", data_);
+  setup_ps_.bind_image("out_color_img", &setup_color_tx_);
+  setup_ps_.bind_image("out_coc_img", &setup_coc_tx_);
   setup_ps_.dispatch(&dispatch_setup_size_);
   setup_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH);
 }
@@ -274,20 +274,20 @@ void DepthOfField::stabilize_pass_sync()
 
   stabilize_ps_.init();
   stabilize_ps_.shader_set(inst_.shaders.static_shader_get(DOF_STABILIZE));
-  stabilize_ps_.bind("camera_prev", &(*velocity.camera_steps[STEP_PREVIOUS]));
-  stabilize_ps_.bind("camera_curr", &(*velocity.camera_steps[STEP_CURRENT]));
+  stabilize_ps_.bind_ubo("camera_prev", &(*velocity.camera_steps[STEP_PREVIOUS]));
+  stabilize_ps_.bind_ubo("camera_curr", &(*velocity.camera_steps[STEP_CURRENT]));
   /* This is only for temporal stability. The next step is not needed. */
-  stabilize_ps_.bind("camera_next", &(*velocity.camera_steps[STEP_PREVIOUS]));
-  stabilize_ps_.bind("coc_tx", &setup_coc_tx_, no_filter);
-  stabilize_ps_.bind("color_tx", &setup_color_tx_, no_filter);
-  stabilize_ps_.bind("velocity_tx", &render_buffers.vector_tx, no_filter);
-  stabilize_ps_.bind("in_history_tx", &stabilize_input_, with_filter);
-  stabilize_ps_.bind("depth_tx", &render_buffers.depth_tx, no_filter);
-  stabilize_ps_.bind("dof_buf", data_);
+  stabilize_ps_.bind_ubo("camera_next", &(*velocity.camera_steps[STEP_PREVIOUS]));
+  stabilize_ps_.bind_texture("coc_tx", &setup_coc_tx_, no_filter);
+  stabilize_ps_.bind_texture("color_tx", &setup_color_tx_, no_filter);
+  stabilize_ps_.bind_texture("velocity_tx", &render_buffers.vector_tx, no_filter);
+  stabilize_ps_.bind_texture("in_history_tx", &stabilize_input_, with_filter);
+  stabilize_ps_.bind_texture("depth_tx", &render_buffers.depth_tx, no_filter);
+  stabilize_ps_.bind_ubo("dof_buf", data_);
   stabilize_ps_.push_constant("use_history", &stabilize_valid_history_, 1);
-  stabilize_ps_.bind("out_coc_img", as_image(reduced_coc_tx_.mip_view(0)));
-  stabilize_ps_.bind("out_color_img", as_image(reduced_color_tx_.mip_view(0)));
-  stabilize_ps_.bind("out_history_img", as_image(&stabilize_output_tx_));
+  stabilize_ps_.bind_image("out_coc_img", reduced_coc_tx_.mip_view(0));
+  stabilize_ps_.bind_image("out_color_img", reduced_color_tx_.mip_view(0));
+  stabilize_ps_.bind_image("out_history_img", &stabilize_output_tx_);
   stabilize_ps_.dispatch(&dispatch_stabilize_size_);
   stabilize_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH | GPU_BARRIER_SHADER_IMAGE_ACCESS);
 }
@@ -296,9 +296,9 @@ void DepthOfField::downsample_pass_sync()
 {
   downsample_ps_.init();
   downsample_ps_.shader_set(inst_.shaders.static_shader_get(DOF_DOWNSAMPLE));
-  downsample_ps_.bind("color_tx", reduced_color_tx_.mip_view(0), no_filter);
-  downsample_ps_.bind("coc_tx", reduced_coc_tx_.mip_view(0), no_filter);
-  downsample_ps_.bind("out_color_img", as_image(&downsample_tx_));
+  downsample_ps_.bind_texture("color_tx", reduced_color_tx_.mip_view(0), no_filter);
+  downsample_ps_.bind_texture("coc_tx", reduced_coc_tx_.mip_view(0), no_filter);
+  downsample_ps_.bind_image("out_color_img", &downsample_tx_);
   downsample_ps_.dispatch(&dispatch_downsample_size_);
   downsample_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH);
 }
@@ -307,20 +307,20 @@ void DepthOfField::reduce_pass_sync()
 {
   reduce_ps_.init();
   reduce_ps_.shader_set(inst_.shaders.static_shader_get(DOF_REDUCE));
-  reduce_ps_.bind("dof_buf", data_);
-  reduce_ps_.bind("downsample_tx", &downsample_tx_, no_filter);
-  reduce_ps_.bind("scatter_fg_list_buf", scatter_fg_list_buf_);
-  reduce_ps_.bind("scatter_bg_list_buf", scatter_bg_list_buf_);
-  reduce_ps_.bind("scatter_fg_indirect_buf", scatter_fg_indirect_buf_);
-  reduce_ps_.bind("scatter_bg_indirect_buf", scatter_bg_indirect_buf_);
-  reduce_ps_.bind("inout_color_lod0_img", as_image(reduced_color_tx_.mip_view(0)));
-  reduce_ps_.bind("out_color_lod1_img", as_image(reduced_color_tx_.mip_view(1)));
-  reduce_ps_.bind("out_color_lod2_img", as_image(reduced_color_tx_.mip_view(2)));
-  reduce_ps_.bind("out_color_lod3_img", as_image(reduced_color_tx_.mip_view(3)));
-  reduce_ps_.bind("in_coc_lod0_img", as_image(reduced_coc_tx_.mip_view(0)));
-  reduce_ps_.bind("out_coc_lod1_img", as_image(reduced_coc_tx_.mip_view(1)));
-  reduce_ps_.bind("out_coc_lod2_img", as_image(reduced_coc_tx_.mip_view(2)));
-  reduce_ps_.bind("out_coc_lod3_img", as_image(reduced_coc_tx_.mip_view(3)));
+  reduce_ps_.bind_ubo("dof_buf", data_);
+  reduce_ps_.bind_texture("downsample_tx", &downsample_tx_, no_filter);
+  reduce_ps_.bind_ssbo("scatter_fg_list_buf", scatter_fg_list_buf_);
+  reduce_ps_.bind_ssbo("scatter_bg_list_buf", scatter_bg_list_buf_);
+  reduce_ps_.bind_ssbo("scatter_fg_indirect_buf", scatter_fg_indirect_buf_);
+  reduce_ps_.bind_ssbo("scatter_bg_indirect_buf", scatter_bg_indirect_buf_);
+  reduce_ps_.bind_image("inout_color_lod0_img", reduced_color_tx_.mip_view(0));
+  reduce_ps_.bind_image("out_color_lod1_img", reduced_color_tx_.mip_view(1));
+  reduce_ps_.bind_image("out_color_lod2_img", reduced_color_tx_.mip_view(2));
+  reduce_ps_.bind_image("out_color_lod3_img", reduced_color_tx_.mip_view(3));
+  reduce_ps_.bind_image("in_coc_lod0_img", reduced_coc_tx_.mip_view(0));
+  reduce_ps_.bind_image("out_coc_lod1_img", reduced_coc_tx_.mip_view(1));
+  reduce_ps_.bind_image("out_coc_lod2_img", reduced_coc_tx_.mip_view(2));
+  reduce_ps_.bind_image("out_coc_lod3_img", reduced_coc_tx_.mip_view(3));
   reduce_ps_.dispatch(&dispatch_reduce_size_);
   /* NOTE: Command buffer barrier is done automatically by the GPU backend. */
   reduce_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH | GPU_BARRIER_SHADER_STORAGE);
@@ -333,9 +333,9 @@ void DepthOfField::tiles_flatten_pass_sync()
   /* NOTE(fclem): We should use the reduced_coc_tx_ as it is stable, but we need the slight focus
    * flag from the setup pass. A better way would be to do the brute-force in focus gather without
    * this. */
-  tiles_flatten_ps_.bind("coc_tx", &setup_coc_tx_, no_filter);
-  tiles_flatten_ps_.bind("out_tiles_fg_img", as_image(&tiles_fg_tx_.current()));
-  tiles_flatten_ps_.bind("out_tiles_bg_img", as_image(&tiles_bg_tx_.current()));
+  tiles_flatten_ps_.bind_texture("coc_tx", &setup_coc_tx_, no_filter);
+  tiles_flatten_ps_.bind_image("out_tiles_fg_img", &tiles_fg_tx_.current());
+  tiles_flatten_ps_.bind_image("out_tiles_bg_img", &tiles_bg_tx_.current());
   tiles_flatten_ps_.dispatch(&dispatch_tiles_flatten_size_);
   tiles_flatten_ps_.barrier(GPU_BARRIER_SHADER_IMAGE_ACCESS);
 }
@@ -347,10 +347,10 @@ void DepthOfField::tiles_dilate_pass_sync()
     eShaderType sh_type = (pass == 0) ? DOF_TILES_DILATE_MINMAX : DOF_TILES_DILATE_MINABS;
     drw_pass.init();
     drw_pass.shader_set(inst_.shaders.static_shader_get(sh_type));
-    drw_pass.bind("in_tiles_fg_img", as_image(&tiles_fg_tx_.previous()));
-    drw_pass.bind("in_tiles_bg_img", as_image(&tiles_bg_tx_.previous()));
-    drw_pass.bind("out_tiles_fg_img", as_image(&tiles_fg_tx_.current()));
-    drw_pass.bind("out_tiles_bg_img", as_image(&tiles_bg_tx_.current()));
+    drw_pass.bind_image("in_tiles_fg_img", &tiles_fg_tx_.previous());
+    drw_pass.bind_image("in_tiles_bg_img", &tiles_bg_tx_.previous());
+    drw_pass.bind_image("out_tiles_fg_img", &tiles_fg_tx_.current());
+    drw_pass.bind_image("out_tiles_bg_img", &tiles_bg_tx_.current());
     drw_pass.push_constant("ring_count", &tiles_dilate_ring_count_, 1);
     drw_pass.push_constant("ring_width_multiplier", &tiles_dilate_ring_width_mul_, 1);
     drw_pass.dispatch(&dispatch_tiles_dilate_size_);
@@ -371,16 +371,16 @@ void DepthOfField::gather_pass_sync()
     drw_pass.init();
     inst_.sampling.bind_resources(&drw_pass);
     drw_pass.shader_set(inst_.shaders.static_shader_get(sh_type));
-    drw_pass.bind("dof_buf", data_);
-    drw_pass.bind("color_bilinear_tx", reduced_color_tx_, gather_bilinear);
-    drw_pass.bind("color_tx", reduced_color_tx_, gather_nearest);
-    drw_pass.bind("coc_tx", reduced_coc_tx_, gather_nearest);
-    drw_pass.bind("in_tiles_fg_img", as_image(&tiles_fg_tx_.current()));
-    drw_pass.bind("in_tiles_bg_img", as_image(&tiles_bg_tx_.current()));
-    drw_pass.bind("out_color_img", as_image(&color_chain.current()));
-    drw_pass.bind("out_weight_img", as_image(&weight_chain.current()));
-    drw_pass.bind("out_occlusion_img", as_image(&occlusion_tx_));
-    drw_pass.bind("bokeh_lut_tx", &bokeh_gather_lut_tx_);
+    drw_pass.bind_ubo("dof_buf", data_);
+    drw_pass.bind_texture("color_bilinear_tx", reduced_color_tx_, gather_bilinear);
+    drw_pass.bind_texture("color_tx", reduced_color_tx_, gather_nearest);
+    drw_pass.bind_texture("coc_tx", reduced_coc_tx_, gather_nearest);
+    drw_pass.bind_image("in_tiles_fg_img", &tiles_fg_tx_.current());
+    drw_pass.bind_image("in_tiles_bg_img", &tiles_bg_tx_.current());
+    drw_pass.bind_image("out_color_img", &color_chain.current());
+    drw_pass.bind_image("out_weight_img", &weight_chain.current());
+    drw_pass.bind_image("out_occlusion_img", &occlusion_tx_);
+    drw_pass.bind_texture("bokeh_lut_tx", &bokeh_gather_lut_tx_);
     drw_pass.dispatch(&dispatch_gather_size_);
     drw_pass.barrier(GPU_BARRIER_TEXTURE_FETCH);
   }
@@ -394,10 +394,10 @@ void DepthOfField::filter_pass_sync()
     SwapChain<TextureFromPool, 2> &weight_chain = (pass == 0) ? weight_fg_tx_ : weight_bg_tx_;
     drw_pass.init();
     drw_pass.shader_set(inst_.shaders.static_shader_get(DOF_FILTER));
-    drw_pass.bind("color_tx", &color_chain.previous());
-    drw_pass.bind("weight_tx", &weight_chain.previous());
-    drw_pass.bind("out_color_img", as_image(&color_chain.current()));
-    drw_pass.bind("out_weight_img", as_image(&weight_chain.current()));
+    drw_pass.bind_texture("color_tx", &color_chain.previous());
+    drw_pass.bind_texture("weight_tx", &weight_chain.previous());
+    drw_pass.bind_image("out_color_img", &color_chain.current());
+    drw_pass.bind_image("out_weight_img", &weight_chain.current());
     drw_pass.dispatch(&dispatch_filter_size_);
     drw_pass.barrier(GPU_BARRIER_TEXTURE_FETCH);
   }
@@ -411,16 +411,16 @@ void DepthOfField::scatter_pass_sync()
     drw_pass.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
     drw_pass.shader_set(inst_.shaders.static_shader_get(DOF_SCATTER));
     drw_pass.push_constant("use_bokeh_lut", use_bokeh_lut_);
-    drw_pass.bind("bokeh_lut_tx", &bokeh_scatter_lut_tx_);
-    drw_pass.bind("occlusion_tx", &occlusion_tx_);
+    drw_pass.bind_texture("bokeh_lut_tx", &bokeh_scatter_lut_tx_);
+    drw_pass.bind_texture("occlusion_tx", &occlusion_tx_);
     if (pass == 0) {
-      drw_pass.bind("scatter_list_buf", scatter_fg_list_buf_);
+      drw_pass.bind_ssbo("scatter_list_buf", scatter_fg_list_buf_);
       drw_pass.draw_procedural_indirect(GPU_PRIM_TRI_STRIP, scatter_fg_indirect_buf_);
       /* Avoid background gather pass writing to the occlusion_tx mid pass. */
       drw_pass.barrier(GPU_BARRIER_SHADER_IMAGE_ACCESS);
     }
     else {
-      drw_pass.bind("scatter_list_buf", scatter_bg_list_buf_);
+      drw_pass.bind_ssbo("scatter_list_buf", scatter_bg_list_buf_);
       drw_pass.draw_procedural_indirect(GPU_PRIM_TRI_STRIP, scatter_bg_indirect_buf_);
     }
   }
@@ -431,14 +431,14 @@ void DepthOfField::hole_fill_pass_sync()
   hole_fill_ps_.init();
   inst_.sampling.bind_resources(&hole_fill_ps_);
   hole_fill_ps_.shader_set(inst_.shaders.static_shader_get(DOF_GATHER_HOLE_FILL));
-  hole_fill_ps_.bind("dof_buf", data_);
-  hole_fill_ps_.bind("color_bilinear_tx", reduced_color_tx_, gather_bilinear);
-  hole_fill_ps_.bind("color_tx", reduced_color_tx_, gather_nearest);
-  hole_fill_ps_.bind("coc_tx", reduced_coc_tx_, gather_nearest);
-  hole_fill_ps_.bind("in_tiles_fg_img", as_image(&tiles_fg_tx_.current()));
-  hole_fill_ps_.bind("in_tiles_bg_img", as_image(&tiles_bg_tx_.current()));
-  hole_fill_ps_.bind("out_color_img", as_image(&hole_fill_color_tx_));
-  hole_fill_ps_.bind("out_weight_img", as_image(&hole_fill_weight_tx_));
+  hole_fill_ps_.bind_ubo("dof_buf", data_);
+  hole_fill_ps_.bind_texture("color_bilinear_tx", reduced_color_tx_, gather_bilinear);
+  hole_fill_ps_.bind_texture("color_tx", reduced_color_tx_, gather_nearest);
+  hole_fill_ps_.bind_texture("coc_tx", reduced_coc_tx_, gather_nearest);
+  hole_fill_ps_.bind_image("in_tiles_fg_img", &tiles_fg_tx_.current());
+  hole_fill_ps_.bind_image("in_tiles_bg_img", &tiles_bg_tx_.current());
+  hole_fill_ps_.bind_image("out_color_img", &hole_fill_color_tx_);
+  hole_fill_ps_.bind_image("out_weight_img", &hole_fill_weight_tx_);
   hole_fill_ps_.dispatch(&dispatch_gather_size_);
   hole_fill_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH);
 }
@@ -452,20 +452,20 @@ void DepthOfField::resolve_pass_sync()
   resolve_ps_.init();
   inst_.sampling.bind_resources(&resolve_ps_);
   resolve_ps_.shader_set(inst_.shaders.static_shader_get(sh_type));
-  resolve_ps_.bind("dof_buf", data_);
-  resolve_ps_.bind("depth_tx", &render_buffers.depth_tx, no_filter);
-  resolve_ps_.bind("color_tx", &input_color_tx_, no_filter);
-  resolve_ps_.bind("stable_color_tx", &resolve_stable_color_tx_, no_filter);
-  resolve_ps_.bind("color_bg_tx", &color_bg_tx_.current(), with_filter);
-  resolve_ps_.bind("color_fg_tx", &color_fg_tx_.current(), with_filter);
-  resolve_ps_.bind("in_tiles_fg_img", as_image(&tiles_fg_tx_.current()));
-  resolve_ps_.bind("in_tiles_bg_img", as_image(&tiles_bg_tx_.current()));
-  resolve_ps_.bind("weight_bg_tx", &weight_bg_tx_.current());
-  resolve_ps_.bind("weight_fg_tx", &weight_fg_tx_.current());
-  resolve_ps_.bind("color_hole_fill_tx", &hole_fill_color_tx_);
-  resolve_ps_.bind("weight_hole_fill_tx", &hole_fill_weight_tx_);
-  resolve_ps_.bind("bokeh_lut_tx", &bokeh_resolve_lut_tx_);
-  resolve_ps_.bind("out_color_img", as_image(&output_color_tx_));
+  resolve_ps_.bind_ubo("dof_buf", data_);
+  resolve_ps_.bind_texture("depth_tx", &render_buffers.depth_tx, no_filter);
+  resolve_ps_.bind_texture("color_tx", &input_color_tx_, no_filter);
+  resolve_ps_.bind_texture("stable_color_tx", &resolve_stable_color_tx_, no_filter);
+  resolve_ps_.bind_texture("color_bg_tx", &color_bg_tx_.current(), with_filter);
+  resolve_ps_.bind_texture("color_fg_tx", &color_fg_tx_.current(), with_filter);
+  resolve_ps_.bind_image("in_tiles_fg_img", &tiles_fg_tx_.current());
+  resolve_ps_.bind_image("in_tiles_bg_img", &tiles_bg_tx_.current());
+  resolve_ps_.bind_texture("weight_bg_tx", &weight_bg_tx_.current());
+  resolve_ps_.bind_texture("weight_fg_tx", &weight_fg_tx_.current());
+  resolve_ps_.bind_texture("color_hole_fill_tx", &hole_fill_color_tx_);
+  resolve_ps_.bind_texture("weight_hole_fill_tx", &hole_fill_weight_tx_);
+  resolve_ps_.bind_texture("bokeh_lut_tx", &bokeh_resolve_lut_tx_);
+  resolve_ps_.bind_image("out_color_img", &output_color_tx_);
   resolve_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH);
   resolve_ps_.dispatch(&dispatch_resolve_size_);
   resolve_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH);
diff --git a/source/blender/draw/engines/eevee_next/eevee_film.cc b/source/blender/draw/engines/eevee_next/eevee_film.cc
index ea0afdb16d3..b0731ceec2f 100644
--- a/source/blender/draw/engines/eevee_next/eevee_film.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_film.cc
@@ -380,34 +380,34 @@ void Film::sync()
   accumulate_ps_.init();
   accumulate_ps_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_ALWAYS);
   accumulate_ps_.shader_set(inst_.shaders.static_shader_get(shader));
-  accumulate_ps_.bind("film_buf", &data_);
-  accumulate_ps_.bind("camera_prev", &(*velocity.camera_steps[STEP_PREVIOUS]));
-  accumulate_ps_.bind("camera_curr", &(*velocity.camera_steps[STEP_CURRENT]));
-  accumulate_ps_.bind("camera_next", &(*velocity.camera_steps[step_next]));
-  accumulate_ps_.bind("depth_tx", &rbuffers.depth_tx);
-  accumulate_ps_.bind("combined_tx", &combined_final_tx_);
-  accumulate_ps_.bind("normal_tx", &rbuffers.normal_tx);
-  accumulate_ps_.bind("vector_tx", &rbuffers.vector_tx);
-  accumulate_ps_.bind("light_tx", &rbuffers.light_tx);
-  accumulate_ps_.bind("diffuse_color_tx", &rbuffers.diffuse_color_tx);
-  accumulate_ps_.bind("specular_color_tx", &rbuffers.specular_color_tx);
-  accumulate_ps_.bind("volume_light_tx", &rbuffers.volume_light_tx);
-  accumulate_ps_.bind("emission_tx", &rbuffers.emission_tx);
-  accumulate_ps_.bind("environment_tx", &rbuffers.environment_tx);
-  accumulate_ps_.bind("shadow_tx", &rbuffers.shadow_tx);
-  accumulate_ps_.bind("ambient_occlusion_tx", &rbuffers.ambient_occlusion_tx);
-  accumulate_ps_.bind("aov_color_tx", &rbuffers.aov_color_tx);
-  accumulate_ps_.bind("aov_value_tx", &rbuffers.aov_value_tx);
+  accumulate_ps_.bind_ubo("film_buf", &data_);
+  accumulate_ps_.bind_ubo("camera_prev", &(*velocity.camera_steps[STEP_PREVIOUS]));
+  accumulate_ps_.bind_ubo("camera_curr", &(*velocity.camera_steps[STEP_CURRENT]));
+  accumulate_ps_.bind_ubo("camera_next", &(*velocity.camera_steps[step_next]));
+  accumulate_ps_.bind_texture("depth_tx", &rbuffers.depth_tx);
+  accumulate_ps_.bind_texture("combined_tx", &combined_final_tx_);
+  accumulate_ps_.bind_texture("normal_tx", &rbuffers.normal_tx);
+  accumulate_ps_.bind_texture("vector_tx", &rbuffers.vector_tx);
+  accumulate_ps_.bind_texture("light_tx", &rbuffers.light_tx);
+  accumulate_ps_.bind_texture("diffuse_color_tx", &rbuffers.diffuse_color_tx);
+  accumulate_ps_.bind_texture("specular_color_tx", &rbuffers.specular_color_tx);
+  accumulate_ps_.bind_texture("volume_light_tx", &rbuffers.volume_light_tx);
+  accumulate_ps_.bind_texture("emission_tx", &rbuffers.emission_tx);
+  accumulate_ps_.bind_texture("environment_tx", &rbuffers.environment_tx);
+  accumulate_ps_.bind_texture("shadow_tx", &rbuffers.shadow_tx);
+  accumulate_ps_.bind_texture("ambient_occlusion_tx", &rbuffers.ambient_occlusion_tx);
+  accumulate_ps_.bind_texture("aov_color_tx", &rbuffers.aov_color_tx);
+  accumulate_ps_.bind_texture("aov_value_tx", &rbuffers.aov_value_tx);
   /* NOTE(@fclem): 16 is the max number of sampled texture in many implementations.
    * If we need more, we need to pack more of the similar passes in the same textures as arrays or
    * use image binding instead. */
-  accumulate_ps_.bind("in_weight_img", draw::as_image(&weight_tx_.current()));
-  accumulate_ps_.bind("out_weight_img", draw::as_image(&weight_tx_.next()));
-  accumulate_ps_.bind("in_combined_tx", &combined_tx_.current(), filter);
-  accumulate_ps_.bind("out_combined_img", draw::as_image(&combined_tx_.next()));
-  accumulate_ps_.bind("depth_img", draw::as_image(&depth_tx_));
-  accumulate_ps_.bind("color_accum_img", draw::as_image(&color_accum_tx_));
-  accumulate_ps_.bind("value_accum_img", draw::as_image(&value_accum_tx_));
+  accumulate_ps_.bind_image("in_weight_img", &weight_tx_.current());
+  accumulate_ps_.bind_image("out_weight_img", &weight_tx_.next());
+  accumulate_ps_.bind_texture("in_combined_tx", &combined_tx_.current(), filter);
+  accumulate_ps_.bind_image("out_combined_img", &combined_tx_.next());
+  accumulate_ps_.bind_image("depth_img", &depth_tx_);
+  accumulate_ps_.bind_image("color_accum_img", &color_accum_tx_);
+  accumulate_ps_.bind_image("value_accum_img", &value_accum_tx_);
   /* Sync with rendering passes. */
   accumulate_ps_.barrier(GPU_BARRIER_TEXTURE_FETCH | GPU_BARRIER_SHADER_IMAGE_ACCESS);
   if (use_compute) {
diff --git a/source/blender/draw/engines/eevee_next/eevee_hizbuffer.cc b/source/blender/draw/engines/eevee_next/eevee_hizbuffer.cc
index d93a69c859f..cf9049da514 100644
--- a/source/blender/draw/engines/eevee_next/eevee_hizbuffer.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_hizbuffer.cc
@@ -34,16 +34,16 @@ void HiZBuffer::sync()
   {
     hiz_update_ps_.init();
     hiz_update_ps_.shader_set(inst_.shaders.static_shader_get(HIZ_UPDATE));
-    hiz_update_ps_.bind("finished_tile_counter", atomic_tile_counter_);
-    hiz_update_ps_.bind("depth_tx", &render_buffers.depth_tx, with_filter);
-    hiz_update_ps_.bind("out_mip_0", as_image(hiz_tx_.mip_view(0)));
-    hiz_update_ps_.bind("out_mip_1", as_image(hiz_tx_.mip_view(1)));
-    hiz_update_ps_.bind("out_mip_2", as_image(hiz_tx_.mip_view(2)));
-    hiz_update_ps_.bind("out_mip_3", as_image(hiz_tx_.mip_view(3)));
-    hiz_update_ps_.bind("out_mip_4", as_image(hiz_tx_.mip_view(4)));
-    hiz_update_ps_.bind("out_mip_5", as_image(hiz_tx_.mip_view(5)));
-    hiz_update_ps_.bind("out_mip_6", as_image(hiz_tx_.mip_view(6)));
-    hiz_update_ps_.bind("out_mip_7", as_image(hiz_tx_.mip_view(7)));
+    hiz_update_ps_.bind_ssbo("finished_tile_counter", atomic_tile_counter_);
+    hiz_update_ps_.bind_texture("depth_tx", &render_buffers.depth_tx, with_filter);
+    hiz_update_ps_.bind_image("out_mip_0", hiz_tx_.mip_view(0));
+    hiz_update_ps_.bind_image("out_mip_1", hiz_tx_.mip_view(1));
+    hiz_update_ps_.bind_image("out_mip_2", hiz_tx_.mip_view(2));
+    hiz_update_ps_.bind_image("out_mip_3", hiz_tx_.mip_view(3));
+    hiz_update_ps_.bind_image("out_mip_4", hiz_tx_.mip_view(4));
+    hiz_update_ps_.bind_image("out_mip_5", hiz_tx_.mip_view(5));
+    hiz_update_ps_.bind_image("out_mip_6", hiz_tx_.mip_view(6));
+    hiz_update_ps_.bind_image("out_mip_7", hiz_tx_.mip_view(7));
     /* TODO(@fclem): There might be occasions where we might not want to
      * copy mip 0 for performance reasons if there is no need for it. */
     hiz_update_ps_.push_constant("update_mip_0", true);
diff --git a/source/blender/draw/engines/eevee_next/eevee_hizbuffer.hh b/source/blender/draw/engines/eevee_next/eevee_hizbuffer.hh
index 8ea44236b35..8b8e4de55b1 100644
--- a/source/blender/draw/engines/eevee_next/eevee_hizbuffer.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_hizbuffer.hh
@@ -78,8 +78,8 @@ class HiZBuffer {
   /* TODO(fclem): Hardcoded bind slots. */
   template<typename T> void bind_resources(draw::detail::PassBase<T> *pass)
   {
-    pass->bind("hiz_tx", &hiz_tx_);
-    pass->bind("hiz_buf", &data_);
+    pass->bind_texture("hiz_tx", &hiz_tx_);
+    pass->bind_ubo("hiz_buf", &data_);
   }
 };
 
diff --git a/source/blender/draw/engines/eevee_next/eevee_light.cc b/source/blender/draw/engines/eevee_next/eevee_light.cc
index a52fa93d949..05333dc1885 100644
--- a/source/blender/draw/engines/eevee_next/eevee_light.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_light.cc
@@ -404,40 +404,40 @@ void LightModule::culling_pass_sync()
   {
     auto &sub = culling_ps_.sub("Select");
     sub.shader_set(inst_.shaders.static_shader_get(LIGHT_CULLING_SELECT));
-    sub.bind("light_cull_buf", &culling_data_buf_);
-    sub.bind("in_light_buf", light_buf_);
-    sub.bind("out_light_buf", culling_light_buf_);
-    sub.bind("out_zdist_buf", culling_zdist_buf_);
-    sub.bind("out_key_buf", culling_key_buf_);
+    sub.bind_ssbo("light_cull_buf", &culling_data_buf_);
+    sub.bind_ssbo("in_light_buf", light_buf_);
+    sub.bind_ssbo("out_light_buf", culling_light_buf_);
+    sub.bind_ssbo("out_zdist_buf", culling_zdist_buf_);
+    sub.bind_ssbo("out_key_buf", culling_key_buf_);
     sub.dispatch(int3(culling_select_dispatch_size, 1, 1));
     sub.barrier(GPU_BARRIER_SHADER_STORAGE);
   }
   {
     auto &sub = culling_ps_.sub("Sort");
     sub.shader_set(inst_.shaders.static_shader_get(LIGHT_CULLING_SORT));
-    sub.bind("light_cull_buf", &culling_data_buf_);
-    sub.bind("in_light_buf", light_buf_);
-    sub.bind("out_light_buf", culling_light_buf_);
-    sub.bind("in_zdist_buf", culling_zdist_buf_);
-    sub.bind("in_key_buf", culling_key_buf_);
+    sub.bind_ssbo("light_cull_buf", &culling_data_buf_);
+    sub.bind_ssbo("in_light_buf", light_buf_);
+    sub.bind_ssbo("out_light_buf", culling_light_buf_);
+    sub.bind_ssbo("in_zdist_buf", culling_zdist_buf_);
+    sub.bind_ssbo("in_key_buf", culling_key_buf_);
     sub.dispatch(int3(culling_sort_dispatch_size, 1, 1));
     sub.barrier(GPU_BARRIER_SHADER_STORAGE);
   }
   {
     auto &sub = culling_ps_.sub("Zbin");
     sub.shader_set(inst_.shaders.static_shader_get(LIGHT_CULLING_ZBIN));
-    sub.bind("light_cull_buf", &culling_data_buf_);
-    sub.bind("light_buf", culling_light_buf_);
-    sub.bind("out_zbin_buf", culling_zbin_buf_);
+    sub.bind_ssbo("light_cull_buf", &culling_data_buf_);
+    sub.bind_ssbo("light_buf", culling_light_buf_);
+    sub.bind_ssbo("out_zbin_buf", culling_zbin_buf_);
     sub.dispatch(int3(1, 1, 1));
     sub.barrier(GPU_BARRIER_SHADER_STORAGE);
   }
   {
     auto &sub = culling_ps_.sub("Tiles");
     sub.shader_set(inst_.shaders.static_shader_get(LIGHT_CULLING_TILE));
-    sub.bind("light_cull_buf", &culling_data_buf_);
-    sub.bind("light_buf", culling_light_buf_);
-    sub.bind("out_light_tile_buf", culling_tile_buf_);
+    sub.bind_ssbo("light_cull_buf", &culling_data_buf_);
+    sub.bind_ssbo("light_buf", culling_light_buf_);
+    sub.bind_ssbo("out_light_tile_buf", culling_tile_buf_);
     sub.dispatch(int3(culling_tile_dispatch_size, 1, 1));
     sub.barrier(GPU_BARRIER_SHADER_STORAGE);
   }
@@ -450,11 +450,11 @@ void LightModule::debug_pass_sync()
     debug_draw_ps_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_CUSTOM);
     debug_draw_ps_.shader_set(inst_.shaders.static_shader_get(LIGHT_CULLING_DEBUG));
     inst_.hiz_buffer.bind_resources(&debug_draw_ps_);
-    debug_draw_ps_.bind("light_buf", &culling_light_buf_);
-    debug_draw_ps_.bind("light_cull_buf", &culling_data_buf_);
-    debug_draw_ps_.bind("light_zbin_buf", &culling_zbin_buf_);
-    debug_draw_ps_.bind("light_tile_buf", &culling_tile_buf_);
-    debug_draw_ps_.bind("depth_tx", &inst_.render_buffers.depth_tx);
+    debug_draw_ps_.bind_ssbo("light_buf", &culling_light_buf_);
+    debug_draw_ps_.bind_ssbo("light_cull_buf", &culling_data_buf_);
+    debug_draw_ps_.bind_ssbo("light_zbin_buf", &culling_zbin_buf_);
+    debug_draw_ps_.bind_ssbo("light_tile_buf", &culling_tile_buf_);
+    debug_draw_ps_.bind_texture("depth_tx", &inst_.render_buffers.depth_tx);
     debug_draw_ps_.draw_procedural(GPU_PRIM_TRIS, 1, 3);
   }
 }
diff --git a/source/blender/draw/engines/eevee_next/eevee_light.hh b/source/blender/draw/engines/eevee_next/eevee_light.hh
index c4f88044533..9bacc180ea8 100644
--- a/source/blender/draw/engines/eevee_next/eevee_light.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_light.hh
@@ -153,10 +153,10 @@ class LightModule {
   template<typename T> void bind_resources(draw::detail::PassBase<T> *pass)
   {
     /* Storage Buf. */
-    pass->bind(LIGHT_CULL_BUF_SLOT, &culling_data_buf_);
-    pass->bind(LIGHT_BUF_SLOT, &culling_light_buf_);
-    pass->bind(LIGHT_ZBIN_BUF_SLOT, &culling_zbin_buf_);
-    pass->bind(LIGHT_TILE_BUF_SLOT, &culling_tile_buf_);
+    pass->bind_ssbo(LIGHT_CULL_BUF_SLOT, &culling_data_buf_);
+    pass->bind_ssbo(LIGHT_BUF_SLOT, &culling_light_buf_);
+    pass->bind_ssbo(LIGHT_ZBIN_BUF_SLOT, &culling_zbin_buf_);
+    pass->bind_ssbo(LIGHT_TILE_BUF_SLOT, &culling_tile_buf_);
   }
 
  private:
diff --git a/source/blender/draw/engines/eevee_next/eevee_motion_blur.cc b/source/blender/draw/engines/eevee_next/eevee_motion_blur.cc
index 0e706c7eea6..f68abafa3d4 100644
--- a/source/blender/draw/engines/eevee_next/eevee_motion_blur.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_motion_blur.cc
@@ -144,10 +144,10 @@ void MotionBlurModule::sync()
     eShaderType shader = (inst_.is_viewport()) ? MOTION_BLUR_TILE_FLATTEN_VIEWPORT :
                                                  MOTION_BLUR_TILE_FLATTEN_RENDER;
     sub.shader_set(inst_.shaders.static_shader_get(shader));
-    sub.bind("motion_blur_buf", data_);
-    sub.bind("depth_tx", &render_buffers.depth_tx);
-    sub.bind("velocity_img", as_image(&render_buffers.vector_tx));
-    sub.bind("out_tiles_img", as_image(&tiles_tx_));
+    sub.bind_ubo("motion_blur_buf", data_);
+    sub.bind_texture("depth_tx", &render_buffers.depth_tx);
+    sub.bind_image("velocity_img", &render_buffers.vector_tx);
+    sub.bind_image("out_tiles_img", &tiles_tx_);
     sub.dispatch(&dispatch_flatten_size_);
     sub.barrier(GPU_BARRIER_SHADER_IMAGE_ACCESS | GPU_BARRIER_TEXTURE_FETCH);
   }
@@ -155,8 +155,8 @@ void MotionBlurModule::sync()
     /* Expand max velocity tiles by spreading them in their neighborhood. */
     PassSimple::Sub &sub = motion_blur_ps_.sub("TilesDilate");
     sub.shader_set(inst_.shaders.static_shader_get(MOTION_BLUR_TILE_DILATE));
-    sub.bind("tile_indirection_buf", tile_indirection_buf_);
-    sub.bind("in_tiles_img", as_image(&tiles_tx_));
+    sub.bind_ssbo("tile_indirection_buf", tile_indirection_buf_);
+    sub.bind_image("in_tiles_img", &tiles_tx_);
     sub.dispatch(&dispatch_dilate_size_);
     sub.barrier(GPU_BARRIER_SHADER_STORAGE);
   }
@@ -164,13 +164,13 @@ void MotionBlurModule::sync()
     /* Do the motion blur gather algorithm. */
     PassSimple::Sub &sub = motion_blur_ps_.sub("ConvolveGather");
     sub.shader_set(inst_.shaders.static_shader_get(MOTION_BLUR_GATHER));
-    sub.bind("motion_blur_buf", data_);
-    sub.bind("tile_indirection_buf", tile_indirection_buf_);
-    sub.bind("depth_tx", &render_buffers.depth_tx, no_filter);
-    sub.bind("velocity_tx", &render_buffers.vector_tx, no_filter);
-    sub.bind("in_color_tx", &input_color_tx_, no_filter);
-    sub.bind("in_tiles_img", as_image(&tiles_tx_));
-    sub.bind("out_color_img", as_image(&output_color_tx_));
+    sub.bind_ubo("motion_blur_buf", data_);
+    sub.bind_ssbo("tile_indirection_buf", tile_indirection_buf_);
+    sub.bind_texture("depth_tx", &render_buffers.depth_tx, no_filter);
+    sub.bind_texture("velocity_tx", &render_buffers.vector_tx, no_filter);
+    sub.bind_texture("in_color_tx", &input_color_tx_, no_filter);
+    sub.bind_image("in_tiles_img", &tiles_tx_);
+    sub.bind_image("out_color_img", &output_color_tx_);
 
     sub.dispatch(&dispatch_gather_size_);
     sub.barrier(GPU_BARRIER_TEXTURE_FETCH);
diff --git a/source/blender/draw/engines/eevee_next/eevee_pipeline.cc b/source/blender/draw/engines/eevee_next/eevee_pipeline.cc
index 336c8c8800a..16bdfb04d14 100644
--- a/source/blender/draw/engines/eevee_next/eevee_pipeline.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_pipeline.cc
@@ -33,17 +33,17 @@ void WorldPipeline::sync(GPUMaterial *gpumat)
   world_ps_.state_set(DRW_STATE_WRITE_COLOR);
   world_ps_.material_set(manager, gpumat);
   world_ps_.push_constant("world_opacity_fade", inst_.film.background_opacity_get());
-  world_ps_.bind("utility_tx", inst_.pipelines.utility_tx);
+  world_ps_.bind_texture("utility_tx", inst_.pipelines.utility_tx);
   /* AOVs. */
-  world_ps_.bind("aov_color_img", as_image(&rbufs.aov_color_tx));
-  world_ps_.bind("aov_value_img", as_image(&rbufs.aov_value_tx));
-  world_ps_.bind("aov_buf", &inst_.film.aovs_info);
+  world_ps_.bind_image("aov_color_img", &rbufs.aov_color_tx);
+  world_ps_.bind_image("aov_value_img", &rbufs.aov_value_tx);
+  world_ps_.bind_ssbo("aov_buf", &inst_.film.aovs_info);
   /* RenderPasses. Cleared by background (even if bad practice). */
-  world_ps_.bind("rp_normal_img", as_image(&rbufs.normal_tx));
-  world_ps_.bind("rp_light_img", as_image(&rbufs.light_tx));
-  world_ps_.bind("rp_diffuse_color_img", as_image(&rbufs.diffuse_color_tx));
-  world_ps_.bind("rp_specular_color_img", as_image(&rbufs.specular_color_tx));
-  world_ps_.bind("rp_emission_img", as_image(&rbufs.emission_tx));
+  world_ps_.bind_image("rp_normal_img", &rbufs.normal_tx);
+  world_ps_.bind_image("rp_light_img", &rbufs.light_tx);
+  world_ps_.bind_image("rp_diffuse_color_img", &rbufs.diffuse_color_tx);
+  world_ps_.bind_image("rp_specular_color_img", &rbufs.specular_color_tx);
+  world_ps_.bind_image("rp_emission_img", &rbufs.emission_tx);
 
   world_ps_.draw(DRW_cache_fullscreen_quad_get(), handle);
   /* To allow opaque pass rendering over it. */
@@ -77,7 +77,7 @@ void ForwardPipeline::sync()
       /* Common resources. */
 
       /* Textures. */
-      prepass_ps_.bind(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
+      prepass_ps_.bind_texture(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
 
       inst_.velocity.bind_resources(&prepass_ps_);
       inst_.sampling.bind_resources(&prepass_ps_);
@@ -102,18 +102,18 @@ void ForwardPipeline::sync()
       /* Common resources. */
 
       /* RenderPasses. */
-      opaque_ps_.bind(RBUFS_NORMAL_SLOT, as_image(&inst_.render_buffers.normal_tx));
-      opaque_ps_.bind(RBUFS_LIGHT_SLOT, as_image(&inst_.render_buffers.light_tx));
-      opaque_ps_.bind(RBUFS_DIFF_COLOR_SLOT, as_image(&inst_.render_buffers.diffuse_color_tx));
-      opaque_ps_.bind(RBUFS_SPEC_COLOR_SLOT, as_image(&inst_.render_buffers.specular_color_tx));
-      opaque_ps_.bind(RBUFS_EMISSION_SLOT, as_image(&inst_.render_buffers.emission_tx));
+      opaque_ps_.bind_image(RBUFS_NORMAL_SLOT, &inst_.render_buffers.normal_tx);
+      opaque_ps_.bind_image(RBUFS_LIGHT_SLOT, &inst_.render_buffers.light_tx);
+      opaque_ps_.bind_image(RBUFS_DIFF_COLOR_SLOT, &inst_.render_buffers.diffuse_color_tx);
+      opaque_ps_.bind_image(RBUFS_SPEC_COLOR_SLOT, &inst_.render_buffers.specular_color_tx);
+      opaque_ps_.bind_image(RBUFS_EMISSION_SLOT, &inst_.render_buffers.emission_tx);
       /* AOVs. */
-      opaque_ps_.bind(RBUFS_AOV_COLOR_SLOT, as_image(&inst_.render_buffers.aov_color_tx));
-      opaque_ps_.bind(RBUFS_AOV_VALUE_SLOT, as_image(&inst_.render_buffers.aov_value_tx));
+      opaque_ps_.bind_image(RBUFS_AOV_COLOR_SLOT, &inst_.render_buffers.aov_color_tx);
+      opaque_ps_.bind_image(RBUFS_AOV_VALUE_SLOT, &inst_.render_buffers.aov_value_tx);
       /* Storage Buf. */
-      opaque_ps_.bind(RBUFS_AOV_BUF_SLOT, &inst_.film.aovs_info);
+      opaque_ps_.bind_ssbo(RBUFS_AOV_BUF_SLOT, &inst_.film.aovs_info);
       /* Textures. */
-      opaque_ps_.bind(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
+      opaque_ps_.bind_texture(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
 
       inst_.lights.bind_resources(&opaque_ps_);
       inst_.sampling.bind_resources(&opaque_ps_);
@@ -135,7 +135,7 @@ void ForwardPipeline::sync()
     /* Common resources. */
 
     /* Textures. */
-    sub.bind(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
+    sub.bind_texture(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
 
     inst_.lights.bind_resources(&sub);
     inst_.sampling.bind_resources(&sub);
diff --git a/source/blender/draw/engines/eevee_next/eevee_sampling.hh b/source/blender/draw/engines/eevee_next/eevee_sampling.hh
index 72a906d5988..c2bf23d20fc 100644
--- a/source/blender/draw/engines/eevee_next/eevee_sampling.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_sampling.hh
@@ -90,7 +90,7 @@ class Sampling {
   template<typename T> void bind_resources(draw::detail::PassBase<T> *pass)
   {
     /* Storage Buf. */
-    pass->bind(SAMPLING_BUF_SLOT, &data_);
+    pass->bind_ssbo(SAMPLING_BUF_SLOT, &data_);
   }
 
   /* Returns a pseudo random number in [0..1] range. Each dimension are de-correlated. */
diff --git a/source/blender/draw/engines/eevee_next/eevee_velocity.hh b/source/blender/draw/engines/eevee_next/eevee_velocity.hh
index 51f260f8848..6f18b05d476 100644
--- a/source/blender/draw/engines/eevee_next/eevee_velocity.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_velocity.hh
@@ -121,15 +121,15 @@ class VelocityModule {
   template<typename T> void bind_resources(draw::detail::Pass<T> *pass)
   {
     /* Storage Buf. */
-    pass->bind(VELOCITY_OBJ_PREV_BUF_SLOT, &(*object_steps[STEP_PREVIOUS]));
-    pass->bind(VELOCITY_OBJ_NEXT_BUF_SLOT, &(*object_steps[next_step_]));
-    pass->bind(VELOCITY_GEO_PREV_BUF_SLOT, &(*geometry_steps[STEP_PREVIOUS]));
-    pass->bind(VELOCITY_GEO_NEXT_BUF_SLOT, &(*geometry_steps[next_step_]));
-    pass->bind(VELOCITY_INDIRECTION_BUF_SLOT, &indirection_buf);
+    pass->bind_ssbo(VELOCITY_OBJ_PREV_BUF_SLOT, &(*object_steps[STEP_PREVIOUS]));
+    pass->bind_ssbo(VELOCITY_OBJ_NEXT_BUF_SLOT, &(*object_steps[next_step_]));
+    pass->bind_ssbo(VELOCITY_GEO_PREV_BUF_SLOT, &(*geometry_steps[STEP_PREVIOUS]));
+    pass->bind_ssbo(VELOCITY_GEO_NEXT_BUF_SLOT, &(*geometry_steps[next_step_]));
+    pass->bind_ssbo(VELOCITY_INDIRECTION_BUF_SLOT, &indirection_buf);
     /* Uniform Buf. */
-    pass->bind(VELOCITY_CAMERA_PREV_BUF, &(*camera_steps[STEP_PREVIOUS]));
-    pass->bind(VELOCITY_CAMERA_CURR_BUF, &(*camera_steps[STEP_CURRENT]));
-    pass->bind(VELOCITY_CAMERA_NEXT_BUF, &(*camera_steps[next_step_]));
+    pass->bind_ubo(VELOCITY_CAMERA_PREV_BUF, &(*camera_steps[STEP_PREVIOUS]));
+    pass->bind_ubo(VELOCITY_CAMERA_CURR_BUF, &(*camera_steps[STEP_CURRENT]));
+    pass->bind_ubo(VELOCITY_CAMERA_NEXT_BUF, &(*camera_steps[next_step_]));
   }
 
   bool camera_has_motion() const;
diff --git a/source/blender/draw/intern/draw_pass.hh b/source/blender/draw/intern/draw_pass.hh
index d96638ebae9..cbc3a6548d0 100644
--- a/source/blender/draw/intern/draw_pass.hh
+++ b/source/blender/draw/intern/draw_pass.hh
@@ -105,6 +105,9 @@ template<
 class PassBase {
   friend Manager;
 
+  /** Will use texture own sampler state. */
+  static constexpr eGPUSamplerState sampler_auto = GPU_SAMPLER_MAX;
+
  protected:
   /** Highest level of the command stream. Split command stream in different command types. */
   Vector<command::Header, 0> headers_;
@@ -242,22 +245,22 @@ class PassBase {
    * NOTE: Variations using slot will not query a shader interface and can be used before
    * binding a shader.
    */
-  void bind(const char *name, GPUStorageBuf *buffer);
-  void bind(const char *name, GPUUniformBuf *buffer);
-  void bind(const char *name, draw::Image *image);
-  void bind(const char *name, GPUTexture *texture, eGPUSamplerState state = GPU_SAMPLER_MAX);
-  void bind(const char *name, GPUStorageBuf **buffer);
-  void bind(const char *name, GPUUniformBuf **buffer);
-  void bind(const char *name, draw::Image **image);
-  void bind(const char *name, GPUTexture **texture, eGPUSamplerState state = GPU_SAMPLER_MAX);
-  void bind(int slot, GPUStorageBuf *buffer);
-  void bind(int slot, GPUUniformBuf *buffer);
-  void bind(int slot, draw::Image *image);
-  void bind(int slot, GPUTexture *texture, eGPUSamplerState state = GPU_SAMPLER_MAX);
-  void bind(int slot, GPUStorageBuf **buffer);
-  void bind(int slot, GPUUniformBuf **buffer);
-  void bind(int slot, draw::Image **image);
-  void bind(int slot, GPUTexture **texture, eGPUSamplerState state = GPU_SAMPLER_MAX);
+  void bind_image(const char *name, GPUTexture *image);
+  void bind_image(const char *name, GPUTexture **image);
+  void bind_image(int slot, GPUTexture *image);
+  void bind_image(int slot, GPUTexture **image);
+  void bind_texture(const char *name, GPUTexture *texture, eGPUSamplerState state = sampler_auto);
+  void bind_texture(const char *name, GPUTexture **texture, eGPUSamplerState state = sampler_auto);
+  void bind_texture(int slot, GPUTexture *texture, eGPUSamplerState state = sampler_auto);
+  void bind_texture(int slot, GPUTexture **texture, eGPUSamplerState state = sampler_auto);
+  void bind_ssbo(const char *name, GPUStorageBuf *buffer);
+  void bind_ssbo(const char *name, GPUStorageBuf **buffer);
+  void bind_ssbo(int slot, GPUStorageBuf *buffer);
+  void bind_ssbo(int slot, GPUStorageBuf **buffer);
+  void bind_ubo(const char *name, GPUUniformBuf *buffer);
+  void bind_ubo(const char *name, GPUUniformBuf **buffer);
+  void bind_ubo(int slot, GPUUniformBuf *buffer);
+  void bind_ubo(int slot, GPUUniformBuf **buffer);
 
   /**
    * Update a shader constant.
@@ -739,27 +742,27 @@ template<class T> inline void PassBase<T>::material_set(Manager &manager, GPUMat
       if (tex->tiled_mapping_name[0]) {
         GPUTexture *tiles = BKE_image_get_gpu_tiles(tex->ima, iuser, nullptr);
         manager.acquire_texture(tiles);
-        bind(tex->sampler_name, tiles, (eGPUSamplerState)tex->sampler_state);
+        bind_texture(tex->sampler_name, tiles, (eGPUSamplerState)tex->sampler_state);
 
         GPUTexture *tile_map = BKE_image_get_gpu_tilemap(tex->ima, iuser, nullptr);
         manager.acquire_texture(tile_map);
-        bind(tex->tiled_mapping_name, tile_map, (eGPUSamplerState)tex->sampler_state);
+        bind_texture(tex->tiled_mapping_name, tile_map, (eGPUSamplerState)tex->sampler_state);
       }
       else {
         GPUTexture *texture = BKE_image_get_gpu_texture(tex->ima, iuser, nullptr);
         manager.acquire_texture(texture);
-        bind(tex->sampler_name, texture, (eGPUSamplerState)tex->sampler_state);
+        bind_texture(tex->sampler_name, texture, (eGPUSamplerState)tex->sampler_state);
       }
     }
     else if (tex->colorband) {
       /* Color Ramp */
-      bind(tex->sampler_name, *tex->colorband);
+      bind_texture(tex->sampler_name, *tex->colorband);
     }
   }
 
   GPUUniformBuf *ubo = GPU_material_uniform_buffer_get(material);
   if (ubo != nullptr) {
-    bind(GPU_UBO_BLOCK_NAME, ubo);
+    bind_ubo(GPU_UBO_BLOCK_NAME, ubo);
   }
 }
 
@@ -774,89 +777,93 @@ template<class T> inline int PassBase<T>::push_constant_offset(const char *name)
   return GPU_shader_get_uniform(shader_, name);
 }
 
-template<class T> inline void PassBase<T>::bind(const char *name, GPUStorageBuf *buffer)
+template<class T> inline void PassBase<T>::bind_ssbo(const char *name, GPUStorageBuf *buffer)
 {
-  bind(GPU_shader_get_ssbo(shader_, name), buffer);
+  bind_ssbo(GPU_shader_get_ssbo(shader_, name), buffer);
 }
 
-template<class T> inline void PassBase<T>::bind(const char *name, GPUUniformBuf *buffer)
+template<class T> inline void PassBase<T>::bind_ubo(const char *name, GPUUniformBuf *buffer)
 {
-  bind(GPU_shader_get_uniform_block_binding(shader_, name), buffer);
+  bind_ubo(GPU_shader_get_uniform_block_binding(shader_, name), buffer);
 }
 
 template<class T>
-inline void PassBase<T>::bind(const char *name, GPUTexture *texture, eGPUSamplerState state)
+inline void PassBase<T>::bind_texture(const char *name,
+                                      GPUTexture *texture,
+                                      eGPUSamplerState state)
 {
-  bind(GPU_shader_get_texture_binding(shader_, name), texture, state);
+  bind_texture(GPU_shader_get_texture_binding(shader_, name), texture, state);
 }
 
-template<class T> inline void PassBase<T>::bind(const char *name, draw::Image *image)
+template<class T> inline void PassBase<T>::bind_image(const char *name, GPUTexture *image)
 {
-  bind(GPU_shader_get_texture_binding(shader_, name), image);
+  bind_texture(GPU_shader_get_texture_binding(shader_, name), image);
 }
 
-template<class T> inline void PassBase<T>::bind(int slot, GPUStorageBuf *buffer)
+template<class T> inline void PassBase<T>::bind_ssbo(int slot, GPUStorageBuf *buffer)
 {
   create_command(Type::ResourceBind).resource_bind = {slot, buffer};
 }
 
-template<class T> inline void PassBase<T>::bind(int slot, GPUUniformBuf *buffer)
+template<class T> inline void PassBase<T>::bind_ubo(int slot, GPUUniformBuf *buffer)
 {
   create_command(Type::ResourceBind).resource_bind = {slot, buffer};
 }
 
 template<class T>
-inline void PassBase<T>::bind(int slot, GPUTexture *texture, eGPUSamplerState state)
+inline void PassBase<T>::bind_texture(int slot, GPUTexture *texture, eGPUSamplerState state)
 {
   create_command(Type::ResourceBind).resource_bind = {slot, texture, state};
 }
 
-template<class T> inline void PassBase<T>::bind(int slot, draw::Image *image)
+template<class T> inline void PassBase<T>::bind_image(int slot, GPUTexture *image)
 {
-  create_command(Type::ResourceBind).resource_bind = {slot, image};
+  create_command(Type::ResourceBind).resource_bind = {slot, as_image(image)};
 }
 
-template<class T> inline void PassBase<T>::bind(const char *name, GPUStorageBuf **buffer)
+template<class T> inline void PassBase<T>::bind_ssbo(const char *name, GPUStorageBuf **buffer)
 {
-  bind(GPU_shader_get_ssbo(shader_, name), buffer);
+  bind_ssbo(GPU_shader_get_ssbo(shader_, name), buffer);
 }
 
-template<class T> inline void PassBase<T>::bind(const char *name, GPUUniformBuf **buffer)
+template<class T> inline void PassBase<T>::bind_ubo(const char *name, GPUUniformBuf **buffer)
 {
-  bind(GPU_shader_get_uniform_block_binding(shader_, name), buffer);
+  bind_ubo(GPU_shader_get_uniform_block_binding(shader_, name), buffer);
 }
 
 template<class T>
-inline void PassBase<T>::bind(const char *name, GPUTexture **texture, eGPUSamplerState state)
+inline void PassBase<T>::bind_texture(const char *name,
+                                      GPUTexture **texture,
+                                      eGPUSamplerState state)
 {
-  bind(GPU_shader_get_texture_binding(shader_, name), texture, state);
+  bind_texture(GPU_shader_get_texture_binding(shader_, name), texture, state);
 }
 
-template<class T> inline void PassBase<T>::bind(const char *name, draw::Image **image)
+template<class T> inline void PassBase<T>::bind_image(const char *name, GPUTexture **image)
 {
-  bind(GPU_shader_get_texture_binding(shader_, name), image);
+  bind_image(GPU_shader_get_texture_binding(shader_, name), image);
 }
 
-template<class T> inline void PassBase<T>::bind(int slot, GPUStorageBuf **buffer)
+template<class T> inline void PassBase<T>::bind_ssbo(int slot, GPUStorageBuf **buffer)
 {
 
   create_command(Type::ResourceBind).resource_bind = {slot, buffer};
 }
 
-template<class T> inline void PassBase<T>::bind(int slot, GPUUniformBuf **buffer)
+template<class T> inline void PassBase<T>::bind_ubo(int slot, GPUUniformBuf **buffer)
 {
   create_command(Type::ResourceBind).resource_bind = {slot, buffer};
 }
 
 template<class T>
-inline void PassBase<T>::bind(int slot, GPUTexture **texture, eGPUSamplerState state)
+inline void PassBase<T>::bind_texture(int slot, GPUTexture **texture, eGPUSamplerState state)
 {
   create_command(Type::ResourceBind).resource_bind = {slot, texture, state};
 }
 
-template<class T> inline void PassBase<T>::bind(int slot, draw::Image **image)
+template<class T> inline void PassBase<T>::bind_image(int slot, GPUTexture **image)
 {
-  create_command(Type::ResourceBind).resource_bind = {slot, image};
+  create_command(Type::ResourceBind).resource_bind = {slot, as_image(image)};
 }
 
 /** \} */
diff --git a/source/blender/draw/tests/draw_pass_test.cc b/source/blender/draw/tests/draw_pass_test.cc
index d2ab3d925b5..f8a006d096b 100644
--- a/source/blender/draw/tests/draw_pass_test.cc
+++ b/source/blender/draw/tests/draw_pass_test.cc
@@ -31,14 +31,14 @@ static void test_draw_pass_all_commands()
   pass.clear_color_depth_stencil(float4(0.25f, 0.5f, 100.0f, -2000.0f), 0.5f, 0xF0);
   pass.state_stencil(0x80, 0x0F, 0x8F);
   pass.shader_set(GPU_shader_get_builtin_shader(GPU_SHADER_3D_IMAGE_MODULATE_ALPHA));
-  pass.bind("image", tex);
-  pass.bind("image", &tex);
-  pass.bind("missing_image", as_image(tex));  /* Should not crash. */
-  pass.bind("missing_image", as_image(&tex)); /* Should not crash. */
-  pass.bind("missing_ubo", ubo);              /* Should not crash. */
-  pass.bind("missing_ubo", &ubo);             /* Should not crash. */
-  pass.bind("missing_ssbo", ssbo);            /* Should not crash. */
-  pass.bind("missing_ssbo", &ssbo);           /* Should not crash. */
+  pass.bind_texture("image", tex);
+  pass.bind_texture("image", &tex);
+  pass.bind_image("missing_image", tex);  /* Should not crash. */
+  pass.bind_image("missing_image", &tex); /* Should not crash. */
+  pass.bind_ubo("missing_ubo", ubo);      /* Should not crash. */
+  pass.bind_ubo("missing_ubo", &ubo);     /* Should not crash. */
+  pass.bind_ssbo("missing_ssbo", ssbo);   /* Should not crash. */
+  pass.bind_ssbo("missing_ssbo", &ssbo);  /* Should not crash. */
   pass.push_constant("alpha", alpha);
   pass.push_constant("alpha", &alpha);
   pass.push_constant("ModelViewProjectionMatrix", float4x4::identity());