35 if (curves_ !=
nullptr) {
45 if (curves_ !=
nullptr) {
49 if (curve_for_render_ !=
nullptr) {
53 curve_for_render_ =
nullptr;
62 return curves_ !=
nullptr;
70 ownership_ = ownership;
98 return curves_ ==
nullptr;
117 if (curves_ ==
nullptr) {
120 if (curve_for_render_ !=
nullptr) {
121 return curve_for_render_;
123 std::lock_guard
lock{curve_for_render_mutex_};
124 if (curve_for_render_ !=
nullptr) {
125 return curve_for_render_;
131 return curve_for_render_;
156 Vector<float3> nurbs_tangents;
158 for (const int i_curve : range) {
159 const IndexRange points = curves.points_for_curve(i_curve);
160 const IndexRange evaluated_points = curves.evaluated_points_for_curve(i_curve);
162 MutableSpan<float3> curve_normals = results.as_mutable_span().slice(points);
164 switch (types[i_curve]) {
165 case CURVE_TYPE_CATMULL_ROM: {
166 const Span<float3> normals = evaluated_normals.slice(evaluated_points);
167 const int resolution = resolutions[i_curve];
168 for (const int i : IndexRange(points.size())) {
169 curve_normals[i] = normals[resolution * i];
173 case CURVE_TYPE_POLY:
174 curve_normals.copy_from(evaluated_normals.slice(evaluated_points));
176 case CURVE_TYPE_BEZIER: {
177 const Span<float3> normals = evaluated_normals.slice(evaluated_points);
178 curve_normals.first() = normals.first();
179 const Span<int> offsets = curves.bezier_evaluated_offsets_for_curve(i_curve);
180 for (const int i : IndexRange(points.size()).drop_front(1)) {
181 curve_normals[i] = normals[offsets[i - 1]];
185 case CURVE_TYPE_NURBS: {
188 nurbs_tangents.clear();
189 nurbs_tangents.resize(points.size());
190 const bool cyclic = curves_cyclic[i_curve];
191 const Span<float3> curve_positions = positions.slice(points);
192 bke::curves::poly::calculate_tangents(curve_positions, cyclic, nurbs_tangents);
193 switch (NormalMode(normal_modes[i_curve])) {
194 case NORMAL_MODE_Z_UP:
195 bke::curves::poly::calculate_normals_z_up(nurbs_tangents, curve_normals);
197 case NORMAL_MODE_MINIMUM_TWIST:
198 bke::curves::poly::calculate_normals_minimum(nurbs_tangents, cyclic, curve_normals);
253 curves.ensure_evaluated_lengths();
258 return curves.evaluated_length_total_for_curve(index, cyclic[index]);
266 return component.attributes()->adapt_domain<
float>(
273 CurveLengthFieldInput::CurveLengthFieldInput()
312 curves.tag_topology_changed();
318 curves.update_curve_types();
319 curves.tag_topology_changed();
325 curves.tag_positions_changed();
331 curves.tag_normals_changed();
351 return &
curves.curve_data;
355 return &
curves.curve_data;
357 [](
const void *owner) ->
int {
359 return curves.curves_num();
365 return &
curves.point_data;
369 return &
curves.point_data;
371 [](
const void *owner) ->
int {
373 return curves.points_num();
385 make_array_read_attribute<float3>,
386 make_array_write_attribute<float3>,
397 make_array_read_attribute<float>,
398 make_array_write_attribute<float>,
409 make_array_read_attribute<int>,
410 make_array_write_attribute<int>,
421 make_array_read_attribute<float>,
422 make_array_write_attribute<float>,
433 make_array_read_attribute<float3>,
434 make_array_write_attribute<float3>,
445 make_array_read_attribute<float3>,
446 make_array_write_attribute<float3>,
457 make_array_read_attribute<int8_t>,
458 make_array_write_attribute<int8_t>,
469 make_array_read_attribute<int8_t>,
470 make_array_write_attribute<int8_t>,
481 make_array_read_attribute<float>,
482 make_array_write_attribute<float>,
493 make_array_read_attribute<int8_t>,
494 make_array_write_attribute<int8_t>,
505 make_array_read_attribute<int8_t>,
506 make_array_write_attribute<int8_t>,
517 make_array_read_attribute<int8_t>,
518 make_array_write_attribute<int8_t>,
529 make_array_read_attribute<int8_t>,
530 make_array_write_attribute<int8_t>,
541 make_array_read_attribute<int>,
542 make_array_write_attribute<int>,
553 make_array_read_attribute<bool>,
554 make_array_write_attribute<bool>,
575 {&curve_custom_data, &point_custom_data});
584 attribute_accessor_functions::accessor_functions_for_providers<providers>();
586 if (owner ==
nullptr) {
592 return curves.points_num();
594 return curves.curves_num();
606 if (owner ==
nullptr) {
610 return curves.adapt_domain(varray, from_domain, to_domain);
typedef float(TangentPoint)[2]
struct Curves * BKE_curves_copy_for_eval(struct Curves *curves_src, bool reference)
Low-level operations for curves.
@ GEO_COMPONENT_TYPE_CURVE
void * BKE_id_new_nomain(short type, const char *name)
void BKE_id_free(struct Main *bmain, void *idv)
static uint8 component(Color32 c, uint i)
Enumerations for DNA_ID.h.
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to curves
void ensure_owns_direct_data() override
GeometryComponent * copy() const override
const Curve * get_curve_for_render() const
const Curves * get_for_read() const
bool owns_direct_data() const override
bool is_empty() const final
void replace(Curves *curve, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
std::optional< blender::bke::AttributeAccessor > attributes() const final
std::optional< blender::bke::MutableAttributeAccessor > attributes_for_write() final
MutableAttributeAccessor attributes_for_write()
AttributeAccessor attributes() const
static void tag_component_topology_changed(void *owner)
static void tag_component_curve_types_changed(void *owner)
static void tag_component_normals_changed(void *owner)
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
static struct PartialUpdateUser * wrap(PartialUpdateUserImpl *user)
VArray< float3 > curve_normals_varray(const CurveComponent &component, const eAttrDomain domain)
static Array< float3 > curve_normal_point_domain(const bke::CurvesGeometry &curves)
static void tag_component_positions_changed(void *owner)
static AttributeAccessorFunctions get_curves_accessor_functions()
static const AttributeAccessorFunctions & get_curves_accessor_functions_ref()
static ComponentAttributeProviders create_attribute_providers_for_curve()
static VArray< float > construct_curve_length_gvarray(const CurveComponent &component, const eAttrDomain domain)
void parallel_for(IndexRange range, int64_t grain_size, const Function &function)
MutableSpan< float3 > positions
MutableSpan< float3 > normals
unsigned __int64 uint64_t
const struct Curves * curve_eval
struct EditFont * editfont
bool(* domain_supported)(const void *owner, eAttrDomain domain)
GVArray(* adapt_domain)(const void *owner, const GVArray &varray, eAttrDomain from_domain, eAttrDomain to_domain)
int(* domain_size)(const void *owner, eAttrDomain domain)