diff options
Diffstat (limited to 'source/blender/blenkernel/intern/displist.cc')
-rw-r--r-- | source/blender/blenkernel/intern/displist.cc | 1822 |
1 files changed, 1822 insertions, 0 deletions
diff --git a/source/blender/blenkernel/intern/displist.cc b/source/blender/blenkernel/intern/displist.cc new file mode 100644 index 00000000000..20534ef933b --- /dev/null +++ b/source/blender/blenkernel/intern/displist.cc @@ -0,0 +1,1822 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + */ + +/** \file + * \ingroup bke + */ + +#include <cmath> +#include <cstdio> +#include <cstring> + +#include "MEM_guardedalloc.h" + +#include "DNA_curve_types.h" +#include "DNA_mesh_types.h" +#include "DNA_object_types.h" +#include "DNA_scene_types.h" +#include "DNA_vfont_types.h" + +#include "BLI_bitmap.h" +#include "BLI_linklist.h" +#include "BLI_listbase.h" +#include "BLI_math.h" +#include "BLI_memarena.h" +#include "BLI_scanfill.h" +#include "BLI_string.h" +#include "BLI_utildefines.h" + +#include "BKE_anim_path.h" +#include "BKE_curve.h" +#include "BKE_displist.h" +#include "BKE_font.h" +#include "BKE_key.h" +#include "BKE_lattice.h" +#include "BKE_lib_id.h" +#include "BKE_mball.h" +#include "BKE_mball_tessellate.h" +#include "BKE_mesh.h" +#include "BKE_modifier.h" +#include "BKE_object.h" + +#include "BLI_sys_types.h" // for intptr_t support + +#include "DEG_depsgraph.h" +#include "DEG_depsgraph_query.h" + +static void boundbox_displist_object(Object *ob); + +void BKE_displist_elem_free(DispList *dl) +{ + if (dl) { + if (dl->verts) { + MEM_freeN(dl->verts); + } + if (dl->nors) { + MEM_freeN(dl->nors); + } + if (dl->index) { + MEM_freeN(dl->index); + } + MEM_freeN(dl); + } +} + +void BKE_displist_free(ListBase *lb) +{ + DispList *dl; + + while ((dl = (DispList *)BLI_pophead(lb))) { + BKE_displist_elem_free(dl); + } +} + +DispList *BKE_displist_find_or_create(ListBase *lb, int type) +{ + LISTBASE_FOREACH (DispList *, dl, lb) { + if (dl->type == type) { + return dl; + } + } + + DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), "find_disp"); + dl->type = type; + BLI_addtail(lb, dl); + + return dl; +} + +DispList *BKE_displist_find(ListBase *lb, int type) +{ + LISTBASE_FOREACH (DispList *, dl, lb) { + if (dl->type == type) { + return dl; + } + } + + return nullptr; +} + +bool BKE_displist_has_faces(const ListBase *lb) +{ + LISTBASE_FOREACH (const DispList *, dl, lb) { + if (ELEM(dl->type, DL_INDEX3, DL_INDEX4, DL_SURF)) { + return true; + } + } + + return false; +} + +void BKE_displist_copy(ListBase *lbn, const ListBase *lb) +{ + BKE_displist_free(lbn); + + LISTBASE_FOREACH (const DispList *, dl, lb) { + DispList *dln = (DispList *)MEM_dupallocN(dl); + BLI_addtail(lbn, dln); + dln->verts = (float *)MEM_dupallocN(dl->verts); + dln->nors = (float *)MEM_dupallocN(dl->nors); + dln->index = (int *)MEM_dupallocN(dl->index); + } +} + +void BKE_displist_normals_add(ListBase *lb) +{ + float *vdata, *ndata, nor[3]; + float *v1, *v2, *v3, *v4; + float *n1, *n2, *n3, *n4; + int a, b, p1, p2, p3, p4; + + LISTBASE_FOREACH (DispList *, dl, lb) { + if (dl->type == DL_INDEX3) { + if (dl->nors == nullptr) { + dl->nors = (float *)MEM_callocN(sizeof(float[3]), "dlnors"); + + if (dl->flag & DL_BACK_CURVE) { + dl->nors[2] = -1.0f; + } + else { + dl->nors[2] = 1.0f; + } + } + } + else if (dl->type == DL_SURF) { + if (dl->nors == nullptr) { + dl->nors = (float *)MEM_callocN(sizeof(float[3]) * dl->nr * dl->parts, "dlnors"); + + vdata = dl->verts; + ndata = dl->nors; + + for (a = 0; a < dl->parts; a++) { + + if (BKE_displist_surfindex_get(dl, a, &b, &p1, &p2, &p3, &p4) == 0) { + break; + } + + v1 = vdata + 3 * p1; + n1 = ndata + 3 * p1; + v2 = vdata + 3 * p2; + n2 = ndata + 3 * p2; + v3 = vdata + 3 * p3; + n3 = ndata + 3 * p3; + v4 = vdata + 3 * p4; + n4 = ndata + 3 * p4; + + for (; b < dl->nr; b++) { + normal_quad_v3(nor, v1, v3, v4, v2); + + add_v3_v3(n1, nor); + add_v3_v3(n2, nor); + add_v3_v3(n3, nor); + add_v3_v3(n4, nor); + + v2 = v1; + v1 += 3; + v4 = v3; + v3 += 3; + n2 = n1; + n1 += 3; + n4 = n3; + n3 += 3; + } + } + a = dl->parts * dl->nr; + v1 = ndata; + while (a--) { + normalize_v3(v1); + v1 += 3; + } + } + } + } +} + +void BKE_displist_count(const ListBase *lb, int *totvert, int *totface, int *tottri) +{ + LISTBASE_FOREACH (const DispList *, dl, lb) { + int vert_tot = 0; + int face_tot = 0; + int tri_tot = 0; + bool cyclic_u = dl->flag & DL_CYCL_U; + bool cyclic_v = dl->flag & DL_CYCL_V; + + switch (dl->type) { + case DL_SURF: { + int segments_u = dl->nr - (cyclic_u == false); + int segments_v = dl->parts - (cyclic_v == false); + vert_tot = dl->nr * dl->parts; + face_tot = segments_u * segments_v; + tri_tot = face_tot * 2; + break; + } + case DL_INDEX3: { + vert_tot = dl->nr; + face_tot = dl->parts; + tri_tot = face_tot; + break; + } + case DL_INDEX4: { + vert_tot = dl->nr; + face_tot = dl->parts; + tri_tot = face_tot * 2; + break; + } + case DL_POLY: + case DL_SEGM: { + vert_tot = dl->nr * dl->parts; + break; + } + } + + *totvert += vert_tot; + *totface += face_tot; + *tottri += tri_tot; + } +} + +bool BKE_displist_surfindex_get( + const DispList *dl, int a, int *b, int *p1, int *p2, int *p3, int *p4) +{ + if ((dl->flag & DL_CYCL_V) == 0 && a == (dl->parts) - 1) { + return false; + } + + if (dl->flag & DL_CYCL_U) { + (*p1) = dl->nr * a; + (*p2) = (*p1) + dl->nr - 1; + (*p3) = (*p1) + dl->nr; + (*p4) = (*p2) + dl->nr; + (*b) = 0; + } + else { + (*p2) = dl->nr * a; + (*p1) = (*p2) + 1; + (*p4) = (*p2) + dl->nr; + (*p3) = (*p1) + dl->nr; + (*b) = 1; + } + + if ((dl->flag & DL_CYCL_V) && a == dl->parts - 1) { + (*p3) -= dl->nr * dl->parts; + (*p4) -= dl->nr * dl->parts; + } + + return true; +} + +/* ****************** make displists ********************* */ +#ifdef __INTEL_COMPILER +/* ICC with the optimization -02 causes crashes. */ +# pragma intel optimization_level 1 +#endif + +static void curve_to_displist(const Curve *cu, + const ListBase *nubase, + const bool for_render, + ListBase *r_dispbase) +{ + const bool editmode = (!for_render && (cu->editnurb || cu->editfont)); + + LISTBASE_FOREACH (Nurb *, nu, nubase) { + if (nu->hide != 0 && editmode) { + continue; + } + if (!BKE_nurb_check_valid_u(nu)) { + continue; + } + + const int resolution = (for_render && cu->resolu_ren != 0) ? cu->resolu_ren : nu->resolu; + const bool is_cyclic = nu->flagu & CU_NURB_CYCLIC; + const BezTriple *bezt_first = &nu->bezt[0]; + const BezTriple *bezt_last = &nu->bezt[nu->pntsu - 1]; + + if (nu->type == CU_BEZIER) { + int samples_len = 0; + for (int i = 1; i < nu->pntsu; i++) { + const BezTriple *prevbezt = &nu->bezt[i - 1]; + const BezTriple *bezt = &nu->bezt[i]; + if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) { + samples_len++; + } + else { + samples_len += resolution; + } + } + if (is_cyclic) { + /* If the curve is cyclic, sample the last edge between the last and first points. */ + if (bezt_first->h1 == HD_VECT && bezt_last->h2 == HD_VECT) { + samples_len++; + } + else { + samples_len += resolution; + } + } + else { + /* Otherwise, we only need one additional sample to complete the last edge. */ + samples_len++; + } + + /* Check that there are more than two points so the curve doesn't loop back on itself. This + * needs to be separate from `is_cyclic` because cyclic sampling can work with two points + * and resolution > 1. */ + const bool use_cyclic_sample = is_cyclic && (samples_len != 2); + + DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), __func__); + /* Add one to the length because of 'BKE_curve_forward_diff_bezier'. */ + dl->verts = (float *)MEM_mallocN(sizeof(float[3]) * (samples_len + 1), "dlverts"); + BLI_addtail(r_dispbase, dl); + dl->parts = 1; + dl->nr = samples_len; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + + dl->type = use_cyclic_sample ? DL_POLY : DL_SEGM; + + float *data = dl->verts; + for (int i = 1; i < nu->pntsu; i++) { + const BezTriple *prevbezt = &nu->bezt[i - 1]; + const BezTriple *bezt = &nu->bezt[i]; + + if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) { + copy_v3_v3(data, prevbezt->vec[1]); + data += 3; + } + else { + for (int j = 0; j < 3; j++) { + BKE_curve_forward_diff_bezier(prevbezt->vec[1][j], + prevbezt->vec[2][j], + bezt->vec[0][j], + bezt->vec[1][j], + data + j, + resolution, + sizeof(float[3])); + } + data += 3 * resolution; + } + } + if (is_cyclic) { + if (bezt_first->h1 == HD_VECT && bezt_last->h2 == HD_VECT) { + copy_v3_v3(data, bezt_last->vec[1]); + } + else { + for (int j = 0; j < 3; j++) { + BKE_curve_forward_diff_bezier(bezt_last->vec[1][j], + bezt_last->vec[2][j], + bezt_first->vec[0][j], + bezt_first->vec[1][j], + data + j, + resolution, + sizeof(float[3])); + } + } + } + else { + copy_v3_v3(data, bezt_last->vec[1]); + } + } + else if (nu->type == CU_NURBS) { + const int len = (resolution * SEGMENTSU(nu)); + DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), __func__); + dl->verts = (float *)MEM_mallocN(len * sizeof(float[3]), "dlverts"); + BLI_addtail(r_dispbase, dl); + dl->parts = 1; + dl->nr = len; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + dl->type = is_cyclic ? DL_POLY : DL_SEGM; + + BKE_nurb_makeCurve(nu, dl->verts, nullptr, nullptr, nullptr, resolution, sizeof(float[3])); + } + else if (nu->type == CU_POLY) { + const int len = nu->pntsu; + DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), __func__); + dl->verts = (float *)MEM_mallocN(len * sizeof(float[3]), "dlverts"); + BLI_addtail(r_dispbase, dl); + dl->parts = 1; + dl->nr = len; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + dl->type = (is_cyclic && (dl->nr != 2)) ? DL_POLY : DL_SEGM; + + float(*coords)[3] = (float(*)[3])dl->verts; + for (int i = 0; i < len; i++) { + const BPoint *bp = &nu->bp[i]; + copy_v3_v3(coords[i], bp->vec); + } + } + } +} + +/** + * \param normal_proj: Optional normal that's used to project the scanfill verts into 2d coords. + * Pass this along if known since it saves time calculating the normal. + * This is also used to initialize #DispList.nors (one normal per display list). + * \param flipnormal: Flip the normal (same as passing \a normal_proj negated) + */ +void BKE_displist_fill(const ListBase *dispbase, + ListBase *to, + const float normal_proj[3], + const bool flip_normal) +{ + if (dispbase == nullptr) { + return; + } + if (BLI_listbase_is_empty(dispbase)) { + return; + } + + const int scanfill_flag = BLI_SCANFILL_CALC_REMOVE_DOUBLES | BLI_SCANFILL_CALC_POLYS | + BLI_SCANFILL_CALC_HOLES; + + MemArena *sf_arena = BLI_memarena_new(BLI_SCANFILL_ARENA_SIZE, __func__); + + short colnr = 0; + int charidx = 0; + bool should_continue = true; + while (should_continue) { + should_continue = false; + bool nextcol = false; + + ScanFillContext sf_ctx; + BLI_scanfill_begin_arena(&sf_ctx, sf_arena); + + int totvert = 0; + short dl_flag_accum = 0; + short dl_rt_accum = 0; + LISTBASE_FOREACH (const DispList *, dl, dispbase) { + if (dl->type == DL_POLY) { + if (charidx < dl->charidx) { + should_continue = true; + } + else if (charidx == dl->charidx) { /* character with needed index */ + if (colnr == dl->col) { + + sf_ctx.poly_nr++; + + /* Make verts and edges. */ + ScanFillVert *sf_vert = nullptr; + ScanFillVert *sf_vert_last = nullptr; + ScanFillVert *sf_vert_new = nullptr; + for (int i = 0; i < dl->nr; i++) { + sf_vert_last = sf_vert; + sf_vert = BLI_scanfill_vert_add(&sf_ctx, &dl->verts[3 * i]); + totvert++; + if (sf_vert_last == nullptr) { + sf_vert_new = sf_vert; + } + else { + BLI_scanfill_edge_add(&sf_ctx, sf_vert_last, sf_vert); + } + } + + if (sf_vert != nullptr && sf_vert_new != nullptr) { + BLI_scanfill_edge_add(&sf_ctx, sf_vert, sf_vert_new); + } + } + else if (colnr < dl->col) { + /* got poly with next material at current char */ + should_continue = true; + nextcol = true; + } + } + dl_flag_accum |= dl->flag; + dl_rt_accum |= dl->rt; + } + } + + const int triangles_len = BLI_scanfill_calc_ex(&sf_ctx, scanfill_flag, normal_proj); + if (totvert != 0 && triangles_len != 0) { + DispList *dlnew = (DispList *)MEM_callocN(sizeof(DispList), "filldisplist"); + dlnew->type = DL_INDEX3; + dlnew->flag = (dl_flag_accum & (DL_BACK_CURVE | DL_FRONT_CURVE)); + dlnew->rt = (dl_rt_accum & CU_SMOOTH); + dlnew->col = colnr; + dlnew->nr = totvert; + dlnew->parts = triangles_len; + + dlnew->index = (int *)MEM_mallocN(sizeof(int[3]) * triangles_len, "dlindex"); + dlnew->verts = (float *)MEM_mallocN(sizeof(float[3]) * totvert, "dlverts"); + + /* vert data */ + int i; + LISTBASE_FOREACH_INDEX (ScanFillVert *, sf_vert, &sf_ctx.fillvertbase, i) { + copy_v3_v3(&dlnew->verts[3 * i], sf_vert->co); + sf_vert->tmp.i = i; /* Index number. */ + } + + /* index data */ + int *index = dlnew->index; + LISTBASE_FOREACH (ScanFillFace *, sf_tri, &sf_ctx.fillfacebase) { + index[0] = sf_tri->v1->tmp.i; + index[1] = flip_normal ? sf_tri->v3->tmp.i : sf_tri->v2->tmp.i; + index[2] = flip_normal ? sf_tri->v2->tmp.i : sf_tri->v3->tmp.i; + index += 3; + } + + BLI_addhead(to, dlnew); + } + BLI_scanfill_end_arena(&sf_ctx, sf_arena); + + if (nextcol) { + /* stay at current char but fill polys with next material */ + colnr++; + } + else { + /* switch to next char and start filling from first material */ + charidx++; + colnr = 0; + } + } + + BLI_memarena_free(sf_arena); + /* do not free polys, needed for wireframe display */ +} + +static void bevels_to_filledpoly(const Curve *cu, ListBase *dispbase) +{ + ListBase front = {nullptr, nullptr}; + ListBase back = {nullptr, nullptr}; + + LISTBASE_FOREACH (const DispList *, dl, dispbase) { + if (dl->type == DL_SURF) { + if ((dl->flag & DL_CYCL_V) && (dl->flag & DL_CYCL_U) == 0) { + if ((cu->flag & CU_BACK) && (dl->flag & DL_BACK_CURVE)) { + DispList *dlnew = (DispList *)MEM_callocN(sizeof(DispList), __func__); + BLI_addtail(&front, dlnew); + dlnew->verts = (float *)MEM_mallocN(sizeof(float[3]) * dl->parts, __func__); + dlnew->nr = dl->parts; + dlnew->parts = 1; + dlnew->type = DL_POLY; + dlnew->flag = DL_BACK_CURVE; + dlnew->col = dl->col; + dlnew->charidx = dl->charidx; + + const float *old_verts = dl->verts; + float *new_verts = dlnew->verts; + for (int i = 0; i < dl->parts; i++) { + copy_v3_v3(new_verts, old_verts); + new_verts += 3; + old_verts += 3 * dl->nr; + } + } + if ((cu->flag & CU_FRONT) && (dl->flag & DL_FRONT_CURVE)) { + DispList *dlnew = (DispList *)MEM_callocN(sizeof(DispList), __func__); + BLI_addtail(&back, dlnew); + dlnew->verts = (float *)MEM_mallocN(sizeof(float[3]) * dl->parts, __func__); + dlnew->nr = dl->parts; + dlnew->parts = 1; + dlnew->type = DL_POLY; + dlnew->flag = DL_FRONT_CURVE; + dlnew->col = dl->col; + dlnew->charidx = dl->charidx; + + const float *old_verts = dl->verts + 3 * (dl->nr - 1); + float *new_verts = dlnew->verts; + for (int i = 0; i < dl->parts; i++) { + copy_v3_v3(new_verts, old_verts); + new_verts += 3; + old_verts += 3 * dl->nr; + } + } + } + } + } + + const float z_up[3] = {0.0f, 0.0f, -1.0f}; + BKE_displist_fill(&front, dispbase, z_up, true); + BKE_displist_fill(&back, dispbase, z_up, false); + + BKE_displist_free(&front); + BKE_displist_free(&back); + + BKE_displist_fill(dispbase, dispbase, z_up, false); +} + +static void curve_to_filledpoly(const Curve *cu, ListBase *dispbase) +{ + if (!CU_DO_2DFILL(cu)) { + return; + } + + if (dispbase->first && ((DispList *)dispbase->first)->type == DL_SURF) { + bevels_to_filledpoly(cu, dispbase); + } + else { + const float z_up[3] = {0.0f, 0.0f, -1.0f}; + BKE_displist_fill(dispbase, dispbase, z_up, false); + } +} + +/* taper rules: + * - only 1 curve + * - first point left, last point right + * - based on subdivided points in original curve, not on points in taper curve (still) + */ +static float displist_calc_taper(Depsgraph *depsgraph, + const Scene *scene, + Object *taperobj, + float fac) +{ + if (taperobj == nullptr || taperobj->type != OB_CURVE) { + return 1.0; + } + + DispList *dl = taperobj->runtime.curve_cache ? + (DispList *)taperobj->runtime.curve_cache->disp.first : + nullptr; + if (dl == nullptr) { + BKE_displist_make_curveTypes(depsgraph, scene, taperobj, false, false); + dl = (DispList *)taperobj->runtime.curve_cache->disp.first; + } + if (dl) { + float minx, dx, *fp; + int a; + + /* horizontal size */ + minx = dl->verts[0]; + dx = dl->verts[3 * (dl->nr - 1)] - minx; + if (dx > 0.0f) { + fp = dl->verts; + for (a = 0; a < dl->nr; a++, fp += 3) { + if ((fp[0] - minx) / dx >= fac) { + /* interpolate with prev */ + if (a > 0) { + float fac1 = (fp[-3] - minx) / dx; + float fac2 = (fp[0] - minx) / dx; + if (fac1 != fac2) { + return fp[1] * (fac1 - fac) / (fac1 - fac2) + fp[-2] * (fac - fac2) / (fac1 - fac2); + } + } + return fp[1]; + } + } + return fp[-2]; // last y coord + } + } + + return 1.0; +} + +float BKE_displist_calc_taper( + Depsgraph *depsgraph, const Scene *scene, Object *taperobj, int cur, int tot) +{ + float fac = ((float)cur) / (float)(tot - 1); + + return displist_calc_taper(depsgraph, scene, taperobj, fac); +} + +void BKE_displist_make_mball(Depsgraph *depsgraph, Scene *scene, Object *ob) +{ + if (!ob || ob->type != OB_MBALL) { + return; + } + + if (ob == BKE_mball_basis_find(scene, ob)) { + if (ob->runtime.curve_cache) { + BKE_displist_free(&(ob->runtime.curve_cache->disp)); + } + else { + ob->runtime.curve_cache = (CurveCache *)MEM_callocN(sizeof(CurveCache), + "CurveCache for MBall"); + } + + BKE_mball_polygonize(depsgraph, scene, ob, &ob->runtime.curve_cache->disp); + BKE_mball_texspace_calc(ob); + + object_deform_mball(ob, &ob->runtime.curve_cache->disp); + + /* NOP for MBALLs anyway... */ + boundbox_displist_object(ob); + } +} + +void BKE_displist_make_mball_forRender(Depsgraph *depsgraph, + Scene *scene, + Object *ob, + ListBase *dispbase) +{ + BKE_mball_polygonize(depsgraph, scene, ob, dispbase); + BKE_mball_texspace_calc(ob); + + object_deform_mball(ob, dispbase); +} + +static ModifierData *curve_get_tessellate_point(const Scene *scene, + const Object *ob, + const bool for_render, + const bool editmode) +{ + VirtualModifierData virtualModifierData; + ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData); + ModifierData *pretessellatePoint; + int required_mode; + + if (for_render) { + required_mode = eModifierMode_Render; + } + else { + required_mode = eModifierMode_Realtime; + } + + if (editmode) { + required_mode |= eModifierMode_Editmode; + } + + pretessellatePoint = nullptr; + for (; md; md = md->next) { + const ModifierTypeInfo *mti = BKE_modifier_get_info((ModifierType)md->type); + + if (!BKE_modifier_is_enabled(scene, md, required_mode)) { + continue; + } + if (mti->type == eModifierTypeType_Constructive) { + return pretessellatePoint; + } + + if (ELEM(md->type, eModifierType_Hook, eModifierType_Softbody, eModifierType_MeshDeform)) { + pretessellatePoint = md; + + /* this modifiers are moving point of tessellation automatically + * (some of them even can't be applied on tessellated curve), set flag + * for information button in modifier's header + */ + md->mode |= eModifierMode_ApplyOnSpline; + } + else if (md->mode & eModifierMode_ApplyOnSpline) { + pretessellatePoint = md; + } + } + + return pretessellatePoint; +} + +/* Return true if any modifier was applied. */ +bool BKE_curve_calc_modifiers_pre(Depsgraph *depsgraph, + const Scene *scene, + Object *ob, + ListBase *source_nurb, + ListBase *target_nurb, + const bool for_render) +{ + VirtualModifierData virtualModifierData; + ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData); + ModifierData *pretessellatePoint; + Curve *cu = (Curve *)ob->data; + int numElems = 0, numVerts = 0; + const bool editmode = (!for_render && (cu->editnurb || cu->editfont)); + ModifierApplyFlag apply_flag = (ModifierApplyFlag)0; + float(*deformedVerts)[3] = nullptr; + float *keyVerts = nullptr; + int required_mode; + bool modified = false; + + BKE_modifiers_clear_errors(ob); + + if (editmode) { + apply_flag = MOD_APPLY_USECACHE; + } + if (for_render) { + apply_flag = MOD_APPLY_RENDER; + required_mode = eModifierMode_Render; + } + else { + required_mode = eModifierMode_Realtime; + } + + const ModifierEvalContext mectx = {depsgraph, ob, apply_flag}; + + pretessellatePoint = curve_get_tessellate_point(scene, ob, for_render, editmode); + + if (editmode) { + required_mode |= eModifierMode_Editmode; + } + + if (!editmode) { + keyVerts = BKE_key_evaluate_object(ob, &numElems); + + if (keyVerts) { + BLI_assert(BKE_keyblock_curve_element_count(source_nurb) == numElems); + + /* split coords from key data, the latter also includes + * tilts, which is passed through in the modifier stack. + * this is also the reason curves do not use a virtual + * shape key modifier yet. */ + deformedVerts = BKE_curve_nurbs_key_vert_coords_alloc(source_nurb, keyVerts, &numVerts); + } + } + + if (pretessellatePoint) { + for (; md; md = md->next) { + const ModifierTypeInfo *mti = BKE_modifier_get_info((ModifierType)md->type); + + if (!BKE_modifier_is_enabled(scene, md, required_mode)) { + continue; + } + if (mti->type != eModifierTypeType_OnlyDeform) { + continue; + } + + if (!deformedVerts) { + deformedVerts = BKE_curve_nurbs_vert_coords_alloc(source_nurb, &numVerts); + } + + mti->deformVerts(md, &mectx, nullptr, deformedVerts, numVerts); + modified = true; + + if (md == pretessellatePoint) { + break; + } + } + } + + if (deformedVerts) { + BKE_curve_nurbs_vert_coords_apply(target_nurb, deformedVerts, false); + MEM_freeN(deformedVerts); + } + if (keyVerts) { /* these are not passed through modifier stack */ + BKE_curve_nurbs_key_vert_tilts_apply(target_nurb, keyVerts); + } + + if (keyVerts) { + MEM_freeN(keyVerts); + } + return modified; +} + +static float (*displist_vert_coords_alloc(ListBase *dispbase, int *r_vert_len))[3] +{ + float(*allverts)[3], *fp; + + *r_vert_len = 0; + + LISTBASE_FOREACH (DispList *, dl, dispbase) { + *r_vert_len += (dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr; + } + + allverts = (float(*)[3])MEM_mallocN(sizeof(float[3]) * (*r_vert_len), __func__); + fp = (float *)allverts; + LISTBASE_FOREACH (DispList *, dl, dispbase) { + int ofs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr); + memcpy(fp, dl->verts, sizeof(float) * ofs); + fp += ofs; + } + + return allverts; +} + +static void displist_vert_coords_apply(ListBase *dispbase, const float (*allverts)[3]) +{ + const float *fp; + + fp = (float *)allverts; + LISTBASE_FOREACH (DispList *, dl, dispbase) { + int ofs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr); + memcpy(dl->verts, fp, sizeof(float) * ofs); + fp += ofs; + } +} + +static void curve_calc_modifiers_post(Depsgraph *depsgraph, + const Scene *scene, + Object *ob, + ListBase *dispbase, + Mesh **r_final, + const bool for_render, + const bool force_mesh_conversion) +{ + VirtualModifierData virtualModifierData; + ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData); + ModifierData *pretessellatePoint; + const Curve *cu = (const Curve *)ob->data; + int required_mode = 0, totvert = 0; + const bool editmode = (!for_render && (cu->editnurb || cu->editfont)); + Mesh *modified = nullptr, *mesh_applied; + float(*vertCos)[3] = nullptr; + int useCache = !for_render; + ModifierApplyFlag apply_flag = (ModifierApplyFlag)0; + + if (for_render) { + apply_flag = MOD_APPLY_RENDER; + required_mode = eModifierMode_Render; + } + else { + required_mode = eModifierMode_Realtime; + } + + const ModifierEvalContext mectx_deform = { + depsgraph, ob, editmode ? (ModifierApplyFlag)(apply_flag | MOD_APPLY_USECACHE) : apply_flag}; + const ModifierEvalContext mectx_apply = { + depsgraph, ob, useCache ? (ModifierApplyFlag)(apply_flag | MOD_APPLY_USECACHE) : apply_flag}; + + pretessellatePoint = curve_get_tessellate_point(scene, ob, for_render, editmode); + + if (editmode) { + required_mode |= eModifierMode_Editmode; + } + + if (pretessellatePoint) { + md = pretessellatePoint->next; + } + + if (r_final && *r_final) { + BKE_id_free(nullptr, *r_final); + } + + for (; md; md = md->next) { + const ModifierTypeInfo *mti = BKE_modifier_get_info((ModifierType)md->type); + + if (!BKE_modifier_is_enabled(scene, md, required_mode)) { + continue; + } + + /* If we need normals, no choice, have to convert to mesh now. */ + bool need_normal = mti->dependsOnNormals != nullptr && mti->dependsOnNormals(md); + /* XXX 2.8 : now that batch cache is stored inside the ob->data + * we need to create a Mesh for each curve that uses modifiers. */ + if (modified == nullptr /* && need_normal */) { + if (vertCos != nullptr) { + displist_vert_coords_apply(dispbase, vertCos); + } + + if (ELEM(ob->type, OB_CURVE, OB_FONT) && (cu->flag & CU_DEFORM_FILL)) { + curve_to_filledpoly(cu, dispbase); + } + + modified = BKE_mesh_new_nomain_from_curve_displist(ob, dispbase); + } + + if (mti->type == eModifierTypeType_OnlyDeform || + (mti->type == eModifierTypeType_DeformOrConstruct && !modified)) { + if (modified) { + if (!vertCos) { + vertCos = BKE_mesh_vert_coords_alloc(modified, &totvert); + } + if (need_normal) { + BKE_mesh_ensure_normals(modified); + } + mti->deformVerts(md, &mectx_deform, modified, vertCos, totvert); + } + else { + if (!vertCos) { + vertCos = displist_vert_coords_alloc(dispbase, &totvert); + } + mti->deformVerts(md, &mectx_deform, nullptr, vertCos, totvert); + } + } + else { + if (!r_final) { + /* makeDisplistCurveTypes could be used for beveling, where derived mesh + * is totally unnecessary, so we could stop modifiers applying + * when we found constructive modifier but derived mesh is unwanted result + */ + break; + } + + if (modified) { + if (vertCos) { + Mesh *temp_mesh = (Mesh *)BKE_id_copy_ex( + nullptr, &modified->id, nullptr, LIB_ID_COPY_LOCALIZE); + BKE_id_free(nullptr, modified); + modified = temp_mesh; + + BKE_mesh_vert_coords_apply(modified, vertCos); + } + } + else { + if (vertCos) { + displist_vert_coords_apply(dispbase, vertCos); + } + + if (ELEM(ob->type, OB_CURVE, OB_FONT) && (cu->flag & CU_DEFORM_FILL)) { + curve_to_filledpoly(cu, dispbase); + } + + modified = BKE_mesh_new_nomain_from_curve_displist(ob, dispbase); + } + + if (vertCos) { + /* Vertex coordinates were applied to necessary data, could free it */ + MEM_freeN(vertCos); + vertCos = nullptr; + } + + if (need_normal) { + BKE_mesh_ensure_normals(modified); + } + mesh_applied = mti->modifyMesh(md, &mectx_apply, modified); + + if (mesh_applied) { + /* Modifier returned a new derived mesh */ + + if (modified && modified != mesh_applied) { /* Modifier */ + BKE_id_free(nullptr, modified); + } + modified = mesh_applied; + } + } + } + + if (vertCos) { + if (modified) { + Mesh *temp_mesh = (Mesh *)BKE_id_copy_ex( + nullptr, &modified->id, nullptr, LIB_ID_COPY_LOCALIZE); + BKE_id_free(nullptr, modified); + modified = temp_mesh; + + BKE_mesh_vert_coords_apply(modified, vertCos); + BKE_mesh_calc_normals_mapping_simple(modified); + + MEM_freeN(vertCos); + } + else { + displist_vert_coords_apply(dispbase, vertCos); + MEM_freeN(vertCos); + vertCos = nullptr; + } + } + + if (r_final) { + if (force_mesh_conversion && !modified) { + /* XXX 2.8 : This is a workaround for by some deeper technical debts: + * - DRW Batch cache is stored inside the ob->data. + * - Curve data is not COWed for instances that use different modifiers. + * This can causes the modifiers to be applied on all user of the same data-block + * (see T71055) + * + * The easy workaround is to force to generate a Mesh that will be used for display data + * since a Mesh output is already used for generative modifiers. + * However it does not fix problems with actual edit data still being shared. + * + * The right solution would be to COW the Curve data block at the input of the modifier + * stack just like what the mesh modifier does. + */ + modified = BKE_mesh_new_nomain_from_curve_displist(ob, dispbase); + } + + if (modified) { + + /* XXX2.8(Sybren): make sure the face normals are recalculated as well */ + BKE_mesh_ensure_normals(modified); + + /* Special tweaks, needed since neither BKE_mesh_new_nomain_from_template() nor + * BKE_mesh_new_nomain_from_curve_displist() properly duplicate mat info... + */ + BLI_strncpy(modified->id.name, cu->id.name, sizeof(modified->id.name)); + *((short *)modified->id.name) = ID_ME; + MEM_SAFE_FREE(modified->mat); + /* Set flag which makes it easier to see what's going on in a debugger. */ + modified->id.tag |= LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT; + modified->mat = (Material **)MEM_dupallocN(cu->mat); + modified->totcol = cu->totcol; + + (*r_final) = modified; + } + else { + (*r_final) = nullptr; + } + } + else if (modified != nullptr) { + /* Pretty stupid to generate that whole mesh if it's unused, yet we have to free it. */ + BKE_id_free(nullptr, modified); + } +} + +static void displist_surf_indices(DispList *dl) +{ + int a, b, p1, p2, p3, p4; + int *index; + + dl->totindex = 0; + + index = dl->index = (int *)MEM_mallocN(sizeof(int[4]) * (dl->parts + 1) * (dl->nr + 1), + "index array nurbs"); + + for (a = 0; a < dl->parts; a++) { + + if (BKE_displist_surfindex_get(dl, a, &b, &p1, &p2, &p3, &p4) == 0) { + break; + } + + for (; b < dl->nr; b++, index += 4) { + index[0] = p1; + index[1] = p2; + index[2] = p4; + index[3] = p3; + + dl->totindex++; + + p2 = p1; + p1++; + p4 = p3; + p3++; + } + } +} + +void BKE_displist_make_surf(Depsgraph *depsgraph, + const Scene *scene, + Object *ob, + ListBase *dispbase, + Mesh **r_final, + const bool for_render, + const bool for_orco) +{ + ListBase nubase = {nullptr, nullptr}; + Curve *cu = (Curve *)ob->data; + DispList *dl; + float *data; + int len; + bool force_mesh_conversion = false; + + if (!for_render && cu->editnurb) { + BKE_nurbList_duplicate(&nubase, BKE_curve_editNurbs_get(cu)); + } + else { + BKE_nurbList_duplicate(&nubase, &cu->nurb); + } + + if (!for_orco) { + force_mesh_conversion = BKE_curve_calc_modifiers_pre( + depsgraph, scene, ob, &nubase, &nubase, for_render); + } + + LISTBASE_FOREACH (Nurb *, nu, &nubase) { + if (!(for_render || nu->hide == 0) || !BKE_nurb_check_valid_uv(nu)) { + continue; + } + + int resolu = nu->resolu, resolv = nu->resolv; + + if (for_render) { + if (cu->resolu_ren) { + resolu = cu->resolu_ren; + } + if (cu->resolv_ren) { + resolv = cu->resolv_ren; + } + } + + if (nu->pntsv == 1) { + len = SEGMENTSU(nu) * resolu; + + dl = (DispList *)MEM_callocN(sizeof(DispList), "makeDispListsurf"); + dl->verts = (float *)MEM_mallocN(len * sizeof(float[3]), "dlverts"); + + BLI_addtail(dispbase, dl); + dl->parts = 1; + dl->nr = len; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + + /* dl->rt will be used as flag for render face and */ + /* CU_2D conflicts with R_NOPUNOFLIP */ + dl->rt = nu->flag; + + data = dl->verts; + if (nu->flagu & CU_NURB_CYCLIC) { + dl->type = DL_POLY; + } + else { + dl->type = DL_SEGM; + } + + BKE_nurb_makeCurve(nu, data, nullptr, nullptr, nullptr, resolu, sizeof(float[3])); + } + else { + len = (nu->pntsu * resolu) * (nu->pntsv * resolv); + + dl = (DispList *)MEM_callocN(sizeof(DispList), "makeDispListsurf"); + dl->verts = (float *)MEM_mallocN(len * sizeof(float[3]), "dlverts"); + BLI_addtail(dispbase, dl); + + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + + /* dl->rt will be used as flag for render face and */ + /* CU_2D conflicts with R_NOPUNOFLIP */ + dl->rt = nu->flag; + + data = dl->verts; + dl->type = DL_SURF; + + dl->parts = (nu->pntsu * resolu); /* in reverse, because makeNurbfaces works that way */ + dl->nr = (nu->pntsv * resolv); + if (nu->flagv & CU_NURB_CYCLIC) { + dl->flag |= DL_CYCL_U; /* reverse too! */ + } + if (nu->flagu & CU_NURB_CYCLIC) { + dl->flag |= DL_CYCL_V; + } + + BKE_nurb_makeFaces(nu, data, 0, resolu, resolv); + + /* gl array drawing: using indices */ + displist_surf_indices(dl); + } + } + + if (!for_orco) { + BKE_nurbList_duplicate(&ob->runtime.curve_cache->deformed_nurbs, &nubase); + curve_calc_modifiers_post( + depsgraph, scene, ob, dispbase, r_final, for_render, force_mesh_conversion); + } + + BKE_nurbList_free(&nubase); +} + +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) +{ + float *data = *r_data; + const float *fp = dlb->verts; + for (int b = 0; b < dlb->nr; b++, fp += 3, data += 3) { + if (cu->flag & CU_3D) { + float vec[3], quat[4]; + + vec[0] = fp[1] + widfac; + vec[1] = fp[2]; + vec[2] = 0.0; + + if (nbevp == nullptr) { + copy_v3_v3(data, bevp->vec); + copy_qt_qt(quat, bevp->quat); + } + else { + interp_v3_v3v3(data, bevp->vec, nbevp->vec, bev_blend); + interp_qt_qtqt(quat, bevp->quat, nbevp->quat, bev_blend); + } + + mul_qt_v3(quat, vec); + + data[0] += radius_factor * vec[0]; + data[1] += radius_factor * vec[1]; + data[2] += radius_factor * vec[2]; + } + else { + float sina, cosa; + + if (nbevp == nullptr) { + copy_v3_v3(data, bevp->vec); + sina = bevp->sina; + cosa = bevp->cosa; + } + else { + interp_v3_v3v3(data, bevp->vec, nbevp->vec, bev_blend); + + /* perhaps we need to interpolate angles instead. but the thing is + * cosa and sina are not actually sine and cosine + */ + sina = nbevp->sina * bev_blend + bevp->sina * (1.0f - bev_blend); + cosa = nbevp->cosa * bev_blend + bevp->cosa * (1.0f - bev_blend); + } + + data[0] += radius_factor * (widfac + fp[1]) * sina; + data[1] += radius_factor * (widfac + fp[1]) * cosa; + data[2] += radius_factor * fp[2]; + } + } + + *r_data = data; +} + +static void fillBevelCap(const Nurb *nu, + const DispList *dlb, + const float *prev_fp, + ListBase *dispbase) +{ + DispList *dl; + + dl = (DispList *)MEM_callocN(sizeof(DispList), "makeDispListbev2"); + dl->verts = (float *)MEM_mallocN(sizeof(float[3]) * dlb->nr, "dlverts"); + memcpy(dl->verts, prev_fp, sizeof(float[3]) * dlb->nr); + + dl->type = DL_POLY; + + dl->parts = 1; + dl->nr = dlb->nr; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + + /* dl->rt will be used as flag for render face and */ + /* CU_2D conflicts with R_NOPUNOFLIP */ + dl->rt = nu->flag; + + BLI_addtail(dispbase, dl); +} + +static void calc_bevfac_segment_mapping( + const BevList *bl, float bevfac, float spline_length, int *r_bev, float *r_blend) +{ + float normlen, normsum = 0.0f; + float *seglen = bl->seglen; + int *segbevcount = bl->segbevcount; + int bevcount = 0, nr = bl->nr; + + float bev_fl = bevfac * (bl->nr - 1); + *r_bev = (int)bev_fl; + + while (bevcount < nr - 1) { + normlen = *seglen / spline_length; + if (normsum + normlen > bevfac) { + bev_fl = bevcount + (bevfac - normsum) / normlen * *segbevcount; + *r_bev = (int)bev_fl; + *r_blend = bev_fl - *r_bev; + break; + } + normsum += normlen; + bevcount += *segbevcount; + segbevcount++; + seglen++; + } +} + +static void calc_bevfac_spline_mapping( + const BevList *bl, float bevfac, float spline_length, int *r_bev, float *r_blend) +{ + const float len_target = bevfac * spline_length; + BevPoint *bevp = bl->bevpoints; + float len_next = 0.0f, len = 0.0f; + int i = 0, nr = bl->nr; + + while (nr--) { + bevp++; + len_next = len + bevp->offset; + if (len_next > len_target) { + break; + } + len = len_next; + i++; + } + + *r_bev = i; + *r_blend = (len_target - len) / bevp->offset; +} + +static void calc_bevfac_mapping_default( + const BevList *bl, int *r_start, float *r_firstblend, int *r_steps, float *r_lastblend) +{ + *r_start = 0; + *r_steps = bl->nr; + *r_firstblend = 1.0f; + *r_lastblend = 1.0f; +} + +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) +{ + float tmpf, total_length = 0.0f; + int end = 0, i; + + if ((BKE_nurb_check_valid_u(nu) == false) || + /* not essential, but skips unnecessary calculation */ + (min_ff(cu->bevfac1, cu->bevfac2) == 0.0f && max_ff(cu->bevfac1, cu->bevfac2) == 1.0f)) { + calc_bevfac_mapping_default(bl, r_start, r_firstblend, r_steps, r_lastblend); + return; + } + + if (ELEM(cu->bevfac1_mapping, CU_BEVFAC_MAP_SEGMENT, CU_BEVFAC_MAP_SPLINE) || + ELEM(cu->bevfac2_mapping, CU_BEVFAC_MAP_SEGMENT, CU_BEVFAC_MAP_SPLINE)) { + for (i = 0; i < SEGMENTSU(nu); i++) { + total_length += bl->seglen[i]; + } + } + + switch (cu->bevfac1_mapping) { + case CU_BEVFAC_MAP_RESOLU: { + const float start_fl = cu->bevfac1 * (bl->nr - 1); + *r_start = (int)start_fl; + *r_firstblend = 1.0f - (start_fl - (*r_start)); + break; + } + case CU_BEVFAC_MAP_SEGMENT: { + calc_bevfac_segment_mapping(bl, cu->bevfac1, total_length, r_start, r_firstblend); + *r_firstblend = 1.0f - *r_firstblend; + break; + } + case CU_BEVFAC_MAP_SPLINE: { + calc_bevfac_spline_mapping(bl, cu->bevfac1, total_length, r_start, r_firstblend); + *r_firstblend = 1.0f - *r_firstblend; + break; + } + } + + switch (cu->bevfac2_mapping) { + case CU_BEVFAC_MAP_RESOLU: { + const float end_fl = cu->bevfac2 * (bl->nr - 1); + end = (int)end_fl; + + *r_steps = 2 + end - *r_start; + *r_lastblend = end_fl - end; + break; + } + case CU_BEVFAC_MAP_SEGMENT: { + calc_bevfac_segment_mapping(bl, cu->bevfac2, total_length, &end, r_lastblend); + *r_steps = end - *r_start + 2; + break; + } + case CU_BEVFAC_MAP_SPLINE: { + calc_bevfac_spline_mapping(bl, cu->bevfac2, total_length, &end, r_lastblend); + *r_steps = end - *r_start + 2; + break; + } + } + + if (end < *r_start || (end == *r_start && *r_lastblend < 1.0f - *r_firstblend)) { + SWAP(int, *r_start, end); + tmpf = *r_lastblend; + *r_lastblend = 1.0f - *r_firstblend; + *r_firstblend = 1.0f - tmpf; + *r_steps = end - *r_start + 2; + } + + if (*r_start + *r_steps > bl->nr) { + *r_steps = bl->nr - *r_start; + *r_lastblend = 1.0f; + } +} + +static void do_makeDispListCurveTypes(Depsgraph *depsgraph, + const Scene *scene, + Object *ob, + ListBase *dispbase, + const bool for_render, + const bool for_orco, + Mesh **r_final) +{ + Curve *cu = (Curve *)ob->data; + + /* we do allow duplis... this is only displist on curve level */ + if (!ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) { + return; + } + + if (ob->type == OB_SURF) { + BKE_displist_make_surf(depsgraph, scene, ob, dispbase, r_final, for_render, for_orco); + } + else if (ELEM(ob->type, OB_CURVE, OB_FONT)) { + ListBase dlbev; + ListBase nubase = {nullptr, nullptr}; + bool force_mesh_conversion = false; + + BKE_curve_bevelList_free(&ob->runtime.curve_cache->bev); + + /* We only re-evaluate path if evaluation is not happening for orco. + * If the calculation happens for orco, we should never free data which + * was needed before and only not needed for orco calculation. + */ + if (!for_orco) { + if (ob->runtime.curve_cache->anim_path_accum_length) { + MEM_freeN((void *)ob->runtime.curve_cache->anim_path_accum_length); + } + ob->runtime.curve_cache->anim_path_accum_length = nullptr; + } + + if (ob->type == OB_FONT) { + BKE_vfont_to_curve_nubase(ob, FO_EDIT, &nubase); + } + else { + BKE_nurbList_duplicate(&nubase, BKE_curve_nurbs_get(cu)); + } + + if (!for_orco) { + force_mesh_conversion = BKE_curve_calc_modifiers_pre( + depsgraph, scene, ob, &nubase, &nubase, for_render); + } + + BKE_curve_bevelList_make(ob, &nubase, for_render); + + /* If curve has no bevel will return nothing */ + BKE_curve_bevel_make(ob, &dlbev); + + /* no bevel or extrude, and no width correction? */ + if (!dlbev.first && cu->width == 1.0f) { + curve_to_displist(cu, &nubase, for_render, dispbase); + } + else { + const float widfac = cu->width - 1.0f; + BevList *bl = (BevList *)ob->runtime.curve_cache->bev.first; + Nurb *nu = (Nurb *)nubase.first; + + for (; bl && nu; bl = bl->next, nu = nu->next) { + float *data; + + if (bl->nr == 0) { /* blank bevel lists can happen */ + continue; + } + + /* exception handling; curve without bevel or extrude, with width correction */ + if (BLI_listbase_is_empty(&dlbev)) { + DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), "makeDispListbev"); + dl->verts = (float *)MEM_mallocN(sizeof(float[3]) * bl->nr, "dlverts"); + BLI_addtail(dispbase, dl); + + if (bl->poly != -1) { + dl->type = DL_POLY; + } + else { + dl->type = DL_SEGM; + dl->flag = (DL_FRONT_CURVE | DL_BACK_CURVE); + } + + dl->parts = 1; + dl->nr = bl->nr; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + + /* dl->rt will be used as flag for render face and */ + /* CU_2D conflicts with R_NOPUNOFLIP */ + dl->rt = nu->flag; + + int a = dl->nr; + BevPoint *bevp = bl->bevpoints; + data = dl->verts; + while (a--) { + data[0] = bevp->vec[0] + widfac * bevp->sina; + data[1] = bevp->vec[1] + widfac * bevp->cosa; + data[2] = bevp->vec[2]; + bevp++; + data += 3; + } + } + else { + ListBase bottom_capbase = {nullptr, nullptr}; + ListBase top_capbase = {nullptr, nullptr}; + float bottom_no[3] = {0.0f}; + float top_no[3] = {0.0f}; + float first_blend = 0.0f, last_blend = 0.0f; + int start, steps = 0; + + if (nu->flagu & CU_NURB_CYCLIC) { + calc_bevfac_mapping_default(bl, &start, &first_blend, &steps, &last_blend); + } + else { + if (fabsf(cu->bevfac2 - cu->bevfac1) < FLT_EPSILON) { + continue; + } + + calc_bevfac_mapping(cu, bl, nu, &start, &first_blend, &steps, &last_blend); + } + + LISTBASE_FOREACH (DispList *, dlb, &dlbev) { + /* for each part of the bevel use a separate displblock */ + DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), "makeDispListbev1"); + dl->verts = data = (float *)MEM_mallocN(sizeof(float[3]) * dlb->nr * steps, "dlverts"); + BLI_addtail(dispbase, dl); + + dl->type = DL_SURF; + + dl->flag = dlb->flag & (DL_FRONT_CURVE | DL_BACK_CURVE); + if (dlb->type == DL_POLY) { + dl->flag |= DL_CYCL_U; + } + if ((bl->poly >= 0) && (steps > 2)) { + dl->flag |= DL_CYCL_V; + } + + dl->parts = steps; + dl->nr = dlb->nr; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; + + /* dl->rt will be used as flag for render face and */ + /* CU_2D conflicts with R_NOPUNOFLIP */ + dl->rt = nu->flag; + + /* for each point of poly make a bevel piece */ + BevPoint *bevp_first = bl->bevpoints; + BevPoint *bevp_last = &bl->bevpoints[bl->nr - 1]; + BevPoint *bevp = &bl->bevpoints[start]; + for (int i = start, a = 0; a < steps; i++, bevp++, a++) { + float radius_factor = 1.0; + float *cur_data = data; + + if (cu->taperobj == nullptr) { + radius_factor = bevp->radius; + } + else { + float taper_factor; + if (cu->flag & CU_MAP_TAPER) { + float len = (steps - 3) + first_blend + last_blend; + + if (a == 0) { + taper_factor = 0.0f; + } + else if (a == steps - 1) { + taper_factor = 1.0f; + } + else { + taper_factor = ((float)a - (1.0f - first_blend)) / len; + } + } + else { + float len = bl->nr - 1; + taper_factor = (float)i / len; + + if (a == 0) { + taper_factor += (1.0f - first_blend) / len; + } + else if (a == steps - 1) { + taper_factor -= (1.0f - last_blend) / len; + } + } + + radius_factor = displist_calc_taper(depsgraph, scene, cu->taperobj, taper_factor); + + if (cu->taper_radius_mode == CU_TAPER_RADIUS_MULTIPLY) { + radius_factor *= bevp->radius; + } + else if (cu->taper_radius_mode == CU_TAPER_RADIUS_ADD) { + radius_factor += bevp->radius; + } + } + + /* rotate bevel piece and write in data */ + if ((a == 0) && (bevp != bevp_last)) { + rotateBevelPiece( + cu, bevp, bevp + 1, dlb, 1.0f - first_blend, widfac, radius_factor, &data); + } + else if ((a == steps - 1) && (bevp != bevp_first)) { + rotateBevelPiece( + cu, bevp, bevp - 1, dlb, 1.0f - last_blend, widfac, radius_factor, &data); + } + else { + rotateBevelPiece(cu, bevp, nullptr, dlb, 0.0f, widfac, radius_factor, &data); + } + + if ((cu->flag & CU_FILL_CAPS) && !(nu->flagu & CU_NURB_CYCLIC)) { + if (a == 1) { + fillBevelCap(nu, dlb, cur_data - 3 * dlb->nr, &bottom_capbase); + copy_v3_v3(bottom_no, bevp->dir); + } + if (a == steps - 1) { + fillBevelCap(nu, dlb, cur_data, &top_capbase); + negate_v3_v3(top_no, bevp->dir); + } + } + } + + /* gl array drawing: using indices */ + displist_surf_indices(dl); + } + + if (bottom_capbase.first) { + BKE_displist_fill(&bottom_capbase, dispbase, bottom_no, false); + BKE_displist_fill(&top_capbase, dispbase, top_no, false); + BKE_displist_free(&bottom_capbase); + BKE_displist_free(&top_capbase); + } + } + } + BKE_displist_free(&dlbev); + } + + if (!(cu->flag & CU_DEFORM_FILL)) { + curve_to_filledpoly(cu, dispbase); + } + + if (!for_orco) { + if ((cu->flag & CU_PATH) || + DEG_get_eval_flags_for_id(depsgraph, &ob->id) & DAG_EVAL_NEED_CURVE_PATH) { + BKE_anim_path_calc_data(ob); + } + + BKE_nurbList_duplicate(&ob->runtime.curve_cache->deformed_nurbs, &nubase); + curve_calc_modifiers_post( + depsgraph, scene, ob, dispbase, r_final, for_render, force_mesh_conversion); + } + + if (cu->flag & CU_DEFORM_FILL && !ob->runtime.data_eval) { + curve_to_filledpoly(cu, dispbase); + } + + BKE_nurbList_free(&nubase); + } +} + +void BKE_displist_make_curveTypes(Depsgraph *depsgraph, + const Scene *scene, + Object *ob, + const bool for_render, + const bool for_orco) +{ + ListBase *dispbase; + + /* The same check for duplis as in do_makeDispListCurveTypes. + * Happens when curve used for constraint/bevel was converted to mesh. + * check there is still needed for render displist and orco displists. */ + if (!ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) { + return; + } + + BKE_object_free_derived_caches(ob); + + if (!ob->runtime.curve_cache) { + ob->runtime.curve_cache = (CurveCache *)MEM_callocN(sizeof(CurveCache), + "CurveCache for curve types"); + } + + dispbase = &(ob->runtime.curve_cache->disp); + + Mesh *mesh_eval = nullptr; + do_makeDispListCurveTypes(depsgraph, scene, ob, dispbase, for_render, for_orco, &mesh_eval); + + if (mesh_eval != nullptr) { + BKE_object_eval_assign_data(ob, &mesh_eval->id, true); + } + + boundbox_displist_object(ob); +} + +void BKE_displist_make_curveTypes_forRender(Depsgraph *depsgraph, + const Scene *scene, + Object *ob, + ListBase *dispbase, + Mesh **r_final, + const bool for_orco) +{ + if (ob->runtime.curve_cache == nullptr) { + ob->runtime.curve_cache = (CurveCache *)MEM_callocN(sizeof(CurveCache), + "CurveCache for Curve"); + } + + do_makeDispListCurveTypes(depsgraph, scene, ob, dispbase, true, for_orco, r_final); +} + +void BKE_displist_minmax(const ListBase *dispbase, float min[3], float max[3]) +{ + const float *vert; + int a, tot = 0; + int doit = 0; + + LISTBASE_FOREACH (const DispList *, dl, dispbase) { + tot = (dl->type == DL_INDEX3) ? dl->nr : dl->nr * dl->parts; + vert = dl->verts; + for (a = 0; a < tot; a++, vert += 3) { + minmax_v3v3_v3(min, max, vert); + } + doit |= (tot != 0); + } + + if (!doit) { + /* there's no geometry in displist, use zero-sized boundbox */ + zero_v3(min); + zero_v3(max); + } +} + +/* this is confusing, there's also min_max_object, applying the obmat... */ +static void boundbox_displist_object(Object *ob) +{ + if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) { + /* Curve's BB is already calculated as a part of modifier stack, + * here we only calculate object BB based on final display list. + */ + + /* object's BB is calculated from final displist */ + if (ob->runtime.bb == nullptr) { + ob->runtime.bb = (BoundBox *)MEM_callocN(sizeof(BoundBox), "boundbox"); + } + + Mesh *mesh_eval = BKE_object_get_evaluated_mesh(ob); + if (mesh_eval) { + BKE_object_boundbox_calc_from_mesh(ob, mesh_eval); + } + else { + float min[3], max[3]; + + INIT_MINMAX(min, max); + BKE_displist_minmax(&ob->runtime.curve_cache->disp, min, max); + BKE_boundbox_init_from_minmax(ob->runtime.bb, min, max); + + ob->runtime.bb->flag &= ~BOUNDBOX_DIRTY; + } + } +} |