sculpt_automask.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2024 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <memory>
 
#include "BLI_array.hh"
#include "BLI_bit_vector.hh"
#include "BLI_offset_indices.hh"
#include "BLI_set.hh"
#include "BLI_sys_types.h"
 
#include "DNA_brush_enums.h"
 
struct BMVert;
struct Brush;
struct CurveMapping;
struct Depsgraph;
struct Object;
struct Sculpt;
struct SculptSession;
namespace blender::bke::pbvh {
struct MeshNode;
struct GridsNode;
struct BMeshNode;
}  // namespace blender::bke::pbvh
 
namespace blender::ed::sculpt_paint::auto_mask {
 
struct Settings {
  /* eAutomasking_flag. */
  int flags;
  int initial_face_set;
  int initial_island_nr;
 
  float cavity_factor;
  int cavity_blur_steps;
  CurveMapping *cavity_curve;
 
  float start_normal_limit, start_normal_falloff;
  float view_normal_limit, view_normal_falloff;
 
  bool topology_use_brush_limit;
};
 
struct Cache {
  Settings settings;
 
  Array<float> factor;
 
  enum class OcclusionValue : int8_t {
    Unknown = 0,
    Visible = 1,
    Occluded = 2,
  };
  Array<OcclusionValue> occlusion;
 
  Array<float> cavity_factor;
 
  bool can_reuse_mask;
  uchar current_stroke_id;
};
 
const Cache *active_cache_get(const SculptSession &ss);
 
std::unique_ptr<Cache> cache_init(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob);
std::unique_ptr<Cache> cache_init(const Depsgraph &depsgraph,
                                  const Sculpt &sd,
                                  const Brush *brush,
                                  Object &ob);
 
bool mode_enabled(const Sculpt &sd, const Brush *br, eAutomasking_flag mode);
bool is_enabled(const Sculpt &sd, const Object &object, const Brush *br);
 
bool needs_normal(const SculptSession &ss, const Sculpt &sd, const Brush *brush);
 
bool brush_type_can_reuse_automask(int sculpt_brush_type);
 
void calc_vert_factors(const Depsgraph &depsgraph,
                       const Object &object,
                       const Cache &cache,
                       const bke::pbvh::MeshNode &node,
                       Span<int> verts,
                       MutableSpan<float> factors);
inline void calc_vert_factors(const Depsgraph &depsgraph,
                              const Object &object,
                              const Cache *cache,
                              const bke::pbvh::MeshNode &node,
                              Span<int> verts,
                              MutableSpan<float> factors)
{
  if (cache) {
    calc_vert_factors(depsgraph, object, *cache, node, verts, factors);
  }
}
void calc_grids_factors(const Depsgraph &depsgraph,
                        const Object &object,
                        const Cache &cache,
                        const bke::pbvh::GridsNode &node,
                        Span<int> grids,
                        MutableSpan<float> factors);
inline void calc_grids_factors(const Depsgraph &depsgraph,
                               const Object &object,
                               const Cache *cache,
                               const bke::pbvh::GridsNode &node,
                               Span<int> grids,
                               MutableSpan<float> factors)
{
  if (cache) {
    calc_grids_factors(depsgraph, object, *cache, node, grids, factors);
  }
}
void calc_vert_factors(const Depsgraph &depsgraph,
                       const Object &object,
                       const Cache &cache,
                       const bke::pbvh::BMeshNode &node,
                       const Set<BMVert *, 0> &verts,
                       MutableSpan<float> factors);
inline void calc_vert_factors(const Depsgraph &depsgraph,
                              const Object &object,
                              const Cache *cache,
                              const bke::pbvh::BMeshNode &node,
                              const Set<BMVert *, 0> &verts,
                              MutableSpan<float> factors)
{
  if (cache) {
    calc_vert_factors(depsgraph, object, *cache, node, verts, factors);
  }
}
 
void calc_face_factors(const Depsgraph &depsgraph,
                       const Object &object,
                       OffsetIndices<int> faces,
                       Span<int> corner_verts,
                       const Cache &cache,
                       const bke::pbvh::MeshNode &node,
                       Span<int> face_indices,
                       MutableSpan<float> factors);
 
}  // namespace blender::ed::sculpt_paint::auto_mask