Overlay-Next: Facing

Overlay-Next version of facing.

Rel #102179

Pull Request: https://projects.blender.org/blender/blender/pulls/126153

source/blender/draw/CMakeLists.txt

@@ -294,6 +294,7 @@ set(SRC
   engines/overlay/overlay_next_bounds.hh
   engines/overlay/overlay_next_empty.hh
   engines/overlay/overlay_next_camera.hh
+  engines/overlay/overlay_next_facing.hh
   engines/overlay/overlay_next_force_field.hh
   engines/overlay/overlay_next_grid.hh
   engines/overlay/overlay_next_instance.hh

source/blender/draw/engines/overlay/overlay_next_facing.hh

@@ -0,0 +1,83 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup overlay
+ */
+
+#pragma once
+
+#include "BKE_paint.hh"
+
+#include "overlay_next_private.hh"
+
+namespace blender::draw::overlay {
+
+class Facing {
+
+ private:
+  const SelectionType selection_type_;
+
+  PassMain ps_ = {"Facing"};
+
+  bool enabled = false;
+
+ public:
+  Facing(const SelectionType selection_type_) : selection_type_(selection_type_) {}
+
+  void begin_sync(Resources &res, const State &state)
+  {
+    enabled = state.overlay.flag & V3D_OVERLAY_FACE_ORIENTATION && !state.xray_enabled &&
+              selection_type_ == SelectionType::DISABLED;
+    if (!enabled) {
+      /* Not used. But release the data. */
+      ps_.init();
+      return;
+    }
+    ps_.init();
+    ps_.state_set(DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WRITE_DEPTH |
+                  state.clipping_state);
+    ps_.shader_set(res.shaders.facing.get());
+    ps_.bind_ubo("globalsBlock", &res.globals_buf);
+  }
+
+  void object_sync(Manager &manager, const ObjectRef &ob_ref, const State &state)
+  {
+    if (!enabled) {
+      return;
+    }
+    const bool renderable = DRW_object_is_renderable(ob_ref.object);
+    const bool draw_surface = (ob_ref.object->dt >= OB_WIRE) &&
+                              (renderable || (ob_ref.object->dt == OB_WIRE));
+    const bool draw_facing = draw_surface && (ob_ref.object->dt >= OB_SOLID);
+    if (!draw_facing) {
+      return;
+    }
+    const bool use_sculpt_pbvh = BKE_sculptsession_use_pbvh_draw(ob_ref.object, state.rv3d) &&
+                                 !DRW_state_is_image_render();
+
+    if (use_sculpt_pbvh) {
+      /* TODO: Add sculpt mode. */
+      // DRW_shgroup_call_sculpt(pd->facing_grp[is_xray], ob, false, false, false, false, false);
+    }
+    else {
+      blender::gpu::Batch *geom = DRW_cache_object_surface_get(ob_ref.object);
+      if (geom) {
+        ResourceHandle res_handle = manager.resource_handle(ob_ref);
+        ps_.draw(geom, res_handle);
+      }
+    }
+  }
+
+  void draw(Framebuffer &framebuffer, Manager &manager, View &view)
+  {
+    if (!enabled) {
+      return;
+    }
+    GPU_framebuffer_bind(framebuffer);
+    manager.submit(ps_, view);
+  }
+};
+
+}  // namespace blender::draw::overlay

source/blender/draw/engines/overlay/overlay_next_force_field.hh

@@ -52,6 +52,9 @@ class ForceFields {
 
   void object_sync(const ObjectRef &ob_ref, Resources &res, const State &state)
   {
+    if (!ob_ref.object->pd || !ob_ref.object->pd->forcefield) {
+      return;
+    }
     const select::ID select_id = res.select_id(ob_ref);
     const Object *ob = ob_ref.object;
     PartDeflect *pd = ob->pd;

source/blender/draw/engines/overlay/overlay_next_instance.cc

@@ -90,6 +90,7 @@ void Instance::begin_sync()
     layer.bounds.begin_sync();
     layer.cameras.begin_sync();
     layer.empties.begin_sync();
+    layer.facing.begin_sync(resources, state);
     layer.force_fields.begin_sync();
     layer.lattices.begin_sync(resources, state);
     layer.lights.begin_sync();
@@ -113,7 +114,8 @@ void Instance::object_sync(ObjectRef &ob_ref, Manager &manager)
   const bool in_edit_mode = object_is_edit_mode(ob_ref.object);
   const bool needs_prepass = true; /* TODO */
 
-  OverlayLayer &layer = (ob_ref.object->dtx & OB_DRAW_IN_FRONT) ? infront : regular;
+  OverlayLayer &layer = (state.use_in_front && ob_ref.object->dtx & OB_DRAW_IN_FRONT) ? infront :
+                                                                                        regular;
 
   if (needs_prepass) {
     switch (ob_ref.object->type) {
@@ -183,9 +185,8 @@ void Instance::object_sync(ObjectRef &ob_ref, Manager &manager)
         layer.speakers.object_sync(ob_ref, resources, state);
         break;
     }
-    if (ob_ref.object->pd && ob_ref.object->pd->forcefield) {
-      layer.force_fields.object_sync(ob_ref, resources, state);
-    }
+    layer.facing.object_sync(manager, ob_ref, state);
+    layer.force_fields.object_sync(ob_ref, resources, state);
     layer.bounds.object_sync(ob_ref, resources, state);
     layer.relations.object_sync(ob_ref, resources, state);
   }
@@ -290,6 +291,12 @@ void Instance::draw(Manager &manager)
   regular.prepass.draw(resources.overlay_line_fb, manager, view);
   infront.prepass.draw(resources.overlay_line_in_front_fb, manager, view);
 
+  auto overlay_fb_draw = [&](OverlayLayer &layer, Framebuffer &framebuffer) {
+    regular.facing.draw(framebuffer, manager, view);
+  };
+
+  overlay_fb_draw(regular, resources.overlay_fb);
+
   auto draw_layer = [&](OverlayLayer &layer, Framebuffer &framebuffer) {
     layer.bounds.draw(framebuffer, manager, view);
     layer.cameras.draw(framebuffer, manager, view);

source/blender/draw/engines/overlay/overlay_next_instance.hh

@@ -15,6 +15,7 @@
 #include "overlay_next_bounds.hh"
 #include "overlay_next_camera.hh"
 #include "overlay_next_empty.hh"
+#include "overlay_next_facing.hh"
 #include "overlay_next_force_field.hh"
 #include "overlay_next_grid.hh"
 #include "overlay_next_lattice.hh"
@@ -54,6 +55,7 @@ class Instance {
     Bounds bounds = {selection_type_};
     Cameras cameras = {selection_type_};
     Empties empties = {selection_type_};
+    Facing facing = {selection_type_};
     ForceFields force_fields = {selection_type_};
     Lattices lattices;
     Lights lights = {selection_type_};

source/blender/draw/engines/overlay/overlay_next_private.hh

@@ -191,6 +191,7 @@ class ShaderModule {
   ShaderPtr extra_wire;
   ShaderPtr extra_loose_points;
   ShaderPtr extra_ground_line;
+  ShaderPtr facing;
   ShaderPtr lattice_points;
   ShaderPtr lattice_wire;
 

source/blender/draw/engines/overlay/overlay_next_shader.cc

@@ -176,6 +176,12 @@ ShaderModule::ShaderModule(const SelectionType selection_type, const bool clippi
     info.additional_info("draw_view", "draw_modelmat_new", "draw_resource_handle_new");
   });
 
+  facing = shader("overlay_facing", [](gpu::shader::ShaderCreateInfo &info) {
+    info.additional_infos_.clear();
+    info.additional_info(
+        "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
+  });
+
   extra_shape = selectable_shader("overlay_extra", [](gpu::shader::ShaderCreateInfo &info) {
     info.storage_buf(0, Qualifier::READ, "ExtraInstanceData", "data_buf[]");
     info.define("color", "data_buf[gl_InstanceID].color_");