[Bf-blender-cvs] [0f2e141b62e] temp-sculpt-normals-masking: Merge branch 'master' into temp-sculpt-normals-masking
Joseph Eagar
noreply at git.blender.org
Thu Sep 22 20:29:48 CEST 2022
Commit: 0f2e141b62e3a24d1b659c48c4993835799454c3
Author: Joseph Eagar
Date: Tue Sep 20 11:49:39 2022 -0700
Branches: temp-sculpt-normals-masking
https://developer.blender.org/rB0f2e141b62e3a24d1b659c48c4993835799454c3
Merge branch 'master' into temp-sculpt-normals-masking
===================================================================
===================================================================
diff --cc source/blender/blenkernel/intern/paint.cc
index 174d70a8e4e,0181c6e7eac..2f00ce42ed9
--- a/source/blender/blenkernel/intern/paint.cc
+++ b/source/blender/blenkernel/intern/paint.cc
@@@ -2024,15 -2083,7 +2083,15 @@@ void BKE_sculpt_toolsettings_data_ensur
sd->constant_detail = 3.0f;
}
+ if (!sd->automasking_start_normal_limit) {
+ sd->automasking_start_normal_limit = 20.0f / 180.0f * M_PI;
+ sd->automasking_start_normal_falloff = 0.25f;
+
+ sd->automasking_view_normal_limit = 90.0f / 180.0f * M_PI;
+ sd->automasking_view_normal_falloff = 0.25f;
+ }
+
- /* Set sane default tiling offsets */
+ /* Set sane default tiling offsets. */
if (!sd->paint.tile_offset[0]) {
sd->paint.tile_offset[0] = 1.0f;
}
diff --cc source/blender/editors/sculpt_paint/sculpt_automasking.cc
index 36f0b4bf3c8,f4da70faad7..2707d4fd938
--- a/source/blender/editors/sculpt_paint/sculpt_automasking.cc
+++ b/source/blender/editors/sculpt_paint/sculpt_automasking.cc
@@@ -165,73 -114,9 +165,75 @@@ static bool SCULPT_automasking_needs_fa
return false;
}
+static float automasking_brush_normal_factor(AutomaskingCache *automasking,
+ SculptSession *ss,
+ PBVHVertRef vertex,
+ AutomaskingNodeData *automask_data)
+{
+ float falloff = automasking->settings.start_normal_falloff * M_PI;
+ float initial_normal[3];
+
+ if (ss->cache) {
+ copy_v3_v3(initial_normal, ss->cache->initial_normal);
+ }
+ else {
+ copy_v3_v3(initial_normal, ss->filter_cache->initial_normal);
+ }
+
+ return sculpt_automasking_normal_calc(automasking,
+ ss,
+ vertex,
+ initial_normal,
+ automasking->settings.start_normal_limit - falloff * 0.5f,
+ automasking->settings.start_normal_limit + falloff * 0.5f,
+ automask_data);
+}
+
+static float automasking_view_normal_factor(AutomaskingCache *automasking,
+ SculptSession *ss,
+ PBVHVertRef vertex,
+ AutomaskingNodeData *automask_data)
+{
+ float falloff = automasking->settings.view_normal_falloff * M_PI;
+
+ float view_normal[3];
+
+ if (ss->cache) {
+ copy_v3_v3(view_normal, ss->cache->view_normal);
+ }
+ else {
+ copy_v3_v3(view_normal, ss->filter_cache->view_normal);
+ }
+
+ return sculpt_automasking_normal_calc(automasking,
+ ss,
+ vertex,
+ view_normal,
+ automasking->settings.view_normal_limit,
+ automasking->settings.view_normal_limit + falloff,
+ automask_data);
+}
+
+static float automasking_view_occlusion_factor(AutomaskingCache *automasking,
+ SculptSession *ss,
+ PBVHVertRef vertex,
+ AutomaskingNodeData *automask_data)
+{
+ int index = BKE_pbvh_vertex_to_index(ss->pbvh, vertex);
+
- if (!automasking->occluded[index]) {
- automasking->occluded[index] = SCULPT_vertex_is_occluded(ss, vertex, true) ? 2 : 1;
++ char f = *(char *)SCULPT_vertex_attr_get(vertex, automasking->occlusion_attr);
++
++ if (!f) {
++ f = *(char *)SCULPT_vertex_attr_get(vertex, automasking->occlusion_attr) = SCULPT_vertex_is_occluded(ss, vertex, true) ? 2 : 1;
+ }
+
- return automasking->occluded[index] == 2;
++ return f == 2;
+}
+
float SCULPT_automasking_factor_get(AutomaskingCache *automasking,
SculptSession *ss,
- PBVHVertRef vert)
+ PBVHVertRef vert,
+ AutomaskingNodeData *automask_data)
{
if (!automasking) {
return 1.0f;
@@@ -240,19 -125,10 +242,17 @@@
/* If the cache is initialized with valid info, use the cache. This is used when the
* automasking information can't be computed in real time per vertex and needs to be
* initialized for the whole mesh when the stroke starts. */
- if (automasking->factor) {
- return automasking->factor[index];
+ if (ss->attrs.automasking_factor) {
+ return *(float *)SCULPT_vertex_attr_get(vert, ss->attrs.automasking_factor);
}
+ bool do_occlusion = (automasking->settings.flags &
+ (BRUSH_AUTOMASKING_VIEW_OCCLUSION | BRUSH_AUTOMASKING_VIEW_NORMAL)) ==
+ (BRUSH_AUTOMASKING_VIEW_OCCLUSION | BRUSH_AUTOMASKING_VIEW_NORMAL);
+ if (do_occlusion && automasking_view_occlusion_factor(automasking, ss, vert, automask_data)) {
+ return 0.0f;
+ }
+
if (automasking->settings.flags & BRUSH_AUTOMASKING_FACE_SETS) {
if (!SCULPT_vertex_has_face_set(ss, vert, automasking->settings.initial_face_set)) {
return 0.0f;
@@@ -470,39 -328,6 +464,42 @@@ static void SCULPT_automasking_cache_se
{
automasking->settings.flags = sculpt_automasking_mode_effective_bits(sd, brush);
automasking->settings.initial_face_set = SCULPT_active_face_set_get(ss);
+
+ automasking->settings.view_normal_limit = sd->automasking_view_normal_limit;
+ automasking->settings.view_normal_falloff = sd->automasking_view_normal_falloff;
+ automasking->settings.start_normal_limit = sd->automasking_start_normal_limit;
+ automasking->settings.start_normal_falloff = sd->automasking_start_normal_falloff;
+}
+
+void sculpt_normal_occlusion_automasking_fill(AutomaskingCache *automasking,
+ Object *ob,
- float *factor,
+ eAutomasking_flag mode)
+{
+ SculptSession *ss = ob->sculpt;
+ const int totvert = SCULPT_vertex_count_get(ss);
+
+ /* No need to build original data since this is only called at the beginning of strokes.*/
+ AutomaskingNodeData nodedata;
+ nodedata.have_orig_data = false;
+
+ for (int i = 0; i < totvert; i++) {
+ PBVHVertRef vertex = BKE_pbvh_index_to_vertex(ss->pbvh, i);
+
++ float f = *(float *)SCULPT_vertex_attr_get(vertex, ss->attrs.automasking_factor);
++
+ if ((int)mode & BRUSH_AUTOMASKING_BRUSH_NORMAL) {
- factor[i] *= automasking_brush_normal_factor(automasking, ss, vertex, &nodedata);
++ f *= automasking_brush_normal_factor(automasking, ss, vertex, &nodedata);
+ }
+ if ((int)mode & BRUSH_AUTOMASKING_VIEW_NORMAL) {
+ if ((int)mode & BRUSH_AUTOMASKING_VIEW_OCCLUSION) {
- factor[i] *= automasking_view_occlusion_factor(automasking, ss, vertex, &nodedata);
++ f *= automasking_view_occlusion_factor(automasking, ss, vertex, &nodedata);
+ }
+
- factor[i] *= automasking_view_normal_factor(automasking, ss, vertex, &nodedata);
++ f *= automasking_view_normal_factor(automasking, ss, vertex, &nodedata);
+ }
++
++ *(float *)SCULPT_vertex_attr_get(vertex, ss->attrs.automasking_factor) = f;
+ }
}
AutomaskingCache *SCULPT_automasking_cache_init(Sculpt *sd, Brush *brush, Object *ob)
@@@ -519,10 -344,6 +516,14 @@@
SCULPT_automasking_cache_settings_update(automasking, ss, sd, brush);
SCULPT_boundary_info_ensure(ob);
+ if (sculpt_automasking_mode_effective_bits(sd, brush) & BRUSH_AUTOMASKING_VIEW_OCCLUSION) {
- automasking->occluded = (char *)MEM_callocN(totvert, "automasking->occluded");
++ SculptAttributeParams params = {0};
++
++ params.stroke_only = true;
++ automasking->occlusion_attr = BKE_sculpt_attribute_ensure(
++ ob, ATTR_DOMAIN_POINT, CD_PROP_INT8, ".sculpt.automasking_occlusion", ¶ms);
+ }
+
if (!SCULPT_automasking_needs_factors_cache(sd, brush)) {
return automasking;
}
@@@ -542,22 -370,12 +550,21 @@@
}
if (SCULPT_is_automasking_mode_enabled(sd, brush, BRUSH_AUTOMASKING_FACE_SETS)) {
SCULPT_vertex_random_access_ensure(ss);
- sculpt_face_sets_automasking_init(sd, ob, automasking->factor);
+ sculpt_face_sets_automasking_init(sd, ob);
}
+ int normal_bits = sculpt_automasking_mode_effective_bits(sd, brush) &
+ (BRUSH_AUTOMASKING_BRUSH_NORMAL | BRUSH_AUTOMASKING_VIEW_NORMAL |
+ BRUSH_AUTOMASKING_VIEW_OCCLUSION);
+
+ if (normal_bits) {
+ sculpt_normal_occlusion_automasking_fill(
- automasking, ob, automasking->factor, (eAutomasking_flag)normal_bits);
++ automasking, ob, (eAutomasking_flag)normal_bits);
+ }
+
if (SCULPT_is_automasking_mode_enabled(sd, brush, BRUSH_AUTOMASKING_BOUNDARY_EDGES)) {
SCULPT_vertex_random_access_ensure(ss);
- SCULPT_boundary_automasking_init(
- ob, AUTOMASK_INIT_BOUNDARY_EDGES, boundary_propagation_steps, automasking->factor);
+ SCULPT_boundary_automasking_init(ob, AUTOMASK_INIT_BOUNDARY_EDGES, boundary_propagation_steps);
}
if (SCULPT_is_automasking_mode_enabled(sd, brush, BRUSH_AUTOMASKING_BOUNDARY_FACE_SETS)) {
SCULPT_vertex_random_access_ensure(ss);
diff --cc source/blender/editors/sculpt_paint/sculpt_boundary.c
index aae124ff259,005892b88a0..f6da40065e0
--- a/source/blender/editors/sculpt_paint/sculpt_boundary.c
+++ b/source/blender/editors/sculpt_paint/sculpt_boundary.c
@@@ -682,12 -681,9 +681,12 @@@ static void do_boundary_brush_bend_task
angle_factor = floorf(angle_factor * 10) / 10.0f;
}
const float angle = angle_factor * M_PI;
+ AutomaskingNodeData automask_data;
+ SCULPT_automasking_node_begin(
+ data->ob, ss, ss->cache->automasking, &automask_data, data->nodes[n]);
BKE_pbvh_vertex_iter_begin (ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE) {
- if (boundary->edit_info[vd.index].num_propagation_steps == -1) {
+
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list