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_offset_indices.hh"
#include "BLI_set.hh"
 
#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;

  void calc_cavity_factor(const Depsgraph &depsgraph,
                          const Object &object,
                          const IndexMask &node_mask);
};

const Cache *active_cache_get(const SculptSession &ss);

std::unique_ptr<Cache> cache_init(const Depsgraph &depsgraph,
                                  const Sculpt &sd,
                                  const Brush *brush,
                                  Object &ob);

Cache &filter_cache_ensure(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob);
Cache &stroke_cache_ensure(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);

void calc_vert_factors(const Depsgraph &depsgraph,
                       const Object &object,
                       const Cache &automasking,
                       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 &automasking,
                        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 &automasking,
                       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 &automasking,
                       const bke::pbvh::MeshNode &node,
                       Span<int> face_indices,
                       MutableSpan<float> factors);
 
}  // namespace blender::ed::sculpt_paint::auto_mask