Blender V5.3
MOD_grease_pencil_outline.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_attribute.hh"
10#include "BKE_material.hh"
11#include "BLI_array_utils.hh"
12#include "BLI_index_range.hh"
13#include "BLI_math_matrix.hh"
14#include "BLI_math_vector.hh"
15#include "BLI_offset_indices.hh"
16#include "BLI_span.hh"
17#include "BLI_virtual_array.hh"
18
19#include "DNA_modifier_types.h"
20#include "DNA_scene_types.h"
21
22#include "BKE_curves.hh"
23#include "BKE_geometry_set.hh"
24#include "BKE_grease_pencil.hh"
25#include "BKE_instances.hh"
26#include "BKE_lib_query.hh"
27#include "BKE_modifier.hh"
28#include "BKE_screen.hh"
29
30#include "BLO_read_write.hh"
31
33
34#include "ED_grease_pencil.hh"
35
37
39#include "UI_resources.hh"
40
41#include "BLT_translation.hh"
42
43#include "WM_api.hh"
44#include "WM_types.hh"
45
46#include "RNA_access.hh"
47#include "RNA_prototypes.hh"
48
50#include "MOD_ui_common.hh"
51
52namespace blender {
53
54static void init_data(ModifierData *md)
55{
56 auto *omd = reinterpret_cast<GreasePencilOutlineModifierData *>(md);
58 modifier::greasepencil::init_influence_data(&omd->influence, false);
59}
60
61static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
62{
63 const auto *omd = reinterpret_cast<const GreasePencilOutlineModifierData *>(md);
64 auto *tmmd = reinterpret_cast<GreasePencilOutlineModifierData *>(target);
65
67
68 BKE_modifier_copydata_generic(md, target, flag);
69 modifier::greasepencil::copy_influence_data(&omd->influence, &tmmd->influence, flag);
70}
71
72static void free_data(ModifierData *md)
73{
74 auto *omd = reinterpret_cast<GreasePencilOutlineModifierData *>(md);
76}
77
78static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
79{
80 auto *omd = reinterpret_cast<GreasePencilOutlineModifierData *>(md);
81 modifier::greasepencil::foreach_influence_ID_link(&omd->influence, ob, walk, user_data);
82 walk(user_data, ob, reinterpret_cast<ID **>(&omd->outline_material), IDWALK_CB_USER);
83 walk(user_data, ob, reinterpret_cast<ID **>(&omd->object), IDWALK_CB_NOP);
84}
85
87{
88 auto *omd = reinterpret_cast<GreasePencilOutlineModifierData *>(md);
89 if (ctx->scene->camera) {
91 ctx->node, ctx->scene->camera, DEG_OB_COMP_TRANSFORM, "Grease Pencil Outline Modifier");
93 ctx->node, ctx->scene->camera, DEG_OB_COMP_PARAMETERS, "Grease Pencil Outline Modifier");
94 }
95 if (omd->object != nullptr) {
97 ctx->node, omd->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Outline Modifier");
98 }
100 ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Outline Modifier");
101}
102
109 const IndexMask &curve_selection,
110 const Span<int> curve_offsets)
111{
112 BLI_assert(curve_offsets.size() == src_curves.curves_num());
113
114 OffsetIndices<int> src_offsets = src_curves.points_by_curve();
115 bke::AttributeAccessor src_attributes = src_curves.attributes();
116
117 Array<int> indices(src_curves.points_num());
118 curve_selection.foreach_index(
119 [&](const int64_t curve_i) {
120 const IndexRange points = src_offsets[curve_i];
121 const int point_num = points.size();
122 const int point_start = points.start();
123 MutableSpan<int> point_indices = indices.as_mutable_span().slice(points);
124 if (points.size() < 2) {
125 array_utils::fill_index_range(point_indices, point_start);
126 return;
127 }
128 /* Offset can be negative or larger than the buffer. Use modulo to get an
129 * equivalent offset within buffer size to simplify copying. */
130 const int offset_raw = curve_offsets[curve_i];
131 const int offset = offset_raw >= 0 ? offset_raw % points.size() :
132 points.size() - ((-offset_raw) % points.size());
133 BLI_assert(0 <= offset && offset < points.size());
134 if (offset == 0) {
135 array_utils::fill_index_range(point_indices, point_start);
136 return;
137 }
138
139 const int point_middle = point_start + offset;
140 array_utils::fill_index_range(point_indices.take_front(point_num - offset), point_middle);
141 array_utils::fill_index_range(point_indices.take_back(offset), point_start);
142 },
144
145 /* Have to make a copy of the input geometry, gather_attributes does not work in-place when the
146 * source indices are not ordered. */
147 bke::CurvesGeometry dst_curves(src_curves);
148 bke::MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
150 src_attributes, bke::AttrDomain::Point, bke::AttrDomain::Point, {}, indices, dst_attributes);
151
152 return dst_curves;
153}
154
155static int find_closest_point(const Span<float3> positions, const float3 &target)
156{
157 if (positions.is_empty()) {
158 return 0;
159 }
160
161 int closest_i = 0;
162 float min_dist_squared = math::distance_squared(positions.first(), target);
163 for (const int i : positions.index_range().drop_front(1)) {
164 const float dist_squared = math::distance_squared(positions[i], target);
165 if (dist_squared < min_dist_squared) {
166 closest_i = i;
167 min_dist_squared = dist_squared;
168 }
169 }
170 return closest_i;
171}
172
174 const ModifierEvalContext &ctx,
176 const float4x4 &viewmat)
177{
179
180 if (drawing.strokes().curve_num == 0) {
181 return;
182 }
183
184 /* Selected source curves. */
185 IndexMaskMemory curve_mask_memory;
187 ctx.object, drawing.strokes(), omd.influence, curve_mask_memory);
188
189 /* Unit object scale is applied to the stroke radius. */
190 const float object_scale = math::length(
191 math::transform_direction(ctx.object->object_to_world(), float3(M_SQRT1_3)));
192 /* Legacy thickness setting is diameter in pixels, divide by 2000 to get radius. */
193 const float radius = math::max(omd.thickness * object_scale, 1.0f) *
195 /* Offset the strokes by the radius so the outside aligns with the input stroke. */
196 const float outline_offset = (omd.flag & MOD_GREASE_PENCIL_OUTLINE_KEEP_SHAPE) != 0 ? -radius :
197 0.0f;
198 const int mat_nr = (omd.outline_material ?
200 -1);
201
203 drawing, curves_mask, viewmat, omd.subdiv, radius, outline_offset, mat_nr);
204
205 /* Cyclic curve reordering feature. */
206 if (omd.object) {
207 const OffsetIndices points_by_curve = curves.points_by_curve();
208
209 /* Computes the offset of the closest point to the object from the curve start. */
210 Array<int> offset_by_curve(curves.curves_num());
211 for (const int i : curves.curves_range()) {
212 const IndexRange points = points_by_curve[i];
213 /* Closest point index is already relative to the point range and can be used as offset. */
214 offset_by_curve[i] = find_closest_point(curves.positions().slice(points), omd.object->loc);
215 }
216
217 curves = reorder_cyclic_curve_points(curves, curves.curves_range(), offset_by_curve);
218 }
219
220 /* Resampling feature. */
221 if (omd.sample_length > 0.0f) {
223 curves.curves_num());
224 curves = geometry::resample_to_length(curves, curves.curves_range(), sample_lengths);
225 }
226
227 drawing.strokes_for_write() = std::move(curves);
228 drawing.tag_topology_changed();
229}
230
232 const ModifierEvalContext *ctx,
233 bke::GeometrySet *geometry_set)
234{
238
239 const auto &omd = *reinterpret_cast<const GreasePencilOutlineModifierData *>(md);
240
241 const Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
242 if (!scene->camera) {
243 return;
244 }
245 const float4x4 viewinv = scene->camera->world_to_object();
246
247 if (!geometry_set->has_grease_pencil()) {
248 return;
249 }
251 const int frame = grease_pencil.runtime->eval_frame;
252
253 IndexMaskMemory mask_memory;
255 grease_pencil, omd.influence, mask_memory);
256
258 grease_pencil, layer_mask, frame);
259 threading::parallel_for_each(drawings, [&](const LayerDrawingInfo &info) {
260 const Layer &layer = grease_pencil.layer(info.layer_index);
261 const float4x4 viewmat = viewinv * layer.to_world_space(*ctx->object);
262 modify_drawing(omd, *ctx, *info.drawing, viewmat);
263 });
264}
265
266static void panel_draw(const bContext *C, Panel *panel)
267{
268 ui::Layout &layout = *panel->layout;
269
270 PointerRNA ob_ptr;
272
273 layout.use_property_split_set(true);
274
275 layout.prop(ptr, "thickness", UI_ITEM_NONE, std::nullopt, ICON_NONE);
276 layout.prop(ptr, "use_keep_shape", UI_ITEM_NONE, std::nullopt, ICON_NONE);
277 layout.prop(ptr, "subdivision", UI_ITEM_NONE, std::nullopt, ICON_NONE);
278 layout.prop(ptr, "sample_length", UI_ITEM_NONE, std::nullopt, ICON_NONE);
279 layout.prop(ptr, "outline_material", UI_ITEM_NONE, std::nullopt, ICON_NONE);
280 layout.prop(ptr, "object", UI_ITEM_NONE, std::nullopt, ICON_NONE);
281
282 Scene *scene = CTX_data_scene(C);
283 if (scene->camera == nullptr) {
284 layout.label(RPT_("Outline requires an active camera"), ICON_STATUS_ERROR);
285 }
286
287 if (ui::Layout *influence_panel = layout.panel_prop(
288 C, ptr, "open_influence_panel", IFACE_("Influence")))
289 {
292 }
293
294 modifier_error_message_draw(layout, ptr);
295}
296
301
302static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
303{
304 const auto *omd = reinterpret_cast<const GreasePencilOutlineModifierData *>(md);
305
306 writer->write_struct(omd);
307 modifier::greasepencil::write_influence_data(writer, &omd->influence);
308}
309
310static void blend_read(BlendDataReader *reader, ModifierData *md)
311{
312 auto *omd = reinterpret_cast<GreasePencilOutlineModifierData *>(md);
313
314 modifier::greasepencil::read_influence_data(reader, &omd->influence);
315}
316
318 /*idname*/ "GreasePencilOutline",
319 /*name*/ N_("Outline"),
320 /*struct_name*/ "GreasePencilOutlineModifierData",
321 /*struct_size*/ sizeof(GreasePencilOutlineModifierData),
322 /*srna*/ &RNA_GreasePencilOutlineModifier,
326 /*icon*/ ICON_MOD_OUTLINE,
327
328 /*copy_data*/ copy_data,
329
330 /*deform_verts*/ nullptr,
331 /*deform_matrices*/ nullptr,
332 /*deform_verts_EM*/ nullptr,
333 /*deform_matrices_EM*/ nullptr,
334 /*modify_mesh*/ nullptr,
335 /*modify_geometry_set*/ modify_geometry_set,
336
337 /*init_data*/ init_data,
338 /*required_data_mask*/ nullptr,
339 /*free_data*/ free_data,
340 /*is_disabled*/ nullptr,
341 /*update_depsgraph*/ update_depsgraph,
342 /*depends_on_time*/ nullptr,
343 /*depends_on_normals*/ nullptr,
344 /*foreach_ID_link*/ foreach_ID_link,
345 /*foreach_tex_link*/ nullptr,
346 /*free_runtime_data*/ nullptr,
347 /*panel_register*/ panel_register,
348 /*blend_write*/ blend_write,
349 /*blend_read*/ blend_read,
350};
351
352} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define M_SQRT1_3
#define RPT_(msgid)
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
constexpr int64_t size() const
constexpr int64_t start() const
constexpr MutableSpan take_back(const int64_t n) const
Definition BLI_span.hh:646
constexpr MutableSpan take_front(const int64_t n) const
Definition BLI_span.hh:635
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
static VArray from_single(T value, const int64_t size)
AttributeAccessor attributes() const
OffsetIndices< int > points_by_curve() const
MutableAttributeAccessor attributes_for_write()
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
constexpr IndexRange drop_front(int64_t n) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define layer
void fill_index_range(MutableSpan< T > span, const T start=0)
constexpr float LEGACY_RADIUS_CONVERSION_FACTOR
void gather_attributes(AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, const IndexMask &selection, MutableAttributeAccessor dst_attributes)
bke::CurvesGeometry create_curves_outline(const bke::greasepencil::Drawing &drawing, const IndexMask &strokes, const float4x4 &transform, const int corner_subdivisions, const float outline_radius, const float outline_offset, const int material_index)
constexpr ParallelGrainSize grain_size(int grain_size)
CurvesGeometry resample_to_length(const CurvesGeometry &src_curves, const IndexMask &selection, const VArray< float > &sample_lengths, const ResampleCurvesOutputAttributeIDs &output_ids={}, bool keep_last_segment=false)
T length(const VecBase< T, Size > &a)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
T max(const T &a, const T &b)
VecBase< T, 3 > transform_direction(const MatBase< T, 3, 3 > &mat, const VecBase< T, 3 > &direction)
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void draw_material_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void init_influence_data(GreasePencilModifierInfluenceData *influence_data, const bool has_custom_curve)
Vector< LayerDrawingInfo > get_drawing_infos_by_layer(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
void write_influence_data(BlendWriter *writer, const GreasePencilModifierInfluenceData *influence_data)
void draw_layer_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
IndexMask get_filtered_layer_mask(const GreasePencil &grease_pencil, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
IndexMask get_filtered_stroke_mask(const Object *ob, const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
void free_influence_data(GreasePencilModifierInfluenceData *influence_data)
void foreach_influence_ID_link(GreasePencilModifierInfluenceData *influence_data, Object *ob, IDWalkFunc walk, void *user_data)
void copy_influence_data(const GreasePencilModifierInfluenceData *influence_data_src, GreasePencilModifierInfluenceData *influence_data_dst, const int)
void ensure_no_bezier_curves(Drawing &drawing)
void parallel_for_each(Range &&range, const Function &function)
Definition BLI_task.hh:31
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
__int64 int64_t
Definition BKE_text.h:90
static void blend_write(BlendWriter *writer, const ID *, const ModifierData *md)
Definition MOD_bevel.cc:454
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
static int find_closest_point(const Span< float3 > positions, const float3 &target)
@ eModifierType_GreasePencilOutline
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
MatBase< float, 4, 4 > float4x4
static bke::CurvesGeometry reorder_cyclic_curve_points(const bke::CurvesGeometry &src_curves, const IndexMask &curve_selection, const Span< int > curve_offsets)
@ MOD_GREASE_PENCIL_OUTLINE_KEEP_SHAPE
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
int BKE_object_material_index_get(Object *ob, const Material *ma)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
static void modify_drawing(const GreasePencilArrayModifierData &mmd, const ModifierEvalContext &ctx, bke::greasepencil::Drawing &drawing)
static void blend_read(BlendDataReader *, ModifierData *md)
ModifierTypeInfo modifierType_GreasePencilOutline
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
Scene * CTX_data_scene(const bContext *C)
VecBase< float, 3 > float3
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilModifierInfluenceData influence
ui::Layout * layout
struct Object * camera
GreasePencil * get_grease_pencil_for_write()
void use_property_split_set(bool is_sep)
void label(StringRef name, int icon)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
#define N_(msgid)