Blender V5.3
sculpt_randomize.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
5#include "BLI_hash_c.hh"
6#include "BLI_math_vector.hh"
7#include "BLI_rand.hh"
8#include "BLI_task.hh"
9
10#include "DNA_brush_types.h"
11
12#include "BKE_context.hh"
13#include "BKE_crazyspace.hh"
14#include "BKE_curves.hh"
15#include "BKE_grease_pencil.hh"
16#include "BKE_paint.hh"
17
18#include "ED_grease_pencil.hh"
19#include "ED_view3d.hh"
20
21#include "WM_api.hh"
22#include "WM_types.hh"
23
24#include "../paint_intern.hh"
26
28
29/* Use a hash to generate random numbers. */
30static float hash_rng(uint32_t seed1, uint32_t seed2, int index)
31{
32 return BLI_hash_int_01(BLI_hash_int_3d(seed1, seed2, uint32_t(index)));
33}
34
36 public:
38
39 /* Get a different seed value for each stroke. */
40 uint32_t unique_seed() const;
41
42 void on_stroke_begin(const bContext &C, const InputSample &start_sample) override;
43 void on_stroke_extended(const bContext &C, const InputSample &extension_sample) override;
44 void on_stroke_done(const bContext & /*C*/) override {}
45};
46
51
53{
54 this->init_stroke(C, start_sample);
55 this->init_auto_masking(C, start_sample);
56}
57
58void RandomizeOperation::on_stroke_extended(const bContext &C, const InputSample &extension_sample)
59{
61 const Brush &brush = *BKE_paint_brush(&paint);
62 const int sculpt_mode_flag = brush.gpencil_settings->sculpt_mode_flag;
63
65 C,
66 [&](const GreasePencilStrokeParams &params,
67 const IndexMask &point_mask,
68 const DeltaProjectionFunc &projection_fn) {
69 const uint32_t seed = this->unique_seed();
70
72 const Array<float2> view_positions = view_positions_from_point_mask(params, point_mask);
74 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
75
76 bool changed = false;
77 if (sculpt_mode_flag & GP_SCULPT_FLAGMODE_APPLY_POSITION) {
78 MutableSpan<float3> positions = curves.positions_for_write();
79
80 /* Jitter is applied perpendicular to the mouse movement vector. */
81 const float2 forward = math::normalize(this->mouse_delta(extension_sample));
82 const float2 sideways = float2(-forward.y, forward.x);
83
84 point_mask.foreach_index(
85 [&](const int64_t point_i) {
86 const float2 &co = view_positions[point_i];
87 const float influence = brush_point_influence(
88 paint, brush, co, extension_sample, params.multi_frame_falloff);
89 if (influence <= 0.0f) {
90 return;
91 }
92 const float noise = 2.0f * hash_rng(seed, 5678, point_i) - 1.0f;
93 positions[point_i] += compute_orig_delta(
94 projection_fn, deformation, point_i, sideways * influence * noise);
95 },
97
98 if (curves.has_curve_with_type(CURVE_TYPE_BEZIER)) {
99 MutableSpan<float3> handle_positions_left = curves.handle_positions_left_for_write();
100 MutableSpan<float3> handle_positions_right = curves.handle_positions_right_for_write();
101
102 const Array<float2> view_positions_left = view_positions_left_from_point_mask(
103 params, point_mask);
104 const Array<float2> view_positions_right = view_positions_right_from_point_mask(
105 params, point_mask);
106
107 point_mask.foreach_index(
108 [&](const int64_t point_i) {
109 const float2 co_left = view_positions_left[point_i];
110 const float2 co_right = view_positions_right[point_i];
111 const float influence_left = brush_point_influence(
112 paint, brush, co_left, extension_sample, params.multi_frame_falloff);
113 const float influence_right = brush_point_influence(
114 paint, brush, co_right, extension_sample, params.multi_frame_falloff);
115
116 const float noise_left = 2.0f * hash_rng(seed, 3621, point_i) - 1.0f;
117 handle_positions_left[point_i] += compute_orig_delta(
118 projection_fn, deformation, point_i, sideways * influence_left * noise_left);
119 const float noise_right = 2.0f * hash_rng(seed, 9754, point_i) - 1.0f;
120 handle_positions_right[point_i] += compute_orig_delta(
121 projection_fn,
122 deformation,
123 point_i,
124 sideways * influence_right * noise_right);
125 },
127
128 curves.calculate_bezier_auto_handles();
129 curves.calculate_bezier_aligned_handles();
130 }
131
133 changed = true;
134 }
135 if (sculpt_mode_flag & GP_SCULPT_FLAGMODE_APPLY_STRENGTH) {
137 point_mask.foreach_index(
138 [&](const int64_t point_i) {
139 const float2 &co = view_positions[point_i];
140 const float influence = brush_point_influence(
141 paint, brush, co, extension_sample, params.multi_frame_falloff);
142 if (influence <= 0.0f) {
143 return;
144 }
145 const float noise = 2.0f * hash_rng(seed, 1212, point_i) - 1.0f;
146 opacities[point_i] = math::clamp(
147 opacities[point_i] + influence * noise, 0.0f, 1.0f);
148 },
150 changed = true;
151 }
152 if (sculpt_mode_flag & GP_SCULPT_FLAGMODE_APPLY_THICKNESS) {
153 const MutableSpan<float> radii = params.drawing.radii_for_write();
154 point_mask.foreach_index(
155 [&](const int64_t point_i) {
156 const float2 &co = view_positions[point_i];
157 const float influence = brush_point_influence(
158 paint, brush, co, extension_sample, params.multi_frame_falloff);
159 if (influence <= 0.0f) {
160 return;
161 }
162 const float noise = 2.0f * hash_rng(seed, 1212, point_i) - 1.0f;
163 radii[point_i] = math::max(radii[point_i] + influence * noise * 0.001f, 0.0f);
164 },
166 curves.tag_radii_changed();
167 changed = true;
168 }
169 if (sculpt_mode_flag & GP_SCULPT_FLAGMODE_APPLY_UV) {
170 if (bke::SpanAttributeWriter<float> rotations =
171 attributes.lookup_or_add_for_write_span<float>("rotation",
173 {
174 point_mask.foreach_index(
175 [&](const int64_t point_i) {
176 const float2 &co = view_positions[point_i];
177 const float influence = brush_point_influence(
178 paint, brush, co, extension_sample, params.multi_frame_falloff);
179 if (influence <= 0.0f) {
180 return;
181 }
182 const float noise = 2.0f * hash_rng(seed, 1212, point_i) - 1.0f;
183 rotations.span[point_i] = math::clamp(
184 rotations.span[point_i] + influence * noise, -float(M_PI_2), float(M_PI_2));
185 },
187 rotations.finish();
188 changed = true;
189 }
190 }
191 return changed;
192 });
193 this->stroke_extended(extension_sample);
194}
195
196std::unique_ptr<GreasePencilStrokeOperation> new_randomize_operation(
197 const BrushStrokeMode stroke_mode)
198{
199 return std::make_unique<RandomizeOperation>(stroke_mode);
200}
201
202} // namespace blender::ed::sculpt_paint::greasepencil
Low-level operations for curves.
Low-level operations for grease pencil.
#define M_PI_2
#define C
Definition RandGen.cpp:29
static RandomNumberGenerator from_random_seed()
Definition rand.cc:288
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
MutableSpan< float > opacities_for_write()
MutableSpan< float > radii_for_write()
bke::CurvesGeometry & strokes_for_write()
void foreach_editable_drawing_with_automask(const bContext &C, FunctionRef< bool(const GreasePencilStrokeParams &params, const IndexMask &points)> fn) const
void init_stroke(const bContext &C, const InputSample &start_sample)
void init_auto_masking(const bContext &C, const InputSample &start_sample)
void on_stroke_begin(const bContext &C, const InputSample &start_sample) override
void on_stroke_extended(const bContext &C, const InputSample &extension_sample) override
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
Array< float2 > view_positions_left_from_point_mask(const GreasePencilStrokeParams &params, const IndexMask &selection)
Array< float2 > view_positions_right_from_point_mask(const GreasePencilStrokeParams &params, const IndexMask &selection)
float brush_point_influence(const Paint &paint, const Brush &brush, const float2 &co, const InputSample &sample, float multi_frame_falloff)
std::unique_ptr< GreasePencilStrokeOperation > new_randomize_operation(BrushStrokeMode stroke_mode)
Array< float2 > view_positions_from_point_mask(const GreasePencilStrokeParams &params, const IndexMask &point_mask)
bke::crazyspace::GeometryDeformation get_drawing_deformation(const GreasePencilStrokeParams &params)
static float hash_rng(uint32_t seed1, uint32_t seed2, int index)
float3 compute_orig_delta(const DeltaProjectionFunc &projection_fn, const bke::crazyspace::GeometryDeformation &deformation, int index, const float2 &screen_delta)
std::function< float3(const float3 position, const float2 &screen_delta)> DeltaProjectionFunc
constexpr ParallelGrainSize grain_size(int grain_size)
T clamp(const T &a, const T &min, const T &max)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T max(const T &a, const T &b)
__int64 int64_t
Definition BKE_text.h:90
BLI_INLINE float BLI_hash_int_01(unsigned int k)
Definition BLI_hash_c.hh:94
unsigned int uint32_t
Definition BKE_text.h:81
VecBase< float, 2 > float2
Paint * BKE_paint_get_active_from_context(const bContext *C)
BLI_INLINE unsigned int BLI_hash_int_3d(unsigned int kx, unsigned int ky, unsigned int kz)
Definition BLI_hash_c.hh:40
Brush * BKE_paint_brush(Paint *paint)
@ GP_SCULPT_FLAGMODE_APPLY_POSITION
@ GP_SCULPT_FLAGMODE_APPLY_UV
@ GP_SCULPT_FLAGMODE_APPLY_THICKNESS
@ GP_SCULPT_FLAGMODE_APPLY_STRENGTH