diff --git a/scripts/startup/bl_ui/properties_data_modifier.py b/scripts/startup/bl_ui/properties_data_modifier.py index c4905a12328..ca0ed5537f4 100644 --- a/scripts/startup/bl_ui/properties_data_modifier.py +++ b/scripts/startup/bl_ui/properties_data_modifier.py @@ -108,6 +108,7 @@ class OBJECT_MT_modifier_add_edit(ModifierAddMenu, Menu): self.operator_modifier_add(layout, 'VERTEX_WEIGHT_MIX') self.operator_modifier_add(layout, 'VERTEX_WEIGHT_PROXIMITY') if ob_type == 'GREASEPENCIL': + self.operator_modifier_add(layout, 'GREASE_PENCIL_VERTEX_WEIGHT_PROXIMITY') self.operator_modifier_add(layout, 'GREASE_PENCIL_VERTEX_WEIGHT_ANGLE') layout.template_modifier_asset_menu_items(catalog_path=self.bl_label) diff --git a/source/blender/makesdna/DNA_modifier_defaults.h b/source/blender/makesdna/DNA_modifier_defaults.h index 4a904668446..ccfce0057b0 100644 --- a/source/blender/makesdna/DNA_modifier_defaults.h +++ b/source/blender/makesdna/DNA_modifier_defaults.h @@ -943,4 +943,12 @@ .mat_rpl = 0, \ } +#define _DNA_DEFAULT_GreasePencilWeightProximityModifierData \ + { \ + .target_vgname = "", \ + .flag = 0, \ + .dist_start = 0.0f, \ + .dist_end = 20.0f, \ + } + /* clang-format off */ diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h index 794bcad42c8..a94a2af2417 100644 --- a/source/blender/makesdna/DNA_modifier_types.h +++ b/source/blender/makesdna/DNA_modifier_types.h @@ -110,6 +110,7 @@ typedef enum ModifierType { eModifierType_GreasePencilLength = 73, eModifierType_GreasePencilWeightAngle = 74, eModifierType_GreasePencilArray = 75, + eModifierType_GreasePencilWeightProximity = 76, NUM_MODIFIER_TYPES, } ModifierType; @@ -2926,3 +2927,23 @@ typedef enum GreasePencilArrayModifierFlag { MOD_GREASE_PENCIL_ARRAY_USE_OB_OFFSET = (1 << 9), MOD_GREASE_PENCIL_ARRAY_UNIFORM_RANDOM_SCALE = (1 << 10), } GreasePencilArrayModifierFlag; + +typedef struct GreasePencilWeightProximityModifierData { + ModifierData modifier; + GreasePencilModifierInfluenceData influence; + + /* #GreasePencilWeightProximityFlag. */ + int flag; + char target_vgname[64]; + float min_weight; + + float dist_start; + float dist_end; + + struct Object *object; +} GreasePencilWeightProximityModifierData; + +typedef enum GreasePencilWeightProximityFlag { + MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_INVERT_OUTPUT = (1 << 0), + MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_MULTIPLY_DATA = (1 << 1), +} GreasePencilWeightProximityFlag; diff --git a/source/blender/makesdna/intern/dna_defaults.c b/source/blender/makesdna/intern/dna_defaults.c index 78e1cbf1833..09135af33a7 100644 --- a/source/blender/makesdna/intern/dna_defaults.c +++ b/source/blender/makesdna/intern/dna_defaults.c @@ -340,6 +340,7 @@ SDNA_DEFAULT_DECL_STRUCT(GreasePencilDashModifierData); SDNA_DEFAULT_DECL_STRUCT(GreasePencilMultiModifierData); SDNA_DEFAULT_DECL_STRUCT(GreasePencilWeightAngleModifierData); SDNA_DEFAULT_DECL_STRUCT(GreasePencilArrayModifierData); +SDNA_DEFAULT_DECL_STRUCT(GreasePencilWeightProximityModifierData); #undef SDNA_DEFAULT_DECL_STRUCT @@ -602,6 +603,7 @@ const void *DNA_default_table[SDNA_TYPE_MAX] = { SDNA_DEFAULT_DECL(GreasePencilDashModifierData), SDNA_DEFAULT_DECL(GreasePencilMultiModifierData), SDNA_DEFAULT_DECL(GreasePencilArrayModifierData), + SDNA_DEFAULT_DECL(GreasePencilWeightProximityModifierData), }; #undef SDNA_DEFAULT_DECL #undef SDNA_DEFAULT_DECL_EX diff --git a/source/blender/makesrna/intern/rna_modifier.cc b/source/blender/makesrna/intern/rna_modifier.cc index 3753858b670..c65b70bc236 100644 --- a/source/blender/makesrna/intern/rna_modifier.cc +++ b/source/blender/makesrna/intern/rna_modifier.cc @@ -49,6 +49,13 @@ #include "MOD_nodes.hh" const EnumPropertyItem rna_enum_object_modifier_type_items[] = { + RNA_ENUM_ITEM_HEADING(N_("Modify"), nullptr), + {eModifierType_GreasePencilWeightProximity, + "GREASE_PENCIL_VERTEX_WEIGHT_PROXIMITY", + ICON_MOD_VERTEX_WEIGHT, + "Vertex Weight Proximity", + "Generate Vertex Weights base on distance to object"}, + RNA_ENUM_ITEM_HEADING(N_("Modify"), nullptr), {eModifierType_DataTransfer, "DATA_TRANSFER", @@ -899,6 +906,7 @@ RNA_MOD_VGROUP_NAME_SET(WeightedNormal, defgrp_name); RNA_MOD_VGROUP_NAME_SET(Weld, defgrp_name); RNA_MOD_VGROUP_NAME_SET(Wireframe, defgrp_name); RNA_MOD_VGROUP_NAME_SET(GreasePencilWeightAngle, target_vgname); +RNA_MOD_VGROUP_NAME_SET(GreasePencilWeightProximity, target_vgname); static void rna_ExplodeModifier_vgroup_get(PointerRNA *ptr, char *value) { @@ -978,6 +986,7 @@ RNA_MOD_OBJECT_SET(SurfaceDeform, target, OB_MESH); RNA_MOD_OBJECT_SET(GreasePencilMirror, object, OB_EMPTY); RNA_MOD_OBJECT_SET(GreasePencilTint, object, OB_EMPTY); RNA_MOD_OBJECT_SET(GreasePencilLattice, object, OB_LATTICE); +RNA_MOD_OBJECT_SET(GreasePencilWeightProximity, object, OB_EMPTY); static void rna_HookModifier_object_set(PointerRNA *ptr, PointerRNA value, @@ -1895,6 +1904,7 @@ RNA_MOD_GREASE_PENCIL_MATERIAL_FILTER_SET(GreasePencilMulti); RNA_MOD_GREASE_PENCIL_MATERIAL_FILTER_SET(GreasePencilLength); RNA_MOD_GREASE_PENCIL_MATERIAL_FILTER_SET(GreasePencilWeightAngle); RNA_MOD_GREASE_PENCIL_MATERIAL_FILTER_SET(GreasePencilArray); +RNA_MOD_GREASE_PENCIL_MATERIAL_FILTER_SET(GreasePencilWeightProximity); RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilOffset); RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilOpacity); @@ -1906,6 +1916,7 @@ RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilThick); RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilLattice); RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilLength); RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilWeightAngle); +RNA_MOD_GREASE_PENCIL_VERTEX_GROUP_SET(GreasePencilWeightProximity); static void rna_GreasePencilOpacityModifier_opacity_factor_range( PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) @@ -9057,6 +9068,78 @@ static void rna_def_modifier_grease_pencil_multiply(BlenderRNA *brna) RNA_define_lib_overridable(false); } +static void rna_def_modifier_grease_pencil_weight_proximity(BlenderRNA *brna) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, "GreasePencilWeightProximityModifier", "Modifier"); + RNA_def_struct_ui_text(srna, "Weight Modifier Proximity", "Calculate Vertex Weight dynamically"); + RNA_def_struct_sdna(srna, "GreasePencilWeightProximityModifierData"); + RNA_def_struct_ui_icon(srna, ICON_MOD_VERTEX_WEIGHT); + + rna_def_modifier_grease_pencil_layer_filter(srna); + rna_def_modifier_grease_pencil_material_filter( + srna, "rna_GreasePencilWeightProximityModifier_material_filter_set"); + rna_def_modifier_grease_pencil_vertex_group( + srna, "rna_GreasePencilWeightProximityModifier_vertex_group_name_set"); + + rna_def_modifier_panel_open_prop(srna, "open_influence_panel", 0); + + RNA_define_lib_overridable(true); + + prop = RNA_def_property(srna, "use_multiply", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna( + prop, nullptr, "flag", MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_MULTIPLY_DATA); + RNA_def_property_ui_text( + prop, + "Multiply Weights", + "Multiply the calculated weights with the existing values in the vertex group"); + RNA_def_property_update(prop, 0, "rna_Modifier_update"); + + prop = RNA_def_property(srna, "use_invert_output", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna( + prop, nullptr, "flag", MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_INVERT_OUTPUT); + RNA_def_property_ui_text(prop, "Invert", "Invert output weight values"); + RNA_def_property_update(prop, 0, "rna_Modifier_update"); + + prop = RNA_def_property(srna, "target_vertex_group", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, nullptr, "target_vgname"); + RNA_def_property_ui_text(prop, "Vertex Group", "Output Vertex group"); + RNA_def_property_string_funcs( + prop, nullptr, nullptr, "rna_GreasePencilWeightProximityModifier_target_vgname_set"); + RNA_def_property_update(prop, 0, "rna_Modifier_update"); + + /* Distance reference object */ + prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE); + RNA_def_property_ui_text(prop, "Target Object", "Object used as distance reference"); + RNA_def_property_pointer_funcs( + prop, nullptr, "rna_GreasePencilWeightProximityModifier_object_set", nullptr, nullptr); + RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK); + RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update"); + + prop = RNA_def_property(srna, "distance_start", PROP_FLOAT, PROP_DISTANCE); + RNA_def_property_float_sdna(prop, nullptr, "dist_start"); + RNA_def_property_range(prop, 0.0, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0, 1000.0, 1.0, 2); + RNA_def_property_ui_text(prop, "Lowest", "Distance mapping to 0.0 weight"); + RNA_def_property_update(prop, 0, "rna_Modifier_update"); + + prop = RNA_def_property(srna, "minimum_weight", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, nullptr, "min_weight"); + RNA_def_property_ui_text(prop, "Minimum", "Minimum value for vertex weight"); + RNA_def_property_update(prop, 0, "rna_Modifier_update"); + + prop = RNA_def_property(srna, "distance_end", PROP_FLOAT, PROP_DISTANCE); + RNA_def_property_float_sdna(prop, nullptr, "dist_end"); + RNA_def_property_range(prop, 0.0, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0, 1000.0, 1.0, 2); + RNA_def_property_ui_text(prop, "Highest", "Distance mapping to 1.0 weight"); + RNA_def_property_update(prop, 0, "rna_Modifier_update"); + + RNA_define_lib_overridable(false); +} + void RNA_def_modifier(BlenderRNA *brna) { StructRNA *srna; @@ -9240,6 +9323,7 @@ void RNA_def_modifier(BlenderRNA *brna) rna_def_modifier_grease_pencil_length(brna); rna_def_modifier_grease_pencil_weight_angle(brna); rna_def_modifier_grease_pencil_array(brna); + rna_def_modifier_grease_pencil_weight_proximity(brna); } #endif diff --git a/source/blender/modifiers/CMakeLists.txt b/source/blender/modifiers/CMakeLists.txt index b8a062b489e..bb55360778a 100644 --- a/source/blender/modifiers/CMakeLists.txt +++ b/source/blender/modifiers/CMakeLists.txt @@ -60,6 +60,7 @@ set(SRC intern/MOD_grease_pencil_tint.cc intern/MOD_grease_pencil_util.cc intern/MOD_grease_pencil_weight_angle.cc + intern/MOD_grease_pencil_weight_proximity.cc intern/MOD_hook.cc intern/MOD_laplaciandeform.cc intern/MOD_laplaciansmooth.cc diff --git a/source/blender/modifiers/MOD_modifiertypes.hh b/source/blender/modifiers/MOD_modifiertypes.hh index f104e29d23e..d3d3f9313f9 100644 --- a/source/blender/modifiers/MOD_modifiertypes.hh +++ b/source/blender/modifiers/MOD_modifiertypes.hh @@ -88,6 +88,7 @@ extern ModifierTypeInfo modifierType_GreasePencilMultiply; extern ModifierTypeInfo modifierType_GreasePencilLength; extern ModifierTypeInfo modifierType_GreasePencilWeightAngle; extern ModifierTypeInfo modifierType_GreasePencilArray; +extern ModifierTypeInfo modifierType_GreasePencilWeightProximity; /* MOD_util.cc */ diff --git a/source/blender/modifiers/intern/MOD_grease_pencil_weight_proximity.cc b/source/blender/modifiers/intern/MOD_grease_pencil_weight_proximity.cc new file mode 100644 index 00000000000..0b573a3810e --- /dev/null +++ b/source/blender/modifiers/intern/MOD_grease_pencil_weight_proximity.cc @@ -0,0 +1,321 @@ +/* SPDX-FileCopyrightText: 2005 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +/** \file + * \ingroup modifiers + */ + +#include "BLI_index_mask.hh" +#include "BLI_math_matrix.hh" +#include "BLI_string.h" /* For #STRNCPY. */ + +#include "BLT_translation.hh" + +#include "BLO_read_write.hh" + +#include "DNA_defaults.h" +#include "DNA_modifier_types.h" +#include "DNA_screen_types.h" + +#include "RNA_access.hh" + +#include "BKE_curves.hh" +#include "BKE_geometry_set.hh" +#include "BKE_grease_pencil.hh" +#include "BKE_lib_query.hh" +#include "BKE_modifier.hh" + +#include "UI_interface.hh" +#include "UI_resources.hh" + +#include "MOD_grease_pencil_util.hh" +#include "MOD_modifiertypes.hh" +#include "MOD_ui_common.hh" + +#include "RNA_prototypes.h" + +namespace blender { + +static void init_data(ModifierData *md) +{ + auto *gpmd = reinterpret_cast(md); + + BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(gpmd, modifier)); + + MEMCPY_STRUCT_AFTER( + gpmd, DNA_struct_default_get(GreasePencilWeightProximityModifierData), modifier); + modifier::greasepencil::init_influence_data(&gpmd->influence, false); +} + +static void copy_data(const ModifierData *md, ModifierData *target, const int flag) +{ + const auto *gmd = reinterpret_cast(md); + auto *tgmd = reinterpret_cast(target); + + BKE_modifier_copydata_generic(md, target, flag); + modifier::greasepencil::copy_influence_data(&gmd->influence, &tgmd->influence, flag); +} + +static void free_data(ModifierData *md) +{ + auto *mmd = reinterpret_cast(md); + + modifier::greasepencil::free_influence_data(&mmd->influence); +} + +static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/) +{ + auto *mmd = reinterpret_cast(md); + + return (mmd->target_vgname[0] == '\0' || mmd->object == nullptr); +} + +static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data) +{ + GreasePencilWeightProximityModifierData *mmd = + reinterpret_cast(md); + + modifier::greasepencil::foreach_influence_ID_link(&mmd->influence, ob, walk, user_data); + + walk(user_data, ob, (ID **)&mmd->object, IDWALK_CB_NOP); +} + +static void update_depsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx) +{ + auto *mmd = reinterpret_cast(md); + if (mmd->object != nullptr) { + DEG_add_object_relation( + ctx->node, mmd->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Proximity Modifier"); + DEG_add_depends_on_transform_relation(ctx->node, "Grease Pencil Proximity Modifier"); + } +} + +static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md) +{ + const GreasePencilWeightProximityModifierData *mmd = + reinterpret_cast(md); + + BLO_write_struct(writer, GreasePencilWeightProximityModifierData, mmd); + modifier::greasepencil::write_influence_data(writer, &mmd->influence); +} + +static void blend_read(BlendDataReader *reader, ModifierData *md) +{ + GreasePencilWeightProximityModifierData *mmd = + reinterpret_cast(md); + modifier::greasepencil::read_influence_data(reader, &mmd->influence); +} + +static float get_distance_factor( + float3 target_pos, float4x4 obmat, float3 pos, const float dist_min, const float dist_max) +{ + const float3 gvert = math::transform_point(obmat, pos); + const float dist = math::distance(target_pos, gvert); + + if (dist > dist_max) { + return 1.0f; + } + if (dist <= dist_max && dist > dist_min) { + return 1.0f - ((dist_max - dist) / math::max((dist_max - dist_min), 0.0001f)); + } + return 0.0f; +} + +static int ensure_vertex_group(const StringRefNull name, ListBase &vertex_group_names) +{ + int def_nr = BLI_findstringindex( + &vertex_group_names, name.c_str(), offsetof(bDeformGroup, name)); + if (def_nr < 0) { + bDeformGroup *defgroup = MEM_cnew(__func__); + STRNCPY(defgroup->name, name.c_str()); + BLI_addtail(&vertex_group_names, defgroup); + def_nr = BLI_listbase_count(&vertex_group_names) - 1; + BLI_assert(def_nr >= 0); + } + return def_nr; +} + +static bool target_vertex_group_available(const StringRefNull name, + const ListBase &vertex_group_names) +{ + const int def_nr = BLI_findstringindex( + &vertex_group_names, name.c_str(), offsetof(bDeformGroup, name)); + if (def_nr < 0) { + return false; + } + return true; +} + +static void write_weights_for_drawing(const ModifierData &md, + const Object &ob, + bke::greasepencil::Drawing &drawing) +{ + const auto &mmd = reinterpret_cast(md); + bke::CurvesGeometry &curves = drawing.strokes_for_write(); + if (curves.points_num() == 0) { + return; + } + IndexMaskMemory memory; + const IndexMask strokes = modifier::greasepencil::get_filtered_stroke_mask( + &ob, curves, mmd.influence, memory); + if (strokes.is_empty()) { + return; + } + + /* Make sure that the target vertex group is added to this drawing so we can write to it. */ + ensure_vertex_group(mmd.target_vgname, curves.vertex_group_names); + + bke::MutableAttributeAccessor attributes = curves.attributes_for_write(); + bke::SpanAttributeWriter dst_weights = attributes.lookup_for_write_span( + mmd.target_vgname); + + BLI_assert(!dst_weights.span.is_empty()); + + const VArray vgroup_weights = modifier::greasepencil::get_influence_vertex_weights( + curves, mmd.influence); + + const Span positions = curves.positions(); + const float4x4 obmat = ob.object_to_world(); + const float3 target_pos = mmd.object->object_to_world().location(); + const bool invert = (mmd.flag & MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_INVERT_OUTPUT) != 0; + const bool do_multiply = (mmd.flag & MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_MULTIPLY_DATA) != 0; + + threading::parallel_for(positions.index_range(), 1024, [&](const IndexRange range) { + for (const int point_i : range) { + const float weight = vgroup_weights[point_i]; + if (weight < 0.0f) { + continue; + } + + float dist_fac = get_distance_factor( + target_pos, obmat, positions[point_i], mmd.dist_start, mmd.dist_end); + + if (invert) { + dist_fac = 1.0f - dist_fac; + } + + dst_weights.span[point_i] = do_multiply ? dst_weights.span[point_i] * dist_fac : dist_fac; + + dst_weights.span[point_i] = math::clamp( + dst_weights.span[point_i], + /** Weight==0 will remove the point from the group, assign a sufficiently small value + * there to prevent the visual disconnect, and keep the behavior same as the old + * modifier. */ + math::max(mmd.min_weight, 1e-5f), + 1.0f); + } + }); + + dst_weights.finish(); +} + +static void modify_geometry_set(ModifierData *md, + const ModifierEvalContext *ctx, + bke::GeometrySet *geometry_set) +{ + const GreasePencilWeightProximityModifierData *mmd = + reinterpret_cast(md); + + if (!geometry_set->has_grease_pencil()) { + return; + } + + GreasePencil &grease_pencil = *geometry_set->get_grease_pencil_for_write(); + + if (!target_vertex_group_available(mmd->target_vgname, grease_pencil.vertex_group_names)) { + return; + } + + const int current_frame = grease_pencil.runtime->eval_frame; + + IndexMaskMemory mask_memory; + const IndexMask layer_mask = modifier::greasepencil::get_filtered_layer_mask( + grease_pencil, mmd->influence, mask_memory); + const Vector drawings = + modifier::greasepencil::get_drawings_for_write(grease_pencil, layer_mask, current_frame); + + threading::parallel_for_each(drawings, [&](bke::greasepencil::Drawing *drawing) { + write_weights_for_drawing(*md, *ctx->object, *drawing); + }); +} + +static void panel_draw(const bContext *C, Panel *panel) +{ + uiLayout *row, *sub; + uiLayout *layout = panel->layout; + + PointerRNA ob_ptr; + PointerRNA *ptr = modifier_panel_get_property_pointers(panel, &ob_ptr); + + uiLayoutSetPropSep(layout, true); + row = uiLayoutRow(layout, true); + uiItemPointerR(row, ptr, "target_vertex_group", &ob_ptr, "vertex_groups", nullptr, ICON_NONE); + sub = uiLayoutRow(row, true); + bool has_output = RNA_string_length(ptr, "target_vertex_group") != 0; + uiLayoutSetPropDecorate(sub, false); + uiLayoutSetActive(sub, has_output); + uiItemR(sub, ptr, "use_invert_output", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT); + + uiItemR(layout, ptr, "object", UI_ITEM_NONE, nullptr, ICON_NONE); + + sub = uiLayoutColumn(layout, true); + uiItemR(sub, ptr, "distance_start", UI_ITEM_NONE, nullptr, ICON_NONE); + uiItemR(sub, ptr, "distance_end", UI_ITEM_NONE, nullptr, ICON_NONE); + + uiItemR(layout, ptr, "minimum_weight", UI_ITEM_NONE, nullptr, ICON_NONE); + uiItemR(layout, ptr, "use_multiply", UI_ITEM_NONE, nullptr, ICON_NONE); + + if (uiLayout *influence_panel = uiLayoutPanelProp( + C, layout, ptr, "open_influence_panel", "Influence")) + { + modifier::greasepencil::draw_layer_filter_settings(C, influence_panel, ptr); + modifier::greasepencil::draw_material_filter_settings(C, influence_panel, ptr); + modifier::greasepencil::draw_vertex_group_settings(C, influence_panel, ptr); + } + + modifier_panel_end(layout, ptr); +} + +static void panel_register(ARegionType *region_type) +{ + modifier_panel_register(region_type, eModifierType_GreasePencilWeightProximity, panel_draw); +} + +} // namespace blender + +ModifierTypeInfo modifierType_GreasePencilWeightProximity = { + /*idname*/ "GreasePencilWeightProximityModifier", + /*name*/ N_("Weight Proximity"), + /*struct_name*/ "GreasePencilWeightProximityModifierData", + /*struct_size*/ sizeof(GreasePencilWeightProximityModifierData), + /*srna*/ &RNA_GreasePencilWeightProximityModifier, + /*type*/ ModifierTypeType::NonGeometrical, + /*flags*/ + eModifierTypeFlag_AcceptsGreasePencil | eModifierTypeFlag_SupportsEditmode | + eModifierTypeFlag_EnableInEditmode | eModifierTypeFlag_SupportsMapping, + /*icon*/ ICON_MOD_VERTEX_WEIGHT, + + /*copy_data*/ blender::copy_data, + + /*deform_verts*/ nullptr, + /*deform_matrices*/ nullptr, + /*deform_verts_EM*/ nullptr, + /*deform_matrices_EM*/ nullptr, + /*modify_mesh*/ nullptr, + /*modify_geometry_set*/ blender::modify_geometry_set, + + /*init_data*/ blender::init_data, + /*required_data_mask*/ nullptr, + /*free_data*/ blender::free_data, + /*is_disabled*/ blender::is_disabled, + /*update_depsgraph*/ blender::update_depsgraph, + /*depends_on_time*/ nullptr, + /*depends_on_normals*/ nullptr, + /*foreach_ID_link*/ blender::foreach_ID_link, + /*foreach_tex_link*/ nullptr, + /*free_runtime_data*/ nullptr, + /*panel_register*/ blender::panel_register, + /*blend_write*/ blender::blend_write, + /*blend_read*/ blender::blend_read, +}; diff --git a/source/blender/modifiers/intern/MOD_util.cc b/source/blender/modifiers/intern/MOD_util.cc index 6b9027bd0ab..d8b3345b763 100644 --- a/source/blender/modifiers/intern/MOD_util.cc +++ b/source/blender/modifiers/intern/MOD_util.cc @@ -279,5 +279,6 @@ void modifier_type_init(ModifierTypeInfo *types[]) INIT_TYPE(GreasePencilLength); INIT_TYPE(GreasePencilWeightAngle); INIT_TYPE(GreasePencilArray); + INIT_TYPE(GreasePencilWeightProximity); #undef INIT_TYPE }