Objects: Eevee and workbench rendering of new Volume, Hair, PointCloud

Only the volume drawing part is really finished and exposed to the user. Hair
plugs into the existing hair rendering code and is fairly straightforward. The
pointcloud drawing is a hack using overlays rather than Eevee and workbench.

The most tricky part for volume rendering is the case where each volume grid
has a different transform, which requires an additional matrix in the shader
and non-trivial logic in Eevee volume drawing. In the common case were all the
transforms match we don't use the additional per-grid matrix in the shader.

Ref T73201, T68981

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

9 files changed, 226 insertions, 29 deletions

diff --git a/source/blender/draw/intern/draw_cache.c b/source/blender/draw/intern/draw_cache.c
index d0cea5b8c5c..1f76b5ac431 100644
--- a/source/blender/draw/intern/draw_cache.c
+++ b/source/blender/draw/intern/draw_cache.c
@@ -19,13 +19,16 @@
  */
 
 #include "DNA_scene_types.h"
+#include "DNA_hair_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meta_types.h"
 #include "DNA_curve_types.h"
-#include "DNA_object_types.h"
-#include "DNA_particle_types.h"
 #include "DNA_modifier_types.h"
 #include "DNA_lattice_types.h"
+#include "DNA_object_types.h"
+#include "DNA_particle_types.h"
+#include "DNA_pointcloud_types.h"
+#include "DNA_volume_types.h"
 
 #include "UI_resources.h"
 
@@ -799,6 +802,12 @@ GPUBatch *DRW_cache_object_edge_detection_get(Object *ob, bool *r_is_manifold)
       return DRW_cache_text_edge_detection_get(ob, r_is_manifold);
     case OB_MBALL:
       return DRW_cache_mball_edge_detection_get(ob, r_is_manifold);
+    case OB_HAIR:
+      return NULL;
+    case OB_POINTCLOUD:
+      return NULL;
+    case OB_VOLUME:
+      return NULL;
     default:
       return NULL;
   }
@@ -817,6 +826,12 @@ GPUBatch *DRW_cache_object_face_wireframe_get(Object *ob)
       return DRW_cache_text_face_wireframe_get(ob);
     case OB_MBALL:
       return DRW_cache_mball_face_wireframe_get(ob);
+    case OB_HAIR:
+      return NULL;
+    case OB_POINTCLOUD:
+      return NULL;
+    case OB_VOLUME:
+      return DRW_cache_volume_face_wireframe_get(ob);
     case OB_GPENCIL: {
       return DRW_cache_gpencil_face_wireframe_get(ob);
     }
@@ -837,7 +852,13 @@ GPUBatch *DRW_cache_object_loose_edges_get(struct Object *ob)
     case OB_FONT:
       return DRW_cache_text_loose_edges_get(ob);
     case OB_MBALL:
-      /* Cannot have any loose edge */
+      return NULL;
+    case OB_HAIR:
+      return NULL;
+    case OB_POINTCLOUD:
+      return NULL;
+    case OB_VOLUME:
+      return NULL;
     default:
       return NULL;
   }
@@ -856,6 +877,12 @@ GPUBatch *DRW_cache_object_surface_get(Object *ob)
       return DRW_cache_text_surface_get(ob);
     case OB_MBALL:
       return DRW_cache_mball_surface_get(ob);
+    case OB_HAIR:
+      return NULL;
+    case OB_POINTCLOUD:
+      return NULL;
+    case OB_VOLUME:
+      return NULL;
     default:
       return NULL;
   }
@@ -875,6 +902,12 @@ int DRW_cache_object_material_count_get(struct Object *ob)
       return DRW_curve_material_count_get(ob->data);
     case OB_MBALL:
       return DRW_metaball_material_count_get(ob->data);
+    case OB_HAIR:
+      return DRW_hair_material_count_get(ob->data);
+    case OB_POINTCLOUD:
+      return DRW_pointcloud_material_count_get(ob->data);
+    case OB_VOLUME:
+      return DRW_volume_material_count_get(ob->data);
     default:
       BLI_assert(0);
       return 0;
@@ -896,6 +929,12 @@ GPUBatch **DRW_cache_object_surface_material_get(struct Object *ob,
       return DRW_cache_text_surface_shaded_get(ob, gpumat_array, gpumat_array_len);
     case OB_MBALL:
       return DRW_cache_mball_surface_shaded_get(ob, gpumat_array, gpumat_array_len);
+    case OB_HAIR:
+      return NULL;
+    case OB_POINTCLOUD:
+      return NULL;
+    case OB_VOLUME:
+      return NULL;
     default:
       return NULL;
   }
@@ -3214,6 +3253,27 @@ GPUBatch *DRW_cache_lattice_vert_overlay_get(Object *ob)
 /** \} */
 
 /* -------------------------------------------------------------------- */
+/** \name PointCloud
+ * \{ */
+
+GPUBatch *DRW_cache_pointcloud_get_dots(Object *object)
+{
+  return DRW_pointcloud_batch_cache_get_dots(object);
+}
+
+/* -------------------------------------------------------------------- */
+/** \name Volume
+ * \{ */
+
+GPUBatch *DRW_cache_volume_face_wireframe_get(Object *ob)
+{
+  BLI_assert(ob->type == OB_VOLUME);
+  return DRW_volume_batch_cache_get_wireframes_face(ob->data);
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
 /** \name Particles
  * \{ */
 
@@ -3444,6 +3504,15 @@ void drw_batch_cache_validate(Object *ob)
     case OB_LATTICE:
       DRW_lattice_batch_cache_validate((Lattice *)ob->data);
       break;
+    case OB_HAIR:
+      DRW_hair_batch_cache_validate((Hair *)ob->data);
+      break;
+    case OB_POINTCLOUD:
+      DRW_pointcloud_batch_cache_validate((PointCloud *)ob->data);
+      break;
+    case OB_VOLUME:
+      DRW_volume_batch_cache_validate((Volume *)ob->data);
+      break;
     default:
       break;
   }
diff --git a/source/blender/draw/intern/draw_cache.h b/source/blender/draw/intern/draw_cache.h
index 8ac0d7ada21..77c7b6b9307 100644
--- a/source/blender/draw/intern/draw_cache.h
+++ b/source/blender/draw/intern/draw_cache.h
@@ -29,6 +29,8 @@ struct ModifierData;
 struct Object;
 struct PTCacheEdit;
 struct ParticleSystem;
+struct Volume;
+struct VolumeGrid;
 struct bGPDstroke;
 
 void DRW_shape_cache_free(void);
@@ -200,6 +202,39 @@ struct GPUBatch **DRW_cache_mball_surface_shaded_get(struct Object *ob,
 struct GPUBatch *DRW_cache_mball_face_wireframe_get(struct Object *ob);
 struct GPUBatch *DRW_cache_mball_edge_detection_get(struct Object *ob, bool *r_is_manifold);
 
+/* Hair */
+struct GPUBatch *DRW_cache_hair_surface_get(struct Object *ob);
+struct GPUBatch **DRW_cache_hair_surface_shaded_get(struct Object *ob,
+                                                    struct GPUMaterial **gpumat_array,
+                                                    uint gpumat_array_len);
+struct GPUBatch *DRW_cache_hair_face_wireframe_get(struct Object *ob);
+struct GPUBatch *DRW_cache_hair_edge_detection_get(struct Object *ob, bool *r_is_manifold);
+
+/* PointCloud */
+struct GPUBatch *DRW_cache_pointcloud_get_dots(struct Object *obj);
+
+/* Volume */
+typedef struct DRWVolumeGrid {
+  struct DRWVolumeGrid *next, *prev;
+
+  /* Grid name. */
+  char *name;
+
+  /* 3D texture. */
+  struct GPUTexture *texture;
+
+  /* Transform between 0..1 texture space and object space. */
+  float texture_to_object[4][4];
+  float object_to_texture[4][4];
+
+  /* Transfrom from bounds to texture space. */
+  float object_to_bounds[4][4];
+  float bounds_to_texture[4][4];
+} DRWVolumeGrid;
+
+DRWVolumeGrid *DRW_volume_batch_cache_get_grid(struct Volume *volume, struct VolumeGrid *grid);
+struct GPUBatch *DRW_cache_volume_face_wireframe_get(struct Object *ob);
+
 /* GPencil */
 struct GPUBatch *DRW_cache_gpencil_strokes_get(struct Object *ob, int cfra);
 struct GPUBatch *DRW_cache_gpencil_fills_get(struct Object *ob, int cfra);
diff --git a/source/blender/draw/intern/draw_cache_impl.h b/source/blender/draw/intern/draw_cache_impl.h
index 755f794d201..b3450bf4715 100644
--- a/source/blender/draw/intern/draw_cache_impl.h
+++ b/source/blender/draw/intern/draw_cache_impl.h
@@ -32,11 +32,14 @@ struct ModifierData;
 struct PTCacheEdit;
 struct ParticleSystem;
 
+struct bGPdata;
 struct Curve;
+struct Hair;
 struct Lattice;
 struct Mesh;
 struct MetaBall;
-struct bGPdata;
+struct PointCloud;
+struct Volume;
 
 /* Expose via BKE callbacks */
 void DRW_mball_batch_cache_dirty_tag(struct MetaBall *mb, int mode);
@@ -61,11 +64,26 @@ void DRW_particle_batch_cache_free(struct ParticleSystem *psys);
 void DRW_gpencil_batch_cache_dirty_tag(struct bGPdata *gpd);
 void DRW_gpencil_batch_cache_free(struct bGPdata *gpd);
 
+void DRW_hair_batch_cache_dirty_tag(struct Hair *hair, int mode);
+void DRW_hair_batch_cache_validate(struct Hair *hair);
+void DRW_hair_batch_cache_free(struct Hair *hair);
+
+void DRW_pointcloud_batch_cache_dirty_tag(struct PointCloud *pointcloud, int mode);
+void DRW_pointcloud_batch_cache_validate(struct PointCloud *pointcloud);
+void DRW_pointcloud_batch_cache_free(struct PointCloud *pointcloud);
+
+void DRW_volume_batch_cache_dirty_tag(struct Volume *volume, int mode);
+void DRW_volume_batch_cache_validate(struct Volume *volume);
+void DRW_volume_batch_cache_free(struct Volume *volume);
+
 /* Garbage collection */
 void DRW_batch_cache_free_old(struct Object *ob, int ctime);
 
 void DRW_mesh_batch_cache_free_old(struct Mesh *me, int ctime);
 
+/* Generic */
+void DRW_vertbuf_create_wiredata(struct GPUVertBuf *vbo, const int vert_len);
+
 /* Curve */
 void DRW_curve_batch_cache_create_requested(struct Object *ob);
 
@@ -118,6 +136,19 @@ struct GPUBatch *DRW_lattice_batch_cache_get_all_edges(struct Lattice *lt,
 struct GPUBatch *DRW_lattice_batch_cache_get_all_verts(struct Lattice *lt);
 struct GPUBatch *DRW_lattice_batch_cache_get_edit_verts(struct Lattice *lt);
 
+/* Hair */
+int DRW_hair_material_count_get(struct Hair *hair);
+
+/* PointCloud */
+int DRW_pointcloud_material_count_get(struct PointCloud *pointcloud);
+
+struct GPUBatch *DRW_pointcloud_batch_cache_get_dots(struct Object *ob);
+
+/* Volume */
+int DRW_volume_material_count_get(struct Volume *volume);
+
+struct GPUBatch *DRW_volume_batch_cache_get_wireframes_face(struct Volume *volume);
+
 /* Mesh */
 void DRW_mesh_batch_cache_create_requested(struct Object *ob,
                                            struct Mesh *me,
diff --git a/source/blender/draw/intern/draw_cache_impl_displist.c b/source/blender/draw/intern/draw_cache_impl_displist.c
index 50979d72189..bc4eb37c3b4 100644
--- a/source/blender/draw/intern/draw_cache_impl_displist.c
+++ b/source/blender/draw/intern/draw_cache_impl_displist.c
@@ -214,7 +214,7 @@ void DRW_displist_vertbuf_create_pos_and_nor(ListBase *lb, GPUVertBuf *vbo)
   }
 }
 
-void DRW_displist_vertbuf_create_wiredata(ListBase *lb, GPUVertBuf *vbo)
+void DRW_vertbuf_create_wiredata(GPUVertBuf *vbo, const int vert_len)
 {
   static GPUVertFormat format = {0};
   static struct {
@@ -232,23 +232,27 @@ void DRW_displist_vertbuf_create_wiredata(ListBase *lb, GPUVertBuf *vbo)
     }
   }
 
-  int vbo_len_used = curve_render_surface_vert_len_get(lb);
-
   GPU_vertbuf_init_with_format(vbo, &format);
-  GPU_vertbuf_data_alloc(vbo, vbo_len_used);
+  GPU_vertbuf_data_alloc(vbo, vert_len);
 
   if (vbo->format.stride == 1) {
-    memset(vbo->data, 0xFF, (size_t)vbo_len_used);
+    memset(vbo->data, 0xFF, (size_t)vert_len);
   }
   else {
     GPUVertBufRaw wd_step;
     GPU_vertbuf_attr_get_raw_data(vbo, attr_id.wd, &wd_step);
-    for (int i = 0; i < vbo_len_used; i++) {
+    for (int i = 0; i < vert_len; i++) {
       *((float *)GPU_vertbuf_raw_step(&wd_step)) = 1.0f;
     }
   }
 }
 
+void DRW_displist_vertbuf_create_wiredata(ListBase *lb, GPUVertBuf *vbo)
+{
+  const int vert_len = curve_render_surface_vert_len_get(lb);
+  DRW_vertbuf_create_wiredata(vbo, vert_len);
+}
+
 void DRW_displist_indexbuf_create_triangles_in_order(ListBase *lb, GPUIndexBuf *ibo)
 {
   const int tri_len = curve_render_surface_tri_len_get(lb);
diff --git a/source/blender/draw/intern/draw_cache_impl_particles.c b/source/blender/draw/intern/draw_cache_impl_particles.c
index 795e7be63b1..c4433cea0df 100644
--- a/source/blender/draw/intern/draw_cache_impl_particles.c
+++ b/source/blender/draw/intern/draw_cache_impl_particles.c
@@ -179,7 +179,7 @@ static void particle_batch_cache_clear_point(ParticlePointCache *point_cache)
   GPU_VERTBUF_DISCARD_SAFE(point_cache->pos);
 }
 
-static void particle_batch_cache_clear_hair(ParticleHairCache *hair_cache)
+void particle_batch_cache_clear_hair(ParticleHairCache *hair_cache)
 {
   /* TODO more granular update tagging. */
   GPU_VERTBUF_DISCARD_SAFE(hair_cache->proc_point_buf);
diff --git a/source/blender/draw/intern/draw_common.c b/source/blender/draw/intern/draw_common.c
index b1ad1455d8c..87cd1cd8546 100644
--- a/source/blender/draw/intern/draw_common.c
+++ b/source/blender/draw/intern/draw_common.c
@@ -437,7 +437,15 @@ bool DRW_object_is_flat(Object *ob, int *r_axis)
 {
   float dim[3];
 
-  if (!ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL)) {
+  if (!ELEM(ob->type,
+            OB_MESH,
+            OB_CURVE,
+            OB_SURF,
+            OB_FONT,
+            OB_MBALL,
+            OB_HAIR,
+            OB_POINTCLOUD,
+            OB_VOLUME)) {
     /* Non-meshes object cannot be considered as flat. */
     return false;
   }
diff --git a/source/blender/draw/intern/draw_hair.c b/source/blender/draw/intern/draw_hair.c
index c88071dc6d6..c89f5f5bba6 100644
--- a/source/blender/draw/intern/draw_hair.c
+++ b/source/blender/draw/intern/draw_hair.c
@@ -142,9 +142,16 @@ static DRWShadingGroup *drw_shgroup_create_hair_procedural_ex(Object *object,
   int thickness_res = (scene->r.hair_type == SCE_HAIR_SHAPE_STRAND) ? 1 : 2;
 
   ParticleHairCache *hair_cache;
-  ParticleSettings *part = psys->part;
-  bool need_ft_update = particles_ensure_procedural_data(
-      object, psys, md, &hair_cache, subdiv, thickness_res);
+  bool need_ft_update;
+  if (psys) {
+    /* Old particle hair. */
+    need_ft_update = particles_ensure_procedural_data(
+        object, psys, md, &hair_cache, subdiv, thickness_res);
+  }
+  else {
+    /* New hair object. */
+    need_ft_update = hair_ensure_procedural_data(object, &hair_cache, subdiv, thickness_res);
+  }
 
   DRWShadingGroup *shgrp;
   if (shgrp_parent) {
@@ -185,34 +192,58 @@ static DRWShadingGroup *drw_shgroup_create_hair_procedural_ex(Object *object,
     DRW_shgroup_uniform_texture(shgrp, "ac", g_dummy_texture);
   }
 
-  if ((dupli_parent != NULL) && (dupli_object != NULL)) {
-    if (dupli_object->type & OB_DUPLICOLLECTION) {
-      copy_m4_m4(dupli_mat, dupli_parent->obmat);
+  if (psys) {
+    if ((dupli_parent != NULL) && (dupli_object != NULL)) {
+      if (dupli_object->type & OB_DUPLICOLLECTION) {
+        copy_m4_m4(dupli_mat, dupli_parent->obmat);
+      }
+      else {
+        copy_m4_m4(dupli_mat, dupli_object->ob->obmat);
+        invert_m4(dupli_mat);
+        mul_m4_m4m4(dupli_mat, object->obmat, dupli_mat);
+      }
     }
     else {
-      copy_m4_m4(dupli_mat, dupli_object->ob->obmat);
-      invert_m4(dupli_mat);
-      mul_m4_m4m4(dupli_mat, object->obmat, dupli_mat);
+      unit_m4(dupli_mat);
     }
   }
   else {
-    unit_m4(dupli_mat);
+    /* New hair object. */
+    copy_m4_m4(dupli_mat, object->obmat);
+  }
+
+  /* Get hair shape parameters. */
+  float hair_rad_shape, hair_rad_root, hair_rad_tip;
+  bool hair_close_tip;
+  if (psys) {
+    /* Old particle hair. */
+    ParticleSettings *part = psys->part;
+    hair_rad_shape = part->shape;
+    hair_rad_root = part->rad_root * part->rad_scale * 0.5f;
+    hair_rad_tip = part->rad_tip * part->rad_scale * 0.5f;
+    hair_close_tip = (part->shape_flag & PART_SHAPE_CLOSE_TIP) != 0;
+  }
+  else {
+    /* TODO: implement for new hair object. */
+    hair_rad_shape = 1.0f;
+    hair_rad_root = 0.005f;
+    hair_rad_tip = 0.0f;
+    hair_close_tip = true;
   }
 
   DRW_shgroup_uniform_texture(shgrp, "hairPointBuffer", hair_cache->final[subdiv].proc_tex);
   DRW_shgroup_uniform_int(shgrp, "hairStrandsRes", &hair_cache->final[subdiv].strands_res, 1);
   DRW_shgroup_uniform_int_copy(shgrp, "hairThicknessRes", thickness_res);
-  DRW_shgroup_uniform_float(shgrp, "hairRadShape", &part->shape, 1);
+  DRW_shgroup_uniform_float_copy(shgrp, "hairRadShape", hair_rad_shape);
   DRW_shgroup_uniform_vec4_copy(shgrp, "hairDupliMatrix[0]", dupli_mat[0]);
   DRW_shgroup_uniform_vec4_copy(shgrp, "hairDupliMatrix[1]", dupli_mat[1]);
   DRW_shgroup_uniform_vec4_copy(shgrp, "hairDupliMatrix[2]", dupli_mat[2]);
   DRW_shgroup_uniform_vec4_copy(shgrp, "hairDupliMatrix[3]", dupli_mat[3]);
-  DRW_shgroup_uniform_float_copy(shgrp, "hairRadRoot", part->rad_root * part->rad_scale * 0.5f);
-  DRW_shgroup_uniform_float_copy(shgrp, "hairRadTip", part->rad_tip * part->rad_scale * 0.5f);
-  DRW_shgroup_uniform_bool_copy(
-      shgrp, "hairCloseTip", (part->shape_flag & PART_SHAPE_CLOSE_TIP) != 0);
-  /* TODO(fclem): Until we have a better way to cull the hair and render with orco, bypass culling
-   * test. */
+  DRW_shgroup_uniform_float_copy(shgrp, "hairRadRoot", hair_rad_root);
+  DRW_shgroup_uniform_float_copy(shgrp, "hairRadTip", hair_rad_tip);
+  DRW_shgroup_uniform_bool_copy(shgrp, "hairCloseTip", hair_close_tip);
+  /* TODO(fclem): Until we have a better way to cull the hair and render with orco, bypass
+   * culling test. */
   GPUBatch *geom = hair_cache->final[subdiv].proc_hairs[thickness_res - 1];
   DRW_shgroup_call_no_cull(shgrp, geom, object);
 
diff --git a/source/blender/draw/intern/draw_hair_private.h b/source/blender/draw/intern/draw_hair_private.h
index c03b4822b1b..4d9eaf88a7d 100644
--- a/source/blender/draw/intern/draw_hair_private.h
+++ b/source/blender/draw/intern/draw_hair_private.h
@@ -79,6 +79,8 @@ typedef struct ParticleHairCache {
   int point_len;
 } ParticleHairCache;
 
+void particle_batch_cache_clear_hair(struct ParticleHairCache *hair_cache);
+
 bool particles_ensure_procedural_data(struct Object *object,
                                       struct ParticleSystem *psys,
                                       struct ModifierData *md,
@@ -86,4 +88,9 @@ bool particles_ensure_procedural_data(struct Object *object,
                                       int subdiv,
                                       int thickness_res);
 
+bool hair_ensure_procedural_data(struct Object *object,
+                                 struct ParticleHairCache **r_hair_cache,
+                                 int subdiv,
+                                 int thickness_res);
+
 #endif /* __DRAW_HAIR_PRIVATE_H__ */
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index 618922d8544..df3a1e3da79 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -38,6 +38,7 @@
 #include "BKE_editmesh.h"
 #include "BKE_global.h"
 #include "BKE_gpencil.h"
+#include "BKE_hair.h"
 #include "BKE_lattice.h"
 #include "BKE_main.h"
 #include "BKE_mball.h"
@@ -48,6 +49,8 @@
 #include "BKE_paint.h"
 #include "BKE_pbvh.h"
 #include "BKE_pointcache.h"
+#include "BKE_pointcloud.h"
+#include "BKE_volume.h"
 
 #include "draw_manager.h"
 #include "DNA_camera_types.h"
@@ -2653,6 +2656,15 @@ void DRW_engines_register(void)
 
     BKE_gpencil_batch_cache_dirty_tag_cb = DRW_gpencil_batch_cache_dirty_tag;
     BKE_gpencil_batch_cache_free_cb = DRW_gpencil_batch_cache_free;
+
+    BKE_hair_batch_cache_dirty_tag_cb = DRW_hair_batch_cache_dirty_tag;
+    BKE_hair_batch_cache_free_cb = DRW_hair_batch_cache_free;
+
+    BKE_pointcloud_batch_cache_dirty_tag_cb = DRW_pointcloud_batch_cache_dirty_tag;
+    BKE_pointcloud_batch_cache_free_cb = DRW_pointcloud_batch_cache_free;
+
+    BKE_volume_batch_cache_dirty_tag_cb = DRW_volume_batch_cache_dirty_tag;
+    BKE_volume_batch_cache_free_cb = DRW_volume_batch_cache_free;
   }
 }