Eevee: internal support for arbitrary number of volume grids

This has no user visible impact yet since smoke volumes only support a fixed
set of attributes, but will become important with the new volume object.

For GPU shader compilation, volume grids are now handled separately from
image textures. They are somewhere between a vertex attribute and an image
texture, basically an attribute that is stored as a texture.

Differential Revision: https://developer.blender.org/D6952

4 files changed, 110 insertions, 29 deletions

diff --git a/source/blender/gpu/intern/gpu_codegen.c b/source/blender/gpu/intern/gpu_codegen.c
index e8616c1e256..bcaa95c2f59 100644
--- a/source/blender/gpu/intern/gpu_codegen.c
+++ b/source/blender/gpu/intern/gpu_codegen.c
@@ -269,18 +269,6 @@ static const char *gpu_builtin_name(eGPUBuiltin builtin)
   else if (builtin == GPU_OBJECT_INFO) {
     return "unfobjectinfo";
   }
-  else if (builtin == GPU_VOLUME_DENSITY) {
-    return "sampdensity";
-  }
-  else if (builtin == GPU_VOLUME_COLOR) {
-    return "sampcolor";
-  }
-  else if (builtin == GPU_VOLUME_FLAME) {
-    return "sampflame";
-  }
-  else if (builtin == GPU_VOLUME_TEMPERATURE) {
-    return "unftemperature";
-  }
   else if (builtin == GPU_BARYCENTRIC_TEXCO) {
     return "unfbarycentrictex";
   }
@@ -344,6 +332,11 @@ static int codegen_process_uniforms_functions(GPUMaterial *material,
     }
   }
 
+  /* Volume Grids */
+  for (GPUMaterialVolumeGrid *grid = graph->volume_grids.first; grid; grid = grid->next) {
+    BLI_dynstr_appendf(ds, "uniform sampler3D %s;\n", grid->sampler_name);
+  }
+
   /* Print other uniforms */
   for (node = graph->nodes.first; node; node = node->next) {
     for (input = node->inputs.first; input; input = input->next) {
@@ -353,13 +346,7 @@ static int codegen_process_uniforms_functions(GPUMaterial *material,
           builtins |= input->builtin;
           name = gpu_builtin_name(input->builtin);
 
-          if (BLI_str_startswith(name, "samp")) {
-            if ((input->builtin == GPU_VOLUME_DENSITY) || (input->builtin == GPU_VOLUME_COLOR) ||
-                (input->builtin == GPU_VOLUME_FLAME)) {
-              BLI_dynstr_appendf(ds, "uniform sampler3D %s;\n", name);
-            }
-          }
-          else if (BLI_str_startswith(name, "unf")) {
+          if (BLI_str_startswith(name, "unf")) {
             BLI_dynstr_appendf(ds, "uniform %s %s;\n", gpu_data_type_to_string(input->type), name);
           }
           else {
@@ -442,6 +429,9 @@ static void codegen_call_functions(DynStr *ds, GPUNodeGraph *graph, GPUOutput *f
       else if (input->source == GPU_SOURCE_TEX_TILED_MAPPING) {
         BLI_dynstr_append(ds, input->texture->tiled_mapping_name);
       }
+      else if (input->source == GPU_SOURCE_VOLUME_GRID) {
+        BLI_dynstr_append(ds, input->volume_grid->sampler_name);
+      }
       else if (input->source == GPU_SOURCE_OUTPUT) {
         codegen_convert_datatype(
             ds, input->link->output->type, input->type, "tmp", input->link->output->id);
diff --git a/source/blender/gpu/intern/gpu_material.c b/source/blender/gpu/intern/gpu_material.c
index b2658839d67..8a4a88d0663 100644
--- a/source/blender/gpu/intern/gpu_material.c
+++ b/source/blender/gpu/intern/gpu_material.c
@@ -70,6 +70,7 @@ struct GPUMaterial {
 
   const void *engine_type; /* attached engine type */
   int options;             /* to identify shader variations (shadow, probe, world background...) */
+  bool is_volume_shader;   /* is volumetric shader */
 
   /* Nodes */
   GPUNodeGraph graph;
@@ -80,7 +81,8 @@ struct GPUMaterial {
   /* XXX: Should be in Material. But it depends on the output node
    * used and since the output selection is different for GPUMaterial...
    */
-  int domain;
+  bool has_volume_output;
+  bool has_surface_output;
 
   /* Only used by Eevee to know which bsdf are used. */
   int flag;
@@ -109,8 +111,8 @@ struct GPUMaterial {
 };
 
 enum {
-  GPU_DOMAIN_SURFACE = (1 << 0),
-  GPU_DOMAIN_VOLUME = (1 << 1),
+  GPU_USE_SURFACE_OUTPUT = (1 << 0),
+  GPU_USE_VOLUME_OUTPUT = (1 << 1),
 };
 
 /* Functions */
@@ -567,6 +569,11 @@ ListBase GPU_material_textures(GPUMaterial *material)
   return material->graph.textures;
 }
 
+ListBase GPU_material_volume_grids(GPUMaterial *material)
+{
+  return material->graph.volume_grids;
+}
+
 void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link)
 {
   if (!material->graph.outlink) {
@@ -592,14 +599,19 @@ eGPUMaterialStatus GPU_material_status(GPUMaterial *mat)
 
 /* Code generation */
 
-bool GPU_material_use_domain_surface(GPUMaterial *mat)
+bool GPU_material_has_surface_output(GPUMaterial *mat)
+{
+  return mat->has_surface_output;
+}
+
+bool GPU_material_has_volume_output(GPUMaterial *mat)
 {
-  return (mat->domain & GPU_DOMAIN_SURFACE);
+  return mat->has_volume_output;
 }
 
-bool GPU_material_use_domain_volume(GPUMaterial *mat)
+bool GPU_material_is_volume_shader(GPUMaterial *mat)
 {
-  return (mat->domain & GPU_DOMAIN_VOLUME);
+  return mat->is_volume_shader;
 }
 
 void GPU_material_flag_set(GPUMaterial *mat, eGPUMatFlag flag)
@@ -636,7 +648,8 @@ GPUMaterial *GPU_material_from_nodetree(Scene *scene,
                                         struct bNodeTree *ntree,
                                         ListBase *gpumaterials,
                                         const void *engine_type,
-                                        int options,
+                                        const int options,
+                                        const bool is_volume_shader,
                                         const char *vert_code,
                                         const char *geom_code,
                                         const char *frag_lib,
@@ -655,6 +668,7 @@ GPUMaterial *GPU_material_from_nodetree(Scene *scene,
   mat->scene = scene;
   mat->engine_type = engine_type;
   mat->options = options;
+  mat->is_volume_shader = is_volume_shader;
 #ifndef NDEBUG
   BLI_snprintf(mat->name, sizeof(mat->name), "%s", name);
 #else
@@ -670,8 +684,8 @@ GPUMaterial *GPU_material_from_nodetree(Scene *scene,
 
   gpu_material_ramp_texture_build(mat);
 
-  SET_FLAG_FROM_TEST(mat->domain, has_surface_output, GPU_DOMAIN_SURFACE);
-  SET_FLAG_FROM_TEST(mat->domain, has_volume_output, GPU_DOMAIN_VOLUME);
+  mat->has_surface_output = has_surface_output;
+  mat->has_volume_output = has_volume_output;
 
   if (mat->graph.outlink) {
     /* HACK: this is only for eevee. We add the define here after the nodetree evaluation. */
diff --git a/source/blender/gpu/intern/gpu_node_graph.c b/source/blender/gpu/intern/gpu_node_graph.c
index de35b43109f..0d5cc46c0b9 100644
--- a/source/blender/gpu/intern/gpu_node_graph.c
+++ b/source/blender/gpu/intern/gpu_node_graph.c
@@ -119,6 +119,10 @@ static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType
       input->source = GPU_SOURCE_TEX_TILED_MAPPING;
       input->texture = link->texture;
       break;
+    case GPU_NODE_LINK_VOLUME_GRID:
+      input->source = GPU_SOURCE_VOLUME_GRID;
+      input->volume_grid = link->volume_grid;
+      break;
     case GPU_NODE_LINK_ATTR:
       input->source = GPU_SOURCE_ATTR;
       input->attr = link->attr;
@@ -321,6 +325,31 @@ static GPUMaterialTexture *gpu_node_graph_add_texture(GPUNodeGraph *graph,
   return tex;
 }
 
+static GPUMaterialVolumeGrid *gpu_node_graph_add_volume_grid(GPUNodeGraph *graph, const char *name)
+{
+  /* Find existing volume grid. */
+  int num_grids = 0;
+  GPUMaterialVolumeGrid *grid = graph->volume_grids.first;
+  for (; grid; grid = grid->next) {
+    if (STREQ(grid->name, name)) {
+      break;
+    }
+    num_grids++;
+  }
+
+  /* Add new requested volume grid. */
+  if (grid == NULL) {
+    grid = MEM_callocN(sizeof(*grid), __func__);
+    grid->name = BLI_strdup(name);
+    BLI_snprintf(grid->sampler_name, sizeof(grid->sampler_name), "vsamp%d", num_grids);
+    BLI_addtail(&graph->volume_grids, grid);
+  }
+
+  grid->users++;
+
+  return grid;
+}
+
 /* Creating Inputs */
 
 GPUNodeLink *GPU_attribute(GPUMaterial *mat, const CustomDataType type, const char *name)
@@ -394,6 +423,30 @@ GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *ro
   return link;
 }
 
+GPUNodeLink *GPU_volume_grid(GPUMaterial *mat, const char *name)
+{
+  /* NOTE: this could be optimized by automatically merging duplicate
+   * lookups of the same attribute. */
+  GPUNodeGraph *graph = gpu_material_node_graph(mat);
+  GPUNodeLink *link = gpu_node_link_create();
+  link->link_type = GPU_NODE_LINK_VOLUME_GRID;
+  link->volume_grid = gpu_node_graph_add_volume_grid(graph, name);
+
+  /* Two special cases, where we adjust the output values of smoke grids to
+   * bring the into standard range without having to modify the grid values. */
+  if (strcmp(name, "color") == 0) {
+    GPU_link(mat, "node_attribute_volume_color", link, &link);
+  }
+  else if (strcmp(name, "temperature") == 0) {
+    GPU_link(mat, "node_attribute_volume_temperature", link, &link);
+  }
+  else {
+    GPU_link(mat, "node_attribute_volume", link, &link);
+  }
+
+  return link;
+}
+
 GPUNodeLink *GPU_builtin(eGPUBuiltin builtin)
 {
   GPUNodeLink *link = gpu_node_link_create();
@@ -537,6 +590,9 @@ static void gpu_inputs_free(ListBase *inputs)
     else if (ELEM(input->source, GPU_SOURCE_TEX, GPU_SOURCE_TEX_TILED_MAPPING)) {
       input->texture->users--;
     }
+    else if (ELEM(input->source, GPU_SOURCE_VOLUME_GRID)) {
+      input->volume_grid->users--;
+    }
 
     if (input->link) {
       gpu_node_link_free(input->link);
@@ -579,6 +635,11 @@ void gpu_node_graph_free_nodes(GPUNodeGraph *graph)
 void gpu_node_graph_free(GPUNodeGraph *graph)
 {
   gpu_node_graph_free_nodes(graph);
+
+  for (GPUMaterialVolumeGrid *grid = graph->volume_grids.first; grid; grid = grid->next) {
+    MEM_SAFE_FREE(grid->name);
+  }
+  BLI_freelistN(&graph->volume_grids);
   BLI_freelistN(&graph->textures);
   BLI_freelistN(&graph->attributes);
 }
@@ -637,4 +698,12 @@ void gpu_node_graph_prune_unused(GPUNodeGraph *graph)
       BLI_freelinkN(&graph->textures, tex);
     }
   }
+
+  for (GPUMaterialVolumeGrid *grid = graph->volume_grids.first, *next = NULL; grid; grid = next) {
+    next = grid->next;
+    if (grid->users == 0) {
+      MEM_SAFE_FREE(grid->name);
+      BLI_freelinkN(&graph->volume_grids, grid);
+    }
+  }
 }
diff --git a/source/blender/gpu/intern/gpu_node_graph.h b/source/blender/gpu/intern/gpu_node_graph.h
index 9214bd7f1ba..ceaeea2bfa8 100644
--- a/source/blender/gpu/intern/gpu_node_graph.h
+++ b/source/blender/gpu/intern/gpu_node_graph.h
@@ -48,6 +48,8 @@ typedef enum eGPUDataSource {
   GPU_SOURCE_STRUCT,
   GPU_SOURCE_TEX,
   GPU_SOURCE_TEX_TILED_MAPPING,
+  GPU_SOURCE_VOLUME_GRID,
+  GPU_SOURCE_VOLUME_GRID_TRANSFORM,
 } eGPUDataSource;
 
 typedef enum {
@@ -59,6 +61,7 @@ typedef enum {
   GPU_NODE_LINK_IMAGE,
   GPU_NODE_LINK_IMAGE_TILED,
   GPU_NODE_LINK_IMAGE_TILED_MAPPING,
+  GPU_NODE_LINK_VOLUME_GRID,
   GPU_NODE_LINK_OUTPUT,
   GPU_NODE_LINK_UNIFORM,
 } GPUNodeLinkType;
@@ -88,6 +91,8 @@ struct GPUNodeLink {
     eGPUBuiltin builtin;
     /* GPU_NODE_LINK_COLORBAND */
     struct GPUTexture **colorband;
+    /* GPU_NODE_LINK_VOLUME_GRID */
+    struct GPUMaterialVolumeGrid *volume_grid;
     /* GPU_NODE_LINK_OUTPUT */
     struct GPUOutput *output;
     /* GPU_NODE_LINK_ATTR */
@@ -126,6 +131,8 @@ typedef struct GPUInput {
     struct GPUMaterialTexture *texture;
     /* GPU_SOURCE_ATTR */
     struct GPUMaterialAttribute *attr;
+    /* GPU_SOURCE_VOLUME_GRID */
+    struct GPUMaterialVolumeGrid *volume_grid;
   };
 } GPUInput;
 
@@ -139,6 +146,7 @@ typedef struct GPUNodeGraph {
   /* Requested attributes and textures. */
   ListBase attributes;
   ListBase textures;
+  ListBase volume_grids;
 } GPUNodeGraph;
 
 /* Node Graph */