Blender V5.3
MOD_grease_pencil_noise.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_hash_c.hh"
10#include "BLI_math_vector.hh"
11
12#include "BLT_translation.hh"
13
14#include "BLO_read_write.hh"
15
17#include "DNA_object_types.h"
18#include "DNA_screen_types.h"
19
20#include "BKE_colortools.hh"
21#include "BKE_curves.hh"
22#include "BKE_geometry_set.hh"
23#include "BKE_grease_pencil.hh"
24
26#include "UI_resources.hh"
27
29#include "MOD_ui_common.hh"
30
31#include "RNA_access.hh"
32#include "RNA_prototypes.hh"
33
34namespace blender {
35
42
49
50static void copy_data(const ModifierData *md, ModifierData *target, int flag)
51{
53 reinterpret_cast<const GreasePencilNoiseModifierData *>(md);
54 GreasePencilNoiseModifierData *tgmd = reinterpret_cast<GreasePencilNoiseModifierData *>(target);
55
56 BKE_modifier_copydata_generic(md, target, flag);
58}
59
60static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
61{
63 reinterpret_cast<const GreasePencilNoiseModifierData *>(md);
64
65 writer->write_struct(mmd);
67}
68
74
75static bool depends_on_time(Scene * /*scene*/, ModifierData *md)
76{
78 return (mmd->flag & GP_NOISE_USE_RANDOM) != 0;
79}
80
81static Array<float> noise_table(const int len, const int offset, const int seed)
82{
83 Array<float> table(len);
84 for (int i = 0; i < len; i++) {
85 table[i] = BLI_hash_int_01(BLI_hash_int_2d(seed, i + offset + 1));
86 }
87 return table;
88}
89
94 const Object &ob,
95 const int ctime,
96 const int start_frame_number,
98{
100 bke::CurvesGeometry &strokes = drawing.strokes_for_write();
102 if (strokes.is_empty()) {
103 return;
104 }
105
106 IndexMaskMemory memory;
108 &ob, strokes, mmd.influence, memory);
109
110 const bool use_curve = (mmd.influence.flag & GREASE_PENCIL_INFLUENCE_USE_CUSTOM_CURVE) != 0;
111 const bool is_keyframe = (mmd.noise_mode == GP_NOISE_RANDOM_KEYFRAME);
112
113 /* Sanitize as it can create out of bound reads. */
114 const float noise_scale = math::clamp(mmd.noise_scale, 0.0f, 1.0f);
115
116 if (filtered_strokes.is_empty()) {
117 return;
118 }
119
120 int seed = mmd.seed;
121 /* Make sure different modifiers get different seeds. */
122 seed += BLI_hash_string(ob.id.name + 2);
123 seed += BLI_hash_string(mmd.modifier.name);
124 if (mmd.flag & GP_NOISE_USE_RANDOM) {
125 if (!is_keyframe) {
126 seed += math::floor(ctime / mmd.step);
127 }
128 else {
129 /* If change every keyframe, use the last keyframe. */
130 seed += start_frame_number;
131 }
132 }
133
134 const OffsetIndices<int> points_by_curve = strokes.points_by_curve();
136 strokes, mmd.influence);
137
138 auto get_weight = [&](const IndexRange points, const int point_i) {
139 const float vertex_weight = vgroup_weights[points[point_i]];
140 if (!use_curve) {
141 return vertex_weight;
142 }
143 const float value = float(point_i) / float(points.size() - 1);
144 return vertex_weight * BKE_curvemapping_evaluateF(mmd.influence.custom_curve, 0, value);
145 };
146
147 auto get_noise = [](const Span<float> noise_table, const float value) {
148 return math::interpolate(noise_table[int(math::floor(value))],
149 noise_table[int(math::ceil(value))],
150 math::fract(value));
151 };
152
153 if (mmd.factor > 0.0f) {
154 const Span<float3> curve_plane_normals = drawing.curve_plane_normals();
155 const Span<float3> tangents = strokes.evaluated_tangents();
156 MutableSpan<float3> positions = strokes.positions_for_write();
157
158 filtered_strokes.foreach_index(
159 [&](const int stroke_i) {
160 const IndexRange points = points_by_curve[stroke_i];
161 const int noise_len = math::ceil(points.size() * noise_scale) + 2;
162 const Array<float> table = noise_table(
163 noise_len, int(math::floor(mmd.noise_offset)), seed + 2 + stroke_i);
164 for (const int i : points.index_range()) {
165 const int point = points[i];
166 float weight = get_weight(points, i);
167 /* Vector orthogonal to normal. */
168 const float3 bi_normal = math::normalize(
169 math::cross(tangents[point], curve_plane_normals[stroke_i]));
170 const float noise = get_noise(table, i * noise_scale + math::fract(mmd.noise_offset));
171 positions[point] += bi_normal * (noise * 2.0f - 1.0f) * weight * mmd.factor * 0.1f;
172 }
173 },
175 drawing.tag_positions_changed();
176 }
177
178 if (mmd.factor_thickness > 0.0f) {
179 MutableSpan<float> radii = drawing.radii_for_write();
180
181 filtered_strokes.foreach_index(
182 [&](const int stroke_i) {
183 const IndexRange points = points_by_curve[stroke_i];
184 const int noise_len = math::ceil(points.size() * noise_scale) + 2;
185 const Array<float> table = noise_table(
186 noise_len, int(math::floor(mmd.noise_offset)), seed + stroke_i);
187 for (const int i : points.index_range()) {
188 const int point = points[i];
189 const float weight = get_weight(points, i);
190 const float noise = get_noise(table, i * noise_scale + math::fract(mmd.noise_offset));
191 radii[point] *= math::max(1.0f + (noise * 2.0f - 1.0f) * weight * mmd.factor_thickness,
192 0.0f);
193 }
194 },
196 }
197
198 if (mmd.factor_strength > 0.0f) {
199 MutableSpan<float> opacities = drawing.opacities_for_write();
200
201 filtered_strokes.foreach_index(
202 [&](const int stroke_i) {
203 const IndexRange points = points_by_curve[stroke_i];
204 const int noise_len = math::ceil(points.size() * noise_scale) + 2;
205 const Array<float> table = noise_table(
206 noise_len, int(math::floor(mmd.noise_offset)), seed + 3 + stroke_i);
207 for (const int i : points.index_range()) {
208 const int point = points[i];
209 const float weight = get_weight(points, i);
210 const float noise = get_noise(table, i * noise_scale + math::fract(mmd.noise_offset));
211 opacities[point] *= math::max(1.0f - noise * weight * mmd.factor_strength, 0.0f);
212 }
213 },
215 }
216
217 if (mmd.factor_uvs > 0.0f) {
218 if (bke::SpanAttributeWriter<float> rotations = attributes.lookup_or_add_for_write_span<float>(
219 "rotation", bke::AttrDomain::Point))
220 {
221 filtered_strokes.foreach_index(
222 [&](const int stroke_i) {
223 const IndexRange points = points_by_curve[stroke_i];
224 const int noise_len = math::ceil(points.size() * noise_scale) + 2;
225 const Array<float> table = noise_table(
226 noise_len, int(math::floor(mmd.noise_offset)), seed + 4 + stroke_i);
227 for (const int i : points.index_range()) {
228 const int point = points[i];
229 const float weight = get_weight(points, i);
230 const float noise = get_noise(table,
231 i * noise_scale + math::fract(mmd.noise_offset));
232 const float delta_rot = (noise * 2.0f - 1.0f) * weight * mmd.factor_uvs * M_PI_2;
233 rotations.span[point] = math::clamp(
234 rotations.span[point] + delta_rot, float(-M_PI_2), float(M_PI_2));
235 }
236 },
238 rotations.finish();
239 }
240 }
241}
242
244 const ModifierEvalContext *ctx,
245 bke::GeometrySet *geometry_set)
246{
247 const auto *mmd = reinterpret_cast<GreasePencilNoiseModifierData *>(md);
248
249 if (!geometry_set->has_grease_pencil()) {
250 return;
251 }
252
253 if (!mmd->factor && !mmd->factor_strength && !mmd->factor_thickness && !mmd->factor_uvs) {
254 return;
255 }
256
258 const int current_frame = grease_pencil.runtime->eval_frame;
259
260 IndexMaskMemory mask_memory;
262 grease_pencil, mmd->influence, mask_memory);
265
267 drawing_infos, [&](const modifier::greasepencil::FrameDrawingInfo &info) {
268 deform_drawing(*mmd, *ctx->object, current_frame, info.start_frame_number, *info.drawing);
269 });
270}
271
272static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
273{
275
277}
278
279static void panel_draw(const bContext *C, Panel *panel)
280{
281 ui::Layout &layout = *panel->layout;
282
284
285 layout.use_property_split_set(true);
286
287 ui::Layout &col = layout.column(false);
288 col.prop(ptr, "factor", UI_ITEM_NONE, IFACE_("Position"), ICON_NONE);
289 col.prop(ptr,
290 "factor_strength",
293 ICON_NONE);
294 col.prop(ptr, "factor_thickness", UI_ITEM_NONE, IFACE_("Thickness"), ICON_NONE);
295 col.prop(ptr, "factor_uvs", UI_ITEM_NONE, IFACE_("UV"), ICON_NONE);
296 col.prop(ptr, "noise_scale", UI_ITEM_NONE, std::nullopt, ICON_NONE);
297 col.prop(ptr, "noise_offset", UI_ITEM_NONE, std::nullopt, ICON_NONE);
298 col.prop(ptr, "seed", UI_ITEM_NONE, std::nullopt, ICON_NONE);
299 ui::PanelLayout random_panel_layout = layout.panel_prop_with_bool_header(
300 C, ptr, "open_random_panel", ptr, "use_random", IFACE_("Random"));
301 if (ui::Layout *random_layout = random_panel_layout.body) {
302 ui::Layout &random_col = random_layout->column(false);
303 random_col.active_set(RNA_boolean_get(ptr, "use_random"));
304
305 random_col.prop(ptr, "random_mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
306 const int mode = RNA_enum_get(ptr, "random_mode");
307 if (mode != GP_NOISE_RANDOM_KEYFRAME) {
308 random_col.prop(ptr, "step", UI_ITEM_NONE, std::nullopt, ICON_NONE);
309 }
310 }
311
312 if (ui::Layout *influence_panel = layout.panel_prop(
313 C, ptr, "open_influence_panel", IFACE_("Influence")))
314 {
319 }
320
321 modifier_error_message_draw(layout, ptr);
322}
323
328
330 /*idname*/ "GreasePencilNoiseModifier",
331 /*name*/ N_("Noise"),
332 /*struct_name*/ "GreasePencilNoiseModifierData",
333 /*struct_size*/ sizeof(GreasePencilNoiseModifierData),
334 /*srna*/ &RNA_GreasePencilNoiseModifier,
336 /*flags*/
339 /*icon*/ ICON_GREASEPENCIL,
340
341 /*copy_data*/ copy_data,
342
343 /*deform_verts*/ nullptr,
344 /*deform_matrices*/ nullptr,
345 /*deform_verts_EM*/ nullptr,
346 /*deform_matrices_EM*/ nullptr,
347 /*modify_mesh*/ nullptr,
348 /*modify_geometry_set*/ modify_geometry_set,
349
350 /*init_data*/ init_data,
351 /*required_data_mask*/ nullptr,
352 /*free_data*/ free_data,
353 /*is_disabled*/ nullptr,
354 /*update_depsgraph*/ nullptr,
355 /*depends_on_time*/ depends_on_time,
356 /*depends_on_normals*/ nullptr,
357 /*foreach_ID_link*/ foreach_ID_link,
358 /*foreach_tex_link*/ nullptr,
359 /*free_runtime_data*/ nullptr,
360 /*panel_register*/ panel_register,
361 /*blend_write*/ blend_write,
362 /*blend_read*/ blend_read,
363};
364
365} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
#define M_PI_2
#define BLT_I18NCONTEXT_ID_GPENCIL
#define CTX_IFACE_(context, msgid)
#define IFACE_(msgid)
Object is a sort of wrapper for general info.
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
constexpr int64_t size() const
constexpr IndexRange index_range() const
Span< float3 > evaluated_tangents() const
MutableSpan< float3 > positions_for_write()
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())
Span< float3 > curve_plane_normals() const
MutableSpan< float > opacities_for_write()
MutableSpan< float > radii_for_write()
bke::CurvesGeometry & strokes_for_write()
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
constexpr ParallelGrainSize grain_size(int grain_size)
T clamp(const T &a, const T &min, const T &max)
T floor(const T &a)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
T interpolate(const T &a, const T &b, const FactorT &t)
T fract(const T &a)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T ceil(const T &a)
T max(const T &a, const T &b)
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)
Vector< FrameDrawingInfo > get_drawing_infos_by_frame(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)
VArray< float > get_influence_vertex_weights(const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data)
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)
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)
ModifierTypeInfo modifierType_GreasePencilNoise
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)
BLI_INLINE unsigned int BLI_hash_int_2d(unsigned int kx, unsigned int ky)
Definition BLI_hash_c.hh:53
static bool depends_on_time(Scene *, ModifierData *)
Definition MOD_build.cc:46
@ eModifierType_GreasePencilNoise
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
@ GREASE_PENCIL_INFLUENCE_USE_CUSTOM_CURVE
BLI_INLINE float BLI_hash_int_01(unsigned int k)
Definition BLI_hash_c.hh:94
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
static void deform_drawing(const ModifierData &md, const Object &ob, bke::greasepencil::Drawing &drawing)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
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
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
static Array< float > noise_table(int len, int offset, int seed)
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
char name[258]
Definition DNA_ID.h:433
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)
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)