Blender V5.3
paint_image_2d_curve_mask.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "MEM_guardedalloc.h"
10
11#include "DNA_brush_types.h"
12
13#include "BKE_brush.hh"
14
15#include "BLI_math_vector_c.hh"
16
17#include "../paint_intern.hh"
18
19namespace blender {
20
21namespace ed::sculpt_paint {
22
28constexpr int CurveSamplesBaseLen = 1024;
36
37static int aa_samples_per_texel_axis(const Brush *brush, const float radius)
38{
39 int aa_samples = 1.0f / (radius * 0.20f);
40 if (brush->sampling_flag & BRUSH_PAINT_ANTIALIASING) {
41 aa_samples = clamp_i(
43 }
44 else {
45 aa_samples = 1;
46 }
47 return aa_samples;
48}
49
50/* create a mask with the falloff strength */
51static void update_curve_mask(CurveMaskCache *curve_mask_cache,
52 const Brush *brush,
53 const int diameter,
54 const float radius,
55 const float cursor_position[2])
56{
57 BLI_assert(curve_mask_cache->curve_mask != nullptr);
58 int offset = int(floorf(diameter / 2.0f));
59 float clamped_radius = max_ff(radius, 0.5f);
60
61 ushort *m = curve_mask_cache->curve_mask;
62
63 const int aa_samples = aa_samples_per_texel_axis(brush, radius);
64 const float aa_offset = 1.0f / (2.0f * float(aa_samples));
65 const float aa_step = 1.0f / float(aa_samples);
66
67 float bpos[2];
68 bpos[0] = cursor_position[0] - floorf(cursor_position[0]) + offset;
69 bpos[1] = cursor_position[1] - floorf(cursor_position[1]) + offset;
70
71 float weight_factor = 65535.0f / float(aa_samples * aa_samples);
72
73 if (aa_samples == 1) {
74 /* When AA is disabled, snap the cursor to either the corners or centers of the pixels,
75 * depending on if the diameter is even or odd, respectively.*/
76
77 if (int(clamped_radius * 2) % 2 == 0) {
78 bpos[0] = roundf(bpos[0]);
79 bpos[1] = roundf(bpos[1]);
80 }
81 else {
82 bpos[0] = floorf(bpos[0]) + 0.5f;
83 bpos[1] = floorf(bpos[1]) + 0.5f;
84 }
85 }
86
87 for (int y = 0; y < diameter; y++) {
88 for (int x = 0; x < diameter; x++, m++) {
89 float pixel_xy[2];
90 pixel_xy[0] = float(x) + aa_offset;
91 float total_weight = 0;
92
93 for (int i = 0; i < aa_samples; i++) {
94 pixel_xy[1] = float(y) + aa_offset;
95 for (int j = 0; j < aa_samples; j++) {
96 const float len = len_v2v2(pixel_xy, bpos);
97 const int sample_index = min_ii((len / clamped_radius) * CurveSamplesBaseLen,
98 CurveSamplesLen - 1);
99 const float sample_weight = curve_mask_cache->sampled_curve[sample_index];
100
101 total_weight += sample_weight;
102
103 pixel_xy[1] += aa_step;
104 }
105 pixel_xy[0] += aa_step;
106 }
107 *m = ushort(total_weight * weight_factor);
108 }
109 }
110}
111
112static bool is_sampled_curve_valid(const CurveMaskCache *curve_mask_cache, const Brush *brush)
113{
114 if (curve_mask_cache->sampled_curve == nullptr) {
115 return false;
116 }
117 return curve_mask_cache->last_curve_timestamp ==
118 brush->curve_distance_falloff->changed_timestamp;
119}
120
121static void sampled_curve_free(CurveMaskCache *curve_mask_cache)
122{
123 MEM_SAFE_DELETE(curve_mask_cache->sampled_curve);
124 curve_mask_cache->last_curve_timestamp = 0;
125}
126
127static void update_sampled_curve(CurveMaskCache *curve_mask_cache, const Brush *brush)
128{
129 if (curve_mask_cache->sampled_curve == nullptr) {
131 __func__);
132 }
133
134 for (int i = 0; i < CurveSamplesLen; i++) {
135 const float len = i / float(CurveSamplesBaseLen);
136 const float sample_weight = BKE_brush_curve_strength_clamped(brush, len, 1.0f);
137 curve_mask_cache->sampled_curve[i] = sample_weight;
138 }
139 curve_mask_cache->last_curve_timestamp = brush->curve_distance_falloff->changed_timestamp;
140}
141
142static size_t diameter_to_curve_mask_size(const int diameter)
143{
144 return diameter * diameter * sizeof(ushort);
145}
146
147static bool is_curve_mask_size_valid(const CurveMaskCache *curve_mask_cache, const int diameter)
148{
149 return curve_mask_cache->curve_mask_size == diameter_to_curve_mask_size(diameter);
150}
151
152static void curve_mask_free(CurveMaskCache *curve_mask_cache)
153{
154 curve_mask_cache->curve_mask_size = 0;
155 MEM_SAFE_DELETE(curve_mask_cache->curve_mask);
156}
157
158static void curve_mask_allocate(CurveMaskCache *curve_mask_cache, const int diameter)
159{
160 const size_t curve_mask_size = diameter_to_curve_mask_size(diameter);
161 curve_mask_cache->curve_mask = static_cast<ushort *>(
162 MEM_new_uninitialized(curve_mask_size, __func__));
163 curve_mask_cache->curve_mask_size = curve_mask_size;
164}
165
166} // namespace ed::sculpt_paint
167
168using namespace blender::ed::sculpt_paint;
169
171{
172 sampled_curve_free(curve_mask_cache);
173 curve_mask_free(curve_mask_cache);
174}
175
177 const Brush *brush,
178 const int diameter,
179 const float radius,
180 const float cursor_position[2])
181{
182 if (!is_sampled_curve_valid(curve_mask_cache, brush)) {
183 update_sampled_curve(curve_mask_cache, brush);
184 }
185
186 if (!is_curve_mask_size_valid(curve_mask_cache, diameter)) {
187 curve_mask_free(curve_mask_cache);
188 curve_mask_allocate(curve_mask_cache, diameter);
189 }
190 update_curve_mask(curve_mask_cache, brush, diameter, radius, cursor_position);
191}
192
193} // namespace blender
#define M_SQRT2
Read Blender memory allocation and freeing.
#define roundf(x)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
constexpr int CurveSamplesBaseLen
Number of samples to use between 0..1.
static void sampled_curve_free(CurveMaskCache *curve_mask_cache)
static int aa_samples_per_texel_axis(const Brush *brush, const float radius)
static void update_curve_mask(CurveMaskCache *curve_mask_cache, const Brush *brush, const int diameter, const float radius, const float cursor_position[2])
static size_t diameter_to_curve_mask_size(const int diameter)
static void curve_mask_free(CurveMaskCache *curve_mask_cache)
static bool is_sampled_curve_valid(const CurveMaskCache *curve_mask_cache, const Brush *brush)
static void curve_mask_allocate(CurveMaskCache *curve_mask_cache, const int diameter)
static bool is_curve_mask_size_valid(const CurveMaskCache *curve_mask_cache, const int diameter)
static void update_sampled_curve(CurveMaskCache *curve_mask_cache, const Brush *brush)
constexpr int CurveSamplesLen
Number of samples to store in the cache.
BMesh Iterators.
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
unsigned short ushort
Definition BKE_text.h:56
void paint_curve_mask_cache_free_data(CurveMaskCache *curve_mask_cache)
@ BRUSH_PAINT_ANTIALIASING
float BKE_brush_curve_strength_clamped(const Brush *br, float p, float len)
Definition brush.cc:1751
MINLINE float max_ff(float a, float b)
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
MINLINE int min_ii(int a, int b)
MINLINE int clamp_i(int value, int min, int max)
void paint_curve_mask_cache_update(CurveMaskCache *curve_mask_cache, const Brush *brush, const int diameter, const float radius, const float cursor_position[2])
#define floorf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
Caching structure for curve mask.
float * sampled_curve
sampled version of the brush curve-mapping.
ushort * curve_mask
Curve mask that can be passed as curve_mask parameter when.
int last_curve_timestamp
Last CurveMapping.changed_timestamp being read.
size_t curve_mask_size
Size in bytes of the curve_mask field.