diff options
author | YimingWu <xp8110@outlook.com> | 2021-03-17 10:04:51 +0300 |
---|---|---|
committer | Sebastian Parborg <darkdefende@gmail.com> | 2021-03-17 17:23:20 +0300 |
commit | 7f769567d085ef5c13d99a34bb7af7a7b147f523 (patch) | |
tree | 5467e0ac572576c138ccfde7844fcc12cf6f2522 | |
parent | 0f1482279c6dd39992470ff5d09cc3615c344b34 (diff) |
LineArt: Remove "Render" in structure names.
5 files changed, 315 insertions, 331 deletions
diff --git a/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h b/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h index 7519f3ef40f..0c170deacbb 100644 --- a/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h +++ b/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h @@ -45,12 +45,12 @@ typedef struct LineartStaticMemPool { SpinLock lock_mem; } LineartStaticMemPool; -typedef struct LineartRenderTriangleAdjacent { - struct LineartRenderLine *rl[3]; -} LineartRenderTriangleAdjacent; +typedef struct LineartTriangleAdjacent { + struct LineartLine *rl[3]; +} LineartTriangleAdjacent; -typedef struct LineartRenderTriangle { - struct LineartRenderVert *v[3]; +typedef struct LineartTriangle { + struct LineartVert *v[3]; /* first culled in line list to use adjacent triangle info, then go through triangle list. */ double gn[3]; @@ -63,18 +63,18 @@ typedef struct LineartRenderTriangle { * This variable is also reused to store the pointer to adjacent lines of this triangle before * intersection statge */ struct LinkNode *intersecting_verts; -} LineartRenderTriangle; +} LineartTriangle; -typedef struct LineartRenderTriangleThread { - struct LineartRenderTriangle base; +typedef struct LineartTriangleThread { + struct LineartTriangle base; /* This variable is used to store per-thread triangle-line testing pair, * also re-used to store triangle-triangle pair for intersection testing stage. - * Do not directly use LineartRenderTriangleThread. - * The size of LineartRenderTriangle is dynamically allocated to contain set thread number of + * Do not directly use LineartTriangleThread. + * The size of LineartTriangle is dynamically allocated to contain set thread number of * "testing" field. Worker threads will test lines against the "base" triangle. * At least one thread is present, thus we always have at least testing[0]. */ - struct LineartRenderLine *testing[1]; -} LineartRenderTriangleThread; + struct LineartLine *testing[1]; +} LineartTriangleThread; typedef enum eLineArtElementNodeFlag { LRT_ELEMENT_IS_ADDITIONAL = (1 << 0), @@ -82,8 +82,8 @@ typedef enum eLineArtElementNodeFlag { LRT_ELEMENT_NO_INTERSECTION = (1 << 2), } eLineArtElementNodeFlag; -typedef struct LineartRenderElementLinkNode { - struct LineartRenderElementLinkNode *next, *prev; +typedef struct LineartElementLinkNode { + struct LineartElementLinkNode *next, *prev; void *pointer; int element_count; void *object_ref; @@ -91,10 +91,10 @@ typedef struct LineartRenderElementLinkNode { /* Per object value, always set, if not enabled by ObjectLineArt, then it's set to global. */ float crease_threshold; -} LineartRenderElementLinkNode; +} LineartElementLinkNode; -typedef struct LineartRenderLineSegment { - struct LineartRenderLineSegment *next, *prev; +typedef struct LineartLineSegment { + struct LineartLineSegment *next, *prev; /** at==0: left at==1: right (this is in 2D projected space) */ double at; /** Occlusion level after "at" point */ @@ -106,9 +106,9 @@ typedef struct LineartRenderLineSegment { * enought for most cases. */ unsigned char transparency_mask; -} LineartRenderLineSegment; +} LineartLineSegment; -typedef struct LineartRenderVert { +typedef struct LineartVert { double gloc[3]; double fbcoord[4]; @@ -121,28 +121,28 @@ typedef struct LineartRenderVert { */ char flag; -} LineartRenderVert; +} LineartVert; -typedef struct LineartRenderVertIntersection { - struct LineartRenderVert base; +typedef struct LineartVertIntersection { + struct LineartVert base; /* Use vert index because we only use this to check vertex equal. This way we save 8 Bytes. */ int isec1, isec2; - struct LineartRenderTriangle *intersecting_with; -} LineartRenderVertIntersection; + struct LineartTriangle *intersecting_with; +} LineartVertIntersection; typedef enum eLineArtVertFlags { LRT_VERT_HAS_INTERSECTION_DATA = (1 << 0), LRT_VERT_EDGE_USED = (1 << 1), } eLineArtVertFlags; -typedef struct LineartRenderLine { +typedef struct LineartLine { /* We only need link node kind of list here. */ - struct LineartRenderLine *next; - struct LineartRenderVert *l, *r; + struct LineartLine *next; + struct LineartVert *l, *r; /* Local vertex index for two ends, not puting in RenderVert because all verts are loaded, so as * long as fewer than half of the mesh edges are becoming a feature line, we save more memory. */ int l_obindex, r_obindex; - struct LineartRenderTriangle *tl, *tr; + struct LineartTriangle *tl, *tr; ListBase segments; char min_occ; @@ -154,10 +154,10 @@ typedef struct LineartRenderLine { * another bit in flags to be able to show the difference. */ struct Object *object_ref; -} LineartRenderLine; +} LineartLine; -typedef struct LineartRenderLineChain { - struct LineartRenderLineChain *next, *prev; +typedef struct LineartLineChain { + struct LineartLineChain *next, *prev; ListBase chain; /** Calculated before draw cmd. */ @@ -172,10 +172,10 @@ typedef struct LineartRenderLineChain { unsigned char transparency_mask; struct Object *object_ref; -} LineartRenderLineChain; +} LineartLineChain; -typedef struct LineartRenderLineChainItem { - struct LineartRenderLineChainItem *next, *prev; +typedef struct LineartLineChainItem { + struct LineartLineChainItem *next, *prev; /** Need z value for fading */ float pos[3]; /** For restoring position to 3d space */ @@ -185,12 +185,12 @@ typedef struct LineartRenderLineChainItem { char occlusion; unsigned char transparency_mask; size_t index; -} LineartRenderLineChainItem; +} LineartLineChainItem; typedef struct LineartChainRegisterEntry { struct LineartChainRegisterEntry *next, *prev; - LineartRenderLineChain *rlc; - LineartRenderLineChainItem *rlci; + LineartLineChain *rlc; + LineartLineChainItem *rlci; char picked; /** left/right mark. @@ -232,29 +232,29 @@ typedef struct LineartRenderBuffer { unsigned int contour_count; unsigned int contour_processed; - LineartRenderLine *contour_managed; + LineartLine *contour_managed; /* Now changed to linknodes. */ - LineartRenderLine *contours; + LineartLine *contours; unsigned int intersection_count; unsigned int intersection_processed; - LineartRenderLine *intersection_managed; - LineartRenderLine *intersection_lines; + LineartLine *intersection_managed; + LineartLine *intersection_lines; unsigned int crease_count; unsigned int crease_processed; - LineartRenderLine *crease_managed; - LineartRenderLine *crease_lines; + LineartLine *crease_managed; + LineartLine *crease_lines; unsigned int material_line_count; unsigned int material_processed; - LineartRenderLine *material_managed; - LineartRenderLine *material_lines; + LineartLine *material_managed; + LineartLine *material_lines; unsigned int edge_mark_count; unsigned int edge_mark_processed; - LineartRenderLine *edge_mark_managed; - LineartRenderLine *edge_marks; + LineartLine *edge_mark_managed; + LineartLine *edge_marks; ListBase chains; @@ -317,20 +317,20 @@ typedef struct LineartRenderTaskInfo { int thread_id; - LineartRenderLine *contour; - LineartRenderLine *contour_end; + LineartLine *contour; + LineartLine *contour_end; - LineartRenderLine *intersection; - LineartRenderLine *intersection_end; + LineartLine *intersection; + LineartLine *intersection_end; - LineartRenderLine *crease; - LineartRenderLine *crease_end; + LineartLine *crease; + LineartLine *crease_end; - LineartRenderLine *material; - LineartRenderLine *material_end; + LineartLine *material; + LineartLine *material_end; - LineartRenderLine *edge_mark; - LineartRenderLine *edge_mark_end; + LineartLine *edge_mark; + LineartLine *edge_mark_end; } LineartRenderTaskInfo; @@ -507,7 +507,7 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb, const bool do_geometry_s void MOD_lineart_chain_discard_short(LineartRenderBuffer *rb, const float threshold); void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshold_rad); -int MOD_lineart_chain_count(const LineartRenderLineChain *rlc); +int MOD_lineart_chain_count(const LineartLineChain *rlc); void MOD_lineart_chain_clear_picked_flag(struct LineartRenderBuffer *rb); int MOD_lineart_compute_feature_lines(struct Depsgraph *depsgraph, @@ -545,7 +545,7 @@ void MOD_lineart_gpencil_generate(LineartRenderBuffer *rb, const char *vgname, int modifier_flags); -float MOD_lineart_chain_compute_length(LineartRenderLineChain *rlc); +float MOD_lineart_chain_compute_length(LineartLineChain *rlc); struct wmOperatorType; diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c index 36115fa1027..7b6ad05f7ce 100644 --- a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c +++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c @@ -48,13 +48,13 @@ /* Get a connected line, only for lines who has the exact given vert, or (in the case of * intersection lines) who has a vert that has the exact same position. */ -static LineartRenderLine *lineart_line_get_connected(LineartBoundingArea *ba, - LineartRenderVert *rv, - LineartRenderVert **new_rv, - int match_flag) +static LineartLine *lineart_line_get_connected(LineartBoundingArea *ba, + LineartVert *rv, + LineartVert **new_rv, + int match_flag) { LISTBASE_FOREACH (LinkData *, lip, &ba->linked_lines) { - LineartRenderLine *nrl = lip->data; + LineartLine *nrl = lip->data; if ((!(nrl->flags & LRT_EDGE_FLAG_ALL_TYPE)) || (nrl->flags & LRT_EDGE_FLAG_CHAIN_PICKED)) { continue; @@ -84,17 +84,17 @@ static LineartRenderLine *lineart_line_get_connected(LineartBoundingArea *ba, return NULL; } -static LineartRenderLineChain *lineart_chain_create(LineartRenderBuffer *rb) +static LineartLineChain *lineart_chain_create(LineartRenderBuffer *rb) { - LineartRenderLineChain *rlc; - rlc = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderLineChain)); + LineartLineChain *rlc; + rlc = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineChain)); BLI_addtail(&rb->chains, rlc); return rlc; } -static bool lineart_point_overlapping(LineartRenderLineChainItem *rlci, +static bool lineart_point_overlapping(LineartLineChainItem *rlci, float x, float y, double threshold) @@ -109,29 +109,29 @@ static bool lineart_point_overlapping(LineartRenderLineChainItem *rlci, return false; } -static LineartRenderLineChainItem *lineart_chain_append_point(LineartRenderBuffer *rb, - LineartRenderLineChain *rlc, - float *fbcoord, - float *gpos, - float *normal, - char type, - int level, - unsigned char transparency_mask, - size_t index) +static LineartLineChainItem *lineart_chain_append_point(LineartRenderBuffer *rb, + LineartLineChain *rlc, + float *fbcoord, + float *gpos, + float *normal, + char type, + int level, + unsigned char transparency_mask, + size_t index) { - LineartRenderLineChainItem *rlci; + LineartLineChainItem *rlci; if (lineart_point_overlapping(rlc->chain.last, fbcoord[0], fbcoord[1], 1e-5)) { /* Because the new chain point is overlapping, just replace the type and occlusion level of the * current point. This makes it so that the line to the point after this one has the correct * type and level. */ - LineartRenderLineChainItem *old_rlci = rlc->chain.last; + LineartLineChainItem *old_rlci = rlc->chain.last; old_rlci->line_type = type; old_rlci->occlusion = level; return old_rlci; } - rlci = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderLineChainItem)); + rlci = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineChainItem)); copy_v2_v2(rlci->pos, fbcoord); copy_v3_v3(rlci->gpos, gpos); @@ -145,23 +145,23 @@ static LineartRenderLineChainItem *lineart_chain_append_point(LineartRenderBuffe return rlci; } -static LineartRenderLineChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb, - LineartRenderLineChain *rlc, - float *fbcoord, - float *gpos, - float *normal, - char type, - int level, - unsigned char transparency_mask, - size_t index) +static LineartLineChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb, + LineartLineChain *rlc, + float *fbcoord, + float *gpos, + float *normal, + char type, + int level, + unsigned char transparency_mask, + size_t index) { - LineartRenderLineChainItem *rlci; + LineartLineChainItem *rlci; if (lineart_point_overlapping(rlc->chain.first, fbcoord[0], fbcoord[1], 1e-5)) { return rlc->chain.first; } - rlci = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderLineChainItem)); + rlci = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineChainItem)); copy_v2_v2(rlci->pos, fbcoord); copy_v3_v3(rlci->gpos, gpos); @@ -177,10 +177,10 @@ static LineartRenderLineChainItem *lineart_chain_prepend_point(LineartRenderBuff void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb) { - LineartRenderLineChain *rlc; - LineartRenderLineChainItem *rlci; + LineartLineChain *rlc; + LineartLineChainItem *rlci; LineartBoundingArea *ba; - LineartRenderLineSegment *rls; + LineartLineSegment *rls; int last_occlusion; unsigned char last_transparency; /* Used when converting from double. */ @@ -210,8 +210,8 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb) * so we assign it based on the first segment we found. */ rlc->object_ref = rl->object_ref; - LineartRenderLine *new_rl = rl; - LineartRenderVert *new_rv; + LineartLine *new_rl = rl; + LineartVert *new_rv; float N[3] = {0}; if (rl->tl) { @@ -337,8 +337,8 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb) /* Step 2: Adding all cuts from the given line, so we can continue connecting the right side * of the line. */ rls = rl->segments.first; - last_occlusion = ((LineartRenderLineSegment *)rls)->occlusion; - last_transparency = ((LineartRenderLineSegment *)rls)->transparency_mask; + last_occlusion = ((LineartLineSegment *)rls)->occlusion; + last_transparency = ((LineartLineSegment *)rls)->transparency_mask; for (rls = rls->next; rls; rls = rls->next) { double gpos[3], lpos[3]; double *lfb = rl->l->fbcoord, *rfb = rl->r->fbcoord; @@ -466,8 +466,9 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb) LRT_ITER_ALL_LINES_END } -static LineartBoundingArea *lineart_bounding_area_get_rlci_recursive( - LineartRenderBuffer *rb, LineartBoundingArea *root, LineartRenderLineChainItem *rlci) +static LineartBoundingArea *lineart_bounding_area_get_rlci_recursive(LineartRenderBuffer *rb, + LineartBoundingArea *root, + LineartLineChainItem *rlci) { if (root->child == NULL) { return root; @@ -494,7 +495,7 @@ static LineartBoundingArea *lineart_bounding_area_get_rlci_recursive( } static LineartBoundingArea *lineart_bounding_area_get_end_point(LineartRenderBuffer *rb, - LineartRenderLineChainItem *rlci) + LineartLineChainItem *rlci) { if (!rlci) { return NULL; @@ -512,8 +513,8 @@ static LineartBoundingArea *lineart_bounding_area_get_end_point(LineartRenderBuf * is too big that it covers multiple small bounding areas. */ static void lineart_bounding_area_link_point_recursive(LineartRenderBuffer *rb, LineartBoundingArea *root, - LineartRenderLineChain *rlc, - LineartRenderLineChainItem *rlci) + LineartLineChain *rlc, + LineartLineChainItem *rlci) { if (root->child == NULL) { LineartChainRegisterEntry *cre = lineart_list_append_pointer_pool_sized( @@ -548,10 +549,10 @@ static void lineart_bounding_area_link_point_recursive(LineartRenderBuffer *rb, } } -static void lineart_bounding_area_link_chain(LineartRenderBuffer *rb, LineartRenderLineChain *rlc) +static void lineart_bounding_area_link_chain(LineartRenderBuffer *rb, LineartLineChain *rlc) { - LineartRenderLineChainItem *pl = rlc->chain.first; - LineartRenderLineChainItem *pr = rlc->chain.last; + LineartLineChainItem *pl = rlc->chain.first; + LineartLineChainItem *pr = rlc->chain.last; LineartBoundingArea *ba1 = MOD_lineart_get_parent_bounding_area(rb, pl->pos[0], pl->pos[1]); LineartBoundingArea *ba2 = MOD_lineart_get_parent_bounding_area(rb, pr->pos[0], pr->pos[1]); @@ -565,8 +566,8 @@ static void lineart_bounding_area_link_chain(LineartRenderBuffer *rb, LineartRen void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb) { - LineartRenderLineChain *rlc, *new_rlc; - LineartRenderLineChainItem *rlci, *next_rlci; + LineartLineChain *rlc, *new_rlc; + LineartLineChainItem *rlci, *next_rlci; ListBase swap = {0}; swap.first = rb->chains.first; @@ -577,7 +578,7 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb) while ((rlc = BLI_pophead(&swap)) != NULL) { rlc->next = rlc->prev = NULL; BLI_addtail(&rb->chains, rlc); - LineartRenderLineChainItem *first_rlci = (LineartRenderLineChainItem *)rlc->chain.first; + LineartLineChainItem *first_rlci = (LineartLineChainItem *)rlc->chain.first; int fixed_occ = first_rlci->occlusion; unsigned char fixed_mask = first_rlci->transparency_mask; rlc->level = fixed_occ; @@ -601,7 +602,7 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb) new_rlc->chain.first = rlci; new_rlc->chain.last = rlc->chain.last; rlc->chain.last = rlci->prev; - ((LineartRenderLineChainItem *)rlc->chain.last)->next = 0; + ((LineartLineChainItem *)rlc->chain.last)->next = 0; rlci->prev = 0; /* End the previous one. */ @@ -624,19 +625,19 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb) } } } - LISTBASE_FOREACH (LineartRenderLineChain *, irlc, &rb->chains) { + LISTBASE_FOREACH (LineartLineChain *, irlc, &rb->chains) { lineart_bounding_area_link_chain(rb, irlc); } } /* Note: segment type (crease/material/contour...) is ambiguous after this. */ static void lineart_chain_connect(LineartRenderBuffer *UNUSED(rb), - LineartRenderLineChain *onto, - LineartRenderLineChain *sub, + LineartLineChain *onto, + LineartLineChain *sub, int reverse_1, int reverse_2) { - LineartRenderLineChainItem *rlci; + LineartLineChainItem *rlci; if (onto->type == LRT_EDGE_FLAG_INTERSECTION) { if (sub->object_ref) { onto->object_ref = sub->object_ref; @@ -659,8 +660,8 @@ static void lineart_chain_connect(LineartRenderBuffer *UNUSED(rb), return; } } - ((LineartRenderLineChainItem *)onto->chain.last)->next = sub->chain.first; - ((LineartRenderLineChainItem *)sub->chain.first)->prev = onto->chain.last; + ((LineartLineChainItem *)onto->chain.last)->next = sub->chain.first; + ((LineartLineChainItem *)sub->chain.first)->prev = onto->chain.last; onto->chain.last = sub->chain.last; } else { /* L-R L--R. */ @@ -674,16 +675,16 @@ static void lineart_chain_connect(LineartRenderBuffer *UNUSED(rb), return; } } - ((LineartRenderLineChainItem *)sub->chain.last)->next = onto->chain.first; - ((LineartRenderLineChainItem *)onto->chain.first)->prev = sub->chain.last; + ((LineartLineChainItem *)sub->chain.last)->next = onto->chain.first; + ((LineartLineChainItem *)onto->chain.first)->prev = sub->chain.last; onto->chain.first = sub->chain.first; } } static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuffer *rb, LineartBoundingArea *ba, - LineartRenderLineChain *rlc, - LineartRenderLineChainItem *rlci, + LineartLineChain *rlc, + LineartLineChainItem *rlci, int occlusion, unsigned char transparency_mask, float dist, @@ -784,8 +785,8 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf * implemented yet. */ void MOD_lineart_chain_connect(LineartRenderBuffer *rb, const bool do_geometry_space) { - LineartRenderLineChain *rlc; - LineartRenderLineChainItem *rlci_l, *rlci_r; + LineartLineChain *rlc; + LineartLineChainItem *rlci_l, *rlci_r; LineartBoundingArea *ba_l, *ba_r; LineartChainRegisterEntry *closest_cre_l, *closest_cre_r, *closest_cre; float dist = do_geometry_space ? rb->chaining_geometry_threshold : rb->chaining_image_threshold; @@ -877,9 +878,9 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb, const bool do_geometry_s } /* Length is in image space. */ -float MOD_lineart_chain_compute_length(LineartRenderLineChain *rlc) +float MOD_lineart_chain_compute_length(LineartLineChain *rlc) { - LineartRenderLineChainItem *rlci; + LineartLineChainItem *rlci; float offset_accum = 0; float dist; float last_point[2]; @@ -896,7 +897,7 @@ float MOD_lineart_chain_compute_length(LineartRenderLineChain *rlc) void MOD_lineart_chain_discard_short(LineartRenderBuffer *rb, const float threshold) { - LineartRenderLineChain *rlc, *next_rlc; + LineartLineChain *rlc, *next_rlc; for (rlc = rb->chains.first; rlc; rlc = next_rlc) { next_rlc = rlc->next; if (MOD_lineart_chain_compute_length(rlc) < threshold) { @@ -905,10 +906,10 @@ void MOD_lineart_chain_discard_short(LineartRenderBuffer *rb, const float thresh } } -int MOD_lineart_chain_count(const LineartRenderLineChain *rlc) +int MOD_lineart_chain_count(const LineartLineChain *rlc) { int count = 0; - LISTBASE_FOREACH (LineartRenderLineChainItem *, rlci, &rlc->chain) { + LISTBASE_FOREACH (LineartLineChainItem *, rlci, &rlc->chain) { count++; } return count; @@ -919,7 +920,7 @@ void MOD_lineart_chain_clear_picked_flag(LineartRenderBuffer *rb) if (rb == NULL) { return; } - LISTBASE_FOREACH (LineartRenderLineChain *, rlc, &rb->chains) { + LISTBASE_FOREACH (LineartLineChain *, rlc, &rb->chains) { rlc->picked = 0; } } @@ -928,8 +929,8 @@ void MOD_lineart_chain_clear_picked_flag(LineartRenderBuffer *rb) * MOD_lineart_chain_split_for_fixed_occlusion().*/ void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshold_rad) { - LineartRenderLineChain *rlc, *new_rlc; - LineartRenderLineChainItem *rlci, *next_rlci, *prev_rlci; + LineartLineChain *rlc, *new_rlc; + LineartLineChainItem *rlci, *next_rlci, *prev_rlci; ListBase swap = {0}; swap.first = rb->chains.first; @@ -940,7 +941,7 @@ void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshol while ((rlc = BLI_pophead(&swap)) != NULL) { rlc->next = rlc->prev = NULL; BLI_addtail(&rb->chains, rlc); - LineartRenderLineChainItem *first_rlci = (LineartRenderLineChainItem *)rlc->chain.first; + LineartLineChainItem *first_rlci = (LineartLineChainItem *)rlc->chain.first; for (rlci = first_rlci->next; rlci; rlci = next_rlci) { next_rlci = rlci->next; prev_rlci = rlci->prev; @@ -956,7 +957,7 @@ void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshol new_rlc->chain.first = rlci; new_rlc->chain.last = rlc->chain.last; rlc->chain.last = rlci->prev; - ((LineartRenderLineChainItem *)rlc->chain.last)->next = 0; + ((LineartLineChainItem *)rlc->chain.last)->next = 0; rlci->prev = 0; /* End the previous one. */ diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c index f83d07b41e6..612da60b098 100644 --- a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c +++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c @@ -79,14 +79,14 @@ #include "lineart_intern.h" static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer *rb, - LineartRenderLine *rl); + LineartLine *rl); static void lineart_bounding_area_link_line(LineartRenderBuffer *rb, LineartBoundingArea *root_ba, - LineartRenderLine *rl); + LineartLine *rl); static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *This, - LineartRenderLine *rl, + LineartLine *rl, double x, double y, double k, @@ -96,7 +96,7 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *This double *next_y); static bool lineart_get_line_bounding_areas(LineartRenderBuffer *rb, - LineartRenderLine *rl, + LineartLine *rl, int *rowbegin, int *rowend, int *colbegin, @@ -104,15 +104,15 @@ static bool lineart_get_line_bounding_areas(LineartRenderBuffer *rb, static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb, LineartBoundingArea *root_ba, - LineartRenderTriangle *rt, + LineartTriangle *rt, double *LRUB, int recursive, int recursive_level, bool do_intersection); static bool lineart_triangle_line_image_space_occlusion(SpinLock *spl, - const LineartRenderTriangle *rt, - const LineartRenderLine *rl, + const LineartTriangle *rt, + const LineartLine *rl, const double *override_camera_loc, const bool override_cam_is_persp, const bool allow_overlapping_edges, @@ -123,13 +123,13 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *spl, double *from, double *to); -static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartRenderLine *rl); +static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartLine *rl); -static void lineart_line_discard_segment(LineartRenderBuffer *rb, LineartRenderLineSegment *rls) +static void lineart_line_discard_segment(LineartRenderBuffer *rb, LineartLineSegment *rls) { BLI_spin_lock(&rb->lock_cuts); - memset(rls, 0, sizeof(LineartRenderLineSegment)); + memset(rls, 0, sizeof(LineartLineSegment)); /* Storing the node for potentially reuse the memory for new segment data. Line Art data is not * freed after all calulations are done. */ @@ -138,34 +138,34 @@ static void lineart_line_discard_segment(LineartRenderBuffer *rb, LineartRenderL BLI_spin_unlock(&rb->lock_cuts); } -static LineartRenderLineSegment *lineart_line_give_segment(LineartRenderBuffer *rb) +static LineartLineSegment *lineart_line_give_segment(LineartRenderBuffer *rb) { BLI_spin_lock(&rb->lock_cuts); /* See if there is any already allocated memory we can reuse. */ if (rb->wasted_cuts.first) { - LineartRenderLineSegment *rls = (LineartRenderLineSegment *)BLI_pophead(&rb->wasted_cuts); + LineartLineSegment *rls = (LineartLineSegment *)BLI_pophead(&rb->wasted_cuts); BLI_spin_unlock(&rb->lock_cuts); - memset(rls, 0, sizeof(LineartRenderLineSegment)); + memset(rls, 0, sizeof(LineartLineSegment)); return rls; } BLI_spin_unlock(&rb->lock_cuts); /* Otherwise allocate some new memory. */ - return (LineartRenderLineSegment *)lineart_mem_aquire_thread(&rb->render_data_pool, - sizeof(LineartRenderLineSegment)); + return (LineartLineSegment *)lineart_mem_aquire_thread(&rb->render_data_pool, + sizeof(LineartLineSegment)); } /* Cuts the line in image space and mark occlusion level for each segment. */ static void lineart_line_cut(LineartRenderBuffer *rb, - LineartRenderLine *rl, + LineartLine *rl, double start, double end, unsigned char transparency_mask) { - LineartRenderLineSegment *rls, *irls, *next_rls, *prev_rls; - LineartRenderLineSegment *cut_start_before = 0, *cut_end_before = 0; - LineartRenderLineSegment *ns = 0, *ns2 = 0; + LineartLineSegment *rls, *irls, *next_rls, *prev_rls; + LineartLineSegment *cut_start_before = 0, *cut_end_before = 0; + LineartLineSegment *ns = 0, *ns2 = 0; int untouched = 0; /* If for some reason the occlusion function may give a result that has zero length, or reversed @@ -315,23 +315,20 @@ static void lineart_line_cut(LineartRenderBuffer *rb, } /* To see if given line is connected to an adjacent intersection line. */ -BLI_INLINE bool lineart_occlusion_is_adjacent_intersection(LineartRenderLine *rl, - LineartRenderTriangle *rt) +BLI_INLINE bool lineart_occlusion_is_adjacent_intersection(LineartLine *rl, LineartTriangle *rt) { - LineartRenderVertIntersection *l = (void *)rl->l; - LineartRenderVertIntersection *r = (void *)rl->r; + LineartVertIntersection *l = (void *)rl->l; + LineartVertIntersection *r = (void *)rl->r; return ((l->base.flag && l->intersecting_with == (void *)rt) || (r->base.flag && r->intersecting_with == (void *)rt)); } -static void lineart_occlusion_single_line(LineartRenderBuffer *rb, - LineartRenderLine *rl, - int thread_id) +static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartLine *rl, int thread_id) { double x = rl->l->fbcoord[0], y = rl->l->fbcoord[1]; LineartBoundingArea *ba = lineart_line_first_bounding_area(rb, rl); LineartBoundingArea *nba = ba; - LineartRenderTriangleThread *rt; + LineartTriangleThread *rt; /* These values are used for marching along the line. */ double l, r; @@ -350,7 +347,7 @@ static void lineart_occlusion_single_line(LineartRenderBuffer *rb, rt = lip->data; /* If we are already testing the line in this thread, then don't do it. */ if (rt->testing[thread_id] == rl || (rt->base.flags & LRT_TRIANGLE_INTERSECTION_ONLY) || - lineart_occlusion_is_adjacent_intersection(rl, (LineartRenderTriangle *)rt)) { + lineart_occlusion_is_adjacent_intersection(rl, (LineartTriangle *)rt)) { continue; } rt->testing[thread_id] = rl; @@ -381,7 +378,7 @@ static void lineart_occlusion_single_line(LineartRenderBuffer *rb, static int lineart_occlusion_make_task_info(LineartRenderBuffer *rb, LineartRenderTaskInfo *rti) { - LineartRenderLine *data; + LineartLine *data; int i; int res = 0; @@ -418,7 +415,7 @@ static int lineart_occlusion_make_task_info(LineartRenderBuffer *rb, LineartRend static void lineart_occlusion_worker(TaskPool *__restrict UNUSED(pool), LineartRenderTaskInfo *rti) { LineartRenderBuffer *rb = rti->rb; - LineartRenderLine *lip; + LineartLine *lip; while (lineart_occlusion_make_task_info(rb, rti)) { @@ -627,53 +624,52 @@ static bool lineart_point_inside_triangle3d(double v[3], double v0[3], double v1 /* The following lineart_memory_get_XXX_space functions are for allocating new memory for some * modified geometries in the culling stage. */ -static LineartRenderElementLinkNode *lineart_memory_get_triangle_space(LineartRenderBuffer *rb) +static LineartElementLinkNode *lineart_memory_get_triangle_space(LineartRenderBuffer *rb) { - LineartRenderElementLinkNode *reln; + LineartElementLinkNode *reln; /* We don't need to allocate a whole bunch of triangles because the amount of clipped triangles * are relatively small. */ - LineartRenderTriangle *render_triangles = lineart_mem_aquire(&rb->render_data_pool, - 64 * rb->triangle_size); + LineartTriangle *render_triangles = lineart_mem_aquire(&rb->render_data_pool, + 64 * rb->triangle_size); reln = lineart_list_append_pointer_pool_sized(&rb->triangle_buffer_pointers, &rb->render_data_pool, render_triangles, - sizeof(LineartRenderElementLinkNode)); + sizeof(LineartElementLinkNode)); reln->element_count = 64; reln->flags |= LRT_ELEMENT_IS_ADDITIONAL; return reln; } -static LineartRenderElementLinkNode *lineart_memory_get_vert_space(LineartRenderBuffer *rb) +static LineartElementLinkNode *lineart_memory_get_vert_space(LineartRenderBuffer *rb) { - LineartRenderElementLinkNode *reln; + LineartElementLinkNode *reln; - LineartRenderVert *render_vertices = lineart_mem_aquire(&rb->render_data_pool, - sizeof(LineartRenderVert) * 64); + LineartVert *render_vertices = lineart_mem_aquire(&rb->render_data_pool, + sizeof(LineartVert) * 64); reln = lineart_list_append_pointer_pool_sized(&rb->vertex_buffer_pointers, &rb->render_data_pool, render_vertices, - sizeof(LineartRenderElementLinkNode)); + sizeof(LineartElementLinkNode)); reln->element_count = 64; reln->flags |= LRT_ELEMENT_IS_ADDITIONAL; return reln; } -static LineartRenderElementLinkNode *lineart_memory_get_line_space(LineartRenderBuffer *rb) +static LineartElementLinkNode *lineart_memory_get_line_space(LineartRenderBuffer *rb) { - LineartRenderElementLinkNode *reln; + LineartElementLinkNode *reln; - LineartRenderLine *render_lines = lineart_mem_aquire(&rb->render_data_pool, - sizeof(LineartRenderLine) * 64); + LineartLine *render_lines = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLine) * 64); reln = lineart_list_append_pointer_pool_sized(&rb->line_buffer_pointers, &rb->render_data_pool, render_lines, - sizeof(LineartRenderElementLinkNode)); + sizeof(LineartElementLinkNode)); reln->element_count = 64; reln->crease_threshold = rb->crease_threshold; reln->flags |= LRT_ELEMENT_IS_ADDITIONAL; @@ -681,21 +677,21 @@ static LineartRenderElementLinkNode *lineart_memory_get_line_space(LineartRender return reln; } -static void lineart_triangle_post(LineartRenderTriangle *rt, LineartRenderTriangle *orig) +static void lineart_triangle_post(LineartTriangle *rt, LineartTriangle *orig) { /* Just re-assign normal and set cull flag. */ copy_v3_v3_db(rt->gn, orig->gn); rt->flags = LRT_CULL_GENERATED; } -static void lineart_triangle_set_cull_flag(LineartRenderTriangle *rt, unsigned char flag) +static void lineart_triangle_set_cull_flag(LineartTriangle *rt, unsigned char flag) { unsigned char intersection_only = (rt->flags & LRT_TRIANGLE_INTERSECTION_ONLY); rt->flags = flag; rt->flags |= intersection_only; } -static bool lineart_line_match(LineartRenderTriangle *rt, LineartRenderLine *rl, int v1, int v2) +static bool lineart_line_match(LineartTriangle *rt, LineartLine *rl, int v1, int v2) { return ((rt->v[v1] == rl->l && rt->v[v2] == rl->r) || (rt->v[v2] == rl->l && rt->v[v1] == rl->r)); @@ -704,7 +700,7 @@ static bool lineart_line_match(LineartRenderTriangle *rt, LineartRenderLine *rl, /* Does near-plane cut on 1 triangle only. When cutting with far-plane, the camera vectors gets * reversed by the caller so don't need to implement one in a different direction. */ static void lineart_triangle_cull_single(LineartRenderBuffer *rb, - LineartRenderTriangle *rt, + LineartTriangle *rt, int in0, int in1, int in2, @@ -716,9 +712,9 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb, int *r_v_count, int *r_l_count, int *r_t_count, - LineartRenderElementLinkNode *veln, - LineartRenderElementLinkNode *leln, - LineartRenderElementLinkNode *teln) + LineartElementLinkNode *veln, + LineartElementLinkNode *leln, + LineartElementLinkNode *teln) { double vv1[3], vv2[3], dot1, dot2; double a; @@ -728,9 +724,9 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb, int l_obi, r_obi; char new_flag = 0; - LineartRenderLine *new_rl, *rl, *old_rl; - LineartRenderLineSegment *rls; - LineartRenderTriangleAdjacent *rta; + LineartLine *new_rl, *rl, *old_rl; + LineartLineSegment *rls; + LineartTriangleAdjacent *rta; if (rt->flags & (LRT_CULL_USED | LRT_CULL_GENERATED | LRT_CULL_DISCARD)) { return; @@ -740,13 +736,12 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb, * lineart_geometry_object_load() for details. */ rta = (void *)rt->intersecting_verts; - LineartRenderVert *rv = &((LineartRenderVert *)veln->pointer)[v_count]; - LineartRenderTriangle *rt1 = (void *)(((unsigned char *)teln->pointer) + - rb->triangle_size * t_count); - LineartRenderTriangle *rt2 = (void *)(((unsigned char *)teln->pointer) + - rb->triangle_size * (t_count + 1)); + LineartVert *rv = &((LineartVert *)veln->pointer)[v_count]; + LineartTriangle *rt1 = (void *)(((unsigned char *)teln->pointer) + rb->triangle_size * t_count); + LineartTriangle *rt2 = (void *)(((unsigned char *)teln->pointer) + + rb->triangle_size * (t_count + 1)); - new_rl = &((LineartRenderLine *)leln->pointer)[l_count]; + new_rl = &((LineartLine *)leln->pointer)[l_count]; /* Init rl to the last rl entry. */ rl = new_rl; @@ -754,11 +749,11 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb, l_count++; \ l_obi = rl->l_obindex; \ r_obi = rl->r_obindex; \ - new_rl = &((LineartRenderLine *)leln->pointer)[l_count]; \ + new_rl = &((LineartLine *)leln->pointer)[l_count]; \ rl = new_rl; \ rl->l_obindex = l_obi; \ rl->r_obindex = r_obi; \ - rls = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderLineSegment)); \ + rls = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineSegment)); \ BLI_addtail(&rl->segments, rls); #define SELECT_RL(rl_num, llink, rlink, newrt) \ @@ -1160,8 +1155,8 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb, */ static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far) { - LineartRenderTriangle *rt; - LineartRenderElementLinkNode *veln, *teln, *leln; + LineartTriangle *rt; + LineartElementLinkNode *veln, *teln, *leln; double(*vp)[4] = rb->view_projection; int i; int v_count = 0, t_count = 0, l_count = 0; @@ -1249,7 +1244,7 @@ static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far) } /* Then go through all the other triangles. */ - LISTBASE_FOREACH (LineartRenderElementLinkNode *, reln, &rb->triangle_buffer_pointers) { + LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->triangle_buffer_pointers) { if (reln->flags & LRT_ELEMENT_IS_ADDITIONAL) { continue; } @@ -1293,28 +1288,28 @@ static void lineart_main_free_adjacent_data(LineartRenderBuffer *rb) while ((ld = BLI_pophead(&rb->triangle_adjacent_pointers)) != NULL) { MEM_freeN(ld->data); } - LISTBASE_FOREACH (LineartRenderElementLinkNode *, reln, &rb->triangle_buffer_pointers) { - LineartRenderTriangle *rt = reln->pointer; + LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->triangle_buffer_pointers) { + LineartTriangle *rt = reln->pointer; int i; for (i = 0; i < reln->element_count; i++) { /* See definition of rt->intersecting_verts and the usage in * lineart_geometry_object_load() for detailes. */ rt->intersecting_verts = NULL; - rt = (LineartRenderTriangle *)(((unsigned char *)rt) + rb->triangle_size); + rt = (LineartTriangle *)(((unsigned char *)rt) + rb->triangle_size); } } } static void lineart_main_perspective_division(LineartRenderBuffer *rb) { - LineartRenderVert *rv; + LineartVert *rv; int i; if (!rb->cam_is_persp) { return; } - LISTBASE_FOREACH (LineartRenderElementLinkNode *, reln, &rb->vertex_buffer_pointers) { + LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->vertex_buffer_pointers) { rv = reln->pointer; for (i = 0; i < reln->element_count; i++) { /* Do not divide Z, we use Z to back transform cut points in later chaining process. */ @@ -1333,30 +1328,30 @@ static void lineart_main_perspective_division(LineartRenderBuffer *rb) /* Transform a single vert to it's viewing position. */ static void lineart_vert_transform( - BMVert *v, int index, LineartRenderVert *RvBuf, double (*mv_mat)[4], double (*mvp_mat)[4]) + BMVert *v, int index, LineartVert *RvBuf, double (*mv_mat)[4], double (*mvp_mat)[4]) { double co[4]; - LineartRenderVert *rv = &RvBuf[index]; + LineartVert *rv = &RvBuf[index]; copy_v3db_v3fl(co, v->co); mul_v3_m4v3_db(rv->gloc, mv_mat, co); mul_v4_m4v3_db(rv->fbcoord, mvp_mat, co); } -/* Because we have a variable size for LineartRenderTriangle, we need an access helper. See - * LineartRenderTriangleThread for more info. */ -static LineartRenderTriangle *lineart_triangle_from_index(LineartRenderBuffer *rb, - LineartRenderTriangle *rt_array, - int index) +/* Because we have a variable size for LineartTriangle, we need an access helper. See + * LineartTriangleThread for more info. */ +static LineartTriangle *lineart_triangle_from_index(LineartRenderBuffer *rb, + LineartTriangle *rt_array, + int index) { char *b = (char *)rt_array; b += (index * rb->triangle_size); - return (LineartRenderTriangle *)b; + return (LineartTriangle *)b; } static char lineart_identify_feature_line(LineartRenderBuffer *rb, BMEdge *e, - LineartRenderTriangle *rt_array, - LineartRenderVert *rv_array, + LineartTriangle *rt_array, + LineartVert *rv_array, float crease_threshold, bool no_crease, bool count_freestyle, @@ -1372,8 +1367,8 @@ static char lineart_identify_feature_line(LineartRenderBuffer *rb, return LRT_EDGE_FLAG_CONTOUR; } - LineartRenderTriangle *rt1, *rt2; - LineartRenderVert *l; + LineartTriangle *rt1, *rt2; + LineartVert *l; /* The mesh should already be triangulated now, so we can assume each face is a triangle. */ rt1 = lineart_triangle_from_index(rb, rt_array, BM_elem_index_get(ll->f)); @@ -1418,7 +1413,7 @@ static char lineart_identify_feature_line(LineartRenderBuffer *rb, return 0; } -static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartRenderLine *rl) +static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartLine *rl) { switch (rl->flags) { case LRT_EDGE_FLAG_CONTOUR: @@ -1439,9 +1434,9 @@ static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartRenderLine } } -static void lineart_triangle_adjacent_assign(LineartRenderTriangle *rt, - LineartRenderTriangleAdjacent *rta, - LineartRenderLine *rl) +static void lineart_triangle_adjacent_assign(LineartTriangle *rt, + LineartTriangleAdjacent *rta, + LineartLine *rl) { if (lineart_line_match(rt, rl, 0, 1)) { rta->rl[0] = rl; @@ -1467,15 +1462,15 @@ static void lineart_geometry_object_load(Depsgraph *dg, BMFace *f; BMEdge *e; BMLoop *loop; - LineartRenderLine *rl; - LineartRenderTriangle *rt; - LineartRenderTriangleAdjacent *orta; + LineartLine *rl; + LineartTriangle *rt; + LineartTriangleAdjacent *orta; double new_mvp[4][4], new_mv[4][4], normal[4][4]; float imat[4][4]; - LineartRenderElementLinkNode *reln; - LineartRenderVert *orv; - LineartRenderLine *orl; - LineartRenderTriangle *ort; + LineartElementLinkNode *reln; + LineartVert *orv; + LineartLine *orl; + LineartTriangle *ort; Object *orig_ob; int CanFindFreestyle = 0; int i, global_i = (*global_vindex); @@ -1568,15 +1563,13 @@ static void lineart_geometry_object_load(Depsgraph *dg, /* Only allocate memory for verts and tris as we don't know how many lines we will generate * yet. */ - orv = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderVert) * bm->totvert); + orv = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartVert) * bm->totvert); ort = lineart_mem_aquire(&rb->render_data_pool, bm->totface * rb->triangle_size); orig_ob = ob->id.orig_id ? (Object *)ob->id.orig_id : ob; - reln = lineart_list_append_pointer_pool_sized(&rb->vertex_buffer_pointers, - &rb->render_data_pool, - orv, - sizeof(LineartRenderElementLinkNode)); + reln = lineart_list_append_pointer_pool_sized( + &rb->vertex_buffer_pointers, &rb->render_data_pool, orv, sizeof(LineartElementLinkNode)); reln->element_count = bm->totvert; reln->object_ref = orig_ob; @@ -1593,17 +1586,14 @@ static void lineart_geometry_object_load(Depsgraph *dg, reln->flags |= LRT_ELEMENT_BORDER_ONLY; } - reln = lineart_list_append_pointer_pool_sized(&rb->triangle_buffer_pointers, - &rb->render_data_pool, - ort, - sizeof(LineartRenderElementLinkNode)); + reln = lineart_list_append_pointer_pool_sized( + &rb->triangle_buffer_pointers, &rb->render_data_pool, ort, sizeof(LineartElementLinkNode)); reln->element_count = bm->totface; reln->object_ref = orig_ob; reln->flags |= (usage == OBJECT_LRT_NO_INTERSECTION ? LRT_ELEMENT_NO_INTERSECTION : 0); /* Note this memory is not from pool, will be deleted after culling. */ - orta = MEM_callocN(sizeof(LineartRenderTriangleAdjacent) * bm->totface, - "LineartRenderTriangleAdjacent"); + orta = MEM_callocN(sizeof(LineartTriangleAdjacent) * bm->totface, "LineartTriangleAdjacent"); /* Link is minimal so we use pool anyway. */ lineart_list_append_pointer_pool(&rb->triangle_adjacent_pointers, &rb->render_data_pool, orta); @@ -1650,7 +1640,7 @@ static void lineart_geometry_object_load(Depsgraph *dg, /* Re-use this field to refer to adjacent info, will be cleared after culling stage. */ rt->intersecting_verts = (void *)&orta[i]; - rt = (LineartRenderTriangle *)(((unsigned char *)rt) + rb->triangle_size); + rt = (LineartTriangle *)(((unsigned char *)rt) + rb->triangle_size); } /* Use BM_ELEM_TAG in f->head.hflag to store needed faces in the first iteration. */ @@ -1672,11 +1662,9 @@ static void lineart_geometry_object_load(Depsgraph *dg, e->head.hflag = eflag; } - orl = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderLine) * allocate_rl); - reln = lineart_list_append_pointer_pool_sized(&rb->line_buffer_pointers, - &rb->render_data_pool, - orl, - sizeof(LineartRenderElementLinkNode)); + orl = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLine) * allocate_rl); + reln = lineart_list_append_pointer_pool_sized( + &rb->line_buffer_pointers, &rb->render_data_pool, orl, sizeof(LineartElementLinkNode)); reln->element_count = allocate_rl; reln->object_ref = orig_ob; @@ -1706,8 +1694,8 @@ static void lineart_geometry_object_load(Depsgraph *dg, rl->flags = e->head.hflag; rl->object_ref = orig_ob; - LineartRenderLineSegment *rls = lineart_mem_aquire(&rb->render_data_pool, - sizeof(LineartRenderLineSegment)); + LineartLineSegment *rls = lineart_mem_aquire(&rb->render_data_pool, + sizeof(LineartLineSegment)); BLI_addtail(&rl->segments, rls); if (usage == OBJECT_LRT_INHERENT || usage == OBJECT_LRT_INCLUDE || usage == OBJECT_LRT_NO_INTERSECTION) { @@ -1826,10 +1814,10 @@ static void lineart_main_load_geometries( /* Returns the two other verts of the triangle given a vertex. Returns false if the given vertex * doesn't belong to this triangle. */ -static bool lineart_triangle_get_other_verts(const LineartRenderTriangle *rt, - const LineartRenderVert *rv, - LineartRenderVert **l, - LineartRenderVert **r) +static bool lineart_triangle_get_other_verts(const LineartTriangle *rt, + const LineartVert *rv, + LineartVert **l, + LineartVert **r) { if (rt->v[0] == rv) { *l = rt->v[1]; @@ -1849,8 +1837,8 @@ static bool lineart_triangle_get_other_verts(const LineartRenderTriangle *rt, return false; } -static bool lineart_edge_from_triangle(const LineartRenderTriangle *rt, - const LineartRenderLine *rl, +static bool lineart_edge_from_triangle(const LineartTriangle *rt, + const LineartLine *rl, bool allow_overlapping_edges) { /* Normally we just determine from the pointer address. */ @@ -1911,8 +1899,8 @@ static bool lineart_edge_from_triangle(const LineartRenderTriangle *rt, * in ratio from rl->l to rl->r. The line is later cut with these two values. */ static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl), - const LineartRenderTriangle *rt, - const LineartRenderLine *rl, + const LineartTriangle *rt, + const LineartLine *rl, const double *override_camera_loc, const bool override_cam_is_persp, const bool allow_overlapping_edges, @@ -2140,8 +2128,7 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl), /* At this stage of the computation we don't have triangle adjacent info anymore, so we can only * compare the global vert index. */ -static bool lineart_triangle_share_edge(const LineartRenderTriangle *l, - const LineartRenderTriangle *r) +static bool lineart_triangle_share_edge(const LineartTriangle *l, const LineartTriangle *r) { if (l->v[0]->index == r->v[0]->index) { if (l->v[1]->index == r->v[1]->index || l->v[1]->index == r->v[2]->index || @@ -2184,8 +2171,8 @@ static bool lineart_triangle_share_edge(const LineartRenderTriangle *l, return false; } -static LineartRenderVert *lineart_triangle_share_point(const LineartRenderTriangle *l, - const LineartRenderTriangle *r) +static LineartVert *lineart_triangle_share_point(const LineartTriangle *l, + const LineartTriangle *r) { if (l->v[0] == r->v[0]) { return r->v[0]; @@ -2218,45 +2205,43 @@ static LineartRenderVert *lineart_triangle_share_point(const LineartRenderTriang } /* To save time and prevent overlapping lines when computing intersection lines. */ -static bool lineart_vert_already_intersected_2v(LineartRenderVertIntersection *rv, - LineartRenderVertIntersection *v1, - LineartRenderVertIntersection *v2) +static bool lineart_vert_already_intersected_2v(LineartVertIntersection *rv, + LineartVertIntersection *v1, + LineartVertIntersection *v2) { return ((rv->isec1 == v1->base.index && rv->isec2 == v2->base.index) || (rv->isec2 == v2->base.index && rv->isec1 == v1->base.index)); } -static void lineart_vert_set_intersection_2v(LineartRenderVert *rv, - LineartRenderVert *v1, - LineartRenderVert *v2) +static void lineart_vert_set_intersection_2v(LineartVert *rv, LineartVert *v1, LineartVert *v2) { - LineartRenderVertIntersection *irv = (LineartRenderVertIntersection *)rv; + LineartVertIntersection *irv = (LineartVertIntersection *)rv; irv->isec1 = v1->index; irv->isec2 = v2->index; } /* This tests a triangle against a virtual line represented by v1---v2. The vertices returned after * repeated calls to this function is then used to create a triangle/triangle intersection line. */ -static LineartRenderVert *lineart_triangle_2v_intersection_test(LineartRenderBuffer *rb, - LineartRenderVert *v1, - LineartRenderVert *v2, - LineartRenderTriangle *rt, - LineartRenderTriangle *testing, - LineartRenderVert *last) +static LineartVert *lineart_triangle_2v_intersection_test(LineartRenderBuffer *rb, + LineartVert *v1, + LineartVert *v2, + LineartTriangle *rt, + LineartTriangle *testing, + LineartVert *last) { double Lv[3]; double Rv[3]; double dot_l, dot_r; - LineartRenderVert *result; + LineartVert *result; double gloc[3]; - LineartRenderVert *l = v1, *r = v2; + LineartVert *l = v1, *r = v2; for (LinkNode *ln = (void *)testing->intersecting_verts; ln; ln = ln->next) { - LineartRenderVertIntersection *rv = ln->link; + LineartVertIntersection *rv = ln->link; if (rv->intersecting_with == rt && lineart_vert_already_intersected_2v( - rv, (LineartRenderVertIntersection *)l, (LineartRenderVertIntersection *)r)) { - return (LineartRenderVert *)rv; + rv, (LineartVertIntersection *)l, (LineartVertIntersection *)r)) { + return (LineartVert *)rv; } } @@ -2287,9 +2272,9 @@ static LineartRenderVert *lineart_triangle_2v_intersection_test(LineartRenderBuf return NULL; } - /* This is an intersection vert, the size is bigger than LineartRenderVert, + /* This is an intersection vert, the size is bigger than LineartVert, * allocated separately. */ - result = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderVertIntersection)); + result = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartVertIntersection)); /* Indicate the data structure difference. */ result->flag = LRT_VERT_HAS_INTERSECTION_DATA; @@ -2302,37 +2287,36 @@ static LineartRenderVert *lineart_triangle_2v_intersection_test(LineartRenderBuf } /* Test if two triangles intersect. Generates one intersection line if the check succeeds */ -static LineartRenderLine *lineart_triangle_intersect(LineartRenderBuffer *rb, - LineartRenderTriangle *rt, - LineartRenderTriangle *testing) -{ - LineartRenderVert *l = 0, *r = 0; - LineartRenderVert **next = &l; - LineartRenderLine *result; - LineartRenderVert *E0T = 0; - LineartRenderVert *E1T = 0; - LineartRenderVert *E2T = 0; - LineartRenderVert *TE0 = 0; - LineartRenderVert *TE1 = 0; - LineartRenderVert *TE2 = 0; - LineartRenderVert *sv1, *sv2; +static LineartLine *lineart_triangle_intersect(LineartRenderBuffer *rb, + LineartTriangle *rt, + LineartTriangle *testing) +{ + LineartVert *l = 0, *r = 0; + LineartVert **next = &l; + LineartLine *result; + LineartVert *E0T = 0; + LineartVert *E1T = 0; + LineartVert *E2T = 0; + LineartVert *TE0 = 0; + LineartVert *TE1 = 0; + LineartVert *TE2 = 0; + LineartVert *sv1, *sv2; double cl[3]; double ZMin, ZMax; ZMax = rb->far_clip; ZMin = rb->near_clip; copy_v3_v3_db(cl, rb->camera_pos); - LineartRenderVert *share = lineart_triangle_share_point(testing, rt); + LineartVert *share = lineart_triangle_share_point(testing, rt); if (share) { /* If triangles have sharing points like (abc) and (acd), then we only need to detect bc * against acd or cd against abc.*/ - LineartRenderVert *new_share; + LineartVert *new_share; lineart_triangle_get_other_verts(rt, share, &sv1, &sv2); - l = new_share = lineart_mem_aquire(&rb->render_data_pool, - (sizeof(LineartRenderVertIntersection))); + l = new_share = lineart_mem_aquire(&rb->render_data_pool, (sizeof(LineartVertIntersection))); new_share->flag = LRT_VERT_HAS_INTERSECTION_DATA; @@ -2428,17 +2412,16 @@ static LineartRenderLine *lineart_triangle_intersect(LineartRenderBuffer *rb, l->fbcoord[2] = ZMin * ZMax / (ZMax - fabs(l->fbcoord[2]) * (ZMax - ZMin)); r->fbcoord[2] = ZMin * ZMax / (ZMax - fabs(r->fbcoord[2]) * (ZMax - ZMin)); - ((LineartRenderVertIntersection *)l)->intersecting_with = rt; - ((LineartRenderVertIntersection *)r)->intersecting_with = testing; + ((LineartVertIntersection *)l)->intersecting_with = rt; + ((LineartVertIntersection *)r)->intersecting_with = testing; - result = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartRenderLine)); + result = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLine)); result->l = l; result->r = r; result->tl = rt; result->tr = testing; - LineartRenderLineSegment *rls = lineart_mem_aquire(&rb->render_data_pool, - sizeof(LineartRenderLineSegment)); + LineartLineSegment *rls = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineSegment)); BLI_addtail(&result->segments, rls); /* Don't need to OR flags right now, just a type mark. */ result->flags = LRT_EDGE_FLAG_INTERSECTION; @@ -2459,13 +2442,13 @@ static LineartRenderLine *lineart_triangle_intersect(LineartRenderBuffer *rb, } static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb, - LineartRenderTriangle *rt, + LineartTriangle *rt, LineartBoundingArea *ba) { /* Testing_triangle->testing[0] is used to store pairing triangle reference. - * See definition of LineartRenderTriangleThread for more info. */ - LineartRenderTriangle *testing_triangle; - LineartRenderTriangleThread *rtt; + * See definition of LineartTriangleThread for more info. */ + LineartTriangle *testing_triangle; + LineartTriangleThread *rtt; LinkData *lip, *next_lip; double *G0 = rt->v[0]->gloc, *G1 = rt->v[1]->gloc, *G2 = rt->v[2]->gloc; @@ -2483,9 +2466,9 @@ static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb, for (lip = ba->linked_triangles.first; lip; lip = next_lip) { next_lip = lip->next; testing_triangle = lip->data; - rtt = (LineartRenderTriangleThread *)testing_triangle; + rtt = (LineartTriangleThread *)testing_triangle; - if (testing_triangle == rt || rtt->testing[0] == (LineartRenderLine *)rt || + if (testing_triangle == rt || rtt->testing[0] == (LineartLine *)rt || (testing_triangle->flags & LRT_TRIANGLE_NO_INTERSECTION) || ((testing_triangle->flags & LRT_TRIANGLE_INTERSECTION_ONLY) && (rt->flags & LRT_TRIANGLE_INTERSECTION_ONLY)) || @@ -2493,7 +2476,7 @@ static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb, continue; } - rtt->testing[0] = (LineartRenderLine *)rt; + rtt->testing[0] = (LineartLine *)rt; double *RG0 = testing_triangle->v[0]->gloc, *RG1 = testing_triangle->v[1]->gloc, *RG2 = testing_triangle->v[2]->gloc; @@ -2646,7 +2629,7 @@ static int lineart_triangle_size_get(const Scene *scene, LineartRenderBuffer *rb if (rb->thread_count == 0) { rb->thread_count = BKE_render_num_threads(&scene->r); } - return sizeof(LineartRenderTriangle) + (sizeof(LineartRenderLine *) * (rb->thread_count)); + return sizeof(LineartTriangle) + (sizeof(LineartLine *) * (rb->thread_count)); } static void lineart_main_bounding_area_make_initial(LineartRenderBuffer *rb) @@ -2862,8 +2845,8 @@ static void lineart_bounding_area_split(LineartRenderBuffer *rb, { LineartBoundingArea *ba = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartBoundingArea) * 4); - LineartRenderTriangle *rt; - LineartRenderLine *rl; + LineartTriangle *rt; + LineartLine *rl; ba[0].l = root->cx; ba[0].r = root->r; @@ -2969,7 +2952,7 @@ static bool lineart_bounding_area_line_intersect(LineartRenderBuffer *UNUSED(fb) } static bool lineart_bounding_area_triangle_intersect(LineartRenderBuffer *fb, - LineartRenderTriangle *rt, + LineartTriangle *rt, LineartBoundingArea *ba) { double p1[2], p2[2], p3[2], p4[2]; @@ -3006,7 +2989,7 @@ static bool lineart_bounding_area_triangle_intersect(LineartRenderBuffer *fb, * 2) Test triangles with existing(added previously) triangles for intersection lines. */ static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb, LineartBoundingArea *root_ba, - LineartRenderTriangle *rt, + LineartTriangle *rt, double *LRUB, int recursive, int recursive_level, @@ -3061,7 +3044,7 @@ static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb, static void lineart_bounding_area_link_line(LineartRenderBuffer *rb, LineartBoundingArea *root_ba, - LineartRenderLine *rl) + LineartLine *rl) { if (root_ba->child == NULL) { lineart_list_append_pointer_pool(&root_ba->linked_lines, &rb->render_data_pool, rl); @@ -3105,7 +3088,7 @@ static void lineart_main_link_lines(LineartRenderBuffer *rb) } static bool lineart_get_triangle_bounding_areas(LineartRenderBuffer *rb, - LineartRenderTriangle *rt, + LineartTriangle *rt, int *rowbegin, int *rowend, int *colbegin, @@ -3149,7 +3132,7 @@ static bool lineart_get_triangle_bounding_areas(LineartRenderBuffer *rb, } static bool lineart_get_line_bounding_areas(LineartRenderBuffer *rb, - LineartRenderLine *rl, + LineartLine *rl, int *rowbegin, int *rowend, int *colbegin, @@ -3283,12 +3266,12 @@ LineartBoundingArea *MOD_lineart_get_bounding_area(LineartRenderBuffer *rb, doub /* Sequentially add triangles into render buffer. This also does intersection along the way. */ static void lineart_main_add_triangles(LineartRenderBuffer *rb) { - LineartRenderTriangle *rt; + LineartTriangle *rt; int i, lim; int x1, x2, y1, y2; int r, co; - LISTBASE_FOREACH (LineartRenderElementLinkNode *, reln, &rb->triangle_buffer_pointers) { + LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->triangle_buffer_pointers) { rt = reln->pointer; lim = reln->element_count; for (i = 0; i < lim; i++) { @@ -3317,7 +3300,7 @@ static void lineart_main_add_triangles(LineartRenderBuffer *rb) /* This function gets the tile for the point rl->l, and later use lineart_bounding_area_next() to * get next along the way. */ static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer *rb, - LineartRenderLine *rl) + LineartLine *rl) { double data[2] = {rl->l->fbcoord[0], rl->l->fbcoord[1]}; double LU[2] = {-1, 1}, RU[2] = {1, 1}, LB[2] = {-1, -1}, RB[2] = {1, -1}; @@ -3351,7 +3334,7 @@ static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer /* This march along one render line in image space and * get the next bounding area the line is crossing. */ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this, - LineartRenderLine *rl, + LineartLine *rl, double x, double y, double k, @@ -3583,7 +3566,7 @@ int MOD_lineart_compute_feature_lines(Depsgraph *depsgraph, LineartGpencilModifi rb = lineart_create_render_buffer(scene, lmd); /* Triangle thread testing data size varies depending on the thread count. - * See definition of LineartRenderTriangleThread for details. */ + * See definition of LineartTriangleThread for details. */ rb->triangle_size = lineart_triangle_size_get(scene, rb); /* This is used to limit calculation to a certain level to save time, lines who have higher @@ -3746,7 +3729,7 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb, bool match_output = modifier_flags & LRT_GPENCIL_MATCH_OUTPUT_VGROUP; bool preserve_weight = modifier_flags & LRT_GPENCIL_SOFT_SELECTION; - LISTBASE_FOREACH (LineartRenderLineChain *, rlc, &rb->chains) { + LISTBASE_FOREACH (LineartLineChain *, rlc, &rb->chains) { if (rlc->picked) { continue; @@ -3788,7 +3771,7 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb, float *stroke_data = MEM_callocN(sizeof(float) * count * GP_PRIM_DATABUF_SIZE, "line art add stroke"); - LISTBASE_FOREACH (LineartRenderLineChainItem *, rlci, &rlc->chain) { + LISTBASE_FOREACH (LineartLineChainItem *, rlci, &rlc->chain) { stroke_data[array_idx] = rlci->gpos[0]; stroke_data[array_idx + 1] = rlci->gpos[1]; stroke_data[array_idx + 2] = rlci->gpos[2]; @@ -3821,7 +3804,7 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb, } } int sindex = 0, vindex; - LISTBASE_FOREACH (LineartRenderLineChainItem *, rlci, &rlc->chain) { + LISTBASE_FOREACH (LineartLineChainItem *, rlci, &rlc->chain) { vindex = rlci->index; if (vindex >= me->totvert) { break; diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h b/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h index 99cfa06b2fe..34f6e62546d 100644 --- a/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h +++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h @@ -35,7 +35,7 @@ struct LineartStaticMemPool; struct LineartStaticMemPoolNode; -struct LineartRenderLine; +struct LineartLine; struct LineartRenderBuffer; void *lineart_list_append_pointer_pool(ListBase *h, struct LineartStaticMemPool *smp, void *data); @@ -58,7 +58,7 @@ void *lineart_mem_aquire(struct LineartStaticMemPool *smp, size_t size); void *lineart_mem_aquire_thread(struct LineartStaticMemPool *smp, size_t size); void lineart_mem_destroy(struct LineartStaticMemPool *smp); -void lineart_prepend_line_direct(struct LineartRenderLine **first, void *node); +void lineart_prepend_line_direct(struct LineartLine **first, void *node); void lineart_prepend_pool(LinkNode **first, struct LineartStaticMemPool *smp, void *link); void lineart_matrix_ortho_44d(double (*mProjection)[4], @@ -76,7 +76,7 @@ int lineart_count_intersection_segment_count(struct LineartRenderBuffer *rb); void lineart_count_and_print_render_buffer_memory(struct LineartRenderBuffer *rb); #define LRT_ITER_ALL_LINES_BEGIN \ - LineartRenderLine *rl, *next_rl, **current_list; \ + LineartLine *rl, *next_rl, **current_list; \ rl = rb->contours; \ for (current_list = &rb->contours; rl; rl = next_rl) { \ next_rl = rl->next; diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c index 0d145042e08..8e8c39391c3 100644 --- a/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c +++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c @@ -130,9 +130,9 @@ void lineart_mem_destroy(LineartStaticMemPool *smp) } } -void lineart_prepend_line_direct(LineartRenderLine **first, void *node) +void lineart_prepend_line_direct(LineartLine **first, void *node) { - LineartRenderLine *ln = (LineartRenderLine *)node; + LineartLine *ln = (LineartLine *)node; ln->next = (*first); (*first) = ln; } @@ -213,16 +213,16 @@ void lineart_count_and_print_render_buffer_memory(LineartRenderBuffer *rb) sum_this = 0; count_this = 0; - LISTBASE_FOREACH (LineartRenderElementLinkNode *, reln, &rb->line_buffer_pointers) { + LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->line_buffer_pointers) { count_this++; - sum_this += reln->element_count * sizeof(LineartRenderLine); + sum_this += reln->element_count * sizeof(LineartLine); } printf(" allocated %lu edge blocks, total %lu Bytes.\n", count_this, sum_this); total += sum_this; sum_this = 0; count_this = 0; - LISTBASE_FOREACH (LineartRenderElementLinkNode *, reln, &rb->triangle_buffer_pointers) { + LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->triangle_buffer_pointers) { count_this++; sum_this += reln->element_count * rb->triangle_size; } |