Blender V5.3
MOD_grease_pencil_tint.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 "MEM_guardedalloc.h"
10
11#include "BLI_math_matrix.hh"
12
13#include "DNA_material_types.h"
14#include "DNA_modifier_types.h"
15#include "DNA_scene_types.h"
16
17#include "BKE_colorband.hh"
18#include "BKE_colortools.hh"
19#include "BKE_curves.hh"
20#include "BKE_geometry_set.hh"
21#include "BKE_grease_pencil.hh"
22#include "BKE_idtype.hh"
23#include "BKE_lib_query.hh"
24#include "BKE_material.hh"
25#include "BKE_modifier.hh"
26#include "BKE_screen.hh"
27
28#include "BLO_read_write.hh"
29
31
32#include "UI_interface.hh"
34#include "UI_resources.hh"
35
36#include "BLT_translation.hh"
37
38#include "WM_types.hh"
39
40#include "RNA_access.hh"
41#include "RNA_enum_types.hh"
42#include "RNA_prototypes.hh"
43
45#include "MOD_modifiertypes.hh"
46#include "MOD_ui_common.hh"
47
48namespace blender {
49
51
52static void init_data(ModifierData *md)
53{
54 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
57
58 /* Add default color ramp. */
59 tmd->color_ramp = BKE_colorband_add(false);
60 if (tmd->color_ramp) {
61 BKE_colorband_init(tmd->color_ramp, true);
62 CBData *data = tmd->color_ramp->data;
63 data[0].r = data[0].g = data[0].b = data[0].a = 1.0f;
64 data[0].pos = 0.0f;
65 data[1].r = data[1].g = data[1].b = 0.0f;
66 data[1].a = 1.0f;
67 data[1].pos = 1.0f;
68
69 tmd->color_ramp->tot = 2;
70 }
71}
72
73static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
74{
75 const auto *tmd = reinterpret_cast<const GreasePencilTintModifierData *>(md);
76 auto *ttmd = reinterpret_cast<GreasePencilTintModifierData *>(target);
77
79 MEM_SAFE_DELETE(ttmd->color_ramp);
80
81 BKE_modifier_copydata_generic(md, target, flag);
82 modifier::greasepencil::copy_influence_data(&tmd->influence, &ttmd->influence, flag);
83
84 if (tmd->color_ramp) {
85 ttmd->color_ramp = MEM_dupalloc(tmd->color_ramp);
86 }
87}
88
89static void free_data(ModifierData *md)
90{
91 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
93
94 MEM_SAFE_DELETE(tmd->color_ramp);
95}
96
97static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
98{
99 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
100 modifier::greasepencil::foreach_influence_ID_link(&tmd->influence, ob, walk, user_data);
101 walk(user_data, ob, reinterpret_cast<ID **>(&tmd->object), IDWALK_CB_NOP);
102}
103
106{
107 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
108 fn.single(tmd->color);
110}
111
112static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
113{
114 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
115 if (tmd->tint_mode == MOD_GREASE_PENCIL_TINT_GRADIENT) {
116 return tmd->object == nullptr;
117 }
118 return false;
119}
120
122{
123 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
124 if (tmd->object != nullptr) {
126 ctx->node, tmd->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Tint Modifier");
127 }
129 ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Tint Modifier");
130}
131
133 const ColorGeometry4f &material_color)
134{
135 /* When input alpha is zero, replace with material color. */
136 return (input_color.a == 0.0f && material_color.a > 0.0f) ? material_color : input_color;
137}
138
140 const ColorGeometry4f &input_color,
141 const float factor)
142{
143 const float3 rgb = math::interpolate(
144 float3(input_color.r, input_color.g, input_color.b), float3(tmd.color), factor);
145 /* Alpha is unchanged. */
146 return ColorGeometry4f(rgb[0], rgb[1], rgb[2], input_color.a);
147}
148
150 const float4x4 &matrix,
151 const float3 &position,
152 const ColorGeometry4f &input_color,
153 const float factor)
154{
155 const float3 gradient_pos = math::transform_point(matrix, position);
156 const float gradient_factor = std::clamp(
157 math::safe_divide(math::length(gradient_pos), tmd.radius), 0.0f, 1.0f);
158
159 float4 gradient_color;
160 BKE_colorband_evaluate(tmd.color_ramp, gradient_factor, gradient_color);
161
162 const float3 input_rgb = {input_color.r, input_color.g, input_color.b};
163 /* GP2 compatibility: ignore vertex group factor and use the plain modifier setting for
164 * RGB mixing. */
165 const float3 rgb = math::interpolate(
166 input_rgb, gradient_color.xyz(), tmd.factor * gradient_color.w);
167 /* GP2 compatibility: use vertex group factor for alpha. */
168 return ColorGeometry4f(rgb[0], rgb[1], rgb[2], factor);
169}
170
174 const IndexMask &curves_mask,
175 const MutableSpan<ColorGeometry4f> vertex_colors)
176{
177 const bool use_curve = (tmd.influence.flag & GREASE_PENCIL_INFLUENCE_USE_CUSTOM_CURVE);
178 const bool use_weight_as_factor = (tmd.flag & MOD_GREASE_PENCIL_TINT_USE_WEIGHT_AS_FACTOR);
179 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
180
181 bke::AttributeAccessor attributes = curves.attributes();
182 const VArray<int> stroke_materials = *attributes.lookup_or_default<int>(
183 "material_index", bke::AttrDomain::Curve, 0);
185 curves, tmd.influence);
186
187 /* Common input color and base factor calculation. */
188 auto get_material_color = [&](const int64_t curve_i) {
189 const Material *ma = BKE_object_material_get(&ob, stroke_materials[curve_i] + 1);
190 const MaterialGPencilStyle *gp_style = ma ? ma->gp_style : nullptr;
191 if (!gp_style) {
192 return ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f);
193 }
194 return ColorGeometry4f(gp_style->stroke_rgba);
195 };
196
197 auto get_point_factor = [&](const int64_t point_i) {
198 const float weight = vgroup_weights[point_i];
199 if (use_weight_as_factor) {
200 return weight;
201 }
202 return tmd.factor * weight;
203 };
204
206 switch (tint_mode) {
208 curves_mask.foreach_index(
209 [&](const int64_t curve_i) {
210 const ColorGeometry4f material_color = get_material_color(curve_i);
211
212 const IndexRange points = points_by_curve[curve_i];
213 for (const int64_t i : points.index_range()) {
214 const int64_t point_i = points[i];
215 const float curve_input = points.size() >= 2 ?
216 (float(i) / float(points.size() - 1)) :
217 0.0f;
218 const float curve_factor = use_curve ?
220 tmd.influence.custom_curve, 0, curve_input) :
221 1.0f;
222 vertex_colors[point_i] = apply_uniform_tint(
223 tmd,
224 get_base_color(vertex_colors[point_i], material_color),
225 get_point_factor(point_i) * curve_factor);
226 }
227 },
229 break;
230 }
232 if (tmd.object == nullptr) {
233 return;
234 }
235
236 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
237 const Span<float3> positions = curves.positions();
238 /* Transforms points to the gradient object space. */
239 const float4x4 matrix = tmd.object->world_to_object() * ob.object_to_world();
240
241 curves_mask.foreach_index(
242 [&](const int64_t curve_i) {
243 const ColorGeometry4f material_color = get_material_color(curve_i);
244
245 const IndexRange points = points_by_curve[curve_i];
246 for (const int64_t point_i : points) {
247 vertex_colors[point_i] = apply_gradient_tint(
248 tmd,
249 matrix,
250 positions[point_i],
251 get_base_color(vertex_colors[point_i], material_color),
252 get_point_factor(point_i));
253 }
254 },
256 break;
257 }
258 }
259}
260
261static void modify_fill_color(Object &ob,
263 Drawing &drawing,
264 const IndexMask &curves_mask)
265{
266 const bool use_weight_as_factor = (tmd.flag & MOD_GREASE_PENCIL_TINT_USE_WEIGHT_AS_FACTOR);
267 const bke::CurvesGeometry &curves = drawing.strokes();
268 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
270
271 /* Check early before getting attribute writers. */
272 if (tint_mode == MOD_GREASE_PENCIL_TINT_GRADIENT && tmd.object == nullptr) {
273 return;
274 }
275
277 /* Fill color per stroke. */
279 const VArray<int> stroke_materials = *attributes.lookup_or_default<int>(
280 "material_index", bke::AttrDomain::Curve, 0);
282 curves, tmd.influence);
283
284 /* Common input color and base factor calculation. */
285 auto get_material_color = [&](const int64_t curve_i) {
286 const Material *ma = BKE_object_material_get(&ob, stroke_materials[curve_i] + 1);
287 const MaterialGPencilStyle *gp_style = ma ? ma->gp_style : nullptr;
288 if (!gp_style) {
289 return ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f);
290 }
291 return ColorGeometry4f(gp_style->fill_rgba);
292 };
293
294 auto get_curve_factor = [&](const int64_t curve_i) {
295 /* Use the first stroke point as vertex weight. */
296 const IndexRange points = points_by_curve[curve_i];
297 const float vgroup_weight_first = vgroup_weights[points.first()];
298 float stroke_weight = vgroup_weight_first;
299 if (points.is_empty() || (stroke_weight <= 0.0f)) {
300 return 0.0f;
301 }
302 if (use_weight_as_factor) {
303 return stroke_weight;
304 }
305 return tmd.factor * stroke_weight;
306 };
307
308 switch (tint_mode) {
310 curves_mask.foreach_index(
311 [&](int64_t curve_i) {
312 const ColorGeometry4f material_color = get_material_color(curve_i);
313 fill_colors[curve_i] = apply_uniform_tint(
314 tmd,
315 get_base_color(fill_colors[curve_i], material_color),
316 get_curve_factor(curve_i));
317 },
319 break;
320 }
322 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
323 const Span<float3> positions = curves.positions();
324 /* Transforms points to the gradient object space. */
325 const float4x4 matrix = tmd.object->world_to_object() * ob.object_to_world();
326
327 curves_mask.foreach_index(
328 [&](int64_t curve_i) {
329 const ColorGeometry4f material_color = get_material_color(curve_i);
330 /* Use the first stroke point for gradient position. */
331 const IndexRange points = points_by_curve[curve_i];
332 const float3 pos = points.is_empty() ? float3(0.0f, 0.0f, 0.0f) :
333 positions[points.first()];
334
335 fill_colors[curve_i] = apply_gradient_tint(
336 tmd,
337 matrix,
338 pos,
339 get_base_color(fill_colors[curve_i], material_color),
340 get_curve_factor(curve_i));
341 },
343 break;
344 }
345 }
346}
347
350 const IndexMask &curves_mask)
351{
352 /* Only when factor is greater than 1. */
353 if (tmd.factor <= 1.0f) {
354 return;
355 }
356
357 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
358 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
360 "opacity", bke::AttrDomain::Point);
361 if (!opacities) {
362 return;
363 }
364
365 curves_mask.foreach_index(
366 [&](const int64_t curve_i) {
367 const IndexRange points = points_by_curve[curve_i];
368 for (const int64_t point_i : points) {
369 opacities.span[point_i] = std::clamp(
370 opacities.span[point_i] + tmd.factor - 1.0f, 0.0f, 1.0f);
371 }
372 },
374
375 opacities.finish();
376}
377
378static void modify_curves(ModifierData &md, const ModifierEvalContext &ctx, Drawing &drawing)
379{
380 auto &tmd = reinterpret_cast<GreasePencilTintModifierData &>(md);
382
383 IndexMaskMemory mask_memory;
385 ctx.object, curves, tmd.influence, mask_memory);
386
387 /* Factor > 1.0 also affects the opacity of the stroke. */
388 modify_opacity(tmd, curves, curves_mask);
389
390 switch (tmd.color_mode) {
393 *ctx.object, tmd, curves, curves_mask, drawing.vertex_colors_for_write());
394 break;
396 modify_fill_color(*ctx.object, tmd, drawing, curves_mask);
397 break;
400 *ctx.object, tmd, curves, curves_mask, drawing.vertex_colors_for_write());
401 modify_fill_color(*ctx.object, tmd, drawing, curves_mask);
402 break;
405 break;
406 }
407}
408
410 const ModifierEvalContext *ctx,
411 bke::GeometrySet *geometry_set)
412{
413 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
414
415 if (!geometry_set->has_grease_pencil()) {
416 return;
417 }
419 const int frame = grease_pencil.runtime->eval_frame;
420
421 IndexMaskMemory mask_memory;
423 grease_pencil, tmd->influence, mask_memory);
425 grease_pencil, layer_mask, frame);
427 [&](Drawing *drawing) { modify_curves(*md, *ctx, *drawing); });
428}
429
430static void panel_draw(const bContext *C, Panel *panel)
431{
432 ui::Layout &layout = *panel->layout;
433
434 PointerRNA ob_ptr;
436
437 layout.use_property_split_set(true);
438
440 RNA_enum_get(ptr, "tint_mode"));
441 const bool use_weight_as_factor = RNA_boolean_get(ptr, "use_weight_as_factor");
442
443 layout.prop(ptr, "color_mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
444
445 ui::Layout &row = layout.row(true);
446 row.active_set(!use_weight_as_factor);
447 row.prop(ptr, "factor", UI_ITEM_NONE, std::nullopt, ICON_NONE);
448 row.prop(ptr, "use_weight_as_factor", UI_ITEM_NONE, "", ICON_MOD_VERTEX_WEIGHT);
449
450 layout.prop(ptr, "tint_mode", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
451 switch (tint_mode) {
453 layout.prop(ptr, "color", UI_ITEM_NONE, std::nullopt, ICON_NONE);
454 break;
456 ui::Layout &col = layout.column(false);
457 col.use_property_split_set(false);
458 template_color_ramp(&col, ptr, "color_ramp", true);
459 layout.separator();
460 layout.prop(ptr, "object", UI_ITEM_NONE, std::nullopt, ICON_NONE);
461 layout.prop(ptr, "radius", UI_ITEM_NONE, std::nullopt, ICON_NONE);
462 break;
463 }
464
465 if (ui::Layout *influence_panel = layout.panel_prop(
466 C, ptr, "open_influence_panel", IFACE_("Influence")))
467 {
472 }
473
474 modifier_error_message_draw(layout, ptr);
475}
476
481
482static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
483{
484 const auto *tmd = reinterpret_cast<const GreasePencilTintModifierData *>(md);
485
486 writer->write_struct(tmd);
487 modifier::greasepencil::write_influence_data(writer, &tmd->influence);
488 if (tmd->color_ramp) {
489 writer->write_struct(tmd->color_ramp);
490 }
491}
492
493static void blend_read(BlendDataReader *reader, ModifierData *md)
494{
495 auto *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
496
497 modifier::greasepencil::read_influence_data(reader, &tmd->influence);
498 BLO_read_struct(reader, ColorBand, &tmd->color_ramp);
499}
500
502 /*idname*/ "GreasePencilTint",
503 /*name*/ N_("Tint"),
504 /*struct_name*/ "GreasePencilTintModifierData",
505 /*struct_size*/ sizeof(GreasePencilTintModifierData),
506 /*srna*/ &RNA_GreasePencilTintModifier,
510 /*icon*/ ICON_MOD_TINT,
511
512 /*copy_data*/ copy_data,
513
514 /*deform_verts*/ nullptr,
515 /*deform_matrices*/ nullptr,
516 /*deform_verts_EM*/ nullptr,
517 /*deform_matrices_EM*/ nullptr,
518 /*modify_mesh*/ nullptr,
519 /*modify_geometry_set*/ modify_geometry_set,
520
521 /*init_data*/ init_data,
522 /*required_data_mask*/ nullptr,
523 /*free_data*/ free_data,
524 /*is_disabled*/ is_disabled,
525 /*update_depsgraph*/ update_depsgraph,
526 /*depends_on_time*/ nullptr,
527 /*depends_on_normals*/ nullptr,
528 /*foreach_ID_link*/ foreach_ID_link,
529 /*foreach_tex_link*/ nullptr,
530 /*free_runtime_data*/ nullptr,
531 /*panel_register*/ panel_register,
532 /*blend_write*/ blend_write,
533 /*blend_read*/ blend_read,
534 /*foreach_cache*/ nullptr,
535 /*foreach_working_space_color*/ foreach_working_space_color,
536};
537
538} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define BLO_read_struct(reader, struct_name, ptr_p)
#define IFACE_(msgid)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define BLI_assert_unreachable()
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
ChannelStorageType r
ChannelStorageType g
ChannelStorageType b
ChannelStorageType a
constexpr int64_t first() const
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr IndexRange index_range() const
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) 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
MutableSpan< ColorGeometry4f > fill_colors_for_write()
MutableSpan< ColorGeometry4f > vertex_colors_for_write()
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define position
constexpr ParallelGrainSize grain_size(int grain_size)
T safe_divide(const T &a, const T &b)
T length(const VecBase< T, Size > &a)
T interpolate(const T &a, const T &b, const FactorT &t)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void draw_custom_curve_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
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 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)
__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
void BKE_colorband_init(ColorBand *coba, bool rangetype)
Definition colorband.cc:25
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
static ColorGeometry4f apply_uniform_tint(const GreasePencilTintModifierData &tmd, const ColorGeometry4f &input_color, const float factor)
Material * BKE_object_material_get(Object *ob, short act)
static void modify_curves(ModifierData &md, const ModifierEvalContext &ctx, Drawing &drawing, bke::GreasePencilDrawingEditHints *edit_hints)
@ eModifierType_GreasePencilTint
static void foreach_working_space_color(ModifierData *md, const IDTypeForeachColorFunctionCallback &fn)
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)
ColorBand * BKE_colorband_add(bool rangetype)
Definition colorband.cc:301
@ GREASE_PENCIL_INFLUENCE_USE_CUSTOM_CURVE
bool BKE_colorband_evaluate(const ColorBand *coba, float in, float out[4])
Definition colorband.cc:399
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
MatBase< float, 4, 4 > float4x4
void BKE_colorband_foreach_working_space_color(ColorBand *coba, const IDTypeForeachColorFunctionCallback &fn)
Definition colorband.cc:655
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)
static void modify_fill_color(Object &ob, const GreasePencilColorModifierData &cmd, Drawing &drawing, const IndexMask &curves_mask)
ModifierTypeInfo modifierType_GreasePencilTint
@ MOD_GREASE_PENCIL_TINT_GRADIENT
@ MOD_GREASE_PENCIL_TINT_UNIFORM
BMesh const char void * data
static ColorGeometry4f get_base_color(const ColorGeometry4f &input_color, const ColorGeometry4f &material_color)
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
static ColorGeometry4f apply_gradient_tint(const GreasePencilTintModifierData &tmd, const float4x4 &matrix, const float3 &position, const ColorGeometry4f &input_color, const float factor)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
static void modify_stroke_color(Object &ob, const GreasePencilColorModifierData &cmd, bke::CurvesGeometry &curves, const IndexMask &curves_mask, const MutableSpan< ColorGeometry4f > vertex_colors)
static void blend_read(BlendDataReader *, ModifierData *md)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void modify_opacity(const GreasePencilTintModifierData &tmd, bke::CurvesGeometry &curves, const IndexMask &curves_mask)
static void panel_draw(const bContext *, Panel *panel)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
VecBase< float, 3 > float3
static bool is_disabled(const Scene *, ModifierData *md, bool)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
@ MOD_GREASE_PENCIL_COLOR_HARDNESS
@ MOD_GREASE_PENCIL_COLOR_STROKE
@ MOD_GREASE_PENCIL_TINT_USE_WEIGHT_AS_FACTOR
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilModifierInfluenceFlag flag
GreasePencilModifierInfluenceData influence
GreasePencilTintModifierMode tint_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)
void active_set(bool active)
Layout & column(bool align)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
Layout & row(bool align)
#define N_(msgid)