56 MEM_delete(dl->
verts);
62 MEM_delete(dl->
index);
78 if (dl.type == type) {
87 const DispList *dl,
int a,
int *
b,
int *p1,
int *p2,
int *p3,
int *p4)
95 (*p2) = (*p1) + dl->
nr - 1;
96 (*p3) = (*p1) + dl->
nr;
97 (*p4) = (*p2) + dl->
nr;
103 (*p4) = (*p2) + dl->
nr;
104 (*p3) = (*p1) + dl->
nr;
116#ifdef __INTEL_COMPILER
118# pragma intel optimization_level 1
122 const ListBaseT<Nurb> *nubase,
123 const bool for_render,
124 ListBaseT<DispList> *r_dispbase)
128 for (
Nurb &nu : *nubase) {
129 if (nu.hide != 0 && editmode) {
140 const BezTriple *bezt_first = &nu.bezt[0];
141 const BezTriple *bezt_last = &nu.bezt[nu.pntsu - 1];
143 for (
int i = 1; i < nu.pntsu; i++) {
144 const BezTriple *prevbezt = &nu.bezt[i - 1];
150 samples_len += resolution;
159 samples_len += resolution;
170 const bool use_cyclic_sample = is_cyclic && (samples_len != 2);
177 dl->nr = samples_len;
179 dl->charidx = nu.charidx;
183 float *
data = dl->verts;
184 for (
int i = 1; i < nu.pntsu; i++) {
185 const BezTriple *prevbezt = &nu.bezt[i - 1];
193 for (
int j = 0; j < 3; j++) {
202 data += 3 * resolution;
210 for (
int j = 0; j < 3; j++) {
212 bezt_last->
vec[2][j],
213 bezt_first->
vec[0][j],
214 bezt_first->
vec[1][j],
239 const int len = nu.pntsu;
249 float (*coords)[3] =
reinterpret_cast<float (*)[3]
>(dl->
verts);
250 for (
int i = 0; i <
len; i++) {
251 const BPoint *bp = &nu.bp[i];
283 if (edge_index == -1) [[unlikely]] {
291 if (orig_id <
result.face_edge_offset) {
296 const int face_index = (orig_id /
result.face_edge_offset) - 1;
297 const int edge_in_face = orig_id %
result.face_edge_offset;
299 if (face_index == -1 || face_index >=
int(poly_ranges.
size())) [[unlikely]] {
303 const PolyRange &poly = poly_ranges[face_index];
304 if (edge_in_face >= poly.
count) [[unlikely]] {
309 const int v0_local = edge_in_face;
310 const int v1_local = (edge_in_face + 1) % poly.
count;
312 const int v0_global = poly.
start + v0_local;
313 const int v1_global = poly.
start + v1_local;
315 const double2 &p0 = input_verts_2d[v0_global];
316 const double2 &p1 = input_verts_2d[v1_global];
319 const double2 edge_vec = p1 - p0;
323 if (edge_len_sq < 1
e-16) [[unlikely]] {
333 const float z0 = poly.
dl->
verts[(3 * v0_local) + 2];
334 const float z1 = poly.
dl->
verts[(3 * v1_local) + 2];
337 return z0 + (
float(t) * (z1 - z0));
348 ListBaseT<DispList> *to,
349 const float normal_proj[3],
350 const bool flip_normal)
352 if (dispbase ==
nullptr) {
366 bool should_continue =
true;
367 while (should_continue) {
368 should_continue =
false;
369 bool nextcol =
false;
375 short dl_flag_accum = 0;
376 short dl_rt_accum = 0;
377 for (
const DispList &dl : *dispbase) {
379 if (charidx < dl.charidx) {
380 should_continue =
true;
382 else if (charidx == dl.charidx) {
383 if (colnr == dl.col) {
391 for (
int i = 0; i < dl.nr; i++) {
392 sf_vert_last = sf_vert;
395 if (sf_vert_last ==
nullptr) {
396 sf_vert_new = sf_vert;
403 if (sf_vert !=
nullptr && sf_vert_new !=
nullptr) {
407 dl_flag_accum |= dl.flag;
408 dl_rt_accum |= dl.rt;
410 else if (colnr < dl.col) {
412 should_continue =
true;
420 if (totvert != 0 && triangles_len != 0) {
427 dlnew->
parts = triangles_len;
434 for (
const auto [i, sf_vert] : sf_ctx.
fillvertbase.enumerate()) {
481 const bool flip_normal,
489 const float first_z = group.
poly_ranges[0].dl->verts[2];
490 bool uniform_z =
true;
519 for (
int i = 0; i < poly.
count; i++) {
520 const float *
v = &poly.
dl->
verts[3 * i];
521 const int vert_index = poly.
start + i;
522 verts_2d[vert_index] =
double2(
v[0],
v[1]);
523 vert_to_poly[vert_index] = int(p);
524 if (uniform_z &&
v[2] != first_z) {
531 input.
vert = verts_2d;
540 if (
result.face.is_empty()) [[unlikely]] {
545 const int out_verts = int(
result.vert.size());
546 const int out_tris = int(
result.face.size());
553 dlnew->
nr = out_verts;
554 dlnew->
parts = out_tris;
563 isect_vert_to_edge.
fill(-1);
564 for (
int e = 0;
e < int(
result.edge.size());
e++) {
565 if (
result.edge_orig[
e].is_empty()) {
568 const int v0 =
result.edge[
e][0];
569 const int v1 =
result.edge[
e][1];
570 if (
result.vert_orig[v0].is_empty()) {
571 isect_vert_to_edge[v0] =
e;
573 if (
result.vert_orig[v1].is_empty()) {
574 isect_vert_to_edge[v1] =
e;
580 for (
int i = 0; i < out_verts; i++) {
582 if (!
result.vert_orig[i].is_empty()) {
584 const int orig_index =
result.vert_orig[i][0];
586 const int local_index = orig_index - poly.
start;
593 out[2] = uniform_z ? first_z :
604 index[1] = flip_normal ? face[1] : face[2];
605 index[2] = flip_normal ? face[2] : face[1];
616 ListBaseT<DispList> *to,
617 const bool flip_normal,
628 for (
const DispList &dl : *dispbase) {
632 const std::pair<int, short> key(dl.charidx, dl.col);
636 group.
colnr = dl.col;
651 if (groups.
is_empty()) [[unlikely]] {
659 for (const int i : range) {
660 results[i] = displist_fill_cdt_process_group(groups[i], flip_normal, cdt_output_type);
665 for (DispList *dl : results) {
673 ListBaseT<DispList> *to,
674 const float normal_proj[3],
675 const bool flip_normal,
679 switch (fill_solver) {
706 ListBaseT<DispList> front = {
nullptr,
nullptr};
707 ListBaseT<DispList> back = {
nullptr,
nullptr};
709 for (
const DispList &dl : *dispbase) {
716 dlnew->
nr = dl.parts;
723 const float *old_verts = dl.verts;
724 float *new_verts = dlnew->
verts;
725 for (
int i = 0; i < dl.parts; i++) {
728 old_verts += 3 * dl.nr;
735 dlnew->
nr = dl.parts;
742 const float *old_verts = dl.verts + 3 * (dl.nr - 1);
743 float *new_verts = dlnew->
verts;
744 for (
int i = 0; i < dl.parts; i++) {
747 old_verts += 3 * dl.nr;
754 const float z_up[3] = {0.0f, 0.0f, -1.0f};
785 if (dispbase->first() && (dispbase->first())->type ==
DL_SURF) {
789 const float z_up[3] = {0.0f, 0.0f, -1.0f};
825 dx = dl->
verts[3 * (dl->
nr - 1)] - minx;
828 for (a = 0; a < dl->
nr; a++, fp += 3) {
829 if ((fp[0] - minx) / dx >= fac) {
832 float fac1 = (fp[-3] - minx) / dx;
833 float fac2 = (fp[0] - minx) / dx;
835 return fp[1] * (fac1 - fac) / (fac1 - fac2) + fp[-2] * (fac - fac2) / (fac1 - fac2);
849 Depsgraph *depsgraph,
const Scene *scene,
Object *taperobj,
int cur,
int tot)
851 const float fac =
float(cur) /
float(tot - 1);
858 const bool for_render,
870 for (; md; md = md->
next) {
877 return pretessellatePoint;
884 return pretessellatePoint;
887 pretessellatePoint = md;
895 pretessellatePoint = md;
899 return pretessellatePoint;
905 ListBaseT<Nurb> *source_nurb,
906 ListBaseT<Nurb> *target_nurb,
907 const bool for_render)
909 const Curve *cu = id_cast<const Curve *>(ob->
data);
927 float *keyVerts =
nullptr;
947 if (pretessellatePoint) {
969 if (md == pretessellatePoint) {
983 MEM_delete(keyVerts);
1020 for (; md; md = md->
next) {
1035 const ListBaseT<DispList> *dispbase,
1036 const bool for_render)
1038 const Curve *cu = id_cast<const Curve *>(ob->
data);
1040 const bool use_cache = !for_render;
1058 pretessellatePoint->
next;
1072 for (; md; md = md->
next) {
1092 mesh->tag_positions_changed();
1096 if (
mesh != output_mesh) {
1105 *(
reinterpret_cast<short *
>(final_mesh->
id.
name)) =
ID_ME;
1108 return geometry_set;
1113 int b, p1, p2, p3, p4;
1118 4 *
size_t(dl->
parts + 1) *
size_t(dl->
nr + 1), __func__);
1120 for (
int a = 0; a < dl->
parts; a++) {
1145 const bool for_render,
1146 ListBaseT<DispList> *r_dispbase)
1149 const Curve *cu = id_cast<const Curve *>(ob->
data);
1162 for (
const Nurb &nu : *deformed_nurbs) {
1170 if (nu.pntsv == 1) {
1179 dl->
col = nu.mat_nr;
1194 const int len = (nu.pntsu * resolu) * (nu.pntsv * resolv);
1200 dl->
col = nu.mat_nr;
1207 dl->
parts = (nu.pntsu * resolu);
1208 dl->
nr = (nu.pntsv * resolv);
1225 depsgraph, scene, ob, r_dispbase, for_render);
1229 return geometry_set;
1236 const float bev_blend,
1238 const float radius_factor,
1241 float *
data = *r_data;
1242 const float *fp = dlb->
verts;
1243 for (
int b = 0;
b < dlb->
nr;
b++, fp += 3,
data += 3) {
1245 float vec[3], quat[4];
1247 vec[0] = fp[1] + widfac;
1251 if (nbevp ==
nullptr) {
1262 data[0] += radius_factor * vec[0];
1263 data[1] += radius_factor * vec[1];
1264 data[2] += radius_factor * vec[2];
1269 if (nbevp ==
nullptr) {
1280 sina = nbevp->
sina * bev_blend + bevp->
sina * (1.0f - bev_blend);
1281 cosa = nbevp->
cosa * bev_blend + bevp->
cosa * (1.0f - bev_blend);
1284 data[0] += radius_factor * (widfac + fp[1]) * sina;
1285 data[1] += radius_factor * (widfac + fp[1]) * cosa;
1286 data[2] += radius_factor * fp[2];
1295 const float *prev_fp,
1296 ListBaseT<DispList> *dispbase)
1300 memcpy(dl->
verts, prev_fp,
sizeof(
float[3]) * dlb->
nr);
1314 const BevList *bl,
float bevfac,
float spline_length,
int *r_bev,
float *r_blend)
1316 float normsum = 0.0f;
1317 float *seglen = bl->
seglen;
1319 int bevcount = 0, nr = bl->
nr;
1321 float bev_fl = bevfac * (bl->
nr - 1);
1322 *r_bev = int(bev_fl);
1324 while (bevcount < nr - 1) {
1325 float normlen = *seglen / spline_length;
1326 if (normsum + normlen > bevfac) {
1327 bev_fl = bevcount + (bevfac - normsum) / normlen * *segbevcount;
1328 *r_bev = int(bev_fl);
1329 *r_blend = bev_fl - *r_bev;
1333 bevcount += *segbevcount;
1340 const BevList *bl,
float bevfac,
float spline_length,
int *r_bev,
float *r_blend)
1342 const float len_target = bevfac * spline_length;
1344 float len_next = 0.0f,
len = 0.0f;
1345 int i = 0, nr = bl->
nr;
1350 if (len_next > len_target) {
1358 *r_blend = (len_target -
len) / bevp->
offset;
1362 const BevList *bl,
int *r_start,
float *r_firstblend,
int *r_steps,
float *r_lastblend)
1366 *r_firstblend = 1.0f;
1367 *r_lastblend = 1.0f;
1374 float *r_firstblend,
1378 float tmpf, total_length = 0.0f;
1393 total_length += bl->
seglen[i];
1399 const float start_fl = cu->
bevfac1 * (bl->
nr - 1);
1400 *r_start = int(start_fl);
1401 *r_firstblend = 1.0f - (start_fl - (*r_start));
1406 *r_firstblend = 1.0f - *r_firstblend;
1411 *r_firstblend = 1.0f - *r_firstblend;
1418 const float end_fl = cu->
bevfac2 * (bl->
nr - 1);
1421 *r_steps = 2 + end - *r_start;
1422 *r_lastblend = end_fl - end;
1427 *r_steps = end - *r_start + 2;
1432 *r_steps = end - *r_start + 2;
1437 if (end < *r_start || (end == *r_start && *r_lastblend < 1.0f - *r_firstblend)) {
1438 std::swap(*r_start, end);
1439 tmpf = *r_lastblend;
1440 *r_lastblend = 1.0f - *r_firstblend;
1441 *r_firstblend = 1.0f - tmpf;
1442 *r_steps = end - *r_start + 2;
1445 if (*r_start + *r_steps > bl->
nr) {
1446 *r_steps = bl->
nr - *r_start;
1447 *r_lastblend = 1.0f;
1454 const bool for_render,
1455 ListBaseT<DispList> *r_dispbase)
1458 const Curve *cu = id_cast<const Curve *>(ob->
data);
1483 if (dlbev.is_empty() && cu->
offset == 1.0f) {
1487 const float widfac = cu->
offset - 1.0f;
1490 const Nurb *nu = deformed_nurbs->first();
1491 for (; bl && nu; bl = bl->
next, nu = nu->
next) {
1499 if (dlbev.is_empty()) {
1504 if (bl->
poly != -1) {
1533 ListBaseT<DispList> bottom_capbase = {
nullptr,
nullptr};
1534 ListBaseT<DispList> top_capbase = {
nullptr,
nullptr};
1535 float bottom_no[3] = {0.0f};
1536 float top_no[3] = {0.0f};
1537 float first_blend = 0.0f, last_blend = 0.0f;
1538 int start, steps = 0;
1564 if ((bl->
poly >= 0) && (steps > 2)) {
1581 for (
int i = start, a = 0; a < steps; i++, bevp++, a++) {
1582 float radius_factor = 1.0;
1583 float *cur_data =
data;
1586 radius_factor = bevp->
radius;
1591 float len = (steps - 3) + first_blend + last_blend;
1594 taper_factor = 0.0f;
1596 else if (a == steps - 1) {
1597 taper_factor = 1.0f;
1600 taper_factor = (
float(a) - (1.0f - first_blend)) /
len;
1604 float len = bl->
nr - 1;
1608 taper_factor += (1.0f - first_blend) /
len;
1610 else if (a == steps - 1) {
1611 taper_factor -= (1.0f - last_blend) /
len;
1618 radius_factor *= bevp->
radius;
1621 radius_factor += bevp->
radius;
1626 if ((a == 0) && (bevp != bevp_last)) {
1628 cu, bevp, bevp + 1, &dlb, 1.0f - first_blend, widfac, radius_factor, &
data);
1630 else if ((a == steps - 1) && (bevp != bevp_first)) {
1632 cu, bevp, bevp - 1, &dlb, 1.0f - last_blend, widfac, radius_factor, &
data);
1642 fillBevelCap(nu, &dlb, cur_data - 3 * dlb.nr, &bottom_capbase);
1646 if (a == steps - 1) {
1660 if (bottom_capbase.first()) {
1669 if (top_capbase.first()) {
1691 const bool for_render)
1699 const Curve &original_curve = *id_cast<const Curve *>(ob->
data);
1706 depsgraph, scene, ob, for_render, dispbase);
1711 depsgraph, scene, ob, for_render, dispbase);
1727 Curve &cow_curve = *
reinterpret_cast<Curve *
>(
1745 for (
const DispList &dl : *dispbase) {
1746 const int tot = dl.type ==
DL_INDEX3 ? dl.nr : dl.nr * dl.parts;
display list (or rather multi purpose list) stuff.
General operations, lookup, etc. for blender objects.
#define BLI_SCANFILL_ARENA_SIZE
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
ccl_device_inline float2 to_point(const float gamma, const float b)
MutableSpan< T > as_mutable_span()
void fill(const T &value) const
void reinitialize(const int64_t new_size)
Value & lookup_or_add_default(const Key &key)
ValueIterator values() const &
constexpr std::reverse_iterator< T * > rbegin() const
constexpr T * end() const
constexpr T * begin() const
constexpr std::reverse_iterator< T * > rend() const
constexpr int64_t size() const
IndexRange index_range() const
void append_unchecked(const T &value)
void reserve(const int64_t min_capacity)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Curves * curve_legacy_to_curves(const Curve &curve_legacy)
T length_squared(const VecBase< T, Size > &a)
T clamp(const T &a, const T &min, const T &max)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
CDT_result< T > delaunay_2d_calc(const CDT_input< T > &input, CDT_output_type output_type)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
MINLINE float min_ff(float a, float b)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE void negate_v3_v3(float r[3], const float a[3])
static void fillBevelCap(const Nurb *nu, const DispList *dlb, const float *prev_fp, ListBaseT< DispList > *dispbase)
char * STRNCPY(char(&dst)[N], const char *src)
static void curve_to_filledpoly(const Curve *cu, ListBaseT< DispList > *dispbase)
MemArena * BLI_memarena_new(size_t bufsize, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(2) ATTR_MALLOC
static void calc_bevfac_mapping(const Curve *cu, const BevList *bl, const Nurb *nu, int *r_start, float *r_firstblend, int *r_steps, float *r_lastblend)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
const ListBaseT< Nurb > * BKE_curve_nurbs_get_for_read(const Curve *cu)
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_displist_fill(const ListBaseT< DispList > *dispbase, ListBaseT< DispList > *to, const float normal_proj[3], bool flip_normal, CurveFillSolverType fill_solver, CurveFillRuleType fill_rule)
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
void BKE_displist_free(ListBaseT< DispList > *lb)
static void rotateBevelPiece(const Curve *cu, const BevPoint *bevp, const BevPoint *nbevp, const DispList *dlb, const float bev_blend, const float widfac, const float radius_factor, float **r_data)
void BKE_object_eval_assign_data(Object *object, ID *data, bool is_owned)
@ CDT_INSIDE_WITH_HOLES_NONZERO
@ eModifierType_MeshDeform
VecBase< double, 2 > double2
@ BLI_SCANFILL_CALC_POLYS
@ BLI_SCANFILL_CALC_HOLES
@ BLI_SCANFILL_CALC_REMOVE_DOUBLES
void BKE_curve_calc_modifiers_pre(struct Depsgraph *depsgraph, const struct Scene *scene, struct Object *ob, ListBaseT< Nurb > *source_nurb, ListBaseT< Nurb > *target_nurb, bool for_render)
static bool do_curve_implicit_mesh_conversion(const Curve *curve, ModifierData *first_modifier, const Scene *scene, const ModifierMode required_mode, const bool editmode)
DispList * BKE_displist_find(ListBaseT< DispList > *lb, int type)
BLI_INLINE bool BLI_listbase_is_empty(const ListBase *lb)
uint32_t DEG_get_eval_flags_for_id(const Depsgraph *graph, const ID *id)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
const ListBaseT< Nurb > * BKE_curve_editNurbs_get_for_read(const Curve *cu)
void mul_qt_v3(const float q[4], float r[3])
void BKE_curve_nurbs_key_vert_tilts_apply(ListBaseT< Nurb > *lb, const float *key)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BKE_object_free_derived_caches(Object *ob)
@ eModifierMode_ApplyOnSpline
void copy_qt_qt(float q[4], const float a[4])
@ CU_FILL_SOLVER_SWEEP_LINE
BMesh const char void * data
void interp_qt_qtqt(float q[4], const float a[4], const float b[4], float t)
void BKE_nurb_makeCurve(const Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride)
void BLI_scanfill_begin_arena(ScanFillContext *sf_ctx, struct MemArena *arena)
struct ScanFillVert * BLI_scanfill_vert_add(ScanFillContext *sf_ctx, const float vec[3])
void BKE_curve_nurbs_vert_coords_apply(ListBaseT< Nurb > *lb, const Span< float3 > vert_coords, bool constrain_2d)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
ModifierData * BKE_modifiers_get_virtual_modifierlist(const Object *ob, VirtualModifierData *data)
static float displist_calc_taper(Depsgraph *depsgraph, const Scene *scene, Object *taperobj, float fac)
static void displist_surf_indices(DispList *dl)
void BKE_displist_minmax(const ListBaseT< DispList > *dispbase, float min[3], float max[3])
Mesh * BKE_mesh_new_nomain_from_curve_displist(const Object *ob, const ListBaseT< DispList > *dispbase)
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
Array< float3 > BKE_curve_nurbs_key_vert_coords_alloc(const ListBaseT< Nurb > *lb, const float *key)
void BKE_modifiers_clear_errors(Object *ob)
static void calc_bevfac_segment_mapping(const BevList *bl, float bevfac, float spline_length, int *r_bev, float *r_blend)
MINLINE void zero_v3(float r[3])
bool BKE_displist_surfindex_get(const struct DispList *dl, int a, int *b, int *p1, int *p2, int *p3, int *p4)
float BKE_displist_calc_taper(struct Depsgraph *depsgraph, const struct Scene *scene, struct Object *taperobj, int cur, int tot)
@ DAG_EVAL_NEED_CURVE_PATH
struct ScanFillEdge * BLI_scanfill_edge_add(ScanFillContext *sf_ctx, struct ScanFillVert *v1, struct ScanFillVert *v2)
static void displist_fill_scanfill(const ListBaseT< DispList > *dispbase, ListBaseT< DispList > *to, const float normal_proj[3], const bool flip_normal)
Array< float3 > BKE_curve_nurbs_vert_coords_alloc(const ListBaseT< Nurb > *lb)
@ CU_TAPER_RADIUS_MULTIPLY
void BKE_nurbList_duplicate(ListBaseT< Nurb > *lb1, const ListBaseT< Nurb > *lb2)
bool BKE_nurb_check_valid_u(const Nurb *nu)
void BLI_scanfill_end_arena(ScanFillContext *sf_ctx, struct MemArena *arena)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
int BKE_keyblock_curve_element_count(const ListBaseT< Nurb > *nurb)
static ModifierData * curve_get_tessellate_point(const Scene *scene, const Object *ob, const bool for_render, const bool editmode)
MINLINE float max_ff(float a, float b)
float * BKE_key_evaluate_object(Object *ob, int *r_totelem)
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
static bke::GeometrySet evaluate_curve_type_object(Depsgraph *depsgraph, const Scene *scene, Object *ob, const bool for_render, ListBaseT< DispList > *r_dispbase)
bool BKE_nurb_check_valid_uv(const Nurb *nu)
static bke::GeometrySet evaluate_surface_object(Depsgraph *depsgraph, const Scene *scene, Object *ob, const bool for_render, ListBaseT< DispList > *r_dispbase)
static float isect_vert_calc_z(int vert_index, int edge_index, const meshintersect::CDT_result< double > &result, Span< PolyRange > poly_ranges, Span< double2 > input_verts_2d)
unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, int flag, const float nor_proj[3])
ID * BKE_id_copy_ex(Main *bmain, const ID *id, ID **new_id_p, int flag)
void BKE_displist_make_curveTypes(struct Depsgraph *depsgraph, const struct Scene *scene, struct Object *ob, bool for_render)
void BKE_curve_bevelList_make(Object *ob, const ListBaseT< Nurb > *nurbs, bool for_render)
static void calc_bevfac_spline_mapping(const BevList *bl, float bevfac, float spline_length, int *r_bev, float *r_blend)
static void displist_elem_free(DispList *dl)
void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
void BKE_anim_path_calc_data(struct Object *ob)
static void calc_bevfac_mapping_default(const BevList *bl, int *r_start, float *r_firstblend, int *r_steps, float *r_lastblend)
static void curve_to_displist(const Curve *cu, const ListBaseT< Nurb > *nubase, const bool for_render, ListBaseT< DispList > *r_dispbase)
const ModifierTypeInfo * BKE_modifier_get_info(ModifierType type)
bool BKE_vfont_to_curve_nubase(Object *ob, eEditFontMode mode, ListBaseT< Nurb > *r_nubase)
void BKE_nurb_makeFaces(const Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv)
static void displist_fill_cdt(const ListBaseT< DispList > *dispbase, ListBaseT< DispList > *to, const bool flip_normal, const CDT_output_type cdt_output_type)
static DispList * displist_fill_cdt_process_group(const CDTFillGroup &group, const bool flip_normal, const CDT_output_type cdt_output_type)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
static void bevels_to_filledpoly(const Curve *cu, ListBaseT< DispList > *dispbase)
ListBaseT< DispList > BKE_curve_bevel_make(const Curve *curve)
void BLI_memarena_free(MemArena *ma) ATTR_NONNULL(1)
static bke::GeometrySet curve_calc_modifiers_post(Depsgraph *depsgraph, const Scene *scene, Object *ob, const ListBaseT< DispList > *dispbase, const bool for_render)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
Vector< PolyRange > poly_ranges
ListBaseT< Nurb > deformed_nurbs
ListBaseT< DispList > disp
eCurveTaperRadiusMode taper_radius_mode
eCurveBevfacMapping bevfac2_mapping
struct EditFont * editfont
CurveFillSolverType fill_solver
eCurveBevelMode bevel_mode
CurveFillRuleType fill_rule
eCurveBevfacMapping bevfac1_mapping
const struct Curves * curve_eval
char edit_data_from_original
struct ModifierData * next
void(*) deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
Mesh *(*) modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
void(*) modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
bke::ObjectRuntime * runtime
ListBaseT< ScanFillFace > fillfacebase
ListBaseT< ScanFillVert > fillvertbase
union blender::ScanFillVert::@124355022001164321030006076112165043115032300246 tmp
void replace_curves(Curves *curves, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
void replace_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
Mesh * get_mesh_for_write()
GeometrySet * geometry_set_eval