sculpt_intern.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2006 by Nicholas Bishop. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <optional>
 
#include "BKE_paint.hh"
#include "BKE_paint_bvh.hh"
#include "BKE_subdiv_ccg.hh"
 
#include "BLI_array.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_math_quaternion_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_set.hh"
#include "BLI_span.hh"
#include "BLI_vector.hh"
 
#include "DNA_brush_enums.h"
#include "DNA_brush_types.h"
 
#include "ED_view3d.hh"
 
namespace blender::ed::sculpt_paint {
namespace auto_mask {
struct Cache;
}
namespace boundary {
struct SculptBoundary;
}
namespace cloth {
struct SimulationData;
}
namespace pose {
struct IKChain;
}
namespace undo {
struct Node;
enum class Type : int8_t;
}  // namespace undo
}  // namespace blender::ed::sculpt_paint
struct bContext;
struct BMLog;
struct Dial;
struct DistRayAABB_Precalc;
struct Image;
struct ImageUser;
struct Key;
struct KeyBlock;
struct Object;
struct PaintModeSettings;
struct ReportList;
struct wmKeyConfig;
struct wmKeyMap;
struct wmOperatorType;
 
/* -------------------------------------------------------------------- */
 
namespace blender::ed::sculpt_paint {

struct ShapeKeyData {
  MutableSpan<float3> active_key_data;
  bool basis_key_active;
  Vector<MutableSpan<float3>> dependent_keys;
 
  static std::optional<ShapeKeyData> from_object(Object &object);
};

class PositionDeformData {
 public:
  Span<float3> eval;
 
 private:
  std::optional<MutableSpan<float3>> eval_mut_;

  std::optional<Span<float3x3>> deform_imats_;

  MutableSpan<float3> orig_;
 
  std::optional<ShapeKeyData> shape_key_data_;
 
 public:
  PositionDeformData(const Depsgraph &depsgraph, Object &object_orig);
  void deform(MutableSpan<float3> translations, Span<int> verts) const;
};
 
enum class UpdateType {
  Position,
  Mask,
  Visibility,
  Color,
  Image,
  FaceSet,
};
 
}  // namespace blender::ed::sculpt_paint
 
/* Factor of brush to have rake point following behind
 * (could be configurable but this is reasonable default). */
#define SCULPT_RAKE_BRUSH_FACTOR 0.25f
 
struct SculptRakeData {
  float follow_dist = 0.0f;
  blender::float3 follow_co = blender::float3(0);
  float angle = 0.0f;
};
 
namespace blender::ed::sculpt_paint {
enum class TransformDisplacementMode {
  /* Displaces the elements from their original coordinates. */
  Original = 0,
  /* Displaces the elements incrementally from their previous position. */
  Incremental = 1,
};
}
/* Defines how transform tools are going to apply its displacement. */
 
namespace blender::ed::sculpt_paint {
 
static constexpr int plane_brush_max_rolling_average_num = 20;

struct StrokeCache {
  /* Invariants */
  float initial_radius = 0.0f;
  float3 scale = float3(0);
  struct {
    uint8_t flag = 0;
    float3 tolerance = float3(0);
    float4x4 mat = float4x4::identity();
    float4x4 mat_inv = float4x4::identity();
  } mirror_modifier_clip;
  float2 initial_mouse = float2(0);

  bool initial_direction_flipped = false;
 
  /* Variants */
  float radius = 0.0f;
  float radius_squared = 0.0f;
  float3 location = float3(0);
  float3 last_location = float3(0);
  float3 location_symm = float3(0);
  float3 last_location_symm = float3(0);
  float stroke_distance = 0.0f;

  int iteration_count = 0;
 
  /* Original pixel radius with the pressure curve applied for dyntopo detail size */
  float dyntopo_pixel_radius = 0.0f;
 
  bool is_last_valid = false;
 
  bool pen_flip = false;

  bool invert = false;
  float pressure = 0.0f;
  float hardness = 0.0f;
  float bstrength = 0.0f;
  float normal_weight = 0.0f; /* from brush (with optional override) */
  float2 tilt = float2(0);

  float2 mouse = float2(0);
  /* Position of the mouse event in screen space, not modified by the stroke type. */
  float2 mouse_event = float2(0);
 
  struct {
    Array<float3> prev_displacement;
    Array<float3> limit_surface_co;
  } displacement_smear;
 
  /* The rest is temporary storage that isn't saved as a property */
 
  /* Store initial starting points for perlin noise on the beginning of each stroke when using
   * color jitter. */
  std::optional<blender::float3> initial_hsv_jitter;
  /* Beginning of stroke may do some things special. */
  bool first_time = false;
 
  /* from ED_view3d_ob_project_mat_get(). */
  float4x4 projection_mat = float4x4::identity();
 
  /* TODO: Clean this up! */
  ViewContext *vc = nullptr;
  const Brush *brush = nullptr;
 
  float special_rotation = 0.0f;
  float3 grab_delta = float3(0);
  float3 grab_delta_symm = float3(0);
  float3 old_grab_location = float3(0);
  float3 orig_grab_location = float3(0);
 
  /* Screen-space rotation defined by mouse motion. */
  std::optional<math::Quaternion> rake_rotation;
  std::optional<math::Quaternion> rake_rotation_symm;
  SculptRakeData rake_data;
 
  /* The face set being painted. */
  int paint_face_set = SCULPT_FACE_SET_NONE;

  int symmetry = 0;
  /* The symmetry pass we are currently on between 0 and 7. */
  ePaintSymmetryFlags mirror_symmetry_pass = ePaintSymmetryFlags(0);
  float3 view_normal = float3(0);
  float3 view_normal_symm = float3(0);

  float3 sculpt_normal = float3(0);
  float3 sculpt_normal_symm = float3(0);

  float4x4 brush_local_mat = float4x4::identity();
  float4x4 brush_local_mat_inv = float4x4::identity();
 
  /* used to shift the plane around when doing tiled strokes */
  float3 plane_offset = float3(0);
  int tile_pass = 0;
 
  float3 last_center = float3(0);
  int radial_symmetry_pass = 0;
  float4x4 symm_rot_mat = float4x4::identity();
  float4x4 symm_rot_mat_inv = float4x4::identity();

  bool accum = false;
 
  /* Paint Brush. */
  struct {
    float flow = 0.0f;
 
    float4 wet_mix_prev_color = float4(0);
    float wet_mix = 0.0f;
    float wet_persistence = 0.0f;
 
    std::optional<float> density_seed;
    float density = 0.0f;

    Array<float4> mix_colors;
    Array<float4> prev_colors;
  } paint_brush;
 
  /* Pose brush */
  std::unique_ptr<pose::IKChain> pose_ik_chain;
 
  /* Enhance Details. */
  Array<float3> detail_directions;
 
  /* Clay Thumb brush */
  struct {
    /* Angle of the front tilting plane of the brush to simulate clay accumulation. */
    float front_angle = 0.0f;
    /* Stores the last 10 pressure samples to get a stabilized strength and radius variation. */
    std::array<float, 10> pressure_stabilizer;
    int stabilizer_index = 0;
 
  } clay_thumb_brush;
 
  /* Plane Brush */
  struct {
    std::optional<float3> last_normal;
    std::optional<float3> last_center;
    Array<float3> normals;
    Array<float3> centers;
    int normal_index = 0;
    int center_index = 0;

    bool first_time = false;
  } plane_brush;
 
  /* Cloth brush */
  std::unique_ptr<cloth::SimulationData> cloth_sim;
  float3 initial_location_symm = float3(0);
  float3 initial_location = float3(0);
  float3 initial_normal_symm = float3(0);
  float3 initial_normal = float3(0);
 
  /* Boundary brush */
  std::array<std::unique_ptr<boundary::SculptBoundary>, PAINT_SYMM_AREAS> boundaries;
 
  /* Surface Smooth Brush */
  /* Stores the displacement produced by the laplacian step of HC smooth. */
  Array<float3> surface_smooth_laplacian_disp;
 
  /* Layer brush */
  Array<float> layer_displacement_factor;
 
  /* Amount to rotate the vertices when using rotate brush. */
  float vertex_rotation = 0.0f;
  Dial *dial = nullptr;
 
  Brush *saved_active_brush = nullptr;
  char saved_mask_brush_tool = 0;
  /* Smooth tool copies the size of the current tool. */
  int saved_smooth_size = 0;

  bool alt_smooth = false;
 
  float plane_trim_squared = 0.0f;
 
  bool supports_gravity = false;
  float3 gravity_direction = float3(0);
  float3 gravity_direction_symm = float3(0);
 
  std::unique_ptr<auto_mask::Cache> automasking;
 
  float4x4 stroke_local_mat = float4x4::identity();
  float multiplane_scrape_angle = 0.0f;
 
  StrokeCache();
  ~StrokeCache();
};
 
}  // namespace blender::ed::sculpt_paint

 
/* -------------------------------------------------------------------- */
 
bool SCULPT_mode_poll(bContext *C);
bool SCULPT_mode_poll_view3d(bContext *C);
bool SCULPT_poll(bContext *C);

bool SCULPT_brush_cursor_poll(bContext *C);
 
namespace blender::ed::sculpt_paint {
bool color_supported_check(const Scene &scene, Object &object, ReportList *reports);
}  // namespace blender::ed::sculpt_paint

 
/* -------------------------------------------------------------------- */
 
namespace blender::ed::sculpt_paint {

void flush_update_step(const bContext *C, UpdateType update_type);
void flush_update_done(const bContext *C, Object &ob, UpdateType update_type);
 
}  // namespace blender::ed::sculpt_paint

void SCULPT_tag_update_overlays(bContext *C);
 
/* -------------------------------------------------------------------- */
 
namespace blender::ed::sculpt_paint {
bool stroke_get_location_bvh(bContext *C, float out[3], const float mval[2], bool force_original);
 
struct CursorGeometryInfo {
  float3 location;
  float3 normal;
  float3 active_vertex_co;
};

bool cursor_geometry_info_update(bContext *C,
                                 CursorGeometryInfo *out,
                                 const float2 &mval,
                                 bool use_sampled_normal);
 
void geometry_preview_lines_update(Depsgraph &depsgraph,
                                   Object &object,
                                   SculptSession &ss,
                                   float radius);
 
}  // namespace blender::ed::sculpt_paint
 
void SCULPT_stroke_modifiers_check(const bContext *C, Object &ob, const Brush &brush);
namespace blender::ed::sculpt_paint {
float raycast_init(ViewContext *vc,
                   const float2 &mval,
                   float3 &ray_start,
                   float3 &ray_end,
                   float3 &ray_normal,
                   bool original);
}
 
/* Symmetry */
ePaintSymmetryFlags SCULPT_mesh_symmetry_xyz_get(const Object &object);

bool SCULPT_stroke_is_main_symmetry_pass(const blender::ed::sculpt_paint::StrokeCache &cache);
bool SCULPT_stroke_is_first_brush_step(const blender::ed::sculpt_paint::StrokeCache &cache);
bool SCULPT_stroke_is_first_brush_step_of_symmetry_pass(
    const blender::ed::sculpt_paint::StrokeCache &cache);

void sculpt_project_v3_normal_align(const SculptSession &ss,
                                    float normal_weight,
                                    float grab_delta[3]);

 
/* -------------------------------------------------------------------- */
 
namespace blender::ed::sculpt_paint {
void vert_random_access_ensure(Object &object);
}  // namespace blender::ed::sculpt_paint
 
int SCULPT_vertex_count_get(const Object &object);
 
namespace blender::ed::sculpt_paint {
bool vertex_is_occluded(const Depsgraph &depsgraph,
                        const Object &object,
                        const float3 &position,
                        bool original);

Span<float3> vert_positions_for_grab_active_get(const Depsgraph &depsgraph, const Object &object);
 
using BMeshNeighborVerts = Vector<BMVert *, 64>;
Span<BMVert *> vert_neighbors_get_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors);
Span<BMVert *> vert_neighbors_get_interior_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors);
 
Span<int> vert_neighbors_get_mesh(OffsetIndices<int> faces,
                                  Span<int> corner_verts,
                                  GroupedSpan<int> vert_to_face,
                                  Span<bool> hide_poly,
                                  int vert,
                                  Vector<int> &r_neighbors);
}  // namespace blender::ed::sculpt_paint
 
/* Fake Neighbors */
 
#define FAKE_NEIGHBOR_NONE -1

blender::Span<int> SCULPT_fake_neighbors_ensure(const Depsgraph &depsgraph,
                                                Object &ob,
                                                float max_dist);
void SCULPT_fake_neighbors_free(Object &ob);

 
/* -------------------------------------------------------------------- */
 
namespace blender::ed::sculpt_paint {
 
float brush_plane_offset_get(const Brush &brush, const SculptSession &ss);

void calc_brush_plane(const Depsgraph &depsgraph,
                      const Brush &brush,
                      Object &ob,
                      const IndexMask &node_mask,
                      float3 &r_area_no,
                      float3 &r_area_co);
 
std::optional<float3> calc_area_normal(const Depsgraph &depsgraph,
                                       const Brush &brush,
                                       const Object &ob,
                                       const IndexMask &node_mask);

void calc_area_normal_and_center(const Depsgraph &depsgraph,
                                 const Brush &brush,
                                 const Object &ob,
                                 const IndexMask &node_mask,
                                 float r_area_no[3],
                                 float r_area_co[3]);
void calc_area_center(const Depsgraph &depsgraph,
                      const Brush &brush,
                      const Object &ob,
                      const IndexMask &node_mask,
                      float r_area_co[3]);
 
std::optional<int> nearest_vert_calc_mesh(const bke::pbvh::Tree &pbvh,
                                          Span<float3> vert_positions,
                                          Span<bool> hide_vert,
                                          const float3 &location,
                                          float max_distance,
                                          bool use_original);
std::optional<SubdivCCGCoord> nearest_vert_calc_grids(const bke::pbvh::Tree &pbvh,
                                                      const SubdivCCG &subdiv_ccg,
                                                      const float3 &location,
                                                      float max_distance,
                                                      bool use_original);
std::optional<BMVert *> nearest_vert_calc_bmesh(const bke::pbvh::Tree &pbvh,
                                                const float3 &location,
                                                float max_distance,
                                                bool use_original);
}  // namespace blender::ed::sculpt_paint
 
ePaintSymmetryAreas SCULPT_get_vertex_symm_area(const float co[3]);
bool SCULPT_check_vertex_pivot_symmetry(const float vco[3], const float pco[3], char symm);
bool SCULPT_is_vertex_inside_brush_radius_symm(const float vertex[3],
                                               const float br_co[3],
                                               float radius,
                                               char symm);
blender::float3 SCULPT_flip_v3_by_symm_area(const blender::float3 &vector,
                                            ePaintSymmetryFlags symm,
                                            ePaintSymmetryAreas symmarea,
                                            const blender::float3 &pivot);
void SCULPT_flip_quat_by_symm_area(float quat[4],
                                   ePaintSymmetryFlags symm,
                                   ePaintSymmetryAreas symmarea,
                                   const float pivot[3]);
 
namespace blender::ed::sculpt_paint {

Vector<int> find_symm_verts_mesh(const Depsgraph &depsgraph,
                                 const Object &object,
                                 int original_vert,
                                 float max_distance = std::numeric_limits<float>::max());
Vector<int> find_symm_verts_grids(const Object &object,
                                  int original_vert,
                                  float max_distance = std::numeric_limits<float>::max());
Vector<int> find_symm_verts_bmesh(const Object &object,
                                  int original_vert,
                                  float max_distance = std::numeric_limits<float>::max());
Vector<int> find_symm_verts(const Depsgraph &depsgraph,
                            const Object &object,
                            int original_vert,
                            float max_distance = std::numeric_limits<float>::max());
 
bool node_fully_masked_or_hidden(const bke::pbvh::Node &node);
bool node_in_sphere(const bke::pbvh::Node &node,
                    const float3 &location,
                    float radius_sq,
                    bool original);
bool node_in_cylinder(const DistRayAABB_Precalc &ray_dist_precalc,
                      const bke::pbvh::Node &node,
                      float radius_sq,
                      bool original);
IndexMask gather_nodes(const bke::pbvh::Tree &pbvh,
                       eBrushFalloffShape falloff_shape,
                       bool use_original,
                       const float3 &location,
                       float radius_sq,
                       const std::optional<float3> &ray_direction,
                       IndexMaskMemory &memory);
 
}  // namespace blender::ed::sculpt_paint
 
const float *SCULPT_brush_frontface_normal_from_falloff_shape(const SculptSession &ss,
                                                              char falloff_shape);
void SCULPT_cube_tip_init(const Sculpt &sd, const Object &ob, const Brush &brush, float mat[4][4]);

void sculpt_apply_texture(const SculptSession &ss,
                          const Brush &brush,
                          const float brush_point[3],
                          int thread_id,
                          float *r_value,
                          float r_rgba[4]);

void SCULPT_calc_vertex_displacement(const SculptSession &ss,
                                     const Brush &brush,
                                     float translation[3]);
 
namespace blender::ed::sculpt_paint {
float3 tilt_apply_to_normal(const Object &object,
                            const float4x4 &view_inverse,
                            const float3 &normal,
                            const float2 &tilt,
                            float tilt_strength);
float3 tilt_apply_to_normal(const float3 &normal, const StrokeCache &cache, float tilt_strength);

float3 tilt_effective_normal_get(const SculptSession &ss, const Brush &brush);
}  // namespace blender::ed::sculpt_paint
 
namespace blender::ed::sculpt_paint {
void calc_smooth_translations(const Depsgraph &depsgraph,
                              const Object &object,
                              const IndexMask &node_mask,
                              MutableSpan<float3> translations);
 
}  // namespace blender::ed::sculpt_paint

void SCULPT_cache_calc_brushdata_symm(blender::ed::sculpt_paint::StrokeCache &cache,
                                      ePaintSymmetryFlags symm,
                                      char axis,
                                      float angle);
 
namespace blender::ed::sculpt_paint {
 
struct OrigPositionData {
  Span<float3> positions;
  Span<float3> normals;
};

std::optional<OrigPositionData> orig_position_data_lookup_mesh_all_verts(
    const Object &object, const bke::pbvh::MeshNode &node);
std::optional<OrigPositionData> orig_position_data_lookup_mesh(const Object &object,
                                                               const bke::pbvh::MeshNode &node);
inline OrigPositionData orig_position_data_get_mesh(const Object &object,
                                                    const bke::pbvh::MeshNode &node)
{
  const std::optional<OrigPositionData> result = orig_position_data_lookup_mesh(object, node);
  BLI_assert(result.has_value());
  return *result;
}
 
std::optional<OrigPositionData> orig_position_data_lookup_grids(const Object &object,
                                                                const bke::pbvh::GridsNode &node);
inline OrigPositionData orig_position_data_get_grids(const Object &object,
                                                     const bke::pbvh::GridsNode &node)
{
  const std::optional<OrigPositionData> result = orig_position_data_lookup_grids(object, node);
  BLI_assert(result.has_value());
  return *result;
}
 
void orig_position_data_gather_bmesh(const BMLog &bm_log,
                                     const Set<BMVert *, 0> &verts,
                                     MutableSpan<float3> positions,
                                     MutableSpan<float3> normals);
 
std::optional<Span<float4>> orig_color_data_lookup_mesh(const Object &object,
                                                        const bke::pbvh::MeshNode &node);
inline Span<float4> orig_color_data_get_mesh(const Object &object, const bke::pbvh::MeshNode &node)
{
  return *orig_color_data_lookup_mesh(object, node);
}
 
std::optional<Span<int>> orig_face_set_data_lookup_mesh(const Object &object,
                                                        const bke::pbvh::MeshNode &node);
 
std::optional<Span<int>> orig_face_set_data_lookup_grids(const Object &object,
                                                         const bke::pbvh::GridsNode &node);
 
std::optional<Span<float>> orig_mask_data_lookup_mesh(const Object &object,
                                                      const bke::pbvh::MeshNode &node);
 
std::optional<Span<float>> orig_mask_data_lookup_grids(const Object &object,
                                                       const bke::pbvh::GridsNode &node);
 
inline bool brush_type_is_paint(const int tool)
{
  return ELEM(tool, SCULPT_BRUSH_TYPE_PAINT, SCULPT_BRUSH_TYPE_SMEAR);
}
 
inline bool brush_type_is_mask(const int tool)
{
  return ELEM(tool, SCULPT_BRUSH_TYPE_MASK);
}
 
BLI_INLINE bool brush_type_is_attribute_only(const int tool)
{
  return brush_type_is_paint(tool) || brush_type_is_mask(tool) ||
         ELEM(tool, SCULPT_BRUSH_TYPE_DRAW_FACE_SETS);
}
 
inline bool brush_uses_vector_displacement(const Brush &brush)
{
  return brush.sculpt_brush_type == SCULPT_BRUSH_TYPE_DRAW &&
         brush.flag2 & BRUSH_USE_COLOR_AS_DISPLACEMENT &&
         brush.mtex.brush_map_mode == MTEX_MAP_MODE_AREA;
}
 
void ensure_valid_pivot(const Object &ob, Scene &scene);

float object_space_radius_get(const ViewContext &vc,
                              const Scene &scene,
                              const Brush &brush,
                              const float3 &location,
                              float scale_factor = 1.0);
}  // namespace blender::ed::sculpt_paint

 
/* -------------------------------------------------------------------- */

bool SCULPT_paint_image_canvas_get(PaintModeSettings &paint_mode_settings,
                                   Object &ob,
                                   Image **r_image,
                                   ImageUser **r_image_user) ATTR_NONNULL();
void SCULPT_do_paint_brush_image(const Scene &scene,
                                 const Depsgraph &depsgraph,
                                 PaintModeSettings &paint_mode_settings,
                                 const Sculpt &sd,
                                 Object &ob,
                                 const blender::IndexMask &node_mask);
bool SCULPT_use_image_paint_brush(PaintModeSettings &settings, Object &ob);

 
/* -------------------------------------------------------------------- */
 
namespace blender::ed::sculpt_paint {
 
void SCULPT_OT_brush_stroke(wmOperatorType *ot);
 
}
 
namespace blender::ed::sculpt_paint::expand {
 
void SCULPT_OT_expand(wmOperatorType *ot);
void modal_keymap(wmKeyConfig *keyconf);
 
}  // namespace blender::ed::sculpt_paint::expand
 
namespace blender::ed::sculpt_paint::project {
void SCULPT_OT_project_line_gesture(wmOperatorType *ot);
}
 
namespace blender::ed::sculpt_paint::trim {
void SCULPT_OT_trim_lasso_gesture(wmOperatorType *ot);
void SCULPT_OT_trim_box_gesture(wmOperatorType *ot);
void SCULPT_OT_trim_line_gesture(wmOperatorType *ot);
void SCULPT_OT_trim_polyline_gesture(wmOperatorType *ot);
}  // namespace blender::ed::sculpt_paint::trim
 
namespace blender::ed::sculpt_paint::face_set {
 
void SCULPT_OT_face_sets_randomize_colors(wmOperatorType *ot);
void SCULPT_OT_face_set_change_visibility(wmOperatorType *ot);
void SCULPT_OT_face_sets_init(wmOperatorType *ot);
void SCULPT_OT_face_sets_create(wmOperatorType *ot);
void SCULPT_OT_face_sets_edit(wmOperatorType *ot);
 
void SCULPT_OT_face_set_lasso_gesture(wmOperatorType *ot);
void SCULPT_OT_face_set_box_gesture(wmOperatorType *ot);
void SCULPT_OT_face_set_line_gesture(wmOperatorType *ot);
void SCULPT_OT_face_set_polyline_gesture(wmOperatorType *ot);
 
}  // namespace blender::ed::sculpt_paint::face_set
 
namespace blender::ed::sculpt_paint {
 
void SCULPT_OT_set_pivot_position(wmOperatorType *ot);
 
}
 
namespace blender::ed::sculpt_paint::filter {
 
void SCULPT_OT_mesh_filter(wmOperatorType *ot);
wmKeyMap *modal_keymap(wmKeyConfig *keyconf);
 
}  // namespace blender::ed::sculpt_paint::filter
 
namespace blender::ed::sculpt_paint::cloth {
void SCULPT_OT_cloth_filter(wmOperatorType *ot);
}
 
namespace blender::ed::sculpt_paint::color {
void SCULPT_OT_color_filter(wmOperatorType *ot);
}
 
namespace blender::ed::sculpt_paint::mask {
 
void SCULPT_OT_mask_filter(wmOperatorType *ot);
void SCULPT_OT_mask_init(wmOperatorType *ot);
 
}  // namespace blender::ed::sculpt_paint::mask
 
namespace blender::ed::sculpt_paint::dyntopo {
 
void SCULPT_OT_detail_flood_fill(wmOperatorType *ot);
void SCULPT_OT_sample_detail_size(wmOperatorType *ot);
void SCULPT_OT_dyntopo_detail_size_edit(wmOperatorType *ot);
void SCULPT_OT_dynamic_topology_toggle(wmOperatorType *ot);
 
}  // namespace blender::ed::sculpt_paint::dyntopo