DRWManager: New implementation.

This is a new implementation of the draw manager using modern
rendering practices and GPU driven culling.

This only ports features that are not considered deprecated or to be
removed.

The old DRW API is kept working along side this new one, and does not
interfeer with it. However this needed some more hacking inside the
draw_view_lib.glsl. At least the create info are well separated.

The reviewer might start by looking at `draw_pass_test.cc` to see the
API in usage.

Important files are `draw_pass.hh`, `draw_command.hh`,
`draw_command_shared.hh`.

In a nutshell (for a developper used to old DRW API):
- `DRWShadingGroups` are replaced by `Pass<T>::Sub`.
- Contrary to DRWShadingGroups, all commands recorded inside a pass or
   sub-pass (even binds / push_constant / uniforms) will be executed in order.
- All memory is managed per object (except for Sub-Pass which are managed
   by their parent pass) and not from draw manager pools. So passes "can"
   potentially be recorded once and submitted multiple time (but this is
   not really encouraged for now). The only implicit link is between resource
   lifetime and `ResourceHandles`
- Sub passes can be any level deep.
- IMPORTANT: All state propagate from sub pass to subpass. There is no
   state stack concept anymore. Ensure the correct render state is set before
   drawing anything using `Pass::state_set()`.
- The drawcalls now needs a `ResourceHandle` instead of an `Object *`.
   This is to remove any implicit dependency between `Pass` and `Manager`.
   This was a huge problem in old implementation since the manager did not
   know what to pull from the object. Now it is explicitly requested by the
   engine.
- The pases need to be submitted to a `draw::Manager` instance which can
   be retrieved using `DRW_manager_get()` (for now).

Internally:
- All object data are stored in contiguous storage buffers. Removing a lot
   of complexity in the pass submission.
- Draw calls are sorted and visibility tested on GPU. Making more modern
   culling and better instancing usage possible in the future.
- Unit Tests have been added for regression testing and avoid most API
   breakage.
- `draw::View` now contains culling data for all objects in the scene
   allowing caching for multiple views.
- Bounding box and sphere final setup is moved to GPU.
- Some global resources locations have been hardcoded to reduce complexity.

What is missing:
- ~~Workaround for lack of gl_BaseInstanceARB.~~ Done
- ~~Object Uniform Attributes.~~ Done (Not in this patch)
- Workaround for hardware supporting a maximum of 8 SSBO.

Reviewed By: jbakker

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

12 files changed, 371 insertions, 16 deletions

diff --git a/source/blender/draw/intern/shaders/common_debug_draw_lib.glsl b/source/blender/draw/intern/shaders/common_debug_draw_lib.glsl
index 5f795d3abdb..3287897e73c 100644
--- a/source/blender/draw/intern/shaders/common_debug_draw_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_debug_draw_lib.glsl
@@ -17,8 +17,7 @@ const vec4 drw_debug_default_color = vec4(1.0, 0.0, 0.0, 1.0);
 uint drw_debug_start_draw(uint v_needed)
 {
   uint vertid = atomicAdd(drw_debug_draw_v_count, v_needed);
-  /* NOTE: Skip the header manually. */
-  vertid += 1;
+  vertid += drw_debug_draw_offset;
   return vertid;
 }
 
diff --git a/source/blender/draw/intern/shaders/common_debug_print_lib.glsl b/source/blender/draw/intern/shaders/common_debug_print_lib.glsl
index 0c7f32bd00d..89d1729b52d 100644
--- a/source/blender/draw/intern/shaders/common_debug_print_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_debug_print_lib.glsl
@@ -71,8 +71,7 @@ void drw_print_char4(uint data)
       break;
     }
     uint cursor = atomicAdd(drw_debug_print_cursor, 1u);
-    /* NOTE: Skip the header manually. */
-    cursor += 4;
+    cursor += drw_debug_print_offset;
     if (cursor < DRW_DEBUG_PRINT_MAX) {
       /* For future usage. (i.e: Color) */
       uint flags = 0u;
diff --git a/source/blender/draw/intern/shaders/common_intersect_lib.glsl b/source/blender/draw/intern/shaders/common_intersect_lib.glsl
index 33378588553..83223f89277 100644
--- a/source/blender/draw/intern/shaders/common_intersect_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_intersect_lib.glsl
@@ -70,6 +70,30 @@ IsectBox isect_data_setup(Box shape)
   return data;
 }
 
+/* Construct box from 1 corner point + 3 side vectors. */
+IsectBox isect_data_setup(vec3 origin, vec3 side_x, vec3 side_y, vec3 side_z)
+{
+  IsectBox data;
+  data.corners[0] = origin;
+  data.corners[1] = origin + side_x;
+  data.corners[2] = origin + side_y + side_x;
+  data.corners[3] = origin + side_y;
+  data.corners[4] = data.corners[0] + side_z;
+  data.corners[5] = data.corners[1] + side_z;
+  data.corners[6] = data.corners[2] + side_z;
+  data.corners[7] = data.corners[3] + side_z;
+
+  data.planes[0] = isect_plane_setup(data.corners[0], side_y, side_z);
+  data.planes[1] = isect_plane_setup(data.corners[0], side_x, side_y);
+  data.planes[2] = isect_plane_setup(data.corners[0], side_z, side_x);
+  /* Assumes that the box is actually a box! */
+  data.planes[3] = vec4(-data.planes[0].xyz, -dot(-data.planes[0].xyz, data.corners[6]));
+  data.planes[4] = vec4(-data.planes[1].xyz, -dot(-data.planes[1].xyz, data.corners[6]));
+  data.planes[5] = vec4(-data.planes[2].xyz, -dot(-data.planes[2].xyz, data.corners[6]));
+
+  return data;
+}
+
 struct IsectFrustum {
   vec3 corners[8];
   vec4 planes[6];
@@ -194,6 +218,50 @@ bool intersect_view(Box box)
   return intersects;
 }
 
+bool intersect_view(IsectBox i_box)
+{
+  bool intersects = true;
+
+  /* Do Box vertices vs Frustum planes. */
+  for (int p = 0; p < 6; ++p) {
+    bool is_any_vertex_on_positive_side = false;
+    for (int v = 0; v < 8; ++v) {
+      float test = dot(drw_view.frustum_planes[p], vec4(i_box.corners[v], 1.0));
+      if (test > 0.0) {
+        is_any_vertex_on_positive_side = true;
+        break;
+      }
+    }
+    bool all_vertex_on_negative_side = !is_any_vertex_on_positive_side;
+    if (all_vertex_on_negative_side) {
+      intersects = false;
+      break;
+    }
+  }
+
+  if (!intersects) {
+    return intersects;
+  }
+
+  for (int p = 0; p < 6; ++p) {
+    bool is_any_vertex_on_positive_side = false;
+    for (int v = 0; v < 8; ++v) {
+      float test = dot(i_box.planes[p], vec4(drw_view.frustum_corners[v].xyz, 1.0));
+      if (test > 0.0) {
+        is_any_vertex_on_positive_side = true;
+        break;
+      }
+    }
+    bool all_vertex_on_negative_side = !is_any_vertex_on_positive_side;
+    if (all_vertex_on_negative_side) {
+      intersects = false;
+      break;
+    }
+  }
+
+  return intersects;
+}
+
 bool intersect_view(Sphere sphere)
 {
   bool intersects = true;
diff --git a/source/blender/draw/intern/shaders/common_view_lib.glsl b/source/blender/draw/intern/shaders/common_view_lib.glsl
index 8ab2ef10e4c..6521476c3a7 100644
--- a/source/blender/draw/intern/shaders/common_view_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_view_lib.glsl
@@ -155,7 +155,11 @@ uniform int drw_ResourceID;
 #    define PASS_RESOURCE_ID
 
 #  elif defined(GPU_VERTEX_SHADER)
-#    define resource_id gpu_InstanceIndex
+#    if defined(UNIFORM_RESOURCE_ID_NEW)
+#      define resource_id drw_ResourceID
+#    else
+#      define resource_id gpu_InstanceIndex
+#    endif
 #    define PASS_RESOURCE_ID drw_ResourceID_iface.resource_index = resource_id;
 
 #  elif defined(GPU_GEOMETRY_SHADER)
@@ -203,8 +207,8 @@ flat in int resourceIDFrag;
 #  ifndef DRW_SHADER_SHARED_H
 
 struct ObjectMatrices {
-  mat4 drw_modelMatrix;
-  mat4 drw_modelMatrixInverse;
+  mat4 model;
+  mat4 model_inverse;
 };
 #  endif /* DRW_SHADER_SHARED_H */
 
@@ -214,8 +218,8 @@ layout(std140) uniform modelBlock
   ObjectMatrices drw_matrices[DRW_RESOURCE_CHUNK_LEN];
 };
 
-#    define ModelMatrix (drw_matrices[resource_id].drw_modelMatrix)
-#    define ModelMatrixInverse (drw_matrices[resource_id].drw_modelMatrixInverse)
+#    define ModelMatrix (drw_matrices[resource_id].model)
+#    define ModelMatrixInverse (drw_matrices[resource_id].model_inverse)
 #  endif /* USE_GPU_SHADER_CREATE_INFO */
 
 #else /* GPU_INTEL */
diff --git a/source/blender/draw/intern/shaders/draw_command_generate_comp.glsl b/source/blender/draw/intern/shaders/draw_command_generate_comp.glsl
new file mode 100644
index 00000000000..70842e5bb81
--- /dev/null
+++ b/source/blender/draw/intern/shaders/draw_command_generate_comp.glsl
@@ -0,0 +1,84 @@
+
+/**
+ * Convert DrawPrototype into draw commands.
+ */
+
+#pragma BLENDER_REQUIRE(common_math_lib.glsl)
+
+#define atomicAddAndGet(dst, val) (atomicAdd(dst, val) + val)
+
+/* This is only called by the last thread executed over the group's prototype draws. */
+void write_draw_call(DrawGroup group, uint group_id)
+{
+  DrawCommand cmd;
+  cmd.vertex_len = group.vertex_len;
+  cmd.vertex_first = group.vertex_first;
+  if (group.base_index != -1) {
+    cmd.base_index = group.base_index;
+    cmd.instance_first_indexed = group.start;
+  }
+  else {
+    cmd._instance_first_array = group.start;
+  }
+  /* Back-facing command. */
+  cmd.instance_len = group_buf[group_id].back_facing_counter;
+  command_buf[group_id * 2 + 0] = cmd;
+  /* Front-facing command. */
+  cmd.instance_len = group_buf[group_id].front_facing_counter;
+  command_buf[group_id * 2 + 1] = cmd;
+
+  /* Reset the counters for a next command gen dispatch. Avoids resending the whole data just
+   * for this purpose. Only the last thread will execute this so it is threadsafe.  */
+  group_buf[group_id].front_facing_counter = 0u;
+  group_buf[group_id].back_facing_counter = 0u;
+  group_buf[group_id].total_counter = 0u;
+}
+
+void main()
+{
+  uint proto_id = gl_GlobalInvocationID.x;
+  if (proto_id >= prototype_len) {
+    return;
+  }
+
+  DrawPrototype proto = prototype_buf[proto_id];
+  uint group_id = proto.group_id;
+  bool is_inverted = (proto.resource_handle & 0x80000000u) != 0;
+  uint resource_index = (proto.resource_handle & 0x7FFFFFFFu);
+
+  /* Visibility test result. */
+  bool is_visible = ((visibility_buf[resource_index / 32u] & (1u << (resource_index % 32u)))) != 0;
+
+  DrawGroup group = group_buf[group_id];
+
+  if (!is_visible) {
+    /* Skip the draw but still count towards the completion. */
+    if (atomicAddAndGet(group_buf[group_id].total_counter, proto.instance_len) == group.len) {
+      write_draw_call(group, group_id);
+    }
+    return;
+  }
+
+  uint back_facing_len = group.len - group.front_facing_len;
+  uint front_facing_len = group.front_facing_len;
+  uint dst_index = group.start;
+  if (is_inverted) {
+    uint offset = atomicAdd(group_buf[group_id].back_facing_counter, proto.instance_len);
+    dst_index += offset;
+    if (atomicAddAndGet(group_buf[group_id].total_counter, proto.instance_len) == group.len) {
+      write_draw_call(group, group_id);
+    }
+  }
+  else {
+    uint offset = atomicAdd(group_buf[group_id].front_facing_counter, proto.instance_len);
+    dst_index += back_facing_len + offset;
+    if (atomicAddAndGet(group_buf[group_id].total_counter, proto.instance_len) == group.len) {
+      write_draw_call(group, group_id);
+    }
+  }
+
+  for (uint i = dst_index; i < dst_index + proto.instance_len; i++) {
+    /* Fill resource_id buffer for each instance of this draw */
+    resource_id_buf[i] = resource_index;
+  }
+}
diff --git a/source/blender/draw/intern/shaders/draw_debug_draw_display_vert.glsl b/source/blender/draw/intern/shaders/draw_debug_draw_display_vert.glsl
index ab76df819d5..4061dda5d1c 100644
--- a/source/blender/draw/intern/shaders/draw_debug_draw_display_vert.glsl
+++ b/source/blender/draw/intern/shaders/draw_debug_draw_display_vert.glsl
@@ -6,7 +6,7 @@
 void main()
 {
   /* Skip the first vertex containing header data. */
-  DRWDebugVert vert = drw_debug_verts_buf[gl_VertexID + 1];
+  DRWDebugVert vert = drw_debug_verts_buf[gl_VertexID + 2];
   vec3 pos = uintBitsToFloat(uvec3(vert.pos0, vert.pos1, vert.pos2));
   vec4 col = vec4((uvec4(vert.color) >> uvec4(0, 8, 16, 24)) & 0xFFu) / 255.0;
 
diff --git a/source/blender/draw/intern/shaders/draw_debug_info.hh b/source/blender/draw/intern/shaders/draw_debug_info.hh
index 893a5e537d9..ce450bb1210 100644
--- a/source/blender/draw/intern/shaders/draw_debug_info.hh
+++ b/source/blender/draw/intern/shaders/draw_debug_info.hh
@@ -1,5 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 
+#include "draw_defines.h"
 #include "gpu_shader_create_info.hh"
 
 /* -------------------------------------------------------------------- */
@@ -10,7 +11,7 @@
 
 GPU_SHADER_CREATE_INFO(draw_debug_print)
     .typedef_source("draw_shader_shared.h")
-    .storage_buf(7, Qualifier::READ_WRITE, "uint", "drw_debug_print_buf[]");
+    .storage_buf(DRW_DEBUG_PRINT_SLOT, Qualifier::READ_WRITE, "uint", "drw_debug_print_buf[]");
 
 GPU_SHADER_INTERFACE_INFO(draw_debug_print_display_iface, "").flat(Type::UINT, "char_index");
 
@@ -34,7 +35,10 @@ GPU_SHADER_CREATE_INFO(draw_debug_print_display)
 
 GPU_SHADER_CREATE_INFO(draw_debug_draw)
     .typedef_source("draw_shader_shared.h")
-    .storage_buf(6, Qualifier::READ_WRITE, "DRWDebugVert", "drw_debug_verts_buf[]");
+    .storage_buf(DRW_DEBUG_DRAW_SLOT,
+                 Qualifier::READ_WRITE,
+                 "DRWDebugVert",
+                 "drw_debug_verts_buf[]");
 
 GPU_SHADER_INTERFACE_INFO(draw_debug_draw_display_iface, "interp").flat(Type::VEC4, "color");
 
diff --git a/source/blender/draw/intern/shaders/draw_debug_print_display_vert.glsl b/source/blender/draw/intern/shaders/draw_debug_print_display_vert.glsl
index f67e9d3f9e0..cb379056e2b 100644
--- a/source/blender/draw/intern/shaders/draw_debug_print_display_vert.glsl
+++ b/source/blender/draw/intern/shaders/draw_debug_print_display_vert.glsl
@@ -8,7 +8,7 @@
 void main()
 {
   /* Skip first 4 chars containing header data. */
-  uint char_data = drw_debug_print_buf[gl_VertexID + 4];
+  uint char_data = drw_debug_print_buf[gl_VertexID + 8];
   char_index = (char_data & 0xFFu) - 0x20u;
 
   /* Discard invalid chars. */
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 8fd55ea351f..2ec40ab76e3 100644
--- a/source/blender/draw/intern/shaders/draw_object_infos_info.hh
+++ b/source/blender/draw/intern/shaders/draw_object_infos_info.hh
@@ -1,10 +1,14 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 
+#include "draw_defines.h"
 #include "gpu_shader_create_info.hh"
 
 GPU_SHADER_CREATE_INFO(draw_object_infos)
     .typedef_source("draw_shader_shared.h")
     .define("OBINFO_LIB")
+    .define("OrcoTexCoFactors", "(drw_infos[resource_id].orco_mul_bias)")
+    .define("ObjectInfo", "(drw_infos[resource_id].infos)")
+    .define("ObjectColor", "(drw_infos[resource_id].color)")
     .uniform_buf(1, "ObjectInfos", "drw_infos[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH);
 
 GPU_SHADER_CREATE_INFO(draw_volume_infos)
@@ -14,3 +18,11 @@ GPU_SHADER_CREATE_INFO(draw_volume_infos)
 GPU_SHADER_CREATE_INFO(draw_curves_infos)
     .typedef_source("draw_shader_shared.h")
     .uniform_buf(2, "CurvesInfos", "drw_curves", Frequency::BATCH);
+
+GPU_SHADER_CREATE_INFO(draw_object_infos_new)
+    .typedef_source("draw_shader_shared.h")
+    .define("OBINFO_LIB")
+    .define("OrcoTexCoFactors", "(drw_infos[resource_id].orco_mul_bias)")
+    .define("ObjectInfo", "(drw_infos[resource_id].infos)")
+    .define("ObjectColor", "(drw_infos[resource_id].color)")
+    .storage_buf(DRW_OBJ_INFOS_SLOT, Qualifier::READ, "ObjectInfos", "drw_infos[]");
\ No newline at end of file
diff --git a/source/blender/draw/intern/shaders/draw_resource_finalize_comp.glsl b/source/blender/draw/intern/shaders/draw_resource_finalize_comp.glsl
new file mode 100644
index 00000000000..d834435e54e
--- /dev/null
+++ b/source/blender/draw/intern/shaders/draw_resource_finalize_comp.glsl
@@ -0,0 +1,64 @@
+
+/**
+ * Finish computation of a few draw resource after sync.
+ */
+
+#pragma BLENDER_REQUIRE(common_math_lib.glsl)
+
+void main()
+{
+  uint resource_id = gl_GlobalInvocationID.x;
+  if (resource_id >= resource_len) {
+    return;
+  }
+
+  mat4 model_mat = matrix_buf[resource_id].model;
+  ObjectInfos infos = infos_buf[resource_id];
+  ObjectBounds bounds = bounds_buf[resource_id];
+
+  if (bounds.bounding_sphere.w != -1.0) {
+    /* Convert corners to origin + sides in world space. */
+    vec3 p0 = bounds.bounding_corners[0].xyz;
+    vec3 p01 = bounds.bounding_corners[1].xyz - p0;
+    vec3 p02 = bounds.bounding_corners[2].xyz - p0;
+    vec3 p03 = bounds.bounding_corners[3].xyz - p0;
+    /* Avoid flat box. */
+    p01.x = max(p01.x, 1e-4);
+    p02.y = max(p02.y, 1e-4);
+    p03.z = max(p03.z, 1e-4);
+    vec3 diagonal = p01 + p02 + p03;
+    vec3 center = p0 + diagonal * 0.5;
+    float min_axis = min_v3(abs(diagonal));
+    bounds_buf[resource_id].bounding_sphere.xyz = transform_point(model_mat, center);
+    /* We have to apply scaling to the diagonal. */
+    bounds_buf[resource_id].bounding_sphere.w = length(transform_direction(model_mat, diagonal)) *
+                                                0.5;
+    bounds_buf[resource_id]._inner_sphere_radius = min_axis;
+    bounds_buf[resource_id].bounding_corners[0].xyz = transform_point(model_mat, p0);
+    bounds_buf[resource_id].bounding_corners[1].xyz = transform_direction(model_mat, p01);
+    bounds_buf[resource_id].bounding_corners[2].xyz = transform_direction(model_mat, p02);
+    bounds_buf[resource_id].bounding_corners[3].xyz = transform_direction(model_mat, p03);
+    /* Always have correct handedness in the corners vectors. */
+    if (flag_test(infos.flag, OBJECT_NEGATIVE_SCALE)) {
+      bounds_buf[resource_id].bounding_corners[0].xyz +=
+          bounds_buf[resource_id].bounding_corners[1].xyz;
+      bounds_buf[resource_id].bounding_corners[1].xyz =
+          -bounds_buf[resource_id].bounding_corners[1].xyz;
+    }
+
+    /* TODO: Bypass test for very large objects (see T67319). */
+    if (bounds_buf[resource_id].bounding_sphere.w > 1e12) {
+      bounds_buf[resource_id].bounding_sphere.w = -1.0;
+    }
+  }
+
+  vec3 loc = infos.orco_add;  /* Box center. */
+  vec3 size = infos.orco_mul; /* Box half-extent. */
+  /* This is what the original computation looks like.
+   * Simplify to a nice MADD in shading code. */
+  // orco = (pos - loc) / size;
+  // orco = pos * (1.0 / size) + (-loc / size);
+  vec3 size_inv = safe_rcp(size);
+  infos_buf[resource_id].orco_add = -loc * size_inv;
+  infos_buf[resource_id].orco_mul = size_inv;
+}
\ No newline at end of file
diff --git a/source/blender/draw/intern/shaders/draw_view_info.hh b/source/blender/draw/intern/shaders/draw_view_info.hh
index 0400521c53d..c522c607791 100644
--- a/source/blender/draw/intern/shaders/draw_view_info.hh
+++ b/source/blender/draw/intern/shaders/draw_view_info.hh
@@ -1,5 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 
+#include "draw_defines.h"
 #include "gpu_shader_create_info.hh"
 
 /* -------------------------------------------------------------------- */
@@ -44,13 +45,13 @@ GPU_SHADER_CREATE_INFO(draw_resource_handle)
  * \{ */
 
 GPU_SHADER_CREATE_INFO(draw_view)
-    .uniform_buf(0, "ViewInfos", "drw_view", Frequency::PASS)
+    .uniform_buf(DRW_VIEW_UBO_SLOT, "ViewInfos", "drw_view", Frequency::PASS)
     .typedef_source("draw_shader_shared.h");
 
 GPU_SHADER_CREATE_INFO(draw_modelmat)
     .uniform_buf(8, "ObjectMatrices", "drw_matrices[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH)
-    .define("ModelMatrix", "(drw_matrices[resource_id].drw_modelMatrix)")
-    .define("ModelMatrixInverse", "(drw_matrices[resource_id].drw_modelMatrixInverse)")
+    .define("ModelMatrix", "(drw_matrices[resource_id].model)")
+    .define("ModelMatrixInverse", "(drw_matrices[resource_id].model_inverse)")
     .additional_info("draw_view");
 
 GPU_SHADER_CREATE_INFO(draw_modelmat_legacy)
@@ -136,3 +137,77 @@ GPU_SHADER_CREATE_INFO(draw_gpencil)
     .additional_info("draw_modelmat", "draw_resource_id_uniform", "draw_object_infos");
 
 /** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Internal Draw Manager usage
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(draw_resource_finalize)
+    .do_static_compilation(true)
+    .typedef_source("draw_shader_shared.h")
+    .define("DRAW_FINALIZE_SHADER")
+    .local_group_size(DRW_FINALIZE_GROUP_SIZE)
+    .storage_buf(0, Qualifier::READ, "ObjectMatrices", "matrix_buf[]")
+    .storage_buf(1, Qualifier::READ_WRITE, "ObjectBounds", "bounds_buf[]")
+    .storage_buf(2, Qualifier::READ_WRITE, "ObjectInfos", "infos_buf[]")
+    .push_constant(Type::INT, "resource_len")
+    .compute_source("draw_resource_finalize_comp.glsl");
+
+GPU_SHADER_CREATE_INFO(draw_visibility_compute)
+    .do_static_compilation(true)
+    .local_group_size(DRW_VISIBILITY_GROUP_SIZE)
+    .storage_buf(0, Qualifier::READ, "ObjectBounds", "bounds_buf[]")
+    .storage_buf(1, Qualifier::READ_WRITE, "uint", "visibility_buf[]")
+    .push_constant(Type::INT, "resource_len")
+    .compute_source("draw_visibility_comp.glsl")
+    .additional_info("draw_view");
+
+GPU_SHADER_CREATE_INFO(draw_command_generate)
+    .do_static_compilation(true)
+    .typedef_source("draw_shader_shared.h")
+    .typedef_source("draw_command_shared.hh")
+    .local_group_size(DRW_COMMAND_GROUP_SIZE)
+    .storage_buf(0, Qualifier::READ_WRITE, "DrawGroup", "group_buf[]")
+    .storage_buf(1, Qualifier::READ, "uint", "visibility_buf[]")
+    .storage_buf(2, Qualifier::READ, "DrawPrototype", "prototype_buf[]")
+    .storage_buf(3, Qualifier::WRITE, "DrawCommand", "command_buf[]")
+    .storage_buf(DRW_RESOURCE_ID_SLOT, Qualifier::WRITE, "uint", "resource_id_buf[]")
+    .push_constant(Type::INT, "prototype_len")
+    .compute_source("draw_command_generate_comp.glsl");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Draw Resource ID
+ * New implementation using gl_BaseInstance and storage buffers.
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(draw_resource_id_new)
+    .define("UNIFORM_RESOURCE_ID_NEW")
+    .storage_buf(DRW_RESOURCE_ID_SLOT, Qualifier::READ, "int", "resource_id_buf[]")
+    .define("drw_ResourceID", "resource_id_buf[gpu_BaseInstance + gl_InstanceID]");
+
+/**
+ * Workaround the lack of gl_BaseInstance by binding the resource_id_buf as vertex buf.
+ */
+GPU_SHADER_CREATE_INFO(draw_resource_id_fallback)
+    .define("UNIFORM_RESOURCE_ID_NEW")
+    .vertex_in(15, Type::INT, "drw_ResourceID");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Draw Object Resources
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(draw_modelmat_new)
+    .typedef_source("draw_shader_shared.h")
+    .storage_buf(DRW_OBJ_MAT_SLOT, Qualifier::READ, "ObjectMatrices", "drw_matrix_buf[]")
+    .define("drw_ModelMatrixInverse", "drw_matrix_buf[resource_id].model_inverse")
+    .define("drw_ModelMatrix", "drw_matrix_buf[resource_id].model")
+    /* TODO For compatibility with old shaders. To be removed. */
+    .define("ModelMatrixInverse", "drw_ModelMatrixInverse")
+    .define("ModelMatrix", "drw_ModelMatrix")
+    .additional_info("draw_resource_id_new");
+
+/** \} */
diff --git a/source/blender/draw/intern/shaders/draw_visibility_comp.glsl b/source/blender/draw/intern/shaders/draw_visibility_comp.glsl
new file mode 100644
index 00000000000..7ec58c8f919
--- /dev/null
+++ b/source/blender/draw/intern/shaders/draw_visibility_comp.glsl
@@ -0,0 +1,46 @@
+
+/**
+ * Compute visibility of each resource bounds for a given view.
+ */
+/* TODO(fclem): This could be augmented by a 2 pass occlusion culling system. */
+
+#pragma BLENDER_REQUIRE(common_math_lib.glsl)
+#pragma BLENDER_REQUIRE(common_intersect_lib.glsl)
+
+shared uint shared_result;
+
+void mask_visibility_bit()
+{
+  uint bit = 1u << gl_LocalInvocationID.x;
+  atomicAnd(visibility_buf[gl_WorkGroupID.x], ~bit);
+}
+
+void main()
+{
+  if (gl_GlobalInvocationID.x >= resource_len) {
+    return;
+  }
+
+  ObjectBounds bounds = bounds_buf[gl_GlobalInvocationID.x];
+
+  if (bounds.bounding_sphere.w != -1.0) {
+    IsectBox box = isect_data_setup(bounds.bounding_corners[0].xyz,
+                                    bounds.bounding_corners[1].xyz,
+                                    bounds.bounding_corners[2].xyz,
+                                    bounds.bounding_corners[3].xyz);
+    Sphere bounding_sphere = Sphere(bounds.bounding_sphere.xyz, bounds.bounding_sphere.w);
+    Sphere inscribed_sphere = Sphere(bounds.bounding_sphere.xyz, bounds._inner_sphere_radius);
+
+    if (intersect_view(inscribed_sphere) == true) {
+      /* Visible. */
+    }
+    else if (intersect_view(bounding_sphere) == false) {
+      /* Not visible. */
+      mask_visibility_bit();
+    }
+    else if (intersect_view(box) == false) {
+      /* Not visible. */
+      mask_visibility_bit();
+    }
+  }
+}
\ No newline at end of file