GPU: Replace `GPUMaterialVolumeGrid` by `GPUMaterialAttribute`

This is to make the codegen and shading nodes object type agnostic. This
is essential for flexibility of the engine to use the nodetree as it see
fits.

The essential volume attributes struct properties are moved to the
`GPUMaterialAttribute` which see its final input name set on creation.

The binding process is centralized into `draw_volume.cc` to avoid
duplicating the code between multiple engines. It mimics the hair attributes
process.

Volume object grid transforms and other per object uniforms are packed into
one UBO per object. The grid transform is now based on object which simplify
the matrix preparations.

This also gets rid of the double transforms and use object info orco factors
for volume objects.

Tagging @brecht because he did the initial implementation of Volume Grids.

17 files changed, 467 insertions, 258 deletions

diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt
index 6d3c203b076..522039a1df8 100644
--- a/source/blender/draw/CMakeLists.txt
+++ b/source/blender/draw/CMakeLists.txt
@@ -98,6 +98,7 @@ set(SRC
   intern/draw_texture_pool.cc
   intern/draw_view.c
   intern/draw_view_data.cc
+  intern/draw_volume.cc
   intern/smaa_textures.c
   engines/basic/basic_engine.c
   engines/basic/basic_shader.c
@@ -132,6 +133,9 @@ set(SRC
   engines/eevee/eevee_temporal_sampling.c
   engines/eevee/eevee_volumes.c
   engines/eevee_next/eevee_engine.cc
+  engines/eevee_next/eevee_instance.cc
+  engines/eevee_next/eevee_shader.cc
+  engines/eevee_next/eevee_id_map.cc
   engines/workbench/workbench_data.c
   engines/workbench/workbench_effect_antialiasing.c
   engines/workbench/workbench_effect_cavity.c
diff --git a/source/blender/draw/engines/eevee/eevee_shaders.c b/source/blender/draw/engines/eevee/eevee_shaders.c
index 4e4a2a9eb8e..85cc7f65126 100644
--- a/source/blender/draw/engines/eevee/eevee_shaders.c
+++ b/source/blender/draw/engines/eevee/eevee_shaders.c
@@ -1487,6 +1487,10 @@ struct GPUMaterial *EEVEE_material_get(
   GPUMaterial *mat = eevee_material_get_ex(scene, ma, wo, options, deferred);
 
   int status = GPU_material_status(mat);
+  /* Return null material and bypass drawing for volume shaders. */
+  if ((options & VAR_MAT_VOLUME) && status != GPU_MAT_SUCCESS) {
+    return NULL;
+  }
   switch (status) {
     case GPU_MAT_SUCCESS:
       break;
diff --git a/source/blender/draw/engines/eevee/eevee_shaders_extra.cc b/source/blender/draw/engines/eevee/eevee_shaders_extra.cc
index bb1a0b0abe4..7df26a95cfe 100644
--- a/source/blender/draw/engines/eevee/eevee_shaders_extra.cc
+++ b/source/blender/draw/engines/eevee/eevee_shaders_extra.cc
@@ -97,12 +97,26 @@ void eevee_shader_material_create_info_amend(GPUMaterial *gpumat,
     }
     attr_load << "};\n";
     attr_load << iface.name << " " << iface.instance_name << ";\n";
-    /* Global vars just to make code valid. Only Orco is supported. */
-    for (const ShaderCreateInfo::VertIn &in : info.vertex_inputs_) {
-      attr_load << in.type << " " << in.name << ";\n";
+    if (!is_volume) {
+      /* Global vars just to make code valid. Only Orco is supported. */
+      for (const ShaderCreateInfo::VertIn &in : info.vertex_inputs_) {
+        attr_load << in.type << " " << in.name << ";\n";
+      }
     }
     info.vertex_out_interfaces_.clear();
   }
+  if (is_volume) {
+    /** Volume grid attributes come from 3D textures. Transfer attributes to samplers. */
+    for (auto &input : info.vertex_inputs_) {
+      info.sampler(0, ImageType::FLOAT_3D, input.name, Frequency::BATCH);
+    }
+    info.additional_info("draw_volume_infos");
+    /* Do not add twice. */
+    if (!GPU_material_flag_get(gpumat, GPU_MATFLAG_OBJECT_INFO)) {
+      info.additional_info("draw_object_infos");
+    }
+    info.vertex_inputs_.clear();
+  }
 
   if (!is_volume) {
     info.define("EEVEE_GENERATED_INTERFACE");
diff --git a/source/blender/draw/engines/eevee/eevee_volumes.c b/source/blender/draw/engines/eevee/eevee_volumes.c
index 0ac6c6ad97c..b8bef61f8b1 100644
--- a/source/blender/draw/engines/eevee/eevee_volumes.c
+++ b/source/blender/draw/engines/eevee/eevee_volumes.c
@@ -45,30 +45,6 @@ static struct {
   GPUTexture *dummy_transmit;
 } e_data = {NULL}; /* Engine data */
 
-static void eevee_create_textures_volumes(void)
-{
-  const float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-  e_data.dummy_zero = DRW_texture_create_3d(1, 1, 1, GPU_RGBA8, DRW_TEX_WRAP, zero);
-
-  const float one[4] = {1.0f, 1.0f, 1.0f, 1.0f};
-  e_data.dummy_one = DRW_texture_create_3d(1, 1, 1, GPU_RGBA8, DRW_TEX_WRAP, one);
-
-  const float flame = 0.0f;
-  e_data.dummy_flame = DRW_texture_create_3d(1, 1, 1, GPU_R8, DRW_TEX_WRAP, &flame);
-}
-
-static GPUTexture *eevee_volume_default_texture(eGPUVolumeDefaultValue default_value)
-{
-  switch (default_value) {
-    case GPU_VOLUME_DEFAULT_0:
-      return e_data.dummy_zero;
-    case GPU_VOLUME_DEFAULT_1:
-      return e_data.dummy_one;
-  }
-
-  return e_data.dummy_zero;
-}
-
 void EEVEE_volumes_set_jitter(EEVEE_ViewLayerData *sldata, uint current_sample)
 {
   EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
@@ -224,11 +200,6 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
   Scene *scene = draw_ctx->scene;
   DRWShadingGroup *grp = NULL;
 
-  /* Textures */
-  if (!e_data.dummy_zero) {
-    eevee_create_textures_volumes();
-  }
-
   /* Quick breakdown of the Volumetric rendering:
    *
    * The rendering is separated in 4 stages:
@@ -265,7 +236,7 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
       !LOOK_DEV_STUDIO_LIGHT_ENABLED(draw_ctx->v3d)) {
     struct GPUMaterial *mat = EEVEE_material_get(vedata, scene, NULL, wo, VAR_MAT_VOLUME);
 
-    if (GPU_material_has_volume_output(mat)) {
+    if (mat && GPU_material_has_volume_output(mat)) {
       grp = DRW_shgroup_material_create(mat, psl->volumetric_world_ps);
     }
 
@@ -280,11 +251,7 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
       DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
 
       /* Fix principle volumetric not working with world materials. */
-      ListBase gpu_grids = GPU_material_volume_grids(mat);
-      LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, &gpu_grids) {
-        DRW_shgroup_uniform_texture(
-            grp, gpu_grid->sampler_name, eevee_volume_default_texture(gpu_grid->default_value));
-      }
+      grp = DRW_shgroup_volume_create_sub(NULL, NULL, grp, mat);
 
       DRW_shgroup_call_procedural_triangles(grp, NULL, common_data->vol_tex_size[2]);
 
@@ -296,186 +263,17 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
     /* If no world or volume material is present just clear the buffer with this drawcall */
     grp = DRW_shgroup_create(EEVEE_shaders_volumes_clear_sh_get(), psl->volumetric_world_ps);
     DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
+    DRW_shgroup_uniform_block(grp, "grid_block", sldata->grid_ubo);
     DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
+    DRW_shgroup_uniform_block(grp, "planar_block", sldata->planar_ubo);
     DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
+    DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
     DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
 
     DRW_shgroup_call_procedural_triangles(grp, NULL, common_data->vol_tex_size[2]);
   }
 }
 
-static bool eevee_volume_object_grids_init(Object *ob, ListBase *gpu_grids, DRWShadingGroup *grp)
-{
-  Volume *volume = ob->data;
-  BKE_volume_load(volume, G.main);
-
-  /* Test if we need to use multiple transforms. */
-  DRWVolumeGrid *first_drw_grid = NULL;
-  bool multiple_transforms = true;
-
-  LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, gpu_grids) {
-    const VolumeGrid *volume_grid = BKE_volume_grid_find_for_read(volume, gpu_grid->name);
-    DRWVolumeGrid *drw_grid = (volume_grid) ?
-                                  DRW_volume_batch_cache_get_grid(volume, volume_grid) :
-                                  NULL;
-
-    if (drw_grid) {
-      if (first_drw_grid == NULL) {
-        first_drw_grid = drw_grid;
-      }
-      else if (drw_grid &&
-               !equals_m4m4(drw_grid->object_to_texture, first_drw_grid->object_to_texture)) {
-        multiple_transforms = true;
-        break;
-      }
-    }
-  }
-
-  /* Bail out of no grids to render. */
-  if (first_drw_grid == NULL) {
-    return false;
-  }
-
-  /* Set transform matrix for the volume as a whole. This one is also used for
-   * clipping so must map the entire bounding box to 0..1. */
-  float bounds_to_object[4][4];
-
-  if (multiple_transforms) {
-    /* For multiple grids with different transform, we first transform from object space
-     * to bounds, then for each individual grid from bounds to texture. */
-    const BoundBox *bb = BKE_volume_boundbox_get(ob);
-    float bb_size[3];
-    sub_v3_v3v3(bb_size, bb->vec[6], bb->vec[0]);
-    size_to_mat4(bounds_to_object, bb_size);
-    copy_v3_v3(bounds_to_object[3], bb->vec[0]);
-
-    invert_m4_m4(first_drw_grid->object_to_bounds, bounds_to_object);
-    DRW_shgroup_uniform_mat4(grp, "volumeObjectToTexture", first_drw_grid->object_to_bounds);
-  }
-  else {
-    /* All grid transforms are equal, we can transform to texture space immediately. */
-    DRW_shgroup_uniform_mat4(grp, "volumeObjectToTexture", first_drw_grid->object_to_texture);
-  }
-
-  /* Don't use orco transform here, only matrix. */
-  DRW_shgroup_uniform_vec3_copy(grp, "volumeOrcoLoc", (float[3]){0.5f, 0.5f, 0.5f});
-  DRW_shgroup_uniform_vec3_copy(grp, "volumeOrcoSize", (float[3]){0.5f, 0.5f, 0.5f});
-
-  /* Set density scale. */
-  const float density_scale = BKE_volume_density_scale(volume, ob->obmat);
-  DRW_shgroup_uniform_float_copy(grp, "volumeDensityScale", density_scale);
-
-  /* Bind volume grid textures. */
-  LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, gpu_grids) {
-    const VolumeGrid *volume_grid = BKE_volume_grid_find_for_read(volume, gpu_grid->name);
-    DRWVolumeGrid *drw_grid = (volume_grid) ?
-                                  DRW_volume_batch_cache_get_grid(volume, volume_grid) :
-                                  NULL;
-
-    /* Handle 3 cases here:
-     * - Grid exists and texture was loaded -> use texture.
-     * - Grid exists but has zero size or failed to load -> use zero.
-     * - Grid does not exist -> use default value. */
-    GPUTexture *grid_tex = (drw_grid)    ? drw_grid->texture :
-                           (volume_grid) ? e_data.dummy_zero :
-                                           eevee_volume_default_texture(gpu_grid->default_value);
-
-    DRW_shgroup_uniform_texture(grp, gpu_grid->sampler_name, grid_tex);
-
-    if (drw_grid && multiple_transforms) {
-      /* Specify per-volume transform matrix that is applied after the
-       * transform from object to bounds. */
-      mul_m4_m4m4(drw_grid->bounds_to_texture, drw_grid->object_to_texture, bounds_to_object);
-      DRW_shgroup_uniform_mat4(grp, gpu_grid->transform_name, drw_grid->bounds_to_texture);
-    }
-  }
-
-  return true;
-}
-
-static bool eevee_volume_object_mesh_init(Scene *scene,
-                                          Object *ob,
-                                          ListBase *gpu_grids,
-                                          DRWShadingGroup *grp)
-{
-  static const float white[3] = {1.0f, 1.0f, 1.0f};
-  ModifierData *md = NULL;
-
-  /* Smoke Simulation */
-  if ((md = BKE_modifiers_findby_type(ob, eModifierType_Fluid)) &&
-      (BKE_modifier_is_enabled(scene, md, eModifierMode_Realtime)) &&
-      ((FluidModifierData *)md)->domain != NULL) {
-    FluidModifierData *fmd = (FluidModifierData *)md;
-    FluidDomainSettings *fds = fmd->domain;
-
-    /* Don't try to show liquid domains here. */
-    if (!fds->fluid || !(fds->type == FLUID_DOMAIN_TYPE_GAS)) {
-      return false;
-    }
-
-    /* Don't show smoke before simulation starts, this could be made an option in the future. */
-    /* (sebbas): Always show smoke for manta */
-#if 0
-    const DRWContextState *draw_ctx = DRW_context_state_get();
-    const bool show_smoke = ((int)DEG_get_ctime(draw_ctx->depsgraph) >=
-                             *fds->point_cache[0]->startframe);
-#endif
-
-    if (fds->fluid && (fds->type == FLUID_DOMAIN_TYPE_GAS) /* && show_smoke */) {
-      DRW_smoke_ensure(fmd, fds->flags & FLUID_DOMAIN_USE_NOISE);
-    }
-
-    LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, gpu_grids) {
-      if (STREQ(gpu_grid->name, "density")) {
-        DRW_shgroup_uniform_texture_ref(
-            grp, gpu_grid->sampler_name, fds->tex_density ? &fds->tex_density : &e_data.dummy_one);
-      }
-      else if (STREQ(gpu_grid->name, "color")) {
-        DRW_shgroup_uniform_texture_ref(
-            grp, gpu_grid->sampler_name, fds->tex_color ? &fds->tex_color : &e_data.dummy_one);
-      }
-      else if (STR_ELEM(gpu_grid->name, "flame", "temperature")) {
-        DRW_shgroup_uniform_texture_ref(
-            grp, gpu_grid->sampler_name, fds->tex_flame ? &fds->tex_flame : &e_data.dummy_flame);
-      }
-      else {
-        DRW_shgroup_uniform_texture(
-            grp, gpu_grid->sampler_name, eevee_volume_default_texture(gpu_grid->default_value));
-      }
-    }
-
-    /* Constant Volume color. */
-    bool use_constant_color = ((fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
-                               (fds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
-
-    DRW_shgroup_uniform_vec3(
-        grp, "volumeColor", (use_constant_color) ? fds->active_color : white, 1);
-
-    /* Output is such that 0..1 maps to 0..1000K */
-    DRW_shgroup_uniform_vec2(grp, "volumeTemperature", &fds->flame_ignition, 1);
-  }
-  else {
-    LISTBASE_FOREACH (GPUMaterialVolumeGrid *, gpu_grid, gpu_grids) {
-      DRW_shgroup_uniform_texture(
-          grp, gpu_grid->sampler_name, eevee_volume_default_texture(gpu_grid->default_value));
-    }
-  }
-
-  /* Transform for mesh volumes. */
-  static const float unit_mat[4][4] = {{1.0f, 0.0f, 0.0f, 0.0f},
-                                       {0.0f, 1.0f, 0.0f, 0.0f},
-                                       {0.0f, 0.0f, 1.0f, 0.0f},
-                                       {0.0f, 0.0f, 0.0f, 1.0f}};
-  float *texco_loc, *texco_size;
-  BKE_mesh_texspace_get_reference((struct Mesh *)ob->data, NULL, &texco_loc, &texco_size);
-
-  DRW_shgroup_uniform_mat4(grp, "volumeObjectToTexture", unit_mat);
-  DRW_shgroup_uniform_vec3(grp, "volumeOrcoLoc", texco_loc, 1);
-  DRW_shgroup_uniform_vec3(grp, "volumeOrcoSize", texco_size, 1);
-
-  return true;
-}
-
 void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
                                     EEVEE_Data *vedata,
                                     Scene *scene,
@@ -502,15 +300,22 @@ void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
 
   int mat_options = VAR_MAT_VOLUME | VAR_MAT_MESH;
   struct GPUMaterial *mat = EEVEE_material_get(vedata, scene, ma, NULL, mat_options);
-  eGPUMaterialStatus status = GPU_material_status(mat);
 
   /* If shader failed to compile or is currently compiling. */
-  if (status != GPU_MAT_SUCCESS) {
+  if (mat == NULL) {
     return;
   }
 
+  /* TODO(fclem): Reuse main shading group to avoid shading binding cost just like for surface
+   * shaders. */
   DRWShadingGroup *grp = DRW_shgroup_material_create(mat, vedata->psl->volumetric_objects_ps);
 
+  grp = DRW_shgroup_volume_create_sub(scene, ob, grp, mat);
+
+  if (grp == NULL) {
+    return;
+  }
+
   /* TODO(fclem): remove those "unnecessary" UBOs */
   DRW_shgroup_uniform_block(grp, "planar_block", sldata->planar_ubo);
   DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
@@ -518,22 +323,7 @@ void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
   DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
   DRW_shgroup_uniform_block(grp, "grid_block", sldata->grid_ubo);
   DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
-
   DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
-
-  ListBase gpu_grids = GPU_material_volume_grids(mat);
-
-  if (ob->type == OB_VOLUME) {
-    if (!eevee_volume_object_grids_init(ob, &gpu_grids, grp)) {
-      return;
-    }
-  }
-  else {
-    if (!eevee_volume_object_mesh_init(scene, ob, &gpu_grids, grp)) {
-      return;
-    }
-  }
-
   /* TODO: Reduce to number of slices intersecting. */
   /* TODO: Preemptive culling. */
   DRW_shgroup_call_procedural_triangles(grp, ob, sldata->common_data.vol_tex_size[2]);
diff --git a/source/blender/draw/engines/eevee/shaders/shadow_vert.glsl b/source/blender/draw/engines/eevee/shaders/shadow_vert.glsl
index 0e8e8dd9d01..ab0f4d6bec8 100644
--- a/source/blender/draw/engines/eevee/shaders/shadow_vert.glsl
+++ b/source/blender/draw/engines/eevee/shaders/shadow_vert.glsl
@@ -144,3 +144,13 @@ vec3 attr_load_uv(vec3 attr)
   return attr;
 }
 #endif
+
+/* Passthrough. */
+float attr_load_temperature_post(float attr)
+{
+  return attr;
+}
+vec4 attr_load_color_post(vec4 attr)
+{
+  return attr;
+}
diff --git a/source/blender/draw/engines/eevee/shaders/surface_frag.glsl b/source/blender/draw/engines/eevee/shaders/surface_frag.glsl
index 9ad7a4fdbc1..79ec3807d0b 100644
--- a/source/blender/draw/engines/eevee/shaders/surface_frag.glsl
+++ b/source/blender/draw/engines/eevee/shaders/surface_frag.glsl
@@ -179,3 +179,13 @@ vec3 attr_load_uv(vec3 attr)
 {
   return vec3(0);
 }
+
+/* Passthrough. */
+float attr_load_temperature_post(float attr)
+{
+  return attr;
+}
+vec4 attr_load_color_post(vec4 attr)
+{
+  return attr;
+}
diff --git a/source/blender/draw/engines/eevee/shaders/surface_vert.glsl b/source/blender/draw/engines/eevee/shaders/surface_vert.glsl
index 6c6b810422b..49c18832f72 100644
--- a/source/blender/draw/engines/eevee/shaders/surface_vert.glsl
+++ b/source/blender/draw/engines/eevee/shaders/surface_vert.glsl
@@ -157,3 +157,13 @@ vec3 attr_load_uv(vec3 attr)
   return attr;
 }
 #endif
+
+/* Passthrough. */
+float attr_load_temperature_post(float attr)
+{
+  return attr;
+}
+vec4 attr_load_color_post(vec4 attr)
+{
+  return attr;
+}
diff --git a/source/blender/draw/engines/eevee/shaders/volumetric_frag.glsl b/source/blender/draw/engines/eevee/shaders/volumetric_frag.glsl
index e0a79872928..914261d7f59 100644
--- a/source/blender/draw/engines/eevee/shaders/volumetric_frag.glsl
+++ b/source/blender/draw/engines/eevee/shaders/volumetric_frag.glsl
@@ -4,17 +4,13 @@
 /* Based on Frosbite Unified Volumetric.
  * https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite */
 
-#ifdef MESH_SHADER
-uniform vec3 volumeOrcoLoc;
-uniform vec3 volumeOrcoSize;
-uniform mat4 volumeObjectToTexture;
-uniform float volumeDensityScale = 1.0;
-#endif
+/* Store volumetric properties into the froxel textures. */
 
 flat in int slice;
 
 /* Warning: these are not attributes, these are global vars. */
 vec3 worldPosition = vec3(0.0);
+vec3 objectPosition = vec3(0.0);
 vec3 viewPosition = vec3(0.0);
 vec3 viewNormal = vec3(0.0);
 vec3 volumeOrco = vec3(0.0);
@@ -24,9 +20,9 @@ layout(location = 1) out vec4 volumeExtinction;
 layout(location = 2) out vec4 volumeEmissive;
 layout(location = 3) out vec4 volumePhase;
 
-/* Store volumetric properties into the froxel textures. */
+int attr_id;
 
-#ifdef MESH_SHADER
+#ifndef CLEAR
 GlobalData init_globals(void)
 {
   GlobalData surf;
@@ -80,10 +76,8 @@ void main()
   viewPosition = get_view_space_from_depth(ndc_cell.xy, ndc_cell.z);
   worldPosition = point_view_to_world(viewPosition);
 #ifdef MESH_SHADER
-  volumeOrco = point_world_to_object(worldPosition);
-  /* TODO: redundant transform */
-  volumeOrco = (volumeOrco - volumeOrcoLoc + volumeOrcoSize) / (volumeOrcoSize * 2.0);
-  volumeOrco = (volumeObjectToTexture * vec4(volumeOrco, 1.0)).xyz;
+  objectPosition = point_world_to_object(worldPosition);
+  volumeOrco = OrcoTexCoFactors[0].xyz + objectPosition * OrcoTexCoFactors[1].xyz;
 
   if (any(lessThan(volumeOrco, vec3(0.0))) || any(greaterThan(volumeOrco, vec3(1.0)))) {
     /* Note: Discard is not an explicit return in Metal prior to versions 2.3.
@@ -100,15 +94,13 @@ void main()
   volumeEmissive = vec4(0.0, 0.0, 0.0, 1.0);
   volumePhase = vec4(0.0, 0.0, 0.0, 0.0);
 #else
-#  ifdef MESH_SHADER
   g_data = init_globals();
   attrib_load();
-#  endif
   Closure cl = nodetree_exec();
 #  ifdef MESH_SHADER
-  cl.scatter *= volumeDensityScale;
-  cl.absorption *= volumeDensityScale;
-  cl.emission *= volumeDensityScale;
+  cl.scatter *= drw_volume.density_scale;
+  cl.absorption *= drw_volume.density_scale;
+  cl.emission *= drw_volume.density_scale;
 #  endif
 
   volumeScattering = vec4(cl.scatter, 1.0);
@@ -124,35 +116,72 @@ void main()
 #endif
 }
 
-vec3 attr_load_orco(vec4 orco)
+vec3 grid_coordinates()
+{
+  vec3 co = volumeOrco;
+#ifdef MESH_SHADER
+  /* Optional per-grid transform. */
+  if (drw_volume.grids_xform[attr_id][3][3] != 0.0) {
+    co = (drw_volume.grids_xform[attr_id] * vec4(objectPosition, 1.0)).xyz;
+  }
+#endif
+  attr_id += 1;
+  return co;
+}
+
+vec3 attr_load_orco(sampler3D orco)
 {
+  attr_id += 1;
   return volumeOrco;
 }
-vec4 attr_load_tangent(vec4 tangent)
+vec4 attr_load_tangent(sampler3D tangent)
 {
+  attr_id += 1;
   return vec4(0);
 }
-vec4 attr_load_vec4(vec4 attr)
+vec4 attr_load_vec4(sampler3D tex)
 {
-  return vec4(0);
+  return texture(tex, grid_coordinates());
 }
-vec3 attr_load_vec3(vec3 attr)
+vec3 attr_load_vec3(sampler3D tex)
 {
-  return vec3(0);
+  return texture(tex, grid_coordinates()).rgb;
 }
-vec2 attr_load_vec2(vec2 attr)
+vec2 attr_load_vec2(sampler3D tex)
 {
-  return vec2(0);
+  return texture(tex, grid_coordinates()).rg;
 }
-float attr_load_float(float attr)
+float attr_load_float(sampler3D tex)
 {
-  return 0.0;
+  return texture(tex, grid_coordinates()).r;
 }
-vec4 attr_load_color(vec4 attr)
+vec4 attr_load_color(sampler3D tex)
 {
-  return vec4(0);
+  return texture(tex, grid_coordinates());
 }
-vec3 attr_load_uv(vec3 attr)
+vec3 attr_load_uv(sampler3D attr)
 {
+  attr_id += 1;
   return vec3(0);
 }
+
+/* TODO(@fclem): These implementation details should concern the DRWManager and not be a fix on
+ * the engine side. But as of now, the engines are reponsible for loading the attributes. */
+float attr_load_temperature_post(float attr)
+{
+#ifdef MESH_SHADER
+  /* Bring the into standard range without having to modify the grid values */
+  attr = (attr > 0.01) ? (attr * drw_volume.temperature_mul + drw_volume.temperature_bias) : 0.0;
+#endif
+  return attr;
+}
+vec4 attr_load_color_post(vec4 attr)
+{
+#ifdef MESH_SHADER
+  /* Density is premultiplied for interpolation, divide it out here. */
+  attr.rgb *= safe_rcp(attr.a);
+  attr.rgb *= drw_volume.color_mul.rgb;
+  attr.a = 1.0;
+#endif
+  return attr;
+}
diff --git a/source/blender/draw/intern/DRW_gpu_wrapper.hh b/source/blender/draw/intern/DRW_gpu_wrapper.hh
index ed94c485b32..d7e752a43f4 100644
--- a/source/blender/draw/intern/DRW_gpu_wrapper.hh
+++ b/source/blender/draw/intern/DRW_gpu_wrapper.hh
@@ -53,6 +53,8 @@
  *
  */
 
+#include "DRW_render.h"
+
 #include "MEM_guardedalloc.h"
 
 #include "draw_texture_pool.h"
@@ -61,6 +63,7 @@
 #include "BLI_span.hh"
 #include "BLI_utildefines.h"
 #include "BLI_utility_mixins.hh"
+#include "BLI_vector.hh"
 
 #include "GPU_framebuffer.h"
 #include "GPU_storage_buffer.h"
diff --git a/source/blender/draw/intern/draw_common.h b/source/blender/draw/intern/draw_common.h
index 566e68a5c84..af2efd338e4 100644
--- a/source/blender/draw/intern/draw_common.h
+++ b/source/blender/draw/intern/draw_common.h
@@ -21,6 +21,7 @@ struct Object;
 struct ParticleSystem;
 struct RegionView3D;
 struct ViewLayer;
+struct Scene;
 struct DRWData;
 
 /* Keep in sync with globalsBlock in shaders */
@@ -74,6 +75,22 @@ void DRW_hair_init(void);
 void DRW_hair_update(void);
 void DRW_hair_free(void);
 
+/* draw_volume.cc */
+
+/**
+ * Add attributes bindings of volume grids to an exhisting shading group.
+ * No draw call is added so the caller can decide how to use the data.
+ * \return nullptr if there is something to draw.
+ */
+struct DRWShadingGroup *DRW_shgroup_volume_create_sub(struct Scene *scene,
+                                                      struct Object *ob,
+                                                      struct DRWShadingGroup *shgrp,
+                                                      struct GPUMaterial *gpu_material);
+
+void DRW_volume_init(struct DRWData *drw_data);
+void DRW_volume_ubos_pool_free(void *pool);
+void DRW_volume_free(void);
+
 /* draw_fluid.c */
 
 /* Fluid simulation. */
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index 441628f2490..e0dfc29b966 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -478,6 +478,7 @@ void DRW_viewport_data_free(DRWData *drw_data)
     MEM_freeN(drw_data->matrices_ubo);
     MEM_freeN(drw_data->obinfos_ubo);
   }
+  DRW_volume_ubos_pool_free(drw_data->volume_grids_ubos);
   MEM_freeN(drw_data);
 }
 
@@ -1650,6 +1651,7 @@ void DRW_draw_render_loop_ex(struct Depsgraph *depsgraph,
 
   drw_debug_init();
   DRW_hair_init();
+  DRW_volume_init(DST.vmempool);
   DRW_smoke_init(DST.vmempool);
 
   /* No frame-buffer allowed before drawing. */
@@ -2021,6 +2023,7 @@ void DRW_render_object_iter(
 {
   const DRWContextState *draw_ctx = DRW_context_state_get();
   DRW_hair_init();
+  DRW_volume_init(DST.vmempool);
   DRW_smoke_init(DST.vmempool);
 
   drw_task_graph_init();
@@ -2077,6 +2080,7 @@ void DRW_custom_pipeline(DrawEngineType *draw_engine_type,
   drw_manager_init(&DST, NULL, NULL);
 
   DRW_hair_init();
+  DRW_volume_init(DST.vmempool);
   DRW_smoke_init(DST.vmempool);
 
   ViewportEngineData *data = DRW_view_data_engine_data_get_ensure(DST.view_data_active,
@@ -2111,6 +2115,7 @@ void DRW_cache_restart(void)
   DST.buffer_finish_called = false;
 
   DRW_hair_init();
+  DRW_volume_init(DST.vmempool);
   DRW_smoke_init(DST.vmempool);
 }
 
@@ -2429,6 +2434,7 @@ void DRW_draw_select_loop(struct Depsgraph *depsgraph,
   /* Init engines */
   drw_engines_init();
   DRW_hair_init();
+  DRW_volume_init(DST.vmempool);
   DRW_smoke_init(DST.vmempool);
 
   {
@@ -2602,6 +2608,7 @@ static void drw_draw_depth_loop_impl(struct Depsgraph *depsgraph,
   /* Init engines */
   drw_engines_init();
   DRW_hair_init();
+  DRW_volume_init(DST.vmempool);
   DRW_smoke_init(DST.vmempool);
 
   {
@@ -3027,6 +3034,7 @@ void DRW_engines_free(void)
 
   DRW_shaders_free();
   DRW_hair_free();
+  DRW_volume_free();
   DRW_shape_cache_free();
   DRW_stats_free();
   DRW_globals_free();
diff --git a/source/blender/draw/intern/draw_manager.h b/source/blender/draw/intern/draw_manager.h
index e861d91d47e..8812f112014 100644
--- a/source/blender/draw/intern/draw_manager.h
+++ b/source/blender/draw/intern/draw_manager.h
@@ -527,6 +527,8 @@ typedef struct DRWData {
   struct GPUUniformBuf **obinfos_ubo;
   struct GHash *obattrs_ubo_pool;
   uint ubo_len;
+  /** Per draw-call volume object data. */
+  void *volume_grids_ubos; /* VolumeUniformBufPool */
   /** List of smoke textures to free after drawing. */
   ListBase smoke_textures;
   /** Texture pool to reuse temp texture across engines. */
diff --git a/source/blender/draw/intern/draw_manager_data.c b/source/blender/draw/intern/draw_manager_data.c
index 39f083aaf96..7c779b42c73 100644
--- a/source/blender/draw/intern/draw_manager_data.c
+++ b/source/blender/draw/intern/draw_manager_data.c
@@ -15,6 +15,7 @@
 #include "BKE_object.h"
 #include "BKE_paint.h"
 #include "BKE_pbvh.h"
+#include "BKE_volume.h"
 
 #include "DNA_curve_types.h"
 #include "DNA_mesh_types.h"
@@ -555,10 +556,19 @@ void DRW_shgroup_vertex_buffer_ref_ex(DRWShadingGroup *shgroup,
 static void drw_call_calc_orco(Object *ob, float (*r_orcofacs)[4])
 {
   ID *ob_data = (ob) ? ob->data : NULL;
+  float loc[3], size[3];
   float *texcoloc = NULL;
   float *texcosize = NULL;
   if (ob_data != NULL) {
     switch (GS(ob_data->name)) {
+      case ID_VO: {
+        BoundBox *bbox = BKE_volume_boundbox_get(ob);
+        mid_v3_v3v3(loc, bbox->vec[0], bbox->vec[6]);
+        sub_v3_v3v3(size, bbox->vec[0], bbox->vec[6]);
+        texcoloc = loc;
+        texcosize = size;
+        break;
+      }
       case ID_ME:
         BKE_mesh_texspace_get_reference((Mesh *)ob_data, NULL, &texcoloc, &texcosize);
         break;
@@ -614,7 +624,7 @@ static void drw_call_obinfos_init(DRWObjectInfos *ob_infos, Object *ob)
   drw_call_calc_orco(ob, ob_infos->orcotexfac);
   /* Random float value. */
   uint random = (DST.dupli_source) ?
-                     DST.dupli_source->random_id :
+                    DST.dupli_source->random_id :
                      /* TODO(fclem): this is rather costly to do at runtime. Maybe we can
                       * put it in ob->runtime and make depsgraph ensure it is up to date. */
                      BLI_hash_int_2d(BLI_hash_string(ob->id.name + 2), 0);
diff --git a/source/blender/draw/intern/draw_shader_shared.h b/source/blender/draw/intern/draw_shader_shared.h
index 58875c0496a..d2e51b67468 100644
--- a/source/blender/draw/intern/draw_shader_shared.h
+++ b/source/blender/draw/intern/draw_shader_shared.h
@@ -6,12 +6,16 @@
 typedef struct ViewInfos ViewInfos;
 typedef struct ObjectMatrices ObjectMatrices;
 typedef struct ObjectInfos ObjectInfos;
+typedef struct VolumeInfos VolumeInfos;
 #endif
 
 #define DRW_SHADER_SHARED_H
 
 #define DRW_RESOURCE_CHUNK_LEN 512
 
+/* Define the maximum number of grid we allow in a volume UBO. */
+#define DRW_GRID_PER_VOLUME_MAX 16
+
 struct ViewInfos {
   /* View matrices */
   float4x4 persmat;
@@ -63,6 +67,18 @@ struct ObjectInfos {
 };
 BLI_STATIC_ASSERT_ALIGN(ViewInfos, 16)
 
+struct VolumeInfos {
+  /* Object to grid-space. */
+  float4x4 grids_xform[DRW_GRID_PER_VOLUME_MAX];
+  /* NOTE: vec4 for alignement. Only float3 needed. */
+  float4 color_mul;
+  float density_scale;
+  float temperature_mul;
+  float temperature_bias;
+  float _pad;
+};
+BLI_STATIC_ASSERT_ALIGN(VolumeInfos, 16)
+
 #define OrcoTexCoFactors (drw_infos[resource_id].drw_OrcoTexCoFactors)
 #define ObjectInfo (drw_infos[resource_id].drw_Infos)
 #define ObjectColor (drw_infos[resource_id].drw_ObjectColor)
diff --git a/source/blender/draw/intern/draw_volume.cc b/source/blender/draw/intern/draw_volume.cc
new file mode 100644
index 00000000000..c9c8acaef40
--- /dev/null
+++ b/source/blender/draw/intern/draw_volume.cc
@@ -0,0 +1,266 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright 2022 Blender Foundation. All rights reserved. */
+
+/** \file
+ * \ingroup draw
+ *
+ * \brief Contains Volume object GPU attributes configuration.
+ */
+
+#include "DRW_gpu_wrapper.hh"
+#include "DRW_render.h"
+
+#include "DNA_fluid_types.h"
+#include "DNA_volume_types.h"
+
+#include "BKE_fluid.h"
+#include "BKE_global.h"
+#include "BKE_mesh.h"
+#include "BKE_modifier.h"
+#include "BKE_volume.h"
+#include "BKE_volume_render.h"
+
+#include "GPU_material.h"
+
+#include "draw_common.h"
+#include "draw_manager.h"
+
+using namespace blender;
+using namespace blender::draw;
+using VolumeInfosBuf = blender::draw::UniformBuffer<VolumeInfos>;
+
+static struct {
+  GPUTexture *dummy_zero;
+  GPUTexture *dummy_one;
+  float dummy_grid_mat[4][4];
+} g_data = {};
+
+struct VolumeUniformBufPool {
+  Vector<VolumeInfosBuf *> ubos;
+  uint used = 0;
+
+  ~VolumeUniformBufPool()
+  {
+    for (VolumeInfosBuf *ubo : ubos) {
+      delete ubo;
+    }
+  }
+
+  void reset()
+  {
+    used = 0;
+  }
+
+  VolumeInfosBuf *alloc()
+  {
+    if (used >= ubos.size()) {
+      VolumeInfosBuf *buf = new VolumeInfosBuf();
+      ubos.append(buf);
+      return buf;
+    }
+    return ubos[used++];
+  }
+};
+
+void DRW_volume_ubos_pool_free(void *pool)
+{
+  delete reinterpret_cast<VolumeUniformBufPool *>(pool);
+}
+
+static void drw_volume_globals_init(void)
+{
+  const float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+  const float one[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+  g_data.dummy_zero = GPU_texture_create_3d(
+      "dummy_zero", 1, 1, 1, 1, GPU_RGBA8, GPU_DATA_FLOAT, zero);
+  g_data.dummy_one = GPU_texture_create_3d(
+      "dummy_one", 1, 1, 1, 1, GPU_RGBA8, GPU_DATA_FLOAT, one);
+  GPU_texture_wrap_mode(g_data.dummy_zero, true, true);
+  GPU_texture_wrap_mode(g_data.dummy_one, true, true);
+
+  memset(g_data.dummy_grid_mat, 0, sizeof(g_data.dummy_grid_mat));
+}
+
+void DRW_volume_free(void)
+{
+  GPU_TEXTURE_FREE_SAFE(g_data.dummy_zero);
+  GPU_TEXTURE_FREE_SAFE(g_data.dummy_one);
+}
+
+static GPUTexture *grid_default_texture(eGPUDefaultValue default_value)
+{
+  switch (default_value) {
+    case GPU_DEFAULT_0:
+      return g_data.dummy_zero;
+    case GPU_DEFAULT_1:
+      return g_data.dummy_one;
+  }
+  return g_data.dummy_zero;
+}
+
+void DRW_volume_init(DRWData *drw_data)
+{
+  if (drw_data->volume_grids_ubos == nullptr) {
+    drw_data->volume_grids_ubos = new VolumeUniformBufPool();
+  }
+  VolumeUniformBufPool *pool = (VolumeUniformBufPool *)drw_data->volume_grids_ubos;
+  pool->reset();
+
+  if (g_data.dummy_one == nullptr) {
+    drw_volume_globals_init();
+  }
+}
+
+static DRWShadingGroup *drw_volume_object_grids_init(Object *ob,
+                                                     ListBase *attrs,
+                                                     DRWShadingGroup *grp)
+{
+  VolumeUniformBufPool *pool = (VolumeUniformBufPool *)DST.vmempool->volume_grids_ubos;
+  VolumeInfosBuf &volume_infos = *pool->alloc();
+
+  Volume *volume = (Volume *)ob->data;
+  BKE_volume_load(volume, G.main);
+
+  grp = DRW_shgroup_create_sub(grp);
+
+  volume_infos.density_scale = BKE_volume_density_scale(volume, ob->obmat);
+  volume_infos.color_mul = float4(1.0f);
+  volume_infos.temperature_mul = 1.0f;
+  volume_infos.temperature_bias = 0.0f;
+
+  /* Bind volume grid textures. */
+  int grid_id = 0;
+  LISTBASE_FOREACH (GPUMaterialAttribute *, attr, attrs) {
+    const VolumeGrid *volume_grid = BKE_volume_grid_find_for_read(volume, attr->name);
+    DRWVolumeGrid *drw_grid = (volume_grid) ?
+                                  DRW_volume_batch_cache_get_grid(volume, volume_grid) :
+                                  NULL;
+
+    /* Handle 3 cases here:
+     * - Grid exists and texture was loaded -> use texture.
+     * - Grid exists but has zero size or failed to load -> use zero.
+     * - Grid does not exist -> use default value. */
+    GPUTexture *grid_tex = (drw_grid)    ? drw_grid->texture :
+                           (volume_grid) ? g_data.dummy_zero :
+                                           grid_default_texture(attr->default_value);
+    DRW_shgroup_uniform_texture(grp, attr->input_name, grid_tex);
+
+    copy_m4_m4(volume_infos.grids_xform[grid_id++].ptr(), drw_grid->object_to_texture);
+  }
+
+  volume_infos.push_update();
+
+  DRW_shgroup_uniform_block(grp, "drw_volume", volume_infos);
+
+  return grp;
+}
+
+static DRWShadingGroup *drw_volume_object_mesh_init(Scene *scene,
+                                                    Object *ob,
+                                                    ListBase *attrs,
+                                                    DRWShadingGroup *grp)
+{
+  VolumeUniformBufPool *pool = (VolumeUniformBufPool *)DST.vmempool->volume_grids_ubos;
+  VolumeInfosBuf &volume_infos = *pool->alloc();
+
+  ModifierData *md = NULL;
+
+  volume_infos.density_scale = 1.0f;
+  volume_infos.color_mul = float4(1.0f);
+  volume_infos.temperature_mul = 1.0f;
+  volume_infos.temperature_bias = 0.0f;
+
+  /* Smoke Simulation */
+  if ((md = BKE_modifiers_findby_type(ob, eModifierType_Fluid)) &&
+      (BKE_modifier_is_enabled(scene, md, eModifierMode_Realtime)) &&
+      ((FluidModifierData *)md)->domain != NULL) {
+    FluidModifierData *fmd = (FluidModifierData *)md;
+    FluidDomainSettings *fds = fmd->domain;
+
+    /* Don't try to show liquid domains here. */
+    if (!fds->fluid || !(fds->type == FLUID_DOMAIN_TYPE_GAS)) {
+      return nullptr;
+    }
+
+    if (fds->fluid && (fds->type == FLUID_DOMAIN_TYPE_GAS)) {
+      DRW_smoke_ensure(fmd, fds->flags & FLUID_DOMAIN_USE_NOISE);
+    }
+
+    grp = DRW_shgroup_create_sub(grp);
+
+    int grid_id = 0;
+    LISTBASE_FOREACH (GPUMaterialAttribute *, attr, attrs) {
+      if (STREQ(attr->name, "density")) {
+        DRW_shgroup_uniform_texture_ref(
+            grp, attr->input_name, fds->tex_density ? &fds->tex_density : &g_data.dummy_one);
+      }
+      else if (STREQ(attr->name, "color")) {
+        DRW_shgroup_uniform_texture_ref(
+            grp, attr->input_name, fds->tex_color ? &fds->tex_color : &g_data.dummy_one);
+      }
+      else if (STR_ELEM(attr->name, "flame", "temperature")) {
+        DRW_shgroup_uniform_texture_ref(
+            grp, attr->input_name, fds->tex_flame ? &fds->tex_flame : &g_data.dummy_zero);
+      }
+      else {
+        DRW_shgroup_uniform_texture(
+            grp, attr->input_name, grid_default_texture(attr->default_value));
+      }
+      copy_m4_m4(volume_infos.grids_xform[grid_id++].ptr(), g_data.dummy_grid_mat);
+    }
+
+    bool use_constant_color = ((fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
+                               (fds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
+    if (use_constant_color) {
+      volume_infos.color_mul = float4(UNPACK3(fds->active_color), 1.0f);
+    }
+
+    /* Output is such that 0..1 maps to 0..1000K */
+    volume_infos.temperature_mul = fds->flame_max_temp - fds->flame_ignition;
+    volume_infos.temperature_bias = fds->flame_ignition;
+  }
+  else {
+    grp = DRW_shgroup_create_sub(grp);
+
+    int grid_id = 0;
+    LISTBASE_FOREACH (GPUMaterialAttribute *, attr, attrs) {
+      DRW_shgroup_uniform_texture(
+          grp, attr->input_name, grid_default_texture(attr->default_value));
+      copy_m4_m4(volume_infos.grids_xform[grid_id++].ptr(), g_data.dummy_grid_mat);
+    }
+  }
+
+  volume_infos.push_update();
+
+  DRW_shgroup_uniform_block(grp, "drw_volume", volume_infos);
+
+  return grp;
+}
+
+static DRWShadingGroup *drw_volume_world_grids_init(ListBase *attrs, DRWShadingGroup *grp)
+{
+  /* Bind default volume grid textures. */
+  int grid_id = 0;
+  LISTBASE_FOREACH (GPUMaterialAttribute *, attr, attrs) {
+    DRW_shgroup_uniform_texture(grp, attr->input_name, grid_default_texture(attr->default_value));
+  }
+  return grp;
+}
+
+DRWShadingGroup *DRW_shgroup_volume_create_sub(Scene *scene,
+                                               Object *ob,
+                                               DRWShadingGroup *shgrp,
+                                               GPUMaterial *gpu_material)
+{
+  ListBase attrs = GPU_material_attributes(gpu_material);
+
+  if (ob == nullptr) {
+    return drw_volume_world_grids_init(&attrs, shgrp);
+  }
+  else if (ob->type == OB_VOLUME) {
+    return drw_volume_object_grids_init(ob, &attrs, shgrp);
+  }
+  else {
+    return drw_volume_object_mesh_init(scene, ob, &attrs, shgrp);
+  }
+}
diff --git a/source/blender/draw/intern/shaders/common_attribute_lib.glsl b/source/blender/draw/intern/shaders/common_attribute_lib.glsl
index 99db2929a13..30239a84c0c 100644
--- a/source/blender/draw/intern/shaders/common_attribute_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_attribute_lib.glsl
@@ -19,3 +19,15 @@ vec4 attr_load_vec4(samplerBuffer attr);
 vec3 attr_load_vec3(samplerBuffer attr);
 vec2 attr_load_vec2(samplerBuffer attr);
 float attr_load_float(samplerBuffer attr);
+
+vec3 attr_load_orco(sampler3D orco);
+vec4 attr_load_tangent(sampler3D tangent);
+vec3 attr_load_uv(sampler3D attr);
+vec4 attr_load_color(sampler3D tex);
+vec4 attr_load_vec4(sampler3D tex);
+vec3 attr_load_vec3(sampler3D tex);
+vec2 attr_load_vec2(sampler3D tex);
+float attr_load_float(sampler3D tex);
+
+float attr_load_temperature_post(float attr);
+vec4 attr_load_color_post(vec4 attr);
diff --git a/source/blender/draw/intern/shaders/draw_object_infos_info.hh b/source/blender/draw/intern/shaders/draw_object_infos_info.hh
index 392b016fc3b..c74a043ec97 100644
--- a/source/blender/draw/intern/shaders/draw_object_infos_info.hh
+++ b/source/blender/draw/intern/shaders/draw_object_infos_info.hh
@@ -6,3 +6,7 @@ GPU_SHADER_CREATE_INFO(draw_object_infos)
     .typedef_source("draw_shader_shared.h")
     .define("OBINFO_LIB")
     .uniform_buf(1, "ObjectInfos", "drw_infos[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH);
+
+GPU_SHADER_CREATE_INFO(draw_volume_infos)
+    .typedef_source("draw_shader_shared.h")
+    .uniform_buf(2, "VolumeInfos", "drw_volume", Frequency::BATCH);