Blender V5.3
draw_curves_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "DNA_curves_types.h"
6
7#include "BKE_curves.hh"
8
9#include "GPU_batch.hh"
10#include "GPU_shader.hh"
11
13#include "draw_manager.hh"
14#include "draw_pass.hh"
15#include "draw_testing.hh"
16
17#include "draw_shader_shared.hh"
18
19namespace blender::draw {
20
22{
23 Manager manager;
24
25 gpu::Shader *sh = GPU_shader_create_from_info_name("draw_curves_test");
26
27 struct Indirection {
28 int index;
29 GPU_VERTEX_FORMAT_FUNC(Indirection, index);
30 };
31 gpu::VertBuf *indirection_ribbon_buf = GPU_vertbuf_create_with_format_ex(
32 Indirection::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
33 indirection_ribbon_buf->allocate(9);
34 indirection_ribbon_buf->data<int>().copy_from({0, -1, -2, -3, -4, 0x7FFFFFFF, 1, -1, -2});
35 gpu::Batch *batch_ribbon = GPU_batch_create_procedural(GPU_PRIM_TRI_STRIP, 2 * 9);
36
37 gpu::VertBuf *indirection_cylinder_buf = GPU_vertbuf_create_with_format_ex(
38 Indirection::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
39 indirection_cylinder_buf->allocate(6);
40 indirection_cylinder_buf->data<int>().copy_from({0, -1, -2, -3, 1, -1});
41 gpu::Batch *batch_cylinder = GPU_batch_create_procedural(GPU_PRIM_TRI_STRIP, (3 * 2 + 1) * 6);
42
43 struct PositionRadius {
44 float4 pos_rad;
45 GPU_VERTEX_FORMAT_FUNC(PositionRadius, pos_rad);
46 };
48 PositionRadius::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
49 pos_rad_buf->allocate(8);
50 pos_rad_buf->data<float4>().copy_from({float4{1.0f},
51 float4{0.75f},
52 float4{0.5f},
53 float4{0.25f},
54 float4{0.0f},
55 float4{0.0f},
56 float4{1.0f},
57 float4{2.0f}});
58
59 UniformBuffer<CurvesInfos> curves_info_buf;
60 curves_info_buf.is_point_attribute = 0b10;
61 /* Ribbon. */
62 curves_info_buf.vertex_per_segment = 2;
63 curves_info_buf.half_cylinder_face_count = 1;
64 curves_info_buf.push_update();
65
67 fb.ensure(int2(1, 1));
68
69 {
72 result_pos.clear_to_zero();
73 result_idx.clear_to_zero();
74
75 PassSimple pass("Ribbon Curves");
76 pass.init();
77 pass.framebuffer_set(&fb);
78 pass.shader_set(sh);
79 pass.bind_ubo("drw_curves", curves_info_buf);
80 pass.bind_texture("curves_pos_rad_buf", pos_rad_buf);
81 pass.bind_texture("curves_indirection_buf", indirection_ribbon_buf);
82 pass.bind_ssbo("result_pos_buf", result_pos);
83 pass.bind_ssbo("result_indices_buf", result_idx);
84 pass.draw(batch_ribbon);
86
87 manager.submit(pass);
88
89 /* Note: Expected values follows diagram shown in #142969. */
90
91 result_pos.read();
92 EXPECT_EQ(result_pos[0], 1.0f);
93 EXPECT_EQ(result_pos[1], 1.0f);
94 EXPECT_EQ(result_pos[2], 0.75f);
95 EXPECT_EQ(result_pos[3], 0.75f);
96 EXPECT_EQ(result_pos[4], 0.5f);
97 EXPECT_EQ(result_pos[5], 0.5f);
98 EXPECT_EQ(result_pos[6], 0.25f);
99 EXPECT_EQ(result_pos[7], 0.25f);
100 EXPECT_EQ(result_pos[8], 0.0f);
101 EXPECT_EQ(result_pos[9], 0.0f);
102 EXPECT_TRUE(isnan(result_pos[10]));
103 EXPECT_TRUE(isnan(result_pos[11]));
104 EXPECT_EQ(result_pos[12], 0.0f);
105 EXPECT_EQ(result_pos[13], 0.0f);
106 EXPECT_EQ(result_pos[14], 1.0f);
107 EXPECT_EQ(result_pos[15], 1.0f);
108 EXPECT_EQ(result_pos[16], 2.0f);
109 EXPECT_EQ(result_pos[17], 2.0f);
110
111 result_idx.read();
112 /* x: point_id, y: curve_id, z: curve_segment, w: azimuthal_offset */
113 EXPECT_EQ(result_idx[0], int4(0, 0, 0, -1));
114 EXPECT_EQ(result_idx[1], int4(0, 0, 0, 1));
115 EXPECT_EQ(result_idx[2], int4(1, 0, 1, -1));
116 EXPECT_EQ(result_idx[3], int4(1, 0, 1, 1));
117 EXPECT_EQ(result_idx[4], int4(2, 0, 2, -1));
118 EXPECT_EQ(result_idx[5], int4(2, 0, 2, 1));
119 EXPECT_EQ(result_idx[6], int4(3, 0, 3, -1));
120 EXPECT_EQ(result_idx[7], int4(3, 0, 3, 1));
121 EXPECT_EQ(result_idx[8], int4(4, 0, 4, -1));
122 EXPECT_EQ(result_idx[9], int4(4, 0, 4, 1));
123 EXPECT_EQ(result_idx[10], int4(5, 0, 0, -1)); /* End Of Curve */
124 EXPECT_EQ(result_idx[11], int4(5, 0, 0, 1)); /* End Of Curve */
125 EXPECT_EQ(result_idx[12], int4(5, 1, 0, -1));
126 EXPECT_EQ(result_idx[13], int4(5, 1, 0, 1));
127 EXPECT_EQ(result_idx[14], int4(6, 1, 1, -1));
128 EXPECT_EQ(result_idx[15], int4(6, 1, 1, 1));
129 EXPECT_EQ(result_idx[16], int4(7, 1, 2, -1));
130 EXPECT_EQ(result_idx[17], int4(7, 1, 2, 1));
131 }
132
133 /* Cylinder. */
134 curves_info_buf.vertex_per_segment = 7;
135 curves_info_buf.half_cylinder_face_count = 2;
136 curves_info_buf.push_update();
137
138 {
141 result_pos.clear_to_zero();
142 result_idx.clear_to_zero();
143
144 PassSimple pass("Cylinder Curves");
145 pass.init();
146 pass.framebuffer_set(&fb);
147 pass.shader_set(sh);
148 pass.bind_ubo("drw_curves", curves_info_buf);
149 pass.bind_texture("curves_pos_rad_buf", pos_rad_buf);
150 pass.bind_texture("curves_indirection_buf", indirection_cylinder_buf);
151 pass.bind_ssbo("result_pos_buf", result_pos);
152 pass.bind_ssbo("result_indices_buf", result_idx);
153 pass.draw(batch_cylinder);
155
156 manager.submit(pass);
157
158 /* Note: Expected values follows diagram shown in #142969. */
159
160 result_pos.read();
161 EXPECT_EQ(result_pos[0], 0.75f);
162 EXPECT_EQ(result_pos[1], 1.0f);
163 EXPECT_EQ(result_pos[2], 0.75f);
164 EXPECT_EQ(result_pos[3], 1.0f);
165 EXPECT_EQ(result_pos[4], 0.75f);
166 EXPECT_EQ(result_pos[5], 1.0f);
167 EXPECT_TRUE(isnan(result_pos[6]));
168 EXPECT_EQ(result_pos[7], 0.75f);
169 EXPECT_EQ(result_pos[8], 0.5f);
170 EXPECT_EQ(result_pos[9], 0.75f);
171 EXPECT_EQ(result_pos[10], 0.5f);
172 EXPECT_EQ(result_pos[11], 0.75f);
173 EXPECT_EQ(result_pos[12], 0.5f);
174 EXPECT_TRUE(isnan(result_pos[13]));
175 EXPECT_EQ(result_pos[14], 0.25f);
176 EXPECT_EQ(result_pos[15], 0.5f);
177 EXPECT_EQ(result_pos[16], 0.25f);
178 EXPECT_EQ(result_pos[17], 0.5f);
179 EXPECT_EQ(result_pos[18], 0.25f);
180 EXPECT_EQ(result_pos[19], 0.5f);
181 EXPECT_TRUE(isnan(result_pos[20]));
182 EXPECT_EQ(result_pos[21], 0.25f);
183 EXPECT_EQ(result_pos[22], 0.0f);
184 EXPECT_EQ(result_pos[23], 0.25f);
185 EXPECT_EQ(result_pos[24], 0.0f);
186 EXPECT_EQ(result_pos[25], 0.25f);
187 EXPECT_EQ(result_pos[26], 0.0f);
188 EXPECT_TRUE(isnan(result_pos[27]));
189 EXPECT_EQ(result_pos[28], 1.0f);
190 EXPECT_EQ(result_pos[29], 0.0f);
191 EXPECT_EQ(result_pos[30], 1.0f);
192 EXPECT_EQ(result_pos[31], 0.0f);
193 EXPECT_EQ(result_pos[32], 1.0f);
194 EXPECT_EQ(result_pos[33], 0.0f);
195 EXPECT_TRUE(isnan(result_pos[34]));
196 EXPECT_EQ(result_pos[35], 1.0f);
197 EXPECT_EQ(result_pos[36], 2.0f);
198 EXPECT_EQ(result_pos[37], 1.0f);
199 EXPECT_EQ(result_pos[38], 2.0f);
200 EXPECT_EQ(result_pos[39], 1.0f);
201 EXPECT_EQ(result_pos[40], 2.0f);
202 EXPECT_TRUE(isnan(result_pos[41]));
203
204 result_idx.read();
205 /* x: point_id, y: curve_id, z: curve_segment, w: azimuthal_offset */
206 EXPECT_EQ(result_idx[0], int4(1, 0, 1, -1));
207 EXPECT_EQ(result_idx[1], int4(0, 0, 0, -1));
208 EXPECT_EQ(result_idx[2], int4(1, 0, 1, 0));
209 EXPECT_EQ(result_idx[3], int4(0, 0, 0, 0));
210 EXPECT_EQ(result_idx[4], int4(1, 0, 1, 1));
211 EXPECT_EQ(result_idx[5], int4(0, 0, 0, 1));
212 EXPECT_EQ(result_idx[6], int4(0, 0, 0, 2));
213
214 EXPECT_EQ(result_idx[7], int4(1, 0, 1, -1));
215 EXPECT_EQ(result_idx[8], int4(2, 0, 2, -1));
216 EXPECT_EQ(result_idx[9], int4(1, 0, 1, 0));
217 EXPECT_EQ(result_idx[10], int4(2, 0, 2, 0));
218 EXPECT_EQ(result_idx[11], int4(1, 0, 1, 1));
219 EXPECT_EQ(result_idx[12], int4(2, 0, 2, 1));
220 EXPECT_EQ(result_idx[13], int4(1, 0, 1, 2));
221
222 EXPECT_EQ(result_idx[14], int4(3, 0, 3, -1));
223 EXPECT_EQ(result_idx[15], int4(2, 0, 2, -1));
224 EXPECT_EQ(result_idx[16], int4(3, 0, 3, 0));
225 EXPECT_EQ(result_idx[17], int4(2, 0, 2, 0));
226 EXPECT_EQ(result_idx[18], int4(3, 0, 3, 1));
227 EXPECT_EQ(result_idx[19], int4(2, 0, 2, 1));
228 EXPECT_EQ(result_idx[20], int4(2, 0, 2, 2));
229
230 EXPECT_EQ(result_idx[21], int4(3, 0, 3, -1));
231 EXPECT_EQ(result_idx[22], int4(4, 0, 4, -1));
232 EXPECT_EQ(result_idx[23], int4(3, 0, 3, 0));
233 EXPECT_EQ(result_idx[24], int4(4, 0, 4, 0));
234 EXPECT_EQ(result_idx[25], int4(3, 0, 3, 1));
235 EXPECT_EQ(result_idx[26], int4(4, 0, 4, 1));
236 EXPECT_EQ(result_idx[27], int4(3, 0, 3, 2));
237
238 EXPECT_EQ(result_idx[28], int4(6, 1, 1, -1));
239 EXPECT_EQ(result_idx[29], int4(5, 1, 0, -1));
240 EXPECT_EQ(result_idx[30], int4(6, 1, 1, 0));
241 EXPECT_EQ(result_idx[31], int4(5, 1, 0, 0));
242 EXPECT_EQ(result_idx[32], int4(6, 1, 1, 1));
243 EXPECT_EQ(result_idx[33], int4(5, 1, 0, 1));
244 EXPECT_EQ(result_idx[34], int4(5, 1, 0, 2));
245
246 EXPECT_EQ(result_idx[35], int4(6, 1, 1, -1));
247 EXPECT_EQ(result_idx[36], int4(7, 1, 2, -1));
248 EXPECT_EQ(result_idx[37], int4(6, 1, 1, 0));
249 EXPECT_EQ(result_idx[38], int4(7, 1, 2, 0));
250 EXPECT_EQ(result_idx[39], int4(6, 1, 1, 1));
251 EXPECT_EQ(result_idx[40], int4(7, 1, 2, 1));
252 EXPECT_EQ(result_idx[41], int4(6, 1, 1, 2));
253 }
254
256
258 GPU_BATCH_DISCARD_SAFE(batch_ribbon);
259 GPU_BATCH_DISCARD_SAFE(batch_cylinder);
260 GPU_VERTBUF_DISCARD_SAFE(indirection_ribbon_buf);
261 GPU_VERTBUF_DISCARD_SAFE(indirection_cylinder_buf);
262 GPU_VERTBUF_DISCARD_SAFE(pos_rad_buf);
263}
264DRAW_TEST(draw_curves_lib)
265
267{
268 Manager manager;
269
270 gpu::Shader *sh = GPU_shader_create_from_info_name("draw_curves_topology");
271
272 struct IntBuf {
273 int data;
275 };
276 gpu::VertBuf *curve_offsets_buf = GPU_vertbuf_create_with_format(IntBuf::format());
277 curve_offsets_buf->allocate(4);
278 curve_offsets_buf->data<int>().copy_from({0, 5, 8, 10});
279
280 {
281 StorageArrayBuffer<int, 512> indirection_buf;
282 indirection_buf.clear_to_zero();
283
284 PassSimple pass("Ribbon Curves");
285 pass.init();
286 pass.shader_set(sh);
287 pass.bind_ssbo("evaluated_offsets_buf", curve_offsets_buf);
288 pass.bind_ssbo("curves_cyclic_buf", curve_offsets_buf);
289 pass.bind_ssbo("indirection_buf", indirection_buf);
290 pass.push_constant("curves_start", 0);
291 pass.push_constant("curves_count", 3);
292 pass.push_constant("is_ribbon_topology", true);
293 pass.push_constant("use_cyclic", false);
294 pass.dispatch(1);
296
297 manager.submit(pass);
298
299 /* Note: Expected values follows diagram shown in #142969. */
300 indirection_buf.read();
301
302 EXPECT_EQ(indirection_buf[0], 0);
303 EXPECT_EQ(indirection_buf[1], -1);
304 EXPECT_EQ(indirection_buf[2], -2);
305 EXPECT_EQ(indirection_buf[3], -3);
306 EXPECT_EQ(indirection_buf[4], -4);
307 EXPECT_EQ(indirection_buf[5], 0x7FFFFFFF);
308 EXPECT_EQ(indirection_buf[6], 1);
309 EXPECT_EQ(indirection_buf[7], -1);
310 EXPECT_EQ(indirection_buf[8], -2);
311 EXPECT_EQ(indirection_buf[9], 0x7FFFFFFF);
312 EXPECT_EQ(indirection_buf[10], 2);
313 EXPECT_EQ(indirection_buf[11], -1);
314 EXPECT_EQ(indirection_buf[12], 0x7FFFFFFF);
315 /* Ensure the rest of the buffer is untouched. */
316 EXPECT_EQ(indirection_buf[13], 0);
317 EXPECT_EQ(indirection_buf[14], 0);
318 }
319
320 {
321 StorageArrayBuffer<int, 512> indirection_buf;
322 indirection_buf.clear_to_zero();
323
324 PassSimple pass("Cylinder Curves");
325 pass.init();
326 pass.shader_set(sh);
327 pass.bind_ssbo("evaluated_offsets_buf", curve_offsets_buf);
328 pass.bind_ssbo("curves_cyclic_buf", curve_offsets_buf);
329 pass.bind_ssbo("indirection_buf", indirection_buf);
330 pass.push_constant("curves_start", 0);
331 pass.push_constant("curves_count", 3);
332 pass.push_constant("is_ribbon_topology", false);
333 pass.push_constant("use_cyclic", false);
334 pass.dispatch(1);
336
337 manager.submit(pass);
338
339 /* Note: Expected values follows diagram shown in #142969. */
340 indirection_buf.read();
341
342 EXPECT_EQ(indirection_buf[0], 0);
343 EXPECT_EQ(indirection_buf[1], -1);
344 EXPECT_EQ(indirection_buf[2], -2);
345 EXPECT_EQ(indirection_buf[3], -3);
346 EXPECT_EQ(indirection_buf[4], 1);
347 EXPECT_EQ(indirection_buf[5], -1);
348 EXPECT_EQ(indirection_buf[6], 2);
349 /* Ensure the rest of the buffer is untouched. */
350 EXPECT_EQ(indirection_buf[7], 0);
351 EXPECT_EQ(indirection_buf[8], 0);
352 }
353
355
357 GPU_VERTBUF_DISCARD_SAFE(curve_offsets_buf);
358}
360
362{
363 Manager manager;
364
365 gpu::Shader *sh = GPU_shader_create_from_info_name("draw_curves_interpolate_position");
367 "draw_curves_evaluate_length_intercept");
368
369 const int curve_resolution = 2;
370
371 const Vector<int> evaluated_offsets = {0, 5, 8};
372
373 struct IntBuf {
374 int data;
376 };
377 gpu::VertBuf *points_by_curve_buf = GPU_vertbuf_create_with_format(IntBuf::format());
378 points_by_curve_buf->allocate(3);
379 points_by_curve_buf->data<int>().copy_from({0, 3, 5});
380
381 gpu::VertBuf *curves_type_buf = GPU_vertbuf_create_with_format(IntBuf::format());
382 curves_type_buf->allocate(1);
383 curves_type_buf->data<char>().copy_from({CURVE_TYPE_CATMULL_ROM, CURVE_TYPE_CATMULL_ROM, 0, 0});
384
385 gpu::VertBuf *curves_resolution_buf = GPU_vertbuf_create_with_format(IntBuf::format());
386 curves_resolution_buf->allocate(2);
387 curves_resolution_buf->data<int>().copy_from({curve_resolution, curve_resolution});
388
389 gpu::VertBuf *evaluated_points_by_curve_buf = GPU_vertbuf_create_with_format(IntBuf::format());
390 evaluated_points_by_curve_buf->allocate(3);
391 evaluated_points_by_curve_buf->data<int>().copy_from(evaluated_offsets);
392
393 const Vector<float> points_radius = {1.0f, 0.5f, 0.0f, 0.0f, 2.0f};
394 const Vector<float3> positions = {
395 float3{1.0f}, float3{0.5f}, float3{0.0f}, float3{0.0f}, float3{2.0f}};
396
397 struct Position {
398 float3 pos;
400 };
402 Position::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
403 positions_buf->allocate(positions.size());
404 positions_buf->data<float3>().copy_from(positions);
405
406 struct Radius {
407 float rad;
408 GPU_VERTEX_FORMAT_FUNC(Radius, rad);
409 };
410 gpu::VertBuf *radii_buf = GPU_vertbuf_create_with_format_ex(Radius::format(),
412 radii_buf->allocate(points_radius.size());
413 radii_buf->data<float>().copy_from(points_radius);
414
415 {
416 StorageArrayBuffer<float4, 512> evaluated_positions_radii_buf;
417 StorageArrayBuffer<float, 512> evaluated_time_buf;
418 StorageArrayBuffer<float, 512> curves_length_buf;
419 evaluated_positions_radii_buf.clear_to_zero();
420 evaluated_time_buf.clear_to_zero();
421 curves_length_buf.clear_to_zero();
422
423 PassSimple pass("Curves Interpolation Catmull Rom");
424 pass.init();
425 pass.specialize_constant(sh, "evaluated_type", int(CURVE_TYPE_CATMULL_ROM));
426 pass.shader_set(sh);
427 pass.bind_ssbo(POINTS_BY_CURVES_SLOT, points_by_curve_buf);
428 pass.bind_ssbo(CURVE_TYPE_SLOT, curves_type_buf);
429 pass.bind_ssbo(CURVE_RESOLUTION_SLOT, curves_resolution_buf);
430 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
431 pass.bind_ssbo(POINT_POSITIONS_SLOT, positions_buf);
432 pass.bind_ssbo(POINT_RADII_SLOT, radii_buf);
433 pass.bind_ssbo(EVALUATED_POS_RAD_SLOT, evaluated_positions_radii_buf);
434 pass.push_constant("use_cyclic", false);
435 pass.bind_ssbo(CURVE_CYCLIC_SLOT, evaluated_points_by_curve_buf); /* Dummy, not used. */
436 /* Dummy, not used for Catmull-Rom. */
437 pass.bind_ssbo(HANDLES_POS_LEFT_SLOT, evaluated_points_by_curve_buf);
438 pass.bind_ssbo(HANDLES_POS_RIGHT_SLOT, evaluated_points_by_curve_buf);
439 pass.bind_ssbo(BEZIER_OFFSETS_SLOT, evaluated_points_by_curve_buf);
440 pass.push_constant("curves_start", 0);
441 pass.push_constant("curves_count", 2);
442 pass.push_constant("transform", float4x4::identity());
443 pass.dispatch(1);
445 pass.shader_set(sh_length);
446 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
447 pass.bind_ssbo(EVALUATED_POS_RAD_SLOT, evaluated_positions_radii_buf);
448 pass.bind_ssbo(EVALUATED_TIME_SLOT, evaluated_time_buf);
449 pass.bind_ssbo(CURVES_LENGTH_SLOT, curves_length_buf);
450 pass.push_constant("curves_start", 0);
451 pass.push_constant("curves_count", 2);
452 pass.push_constant("use_cyclic", false);
453 pass.dispatch(1);
455
456 manager.submit(pass);
457
458 evaluated_positions_radii_buf.read();
459 evaluated_time_buf.read();
460 curves_length_buf.read();
461
462 Vector<float> interp_data;
463 interp_data.resize(8);
464
466 GSpan(points_radius.as_span().slice(0, 3)),
467 false,
468 curve_resolution,
469 GMutableSpan(interp_data.as_mutable_span().slice(0, 5)));
470
472 GSpan(points_radius.as_span().slice(3, 2)),
473 false,
474 curve_resolution,
475 GMutableSpan(interp_data.as_mutable_span().slice(5, 3)));
476
477 EXPECT_EQ(evaluated_positions_radii_buf[0], float4(interp_data[0]));
478 EXPECT_EQ(evaluated_positions_radii_buf[1], float4(interp_data[1]));
479 EXPECT_EQ(evaluated_positions_radii_buf[2], float4(interp_data[2]));
480 EXPECT_EQ(evaluated_positions_radii_buf[3], float4(interp_data[3]));
481 EXPECT_EQ(evaluated_positions_radii_buf[4], float4(interp_data[4]));
482 EXPECT_EQ(evaluated_positions_radii_buf[5], float4(interp_data[5]));
483 EXPECT_EQ(evaluated_positions_radii_buf[6], float4(interp_data[6]));
484 EXPECT_EQ(evaluated_positions_radii_buf[7], float4(interp_data[7]));
485 /* Ensure the rest of the buffer is untouched. */
486 EXPECT_EQ(evaluated_positions_radii_buf[8], float4(0.0));
487
488 EXPECT_FLOAT_EQ(curves_length_buf[0], std::numbers::sqrt3);
489 EXPECT_FLOAT_EQ(curves_length_buf[1], 2.0f * std::numbers::sqrt3);
490
491 EXPECT_FLOAT_EQ(evaluated_time_buf[0], 0.0f);
492 EXPECT_FLOAT_EQ(evaluated_time_buf[1], 0.218749985f);
493 EXPECT_FLOAT_EQ(evaluated_time_buf[2], 0.5f);
494 EXPECT_FLOAT_EQ(evaluated_time_buf[3], 0.78125f);
495 EXPECT_FLOAT_EQ(evaluated_time_buf[4], 1.0f);
496 EXPECT_FLOAT_EQ(evaluated_time_buf[5], 0.0f);
497 EXPECT_FLOAT_EQ(evaluated_time_buf[6], 0.5f);
498 EXPECT_FLOAT_EQ(evaluated_time_buf[7], 1.0f);
499 /* Ensure the rest of the buffer is untouched. */
500 EXPECT_EQ(evaluated_time_buf[8], 0.0f);
501 }
502
503 const Vector<float3> handle_pos_left = {
504 float3{0.0f}, float3{1.0f}, float3{-1.0f}, float3{1.0f}, float3{4.0f}};
505 const Vector<float3> handle_pos_right = {
506 float3{0.0f}, float3{-1.0f}, float3{1.0f}, float3{-1.0f}, float3{0.0f}};
507
508 gpu::VertBuf *handles_positions_left_buf = GPU_vertbuf_create_with_format_ex(
509 Position::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
510 handles_positions_left_buf->allocate(handle_pos_left.size());
511 handles_positions_left_buf->data<float3>().copy_from(handle_pos_left);
512
513 gpu::VertBuf *handles_positions_right_buf = GPU_vertbuf_create_with_format_ex(
514 Position::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
515 handles_positions_right_buf->allocate(handle_pos_right.size());
516 handles_positions_right_buf->data<float3>().copy_from(handle_pos_right);
517
518 const Vector<int> bezier_offsets = {0, 2, 4, 5, 0, 2, 3};
519
521 IntBuf::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
522 bezier_offsets_buf->allocate(bezier_offsets.size());
523 bezier_offsets_buf->data<int>().copy_from(bezier_offsets);
524
525 gpu::VertBuf *curves_type_bezier_buf = GPU_vertbuf_create_with_format(IntBuf::format());
526 curves_type_bezier_buf->allocate(1);
527 curves_type_bezier_buf->data<char>().copy_from({CURVE_TYPE_BEZIER, CURVE_TYPE_BEZIER, 0, 0});
528
529 {
530 StorageArrayBuffer<float4, 512> evaluated_positions_radii_buf;
531 StorageArrayBuffer<float, 512> evaluated_time_buf;
532 StorageArrayBuffer<float, 512> curves_length_buf;
533 evaluated_positions_radii_buf.clear_to_zero();
534 evaluated_time_buf.clear_to_zero();
535 curves_length_buf.clear_to_zero();
536
537 PassSimple pass("Curves Interpolation Bezier");
538 pass.init();
539 pass.specialize_constant(sh, "evaluated_type", int(CURVE_TYPE_BEZIER));
540 pass.shader_set(sh);
541 pass.bind_ssbo(POINTS_BY_CURVES_SLOT, points_by_curve_buf);
542 pass.bind_ssbo(CURVE_TYPE_SLOT, curves_type_bezier_buf);
543 pass.bind_ssbo(CURVE_RESOLUTION_SLOT, curves_resolution_buf);
544 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
545 pass.bind_ssbo(POINT_POSITIONS_SLOT, positions_buf);
546 pass.bind_ssbo(POINT_RADII_SLOT, radii_buf);
547 pass.bind_ssbo(EVALUATED_POS_RAD_SLOT, evaluated_positions_radii_buf);
548 pass.push_constant("use_cyclic", false);
549 pass.bind_ssbo(CURVE_CYCLIC_SLOT, evaluated_points_by_curve_buf); /* Dummy, not used. */
550 pass.bind_ssbo(HANDLES_POS_LEFT_SLOT, handles_positions_left_buf);
551 pass.bind_ssbo(HANDLES_POS_RIGHT_SLOT, handles_positions_right_buf);
552 pass.bind_ssbo(BEZIER_OFFSETS_SLOT, bezier_offsets_buf);
553 pass.push_constant("curves_start", 0);
554 pass.push_constant("curves_count", 2);
555 pass.push_constant("transform", float4x4::identity());
556 pass.dispatch(1);
558 pass.shader_set(sh_length);
559 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
560 pass.bind_ssbo(EVALUATED_POS_RAD_SLOT, evaluated_positions_radii_buf);
561 pass.bind_ssbo(EVALUATED_TIME_SLOT, evaluated_time_buf);
562 pass.bind_ssbo(CURVES_LENGTH_SLOT, curves_length_buf);
563 pass.push_constant("curves_start", 0);
564 pass.push_constant("curves_count", 2);
565 pass.push_constant("use_cyclic", false);
566 pass.dispatch(1);
568
569 manager.submit(pass);
570
571 evaluated_positions_radii_buf.read();
572 evaluated_time_buf.read();
573 curves_length_buf.read();
574
575 Vector<float3> interp_pos;
576 interp_pos.resize(8);
577
578 Vector<float> interp_rad;
579 interp_rad.resize(8);
580
581 {
582 const int curve_index = 0;
583 const IndexRange points(0, 3);
584 const IndexRange evaluated_points(0, 5);
585 const IndexRange offsets = bke::curves::per_curve_point_offsets_range(points, curve_index);
586
588 positions.as_span().slice(points),
589 handle_pos_left.as_span().slice(points),
590 handle_pos_right.as_span().slice(points),
591 bezier_offsets.as_span().slice(offsets),
592 interp_pos.as_mutable_span().slice(evaluated_points));
593
595 points_radius.as_span().slice(points),
596 bezier_offsets.as_span().slice(offsets),
597 interp_rad.as_mutable_span().slice(evaluated_points));
598 }
599 {
600 const int curve_index = 1;
601 const IndexRange points(3, 2);
602 const IndexRange evaluated_points(5, 3);
603 const IndexRange offsets = bke::curves::per_curve_point_offsets_range(points, curve_index);
604
606 positions.as_span().slice(points),
607 handle_pos_left.as_span().slice(points),
608 handle_pos_right.as_span().slice(points),
609 bezier_offsets.as_span().slice(offsets),
610 interp_pos.as_mutable_span().slice(evaluated_points));
611
613 points_radius.as_span().slice(points),
614 bezier_offsets.as_span().slice(offsets),
615 interp_rad.as_mutable_span().slice(evaluated_points));
616 }
617
618 EXPECT_EQ(evaluated_positions_radii_buf[0], float4(interp_pos[0], interp_rad[0]));
619 EXPECT_EQ(evaluated_positions_radii_buf[1], float4(interp_pos[1], interp_rad[1]));
620 EXPECT_EQ(evaluated_positions_radii_buf[2], float4(interp_pos[2], interp_rad[2]));
621 EXPECT_EQ(evaluated_positions_radii_buf[3], float4(interp_pos[3], interp_rad[3]));
622 EXPECT_EQ(evaluated_positions_radii_buf[4], float4(interp_pos[4], interp_rad[4]));
623 EXPECT_EQ(evaluated_positions_radii_buf[5], float4(interp_pos[5], interp_rad[5]));
624 EXPECT_EQ(evaluated_positions_radii_buf[6], float4(interp_pos[6], interp_rad[6]));
625 EXPECT_EQ(evaluated_positions_radii_buf[7], float4(interp_pos[7], interp_rad[7]));
626 /* Ensure the rest of the buffer is untouched. */
627 EXPECT_EQ(evaluated_positions_radii_buf[8], float4(0.0));
628
629 float curve_len[2] = {0.0f, 0.0f};
630 Vector<float> interp_time{0.0f};
631 interp_time.resize(8);
632 interp_time[0] = 0.0f;
633 for (int i : IndexRange(1, 4)) {
634 curve_len[0] += math::distance(interp_pos[i], interp_pos[i - 1]);
635 interp_time[i] = curve_len[0];
636 }
637 for (int i : IndexRange(1, 4)) {
638 interp_time[i] /= curve_len[0];
639 }
640 interp_time[5] = 0.0f;
641 for (int i : IndexRange(6, 2)) {
642 curve_len[1] += math::distance(interp_pos[i], interp_pos[i - 1]);
643 interp_time[i] = curve_len[1];
644 }
645 for (int i : IndexRange(6, 2)) {
646 interp_time[i] /= curve_len[1];
647 }
648
649 EXPECT_FLOAT_EQ(curves_length_buf[0], curve_len[0]);
650 EXPECT_FLOAT_EQ(curves_length_buf[1], curve_len[1]);
651
652 EXPECT_FLOAT_EQ(evaluated_time_buf[0], interp_time[0]);
653 EXPECT_FLOAT_EQ(evaluated_time_buf[1], interp_time[1]);
654 EXPECT_FLOAT_EQ(evaluated_time_buf[2], interp_time[2]);
655 EXPECT_FLOAT_EQ(evaluated_time_buf[3], interp_time[3]);
656 EXPECT_FLOAT_EQ(evaluated_time_buf[4], interp_time[4]);
657 EXPECT_FLOAT_EQ(evaluated_time_buf[5], interp_time[5]);
658 EXPECT_FLOAT_EQ(evaluated_time_buf[6], interp_time[6]);
659 EXPECT_FLOAT_EQ(evaluated_time_buf[7], interp_time[7]);
660 /* Ensure the rest of the buffer is untouched. */
661 EXPECT_EQ(evaluated_time_buf[8], 0.0f);
662 }
663
664 const bke::curves::nurbs::BasisCache basis_cache_c0 = {
665 {0.1f, 0.2f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f},
666 {0, 0, 0, 0, 0},
667 false,
668 };
669 const bke::curves::nurbs::BasisCache basis_cache_c1 = {
670 {0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 2.0f},
671 {0, 0, 0},
672 false,
673 };
674
675 Vector<int> basis_cache_offset;
676 Vector<uint32_t> basis_cache_packed;
677 {
678 basis_cache_offset.append(basis_cache_c0.invalid ? -1 : basis_cache_packed.size());
679 basis_cache_packed.extend(
680 Span{reinterpret_cast<const uint32_t *>(basis_cache_c0.start_indices.data()),
681 basis_cache_c0.start_indices.size()});
682 basis_cache_packed.extend(
683 Span{reinterpret_cast<const uint32_t *>(basis_cache_c0.weights.data()),
684 basis_cache_c0.weights.size()});
685
686 basis_cache_offset.append(basis_cache_c1.invalid ? -1 : basis_cache_packed.size());
687 basis_cache_packed.extend(
688 Span{reinterpret_cast<const uint32_t *>(basis_cache_c1.start_indices.data()),
689 basis_cache_c1.start_indices.size()});
690 basis_cache_packed.extend(
691 Span{reinterpret_cast<const uint32_t *>(basis_cache_c1.weights.data()),
692 basis_cache_c1.weights.size()});
693 }
694
695 /* Raw data. Shader reinterpret as float or int. */
697 IntBuf::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
698 basis_cache_buf->allocate(basis_cache_packed.size());
699 basis_cache_buf->data<uint>().copy_from(basis_cache_packed);
700
701 gpu::VertBuf *basis_cache_offset_buf = GPU_vertbuf_create_with_format_ex(
702 IntBuf::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
703 basis_cache_offset_buf->allocate(basis_cache_offset.size());
704 basis_cache_offset_buf->data<int>().copy_from(basis_cache_offset);
705
706 const Vector<int8_t> curves_order = {3, 2, /* Padding. */ 0, 0};
707
709 IntBuf::format(), GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
710 curves_order_buf->allocate(curves_order.size() / 4);
711 curves_order_buf->data<int>().copy_from(
712 Span<int>(reinterpret_cast<const int *>(curves_order.data()), curves_order.size() / 4));
713
714 const Vector<float> control_weights = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
715
716 gpu::VertBuf *control_weights_buf = GPU_vertbuf_create_with_format(Radius::format());
717 control_weights_buf->allocate(control_weights.size());
718 control_weights_buf->data<float>().copy_from(control_weights);
719
720 gpu::VertBuf *curves_type_nurbs_buf = GPU_vertbuf_create_with_format(IntBuf::format());
721 curves_type_nurbs_buf->allocate(1);
722 curves_type_nurbs_buf->data<char>().copy_from({CURVE_TYPE_NURBS, CURVE_TYPE_NURBS, 0, 0});
723
724 {
725 StorageArrayBuffer<float4, 512> evaluated_positions_radii_buf;
726 StorageArrayBuffer<float, 512> evaluated_time_buf;
727 StorageArrayBuffer<float, 512> curves_length_buf;
728 evaluated_positions_radii_buf.clear_to_zero();
729 evaluated_time_buf.clear_to_zero();
730 curves_length_buf.clear_to_zero();
731
732 PassSimple pass("Curves Interpolation Nurbs");
733 pass.init();
734 pass.specialize_constant(sh, "evaluated_type", int(CURVE_TYPE_NURBS));
735 pass.shader_set(sh);
736 pass.bind_ssbo(POINTS_BY_CURVES_SLOT, points_by_curve_buf);
737 pass.bind_ssbo(CURVE_TYPE_SLOT, curves_type_nurbs_buf);
738 pass.bind_ssbo(CURVE_RESOLUTION_SLOT, curves_resolution_buf);
739 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
740 pass.bind_ssbo(POINT_POSITIONS_SLOT, positions_buf);
741 pass.bind_ssbo(POINT_RADII_SLOT, radii_buf);
742 pass.bind_ssbo(EVALUATED_POS_RAD_SLOT, evaluated_positions_radii_buf);
743 pass.push_constant("use_cyclic", false);
744 pass.bind_ssbo(CURVE_CYCLIC_SLOT, evaluated_points_by_curve_buf); /* Dummy, not used. */
745 pass.bind_ssbo(CURVES_ORDER_SLOT, curves_order_buf);
746 pass.bind_ssbo(BASIS_CACHE_SLOT, basis_cache_buf);
747 pass.bind_ssbo(CONTROL_WEIGHTS_SLOT, control_weights_buf);
748 pass.bind_ssbo(BASIS_CACHE_OFFSET_SLOT, basis_cache_offset_buf);
749 pass.push_constant("curves_start", 0);
750 pass.push_constant("curves_count", 2);
751 pass.push_constant("use_point_weight", true);
752 pass.push_constant("transform", float4x4::identity());
753 pass.dispatch(1);
755 pass.shader_set(sh_length);
756 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
757 pass.bind_ssbo(EVALUATED_POS_RAD_SLOT, evaluated_positions_radii_buf);
758 pass.bind_ssbo(EVALUATED_TIME_SLOT, evaluated_time_buf);
759 pass.bind_ssbo(CURVES_LENGTH_SLOT, curves_length_buf);
760 pass.push_constant("curves_start", 0);
761 pass.push_constant("curves_count", 2);
762 pass.push_constant("use_cyclic", false);
763 pass.dispatch(1);
765
766 manager.submit(pass);
767
768 evaluated_positions_radii_buf.read();
769 evaluated_time_buf.read();
770 curves_length_buf.read();
771
772 Vector<float3> interp_pos;
773 interp_pos.resize(8);
774
775 Vector<float> interp_rad;
776 interp_rad.resize(8);
777
778 {
779 const int curve_index = 0;
780 const IndexRange points(0, 3);
781 const IndexRange evaluated_points(0, 5);
782
784 basis_cache_c0,
785 curves_order[curve_index],
786 control_weights.as_span().slice(points),
787 positions.as_span().slice(points),
788 interp_pos.as_mutable_span().slice(evaluated_points));
789
791 basis_cache_c0,
792 curves_order[curve_index],
793 control_weights.as_span().slice(points),
794 points_radius.as_span().slice(points),
795 interp_rad.as_mutable_span().slice(evaluated_points));
796 }
797 {
798 const int curve_index = 1;
799 const IndexRange points(3, 2);
800 const IndexRange evaluated_points(5, 3);
801
803 basis_cache_c1,
804 curves_order[curve_index],
805 control_weights.as_span().slice(points),
806 positions.as_span().slice(points),
807 interp_pos.as_mutable_span().slice(evaluated_points));
808
810 basis_cache_c1,
811 curves_order[curve_index],
812 control_weights.as_span().slice(points),
813 points_radius.as_span().slice(points),
814 interp_rad.as_mutable_span().slice(evaluated_points));
815 }
816
817 EXPECT_NEAR(evaluated_positions_radii_buf[0].x, interp_pos[0].x, 0.000001f);
818 EXPECT_NEAR(evaluated_positions_radii_buf[1].x, interp_pos[1].x, 0.000001f);
819 EXPECT_NEAR(evaluated_positions_radii_buf[2].x, interp_pos[2].x, 0.000001f);
820 EXPECT_NEAR(evaluated_positions_radii_buf[3].x, interp_pos[3].x, 0.000001f);
821 EXPECT_NEAR(evaluated_positions_radii_buf[4].x, interp_pos[4].x, 0.000001f);
822 EXPECT_NEAR(evaluated_positions_radii_buf[5].x, interp_pos[5].x, 0.000001f);
823 EXPECT_NEAR(evaluated_positions_radii_buf[6].x, interp_pos[6].x, 0.000001f);
824 EXPECT_NEAR(evaluated_positions_radii_buf[7].x, interp_pos[7].x, 0.000001f);
825
826 EXPECT_NEAR(evaluated_positions_radii_buf[0].w, interp_rad[0], 0.000001f);
827 EXPECT_NEAR(evaluated_positions_radii_buf[1].w, interp_rad[1], 0.000001f);
828 EXPECT_NEAR(evaluated_positions_radii_buf[2].w, interp_rad[2], 0.000001f);
829 EXPECT_NEAR(evaluated_positions_radii_buf[3].w, interp_rad[3], 0.000001f);
830 EXPECT_NEAR(evaluated_positions_radii_buf[4].w, interp_rad[4], 0.000001f);
831 EXPECT_NEAR(evaluated_positions_radii_buf[5].w, interp_rad[5], 0.000001f);
832 EXPECT_NEAR(evaluated_positions_radii_buf[6].w, interp_rad[6], 0.000001f);
833 EXPECT_NEAR(evaluated_positions_radii_buf[7].w, interp_rad[7], 0.000001f);
834 /* Ensure the rest of the buffer is untouched. */
835 EXPECT_EQ(evaluated_positions_radii_buf[8], float4(0.0));
836
837 float curve_len[2] = {0.0f, 0.0f};
838 Vector<float> interp_time{0.0f};
839 interp_time.resize(8);
840 interp_time[0] = 0.0f;
841 for (int i : IndexRange(1, 4)) {
842 curve_len[0] += math::distance(interp_pos[i], interp_pos[i - 1]);
843 interp_time[i] = curve_len[0];
844 }
845 for (int i : IndexRange(1, 4)) {
846 interp_time[i] /= curve_len[0];
847 }
848 interp_time[5] = 0.0f;
849 for (int i : IndexRange(6, 2)) {
850 curve_len[1] += math::distance(interp_pos[i], interp_pos[i - 1]);
851 interp_time[i] = curve_len[1];
852 }
853 for (int i : IndexRange(6, 2)) {
854 interp_time[i] /= curve_len[1];
855 }
856
857 EXPECT_NEAR(curves_length_buf[0], curve_len[0], 0.000001f);
858 EXPECT_NEAR(curves_length_buf[1], curve_len[1], 0.000001f);
859
860 EXPECT_EQ(evaluated_time_buf[0], interp_time[0]);
861 EXPECT_NEAR(evaluated_time_buf[1], interp_time[1], 0.000001f);
862 EXPECT_NEAR(evaluated_time_buf[2], interp_time[2], 0.000001f);
863 EXPECT_NEAR(evaluated_time_buf[3], interp_time[3], 0.000001f);
864 EXPECT_NEAR(evaluated_time_buf[4], interp_time[4], 0.000001f);
865 EXPECT_EQ(evaluated_time_buf[5], interp_time[5]);
866 EXPECT_NEAR(evaluated_time_buf[6], interp_time[6], 0.000001f);
867 EXPECT_NEAR(evaluated_time_buf[7], interp_time[7], 0.000001f);
868 /* Ensure the rest of the buffer is untouched. */
869 EXPECT_EQ(evaluated_time_buf[8], 0.0f);
870 }
871
873
875 GPU_SHADER_FREE_SAFE(sh_length);
876 GPU_VERTBUF_DISCARD_SAFE(points_by_curve_buf);
877 GPU_VERTBUF_DISCARD_SAFE(curves_type_buf);
878 GPU_VERTBUF_DISCARD_SAFE(curves_type_bezier_buf);
879 GPU_VERTBUF_DISCARD_SAFE(curves_type_nurbs_buf);
880 GPU_VERTBUF_DISCARD_SAFE(curves_resolution_buf);
881 GPU_VERTBUF_DISCARD_SAFE(evaluated_points_by_curve_buf);
882 GPU_VERTBUF_DISCARD_SAFE(positions_buf);
883 GPU_VERTBUF_DISCARD_SAFE(radii_buf);
884 GPU_VERTBUF_DISCARD_SAFE(handles_positions_left_buf);
885 GPU_VERTBUF_DISCARD_SAFE(handles_positions_right_buf);
886 GPU_VERTBUF_DISCARD_SAFE(bezier_offsets_buf);
887 GPU_VERTBUF_DISCARD_SAFE(basis_cache_buf);
888 GPU_VERTBUF_DISCARD_SAFE(basis_cache_offset_buf);
889 GPU_VERTBUF_DISCARD_SAFE(curves_order_buf);
890 GPU_VERTBUF_DISCARD_SAFE(control_weights_buf);
891}
893
895{
896 Manager manager;
897
898 const int curve_resolution = 2;
899
900 const Vector<int> curves_to_point = {0, 3, 5, 7};
901 const Vector<int> evaluated_offsets = {0, 5, 8, 11};
902
903 struct IntBuf {
904 int data;
906 };
907 gpu::VertBuf *points_by_curve_buf = GPU_vertbuf_create_with_format(IntBuf::format());
908 points_by_curve_buf->allocate(curves_to_point.size());
909 points_by_curve_buf->data<int>().copy_from(curves_to_point);
910
911 gpu::VertBuf *curves_type_buf = GPU_vertbuf_create_with_format(IntBuf::format());
912 curves_type_buf->allocate(1);
913 curves_type_buf->data<char>().copy_from(
915
916 gpu::VertBuf *curves_resolution_buf = GPU_vertbuf_create_with_format(IntBuf::format());
917 curves_resolution_buf->allocate(3);
918 curves_resolution_buf->data<int>().copy_from(
919 {curve_resolution, curve_resolution, curve_resolution});
920
921 gpu::VertBuf *evaluated_points_by_curve_buf = GPU_vertbuf_create_with_format(IntBuf::format());
922 evaluated_points_by_curve_buf->allocate(evaluated_offsets.size());
923 evaluated_points_by_curve_buf->data<int>().copy_from(evaluated_offsets);
924
925 /* Attributes. */
926
927 const Vector<float4> attr_float4 = {float4(1.0f, 0.5f, 0.0f, 0.5f),
928 float4(0.5f, 0.0f, 0.0f, 4.0f),
929 float4(0.0f, 0.0f, 2.0f, 4.0f),
930 float4(2.0f, 3.0f, 4.0f, 7.0f),
931 float4(3.0f, 4.0f, 3.0f, 4.0f),
932 float4(2.0f, 2.0f, 3.0f, 4.0f),
933 float4(4.0f, 5.0f, 6.0f, 7.0f)};
934 const Vector<float3> attr_float3 =
935 attr_float4.as_span().cast<float>().take_front(attr_float4.size() * 3).cast<float3>();
936 const Vector<float2> attr_float2 =
937 attr_float4.as_span().cast<float>().take_front(attr_float4.size() * 2).cast<float2>();
938 const Vector<float> attr_float = attr_float4.as_span().cast<float>().take_front(
939 attr_float4.size());
940
941 struct Float4 {
942 float4 value;
944 };
945 gpu::VertBuf *attribute_float4_buf = GPU_vertbuf_create_with_format(Float4::format());
946 attribute_float4_buf->allocate(attr_float4.size());
947 attribute_float4_buf->data<float4>().copy_from(attr_float4);
948
949 struct Float3 {
950 float3 value;
952 };
953 gpu::VertBuf *attribute_float3_buf = GPU_vertbuf_create_with_format(Float3::format());
954 attribute_float3_buf->allocate(attr_float4.size());
955 attribute_float3_buf->data<float3>().copy_from(attr_float3);
956
957 struct Float2 {
958 float2 value;
960 };
961 gpu::VertBuf *attribute_float2_buf = GPU_vertbuf_create_with_format(Float2::format());
962 attribute_float2_buf->allocate(attr_float4.size());
963 attribute_float2_buf->data<float2>().copy_from(attr_float2);
964
965 struct Float {
966 float value;
968 };
969 gpu::VertBuf *attribute_float_buf = GPU_vertbuf_create_with_format(Float::format());
970 attribute_float_buf->allocate(attr_float4.size());
971 attribute_float_buf->data<float>().copy_from(attr_float);
972
973 /* Nurbs. */
974
975 const bke::curves::nurbs::BasisCache basis_cache_c0 = {
976 {0.1f, 0.2f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f},
977 {0, 0, 0, 0, 0},
978 false,
979 };
980
981 Vector<int> basis_cache_offset;
982 Vector<uint32_t> basis_cache_packed;
983 {
984 basis_cache_offset.append(basis_cache_c0.invalid ? -1 : basis_cache_packed.size());
985 basis_cache_packed.extend(
986 Span{reinterpret_cast<const uint32_t *>(basis_cache_c0.start_indices.data()),
987 basis_cache_c0.start_indices.size()});
988 basis_cache_packed.extend(
989 Span{reinterpret_cast<const uint32_t *>(basis_cache_c0.weights.data()),
990 basis_cache_c0.weights.size()});
991
992 basis_cache_offset.append(-1);
993 basis_cache_offset.append(-1);
994 }
995
996 /* Raw data. Shader reinterpret as float or int. */
997 gpu::VertBuf *basis_cache_buf = GPU_vertbuf_create_with_format(IntBuf::format());
998 basis_cache_buf->allocate(basis_cache_packed.size());
999 basis_cache_buf->data<uint>().copy_from(basis_cache_packed);
1000
1001 gpu::VertBuf *basis_cache_offset_buf = GPU_vertbuf_create_with_format(IntBuf::format());
1002 basis_cache_offset_buf->allocate(basis_cache_offset.size());
1003 basis_cache_offset_buf->data<int>().copy_from(basis_cache_offset);
1004
1005 const Vector<int8_t> curves_order = {3, 0, 0, /* Padding. */ 0};
1006
1007 gpu::VertBuf *curves_order_buf = GPU_vertbuf_create_with_format(IntBuf::format());
1008 curves_order_buf->allocate(curves_order.size() / 4);
1009 curves_order_buf->data<int>().copy_from(
1010 Span<int>(reinterpret_cast<const int *>(curves_order.data()), curves_order.size() / 4));
1011
1012 const Vector<float> control_weights = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
1013
1014 gpu::VertBuf *control_weights_buf = GPU_vertbuf_create_with_format(Float::format());
1015 control_weights_buf->allocate(control_weights.size());
1016 control_weights_buf->data<float>().copy_from(control_weights);
1017
1018 /* Bezier */
1019
1020 const Vector<float3> handle_pos_left = {
1021 float3{0.0f}, float3{1.0f}, float3{-1.0f}, float3{1.0f}, float3{4.0f}};
1022 const Vector<float3> handle_pos_right = {
1023 float3{0.0f}, float3{-1.0f}, float3{1.0f}, float3{-1.0f}, float3{0.0f}};
1024
1025 gpu::VertBuf *handles_positions_left_buf = GPU_vertbuf_create_with_format(Float3::format());
1026 handles_positions_left_buf->allocate(handle_pos_left.size());
1027 handles_positions_left_buf->data<float3>().copy_from(handle_pos_left);
1028
1029 gpu::VertBuf *handles_positions_right_buf = GPU_vertbuf_create_with_format(Float3::format());
1030 handles_positions_right_buf->allocate(handle_pos_right.size());
1031 handles_positions_right_buf->data<float3>().copy_from(handle_pos_right);
1032
1033 const Vector<int> bezier_offsets = {0, 2, 4, 5, 0, 2, 3};
1034
1035 gpu::VertBuf *bezier_offsets_buf = GPU_vertbuf_create_with_format(IntBuf::format());
1036 bezier_offsets_buf->allocate(bezier_offsets.size());
1037 bezier_offsets_buf->data<int>().copy_from(bezier_offsets);
1038
1039 auto dispatch =
1040 [&](const char *attr_type, gpu::VertBuf *attr_buf, gpu::StorageBuf *evaluated_attr_buf) {
1041 std::string pass_name = std::string("Curves ") + attr_type + " Interpolation";
1042 std::string sh_name = std::string("draw_curves_interpolate_") + attr_type + "_attribute";
1043 /* Make sure all references to the strings are deleted before the strings themselves. */
1044 {
1045 gpu::Shader *sh = GPU_shader_create_from_info_name(sh_name.c_str());
1046
1047 PassSimple pass(pass_name.c_str());
1048 pass.init();
1049 pass.specialize_constant(sh, "evaluated_type", int(CURVE_TYPE_CATMULL_ROM));
1050 pass.shader_set(sh);
1051 pass.bind_ssbo(POINTS_BY_CURVES_SLOT, points_by_curve_buf);
1052 pass.bind_ssbo(CURVE_TYPE_SLOT, curves_type_buf);
1053 pass.bind_ssbo(CURVE_CYCLIC_SLOT, curves_type_buf); /* Dummy, not used */
1054 pass.bind_ssbo(CURVE_RESOLUTION_SLOT, curves_resolution_buf);
1055 pass.bind_ssbo(EVALUATED_POINT_SLOT, evaluated_points_by_curve_buf);
1056 pass.bind_ssbo(POINT_ATTR_SLOT, attr_buf);
1057 pass.bind_ssbo(EVALUATED_ATTR_SLOT, evaluated_attr_buf);
1058 /* Dummy, not used for Catmull-Rom. */
1059 pass.bind_ssbo(HANDLES_POS_LEFT_SLOT, evaluated_points_by_curve_buf);
1060 pass.bind_ssbo(HANDLES_POS_RIGHT_SLOT, evaluated_points_by_curve_buf);
1061 pass.bind_ssbo(BEZIER_OFFSETS_SLOT, evaluated_points_by_curve_buf);
1062 pass.push_constant("use_cyclic", false);
1063 pass.push_constant("curves_start", 0);
1064 pass.push_constant("curves_count", 3);
1065 pass.dispatch(1);
1066 pass.specialize_constant(sh, "evaluated_type", int(CURVE_TYPE_BEZIER));
1067 pass.shader_set(sh);
1068 pass.bind_ssbo(HANDLES_POS_LEFT_SLOT, handles_positions_left_buf);
1069 pass.bind_ssbo(HANDLES_POS_RIGHT_SLOT, handles_positions_right_buf);
1070 pass.bind_ssbo(BEZIER_OFFSETS_SLOT, bezier_offsets_buf);
1071 pass.push_constant("use_cyclic", false);
1072 pass.push_constant("curves_start", 0);
1073 pass.push_constant("curves_count", 3);
1074 pass.dispatch(1);
1075 pass.specialize_constant(sh, "evaluated_type", int(CURVE_TYPE_NURBS));
1076 pass.shader_set(sh);
1077 pass.bind_ssbo(CURVES_ORDER_SLOT, curves_order_buf);
1078 pass.bind_ssbo(BASIS_CACHE_SLOT, basis_cache_buf);
1079 pass.bind_ssbo(CONTROL_WEIGHTS_SLOT, control_weights_buf);
1080 pass.bind_ssbo(BASIS_CACHE_OFFSET_SLOT, basis_cache_offset_buf);
1081 pass.push_constant("use_cyclic", false);
1082 pass.push_constant("curves_start", 0);
1083 pass.push_constant("curves_count", 3);
1084 pass.push_constant("use_point_weight", true);
1085 pass.dispatch(1);
1087
1088 manager.submit(pass);
1089
1091
1093 }
1094 };
1095
1096 {
1097 StorageArrayBuffer<float4, 512> evaluated_float4_buf;
1098 evaluated_float4_buf.clear_to_zero();
1099
1100 dispatch("float4", attribute_float4_buf, evaluated_float4_buf);
1101
1102 evaluated_float4_buf.read();
1103
1104 Vector<float4> interp_data;
1105 interp_data.resize(11);
1106
1107 OffsetIndices<int> curves_to_point_indices(curves_to_point.as_span());
1108 OffsetIndices<int> curves_to_eval_indices(evaluated_offsets.as_span());
1109 Span<ColorGeometry4f> in_attr = attr_float4.as_span().cast<ColorGeometry4f>();
1110 MutableSpan<ColorGeometry4f> out_attr = interp_data.as_mutable_span().cast<ColorGeometry4f>();
1111 {
1112 const int curve_index = 0;
1113 const IndexRange points = curves_to_point_indices[curve_index];
1114 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1116 curves_order[curve_index],
1117 control_weights.as_span().slice(points),
1118 in_attr.slice(points),
1119 out_attr.slice(evaluated_points));
1120 }
1121 {
1122 const int curve_index = 1;
1123 const IndexRange points = curves_to_point_indices[curve_index];
1124 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1125 const IndexRange offsets = bke::curves::per_curve_point_offsets_range(points, curve_index);
1127 bezier_offsets.as_span().slice(offsets),
1128 out_attr.slice(evaluated_points));
1129 }
1130 {
1131 const int curve_index = 2;
1132 const IndexRange points = curves_to_point_indices[curve_index];
1133 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1135 in_attr.slice(points), false, curve_resolution, out_attr.slice(evaluated_points));
1136 }
1137
1138 EXPECT_EQ(evaluated_float4_buf[0], float4(interp_data[0]));
1139 EXPECT_EQ(evaluated_float4_buf[1], float4(interp_data[1]));
1140 EXPECT_EQ(evaluated_float4_buf[2], float4(interp_data[2]));
1141 EXPECT_EQ(evaluated_float4_buf[3], float4(interp_data[3]));
1142 EXPECT_EQ(evaluated_float4_buf[4], float4(interp_data[4]));
1143 EXPECT_EQ(evaluated_float4_buf[5], float4(interp_data[5]));
1144 EXPECT_EQ(evaluated_float4_buf[6], float4(interp_data[6]));
1145 EXPECT_EQ(evaluated_float4_buf[7], float4(interp_data[7]));
1146 EXPECT_EQ(evaluated_float4_buf[8], float4(interp_data[8]));
1147 EXPECT_EQ(evaluated_float4_buf[9], float4(interp_data[9]));
1148 EXPECT_EQ(evaluated_float4_buf[10], float4(interp_data[10]));
1149 /* Ensure the rest of the buffer is untouched. */
1150 EXPECT_EQ(evaluated_float4_buf[11], float4(0.0));
1151 }
1152
1153 {
1154 StorageArrayBuffer<float3, 512> evaluated_float3_buf;
1155 evaluated_float3_buf.clear_to_zero();
1156
1157 dispatch("float3", attribute_float3_buf, evaluated_float3_buf);
1158
1159 evaluated_float3_buf.read();
1160
1161 Vector<float3> interp_data;
1162 interp_data.resize(11);
1163
1164 OffsetIndices<int> curves_to_point_indices(curves_to_point.as_span());
1165 OffsetIndices<int> curves_to_eval_indices(evaluated_offsets.as_span());
1166 Span<float3> in_attr = attr_float3.as_span();
1167 MutableSpan<float3> out_attr = interp_data.as_mutable_span();
1168 {
1169 const int curve_index = 0;
1170 const IndexRange points = curves_to_point_indices[curve_index];
1171 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1173 curves_order[curve_index],
1174 control_weights.as_span().slice(points),
1175 in_attr.slice(points),
1176 out_attr.slice(evaluated_points));
1177 }
1178 {
1179 const int curve_index = 1;
1180 const IndexRange points = curves_to_point_indices[curve_index];
1181 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1182 const IndexRange offsets = bke::curves::per_curve_point_offsets_range(points, curve_index);
1184 bezier_offsets.as_span().slice(offsets),
1185 out_attr.slice(evaluated_points));
1186 }
1187 {
1188 const int curve_index = 2;
1189 const IndexRange points = curves_to_point_indices[curve_index];
1190 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1192 in_attr.slice(points), false, curve_resolution, out_attr.slice(evaluated_points));
1193 }
1194
1195 EXPECT_EQ(evaluated_float3_buf[0], float3(interp_data[0]));
1196 EXPECT_EQ(evaluated_float3_buf[1], float3(interp_data[1]));
1197 EXPECT_EQ(evaluated_float3_buf[2], float3(interp_data[2]));
1198 EXPECT_EQ(evaluated_float3_buf[3], float3(interp_data[3]));
1199 EXPECT_EQ(evaluated_float3_buf[4], float3(interp_data[4]));
1200 EXPECT_EQ(evaluated_float3_buf[5], float3(interp_data[5]));
1201 EXPECT_EQ(evaluated_float3_buf[6], float3(interp_data[6]));
1202 EXPECT_EQ(evaluated_float3_buf[7], float3(interp_data[7]));
1203 EXPECT_EQ(evaluated_float3_buf[8], float3(interp_data[8]));
1204 EXPECT_EQ(evaluated_float3_buf[9], float3(interp_data[9]));
1205 EXPECT_EQ(evaluated_float3_buf[10], float3(interp_data[10]));
1206 /* Ensure the rest of the buffer is untouched. */
1207 EXPECT_EQ(evaluated_float3_buf[11], float3(0.0));
1208 }
1209
1210 {
1211 StorageArrayBuffer<float2, 512> evaluated_float2_buf;
1212 evaluated_float2_buf.clear_to_zero();
1213
1214 dispatch("float2", attribute_float2_buf, evaluated_float2_buf);
1215
1216 evaluated_float2_buf.read();
1217
1218 Vector<float2> interp_data;
1219 interp_data.resize(11);
1220
1221 OffsetIndices<int> curves_to_point_indices(curves_to_point.as_span());
1222 OffsetIndices<int> curves_to_eval_indices(evaluated_offsets.as_span());
1223 Span<float2> in_attr = attr_float2.as_span();
1224 MutableSpan<float2> out_attr = interp_data.as_mutable_span();
1225 {
1226 const int curve_index = 0;
1227 const IndexRange points = curves_to_point_indices[curve_index];
1228 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1230 curves_order[curve_index],
1231 control_weights.as_span().slice(points),
1232 in_attr.slice(points),
1233 out_attr.slice(evaluated_points));
1234 }
1235 {
1236 const int curve_index = 1;
1237 const IndexRange points = curves_to_point_indices[curve_index];
1238 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1239 const IndexRange offsets = bke::curves::per_curve_point_offsets_range(points, curve_index);
1241 bezier_offsets.as_span().slice(offsets),
1242 out_attr.slice(evaluated_points));
1243 }
1244 {
1245 const int curve_index = 2;
1246 const IndexRange points = curves_to_point_indices[curve_index];
1247 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1249 in_attr.slice(points), false, curve_resolution, out_attr.slice(evaluated_points));
1250 }
1251
1252 EXPECT_EQ(evaluated_float2_buf[0], float2(interp_data[0]));
1253 EXPECT_EQ(evaluated_float2_buf[1], float2(interp_data[1]));
1254 EXPECT_EQ(evaluated_float2_buf[2], float2(interp_data[2]));
1255 EXPECT_EQ(evaluated_float2_buf[3], float2(interp_data[3]));
1256 EXPECT_EQ(evaluated_float2_buf[4], float2(interp_data[4]));
1257 EXPECT_EQ(evaluated_float2_buf[5], float2(interp_data[5]));
1258 EXPECT_EQ(evaluated_float2_buf[6], float2(interp_data[6]));
1259 EXPECT_EQ(evaluated_float2_buf[7], float2(interp_data[7]));
1260 EXPECT_EQ(evaluated_float2_buf[8], float2(interp_data[8]));
1261 EXPECT_EQ(evaluated_float2_buf[9], float2(interp_data[9]));
1262 EXPECT_EQ(evaluated_float2_buf[10], float2(interp_data[10]));
1263 /* Ensure the rest of the buffer is untouched. */
1264 EXPECT_EQ(evaluated_float2_buf[11], float2(0.0));
1265 }
1266
1267 {
1268 StorageArrayBuffer<float, 512> evaluated_float_buf;
1269 evaluated_float_buf.clear_to_zero();
1270
1271 dispatch("float", attribute_float_buf, evaluated_float_buf);
1272
1273 evaluated_float_buf.read();
1274
1275 Vector<float> interp_data;
1276 interp_data.resize(11);
1277
1278 OffsetIndices<int> curves_to_point_indices(curves_to_point.as_span());
1279 OffsetIndices<int> curves_to_eval_indices(evaluated_offsets.as_span());
1280 Span<float> in_attr = attr_float.as_span();
1281 MutableSpan<float> out_attr = interp_data.as_mutable_span();
1282 {
1283 const int curve_index = 0;
1284 const IndexRange points = curves_to_point_indices[curve_index];
1285 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1287 curves_order[curve_index],
1288 control_weights.as_span().slice(points),
1289 in_attr.slice(points),
1290 out_attr.slice(evaluated_points));
1291 }
1292 {
1293 const int curve_index = 1;
1294 const IndexRange points = curves_to_point_indices[curve_index];
1295 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1296 const IndexRange offsets = bke::curves::per_curve_point_offsets_range(points, curve_index);
1298 bezier_offsets.as_span().slice(offsets),
1299 out_attr.slice(evaluated_points));
1300 }
1301 {
1302 const int curve_index = 2;
1303 const IndexRange points = curves_to_point_indices[curve_index];
1304 const IndexRange evaluated_points = curves_to_eval_indices[curve_index];
1306 in_attr.slice(points), false, curve_resolution, out_attr.slice(evaluated_points));
1307 }
1308
1309 EXPECT_EQ(evaluated_float_buf[0], float(interp_data[0]));
1310 EXPECT_EQ(evaluated_float_buf[1], float(interp_data[1]));
1311 EXPECT_EQ(evaluated_float_buf[2], float(interp_data[2]));
1312 EXPECT_EQ(evaluated_float_buf[3], float(interp_data[3]));
1313 EXPECT_EQ(evaluated_float_buf[4], float(interp_data[4]));
1314 EXPECT_EQ(evaluated_float_buf[5], float(interp_data[5]));
1315 EXPECT_EQ(evaluated_float_buf[6], float(interp_data[6]));
1316 EXPECT_EQ(evaluated_float_buf[7], float(interp_data[7]));
1317 EXPECT_EQ(evaluated_float_buf[8], float(interp_data[8]));
1318 EXPECT_EQ(evaluated_float_buf[9], float(interp_data[9]));
1319 EXPECT_EQ(evaluated_float_buf[10], float(interp_data[10]));
1320 /* Ensure the rest of the buffer is untouched. */
1321 EXPECT_EQ(evaluated_float_buf[11], float(0.0));
1322 }
1323
1324 GPU_VERTBUF_DISCARD_SAFE(points_by_curve_buf);
1325 GPU_VERTBUF_DISCARD_SAFE(curves_type_buf);
1326 GPU_VERTBUF_DISCARD_SAFE(curves_resolution_buf);
1327 GPU_VERTBUF_DISCARD_SAFE(evaluated_points_by_curve_buf);
1328 GPU_VERTBUF_DISCARD_SAFE(handles_positions_left_buf);
1329 GPU_VERTBUF_DISCARD_SAFE(handles_positions_right_buf);
1330 GPU_VERTBUF_DISCARD_SAFE(bezier_offsets_buf);
1331 GPU_VERTBUF_DISCARD_SAFE(basis_cache_buf);
1332 GPU_VERTBUF_DISCARD_SAFE(basis_cache_offset_buf);
1333 GPU_VERTBUF_DISCARD_SAFE(curves_order_buf);
1334 GPU_VERTBUF_DISCARD_SAFE(control_weights_buf);
1335 GPU_VERTBUF_DISCARD_SAFE(attribute_float4_buf);
1336 GPU_VERTBUF_DISCARD_SAFE(attribute_float3_buf);
1337 GPU_VERTBUF_DISCARD_SAFE(attribute_float2_buf);
1338 GPU_VERTBUF_DISCARD_SAFE(attribute_float_buf);
1339}
1340DRAW_TEST(draw_curves_interpolate_attributes)
1341
1342} // namespace blender::draw
Low-level operations for curves.
#define GPU_BATCH_DISCARD_SAFE(batch)
Definition GPU_batch.hh:199
#define GPU_SHADER_FREE_SAFE(shader)
#define GPU_VERTBUF_DISCARD_SAFE(verts)
#define GPU_VERTEX_FORMAT_FUNC(_VertT,...)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
GSpan()=default
constexpr IndexRange()=default
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
int64_t size() const
void append(const T &value)
void resize(const int64_t new_size)
MutableSpan< T > as_mutable_span()
void extend(Span< T > array)
Span< T > as_span() const
void submit(PassSimple &pass, View &view)
void framebuffer_set(gpu::FrameBuffer **framebuffer)
void shader_set(gpu::Shader *shader)
void bind_texture(const char *name, gpu::Texture *texture, GPUSamplerState state=sampler_auto)
void specialize_constant(gpu::Shader *shader, const char *name, const float &data)
void dispatch(int group_len)
void barrier(GPUBarrier type)
void bind_ubo(const char *name, gpu::UniformBuf *buffer)
void push_constant(const char *name, const float &data)
void bind_ssbo(const char *name, gpu::StorageBuf *buffer)
void draw(gpu::Batch *batch, uint instance_len=-1, uint vertex_len=-1, uint vertex_first=-1, ResourceIDRange res_id={}, uint custom_id=0)
Definition draw_pass.hh:906
void allocate(uint vert_len)
MutableSpan< T > data()
#define HANDLES_POS_LEFT_SLOT
#define CONTROL_WEIGHTS_SLOT
#define BASIS_CACHE_OFFSET_SLOT
#define POINT_ATTR_SLOT
#define EVALUATED_ATTR_SLOT
#define CURVE_TYPE_SLOT
#define POINT_RADII_SLOT
#define BASIS_CACHE_SLOT
#define CURVES_ORDER_SLOT
#define POINTS_BY_CURVES_SLOT
#define EVALUATED_POS_RAD_SLOT
#define EVALUATED_TIME_SLOT
#define EVALUATED_POINT_SLOT
#define CURVES_LENGTH_SLOT
#define HANDLES_POS_RIGHT_SLOT
#define CURVE_CYCLIC_SLOT
#define BEZIER_OFFSETS_SLOT
#define POINT_POSITIONS_SLOT
#define CURVE_RESOLUTION_SLOT
PipelineCompute draw_curves_interpolate_position(curves::evaluate_curve< curves::InterpPosition, float4 >)
PipelineCompute draw_curves_topology(curves::eval_topology)
#define DRAW_TEST(test_name)
#define isnan
#define EXPECT_TRUE(result)
#define EXPECT_NEAR(result, expect, threshold)
void calculate_evaluated_positions(Span< float3 > positions, Span< float3 > handles_left, Span< float3 > handles_right, OffsetIndices< int > evaluated_offsets, MutableSpan< float3 > evaluated_positions)
void interpolate_to_evaluated(GSpan src, OffsetIndices< int > evaluated_offsets, GMutableSpan dst)
void interpolate_to_evaluated(GSpan src, bool cyclic, int resolution, GMutableSpan dst)
void interpolate_to_evaluated(const BasisCache &basis_cache, int8_t order, Span< float > control_weights, GSpan src, GMutableSpan dst)
IndexRange per_curve_point_offsets_range(const IndexRange points, const int curve_index)
detail::Pass< command::DrawCommandBuf > PassSimple
static void test_draw_curves_interpolate_attributes()
static void test_draw_curves_lib()
static void test_draw_curves_interpolate_position()
static void test_draw_curves_topology()
T distance(const T &a, const T &b)
gpu::Batch * GPU_batch_create_procedural(GPUPrimType primitive_type, int32_t vertex_count)
Definition gpu_batch.cc:85
VecBase< int32_t, 4 > int4
unsigned int uint
Definition BKE_text.h:55
BLI_INLINE float fb(float length, float L)
gpu::Shader * GPU_shader_create_from_info_name(const char *info_name)
@ GPU_PRIM_TRI_STRIP
VecBase< float, 4 > float4
unsigned int uint32_t
Definition BKE_text.h:81
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
BMesh const char void * data
void GPU_shader_unbind()
@ GPU_BARRIER_BUFFER_UPDATE
Definition GPU_state.hh:59
@ GPU_BARRIER_SHADER_STORAGE
Definition GPU_state.hh:51
gpu::VertBuf * GPU_vertbuf_create_with_format_ex(const GPUVertFormat &format, GPUUsageType usage)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
@ CURVE_TYPE_CATMULL_ROM
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
VecBase< float, 3 > float3
@ GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY
int size() const
Definition vector.hh:130