Blender V5.3
sculpt_mask_init.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10#include "BLI_hash_c.hh"
11#include "BLI_time.hh"
12
13#include "DNA_object_types.h"
14
15#include "BKE_ccg.hh"
16#include "BKE_context.hh"
17#include "BKE_layer.hh"
18#include "BKE_mesh.hh"
19#include "BKE_multires.hh"
20#include "BKE_object_types.hh"
21#include "BKE_paint.hh"
22#include "BKE_paint_bvh.hh"
23#include "BKE_subdiv_ccg.hh"
24
25#include "WM_api.hh"
26#include "WM_types.hh"
27
28#include "RNA_access.hh"
29#include "RNA_define.hh"
30
31#include "../paint_intern.hh"
32#include "paint_mask.hh"
33#include "sculpt_face_set.hh"
34#include "sculpt_hide.hh"
35#include "sculpt_intern.hh"
36#include "sculpt_islands.hh"
37#include "sculpt_undo.hh"
38
39#include "bmesh.hh"
40
42
43enum class InitMode {
44 Random,
45 FaceSet,
47};
48
49void write_mask_mesh(const Depsgraph &depsgraph,
50 Object &object,
51 const IndexMask &node_mask,
53{
54 Mesh &mesh = *id_cast<Mesh *>(object.data);
55 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
56 const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
57
58 undo::push_nodes(depsgraph, object, node_mask, undo::Type::Mask);
59
61 ".sculpt_mask", bke::AttrDomain::Point);
62 if (!mask) {
63 return;
64 }
67 node_mask.foreach_index(
68 [&](const int i) {
70 write_fn(mask.span, hide::node_visible_verts(nodes[i], hide_vert, index_data));
72 },
74 pbvh.tag_masks_changed(node_mask);
75 mask.finish();
76}
77
78static void init_mask_grids(
79 Main &bmain,
80 Scene &scene,
81 Depsgraph &depsgraph,
82 Object &object,
83 const IndexMask &node_mask,
84 FunctionRef<void(const BitGroupVector<> &, int, MutableSpan<float>)> write_fn)
85{
87 BKE_sculpt_mask_layers_ensure(&depsgraph, &bmain, &object, mmd);
88
89 SculptSession &ss = *object.runtime->sculpt_session;
92 SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
93 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
94 MutableSpan<float> masks = subdiv_ccg.masks;
95 const BitGroupVector<> &grid_hidden = subdiv_ccg.grid_hidden;
96
97 undo::push_nodes(depsgraph, object, node_mask, undo::Type::Mask);
98
99 node_mask.foreach_index(
100 [&](const int i) {
101 for (const int grid : nodes[i].grids()) {
102 write_fn(grid_hidden, grid, masks.slice(bke::ccg::grid_range(key, grid)));
103 }
105 },
107 pbvh.tag_masks_changed(node_mask);
109}
110
112{
113 const View3D *v3d = CTX_wm_view3d(C);
114 const Base *base = CTX_data_active_base(C);
115 if (!BKE_base_is_visible(v3d, base)) {
116 return OPERATOR_CANCELLED;
117 }
118
120
121 const Scene &scene = *CTX_data_scene(C);
124 Depsgraph &depsgraph = *CTX_data_ensure_evaluated_depsgraph(C);
125
126 BKE_sculptsession_update_for_edit(&depsgraph, &ob, false);
127
129 IndexMaskMemory memory;
130 const IndexMask node_mask = bke::pbvh::all_leaf_nodes(pbvh, memory);
131 if (node_mask.is_empty()) {
132 return OPERATOR_CANCELLED;
133 }
134
135 undo::push_begin(scene, ob, op);
136
137 const InitMode mode = InitMode(RNA_enum_get(op->ptr, "mode"));
138 const int seed = BLI_time_now_seconds();
139
140 switch (pbvh.type()) {
142 switch (mode) {
143 case InitMode::Random:
144 write_mask_mesh(depsgraph, ob, node_mask, [&](MutableSpan<float> mask, Span<int> verts) {
145 for (const int vert : verts) {
146 mask[vert] = BLI_hash_int_01(vert + seed);
147 }
148 });
149 break;
150 case InitMode::FaceSet: {
151 const Mesh &mesh = *id_cast<const Mesh *>(ob.data);
152 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
153 const bke::AttributeAccessor attributes = mesh.attributes();
154 const VArraySpan face_sets = *attributes.lookup_or_default<int>(
155 ".sculpt_face_set", bke::AttrDomain::Face, 1);
156
157 write_mask_mesh(depsgraph, ob, node_mask, [&](MutableSpan<float> mask, Span<int> verts) {
158 for (const int vert : verts) {
160 vert_to_face_map, face_sets, vert);
161 mask[vert] = BLI_hash_int_01(face_set + seed);
162 }
163 });
164 break;
165 }
166 case InitMode::Island:
168 write_mask_mesh(depsgraph, ob, node_mask, [&](MutableSpan<float> mask, Span<int> verts) {
169 for (const int vert : verts) {
170 const int island = islands::vert_id_get(ss, vert);
171 mask[vert] = BLI_hash_int_01(island + seed);
172 }
173 });
174 break;
175 }
176 break;
177 }
179 Main &bmain = *CTX_data_main(C);
180 Scene &scene = *CTX_data_scene(C);
181 const SubdivCCG &subdiv_ccg = *ss.subdiv_ccg;
182 const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
183 switch (mode) {
184 case InitMode::Random: {
185 init_mask_grids(bmain,
186 scene,
187 depsgraph,
188 ob,
189 node_mask,
190 [&](const BitGroupVector<> &grid_hidden,
191 const int grid_index,
192 MutableSpan<float> grid_masks) {
193 const int verts_start = grid_index * key.grid_area;
195 key, grid_hidden, grid_index, [&](const int i) {
196 grid_masks[i] = BLI_hash_int_01(verts_start + i + seed);
197 });
198 });
199 break;
200 }
201 case InitMode::FaceSet: {
202 const Mesh &mesh = *id_cast<const Mesh *>(ob.data);
203 const bke::AttributeAccessor attributes = mesh.attributes();
204 const VArraySpan face_sets = *attributes.lookup_or_default<int>(
205 ".sculpt_face_set", bke::AttrDomain::Face, 1);
206 const Span<int> grid_to_face = subdiv_ccg.grid_to_face_map;
208 bmain,
209 scene,
210 depsgraph,
211 ob,
212 node_mask,
213 [&](const BitGroupVector<> &grid_hidden,
214 const int grid_index,
215 MutableSpan<float> grid_masks) {
216 const int face_set = face_sets[grid_to_face[grid_index]];
217 const float value = BLI_hash_int_01(face_set + seed);
219 key, grid_hidden, grid_index, [&](const int i) { grid_masks[i] = value; });
220 });
221 break;
222 }
223 case InitMode::Island: {
225 init_mask_grids(bmain,
226 scene,
227 depsgraph,
228 ob,
229 node_mask,
230 [&](const BitGroupVector<> &grid_hidden,
231 const int grid_index,
232 MutableSpan<float> grid_masks) {
233 const int verts_start = grid_index * key.grid_area;
235 key, grid_hidden, grid_index, [&](const int i) {
236 const int island = islands::vert_id_get(ss, verts_start + i);
237 grid_masks[i] = BLI_hash_int_01(island + seed);
238 });
239 });
240 break;
241 }
242 }
243 break;
244 }
247 const int offset = CustomData_get_offset_named(&ss.bm->vdata, CD_PROP_FLOAT, ".sculpt_mask");
248 undo::push_nodes(depsgraph, ob, node_mask, undo::Type::Mask);
249 node_mask.foreach_index(
250 [&](const int i) {
253 continue;
254 }
255 switch (mode) {
256 case InitMode::Random:
258 vert, offset, BLI_hash_int_01(BM_elem_index_get(vert) + seed));
259 break;
260 case InitMode::FaceSet: {
261 BM_ELEM_CD_SET_FLOAT(vert, offset, 0.0f);
262 break;
263 }
264 case InitMode::Island:
266 vert,
267 offset,
269 break;
270 }
271 }
273 },
275 pbvh.tag_masks_changed(node_mask);
276 break;
277 }
278 }
279
280 undo::push_end(ob);
281
283 return OPERATOR_FINISHED;
284}
285
287{
288 ot->name = "Init Mask";
289 ot->description = "Creates a new mask for the entire mesh";
290 ot->idname = "SCULPT_OT_mask_init";
291
294
296
297 static EnumPropertyItem modes[] = {
298 {int(InitMode::Random), "RANDOM_PER_VERTEX", 0, "Random per Vertex", ""},
299 {int(InitMode::FaceSet), "RANDOM_PER_FACE_SET", 0, "Random per Face Set", ""},
300 {int(InitMode::Island), "RANDOM_PER_LOOSE_PART", 0, "Random per Loose Part", ""},
301 {0, nullptr, 0, nullptr, nullptr},
302 };
303 RNA_def_enum(ot->srna, "mode", modes, int(InitMode::Random), "Mode", "");
304}
305
306} // namespace blender::ed::sculpt_paint::mask
A BVH for high poly meshes.
Platform independent time functions.
Object is a sort of wrapper for general info.
#define C
Definition RandGen.cpp:29
#define BM_ELEM_CD_SET_FLOAT(ele, offset, f)
#define BM_elem_index_get(ele)
#define BM_elem_flag_test(ele, hflag)
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
GAttributeReader lookup(const StringRef name) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexRange grid_range(const int grid_area, const int grid)
pbvh::Tree * pbvh_get(Object &object)
IndexMask all_leaf_nodes(const Tree &pbvh, IndexMaskMemory &memory)
Definition pbvh.cc:2522
void node_update_mask_bmesh(int mask_offset, BMeshNode &node)
Definition pbvh.cc:1404
void node_update_mask_mesh(Span< float > mask, MeshNode &node)
Definition pbvh.cc:1345
void node_update_mask_grids(const CCGKey &key, Span< float > masks, GridsNode &node)
Definition pbvh.cc:1373
int vert_face_set_max_get(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const int vert)
Definition sculpt.cc:232
Span< int > node_visible_verts(const bke::pbvh::MeshNode &node, const Span< bool > hide_vert, Vector< int, bke::pbvh::MESH_LEAF_LIMIT > &indices)
void ensure_cache(Object &object)
Definition sculpt.cc:6448
int vert_id_get(const SculptSession &ss, const int vert)
Definition sculpt.cc:6310
void write_mask_mesh(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, FunctionRef< void(MutableSpan< float >, Span< int >)> write_fn)
static void init_mask_grids(Main &bmain, Scene &scene, Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, FunctionRef< void(const BitGroupVector<> &, int, MutableSpan< float >)> write_fn)
void SCULPT_OT_mask_init(wmOperatorType *ot)
static wmOperatorStatus sculpt_mask_init_exec(bContext *C, wmOperator *op)
void push_nodes(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, const Type type)
void push_begin(const Scene &scene, Object &ob, const wmOperator *op)
bool sculpt_mode_poll(bContext *C)
Definition sculpt.cc:3800
void mask_overlay_check(bContext &C, wmOperator &op)
Definition sculpt.cc:8298
void tag_update_overlays(bContext *C)
Definition sculpt.cc:895
constexpr ParallelGrainSize grain_size(int grain_size)
int RNA_enum_get(PointerRNA *ptr, const char *name)
MultiresModifierData * BKE_sculpt_multires_active(const Scene *scene, Object *ob)
bool BKE_base_is_visible(const View3D *v3d, const Base *base)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void BKE_subdiv_ccg_average_grids(SubdivCCG &subdiv_ccg)
Base * CTX_data_active_base(const bContext *C)
BLI_INLINE float BLI_hash_int_01(unsigned int k)
Definition BLI_hash_c.hh:94
void BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph, Main *bmain, Object *ob, MultiresModifierData *mmd)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
BMesh const char void * data
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
Main * CTX_data_main(const bContext *C)
void BKE_sculptsession_update_for_edit(Depsgraph *depsgraph, Object *ob_orig, bool is_paint_tool)
void BKE_subdiv_ccg_foreach_visible_grid_vert(const CCGKey &key, const BitGroupVector<> &grid_hidden, const int grid, const Fn &fn)
double BLI_time_now_seconds()
Definition time.cc:30
Scene * CTX_data_scene(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
Object * CTX_data_active_object(const bContext *C)
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
View3D * CTX_wm_view3d(const bContext *C)
CustomData vdata
bke::ObjectRuntime * runtime
Span< int > grid_to_face_map
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165