blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 758 Projects 19 Wiki Activity

LineArt: General code cleanups. 

- Use uintxx_t for all 8/16/64 bit integer types.
- Removed prepend_edge_direct thingy which is no longer needed in current edge iterator model.
- Minor code path adjustments like only copies view vector when necessary etc.
- Correctly handle ies==NULL in edge cutting function.
- White spaces and comments etc.

Reviewed By: Sebastian Parborg (zeddb)

Differential Revision: https://developer.blender.org/D15181
This commit is contained in:
YimingWu 2022-06-13 21:08:36 +08:00
parent 10850f0db9
commit 85fde25178
7 changed files with 82 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
source/blender/gpencil_modifiers/intern/MOD_gpencillineart.c
View File

@ -352,7 +352,7 @@ static void edge_types_panel_draw(const bContext *UNUSED(C), Panel *panel)
uiLayout *sub = uiLayoutRowWithHeading(col, false, IFACE_("Crease"));
uiItemR(sub, ptr, "use_crease", 0, "", ICON_NONE);
uiLayout *entry = uiLayoutRow(sub, false);
uiLayoutSetEnabled(entry, RNA_boolean_get(ptr, "use_crease") || is_first);
uiLayoutSetActive(entry, RNA_boolean_get(ptr, "use_crease") || is_first);
if (use_cache && !is_first) {
uiItemL(entry, IFACE_("Angle Cached"), ICON_INFO);
}
@ -524,6 +524,7 @@ static void intersection_panel_draw(const bContext *UNUSED(C), Panel *panel)
uiItemR(layout, ptr, "use_intersection_match", 0, IFACE_("Exact Match"), ICON_NONE);
}
static void face_mark_panel_draw_header(const bContext *UNUSED(C), Panel *panel)
{
uiLayout *layout = panel->layout;

61
source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
View File

@ -36,10 +36,10 @@ typedef struct LineartTriangle {
/* first culled in line list to use adjacent triangle info, then go through triangle list. */
double gn[3];
unsigned char material_mask_bits;
unsigned char intersection_mask;
unsigned char mat_occlusion;
unsigned char flags; /* #eLineartTriangleFlags */
uint8_t material_mask_bits;
uint8_t intersection_mask;
uint8_t mat_occlusion;
uint8_t flags; /* #eLineartTriangleFlags */
/**
* Only use single link list, because we don't need to go back in order.
@ -84,10 +84,10 @@ typedef struct LineartEdgeSegment {
/** at==0: left at==1: right (this is in 2D projected space) */
double at;
/** Occlusion level after "at" point */
unsigned char occlusion;
uint8_t occlusion;
/* Used to filter line art occlusion edges */
unsigned char material_mask_bits;
uint8_t material_mask_bits;
} LineartEdgeSegment;
typedef struct LineartVert {
@ -119,17 +119,14 @@ typedef enum eLineArtVertFlags {
} eLineArtVertFlags;
typedef struct LineartEdge {
/** We only need link node kind of list here. */
struct LineartEdge *next;
struct LineartVert *v1, *v2;
struct LineartTriangle *t1, *t2;
ListBase segments;
char min_occ;
int8_t min_occ;
/** Also for line type determination on chaining. */
uint16_t flags;
unsigned char intersection_mask;
uint8_t intersection_mask;
/**
* Still need this entry because culled lines will not add to object
@ -149,15 +146,15 @@ typedef struct LineartEdgeChain {
float length;
/** Used when re-connecting and grease-pencil stroke generation. */
char picked;
char level;
int8_t picked;
int8_t level;
/** Chain now only contains one type of segments */
int type;
/** Will only connect chains that has the same loop id. */
int loop_id;
unsigned char material_mask_bits;
unsigned char intersection_mask;
uint8_t material_mask_bits;
uint8_t intersection_mask;
struct Object *object_ref;
} LineartEdgeChain;
@ -170,9 +167,9 @@ typedef struct LineartEdgeChainItem {
float gpos[3];
float normal[3];
uint16_t line_type;
char occlusion;
unsigned char material_mask_bits;
unsigned char intersection_mask;
int8_t occlusion;
uint8_t material_mask_bits;
uint8_t intersection_mask;
size_t index;
} LineartEdgeChainItem;
@ -180,17 +177,17 @@ typedef struct LineartChainRegisterEntry {
struct LineartChainRegisterEntry *next, *prev;
LineartEdgeChain *ec;
LineartEdgeChainItem *eci;
char picked;
int8_t picked;
/* left/right mark.
* Because we revert list in chaining so we need the flag. */
char is_left;
int8_t is_left;
} LineartChainRegisterEntry;
typedef struct LineartAdjacentEdge {
unsigned int v1;
unsigned int v2;
unsigned int e;
uint32_t v1;
uint32_t v2;
uint32_t e;
} LineartAdjacentEdge;
enum eLineArtTileRecursiveLimit {
@ -233,7 +230,7 @@ typedef struct LineartData {
struct LineartBoundingArea *initials;
unsigned int tile_count;
uint32_t tile_count;
} qtree;
@ -333,7 +330,7 @@ typedef struct LineartCache {
ListBase chains;
/** Cache only contains edge types specified in this variable. */
char rb_edge_types;
int8_t rb_edge_types;
} LineartCache;
#define DBL_TRIANGLE_LIM 1e-8
@ -396,7 +393,7 @@ typedef struct LineartObjectLoadTaskInfo {
/* LinkNode styled list */
LineartObjectInfo *pending;
/* Used to spread the load across several threads. This can not overflow. */
long unsigned int total_faces;
uint64_t total_faces;
} LineartObjectLoadTaskInfo;
/**
@ -689,16 +686,16 @@ void MOD_lineart_gpencil_generate(LineartCache *cache,
struct Object *ob,
struct bGPDlayer *gpl,
struct bGPDframe *gpf,
char source_type,
int8_t source_type,
void *source_reference,
int level_start,
int level_end,
int mat_nr,
short edge_types,
unsigned char mask_switches,
unsigned char material_mask_bits,
unsigned char intersection_mask,
short thickness,
int16_t edge_types,
uint8_t mask_switches,
uint8_t material_mask_bits,
uint8_t intersection_mask,
int16_t thickness,
float opacity,
const char *source_vgname,
const char *vgname,

25
source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
View File

@ -23,7 +23,7 @@ static LineartEdge *lineart_line_get_connected(LineartBoundingArea *ba,
LineartVert *vt,
LineartVert **new_vt,
int match_flag,
unsigned char match_isec_mask)
uint8_t match_isec_mask)
{
for (int i = 0; i < ba->line_count; i++) {
LineartEdge *n_e = ba->linked_lines[i];
@ -90,9 +90,9 @@ static LineartEdgeChainItem *lineart_chain_append_point(LineartData *ld,
float *fbcoord,
float *gpos,
float *normal,
char type,
uint8_t type,
int level,
unsigned char material_mask_bits,
uint8_t material_mask_bits,
size_t index)
{
LineartEdgeChainItem *eci;
@ -127,9 +127,9 @@ static LineartEdgeChainItem *lineart_chain_prepend_point(LineartData *ld,
float *fbcoord,
float *gpos,
float *normal,
char type,
uint8_t type,
int level,
unsigned char material_mask_bits,
uint8_t material_mask_bits,
size_t index)
{
LineartEdgeChainItem *eci;
@ -159,7 +159,7 @@ void MOD_lineart_chain_feature_lines(LineartData *ld)
LineartBoundingArea *ba;
LineartEdgeSegment *es;
int last_occlusion;
unsigned char last_transparency;
uint8_t last_transparency;
/* Used when converting from double. */
float use_fbcoord[4];
float use_gpos[3];
@ -564,7 +564,7 @@ static bool lineart_chain_fix_ambiguous_segments(LineartEdgeChain *ec,
float dist_accum = 0;
int fixed_occ = last_matching_eci->occlusion;
unsigned char fixed_mask = last_matching_eci->material_mask_bits;
uint8_t fixed_mask = last_matching_eci->material_mask_bits;
LineartEdgeChainItem *can_skip_to = NULL;
LineartEdgeChainItem *last_eci = last_matching_eci;
@ -627,7 +627,7 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartData *ld)
LineartEdgeChainItem *first_eci = (LineartEdgeChainItem *)ec->chain.first;
int fixed_occ = first_eci->occlusion;
unsigned char fixed_mask = first_eci->material_mask_bits;
uint8_t fixed_mask = first_eci->material_mask_bits;
ec->level = fixed_occ;
ec->material_mask_bits = fixed_mask;
for (eci = first_eci->next; eci; eci = next_eci) {
@ -747,8 +747,8 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartData *ld,
LineartEdgeChain *ec,
LineartEdgeChainItem *eci,
int occlusion,
unsigned char material_mask_bits,
unsigned char isec_mask,
uint8_t material_mask_bits,
uint8_t isec_mask,
int loop_id,
float dist,
float *result_new_len,
@ -857,7 +857,7 @@ void MOD_lineart_chain_connect(LineartData *ld)
float dist = ld->conf.chaining_image_threshold;
float dist_l, dist_r;
int occlusion, reverse_main, loop_id;
unsigned char material_mask_bits, isec_mask;
uint8_t material_mask_bits, isec_mask;
ListBase swap = {0};
if (ld->conf.chaining_image_threshold < 0.0001) {
@ -1238,8 +1238,6 @@ void MOD_lineart_chain_offset_towards_camera(LineartData *ld, float dist, bool u
float cam[3];
float view[3];
float view_clamp[3];
copy_v3fl_v3db(cam, ld->conf.camera_pos);
copy_v3fl_v3db(view, ld->conf.view_vector);
if (use_custom_camera) {
copy_v3fl_v3db(cam, ld->conf.camera_pos);
@ -1260,6 +1258,7 @@ void MOD_lineart_chain_offset_towards_camera(LineartData *ld, float dist, bool u
}
}
else {
copy_v3fl_v3db(view, ld->conf.view_vector);
LISTBASE_FOREACH (LineartEdgeChain *, ec, &ld->chains) {
LISTBASE_FOREACH (LineartEdgeChainItem *, eci, &ec->chain) {
sub_v3_v3v3(dir, cam, eci->gpos);

65
source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
View File

@ -46,10 +46,6 @@
#include "DNA_scene_types.h"
#include "MEM_guardedalloc.h"
#include "bmesh.h"
#include "bmesh_class.h"
#include "bmesh_tools.h"
#include "lineart_intern.h"
typedef struct LineartIsecSingle {
@ -262,8 +258,10 @@ static void lineart_edge_cut(LineartData *ld,
if (cut_start_before != ns) {
/* Insert cutting points for when a new cut is needed. */
ies = cut_start_before->prev ? cut_start_before->prev : NULL;
ns->occlusion = ies ? ies->occlusion : 0;
ns->material_mask_bits = ies->material_mask_bits;
if (ies) {
ns->occlusion = ies->occlusion;
ns->material_mask_bits = ies->material_mask_bits;
}
BLI_insertlinkbefore(&e->segments, cut_start_before, ns);
}
/* Otherwise we already found a existing cutting point, no need to insert a new one. */
@ -280,8 +278,10 @@ static void lineart_edge_cut(LineartData *ld,
/* The same manipulation as on "cut_start_before". */
if (cut_end_before != ns2) {
ies = cut_end_before->prev ? cut_end_before->prev : NULL;
ns2->occlusion = ies ? ies->occlusion : 0;
ns2->material_mask_bits = ies ? ies->material_mask_bits : 0;
if (ies) {
ns2->occlusion = ies->occlusion;
ns2->material_mask_bits = ies->material_mask_bits;
}
BLI_insertlinkbefore(&e->segments, cut_end_before, ns2);
}
}
@ -310,7 +310,7 @@ static void lineart_edge_cut(LineartData *ld,
}
/* Reduce adjacent cutting points of the same level, which saves memory. */
char min_occ = 127;
int8_t min_occ = 127;
prev_es = NULL;
for (es = e->segments.first; es; es = next_es) {
next_es = es->next;
@ -1432,14 +1432,22 @@ static void lineart_mvert_transform_task(void *__restrict userdata,
v->index = i;
}
#define LRT_EDGE_FLAG_TYPE_MAX_BITS 6
static const int LRT_MESH_EDGE_TYPES[] = {
LRT_EDGE_FLAG_EDGE_MARK,
LRT_EDGE_FLAG_CONTOUR,
LRT_EDGE_FLAG_CREASE,
LRT_EDGE_FLAG_MATERIAL,
LRT_EDGE_FLAG_LOOSE,
};
static int lineart_edge_type_duplication_count(char eflag)
#define LRT_MESH_EDGE_TYPES_COUNT 5
static int lineart_edge_type_duplication_count(int eflag)
{
int count = 0;
/* See eLineartEdgeFlag for details. */
for (int i = 0; i < LRT_EDGE_FLAG_TYPE_MAX_BITS; i++) {
if (eflag & (1 << i)) {
for (int i = 0; i < LRT_MESH_EDGE_TYPES_COUNT; i++) {
if (eflag & LRT_MESH_EDGE_TYPES[i]) {
count++;
}
}
@ -1454,7 +1462,7 @@ static LineartTriangle *lineart_triangle_from_index(LineartData *ld,
LineartTriangle *rt_array,
int index)
{
char *b = (char *)rt_array;
int8_t *b = (int8_t *)rt_array;
b += (index * ld->sizeof_triangle);
return (LineartTriangle *)b;
}
@ -1883,7 +1891,7 @@ static void lineart_edge_neighbor_init_task(void *__restrict userdata,
adj_e->v1 = mloop[looptri->tri[i % 3]].v;
adj_e->v2 = mloop[looptri->tri[(i + 1) % 3]].v;
if (adj_e->v1 > adj_e->v2) {
SWAP(unsigned int, adj_e->v1, adj_e->v2);
SWAP(uint32_t, adj_e->v1, adj_e->v2);
}
edge_nabr->e = -1;
@ -2054,7 +2062,7 @@ static void lineart_geometry_object_load(LineartObjectInfo *ob_info, LineartData
tri_data.lineart_triangle_size = la_data->sizeof_triangle;
tri_data.tri_adj = tri_adj;
unsigned int total_edges = tot_tri * 3;
uint32_t total_edges = tot_tri * 3;
BLI_task_parallel_range(0, tot_tri, &tri_data, lineart_load_tri_task, &tri_settings);
@ -2149,8 +2157,8 @@ static void lineart_geometry_object_load(LineartObjectInfo *ob_info, LineartData
LineartEdge *edge_added = NULL;
/* See eLineartEdgeFlag for details. */
for (int flag_bit = 0; flag_bit < LRT_EDGE_FLAG_TYPE_MAX_BITS; flag_bit++) {
char use_type = 1 << flag_bit;
for (int flag_bit = 0; flag_bit < LRT_MESH_EDGE_TYPES_COUNT; flag_bit++) {
int use_type = LRT_MESH_EDGE_TYPES[flag_bit];
if (!(use_type & edge_nabr->flags)) {
continue;
}
@ -2221,9 +2229,6 @@ static void lineart_object_load_worker(TaskPool *__restrict UNUSED(pool),
{
for (LineartObjectInfo *obi = olti->pending; obi; obi = obi->next) {
lineart_geometry_object_load(obi, olti->ld);
if (G.debug_value == 4000) {
printf("thread id: %d processed: %d\n", olti->thread_id, obi->original_me->totpoly);
}
}
}
@ -2301,7 +2306,7 @@ static void lineart_geometry_load_assign_thread(LineartObjectLoadTaskInfo *olti_
int this_face_count)
{
LineartObjectLoadTaskInfo *use_olti = olti_list;
long unsigned int min_face = use_olti->total_faces;
uint64_t min_face = use_olti->total_faces;
for (int i = 0; i < thread_count; i++) {
if (olti_list[i].total_faces < min_face) {
min_face = olti_list[i].total_faces;
@ -3397,6 +3402,7 @@ static LineartData *lineart_create_render_buffer(Scene *scene,
copy_v3db_v3fl(ld->conf.active_camera_pos, active_camera->obmat[3]);
}
copy_m4_m4(ld->conf.cam_obmat, camera->obmat);
ld->conf.cam_is_persp = (c->type == CAM_PERSP);
ld->conf.near_clip = c->clip_start + clipping_offset;
ld->conf.far_clip = c->clip_end - clipping_offset;
@ -4630,8 +4636,6 @@ bool MOD_lineart_compute_feature_lines(Depsgraph *depsgraph,
t_start = PIL_check_seconds_timer();
}
BKE_scene_camera_switch_update(scene);
if (lmd->calculation_flags & LRT_USE_CUSTOM_CAMERA) {
if (!lmd->source_camera ||
(use_camera = DEG_get_evaluated_object(depsgraph, lmd->source_camera))->type !=
@ -4640,6 +4644,9 @@ bool MOD_lineart_compute_feature_lines(Depsgraph *depsgraph,
}
}
else {
BKE_scene_camera_switch_update(scene);
if (!scene->camera) {
return false;
}
@ -4787,7 +4794,7 @@ static void lineart_gpencil_generate(LineartCache *cache,
uchar mask_switches,
uchar material_mask_bits,
uchar intersection_mask,
short thickness,
int16_t thickness,
float opacity,
const char *source_vgname,
const char *vgname,
@ -4946,16 +4953,16 @@ void MOD_lineart_gpencil_generate(LineartCache *cache,
Object *ob,
bGPDlayer *gpl,
bGPDframe *gpf,
char source_type,
int8_t source_type,
void *source_reference,
int level_start,
int level_end,
int mat_nr,
short edge_types,
int16_t edge_types,
uchar mask_switches,
uchar material_mask_bits,
uchar intersection_mask,
short thickness,
int16_t thickness,
float opacity,
const char *source_vgname,
const char *vgname,
@ -4968,7 +4975,7 @@ void MOD_lineart_gpencil_generate(LineartCache *cache,
Object *source_object = NULL;
Collection *source_collection = NULL;
short use_types = 0;
int16_t use_types = 0;
if (source_type == LRT_SOURCE_OBJECT) {
if (!source_reference) {
return;

1
source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h
View File

@ -49,7 +49,6 @@ void *lineart_mem_acquire(struct LineartStaticMemPool *smp, size_t size);
void *lineart_mem_acquire_thread(struct LineartStaticMemPool *smp, size_t size);
void lineart_mem_destroy(struct LineartStaticMemPool *smp);
void lineart_prepend_edge_direct(void **list_head, void *node);
void lineart_prepend_pool(LinkNode **first, struct LineartStaticMemPool *smp, void *link);
void lineart_matrix_ortho_44d(double (*mProjection)[4],

7
source/blender/gpencil_modifiers/intern/lineart/lineart_util.c
View File

@ -144,13 +144,6 @@ void lineart_mem_destroy(LineartStaticMemPool *smp)
}
}
void lineart_prepend_edge_direct(void **list_head, void *node)
{
LineartEdge *e_n = (LineartEdge *)node;
e_n->next = (*list_head);
(*list_head) = e_n;
}
void lineart_prepend_pool(LinkNode **first, LineartStaticMemPool *smp, void *link)
{
LinkNode *ln = lineart_mem_acquire_thread(smp, sizeof(LinkNode));

6
source/blender/makesdna/DNA_lineart_types.h
View File

@ -48,9 +48,9 @@ typedef enum eLineartEdgeFlag {
LRT_EDGE_FLAG_INTERSECTION = (1 << 4),
LRT_EDGE_FLAG_LOOSE = (1 << 5),
/* LRT_EDGE_FLAG_FOR_FUTURE = (1 << 7), */
/* Limited to 8 bits for edge type flag, don't add anymore because `BMEdge->head.eflag` only has
* 8 bits. So unless we changed this into a non-single-bit flag thing, we keep it this way. */
/** Also used as discarded line mark. */
/* It's a legacy limit of 8 bits for feature lines that come from original mesh edges. It should
not be needed in current object loading scheme, but might still be relevant if we are to
impelment EditMesh loading, so don't exceed 8 bits just yet. */
LRT_EDGE_FLAG_CHAIN_PICKED = (1 << 8),
LRT_EDGE_FLAG_CLIPPED = (1 << 9),
/** Limited to 16 bits for the entire thing. */