Cleanup: balance doxygen grouping, minor grouping adjustment

intern/ghost/intern/GHOST_SystemWayland.cc

@@ -193,6 +193,8 @@ static bool use_gnome_confine_hack = false;
 #  define USE_GNOME_NEEDS_LIBDECOR_HACK
 #endif
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Local Defines
  *

source/blender/blenfont/intern/blf_font.c

@@ -129,6 +129,8 @@ static void blf_size_finalizer(void *object)
   font->ft_size = NULL;
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name FreeType Utilities (Internal)
  * \{ */

source/blender/blenfont/intern/blf_glyph.c

@@ -286,7 +286,7 @@ static GlyphBLF *blf_glyph_cache_add_glyph(
  *
  * This table can be used to find a coverage bit based on a charcode.
  * Later we can get default language and script from `codepoint`.
- */
+ * \{ */
 
 struct UnicodeBlock {
   uint first;

source/blender/blenkernel/BKE_mesh.hh

@@ -210,12 +210,12 @@ inline int edge_other_vert(const int2 &edge, const int vert)
 
 /** \} */
 
+}  // namespace blender::bke::mesh
+
 /* -------------------------------------------------------------------- */
 /** \name Inline Mesh Data Access
  * \{ */
 
-}  // namespace blender::bke::mesh
-
 inline blender::Span<blender::float3> Mesh::vert_positions() const
 {
   return {reinterpret_cast<const blender::float3 *>(BKE_mesh_vert_positions(this)), this->totvert};

source/blender/blenkernel/intern/attribute_access.cc

@@ -933,6 +933,6 @@ Vector<AttributeTransferData> retrieve_attributes_for_transfer(
   return attributes;
 }
 
-}  // namespace blender::bke
-
 /** \} */
+
+}  // namespace blender::bke

source/blender/blenkernel/intern/mesh_legacy_convert.cc

@@ -1436,6 +1436,8 @@ void BKE_mesh_legacy_edge_crease_to_layers(Mesh *mesh)
   }
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Sharp Edge Conversion
  * \{ */
@@ -1886,6 +1888,8 @@ void BKE_mesh_legacy_convert_uvs_to_generic(Mesh *mesh)
   }
 }
 
+/** \} */
+
 /** \name Selection Attribute and Legacy Flag Conversion
  * \{ */
 

source/blender/blenkernel/intern/mesh_normals.cc

@@ -193,8 +193,17 @@ void BKE_mesh_calc_poly_normal(const int *poly_verts,
                  {poly_verts, poly_size}));
 }
 
+/** \} */
+
 namespace blender::bke::mesh {
 
+/* -------------------------------------------------------------------- */
+/** \name Mesh Normal Calculation (Polygons & Vertices)
+ *
+ * Take care making optimizations to this function as improvements to low-poly
+ * meshes can slow down high-poly meshes. For details on performance, see D11993.
+ * \{ */
+
 void normals_calc_polys(const Span<float3> positions,
                         const OffsetIndices<int> polys,
                         const Span<int> corner_verts,
@@ -208,15 +217,6 @@ void normals_calc_polys(const Span<float3> positions,
   });
 }
 
-/** \} */
-
-/* -------------------------------------------------------------------- */
-/** \name Mesh Normal Calculation (Polygons & Vertices)
- *
- * Take care making optimizations to this function as improvements to low-poly
- * meshes can slow down high-poly meshes. For details on performance, see D11993.
- * \{ */
-
 void normals_calc_poly_vert(const Span<float3> positions,
                             const OffsetIndices<int> polys,
                             const Span<int> corner_verts,
@@ -305,10 +305,10 @@ void normals_calc_poly_vert(const Span<float3> positions,
   }
 }
 
-}  // namespace blender::bke::mesh
-
 /** \} */
 
+}  // namespace blender::bke::mesh
+
 /* -------------------------------------------------------------------- */
 /** \name Mesh Normal Calculation
  * \{ */

source/blender/blenkernel/intern/mesh_tessellate.cc

@@ -317,6 +317,8 @@ void looptris_calc_with_normals(const Span<float3> vert_positions,
   looptris_calc_all(vert_positions, polys, corner_verts, poly_normals, looptris);
 }
 
+/** \} */
+
 }  // namespace blender::bke::mesh
 
 void BKE_mesh_recalc_looptri(const int *corner_verts,
@@ -333,5 +335,3 @@ void BKE_mesh_recalc_looptri(const int *corner_verts,
       {corner_verts, totloop},
       {mlooptri, poly_to_tri_count(totpoly, totloop)});
 }
-
-/** \} */

source/blender/blenlib/BLI_fileops.h

@@ -139,6 +139,8 @@ typedef enum FileExternalOperation {
 bool BLI_file_external_operation_supported(const char *filepath, FileExternalOperation operation);
 bool BLI_file_external_operation_execute(const char *filepath, FileExternalOperation operation);
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Directories
  * \{ */

source/blender/blenlib/BLI_math_angle_types.hh

@@ -743,5 +743,3 @@ using AngleRadian = AngleRadianBase<float>;
 using AngleCartesian = AngleCartesianBase<float>;
 
 }  // namespace blender::math
-
-/** \} */

source/blender/blenlib/BLI_math_axis_angle_types.hh

@@ -97,5 +97,3 @@ using AxisAngle = AxisAngleBase<float, AngleRadianBase<float>>;
 using AxisAngleCartesian = AxisAngleBase<float, AngleCartesianBase<float>>;
 
 }  // namespace blender::math
-
-/** \} */

source/blender/blenlib/BLI_math_basis_types.hh

@@ -218,7 +218,7 @@ constexpr static bool operator<=(const AxisSigned::Value a, const AxisSigned::Va
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Axes utilities.
+/** \name Axes Utilities
  * \{ */
 
 template<> inline AxisSigned abs(const AxisSigned &axis)
@@ -505,5 +505,3 @@ template<typename T>
 /** \} */
 
 }  // namespace blender::math
-
-/** \} */

source/blender/blenlib/BLI_math_euler.hh

@@ -110,5 +110,3 @@ AxisAngleBase<T, AngleT> to_axis_angle(const Euler3Base<T> &euler)
 /** \} */
 
 }  // namespace blender::math
-
-/** \} */

source/blender/blenlib/BLI_math_euler_types.hh

@@ -439,5 +439,3 @@ using EulerXYZ = EulerXYZBase<float>;
 using Euler3 = Euler3Base<float>;
 
 }  // namespace blender::math
-
-/** \} */

source/blender/blenlib/BLI_math_quaternion.hh

@@ -694,5 +694,3 @@ template<typename T> VecBase<T, 3> QuaternionBase<T>::expmap() const
 /** \} */
 
 }  // namespace blender::math
-
-/** \} */

source/blender/blenlib/BLI_math_quaternion_types.hh

@@ -288,15 +288,22 @@ template<typename T> [[nodiscard]] inline bool is_normalized(const DualQuaternio
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
+/** \name Assertions
+ * \{ */
+
 template<typename U> struct AssertUnitEpsilon<QuaternionBase<U>> {
   static constexpr U value = AssertUnitEpsilon<U>::value * 10;
 };
 
-/**
- * Intermediate Types.
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Intermediate Types
  *
  * Some functions need to have higher precision than standard floats for some operations.
- */
+ * \{ */
+
 template<typename T> struct TypeTraits {
   using DoublePrecision = T;
 };
@@ -307,6 +314,6 @@ template<> struct TypeTraits<float> {
 using Quaternion = QuaternionBase<float>;
 using DualQuaternion = DualQuaternionBase<float>;
 
-}  // namespace blender::math
-
 /** \} */
+
+}  // namespace blender::math

source/blender/blenlib/BLI_math_rotation.hh

@@ -457,6 +457,10 @@ template<typename T> QuaternionBase<T> to_quaternion(const CartesianBasis &rotat
 
 namespace blender::math {
 
+/* -------------------------------------------------------------------- */
+/** \name Explicit Template Instantiations
+ * \{ */
+
 /* Using explicit template instantiations in order to reduce compilation time. */
 extern template EulerXYZ to_euler(const AxisAngle &);
 extern template EulerXYZ to_euler(const AxisAngleCartesian &);
@@ -475,6 +479,6 @@ extern template AxisAngle to_axis_angle(const Euler3 &);
 extern template AxisAngle to_axis_angle(const EulerXYZ &);
 extern template AxisAngle to_axis_angle(const Quaternion &);
 
-}  // namespace blender::math
-
 /** \} */
+
+}  // namespace blender::math

source/blender/blenlib/BLI_math_rotation_types.hh

@@ -16,5 +16,3 @@
 #include "BLI_math_basis_types.hh"
 #include "BLI_math_euler_types.hh"
 #include "BLI_math_quaternion_types.hh"
-
-/** \} */

source/blender/blenlib/BLI_math_vector.h

@@ -371,6 +371,7 @@ bool interp_v2_v2v2_slerp(float target[2], const float a[2], const float b[2], f
 void interp_v3_v3v3_slerp_safe(float target[3], const float a[3], const float b[3], float t);
 void interp_v2_v2v2_slerp_safe(float target[2], const float a[2], const float b[2], float t);
 
+/** Cubic curve interpolation (bezier spline). */
 void interp_v2_v2v2v2v2_cubic(float p[2],
                               const float v1[2],
                               const float v2[2],

source/blender/blenlib/intern/math_vector.c

@@ -134,10 +134,6 @@ void interp_v2_v2v2_slerp_safe(float target[2], const float a[2], const float b[
   }
 }
 
-/* -------------------------------------------------------------------- */
-/** \name Cubic curve interpolation (bezier spline).
- * \{ */
-
 void interp_v2_v2v2v2v2_cubic(float p[2],
                               const float v1[2],
                               const float v2[2],
@@ -157,8 +153,6 @@ void interp_v2_v2v2v2v2_cubic(float p[2],
   interp_v2_v2v2(p, r0, r1, u);
 }
 
-/** \} */
-
 void interp_v3_v3v3v3(
     float p[3], const float v1[3], const float v2[3], const float v3[3], const float w[3])
 {
@@ -1277,6 +1271,8 @@ void copy_vn_fl(float *array_tar, const int size, const float val)
   }
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Double precision versions 'db'.
  * \{ */

source/blender/blenlib/tests/BLI_string_utf8_test.cc

@@ -409,6 +409,8 @@ TEST(string, StrCursorStepNextUtf32Empty)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf32(empty, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf32_single
  * \{ */
@@ -423,6 +425,8 @@ TEST(string, StrCursorStepNextUtf32Single)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf32(single, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf32_simple
  * \{ */
@@ -439,6 +443,8 @@ TEST(string, StrCursorStepNextUtf32Simple)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf32(simple, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf32_allcombining
  * \{ */
@@ -457,6 +463,8 @@ TEST(string, StrCursorStepNextUtf32AllCombining)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf32(allcombining, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf32_complex
  * \{ */
@@ -480,6 +488,8 @@ TEST(string, StrCursorStepNextUtf32Complex)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf32(complex, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf32_invalid
  * \{ */
@@ -509,6 +519,8 @@ TEST(string, StrCursorStepNextUtf32Invalid)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf32(invalid, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf32_empty
  * \{ */
@@ -521,6 +533,8 @@ TEST(string, StrCursorStepPrevUtf32Empty)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(emtpy, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf32_single
  * \{ */
@@ -534,6 +548,8 @@ TEST(string, StrCursorStepPrevUtf32Single)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(single, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf32_simple
  * \{ */
@@ -549,6 +565,8 @@ TEST(string, StrCursorStepPrevUtf32Simple)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(simple, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf32_allcombining
  * \{ */
@@ -567,6 +585,8 @@ TEST(string, StrCursorStepPrevUtf32AllCombining)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(allcombining, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf32_complex
  * \{ */
@@ -590,6 +610,8 @@ TEST(string, StrCursorStepPrevUtf32Complex)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(complex, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf32_invalid
  * \{ */
@@ -619,6 +641,8 @@ TEST(string, StrCursorStepPrevUtf32Invalid)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf8_empty
  * \{ */
@@ -632,6 +656,8 @@ TEST(string, StrCursorStepNextUtf8Empty)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf8(empty, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf8_single
  * \{ */
@@ -644,6 +670,8 @@ TEST(string, StrCursorStepNextUtf8Single)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf8(single, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf8_simple
  * \{ */
@@ -660,6 +688,8 @@ TEST(string, StrCursorStepNextUtf8Simple)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf8(simple, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf8_allcombining
  * \{ */
@@ -684,6 +714,8 @@ TEST(string, StrCursorStepNextUtf8AllCombining)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf8_complex
  * \{ */
@@ -717,6 +749,8 @@ TEST(string, StrCursorStepNextUtf8AllComplex)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf8(complex, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_next_utf8_invalid
  * \{ */
@@ -746,6 +780,8 @@ TEST(string, StrCursorStepNextUtf8Invalid)
   EXPECT_FALSE(BLI_str_cursor_step_next_utf8(invalid, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf8_empty
  * \{ */
@@ -760,6 +796,8 @@ TEST(string, StrCursorStepPrevUtf8Empty)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(empty, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf8_single
  * \{ */
@@ -773,6 +811,8 @@ TEST(string, StrCursorStepPrevUtf8Single)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(single, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf8_single
  * \{ */
@@ -788,6 +828,8 @@ TEST(string, StrCursorStepPrevUtf8Simple)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(simple, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf8_allcombining
  * \{ */
@@ -812,6 +854,8 @@ TEST(string, StrCursorStepPrevUtf8AllCombining)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf8_complex
  * \{ */
@@ -845,6 +889,8 @@ TEST(string, StrCursorStepPrevUtf8Complex)
   EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(complex, len, &pos));
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Test #BLI_str_cursor_step_prev_utf8_invalid
  * \{ */

source/blender/blenloader/intern/readfile.cc

@@ -202,6 +202,10 @@ struct BHeadN {
  */
 #define BHEAD_USE_READ_ON_DEMAND(bhead) ((bhead)->code == BLO_CODE_DATA)
 
+/* -------------------------------------------------------------------- */
+/** \name Blend Loader Reporting Wrapper
+ * \{ */
+
 void BLO_reportf_wrap(BlendFileReadReport *reports, eReportType type, const char *format, ...)
 {
   char fixed_buf[1024]; /* should be long enough */
@@ -227,6 +231,8 @@ static const char *library_parent_filepath(Library *lib)
   return lib->parent ? lib->parent->filepath_abs : "<direct>";
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name OldNewMap API
  * \{ */
@@ -1307,6 +1313,10 @@ void blo_filedata_free(FileData *fd)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
+/** \name Read Thumbnail from Blend File
+ * \{ */
+
 BlendThumbnail *BLO_thumbnail_from_file(const char *filepath)
 {
   FileData *fd;

source/blender/draw/intern/draw_cache_impl_pointcloud.cc

@@ -32,8 +32,6 @@
 
 using namespace blender;
 
-/** \} */
-
 /* -------------------------------------------------------------------- */
 /** \name GPUBatch cache management
  * \{ */

source/blender/draw/intern/draw_debug.cc

@@ -589,8 +589,14 @@ void DebugDraw::display_to_view()
   GPU_debug_group_end();
 }
 
+/** \} */
+
 }  // namespace blender::draw
 
+/* -------------------------------------------------------------------- */
+/** \name DebugDraw Access
+ * \{ */
+
 blender::draw::DebugDraw *DRW_debug_get()
 {
   if (!GPU_shader_storage_buffer_objects_support()) {

source/blender/editors/gizmo_library/gizmo_library_utils.c

@@ -283,3 +283,5 @@ wmGizmo *gizmo_find_from_properties(const struct IDProperty *properties,
   }
   return NULL;
 }
+
+/** \} */

source/blender/editors/object/object_relations.c

@@ -2955,8 +2955,6 @@ static int drop_geometry_nodes_invoke(bContext *C, wmOperator *op, const wmEvent
   return OPERATOR_FINISHED;
 }
 
-/** \} */
-
 void OBJECT_OT_drop_geometry_nodes(wmOperatorType *ot)
 {
   ot->name = "Drop Geometry Node Group on Object";

source/blender/editors/space_sequencer/sequencer_gizmo_retime.cc

@@ -104,5 +104,3 @@ void SEQUENCER_GGT_gizmo_retime(wmGizmoGroupType *gzgt)
   gzgt->poll = gizmogroup_retime_poll;
   gzgt->setup = gizmogroup_retime_setup;
 }
-
-/** \} */

source/blender/editors/transform/transform_gizmo.h

@@ -11,8 +11,6 @@
 extern "C" {
 #endif
 
-/** \} */
-
 /* -------------------------------------------------------------------- */
 /** \name Types/
  * \{ */

source/blender/editors/uvedit/uvedit_path.c

@@ -239,6 +239,8 @@ static int mouse_mesh_uv_shortest_path_vert(Scene *scene,
   return flush;
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name UV Edge Path
  * \{ */

source/blender/gpu/GPU_framebuffer.h

@@ -140,7 +140,8 @@ typedef struct GPULoadStore {
     GPU_LOADACTION_DONT_CARE, GPU_STOREACTION_DONT_CARE \
   }
 
-/* Load store config array (load_store_actions) matches attachment structure of
+/**
+ * Load store config array (load_store_actions) matches attachment structure of
  * GPU_framebuffer_config_array. This allows us to explicitly specify whether attachment data needs
  * to be loaded and stored on a per-attachment basis. This enables a number of bandwidth
  * optimizations:
@@ -157,7 +158,7 @@ typedef struct GPULoadStore {
  *         {GPU_LOADACTION_DONT_CARE, GPU_STOREACTION_STORE}, // Color attachment 1
  *         {GPU_LOADACTION_DONT_CARE, GPU_STOREACTION_STORE} // Color attachment 2
  * })
- * \encode
+ * \endcode
  */
 void GPU_framebuffer_bind_loadstore(GPUFrameBuffer *framebuffer,
                                     const GPULoadStore *load_store_actions,
@@ -185,7 +186,7 @@ void GPU_framebuffer_bind_loadstore(GPUFrameBuffer *framebuffer,
  *         GPU_ATTACHMENT_TEXTURE_CUBEFACE(tex2, 0),
  *         GPU_ATTACHMENT_TEXTURE_LAYER_MIP(tex2, 0, 0)
  * })
- * \encode
+ * \endcode
  *
  * \note Unspecified attachments (i.e: those beyond the last
  * GPU_ATTACHMENT_* in GPU_framebuffer_ensure_config list) are left unchanged.

source/blender/gpu/intern/gpu_shader.cc

@@ -500,6 +500,8 @@ const char *GPU_shader_get_name(GPUShader *shader)
   return unwrap(shader)->name_get();
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Shader cache warming
  * \{ */
@@ -736,6 +738,8 @@ void GPU_shader_uniform_4fv_array(GPUShader *sh, const char *name, int len, cons
 
 /** \} */
 
+namespace blender::gpu {
+
 /* -------------------------------------------------------------------- */
 /** \name sRGB Rendering Workaround
  *
@@ -747,8 +751,6 @@ void GPU_shader_uniform_4fv_array(GPUShader *sh, const char *name, int len, cons
  * frame-buffer color-space.
  * \{ */
 
-namespace blender::gpu {
-
 static int g_shader_builtin_srgb_transform = 0;
 static bool g_shader_builtin_srgb_is_dirty = false;
 
@@ -774,6 +776,6 @@ void Shader::set_framebuffer_srgb_target(int use_srgb_to_linear)
   }
 }
 
-}  // namespace blender::gpu
-
 /** \} */
+
+}  // namespace blender::gpu

source/blender/gpu/metal/mtl_memory.mm

@@ -14,7 +14,8 @@ using namespace blender::gpu;
 namespace blender::gpu {
 
 /* -------------------------------------------------------------------- */
-/** \name Memory Management - MTLBufferPool and MTLSafeFreeList implementations. */
+/** \name Memory Management - MTLBufferPool and MTLSafeFreeList implementations
+ * \{ */
 
 void MTLBufferPool::init(id<MTLDevice> mtl_device)
 {

source/blender/makesdna/DNA_scene_types.h

@@ -177,6 +177,8 @@ typedef struct AudioData {
   char _pad2[4];
 } AudioData;
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Render Layers
  * \{ */

source/blender/windowmanager/intern/wm_window.c

@@ -150,7 +150,7 @@ enum ModSide {
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Window Open & Close
+/** \name Window Open
  * \{ */
 
 static void wm_window_set_drawable(wmWindowManager *wm, wmWindow *win, bool activate);
@@ -359,7 +359,7 @@ wmWindow *wm_window_copy_test(bContext *C,
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Quit Confirmation Dialog
+/** \name Window Quit Confirmation Dialog
  * \{ */
 
 static void wm_save_file_on_quit_dialog_callback(bContext *C, void *UNUSED(user_data))
@@ -405,6 +405,10 @@ void wm_quit_with_optional_confirmation_prompt(bContext *C, wmWindow *win)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
+/** \name Window Close
+ * \{ */
+
 void wm_window_close(bContext *C, wmWindowManager *wm, wmWindow *win)
 {
   wmWindow *win_other;
@@ -436,6 +440,7 @@ void wm_window_close(bContext *C, wmWindowManager *wm, wmWindow *win)
 
   CTX_wm_window_set(C, win); /* needed by handlers */
   WM_event_remove_handlers(C, &win->handlers);
+
   WM_event_remove_handlers(C, &win->modalhandlers);
 
   /* for regular use this will _never_ be NULL,
@@ -1645,6 +1650,8 @@ void wm_window_process_events(const bContext *C)
   }
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Ghost Init/Exit
  * \{ */