Blender V5.3
MOD_grease_pencil_envelope.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 "BLI_array_utils.hh"
12#include "BLI_math_geom_c.hh"
13
14#include "BKE_curves.hh"
15#include "BKE_geometry_set.hh"
16#include "BKE_grease_pencil.hh"
17#include "BKE_instances.hh"
18#include "BKE_material.hh"
19#include "BKE_modifier.hh"
20#include "BKE_screen.hh"
21
22#include "BLO_read_write.hh"
23
25#include "UI_resources.hh"
26
27#include "BLT_translation.hh"
28
29#include "WM_types.hh"
30
31#include "RNA_access.hh"
32#include "RNA_prototypes.hh"
33
35#include "MOD_modifiertypes.hh"
36#include "MOD_ui_common.hh"
37
38namespace blender {
39
40static void init_data(ModifierData *md)
41{
42 auto *emd = reinterpret_cast<GreasePencilEnvelopeModifierData *>(md);
44 modifier::greasepencil::init_influence_data(&emd->influence, false);
45}
46
47static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
48{
49 const auto *emd = reinterpret_cast<const GreasePencilEnvelopeModifierData *>(md);
50 auto *temd = reinterpret_cast<GreasePencilEnvelopeModifierData *>(target);
51
53
54 BKE_modifier_copydata_generic(md, target, flag);
55 modifier::greasepencil::copy_influence_data(&emd->influence, &temd->influence, flag);
56}
57
58static void free_data(ModifierData *md)
59{
60 auto *emd = reinterpret_cast<GreasePencilEnvelopeModifierData *>(md);
62}
63
64static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
65{
66 auto *emd = reinterpret_cast<GreasePencilEnvelopeModifierData *>(md);
67 modifier::greasepencil::foreach_influence_ID_link(&emd->influence, ob, walk, user_data);
68}
69
70static inline float3 calculate_plane(const float3 &center, const float3 &prev, const float3 &next)
71{
72 const float3 v1 = math::normalize(prev - center);
73 const float3 v2 = math::normalize(next - center);
74 return math::normalize(v1 - v2);
75}
76
77static inline std::optional<float3> find_plane_intersection(const float3 &plane_point,
78 const float3 &plane_normal,
79 const float3 &from,
80 const float3 &to)
81{
82 const float lambda = line_plane_factor_v3(plane_point, plane_normal, from, to);
83 if (lambda <= 0.0f || lambda >= 1.0f) {
84 return std::nullopt;
85 }
86 return math::interpolate(from, to, lambda);
87}
88
89/* "Infinite" radius in case no limit is applied. */
90static const float unlimited_radius = FLT_MAX;
91
107static float calc_min_radius_v3v3(const float3 &p1, const float3 &p2, const float3 &dir)
108{
109 const float p1_dir = math::dot(p1, dir);
110 const float p2_dir = math::dot(p2, dir);
111 const float p2_sqr = math::length_squared(p2);
112 const float diff_dir = p1_dir - p2_dir;
113
114 const float u = [=]() {
115 if (diff_dir == 0.0f) {
116 const float p1_sqr = math::length_squared(p1);
117 return p1_sqr < p2_sqr ? 1.0f : 0.0f;
118 }
119
120 const float p = p2_dir / diff_dir;
121 const float3 diff = p1 - p2;
122 const float diff_sqr = math::length_squared(diff);
123 const float diff_p2 = math::dot(diff, p2);
124 const float q = (2 * diff_p2 * p2_dir - p2_sqr * diff_dir) / (diff_dir * diff_sqr);
125 if (p * p - q < 0) {
126 return 0.5f - std::copysign(0.5f, p);
127 }
128
129 return math::clamp(-p - math::sqrt(p * p - q) * std::copysign(1.0f, p), 0.0f, 1.0f);
130 }();
131
132 /* v is the determined minimal radius. In case p1 and p2 are the same, there is a
133 * simple proof for the following formula using the geometric mean theorem and Thales theorem. */
134 const float v = math::length_squared(math::interpolate(p2, p1, u)) /
135 (2 * math::interpolate(p2_dir, p1_dir, u));
136 if (v < 0 || !isfinite(v)) {
137 /* No limit to the radius from this segment. */
138 return unlimited_radius;
139 }
140 return v;
141}
142
143static float calc_radius_limit(const Span<float3> positions,
144 const bool is_cyclic,
145 const int spread,
146 const int point,
147 const float3 &direction)
148{
149 if (math::is_zero(direction)) {
150 return unlimited_radius;
151 }
152
153 const int point_num = positions.size();
154 const float3 &center = positions[point];
155
156 float result = unlimited_radius;
157 if (is_cyclic) {
158 /* Spread should be limited to half the points in the cyclic case. */
159 BLI_assert(spread <= point_num / 2);
160 /* Left side. */
161 for (const int line_i : IndexRange(spread)) {
162 const int from_i = (point - line_i - 2 + point_num) % point_num;
163 const int to_i = (point - line_i - 1 + point_num) % point_num;
164 const float limit = calc_min_radius_v3v3(
165 positions[from_i] - center, positions[to_i] - center, direction);
166 result = std::min(result, limit);
167 }
168 /* Right side. */
169 for (const int line_i : IndexRange(spread)) {
170 const int from_i = (point + line_i + 1 + point_num) % point_num;
171 const int to_i = (point + line_i + 2 + point_num) % point_num;
172 const float limit = calc_min_radius_v3v3(
173 positions[from_i] - center, positions[to_i] - center, direction);
174 result = std::min(result, limit);
175 }
176 }
177 else {
178 if (point == 0 || point >= point_num - 1) {
179 return unlimited_radius;
180 }
181 /* Left side. */
182 const int spread_left = std::min(spread, std::max(point - 2, 0));
183 for (const int line_i : IndexRange(spread_left)) {
184 const int from_i = std::max(point - line_i - 2, 0);
185 const int to_i = std::max(point - line_i - 1, 0);
186 const float limit = calc_min_radius_v3v3(
187 positions[from_i] - center, positions[to_i] - center, direction);
188 result = std::min(result, limit);
189 }
190 /* Right side. */
191 const int spread_right = std::min(spread, std::max(point_num - point - 2, 0));
192 for (const int line_i : IndexRange(spread_right)) {
193 const int from_i = std::min(point + line_i + 1, point_num - 1);
194 const int to_i = std::min(point + line_i + 2, point_num - 1);
195 const float limit = calc_min_radius_v3v3(
196 positions[from_i] - center, positions[to_i] - center, direction);
197 result = std::min(result, limit);
198 }
199 }
200 return result;
201}
202
206static bool find_envelope(const Span<float3> positions,
207 const bool is_cyclic,
208 const int spread,
209 const int point,
210 float3 &r_center,
211 float &r_radius)
212{
213 /* Compute a plane normal for intersections. */
214 const IndexRange points = positions.index_range();
215 const float3 &pos = positions[point];
216 const float3 &prev_pos =
217 positions[points.contains(point - 1) ? point - 1 : (is_cyclic ? points.last() : point)];
218 const float3 &next_pos =
219 positions[points.contains(point + 1) ? point + 1 : (is_cyclic ? points.first() : point)];
220 const float3 plane_normal = calculate_plane(pos, prev_pos, next_pos);
221 if (math::is_zero(plane_normal)) {
222 return false;
223 }
224
225 /* Find two intersections with maximal radii. */
226 float max_distance1 = 0.0f;
227 float max_distance2 = 0.0f;
228 float3 intersect1 = pos;
229 float3 intersect2 = pos;
230 for (const int line_i : IndexRange(spread + 2)) {
231 /* Raw indices, can be out of range. */
232 const int from_spread_i = point - spread - 1 + line_i;
233 const int to_spread_i = point + line_i;
234 /* Clamp or wrap to valid indices. */
235 const int from_i = is_cyclic ? (from_spread_i + points.size()) % points.size() :
236 std::max(from_spread_i, int(points.first()));
237 const int to_i = is_cyclic ? (to_spread_i + points.size()) % points.size() :
238 std::min(to_spread_i, int(points.last()));
239 const float3 &from_pos = positions[from_i];
240 const float3 &to_pos = positions[to_i];
241 const float3 line_delta = to_pos - from_pos;
242
243 const std::optional<float3> line_intersect = find_plane_intersection(
244 pos, plane_normal, from_pos, to_pos);
245 if (!line_intersect) {
246 continue;
247 }
248 const float3 line_direction = line_intersect.value() - pos;
249 const float line_distance = math::length(line_direction);
250
251 /* Diameter of a sphere centered in the plane, touching both #pos and the intersection line. */
252 const float cos_angle = math::abs(math::dot(plane_normal, line_delta)) /
253 math::length(line_delta);
254 const float diameter = line_distance * 2.0f * cos_angle / (1 + cos_angle);
255
256 if (line_i == 0) {
257 max_distance1 = diameter;
258 intersect1 = line_intersect.value();
259 continue;
260 }
261 /* Use as vector 1 or 2 based on primary direction. */
262 if (math::dot(intersect1 - pos, line_direction) >= 0.0f) {
263 if (diameter > max_distance1) {
264 intersect1 = line_intersect.value();
265 max_distance1 = diameter;
266 }
267 }
268 else {
269 if (diameter > max_distance2) {
270 intersect2 = line_intersect.value();
271 max_distance2 = diameter;
272 }
273 }
274 }
275
276 r_radius = 0.5f * (max_distance1 + max_distance2);
277 if (r_radius < FLT_EPSILON) {
278 return false;
279 }
280
281 const float3 new_center = 0.5f * (intersect1 + intersect2);
282 /* Apply radius limiting to not cross existing lines. */
283 const float3 dir = math::normalize(new_center - pos);
284 r_radius = std::min(r_radius, calc_radius_limit(positions, is_cyclic, spread, point, dir));
285
286 r_center = math::interpolate(
287 pos, new_center, 2.0f * r_radius / math::distance(intersect1, intersect2));
288
289 return true;
290}
291
294 const IndexMask &curves_mask)
295{
297 const bke::AttributeAccessor attributes = curves.attributes();
298 const MutableSpan<float3> positions = curves.positions_for_write();
299 const MutableSpan<float> radii = drawing.radii_for_write();
300 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
302 curves, emd.influence);
303 const VArray<bool> cyclic_flags = *attributes.lookup_or_default(
304 "cyclic", bke::AttrDomain::Curve, false);
305
306 /* Cache to avoid affecting neighboring point results when updating positions. */
307 const Array<float3> old_positions(positions.as_span());
308
309 curves_mask.foreach_index(
310 [&](const int64_t curve_i) {
311 const IndexRange points = points_by_curve[curve_i];
312 const bool cyclic = cyclic_flags[curve_i];
313 const int point_num = points.size();
314 const int spread = cyclic ? math::abs(((emd.spread + point_num / 2) % point_num) -
315 point_num / 2) :
316 std::min(emd.spread, point_num - 1);
317
318 for (const int64_t i : points.index_range()) {
319 const int64_t point_i = points[i];
320 const float weight = vgroup_weights[point_i];
321
322 float3 envelope_center;
323 float envelope_radius;
324 if (!find_envelope(old_positions.as_span().slice(points),
325 cyclic,
326 spread,
327 i,
328 envelope_center,
329 envelope_radius))
330 {
331 continue;
332 }
333
334 const float target_radius = radii[point_i] * emd.thickness + envelope_radius;
335 radii[point_i] = math::interpolate(radii[point_i], target_radius, weight);
336 positions[point_i] = math::interpolate(old_positions[point_i], envelope_center, weight);
337 }
338 },
340
341 drawing.tag_positions_changed();
342 curves.tag_radii_changed();
343}
344
346 /* Offset left and right from the source point. */
348 /* Number of points to skip. */
349 int skip;
350 /* Number of points in each envelope stroke. */
352 /* Material index assigned to new strokes. */
355 float strength;
356};
357
359 const ModifierEvalContext &ctx)
360{
361 EnvelopeInfo info;
362 info.spread = emd.spread;
363 info.skip = emd.skip;
366 info.points_per_curve = 0;
367 break;
369 info.points_per_curve = 2;
370 break;
372 info.points_per_curve = 2 * (2 + emd.skip);
373 break;
374 }
375 info.material_index = std::min(emd.mat_nr, ctx.object->totcol - 1);
376 info.thickness = emd.thickness;
377 info.strength = emd.strength;
378 return info;
379}
380
381static int curve_spread(const EnvelopeInfo &info, const int point_num, const bool is_cyclic_curve)
382{
383 /* Clamp spread in the cyclic case to half the curve size. */
384 return is_cyclic_curve ? std::min(info.spread, point_num / 2) : info.spread;
385}
386
388 const int point_num,
389 const bool is_cyclic_curve)
390{
391 const int spread = curve_spread(info, point_num, is_cyclic_curve);
392 /* Number of envelope strokes making up the envelope. */
393 const int num_strokes = point_num + spread - 1;
394 /* Skip strokes (only every n-th point generates strokes). */
395 const int num_strokes_simplified = (num_strokes + info.skip) / (1 + info.skip);
396 return num_strokes_simplified;
397}
398
424static void create_envelope_stroke_for_point(const IndexRange src_curve_points,
425 const bool src_curve_cyclic,
426 const int point,
427 const int spread,
428 const int base_length,
429 const MutableSpan<int> point_src_indices)
430{
431 const int point_num = src_curve_points.size();
432 BLI_assert(point_src_indices.size() == base_length * 2);
433
434 /* Clamp or wrap to ensure a valid index. */
435 auto get_index = [=](const int index) -> int {
436 return src_curve_cyclic ? (index + point_num) % point_num :
437 math::clamp(index, 0, point_num - 1);
438 };
439
440 for (const int i : IndexRange(base_length)) {
441 const int reverse_i = base_length - 1 - i;
442 const int point_left = get_index(point - spread + reverse_i);
443 const int point_right = get_index(point + reverse_i);
444 point_src_indices[i] = src_curve_points[point_left];
445 point_src_indices[base_length + i] = src_curve_points[point_right];
446 }
447}
448
450 const int src_curve_index,
451 const IndexRange src_curve_points,
452 const bool src_curve_cyclic,
453 const VArray<int> &src_material_indices,
454 const IndexRange dst_points,
455 const MutableSpan<int> curve_offsets,
456 const MutableSpan<int> material_indices,
457 const MutableSpan<int> curve_src_indices,
458 const MutableSpan<int> point_src_indices)
459{
460 const int src_point_num = src_curve_points.size();
461 const int spread = curve_spread(info, src_point_num, src_curve_cyclic);
462 const int num_strokes = curve_envelope_strokes_num(info, src_point_num, src_curve_cyclic);
463 const bool use_fills = info.points_per_curve > 2;
464 /* Length of continuous point ranges that get connected. */
465 const int base_length = use_fills ? 2 + info.skip : 1;
466
467 BLI_assert(curve_offsets.size() == num_strokes);
468 BLI_assert(material_indices.size() == num_strokes);
469 BLI_assert(curve_src_indices.size() == num_strokes);
470 BLI_assert(point_src_indices.size() == num_strokes * info.points_per_curve);
471
472 curve_src_indices.fill(src_curve_index);
473
474 /*
475 * Index range here goes beyond the point range:
476 * This adds points [i - spread, i + 1] as a curve.
477 * The total range covers [-spread - 1, spread + 1].
478 * Each span only gets added once since it repeats for neighboring points.
479 */
480
481 for (const int dst_i : IndexRange(num_strokes)) {
482 const int src_i = dst_i * (1 + info.skip);
483 const IndexRange dst_envelope_points = {dst_i * info.points_per_curve, info.points_per_curve};
484
485 curve_offsets[dst_i] = dst_points[dst_envelope_points.start()];
486 material_indices[dst_i] = info.material_index >= 0 ? info.material_index :
487 src_material_indices[src_curve_index];
488
489 create_envelope_stroke_for_point(src_curve_points,
490 src_curve_cyclic,
491 src_i,
492 spread,
493 base_length,
494 point_src_indices.slice(dst_envelope_points));
495 }
496}
497
498static void create_envelope_strokes(const EnvelopeInfo &info,
500 const IndexMask &curves_mask,
501 const bool keep_original)
502{
503 const bke::CurvesGeometry &src_curves = drawing.strokes();
504 const bke::AttributeAccessor src_attributes = src_curves.attributes();
505 const VArray<bool> src_cyclic = *src_attributes.lookup_or_default(
506 "cyclic", bke::AttrDomain::Curve, false);
507 const VArray<int> src_material_indices = *src_attributes.lookup_or_default(
508 "material_index", bke::AttrDomain::Curve, 0);
509 const int src_curves_num = src_curves.curves_num();
510 const int src_points_num = src_curves.points_num();
511
512 /* Count envelopes. */
513 Array<int> envelope_curves_by_curve(src_curves_num + 1, 0);
514 Array<int> envelope_points_by_curve(src_curves_num + 1, 0);
515 curves_mask.foreach_index([&](const int64_t src_curve_i) {
516 const IndexRange points = src_curves.points_by_curve()[src_curve_i];
517 const int curve_num = curve_envelope_strokes_num(info, points.size(), src_cyclic[src_curve_i]);
518 envelope_curves_by_curve[src_curve_i] = curve_num;
519 envelope_points_by_curve[src_curve_i] = info.points_per_curve * curve_num;
520 });
521 /* Ranges by source curve for envelope curves and points. */
522 const int dst_curve_start_offset = keep_original ? src_curves_num : 0;
523 const int dst_points_start_offset = keep_original ? src_points_num : 0;
524 const OffsetIndices envelope_curve_offsets = offset_indices::accumulate_counts_to_offsets(
525 envelope_curves_by_curve, dst_curve_start_offset);
526 const OffsetIndices envelope_point_offsets = offset_indices::accumulate_counts_to_offsets(
527 envelope_points_by_curve, dst_points_start_offset);
528 const int dst_curve_num = envelope_curve_offsets.total_size() + dst_curve_start_offset;
529 const int dst_point_num = envelope_point_offsets.total_size() + dst_points_start_offset;
530 if (dst_curve_num == 0 || dst_point_num == 0) {
531 return;
532 }
533
534 bke::CurvesGeometry dst_curves(dst_point_num, dst_curve_num);
535 bke::MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
536 bke::SpanAttributeWriter<int> dst_material_indices =
537 dst_attributes.lookup_or_add_for_write_span<int>("material_index", bke::AttrDomain::Curve);
538 bke::SpanAttributeWriter<bool> dst_cyclic = dst_attributes.lookup_or_add_for_write_span<bool>(
539 "cyclic", bke::AttrDomain::Curve);
540 /* Map each destination curve and point to its source. */
541 Array<int> src_curve_indices(dst_curve_num);
542 Array<int> src_point_indices(dst_point_num);
543
544 if (keep_original) {
545 /* Add indices to original data. */
546 dst_curves.offsets_for_write()
547 .slice(src_curves.curves_range())
548 .copy_from(src_curves.offsets().drop_back(1));
549
551 src_curve_indices.as_mutable_span().slice(src_curves.curves_range()));
553 src_point_indices.as_mutable_span().slice(src_curves.points_range()));
554
555 array_utils::copy(src_material_indices,
556 dst_material_indices.span.slice(src_curves.curves_range()));
557 }
558
559 curves_mask.foreach_index([&](const int64_t i) {
560 const bool src_curve_cyclic = src_cyclic[i];
561 const IndexRange src_curve_points = src_curves.points_by_curve()[i];
562 const IndexRange envelope_curves = envelope_curve_offsets[i];
563 const IndexRange envelope_points = envelope_point_offsets[i];
564
566 i,
567 src_curve_points,
568 src_curve_cyclic,
569 src_material_indices,
570 envelope_points,
571 dst_curves.offsets_for_write().slice(envelope_curves),
572 dst_material_indices.span.slice(envelope_curves),
573 src_curve_indices.as_mutable_span().slice(envelope_curves),
574 src_point_indices.as_mutable_span().slice(envelope_points));
575 });
576 dst_curves.offsets_for_write().last() = dst_point_num;
577
578 bke::gather_attributes(src_attributes,
581 {},
582 src_point_indices,
583 dst_attributes);
584 bke::gather_attributes(src_attributes,
587 bke::attribute_filter_from_skip_ref({"cyclic", "material_index"}),
588 src_curve_indices,
589 dst_attributes);
590
591 /* Apply thickness and strength factors. */
592 {
593 bke::SpanAttributeWriter radius_writer = dst_attributes.lookup_or_add_for_write_span<float>(
595 const IndexRange all_new_points = keep_original ?
596 IndexRange(src_curves.point_num,
597 dst_point_num - src_curves.point_num) :
598 IndexRange(dst_point_num);
599 for (const int point_i : all_new_points) {
600 radius_writer.span[point_i] *= info.thickness;
601 }
602 radius_writer.finish();
603 if (bke::SpanAttributeWriter<float> opacity_writer =
604 dst_attributes.lookup_or_add_for_write_span<float>(
606 {
607 for (const int point_i : all_new_points) {
608 opacity_writer.span[point_i] *= info.strength;
609 }
610 opacity_writer.finish();
611 }
612 }
613
614 dst_cyclic.finish();
615 dst_material_indices.finish();
616 dst_curves.update_curve_types();
617
618 drawing.strokes_for_write() = std::move(dst_curves);
619 drawing.tag_topology_changed();
620}
621
623 const ModifierEvalContext &ctx,
625{
626 const EnvelopeInfo info = get_envelope_info(emd, ctx);
627
629
630 IndexMaskMemory mask_memory;
632 ctx.object, drawing.strokes(), emd.influence, mask_memory);
633
634 const auto mode = GreasePencilEnvelopeModifierMode(emd.mode);
635 switch (mode) {
637 deform_drawing_as_envelope(emd, drawing, curves_mask);
638 break;
640 create_envelope_strokes(info, drawing, curves_mask, true);
641 break;
643 create_envelope_strokes(info, drawing, curves_mask, false);
644 break;
645 }
646}
647
649 const ModifierEvalContext *ctx,
650 bke::GeometrySet *geometry_set)
651{
653
654 auto *emd = reinterpret_cast<GreasePencilEnvelopeModifierData *>(md);
655
656 if (!geometry_set->has_grease_pencil()) {
657 return;
658 }
660 const int frame = grease_pencil.runtime->eval_frame;
661
662 IndexMaskMemory mask_memory;
664 grease_pencil, emd->influence, mask_memory);
665
667 grease_pencil, layer_mask, frame);
669 [&](Drawing *drawing) { modify_drawing(*emd, *ctx, *drawing); });
670}
671
672static void panel_draw(const bContext *C, Panel *panel)
673{
674 ui::Layout &layout = *panel->layout;
675
676 PointerRNA ob_ptr;
679 RNA_enum_get(ptr, "mode"));
680
681 layout.use_property_split_set(true);
682
683 layout.prop(ptr, "mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
684
685 layout.prop(ptr, "spread", UI_ITEM_NONE, std::nullopt, ICON_NONE);
686 layout.prop(ptr, "thickness", UI_ITEM_NONE, std::nullopt, ICON_NONE);
687
688 switch (mode) {
690 break;
693 layout.prop(ptr, "strength", UI_ITEM_NONE, std::nullopt, ICON_NONE);
694 layout.prop(ptr, "mat_nr", UI_ITEM_NONE, std::nullopt, ICON_NONE);
695 layout.prop(ptr, "skip", UI_ITEM_NONE, std::nullopt, ICON_NONE);
696 break;
697 }
698
699 if (ui::Layout *influence_panel = layout.panel_prop(
700 C, ptr, "open_influence_panel", IFACE_("Influence")))
701 {
705 }
706
707 modifier_error_message_draw(layout, ptr);
708}
709
714
715static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
716{
717 const auto *emd = reinterpret_cast<const GreasePencilEnvelopeModifierData *>(md);
718
719 writer->write_struct(emd);
720 modifier::greasepencil::write_influence_data(writer, &emd->influence);
721}
722
723static void blend_read(BlendDataReader *reader, ModifierData *md)
724{
725 auto *emd = reinterpret_cast<GreasePencilEnvelopeModifierData *>(md);
726
727 modifier::greasepencil::read_influence_data(reader, &emd->influence);
728}
729
731 /*idname*/ "GreasePencilEnvelope",
732 /*name*/ N_("Envelope"),
733 /*struct_name*/ "GreasePencilEnvelopeModifierData",
734 /*struct_size*/ sizeof(GreasePencilEnvelopeModifierData),
735 /*srna*/ &RNA_GreasePencilEnvelopeModifier,
739 /*icon*/ ICON_MOD_ENVELOPE,
740
741 /*copy_data*/ copy_data,
742
743 /*deform_verts*/ nullptr,
744 /*deform_matrices*/ nullptr,
745 /*deform_verts_EM*/ nullptr,
746 /*deform_matrices_EM*/ nullptr,
747 /*modify_mesh*/ nullptr,
748 /*modify_geometry_set*/ modify_geometry_set,
749
750 /*init_data*/ init_data,
751 /*required_data_mask*/ nullptr,
752 /*free_data*/ free_data,
753 /*is_disabled*/ nullptr,
754 /*update_depsgraph*/ nullptr,
755 /*depends_on_time*/ nullptr,
756 /*depends_on_normals*/ nullptr,
757 /*foreach_ID_link*/ foreach_ID_link,
758 /*foreach_tex_link*/ nullptr,
759 /*free_runtime_data*/ nullptr,
760 /*panel_register*/ panel_register,
761 /*blend_write*/ blend_write,
762 /*blend_read*/ blend_read,
763};
764
765} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
constexpr int64_t first() const
constexpr int64_t last(const int64_t n=0) const
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr bool contains(int64_t value) const
constexpr IndexRange index_range() const
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr Span< T > as_span() const
Definition BLI_span.hh:667
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
AttributeAccessor attributes() const
IndexRange curves_range() const
MutableSpan< int > offsets_for_write()
IndexRange points_range() const
OffsetIndices< int > points_by_curve() const
MutableAttributeAccessor attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
MutableSpan< float > radii_for_write()
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
constexpr T & last(const int64_t n=0) const
constexpr void copy_from(Span< T > values) const
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
constexpr Span drop_back(int64_t n) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IMETHOD Vector diff(const Vector &a, const Vector &b, double dt)
Definition frames.inl:1166
#define FLT_MAX
#define FLT_EPSILON
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void fill_index_range(MutableSpan< T > span, const T start=0)
auto attribute_filter_from_skip_ref(const Span< StringRef > skip)
void gather_attributes(AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, const IndexMask &selection, MutableAttributeAccessor dst_attributes)
constexpr ParallelGrainSize grain_size(int grain_size)
T length_squared(const VecBase< T, Size > &a)
T clamp(const T &a, const T &min, const T &max)
T sqrt(const T &a)
T distance(const T &a, const T &b)
T length(const VecBase< T, Size > &a)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
bool is_zero(const T &a)
T interpolate(const T &a, const T &b, const FactorT &t)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T abs(const T &a)
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)
VArray< float > get_influence_vertex_weights(const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data)
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 draw_vertex_group_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
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)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
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
int RNA_enum_get(PointerRNA *ptr, const char *name)
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 void create_envelope_strokes_for_curve(const EnvelopeInfo &info, const int src_curve_index, const IndexRange src_curve_points, const bool src_curve_cyclic, const VArray< int > &src_material_indices, const IndexRange dst_points, const MutableSpan< int > curve_offsets, const MutableSpan< int > material_indices, const MutableSpan< int > curve_src_indices, const MutableSpan< int > point_src_indices)
static const float unlimited_radius
@ eModifierType_GreasePencilEnvelope
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void create_envelope_stroke_for_point(const IndexRange src_curve_points, const bool src_curve_cyclic, const int point, const int spread, const int base_length, const MutableSpan< int > point_src_indices)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
ATTR_WARN_UNUSED_RESULT const BMVert * v
static float3 calculate_plane(const float3 &center, const float3 &prev, const float3 &next)
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
@ MOD_GREASE_PENCIL_ENVELOPE_FILLS
@ MOD_GREASE_PENCIL_ENVELOPE_SEGMENTS
@ MOD_GREASE_PENCIL_ENVELOPE_DEFORM
static float calc_radius_limit(const Span< float3 > positions, const bool is_cyclic, const int spread, const int point, const float3 &direction)
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
static void create_envelope_strokes(const EnvelopeInfo &info, bke::greasepencil::Drawing &drawing, const IndexMask &curves_mask, const bool keep_original)
static bool find_envelope(const Span< float3 > positions, const bool is_cyclic, const int spread, const int point, float3 &r_center, float &r_radius)
@ 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)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
VecBase< float, 3 > float3
float line_plane_factor_v3(const float plane_co[3], const float plane_no[3], const float l1[3], const float l2[3])
static float calc_min_radius_v3v3(const float3 &p1, const float3 &p2, const float3 &dir)
static int curve_spread(const EnvelopeInfo &info, const int point_num, const bool is_cyclic_curve)
static void deform_drawing_as_envelope(const GreasePencilEnvelopeModifierData &emd, bke::greasepencil::Drawing &drawing, const IndexMask &curves_mask)
static EnvelopeInfo get_envelope_info(const GreasePencilEnvelopeModifierData &emd, const ModifierEvalContext &ctx)
static int curve_envelope_strokes_num(const EnvelopeInfo &info, const int point_num, const bool is_cyclic_curve)
ModifierTypeInfo modifierType_GreasePencilEnvelope
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
static std::optional< float3 > find_plane_intersection(const float3 &plane_point, const float3 &plane_normal, const float3 &from, const float3 &to)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilModifierInfluenceData influence
GreasePencilEnvelopeModifierMode mode
ui::Layout * layout
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)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
uint get_index(uint i)
#define N_(msgid)