Blender V5.3
MOD_grease_pencil_array.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
10
11#include "BKE_curves.hh"
12#include "BKE_geometry_set.hh"
13#include "BKE_grease_pencil.hh"
14#include "BKE_instances.hh"
15#include "BKE_lib_query.hh"
16#include "BKE_material.hh"
17#include "BKE_modifier.hh"
18#include "BKE_screen.hh"
19
20#include "BLO_read_write.hh"
21
23
25#include "UI_resources.hh"
26
27#include "BLT_translation.hh"
28
29#include "BLI_bounds_types.hh"
30#include "BLI_hash_c.hh"
31#include "BLI_math_matrix.hh"
32#include "BLI_rand_c.hh"
33
34#include "WM_types.hh"
35
36#include "RNA_access.hh"
37#include "RNA_prototypes.hh"
38
40#include "MOD_modifiertypes.hh"
41#include "MOD_ui_common.hh"
42
43namespace blender {
44
45static void init_data(ModifierData *md)
46{
47 auto *mmd = reinterpret_cast<GreasePencilArrayModifierData *>(md);
49 modifier::greasepencil::init_influence_data(&mmd->influence, false);
50}
51
52static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
53{
54 const auto *mmd = reinterpret_cast<const GreasePencilArrayModifierData *>(md);
55 auto *tmmd = reinterpret_cast<GreasePencilArrayModifierData *>(target);
56
58
59 BKE_modifier_copydata_generic(md, target, flag);
60 modifier::greasepencil::copy_influence_data(&mmd->influence, &tmmd->influence, flag);
61}
62
63static void free_data(ModifierData *md)
64{
65 auto *mmd = reinterpret_cast<GreasePencilArrayModifierData *>(md);
67}
68
69static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
70{
71 auto *mmd = reinterpret_cast<GreasePencilArrayModifierData *>(md);
72 walk(user_data, ob, reinterpret_cast<ID **>(&mmd->object), IDWALK_CB_NOP);
73 modifier::greasepencil::foreach_influence_ID_link(&mmd->influence, ob, walk, user_data);
74}
75
77{
78 auto *mmd = reinterpret_cast<GreasePencilArrayModifierData *>(md);
79 if (mmd->object != nullptr) {
81 ctx->node, mmd->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Array Modifier");
82 DEG_add_depends_on_transform_relation(ctx->node, "Grease Pencil Array Modifier");
83 }
84}
85
88 const int elem_idx,
89 const bool use_object_offset)
90{
91
92 if (use_object_offset) {
93 float4x4 mat_offset = float4x4::identity();
94
96 mat_offset[3] += mmd.offset;
97 }
98 const float4x4 &obinv = ob.world_to_object();
99
100 return mat_offset * obinv * mmd.object->object_to_world();
101 }
102
103 const float3 offset = [&]() {
105 return float3(mmd.offset) * elem_idx;
106 }
107 return float3(0.0f);
108 }();
109
110 return math::from_location<float4x4>(offset);
111}
112
114 const Object &ob,
115 const int elem_id)
116{
117 int seed = mmd.seed;
118 seed += BLI_hash_string(ob.id.name + 2);
119 seed += BLI_hash_string(mmd.modifier.name);
120 const float rand_offset = BLI_hash_int_01(seed);
121 float3x3 rand;
122 for (int j = 0; j < 3; j++) {
123 const uint3 primes(2, 3, 7);
124 double3 offset(0.0);
125 double3 r;
126 /* To ensure a nice distribution, we use halton sequence and offset using the seed. */
127 BLI_halton_3d(primes, offset, elem_id, r);
128
130 float rand_value;
131 rand_value = math::mod(r[0] * 2.0 - 1.0 + rand_offset, 1.0);
132 rand_value = math::mod(math::sin(rand_value * 12.9898 + j * 78.233) * 43758.5453, 1.0);
133 rand[j] = float3(rand_value);
134 }
135 else {
136 for (int i = 0; i < 3; i++) {
137 rand[j][i] = math::mod(r[i] * 2.0 - 1.0 + rand_offset, 1.0);
138 rand[j][i] = math::mod(math::sin(rand[j][i] * 12.9898 + j * 78.233) * 43758.5453, 1.0);
139 }
140 }
141 }
142 /* Calculate Random matrix. */
144 mmd.rnd_offset * rand[0], mmd.rnd_rot * rand[1], float3(1.0f) + mmd.rnd_scale * rand[2]);
145};
146
149 const bke::CurvesGeometry &base_curves,
150 bke::CurvesGeometry filtered_curves)
151{
152 /* Assign replacement material on filtered curves so all copies can have this material when later
153 * when they get instanced. */
154 if (mmd.mat_rpl > 0) {
155 bke::MutableAttributeAccessor attributes = filtered_curves.attributes_for_write();
156 bke::SpanAttributeWriter<int> stroke_materials = attributes.lookup_or_add_for_write_span<int>(
157 "material_index", bke::AttrDomain::Curve);
158 stroke_materials.span.fill(mmd.mat_rpl - 1);
159 stroke_materials.finish();
160 }
161
162 Curves *base_curves_id = bke::curves_new_nomain(base_curves);
163 Curves *filtered_curves_id = bke::curves_new_nomain(filtered_curves);
164 bke::GeometrySet base_geo = bke::GeometrySet::from_curves(base_curves_id);
165 bke::GeometrySet filtered_geo = bke::GeometrySet::from_curves(filtered_curves_id);
166
167 auto instances = std::make_unique<bke::Instances>(mmd.count);
168 const int base_handle = instances->add_reference(bke::InstanceReference{base_geo});
169 const int filtered_handle = instances->add_reference(bke::InstanceReference{filtered_geo});
170
171 /* Always add untouched original curves. */
172 MutableSpan<int> handles = instances->reference_handles_for_write();
173 MutableSpan<float4x4> transforms = instances->transforms_for_write();
174
175 handles.first() = base_handle;
176 transforms.first() = float4x4::identity();
177
178 float3 size(0.0f);
180 std::optional<Bounds<float3>> bounds = filtered_curves.bounds_min_max();
181 if (bounds.has_value()) {
182 size = bounds.value().max - bounds.value().min;
183 /* Need a minimum size (for flat drawings). */
184 size = math::max(size, float3(0.01f));
185 }
186 }
187
188 float4x4 current_offset = float4x4::identity();
189 for (const int elem_id : IndexRange(1, mmd.count - 1)) {
190 const bool use_object_offset = (mmd.flag & MOD_GREASE_PENCIL_ARRAY_USE_OB_OFFSET) &&
191 (mmd.object);
192 const float4x4 mat = get_array_matrix(ob, mmd, elem_id, use_object_offset);
193
194 if (use_object_offset) {
195 current_offset = current_offset * mat;
196 }
197 else {
198 current_offset = mat;
199 }
200
201 /* Apply relative offset. */
203 float3 relative = size * float3(mmd.shift);
204 float3 translate = relative * float3(float(elem_id));
205 current_offset.w += float4(translate, 1.0f);
206 }
207
208 current_offset *= get_rand_matrix(mmd, ob, elem_id);
209
210 handles[elem_id] = filtered_handle;
211 transforms[elem_id] = current_offset;
212 }
213
215 options.keep_original_ids = true;
216 options.realize_instance_attributes = false; /* Should this be true? */
218 bke::GeometrySet::from_instances(std::move(instances)),
219 options)
220 .geometry;
221 return std::move(result_geo.get_curves_for_write()->geometry.wrap());
222}
223
225 const ModifierEvalContext &ctx,
227{
228 const bke::CurvesGeometry &src_curves = drawing.strokes();
229 if (src_curves.curve_num == 0) {
230 return;
231 }
232
233 IndexMaskMemory curve_mask_memory;
235 ctx.object, src_curves, mmd.influence, curve_mask_memory);
236
237 if (curves_mask.size() == src_curves.curve_num) {
238 /* Make a full copy so we can modify materials inside #create_array_copies before instancing.
239 */
240 bke::CurvesGeometry copy = bke::CurvesGeometry(src_curves);
241
243 *ctx.object, mmd, src_curves, std::move(copy));
244 }
245 else {
247 src_curves, curves_mask, {});
248
250 *ctx.object, mmd, src_curves, std::move(masked_curves));
251 }
252
253 drawing.tag_topology_changed();
254}
255
257 const ModifierEvalContext *ctx,
258 bke::GeometrySet *geometry_set)
259{
261
262 auto *mmd = reinterpret_cast<GreasePencilArrayModifierData *>(md);
263
264 if (!geometry_set->has_grease_pencil()) {
265 return;
266 }
268 const int frame = grease_pencil.runtime->eval_frame;
269
270 IndexMaskMemory mask_memory;
272 grease_pencil, mmd->influence, mask_memory);
273
275 grease_pencil, layer_mask, frame);
277 [&](Drawing *drawing) { modify_drawing(*mmd, *ctx, *drawing); });
278}
279
280static void panel_draw(const bContext *C, Panel *panel)
281{
282 ui::Layout &layout = *panel->layout;
283
284 PointerRNA ob_ptr;
286
287 layout.use_property_split_set(true);
288
289 layout.prop(ptr, "count", UI_ITEM_NONE, std::nullopt, ICON_NONE);
290 layout.prop(ptr, "replace_material", UI_ITEM_NONE, IFACE_("Material Override"), ICON_NONE);
291 ui::PanelLayout relative_offset_layout = layout.panel_prop_with_bool_header(
292 C, ptr, "open_relative_offset_panel", ptr, "use_relative_offset", IFACE_("Relative Offset"));
293 if (ui::Layout *sub = relative_offset_layout.body) {
294 ui::Layout &col = sub->column(false);
295 col.active_set(RNA_boolean_get(ptr, "use_relative_offset"));
296 col.prop(ptr, "relative_offset", UI_ITEM_NONE, IFACE_("Factor"), ICON_NONE);
297 }
298 ui::PanelLayout constant_offset_layout = layout.panel_prop_with_bool_header(
299 C, ptr, "open_constant_offset_panel", ptr, "use_constant_offset", IFACE_("Constant Offset"));
300 if (ui::Layout *sub = constant_offset_layout.body) {
301 ui::Layout &col = sub->column(false);
302 col.active_set(RNA_boolean_get(ptr, "use_constant_offset"));
303 col.prop(ptr, "constant_offset", UI_ITEM_NONE, IFACE_("Distance"), ICON_NONE);
304 }
305 ui::PanelLayout object_offset_layout = layout.panel_prop_with_bool_header(
306 C, ptr, "open_object_offset_panel", ptr, "use_object_offset", IFACE_("Object Offset"));
307 if (ui::Layout *sub = object_offset_layout.body) {
308 ui::Layout &col = sub->column(false);
309 col.active_set(RNA_boolean_get(ptr, "use_object_offset"));
310 col.prop(ptr, "offset_object", UI_ITEM_NONE, IFACE_("Object"), ICON_NONE);
311 }
312
313 if (ui::Layout *sub = layout.panel_prop(C, ptr, "open_randomize_panel", IFACE_("Randomize"))) {
314 sub->use_property_split_set(true);
315 sub->prop(ptr, "random_offset", UI_ITEM_NONE, IFACE_("Offset"), ICON_NONE);
316 sub->prop(ptr, "random_rotation", UI_ITEM_NONE, IFACE_("Rotation"), ICON_NONE);
317 sub->prop(ptr, "random_scale", UI_ITEM_NONE, IFACE_("Scale"), ICON_NONE);
318 sub->prop(ptr, "use_uniform_random_scale", UI_ITEM_NONE, std::nullopt, ICON_NONE);
319 sub->prop(ptr, "seed", UI_ITEM_NONE, std::nullopt, ICON_NONE);
320 }
321
322 if (ui::Layout *influence_panel = layout.panel_prop(
323 C, ptr, "open_influence_panel", IFACE_("Influence")))
324 {
327 }
328
329 modifier_error_message_draw(layout, ptr);
330}
331
336
337static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
338{
339 const auto *mmd = reinterpret_cast<const GreasePencilArrayModifierData *>(md);
340
341 writer->write_struct(mmd);
342 modifier::greasepencil::write_influence_data(writer, &mmd->influence);
343}
344
345static void blend_read(BlendDataReader *reader, ModifierData *md)
346{
347 auto *mmd = reinterpret_cast<GreasePencilArrayModifierData *>(md);
348
349 modifier::greasepencil::read_influence_data(reader, &mmd->influence);
350}
351
353 /*idname*/ "GreasePencilArrayModifier",
354 /*name*/ N_("Array"),
355 /*struct_name*/ "GreasePencilArrayModifierData",
356 /*struct_size*/ sizeof(GreasePencilArrayModifierData),
357 /*srna*/ &RNA_GreasePencilArrayModifier,
361 /*icon*/ ICON_MOD_ARRAY,
362
363 /*copy_data*/ copy_data,
364
365 /*deform_verts*/ nullptr,
366 /*deform_matrices*/ nullptr,
367 /*deform_verts_EM*/ nullptr,
368 /*deform_matrices_EM*/ nullptr,
369 /*modify_mesh*/ nullptr,
370 /*modify_geometry_set*/ modify_geometry_set,
371
372 /*init_data*/ init_data,
373 /*required_data_mask*/ nullptr,
374 /*free_data*/ free_data,
375 /*is_disabled*/ nullptr,
376 /*update_depsgraph*/ update_depsgraph,
377 /*depends_on_time*/ nullptr,
378 /*depends_on_normals*/ nullptr,
379 /*foreach_ID_link*/ foreach_ID_link,
380 /*foreach_tex_link*/ nullptr,
381 /*free_runtime_data*/ nullptr,
382 /*panel_register*/ panel_register,
383 /*blend_write*/ blend_write,
384 /*blend_read*/ blend_read,
385};
386
387} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
Random number functions.
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
constexpr IndexRange()=default
constexpr T & first() const
Definition BLI_span.hh:685
std::optional< Bounds< float3 > > bounds_min_max(bool use_radius=true) const
MutableAttributeAccessor attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
CCL_NAMESPACE_BEGIN struct Options options
float4x4 translate(float4x4 mat, float3 translation)
CurvesGeometry curves_copy_curve_selection(const CurvesGeometry &curves, const IndexMask &curves_to_copy, const AttributeFilter &attribute_filter)
Curves * curves_new_nomain(int points_num, int curves_num)
RealizeInstancesResult realize_instances(bke::GeometrySet geometry_set, const RealizeInstancesOptions &options)
T sin(const AngleRadianBase< T > &a)
T max(const T &a, const T &b)
T mod(const T &a, const T &b)
MatT from_location(const typename MatT::loc_type &location)
MatT from_loc_rot_scale(const typename MatT::loc_type &location, const RotationT &rotation, const VecBase< typename MatT::base_type, ScaleDim > &scale)
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)
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)
Vector< bke::greasepencil::Drawing * > get_drawings_for_write(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
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 parallel_for_each(Range &&range, const Function &function)
Definition BLI_task.hh:31
BMesh Iterators.
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
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)
@ eModifierType_GreasePencilArray
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)
VecBase< uint32_t, 3 > uint3
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
MatBase< float, 4, 4 > float4x4
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
BLI_INLINE float BLI_hash_int_01(unsigned int k)
Definition BLI_hash_c.hh:94
@ MOD_GREASE_PENCIL_ARRAY_USE_OB_OFFSET
@ MOD_GREASE_PENCIL_ARRAY_USE_OFFSET
@ MOD_GREASE_PENCIL_ARRAY_UNIFORM_RANDOM_SCALE
@ MOD_GREASE_PENCIL_ARRAY_USE_RELATIVE
VecBase< float, 4 > float4
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
void BLI_halton_3d(const unsigned int prime[3], double offset[3], int n, double *r)
Definition rand.cc:252
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
static float4x4 get_array_matrix(const Object &ob, const GreasePencilArrayModifierData &mmd, const int elem_idx, const bool use_object_offset)
static bke::CurvesGeometry create_array_copies(const Object &ob, const GreasePencilArrayModifierData &mmd, const bke::CurvesGeometry &base_curves, bke::CurvesGeometry filtered_curves)
VecBase< double, 3 > double3
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
MatBase< float, 3, 3 > float3x3
static float4x4 get_rand_matrix(const GreasePencilArrayModifierData &mmd, const Object &ob, const int elem_id)
@ 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)
BLI_INLINE unsigned int BLI_hash_string(const char *str)
Definition BLI_hash_c.hh:69
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
VecBase< float, 3 > float3
ModifierTypeInfo modifierType_GreasePencilArray
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
char name[258]
Definition DNA_ID.h:433
ui::Layout * layout
static GeometrySet from_curves(Curves *curves, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
static GeometrySet from_instances(std::unique_ptr< Instances > instances)
GreasePencil * get_grease_pencil_for_write()
void use_property_split_set(bool is_sep)
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)
void active_set(bool active)
Layout & column(bool align)
PanelLayout panel_prop_with_bool_header(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name, PointerRNA *bool_prop_owner, StringRefNull bool_prop_name, std::optional< StringRef > label)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
#define N_(msgid)