EEVEE-Next: Implement back transparency using PassSortable

10 files changed, 138 insertions, 165 deletions

diff --git a/source/blender/draw/engines/eevee_next/eevee_light.hh b/source/blender/draw/engines/eevee_next/eevee_light.hh
index 72d6d71dd8a..bc13073d765 100644
--- a/source/blender/draw/engines/eevee_next/eevee_light.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_light.hh
@@ -151,7 +151,7 @@ class LightModule {
 #endif
   }
 
-  template<typename T> void bind_resources(draw::detail::Pass<T> *pass)
+  template<typename T> void bind_resources(draw::detail::PassBase<T> *pass)
   {
     /* Storage Buf. */
     pass->bind(LIGHT_CULL_BUF_SLOT, &culling_data_buf_);
diff --git a/source/blender/draw/engines/eevee_next/eevee_material.cc b/source/blender/draw/engines/eevee_next/eevee_material.cc
index ab2e25604d2..13efbd1bd1a 100644
--- a/source/blender/draw/engines/eevee_next/eevee_material.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_material.cc
@@ -145,9 +145,6 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst)
 
 MaterialModule::~MaterialModule()
 {
-  for (Material *mat : material_map_.values()) {
-    delete mat;
-  }
   BKE_id_free(nullptr, glossy_mat);
   BKE_id_free(nullptr, diffuse_mat);
   BKE_id_free(nullptr, error_mat_);
@@ -157,13 +154,12 @@ void MaterialModule::begin_sync()
 {
   queued_shaders_count = 0;
 
-  for (Material *mat : material_map_.values()) {
-    mat->init = false;
-  }
+  material_map_.clear();
   shader_map_.clear();
 }
 
-MaterialPass MaterialModule::material_pass_get(::Material *blender_mat,
+MaterialPass MaterialModule::material_pass_get(Object *ob,
+                                               ::Material *blender_mat,
                                                eMaterialPipeline pipeline_type,
                                                eMaterialGeometry geometry_type)
 {
@@ -203,17 +199,20 @@ MaterialPass MaterialModule::material_pass_get(::Material *blender_mat,
     pipeline_type = MAT_PIPE_FORWARD;
   }
 
-  if ((pipeline_type == MAT_PIPE_FORWARD) &&
+  if (ELEM(pipeline_type,
+           MAT_PIPE_FORWARD,
+           MAT_PIPE_FORWARD_PREPASS,
+           MAT_PIPE_FORWARD_PREPASS_VELOCITY) &&
       GPU_material_flag_get(matpass.gpumat, GPU_MATFLAG_TRANSPARENT)) {
-    /* Transparent needs to use one shgroup per object to support reordering. */
-    matpass.sub_pass = inst_.pipelines.material_add(blender_mat, matpass.gpumat, pipeline_type);
+    /* Transparent pass is generated later. */
+    matpass.sub_pass = nullptr;
   }
   else {
     ShaderKey shader_key(matpass.gpumat, geometry_type, pipeline_type);
 
     PassMain::Sub *shader_sub = shader_map_.lookup_or_add_cb(shader_key, [&]() {
       /* First time encountering this shader. Create a sub that will contain materials using it. */
-      return inst_.pipelines.material_add(blender_mat, matpass.gpumat, pipeline_type);
+      return inst_.pipelines.material_add(ob, blender_mat, matpass.gpumat, pipeline_type);
     });
 
     if (shader_sub != nullptr) {
@@ -226,7 +225,8 @@ MaterialPass MaterialModule::material_pass_get(::Material *blender_mat,
   return matpass;
 }
 
-Material &MaterialModule::material_sync(::Material *blender_mat,
+Material &MaterialModule::material_sync(Object *ob,
+                                        ::Material *blender_mat,
                                         eMaterialGeometry geometry_type,
                                         bool has_motion)
 {
@@ -244,26 +244,32 @@ Material &MaterialModule::material_sync(::Material *blender_mat,
 
   MaterialKey material_key(blender_mat, geometry_type, surface_pipe);
 
-  /* TODO: allocate in blocks to avoid memory fragmentation. */
-  auto add_cb = []() { return new Material(); };
-  Material &mat = *material_map_.lookup_or_add_cb(material_key, add_cb);
-
-  if (mat.init == false) {
-    mat.init = true;
+  Material &mat = material_map_.lookup_or_add_cb(material_key, [&]() {
+    Material mat;
     /* Order is important for transparent. */
-    mat.prepass = material_pass_get(blender_mat, prepass_pipe, geometry_type);
-    mat.shading = material_pass_get(blender_mat, surface_pipe, geometry_type);
+    mat.prepass = material_pass_get(ob, blender_mat, prepass_pipe, geometry_type);
+    mat.shading = material_pass_get(ob, blender_mat, surface_pipe, geometry_type);
     if (blender_mat->blend_shadow == MA_BS_NONE) {
       mat.shadow = MaterialPass();
     }
     else {
-      mat.shadow = material_pass_get(blender_mat, MAT_PIPE_SHADOW, geometry_type);
+      mat.shadow = material_pass_get(ob, blender_mat, MAT_PIPE_SHADOW, geometry_type);
     }
-
     mat.is_alpha_blend_transparent = (blender_mat->blend_method == MA_BM_BLEND) &&
-                                     GPU_material_flag_get(mat.prepass.gpumat,
+                                     GPU_material_flag_get(mat.shading.gpumat,
                                                            GPU_MATFLAG_TRANSPARENT);
+    return mat;
+  });
+
+  if (mat.is_alpha_blend_transparent) {
+    /* Transparent needs to use one sub pass per object to support reordering.
+     * NOTE: Pre-pass needs to be created first in order to be sorted first. */
+    mat.prepass.sub_pass = inst_.pipelines.forward.prepass_transparent_add(
+        ob, blender_mat, mat.shading.gpumat);
+    mat.shading.sub_pass = inst_.pipelines.forward.material_transparent_add(
+        ob, blender_mat, mat.shading.gpumat);
   }
+
   return mat;
 }
 
@@ -291,7 +297,7 @@ MaterialArray &MaterialModule::material_array_get(Object *ob, bool has_motion)
 
   for (auto i : IndexRange(materials_len)) {
     ::Material *blender_mat = material_from_slot(ob, i);
-    Material &mat = material_sync(blender_mat, to_material_geometry(ob), has_motion);
+    Material &mat = material_sync(ob, blender_mat, to_material_geometry(ob), has_motion);
     material_array_.materials.append(&mat);
     material_array_.gpu_materials.append(mat.shading.gpumat);
   }
@@ -304,7 +310,7 @@ Material &MaterialModule::material_get(Object *ob,
                                        eMaterialGeometry geometry_type)
 {
   ::Material *blender_mat = material_from_slot(ob, mat_nr);
-  Material &mat = material_sync(blender_mat, geometry_type, has_motion);
+  Material &mat = material_sync(ob, blender_mat, geometry_type, has_motion);
   return mat;
 }
 
diff --git a/source/blender/draw/engines/eevee_next/eevee_material.hh b/source/blender/draw/engines/eevee_next/eevee_material.hh
index 82ffd2bbd64..ad0c293926b 100644
--- a/source/blender/draw/engines/eevee_next/eevee_material.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_material.hh
@@ -203,12 +203,11 @@ class DefaultSurfaceNodeTree {
  * \{ */
 
 struct MaterialPass {
-  GPUMaterial *gpumat = nullptr;
-  PassMain::Sub *sub_pass = nullptr;
+  GPUMaterial *gpumat;
+  PassMain::Sub *sub_pass;
 };
 
 struct Material {
-  bool init = false;
   bool is_alpha_blend_transparent;
   MaterialPass shadow, shading, prepass;
 };
@@ -228,7 +227,7 @@ class MaterialModule {
  private:
   Instance &inst_;
 
-  Map<MaterialKey, Material *> material_map_;
+  Map<MaterialKey, Material> material_map_;
   Map<ShaderKey, PassMain::Sub *> shader_map_;
 
   MaterialArray material_array_;
@@ -254,13 +253,15 @@ class MaterialModule {
   Material &material_get(Object *ob, bool has_motion, int mat_nr, eMaterialGeometry geometry_type);
 
  private:
-  Material &material_sync(::Material *blender_mat,
+  Material &material_sync(Object *ob,
+                          ::Material *blender_mat,
                           eMaterialGeometry geometry_type,
                           bool has_motion);
 
   /** Return correct material or empty default material if slot is empty. */
   ::Material *material_from_slot(Object *ob, int slot);
-  MaterialPass material_pass_get(::Material *blender_mat,
+  MaterialPass material_pass_get(Object *ob,
+                                 ::Material *blender_mat,
                                  eMaterialPipeline pipeline_type,
                                  eMaterialGeometry geometry_type);
 };
diff --git a/source/blender/draw/engines/eevee_next/eevee_pipeline.cc b/source/blender/draw/engines/eevee_next/eevee_pipeline.cc
index bedcb9ed40f..336c8c8800a 100644
--- a/source/blender/draw/engines/eevee_next/eevee_pipeline.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_pipeline.cc
@@ -65,6 +65,8 @@ void WorldPipeline::render(View &view)
 
 void ForwardPipeline::sync()
 {
+  camera_forward_ = inst_.camera.forward();
+
   DRWState state_depth_only = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS;
   DRWState state_depth_color = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS |
                                DRW_STATE_WRITE_COLOR;
@@ -125,9 +127,18 @@ void ForwardPipeline::sync()
     opaque_double_sided_ps_->state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
   }
   {
-    /* TODO: Transparent pass needs sorting. */
-    // DRWState state = DRW_STATE_DEPTH_LESS_EQUAL;
-    // transparent_ps_ = DRW_pass_create("Forward.Transparent", state);
+    transparent_ps_.init();
+    /* Workaround limitation of PassSortable. Use dummy pass that will be sorted first in all
+     * circumstances. */
+    PassMain::Sub &sub = transparent_ps_.sub("ResourceBind", -FLT_MAX);
+
+    /* Common resources. */
+
+    /* Textures. */
+    sub.bind(RBUFS_UTILITY_TEX_SLOT, inst_.pipelines.utility_tx);
+
+    inst_.lights.bind_resources(&sub);
+    inst_.sampling.bind_resources(&sub);
   }
 }
 
@@ -150,94 +161,37 @@ PassMain::Sub *ForwardPipeline::material_opaque_add(::Material *blender_mat, GPU
   return &pass->sub(GPU_material_get_name(gpumat));
 }
 
-PassMain::Sub *ForwardPipeline::material_transparent_add(::Material *blender_mat,
-                                                         GPUMaterial *gpumat)
-{
-#if 0
-  RenderBuffers &rbufs = inst_.render_buffers;
-  LightModule &lights = inst_.lights;
-  Sampling &sampling = inst_.sampling;
-  // LightProbeModule &lightprobes = inst_.lightprobes;
-  // RaytracingModule &raytracing = inst_.raytracing;
-  // eGPUSamplerState no_interp = GPU_SAMPLER_DEFAULT;
-  DRWShadingGroup *grp = DRW_shgroup_material_create(gpumat, transparent_ps_);
-  lights.bind_resources(grp);
-  sampling.bind_resources(grp);
-  // DRW_shgroup_uniform_block(grp, "sampling_buf", inst_.sampling.ubo_get());
-  // DRW_shgroup_uniform_block(grp, "grids_buf", lightprobes.grid_ubo_get());
-  // DRW_shgroup_uniform_block(grp, "cubes_buf", lightprobes.cube_ubo_get());
-  // DRW_shgroup_uniform_block(grp, "probes_buf", lightprobes.info_ubo_get());
-  // DRW_shgroup_uniform_texture_ref(grp, "lightprobe_grid_tx", lightprobes.grid_tx_ref_get());
-  // DRW_shgroup_uniform_texture_ref(grp, "lightprobe_cube_tx", lightprobes.cube_tx_ref_get());
-  DRW_shgroup_uniform_texture(grp, "utility_tx", inst_.pipelines.utility_tx);
-  /* TODO(fclem): Make this only needed if material uses it ... somehow. */
-  // if (true) {
-  // DRW_shgroup_uniform_texture_ref(
-  //     grp, "sss_transmittance_tx", inst_.subsurface.transmittance_ref_get());
-  // }
-  // if (raytracing.enabled()) {
-  // DRW_shgroup_uniform_block(grp, "rt_diffuse_buf", raytracing.diffuse_data);
-  // DRW_shgroup_uniform_block(grp, "rt_reflection_buf", raytracing.reflection_data);
-  // DRW_shgroup_uniform_block(grp, "rt_refraction_buf", raytracing.refraction_data);
-  // DRW_shgroup_uniform_texture_ref_ex(
-  //     grp, "rt_radiance_tx", &input_screen_radiance_tx_, no_interp);
-  // }
-  // if (raytracing.enabled()) {
-  // DRW_shgroup_uniform_block(grp, "hiz_buf", inst_.hiz.ubo_get());
-  // DRW_shgroup_uniform_texture_ref(grp, "hiz_tx", inst_.hiz_front.texture_ref_get());
-  // }
-  {
-    /* TODO(fclem): This is not needed. This is only to please the OpenGL debug Layer.
-     * If we are to introduce transparency render-passes support, it would be through a separate
-     * pass. */
-    /* AOVs. */
-    DRW_shgroup_uniform_image_ref(grp, "aov_color_img", &rbufs.aov_color_tx);
-    DRW_shgroup_uniform_image_ref(grp, "aov_value_img", &rbufs.aov_value_tx);
-    DRW_shgroup_storage_block_ref(grp, "aov_buf", &inst_.film.aovs_info);
-    /* RenderPasses. */
-    DRW_shgroup_uniform_image_ref(grp, "rp_normal_img", &rbufs.normal_tx);
-    DRW_shgroup_uniform_image_ref(grp, "rp_light_img", &rbufs.light_tx);
-    DRW_shgroup_uniform_image_ref(grp, "rp_diffuse_color_img", &rbufs.diffuse_color_tx);
-    DRW_shgroup_uniform_image_ref(grp, "rp_specular_color_img", &rbufs.specular_color_tx);
-    DRW_shgroup_uniform_image_ref(grp, "rp_emission_img", &rbufs.emission_tx);
-  }
-
-  DRWState state_disable = DRW_STATE_WRITE_DEPTH;
-  DRWState state_enable = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_CUSTOM;
-  if (blender_mat->blend_flag & MA_BL_CULL_BACKFACE) {
-    state_enable |= DRW_STATE_CULL_BACK;
-  }
-  DRW_shgroup_state_disable(grp, state_disable);
-  DRW_shgroup_state_enable(grp, state_enable);
-  return grp;
-#else
-  UNUSED_VARS(blender_mat, gpumat);
-  return nullptr;
-#endif
-}
-
-PassMain::Sub *ForwardPipeline::prepass_transparent_add(::Material *blender_mat,
+PassMain::Sub *ForwardPipeline::prepass_transparent_add(const Object *ob,
+                                                        ::Material *blender_mat,
                                                         GPUMaterial *gpumat)
 {
-#if 0
   if ((blender_mat->blend_flag & MA_BL_HIDE_BACKFACE) == 0) {
     return nullptr;
   }
+  DRWState state = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
+  if ((blender_mat->blend_flag & MA_BL_CULL_BACKFACE)) {
+    state |= DRW_STATE_CULL_BACK;
+  }
+  float sorting_value = math::dot(float3(ob->obmat[3]), camera_forward_);
+  PassMain::Sub *pass = &transparent_ps_.sub(GPU_material_get_name(gpumat), sorting_value);
+  pass->state_set(state);
+  pass->material_set(*inst_.manager, gpumat);
+  return pass;
+}
 
-  DRWShadingGroup *grp = DRW_shgroup_material_create(gpumat, transparent_ps_);
-
-  DRWState state_disable = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_CUSTOM;
-  DRWState state_enable = DRW_STATE_WRITE_DEPTH;
-  if (blender_mat->blend_flag & MA_BL_CULL_BACKFACE) {
-    state_enable |= DRW_STATE_CULL_BACK;
+PassMain::Sub *ForwardPipeline::material_transparent_add(const Object *ob,
+                                                         ::Material *blender_mat,
+                                                         GPUMaterial *gpumat)
+{
+  DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_CUSTOM | DRW_STATE_DEPTH_LESS_EQUAL;
+  if ((blender_mat->blend_flag & MA_BL_CULL_BACKFACE)) {
+    state |= DRW_STATE_CULL_BACK;
   }
-  DRW_shgroup_state_disable(grp, state_disable);
-  DRW_shgroup_state_enable(grp, state_enable);
-  return grp;
-#else
-  UNUSED_VARS(blender_mat, gpumat);
-  return nullptr;
-#endif
+  float sorting_value = math::dot(float3(ob->obmat[3]), camera_forward_);
+  PassMain::Sub *pass = &transparent_ps_.sub(GPU_material_get_name(gpumat), sorting_value);
+  pass->state_set(state);
+  pass->material_set(*inst_.manager, gpumat);
+  return pass;
 }
 
 void ForwardPipeline::render(View &view,
@@ -268,13 +222,7 @@ void ForwardPipeline::render(View &view,
 
   DRW_stats_group_end();
 
-  DRW_stats_group_start("Forward.Transparent");
-  /* TODO(fclem) This is suboptimal. We could sort during sync. */
-  /* FIXME(fclem) This wont work for panoramic, where we need
-   * to sort by distance to camera, not by z. */
-  // DRW_pass_sort_shgroup_z(transparent_ps_);
-  // DRW_draw_pass(transparent_ps_);
-  DRW_stats_group_end();
+  inst_.manager->submit(transparent_ps_, view);
 
   // if (inst_.raytracing.enabled()) {
   //   gbuffer.ray_radiance_tx.release();
diff --git a/source/blender/draw/engines/eevee_next/eevee_pipeline.hh b/source/blender/draw/engines/eevee_next/eevee_pipeline.hh
index 83a61b7145a..0614a963dec 100644
--- a/source/blender/draw/engines/eevee_next/eevee_pipeline.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_pipeline.hh
@@ -13,6 +13,7 @@
 #pragma once
 
 #include "DRW_render.h"
+#include "draw_shader_shared.h"
 
 /* TODO(fclem): Move it to GPU/DRAW. */
 #include "../eevee/eevee_lut.h"
@@ -62,7 +63,8 @@ class ForwardPipeline {
   PassMain::Sub *opaque_single_sided_ps_ = nullptr;
   PassMain::Sub *opaque_double_sided_ps_ = nullptr;
 
-  DRWPass *transparent_ps_ = nullptr;
+  PassSortable transparent_ps_ = {"Forward.Transparent"};
+  float3 camera_forward_;
 
   // GPUTexture *input_screen_radiance_tx_ = nullptr;
 
@@ -71,24 +73,15 @@ class ForwardPipeline {
 
   void sync();
 
-  PassMain::Sub *material_add(::Material *blender_mat, GPUMaterial *gpumat)
-  {
-    return (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT)) ?
-               material_transparent_add(blender_mat, gpumat) :
-               material_opaque_add(blender_mat, gpumat);
-  }
-
-  PassMain::Sub *prepass_add(::Material *blender_mat, GPUMaterial *gpumat, bool has_motion)
-  {
-    return (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT)) ?
-               prepass_transparent_add(blender_mat, gpumat) :
-               prepass_opaque_add(blender_mat, gpumat, has_motion);
-  }
-
-  PassMain::Sub *material_opaque_add(::Material *blender_mat, GPUMaterial *gpumat);
   PassMain::Sub *prepass_opaque_add(::Material *blender_mat, GPUMaterial *gpumat, bool has_motion);
-  PassMain::Sub *material_transparent_add(::Material *blender_mat, GPUMaterial *gpumat);
-  PassMain::Sub *prepass_transparent_add(::Material *blender_mat, GPUMaterial *gpumat);
+  PassMain::Sub *material_opaque_add(::Material *blender_mat, GPUMaterial *gpumat);
+
+  PassMain::Sub *prepass_transparent_add(const Object *ob,
+                                         ::Material *blender_mat,
+                                         GPUMaterial *gpumat);
+  PassMain::Sub *material_transparent_add(const Object *ob,
+                                          ::Material *blender_mat,
+                                          GPUMaterial *gpumat);
 
   void render(View &view,
               Framebuffer &prepass_fb,
@@ -194,26 +187,36 @@ class PipelineModule {
     // velocity.sync();
   }
 
-  PassMain::Sub *material_add(::Material *blender_mat,
+  PassMain::Sub *material_add(Object *ob,
+                              ::Material *blender_mat,
                               GPUMaterial *gpumat,
                               eMaterialPipeline pipeline_type)
   {
     switch (pipeline_type) {
       case MAT_PIPE_DEFERRED_PREPASS:
         // return deferred.prepass_add(blender_mat, gpumat, false);
-        break;
+      case MAT_PIPE_FORWARD_PREPASS:
+        if (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT)) {
+          return forward.prepass_transparent_add(ob, blender_mat, gpumat);
+        }
+        return forward.prepass_opaque_add(blender_mat, gpumat, false);
+
       case MAT_PIPE_DEFERRED_PREPASS_VELOCITY:
         // return deferred.prepass_add(blender_mat, gpumat, true);
-        break;
-      case MAT_PIPE_FORWARD_PREPASS:
-        return forward.prepass_add(blender_mat, gpumat, false);
       case MAT_PIPE_FORWARD_PREPASS_VELOCITY:
-        return forward.prepass_add(blender_mat, gpumat, true);
+        if (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT)) {
+          return forward.prepass_transparent_add(ob, blender_mat, gpumat);
+        }
+        return forward.prepass_opaque_add(blender_mat, gpumat, true);
+
       case MAT_PIPE_DEFERRED:
         // return deferred.material_add(blender_mat, gpumat);
-        break;
       case MAT_PIPE_FORWARD:
-        return forward.material_add(blender_mat, gpumat);
+        if (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT)) {
+          return forward.material_transparent_add(ob, blender_mat, gpumat);
+        }
+        return forward.material_opaque_add(blender_mat, gpumat);
+
       case MAT_PIPE_VOLUME:
         /* TODO(fclem) volume pass. */
         return nullptr;
diff --git a/source/blender/draw/engines/eevee_next/eevee_sampling.hh b/source/blender/draw/engines/eevee_next/eevee_sampling.hh
index 597721c1b9b..72a906d5988 100644
--- a/source/blender/draw/engines/eevee_next/eevee_sampling.hh
+++ b/source/blender/draw/engines/eevee_next/eevee_sampling.hh
@@ -87,7 +87,7 @@ class Sampling {
     DRW_shgroup_storage_block_ref(grp, "sampling_buf", &data_);
   }
 
-  template<typename T> void bind_resources(draw::detail::Pass<T> *pass)
+  template<typename T> void bind_resources(draw::detail::PassBase<T> *pass)
   {
     /* Storage Buf. */
     pass->bind(SAMPLING_BUF_SLOT, &data_);
diff --git a/source/blender/draw/engines/eevee_next/eevee_shader.cc b/source/blender/draw/engines/eevee_next/eevee_shader.cc
index bcdf6d2c872..154f6b96e4c 100644
--- a/source/blender/draw/engines/eevee_next/eevee_shader.cc
+++ b/source/blender/draw/engines/eevee_next/eevee_shader.cc
@@ -199,7 +199,19 @@ void ShaderModule::material_create_info_ammend(GPUMaterial *gpumat, GPUCodegenOu
 
   if (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT)) {
     info.define("MAT_TRANSPARENT");
+    /* Transparent material do not have any velocity specific pipeline. */
+    if (pipeline_type == MAT_PIPE_FORWARD_PREPASS_VELOCITY) {
+      pipeline_type = MAT_PIPE_FORWARD_PREPASS;
+    }
+  }
+
+  if (GPU_material_flag_get(gpumat, GPU_MATFLAG_TRANSPARENT) == false &&
+      pipeline_type == MAT_PIPE_FORWARD) {
+    /* Opaque forward do support AOVs and render pass. */
+    info.additional_info("eevee_aov_out");
+    info.additional_info("eevee_render_pass_out");
   }
+
   if (GPU_material_flag_get(gpumat, GPU_MATFLAG_BARYCENTRIC)) {
     switch (geometry_type) {
       case MAT_GEOM_MESH:
diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_surf_depth_frag.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_surf_depth_frag.glsl
index bd32215ddc2..183aac1e546 100644
--- a/source/blender/draw/engines/eevee_next/shaders/eevee_surf_depth_frag.glsl
+++ b/source/blender/draw/engines/eevee_next/shaders/eevee_surf_depth_frag.glsl
@@ -6,6 +6,7 @@
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
 #pragma BLENDER_REQUIRE(common_math_lib.glsl)
 #pragma BLENDER_REQUIRE(common_hair_lib.glsl)
+#pragma BLENDER_REQUIRE(eevee_sampling_lib.glsl)
 #pragma BLENDER_REQUIRE(eevee_nodetree_lib.glsl)
 #pragma BLENDER_REQUIRE(eevee_surf_lib.glsl)
 #pragma BLENDER_REQUIRE(eevee_velocity_lib.glsl)
@@ -73,8 +74,7 @@ void main()
 
   nodetree_surface();
 
-  // float noise_offset = sampling_rng_1D_get(SAMPLING_TRANSPARENCY);
-  float noise_offset = 0.5;
+  float noise_offset = sampling_rng_1D_get(SAMPLING_TRANSPARENCY);
   float random_threshold = hashed_alpha_threshold(1.0, noise_offset, g_data.P);
 
   float transparency = avg(g_transmittance);
diff --git a/source/blender/draw/engines/eevee_next/shaders/eevee_surf_forward_frag.glsl b/source/blender/draw/engines/eevee_next/shaders/eevee_surf_forward_frag.glsl
index 3f2349b30a1..71f880c1dc1 100644
--- a/source/blender/draw/engines/eevee_next/shaders/eevee_surf_forward_frag.glsl
+++ b/source/blender/draw/engines/eevee_next/shaders/eevee_surf_forward_frag.glsl
@@ -97,6 +97,7 @@ void main()
   out_normal += g_refraction_data.N * g_refraction_data.weight;
   out_normal = safe_normalize(out_normal);
 
+#ifndef MAT_RENDER_PASS_SUPPORT
   ivec2 out_texel = ivec2(gl_FragCoord.xy);
   imageStore(rp_normal_img, out_texel, vec4(out_normal, 1.0));
   imageStore(
@@ -106,6 +107,7 @@ void main()
   imageStore(rp_diffuse_color_img, out_texel, vec4(g_diffuse_data.color, 1.0));
   imageStore(rp_specular_color_img, out_texel, vec4(specular_color, 1.0));
   imageStore(rp_emission_img, out_texel, vec4(g_emission, 1.0));
+#endif
 
   out_radiance.rgb *= 1.0 - g_holdout;
 
diff --git a/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh b/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh
index 47bd6afbe13..8882282e2ac 100644
--- a/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh
+++ b/source/blender/draw/engines/eevee_next/shaders/infos/eevee_material_info.hh
@@ -84,6 +84,14 @@ GPU_SHADER_CREATE_INFO(eevee_aov_out)
     .image_array_out(RBUFS_AOV_VALUE_SLOT, Qualifier::WRITE, GPU_R16F, "aov_value_img")
     .storage_buf(RBUFS_AOV_BUF_SLOT, Qualifier::READ, "AOVsInfoData", "aov_buf");
 
+GPU_SHADER_CREATE_INFO(eevee_render_pass_out)
+    .define("MAT_RENDER_PASS_SUPPORT")
+    .image_out(RBUFS_NORMAL_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_normal_img")
+    .image_array_out(RBUFS_LIGHT_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_light_img")
+    .image_out(RBUFS_DIFF_COLOR_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_diffuse_color_img")
+    .image_out(RBUFS_SPEC_COLOR_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_specular_color_img")
+    .image_out(RBUFS_EMISSION_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_emission_img");
+
 GPU_SHADER_CREATE_INFO(eevee_surf_deferred)
     .vertex_out(eevee_surf_iface)
     /* NOTE: This removes the possibility of using gl_FragDepth. */
@@ -113,27 +121,20 @@ GPU_SHADER_CREATE_INFO(eevee_surf_forward)
     .fragment_out(0, Type::VEC4, "out_radiance", DualBlend::SRC_0)
     .fragment_out(0, Type::VEC4, "out_transmittance", DualBlend::SRC_1)
     .fragment_source("eevee_surf_forward_frag.glsl")
-    .image_out(RBUFS_NORMAL_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_normal_img")
-    .image_array_out(RBUFS_LIGHT_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_light_img")
-    .image_out(RBUFS_DIFF_COLOR_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_diffuse_color_img")
-    .image_out(RBUFS_SPEC_COLOR_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_specular_color_img")
-    .image_out(RBUFS_EMISSION_SLOT, Qualifier::READ_WRITE, GPU_RGBA16F, "rp_emission_img")
-    .additional_info("eevee_aov_out",
-                     "eevee_light_data",
-                     "eevee_utility_texture",
-                     "eevee_sampling_data"
-                     //  "eevee_lightprobe_data",
+    .additional_info("eevee_light_data", "eevee_utility_texture", "eevee_sampling_data"
+                     // "eevee_lightprobe_data",
+                     // "eevee_shadow_data"
                      /* Optionally added depending on the material. */
                      // "eevee_raytrace_data",
                      // "eevee_transmittance_data",
-                     //  "eevee_shadow_data"
+                     // "eevee_aov_out",
+                     // "eevee_render_pass_out",
     );
 
 GPU_SHADER_CREATE_INFO(eevee_surf_depth)
     .vertex_out(eevee_surf_iface)
     .fragment_source("eevee_surf_depth_frag.glsl")
-    // .additional_info("eevee_sampling_data", "eevee_utility_texture")
-    ;
+    .additional_info("eevee_sampling_data", "eevee_utility_texture");
 
 GPU_SHADER_CREATE_INFO(eevee_surf_world)
     .vertex_out(eevee_surf_iface)