20#include "gpu_shader_offset_indices_lib.glsl"
31template<
typename StoredT,
typename T>
struct AttribBuf {
74template struct AttribBuf<StoredFloat, float>;
75template struct AttribBuf<StoredFloat2, float2>;
76template struct AttribBuf<StoredFloat3, float3>;
77template struct AttribBuf<StoredFloat4, float4>;
108 data.w =
max(0.0f, data.w);
137template<
typename DataT> DataT
mix4(DataT v0, DataT v1, DataT v2, DataT v3,
float4 w)
139 v0 = v0 *
w.x + v1 *
w.y + v2 *
w.z + v3 *
w.w;
195 const float t = parameter;
196 const float s = 1.0f - parameter;
197 return 0.5f *
float4(-t * s * s,
198 2.0f + t * t * (3.0f * t - 5.0f),
199 2.0f + s * s * (3.0f * s - 5.0f),
205 int4 point_ids = int(point_id) +
int4(-1, +0, +1, +2);
208 point_ids = ((point_ids + points.size()) % points.size());
211 point_ids =
clamp(point_ids,
int4(0),
int4(points.size() - 1));
213 return points.start() + point_ids;
216template<
typename StorageT,
typename AttrT>
219 const IndexRange points,
220 const IndexRange evaluated_points,
221 const int curve_index)
223 const uint curve_resolution = srt.curves_resolution_buf[curve_index];
224 const bool is_curve_cyclic = srt.curve_cyclic_get(curve_index);
226 const uint evaluated_points_count = uint(evaluated_points.size());
227 for (uint i = 0; i < evaluated_points_count; i++) {
228 const int evaluated_point_id = evaluated_points.start() + int(i);
229 const uint point_id = i / curve_resolution;
230 const float parameter =
float(i % curve_resolution) /
float(curve_resolution);
232 const int4 point_ids =
get_points(point_id, points, is_curve_cyclic);
234 attr.output_write(evaluated_point_id,
235 mix4(attr.input_load(point_ids.
x),
236 attr.input_load(point_ids.
y),
237 attr.input_load(point_ids.
z),
238 attr.input_load(point_ids.
w),
258template<
typename StorageT,
typename AttrT>
262 const IndexRange result)
264 AttrT p0 = attr.input_load(points.
x);
265 AttrT p1 = attr.input_load(points.
y);
267 const float step = 1.0f /
float(result.size());
268 for (
int i = 0; i < result.size(); i++) {
269 attr.output_write(result.start() + i,
mix(p0, p1,
float(i) *
step));
278 const IndexRange result)
280 const auto &handles_right = srt.handles_positions_right_buf;
281 const auto &handles_left = srt.handles_positions_left_buf;
283 float4 p0 = attr.input_load(points.
x);
284 float4 p1 = attr.input_load(points.
y);
286 const float3 point_0 = p0.xyz;
289 const float3 point_3 = p1.xyz;
291 const float rad_0 = p0.
w;
292 const float rad_1 = p1.
w;
295 const float inv_len = 1.0f /
float(result.size());
296 const float inv_len_squared = inv_len * inv_len;
297 const float inv_len_cubed = inv_len_squared * inv_len;
299 const float3 rt1 = 3.0f * (point_1 - point_0) * inv_len;
300 const float3 rt2 = 3.0f * (point_0 - 2.0f * point_1 + point_2) * inv_len_squared;
301 const float3 rt3 = (point_3 - point_0 + 3.0f * (point_1 - point_2)) * inv_len_cubed;
304 float3 q1 = rt1 + rt2 + rt3;
305 float3 q2 = 2.0f * rt2 + 6.0f * rt3;
307 for (
int i = 0; i < result.size(); i++) {
308 float rad =
mix(rad_0, rad_1,
float(i) * inv_len);
309 attr.output_write(result.start() + i,
float4(q0, rad));
335 return {curve_index + points.start(), points.size() + 1};
340 int2 point_ids = int(point_id) +
int2(+0, +1);
343 point_ids = ((point_ids + points.size()) % points.size());
346 point_ids =
clamp(point_ids,
int2(0),
int2(points.size() - 1));
348 return points.start() + point_ids;
351template<
typename StorageT,
typename AttrT>
354 const IndexRange points,
355 const IndexRange evaluated_points,
356 const int curve_index)
360 const bool is_curve_cyclic = srt.curve_cyclic_get(curve_index);
362 for (
int i = 0; i < points.size(); i++) {
364 const IndexRange segment_range = offset_indices::load_range_from_buffer(srt.bezier_offsets_buf,
365 offsets.start() + i);
366 const IndexRange evaluated_segment_range = evaluated_points.slice(segment_range);
367 const int2 point_ids =
get_points(uint(i), points, is_curve_cyclic);
372 if (is_curve_cyclic) {
374 attr.output_write(evaluated_points.last(), attr.output_load(evaluated_points.first()));
391template<
typename StorageT,
typename AttrT>
394 const IndexRange points,
395 const IndexRange evaluated_points,
396 const int curve_index)
398 assert(points.size == evaluated_points.size);
399 const bool is_curve_cyclic = srt.curve_cyclic_get(curve_index);
401 for (
int i = 0; i < points.size(); i++) {
402 attr.output_write(evaluated_points.start() + i, attr.input_load(points.start() + i));
405 if (is_curve_cyclic) {
407 attr.output_write(evaluated_points.last(), attr.output_load(evaluated_points.first()));
424template<
typename StorageT,
typename AttrT>
427 const IndexRange points,
428 const IndexRange evaluated_points_padded,
429 const int curve_index)
432 const auto &curves_order_buf = srt.curves_resolution_buf;
433 const auto &basis_cache_offset_buf = srt.bezier_offsets_buf;
437 const int basis_cache_start = basis_cache_offset_buf[curve_index];
438 const bool invalid = basis_cache_start < 0;
445 const bool is_curve_cyclic = srt.curve_cyclic_get(curve_index);
448 const IndexRange evaluated_points{evaluated_points_padded.start(),
449 evaluated_points_padded.size() - int(srt.use_cyclic)};
451 const int start_indices_range_start = basis_cache_start;
452 const int weights_range_start = basis_cache_start + evaluated_points.size();
455 const auto &basis_cache_buf = srt.handles_positions_left_buf;
456 const auto &control_weights_buf = srt.handles_positions_right_buf;
458 for (
int i = 0; i < evaluated_points.size(); i++) {
459 int evaluated_point_index = evaluated_points.start() + i;
461 attr.output_set_zero(evaluated_point_index);
462 float total_weight = 0.0f;
464 const IndexRange point_weights{weights_range_start + i * int(order), int(order)};
465 const int start_index =
floatBitsToInt(basis_cache_buf[start_indices_range_start + i]);
467 for (
int j = 0; j < point_weights.size(); j++) {
468 const int point_index = points.start() + (start_index + j) % points.size();
469 const float point_weight = basis_cache_buf[point_weights.start() + j];
470 const float control_weight = srt.use_point_weight ? control_weights_buf[point_index] : 1.0f;
471 const float weight = point_weight * control_weight;
473 attr.output_weighted_add(evaluated_point_index, weight, attr.input_load(point_index));
474 total_weight += weight;
477 attr.output_mul(evaluated_point_index,
safe_rcp(total_weight));
480 if (is_curve_cyclic) {
482 attr.output_write(evaluated_points_padded.last(),
483 attr.output_load(evaluated_points_padded.first()));
500template<
typename StorageT,
typename AttrT>
506 if (global_id.x >= uint(srt.curves_count)) {
509 int curve_index = int(global_id.x) + srt.curves_start;
515 IndexRange points = offset_indices::load_range_from_buffer(srt.points_by_curve_buf, curve_index);
516 IndexRange evaluated_points = offset_indices::load_range_from_buffer(
517 srt.evaluated_points_by_curve_buf, curve_index);
519 if (srt.use_cyclic) {
520 evaluated_points = IndexRange{evaluated_points.start() + curve_index,
521 evaluated_points.size() + 1};
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
StoredFloat4 as_data(float4 interp)
float4 load_data(StoredFloat4 data)
#define HANDLES_POS_LEFT_SLOT
#define CURVES_PER_THREADGROUP
#define EVALUATED_ATTR_SLOT
#define POINTS_BY_CURVES_SLOT
#define EVALUATED_POS_RAD_SLOT
#define EVALUATED_POINT_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_float_attribute(curves::evaluate_curve< StoredFloat, float >)
PipelineCompute draw_curves_interpolate_float4_attribute(curves::evaluate_curve< StoredFloat4, float4 >)
PipelineCompute draw_curves_interpolate_float3_attribute(curves::evaluate_curve< StoredFloat3, float3 >)
PipelineCompute draw_curves_interpolate_float2_attribute(curves::evaluate_curve< StoredFloat2, float2 >)
PipelineCompute draw_curves_interpolate_position(curves::evaluate_curve< curves::InterpPosition, float4 >)
uint gpu_attr_load_uchar(const uint(&data_buf)[], uint i)
uint gpu_attr_load_index(uint vertex_index, int2 stride_and_offset)
float3 gpu_attr_load_float3(const float(&data_buf)[], int2 stride_and_offset, uint i)
bool gpu_attr_load_bool(const uint(&data)[], uint i)
#define assert(assertion)
#define storage(slot, qualifiers)
#define specialization_constant(default_value)
#define global_invocation_id
VecBase< int, D > floatBitsToInt(VecOp< float, D >) RET
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
constexpr T clamp(T, U, U) RET
MatBase< float, 4, 4 > float4x4
int2 get_points(uint point_id, IndexRange points, const bool cyclic)
IndexRange per_curve_point_offsets_range(const IndexRange points, const int curve_index)
void evaluate_curve(const CurvesData &srt, AttribBuf< StorageT, AttrT > &attr, const IndexRange points, const IndexRange evaluated_points, const int curve_index)
void evaluate_segment(const CurvesData &, AttribBuf< StorageT, AttrT > &attr, const int2 points, const IndexRange result)
void evaluate_curve(const CurvesData &srt, AttribBuf< StorageT, AttrT > &attr, const IndexRange points, const IndexRange evaluated_points, const int curve_index)
float4 calculate_basis(const float parameter)
int4 get_points(uint point_id, IndexRange points, const bool cyclic)
void evaluate_curve(const CurvesData &srt, AttribBuf< StorageT, AttrT > &attr, const IndexRange points, const IndexRange evaluated_points_padded, const int curve_index)
InterpPosition mix4(InterpPosition v0, InterpPosition v1, InterpPosition v2, InterpPosition v3, float4 w)
void copy_curve_data(const CurvesData &srt, AttribBuf< StorageT, AttrT > &attr, const IndexRange points, const IndexRange evaluated_points, const int curve_index)
void evaluate_curve(const CurvesData &srt, AttribBuf< StorageT, AttrT > &attr, const uint3 global_id)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void output_mul(int evaluated_point_index, float w)
void output_set_zero(int evaluated_point_index)
float4 output_load(int evaluated_point_index) const
void output_weighted_add(int evaluated_point_index, float w, const float4 src)
float4(& evaluated_positions_radii_buf)[]
void output_write(int evaluated_point_index, float4 data)
float4 input_load(int point_index) const
void output_set_zero(int evaluated_point_index)
void output_weighted_add(int evaluated_point_index, float w, const T src)
StoredT(& evaluated_buf)[]
StoredT(& attribute_buf)[]
void output_write(int evaluated_point_index, T data)
T input_load(int point_index) const
T output_load(int evaluated_point_index) const
void output_mul(int evaluated_point_index, float w)
const float(& handles_positions_left_buf)[]
const uint(& curves_cyclic_buf)[]
const uint(& curves_type_buf)[]
const int(& points_by_curve_buf)[]
const float(& handles_positions_right_buf)[]
bool curve_cyclic_get(int curve_index) const
const int(& bezier_offsets_buf)[]
const int(& evaluated_points_by_curve_buf)[]
const uint(& curves_resolution_buf)[]