Cleanup: use "num" as a suffix in: source/blender/blenlib
Also replace "num" with: - "number" when it's not used to denote the number of items. - "digits" when digits in a string are being manipulated.
This commit is contained in:
parent
af3aaf8034
commit
a8ec7845e0
|
|
@ -25,33 +25,33 @@ typedef unsigned int BLI_bitmap;
|
|||
#define _BITMAP_MASK 31
|
||||
|
||||
/**
|
||||
* Number of blocks needed to hold '_tot' bits.
|
||||
* Number of blocks needed to hold '_num' bits.
|
||||
*/
|
||||
#define _BITMAP_NUM_BLOCKS(_tot) (((_tot) >> _BITMAP_POWER) + 1)
|
||||
#define _BITMAP_NUM_BLOCKS(_num) (((_num) >> _BITMAP_POWER) + 1)
|
||||
|
||||
/**
|
||||
* Size (in bytes) used to hold '_tot' bits.
|
||||
* Size (in bytes) used to hold '_num' bits.
|
||||
*/
|
||||
#define BLI_BITMAP_SIZE(_tot) ((size_t)(_BITMAP_NUM_BLOCKS(_tot)) * sizeof(BLI_bitmap))
|
||||
#define BLI_BITMAP_SIZE(_num) ((size_t)(_BITMAP_NUM_BLOCKS(_num)) * sizeof(BLI_bitmap))
|
||||
|
||||
/**
|
||||
* Allocate memory for a bitmap with '_tot' bits; free with MEM_freeN().
|
||||
* Allocate memory for a bitmap with '_num' bits; free with MEM_freeN().
|
||||
*/
|
||||
#define BLI_BITMAP_NEW(_tot, _alloc_string) \
|
||||
((BLI_bitmap *)MEM_callocN(BLI_BITMAP_SIZE(_tot), _alloc_string))
|
||||
#define BLI_BITMAP_NEW(_num, _alloc_string) \
|
||||
((BLI_bitmap *)MEM_callocN(BLI_BITMAP_SIZE(_num), _alloc_string))
|
||||
|
||||
/**
|
||||
* Allocate a bitmap on the stack.
|
||||
*/
|
||||
#define BLI_BITMAP_NEW_ALLOCA(_tot) \
|
||||
((BLI_bitmap *)memset(alloca(BLI_BITMAP_SIZE(_tot)), 0, BLI_BITMAP_SIZE(_tot)))
|
||||
#define BLI_BITMAP_NEW_ALLOCA(_num) \
|
||||
((BLI_bitmap *)memset(alloca(BLI_BITMAP_SIZE(_num)), 0, BLI_BITMAP_SIZE(_num)))
|
||||
|
||||
/**
|
||||
* Allocate using given MemArena.
|
||||
*/
|
||||
#define BLI_BITMAP_NEW_MEMARENA(_mem, _tot) \
|
||||
#define BLI_BITMAP_NEW_MEMARENA(_mem, _num) \
|
||||
(CHECK_TYPE_INLINE(_mem, MemArena *), \
|
||||
((BLI_bitmap *)BLI_memarena_calloc(_mem, BLI_BITMAP_SIZE(_tot))))
|
||||
((BLI_bitmap *)BLI_memarena_calloc(_mem, BLI_BITMAP_SIZE(_num))))
|
||||
|
||||
/**
|
||||
* Get the value of a single bit at '_index'.
|
||||
|
|
@ -107,12 +107,12 @@ typedef unsigned int BLI_bitmap;
|
|||
(void)0
|
||||
|
||||
/**
|
||||
* Resize bitmap to have space for '_tot' bits.
|
||||
* Resize bitmap to have space for '_num' bits.
|
||||
*/
|
||||
#define BLI_BITMAP_RESIZE(_bitmap, _tot) \
|
||||
#define BLI_BITMAP_RESIZE(_bitmap, _num) \
|
||||
{ \
|
||||
CHECK_TYPE(_bitmap, BLI_bitmap *); \
|
||||
(_bitmap) = MEM_recallocN(_bitmap, BLI_BITMAP_SIZE(_tot)); \
|
||||
(_bitmap) = MEM_recallocN(_bitmap, BLI_BITMAP_SIZE(_num)); \
|
||||
} \
|
||||
(void)0
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ typedef void (*HeapFreeFP)(void *ptr);
|
|||
*
|
||||
* \note Use when the size of the heap is known in advance.
|
||||
*/
|
||||
Heap *BLI_heap_new_ex(unsigned int tot_reserve) ATTR_WARN_UNUSED_RESULT;
|
||||
Heap *BLI_heap_new_ex(unsigned int reserve_num) ATTR_WARN_UNUSED_RESULT;
|
||||
Heap *BLI_heap_new(void) ATTR_WARN_UNUSED_RESULT;
|
||||
void BLI_heap_clear(Heap *heap, HeapFreeFP ptrfreefp) ATTR_NONNULL(1);
|
||||
void BLI_heap_free(Heap *heap, HeapFreeFP ptrfreefp) ATTR_NONNULL(1);
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ typedef void (*HeapSimpleFreeFP)(void *ptr);
|
|||
*
|
||||
* \note Use when the size of the heap is known in advance.
|
||||
*/
|
||||
HeapSimple *BLI_heapsimple_new_ex(unsigned int tot_reserve) ATTR_WARN_UNUSED_RESULT;
|
||||
HeapSimple *BLI_heapsimple_new_ex(unsigned int reserve_num) ATTR_WARN_UNUSED_RESULT;
|
||||
HeapSimple *BLI_heapsimple_new(void) ATTR_WARN_UNUSED_RESULT;
|
||||
void BLI_heapsimple_clear(HeapSimple *heap, HeapSimpleFreeFP ptrfreefp) ATTR_NONNULL(1);
|
||||
void BLI_heapsimple_free(HeapSimple *heap, HeapSimpleFreeFP ptrfreefp) ATTR_NONNULL(1);
|
||||
|
|
|
|||
|
|
@ -181,18 +181,18 @@ int BLI_bvhtree_overlap_thread_num(const BVHTree *tree);
|
|||
*/
|
||||
BVHTreeOverlap *BLI_bvhtree_overlap_ex(const BVHTree *tree1,
|
||||
const BVHTree *tree2,
|
||||
uint *r_overlap_tot,
|
||||
uint *r_overlap_num,
|
||||
BVHTree_OverlapCallback callback,
|
||||
void *userdata,
|
||||
uint max_interactions,
|
||||
int flag);
|
||||
BVHTreeOverlap *BLI_bvhtree_overlap(const BVHTree *tree1,
|
||||
const BVHTree *tree2,
|
||||
unsigned int *r_overlap_tot,
|
||||
unsigned int *r_overlap_num,
|
||||
BVHTree_OverlapCallback callback,
|
||||
void *userdata);
|
||||
|
||||
int *BLI_bvhtree_intersect_plane(BVHTree *tree, float plane[4], uint *r_intersect_tot);
|
||||
int *BLI_bvhtree_intersect_plane(BVHTree *tree, float plane[4], uint *r_intersect_num);
|
||||
|
||||
/**
|
||||
* Number of times #BLI_bvhtree_insert has been called.
|
||||
|
|
|
|||
|
|
@ -890,7 +890,7 @@ bool clip_segment_v3_plane(
|
|||
bool clip_segment_v3_plane_n(const float p1[3],
|
||||
const float p2[3],
|
||||
const float plane_array[][4],
|
||||
int plane_tot,
|
||||
int plane_num,
|
||||
float r_p1[3],
|
||||
float r_p2[3]);
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ struct BLI_mempool_chunk;
|
|||
typedef struct BLI_mempool BLI_mempool;
|
||||
|
||||
BLI_mempool *BLI_mempool_create(unsigned int esize,
|
||||
unsigned int totelem,
|
||||
unsigned int elem_num,
|
||||
unsigned int pchunk,
|
||||
unsigned int flag)
|
||||
ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL;
|
||||
|
|
|
|||
|
|
@ -204,12 +204,12 @@ bool BLI_path_filename_ensure(char *filepath, size_t maxlen, const char *filenam
|
|||
* or before dot if no digits.
|
||||
* \param tail: Optional area to return copy of part of string following digits,
|
||||
* or from dot if no digits.
|
||||
* \param r_num_len: Optional to return number of digits found.
|
||||
* \param r_digits_len: Optional to return number of digits found.
|
||||
*/
|
||||
int BLI_path_sequence_decode(const char *string,
|
||||
char *head,
|
||||
char *tail,
|
||||
unsigned short *r_num_len);
|
||||
unsigned short *r_digits_len);
|
||||
/**
|
||||
* Returns in area pointed to by string a string of the form `<head><pic><tail>`,
|
||||
* where pic is formatted as `numlen` digits with leading zeroes.
|
||||
|
|
@ -310,7 +310,7 @@ bool BLI_path_frame_range(char *path, int sta, int end, int digits) ATTR_NONNULL
|
|||
/**
|
||||
* Get the frame from a filename formatted by blender's frame scheme
|
||||
*/
|
||||
bool BLI_path_frame_get(char *path, int *r_frame, int *numdigits) ATTR_NONNULL();
|
||||
bool BLI_path_frame_get(char *path, int *r_frame, int *r_digits_len) ATTR_NONNULL();
|
||||
/**
|
||||
* Given a `path` with digits representing frame numbers, replace the digits with the '#'
|
||||
* character and extract the extension.
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ struct MemArena;
|
|||
* A version of #BLI_polyfill_calc that uses a memory arena to avoid re-allocations.
|
||||
*/
|
||||
void BLI_polyfill_calc_arena(const float (*coords)[2],
|
||||
unsigned int coords_tot,
|
||||
unsigned int coords_num,
|
||||
int coords_sign,
|
||||
unsigned int (*r_tris)[3],
|
||||
|
||||
|
|
@ -27,16 +27,16 @@ void BLI_polyfill_calc_arena(const float (*coords)[2],
|
|||
*
|
||||
* \param coords: 2D coordinates describing vertices of the polygon,
|
||||
* in either clockwise or counterclockwise order.
|
||||
* \param coords_tot: Total points in the array.
|
||||
* \param coords_num: Total points in the array.
|
||||
* \param coords_sign: Pass this when we know the sign in advance to avoid extra calculations.
|
||||
*
|
||||
* \param r_tris: This array is filled in with triangle indices in clockwise order.
|
||||
* The length of the array must be `coords_tot - 2`.
|
||||
* The length of the array must be `coords_num - 2`.
|
||||
* Indices are guaranteed to be assigned to unique triangles, with valid indices,
|
||||
* even in the case of degenerate input (self intersecting polygons, zero area ears... etc).
|
||||
*/
|
||||
void BLI_polyfill_calc(const float (*coords)[2],
|
||||
unsigned int coords_tot,
|
||||
unsigned int coords_num,
|
||||
int coords_sign,
|
||||
unsigned int (*r_tris)[3]);
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ struct MemArena;
|
|||
* are ignored since the edges won't share 2 faces.
|
||||
*/
|
||||
void BLI_polyfill_beautify(const float (*coords)[2],
|
||||
unsigned int coords_tot,
|
||||
unsigned int coords_num,
|
||||
unsigned int (*tris)[3],
|
||||
|
||||
/* structs for reuse */
|
||||
|
|
|
|||
|
|
@ -69,9 +69,9 @@ void BLI_rng_get_tri_sample_float_v3(RNG *rng,
|
|||
void BLI_rng_shuffle_array(struct RNG *rng,
|
||||
void *data,
|
||||
unsigned int elem_size_i,
|
||||
unsigned int elem_tot) ATTR_NONNULL(1, 2);
|
||||
unsigned int elem_num) ATTR_NONNULL(1, 2);
|
||||
|
||||
void BLI_rng_shuffle_bitmap(struct RNG *rng, unsigned int *bitmap, unsigned int bits_tot)
|
||||
void BLI_rng_shuffle_bitmap(struct RNG *rng, unsigned int *bitmap, unsigned int bits_num)
|
||||
ATTR_NONNULL(1, 2);
|
||||
|
||||
/** Note that skipping is as slow as generating n numbers! */
|
||||
|
|
@ -96,10 +96,10 @@ float BLI_hash_frand(unsigned int seed) ATTR_WARN_UNUSED_RESULT;
|
|||
*/
|
||||
void BLI_array_randomize(void *data,
|
||||
unsigned int elem_size,
|
||||
unsigned int elem_tot,
|
||||
unsigned int elem_num,
|
||||
unsigned int seed);
|
||||
|
||||
void BLI_bitmap_randomize(unsigned int *bitmap, unsigned int bits_tot, unsigned int seed)
|
||||
void BLI_bitmap_randomize(unsigned int *bitmap, unsigned int bits_num, unsigned int seed)
|
||||
ATTR_NONNULL(1);
|
||||
|
||||
/** Better seed for the random number generator, using noise.c hash[] */
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ typedef struct ScanFillVert {
|
|||
unsigned int keyindex;
|
||||
unsigned short poly_nr;
|
||||
/** number of edges using this vertex */
|
||||
unsigned char edge_tot;
|
||||
unsigned char edge_count;
|
||||
/** vert status */
|
||||
unsigned int f : 4;
|
||||
/** flag callers can use as they like */
|
||||
|
|
|
|||
|
|
@ -238,18 +238,18 @@ typedef void (*TaskParallelIteratorFunc)(void *__restrict userdata,
|
|||
* \param iter_func: Callback function used to generate chunks of items.
|
||||
* \param init_item: The initial item, if necessary (may be NULL if unused).
|
||||
* \param init_index: The initial index.
|
||||
* \param tot_items: The total amount of items to iterate over
|
||||
* \param items_num: The total amount of items to iterate over
|
||||
* (if unknown, set it to a negative number).
|
||||
* \param func: Callback function.
|
||||
* \param settings: See public API doc of TaskParallelSettings for description of all settings.
|
||||
*
|
||||
* \note Static scheduling is only available when \a tot_items is >= 0.
|
||||
* \note Static scheduling is only available when \a items_num is >= 0.
|
||||
*/
|
||||
void BLI_task_parallel_iterator(void *userdata,
|
||||
TaskParallelIteratorIterFunc iter_func,
|
||||
void *init_item,
|
||||
int init_index,
|
||||
int tot_items,
|
||||
int items_num,
|
||||
TaskParallelIteratorFunc func,
|
||||
const TaskParallelSettings *settings);
|
||||
|
||||
|
|
|
|||
|
|
@ -11,17 +11,17 @@
|
|||
|
||||
/* only validate array-bounds in debug mode */
|
||||
#ifdef DEBUG
|
||||
# define STACK_DECLARE(stack) unsigned int _##stack##_index, _##stack##_totalloc
|
||||
# define STACK_INIT(stack, tot) \
|
||||
((void)stack, (void)((_##stack##_index) = 0), (void)((_##stack##_totalloc) = (tot)))
|
||||
# define STACK_DECLARE(stack) unsigned int _##stack##_index, _##stack##_num_alloc
|
||||
# define STACK_INIT(stack, stack_num) \
|
||||
((void)stack, (void)((_##stack##_index) = 0), (void)((_##stack##_num_alloc) = (stack_num)))
|
||||
# define _STACK_SIZETEST(stack, off) \
|
||||
(BLI_assert((_##stack##_index) + (off) <= _##stack##_totalloc))
|
||||
(BLI_assert((_##stack##_index) + (off) <= _##stack##_num_alloc))
|
||||
# define _STACK_SWAP_TOTALLOC(stack_a, stack_b) \
|
||||
SWAP(unsigned int, _##stack_a##_totalloc, _##stack_b##_totalloc)
|
||||
SWAP(unsigned int, _##stack_a##_num_alloc, _##stack_b##_num_alloc)
|
||||
#else
|
||||
# define STACK_DECLARE(stack) unsigned int _##stack##_index
|
||||
# define STACK_INIT(stack, tot) \
|
||||
((void)stack, (void)((_##stack##_index) = 0), (void)(0 ? (tot) : 0))
|
||||
# define STACK_INIT(stack, stack_num) \
|
||||
((void)stack, (void)((_##stack##_index) = 0), (void)(0 ? (stack_num) : 0))
|
||||
# define _STACK_SIZETEST(stack, off) (void)(stack), (void)(off)
|
||||
# define _STACK_SWAP_TOTALLOC(stack_a, stack_b) (void)(stack_a), (void)(stack_b)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ struct HeapNode_Chunk {
|
|||
* or we allocate past the reserved number.
|
||||
*
|
||||
* \note Optimize number for 64kb allocs.
|
||||
* \note keep type in sync with tot_nodes in heap_node_alloc_chunk.
|
||||
* \note keep type in sync with nodes_num in heap_node_alloc_chunk.
|
||||
*/
|
||||
#define HEAP_CHUNK_DEFAULT_NUM \
|
||||
((uint)((MEM_SIZE_OPTIMAL((1 << 16) - sizeof(struct HeapNode_Chunk))) / sizeof(HeapNode)))
|
||||
|
|
@ -137,13 +137,13 @@ static void heap_up(Heap *heap, uint i)
|
|||
/** \name Internal Memory Management
|
||||
* \{ */
|
||||
|
||||
static struct HeapNode_Chunk *heap_node_alloc_chunk(uint tot_nodes,
|
||||
static struct HeapNode_Chunk *heap_node_alloc_chunk(uint nodes_num,
|
||||
struct HeapNode_Chunk *chunk_prev)
|
||||
{
|
||||
struct HeapNode_Chunk *chunk = MEM_mallocN(
|
||||
sizeof(struct HeapNode_Chunk) + (sizeof(HeapNode) * tot_nodes), __func__);
|
||||
sizeof(struct HeapNode_Chunk) + (sizeof(HeapNode) * nodes_num), __func__);
|
||||
chunk->prev = chunk_prev;
|
||||
chunk->bufsize = tot_nodes;
|
||||
chunk->bufsize = nodes_num;
|
||||
chunk->size = 0;
|
||||
return chunk;
|
||||
}
|
||||
|
|
@ -179,16 +179,16 @@ static void heap_node_free(Heap *heap, HeapNode *node)
|
|||
/** \name Public Heap API
|
||||
* \{ */
|
||||
|
||||
Heap *BLI_heap_new_ex(uint tot_reserve)
|
||||
Heap *BLI_heap_new_ex(uint reserve_num)
|
||||
{
|
||||
Heap *heap = MEM_mallocN(sizeof(Heap), __func__);
|
||||
/* ensure we have at least one so we can keep doubling it */
|
||||
heap->size = 0;
|
||||
heap->bufsize = MAX2(1u, tot_reserve);
|
||||
heap->bufsize = MAX2(1u, reserve_num);
|
||||
heap->tree = MEM_mallocN(heap->bufsize * sizeof(HeapNode *), "BLIHeapTree");
|
||||
|
||||
heap->nodes.chunk = heap_node_alloc_chunk(
|
||||
(tot_reserve > 1) ? tot_reserve : HEAP_CHUNK_DEFAULT_NUM, NULL);
|
||||
(reserve_num > 1) ? reserve_num : HEAP_CHUNK_DEFAULT_NUM, NULL);
|
||||
heap->nodes.free = NULL;
|
||||
|
||||
return heap;
|
||||
|
|
|
|||
|
|
@ -133,12 +133,12 @@ static void heapsimple_up(HeapSimple *heap, uint i, float active_val, void *acti
|
|||
/** \name Public HeapSimple API
|
||||
* \{ */
|
||||
|
||||
HeapSimple *BLI_heapsimple_new_ex(uint tot_reserve)
|
||||
HeapSimple *BLI_heapsimple_new_ex(uint reserve_num)
|
||||
{
|
||||
HeapSimple *heap = MEM_mallocN(sizeof(HeapSimple), __func__);
|
||||
/* ensure we have at least one so we can keep doubling it */
|
||||
heap->size = 0;
|
||||
heap->bufsize = MAX2(1u, tot_reserve);
|
||||
heap->bufsize = MAX2(1u, reserve_num);
|
||||
heap->tree = MEM_mallocN(heap->bufsize * sizeof(HeapSimpleNode), "BLIHeapSimpleTree");
|
||||
return heap;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ typedef struct BVHNode {
|
|||
#endif
|
||||
float *bv; /* Bounding volume of all nodes, max 13 axis */
|
||||
int index; /* face, edge, vertex index */
|
||||
char totnode; /* how many nodes are used, used for speedup */
|
||||
char node_num; /* how many nodes are used, used for speedup */
|
||||
char main_axis; /* Axis used to split this node */
|
||||
} BVHNode;
|
||||
|
||||
|
|
@ -79,8 +79,8 @@ struct BVHTree {
|
|||
BVHNode **nodechild; /* pre-alloc children for nodes */
|
||||
float *nodebv; /* pre-alloc bounding-volumes for nodes */
|
||||
float epsilon; /* Epsilon is used for inflation of the K-DOP. */
|
||||
int totleaf; /* leafs */
|
||||
int totbranch;
|
||||
int leaf_num; /* leafs */
|
||||
int branch_num;
|
||||
axis_t start_axis, stop_axis; /* bvhtree_kdop_axes array indices according to axis */
|
||||
axis_t axis; /* KDOP type (6 => OBB, 7 => AABB, ...) */
|
||||
char tree_type; /* type of tree (4 => quad-tree). */
|
||||
|
|
@ -325,8 +325,8 @@ static void build_skip_links(BVHTree *tree, BVHNode *node, BVHNode *left, BVHNod
|
|||
node->skip[0] = left;
|
||||
node->skip[1] = right;
|
||||
|
||||
for (i = 0; i < node->totnode; i++) {
|
||||
if (i + 1 < node->totnode) {
|
||||
for (i = 0; i < node->node_num; i++) {
|
||||
if (i + 1 < node->node_num) {
|
||||
build_skip_links(tree, node->children[i], left, node->children[i + 1]);
|
||||
}
|
||||
else {
|
||||
|
|
@ -485,9 +485,9 @@ static void bvhtree_info(BVHTree *tree)
|
|||
tree->axis,
|
||||
tree->epsilon);
|
||||
printf("nodes = %d, branches = %d, leafs = %d\n",
|
||||
tree->totbranch + tree->totleaf,
|
||||
tree->totbranch,
|
||||
tree->totleaf);
|
||||
tree->branch_num + tree->leaf_num,
|
||||
tree->branch_num,
|
||||
tree->leaf_num);
|
||||
printf(
|
||||
"Memory per node = %ubytes\n",
|
||||
(uint)(sizeof(BVHNode) + sizeof(BVHNode *) * tree->tree_type + sizeof(float) * tree->axis));
|
||||
|
|
@ -497,7 +497,7 @@ static void bvhtree_info(BVHTree *tree)
|
|||
(uint)(sizeof(BVHTree) + MEM_allocN_len(tree->nodes) + MEM_allocN_len(tree->nodearray) +
|
||||
MEM_allocN_len(tree->nodechild) + MEM_allocN_len(tree->nodebv)));
|
||||
|
||||
bvhtree_print_tree(tree, tree->nodes[tree->totleaf], 0);
|
||||
bvhtree_print_tree(tree, tree->nodes[tree->leaf_num], 0);
|
||||
}
|
||||
#endif /* USE_PRINT_TREE */
|
||||
|
||||
|
|
@ -508,7 +508,7 @@ static void bvhtree_verify(BVHTree *tree)
|
|||
int i, j, check = 0;
|
||||
|
||||
/* check the pointer list */
|
||||
for (i = 0; i < tree->totleaf; i++) {
|
||||
for (i = 0; i < tree->leaf_num; i++) {
|
||||
if (tree->nodes[i]->parent == NULL) {
|
||||
printf("Leaf has no parent: %d\n", i);
|
||||
}
|
||||
|
|
@ -526,7 +526,7 @@ static void bvhtree_verify(BVHTree *tree)
|
|||
}
|
||||
|
||||
/* check the leaf list */
|
||||
for (i = 0; i < tree->totleaf; i++) {
|
||||
for (i = 0; i < tree->leaf_num; i++) {
|
||||
if (tree->nodearray[i].parent == NULL) {
|
||||
printf("Leaf has no parent: %d\n", i);
|
||||
}
|
||||
|
|
@ -544,9 +544,9 @@ static void bvhtree_verify(BVHTree *tree)
|
|||
}
|
||||
|
||||
printf("branches: %d, leafs: %d, total: %d\n",
|
||||
tree->totbranch,
|
||||
tree->totleaf,
|
||||
tree->totbranch + tree->totleaf);
|
||||
tree->branch_num,
|
||||
tree->leaf_num,
|
||||
tree->branch_num + tree->leaf_num);
|
||||
}
|
||||
#endif /* USE_VERIFY_TREE */
|
||||
|
||||
|
|
@ -555,7 +555,7 @@ static void bvhtree_verify(BVHTree *tree)
|
|||
* (basically this is only method to calculate pow(k, n) in O(1).. and stuff like that) */
|
||||
typedef struct BVHBuildHelper {
|
||||
int tree_type;
|
||||
int totleafs;
|
||||
int leafs_num;
|
||||
|
||||
/** Min number of leafs that are achievable from a node at depth `N`. */
|
||||
int leafs_per_child[32];
|
||||
|
|
@ -573,11 +573,11 @@ static void build_implicit_tree_helper(const BVHTree *tree, BVHBuildHelper *data
|
|||
int remain;
|
||||
int nnodes;
|
||||
|
||||
data->totleafs = tree->totleaf;
|
||||
data->leafs_num = tree->leaf_num;
|
||||
data->tree_type = tree->tree_type;
|
||||
|
||||
/* Calculate the smallest tree_type^n such that tree_type^n >= num_leafs */
|
||||
for (data->leafs_per_child[0] = 1; data->leafs_per_child[0] < data->totleafs;
|
||||
/* Calculate the smallest tree_type^n such that tree_type^n >= leafs_num */
|
||||
for (data->leafs_per_child[0] = 1; data->leafs_per_child[0] < data->leafs_num;
|
||||
data->leafs_per_child[0] *= data->tree_type) {
|
||||
/* pass */
|
||||
}
|
||||
|
|
@ -589,7 +589,7 @@ static void build_implicit_tree_helper(const BVHTree *tree, BVHBuildHelper *data
|
|||
data->leafs_per_child[depth] = data->leafs_per_child[depth - 1] / data->tree_type;
|
||||
}
|
||||
|
||||
remain = data->totleafs - data->leafs_per_child[1];
|
||||
remain = data->leafs_num - data->leafs_per_child[1];
|
||||
nnodes = (remain + data->tree_type - 2) / (data->tree_type - 1);
|
||||
data->remain_leafs = remain + nnodes;
|
||||
}
|
||||
|
|
@ -604,7 +604,7 @@ static int implicit_leafs_index(const BVHBuildHelper *data, const int depth, con
|
|||
return min_leaf_index;
|
||||
}
|
||||
if (data->leafs_per_child[depth]) {
|
||||
return data->totleafs -
|
||||
return data->leafs_num -
|
||||
(data->branches_on_level[depth - 1] - child_index) * data->leafs_per_child[depth];
|
||||
}
|
||||
return data->remain_leafs;
|
||||
|
|
@ -725,7 +725,7 @@ static void non_recursive_bvh_div_nodes_task_cb(void *__restrict userdata,
|
|||
|
||||
split_leafs(data->leafs_array, nth_positions, data->tree_type, split_axis);
|
||||
|
||||
/* Setup children and totnode counters
|
||||
/* Setup `children` and `node_num` counters
|
||||
* Not really needed but currently most of BVH code
|
||||
* relies on having an explicit children structure */
|
||||
for (k = 0; k < data->tree_type; k++) {
|
||||
|
|
@ -750,7 +750,7 @@ static void non_recursive_bvh_div_nodes_task_cb(void *__restrict userdata,
|
|||
break;
|
||||
}
|
||||
}
|
||||
parent->totnode = (char)k;
|
||||
parent->node_num = (char)k;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -774,7 +774,7 @@ static void non_recursive_bvh_div_nodes_task_cb(void *__restrict userdata,
|
|||
static void non_recursive_bvh_div_nodes(const BVHTree *tree,
|
||||
BVHNode *branches_array,
|
||||
BVHNode **leafs_array,
|
||||
int num_leafs)
|
||||
int leafs_num)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
@ -782,7 +782,7 @@ static void non_recursive_bvh_div_nodes(const BVHTree *tree,
|
|||
/* this value is 0 (on binary trees) and negative on the others */
|
||||
const int tree_offset = 2 - tree->tree_type;
|
||||
|
||||
const int num_branches = implicit_needed_branches(tree_type, num_leafs);
|
||||
const int branches_num = implicit_needed_branches(tree_type, leafs_num);
|
||||
|
||||
BVHBuildHelper data;
|
||||
int depth;
|
||||
|
|
@ -794,10 +794,10 @@ static void non_recursive_bvh_div_nodes(const BVHTree *tree,
|
|||
|
||||
/* Most of bvhtree code relies on 1-leaf trees having at least one branch
|
||||
* We handle that special case here */
|
||||
if (num_leafs == 1) {
|
||||
refit_kdop_hull(tree, root, 0, num_leafs);
|
||||
if (leafs_num == 1) {
|
||||
refit_kdop_hull(tree, root, 0, leafs_num);
|
||||
root->main_axis = get_largest_axis(root->bv) / 2;
|
||||
root->totnode = 1;
|
||||
root->node_num = 1;
|
||||
root->children[0] = leafs_array[0];
|
||||
root->children[0]->parent = root;
|
||||
return;
|
||||
|
|
@ -819,10 +819,10 @@ static void non_recursive_bvh_div_nodes(const BVHTree *tree,
|
|||
};
|
||||
|
||||
/* Loop tree levels (log N) loops */
|
||||
for (i = 1, depth = 1; i <= num_branches; i = i * tree_type + tree_offset, depth++) {
|
||||
for (i = 1, depth = 1; i <= branches_num; i = i * tree_type + tree_offset, depth++) {
|
||||
const int first_of_next_level = i * tree_type + tree_offset;
|
||||
/* index of last branch on this level */
|
||||
const int i_stop = min_ii(first_of_next_level, num_branches + 1);
|
||||
const int i_stop = min_ii(first_of_next_level, branches_num + 1);
|
||||
|
||||
/* Loop all branches on this level */
|
||||
cb_data.first_of_next_level = first_of_next_level;
|
||||
|
|
@ -832,7 +832,7 @@ static void non_recursive_bvh_div_nodes(const BVHTree *tree,
|
|||
if (true) {
|
||||
TaskParallelSettings settings;
|
||||
BLI_parallel_range_settings_defaults(&settings);
|
||||
settings.use_threading = (num_leafs > KDOPBVH_THREAD_LEAF_THRESHOLD);
|
||||
settings.use_threading = (leafs_num > KDOPBVH_THREAD_LEAF_THRESHOLD);
|
||||
BLI_task_parallel_range(i, i_stop, &cb_data, non_recursive_bvh_div_nodes_task_cb, &settings);
|
||||
}
|
||||
else {
|
||||
|
|
@ -940,21 +940,21 @@ void BLI_bvhtree_balance(BVHTree *tree)
|
|||
|
||||
/* This function should only be called once
|
||||
* (some big bug goes here if its being called more than once per tree) */
|
||||
BLI_assert(tree->totbranch == 0);
|
||||
BLI_assert(tree->branch_num == 0);
|
||||
|
||||
/* Build the implicit tree */
|
||||
non_recursive_bvh_div_nodes(
|
||||
tree, tree->nodearray + (tree->totleaf - 1), leafs_array, tree->totleaf);
|
||||
tree, tree->nodearray + (tree->leaf_num - 1), leafs_array, tree->leaf_num);
|
||||
|
||||
/* current code expects the branches to be linked to the nodes array
|
||||
* we perform that linkage here */
|
||||
tree->totbranch = implicit_needed_branches(tree->tree_type, tree->totleaf);
|
||||
for (int i = 0; i < tree->totbranch; i++) {
|
||||
tree->nodes[tree->totleaf + i] = &tree->nodearray[tree->totleaf + i];
|
||||
tree->branch_num = implicit_needed_branches(tree->tree_type, tree->leaf_num);
|
||||
for (int i = 0; i < tree->branch_num; i++) {
|
||||
tree->nodes[tree->leaf_num + i] = &tree->nodearray[tree->leaf_num + i];
|
||||
}
|
||||
|
||||
#ifdef USE_SKIP_LINKS
|
||||
build_skip_links(tree, tree->nodes[tree->totleaf], NULL, NULL);
|
||||
build_skip_links(tree, tree->nodes[tree->leaf_num], NULL, NULL);
|
||||
#endif
|
||||
|
||||
#ifdef USE_VERIFY_TREE
|
||||
|
|
@ -980,12 +980,12 @@ void BLI_bvhtree_insert(BVHTree *tree, int index, const float co[3], int numpoin
|
|||
{
|
||||
BVHNode *node = NULL;
|
||||
|
||||
/* insert should only possible as long as tree->totbranch is 0 */
|
||||
BLI_assert(tree->totbranch <= 0);
|
||||
BLI_assert((size_t)tree->totleaf < MEM_allocN_len(tree->nodes) / sizeof(*(tree->nodes)));
|
||||
/* insert should only possible as long as tree->branch_num is 0 */
|
||||
BLI_assert(tree->branch_num <= 0);
|
||||
BLI_assert((size_t)tree->leaf_num < MEM_allocN_len(tree->nodes) / sizeof(*(tree->nodes)));
|
||||
|
||||
node = tree->nodes[tree->totleaf] = &(tree->nodearray[tree->totleaf]);
|
||||
tree->totleaf++;
|
||||
node = tree->nodes[tree->leaf_num] = &(tree->nodearray[tree->leaf_num]);
|
||||
tree->leaf_num++;
|
||||
|
||||
create_kdop_hull(tree, node, co, numpoints, 0);
|
||||
node->index = index;
|
||||
|
|
@ -1000,7 +1000,7 @@ bool BLI_bvhtree_update_node(
|
|||
BVHNode *node = NULL;
|
||||
|
||||
/* check if index exists */
|
||||
if (index > tree->totleaf) {
|
||||
if (index > tree->leaf_num) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -1024,8 +1024,8 @@ void BLI_bvhtree_update_tree(BVHTree *tree)
|
|||
* TRICKY: the way we build the tree all the children have an index greater than the parent
|
||||
* This allows us todo a bottom up update by starting on the bigger numbered branch. */
|
||||
|
||||
BVHNode **root = tree->nodes + tree->totleaf;
|
||||
BVHNode **index = tree->nodes + tree->totleaf + tree->totbranch - 1;
|
||||
BVHNode **root = tree->nodes + tree->leaf_num;
|
||||
BVHNode **index = tree->nodes + tree->leaf_num + tree->branch_num - 1;
|
||||
|
||||
for (; index >= root; index--) {
|
||||
node_join(tree, *index);
|
||||
|
|
@ -1033,7 +1033,7 @@ void BLI_bvhtree_update_tree(BVHTree *tree)
|
|||
}
|
||||
int BLI_bvhtree_get_len(const BVHTree *tree)
|
||||
{
|
||||
return tree->totleaf;
|
||||
return tree->leaf_num;
|
||||
}
|
||||
|
||||
int BLI_bvhtree_get_tree_type(const BVHTree *tree)
|
||||
|
|
@ -1048,7 +1048,7 @@ float BLI_bvhtree_get_epsilon(const BVHTree *tree)
|
|||
|
||||
void BLI_bvhtree_get_bounding_box(BVHTree *tree, float r_bb_min[3], float r_bb_max[3])
|
||||
{
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
if (root != NULL) {
|
||||
const float bb_min[3] = {root->bv[0], root->bv[2], root->bv[4]};
|
||||
const float bb_max[3] = {root->bv[1], root->bv[3], root->bv[5]};
|
||||
|
|
@ -1099,9 +1099,9 @@ static void tree_overlap_traverse(BVHOverlapData_Thread *data_thread,
|
|||
|
||||
if (tree_overlap_test(node1, node2, data->start_axis, data->stop_axis)) {
|
||||
/* check if node1 is a leaf */
|
||||
if (!node1->totnode) {
|
||||
if (!node1->node_num) {
|
||||
/* check if node2 is a leaf */
|
||||
if (!node2->totnode) {
|
||||
if (!node2->node_num) {
|
||||
BVHTreeOverlap *overlap;
|
||||
|
||||
if (UNLIKELY(node1 == node2)) {
|
||||
|
|
@ -1143,9 +1143,9 @@ static void tree_overlap_traverse_cb(BVHOverlapData_Thread *data_thread,
|
|||
|
||||
if (tree_overlap_test(node1, node2, data->start_axis, data->stop_axis)) {
|
||||
/* check if node1 is a leaf */
|
||||
if (!node1->totnode) {
|
||||
if (!node1->node_num) {
|
||||
/* check if node2 is a leaf */
|
||||
if (!node2->totnode) {
|
||||
if (!node2->node_num) {
|
||||
BVHTreeOverlap *overlap;
|
||||
|
||||
if (UNLIKELY(node1 == node2)) {
|
||||
|
|
@ -1190,9 +1190,9 @@ static bool tree_overlap_traverse_num(BVHOverlapData_Thread *data_thread,
|
|||
|
||||
if (tree_overlap_test(node1, node2, data->start_axis, data->stop_axis)) {
|
||||
/* check if node1 is a leaf */
|
||||
if (!node1->totnode) {
|
||||
if (!node1->node_num) {
|
||||
/* check if node2 is a leaf */
|
||||
if (!node2->totnode) {
|
||||
if (!node2->node_num) {
|
||||
BVHTreeOverlap *overlap;
|
||||
|
||||
if (UNLIKELY(node1 == node2)) {
|
||||
|
|
@ -1212,7 +1212,7 @@ static bool tree_overlap_traverse_num(BVHOverlapData_Thread *data_thread,
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (j = 0; j < node2->totnode; j++) {
|
||||
for (j = 0; j < node2->node_num; j++) {
|
||||
if (tree_overlap_traverse_num(data_thread, node1, node2->children[j])) {
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1221,7 +1221,7 @@ static bool tree_overlap_traverse_num(BVHOverlapData_Thread *data_thread,
|
|||
}
|
||||
else {
|
||||
const uint max_interactions = data_thread->max_interactions;
|
||||
for (j = 0; j < node1->totnode; j++) {
|
||||
for (j = 0; j < node1->node_num; j++) {
|
||||
if (tree_overlap_traverse_num(data_thread, node1->children[j], node2)) {
|
||||
data_thread->max_interactions = max_interactions;
|
||||
}
|
||||
|
|
@ -1233,7 +1233,7 @@ static bool tree_overlap_traverse_num(BVHOverlapData_Thread *data_thread,
|
|||
|
||||
int BLI_bvhtree_overlap_thread_num(const BVHTree *tree)
|
||||
{
|
||||
return (int)MIN2(tree->tree_type, tree->nodes[tree->totleaf]->totnode);
|
||||
return (int)MIN2(tree->tree_type, tree->nodes[tree->leaf_num]->node_num);
|
||||
}
|
||||
|
||||
static void bvhtree_overlap_task_cb(void *__restrict userdata,
|
||||
|
|
@ -1245,25 +1245,25 @@ static void bvhtree_overlap_task_cb(void *__restrict userdata,
|
|||
|
||||
if (data->max_interactions) {
|
||||
tree_overlap_traverse_num(data,
|
||||
data_shared->tree1->nodes[data_shared->tree1->totleaf]->children[j],
|
||||
data_shared->tree2->nodes[data_shared->tree2->totleaf]);
|
||||
data_shared->tree1->nodes[data_shared->tree1->leaf_num]->children[j],
|
||||
data_shared->tree2->nodes[data_shared->tree2->leaf_num]);
|
||||
}
|
||||
else if (data_shared->callback) {
|
||||
tree_overlap_traverse_cb(data,
|
||||
data_shared->tree1->nodes[data_shared->tree1->totleaf]->children[j],
|
||||
data_shared->tree2->nodes[data_shared->tree2->totleaf]);
|
||||
data_shared->tree1->nodes[data_shared->tree1->leaf_num]->children[j],
|
||||
data_shared->tree2->nodes[data_shared->tree2->leaf_num]);
|
||||
}
|
||||
else {
|
||||
tree_overlap_traverse(data,
|
||||
data_shared->tree1->nodes[data_shared->tree1->totleaf]->children[j],
|
||||
data_shared->tree2->nodes[data_shared->tree2->totleaf]);
|
||||
data_shared->tree1->nodes[data_shared->tree1->leaf_num]->children[j],
|
||||
data_shared->tree2->nodes[data_shared->tree2->leaf_num]);
|
||||
}
|
||||
}
|
||||
|
||||
BVHTreeOverlap *BLI_bvhtree_overlap_ex(
|
||||
const BVHTree *tree1,
|
||||
const BVHTree *tree2,
|
||||
uint *r_overlap_tot,
|
||||
uint *r_overlap_num,
|
||||
/* optional callback to test the overlap before adding (must be thread-safe!) */
|
||||
BVHTree_OverlapCallback callback,
|
||||
void *userdata,
|
||||
|
|
@ -1272,7 +1272,7 @@ BVHTreeOverlap *BLI_bvhtree_overlap_ex(
|
|||
{
|
||||
bool overlap_pairs = (flag & BVH_OVERLAP_RETURN_PAIRS) != 0;
|
||||
bool use_threading = (flag & BVH_OVERLAP_USE_THREADING) != 0 &&
|
||||
(tree1->totleaf > KDOPBVH_THREAD_LEAF_THRESHOLD);
|
||||
(tree1->leaf_num > KDOPBVH_THREAD_LEAF_THRESHOLD);
|
||||
|
||||
/* 'RETURN_PAIRS' was not implemented without 'max_interactions'. */
|
||||
BLI_assert(overlap_pairs || max_interactions);
|
||||
|
|
@ -1293,8 +1293,8 @@ BVHTreeOverlap *BLI_bvhtree_overlap_ex(
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const BVHNode *root1 = tree1->nodes[tree1->totleaf];
|
||||
const BVHNode *root2 = tree2->nodes[tree2->totleaf];
|
||||
const BVHNode *root1 = tree1->nodes[tree1->leaf_num];
|
||||
const BVHNode *root2 = tree2->nodes[tree2->leaf_num];
|
||||
|
||||
start_axis = min_axis(tree1->start_axis, tree2->start_axis);
|
||||
stop_axis = min_axis(tree1->stop_axis, tree2->stop_axis);
|
||||
|
|
@ -1354,7 +1354,7 @@ BVHTreeOverlap *BLI_bvhtree_overlap_ex(
|
|||
BLI_stack_free(data[j].overlap);
|
||||
to += count;
|
||||
}
|
||||
*r_overlap_tot = (uint)total;
|
||||
*r_overlap_num = (uint)total;
|
||||
}
|
||||
|
||||
return overlap;
|
||||
|
|
@ -1363,14 +1363,14 @@ BVHTreeOverlap *BLI_bvhtree_overlap_ex(
|
|||
BVHTreeOverlap *BLI_bvhtree_overlap(
|
||||
const BVHTree *tree1,
|
||||
const BVHTree *tree2,
|
||||
uint *r_overlap_tot,
|
||||
uint *r_overlap_num,
|
||||
/* optional callback to test the overlap before adding (must be thread-safe!) */
|
||||
BVHTree_OverlapCallback callback,
|
||||
void *userdata)
|
||||
{
|
||||
return BLI_bvhtree_overlap_ex(tree1,
|
||||
tree2,
|
||||
r_overlap_tot,
|
||||
r_overlap_num,
|
||||
callback,
|
||||
userdata,
|
||||
0,
|
||||
|
|
@ -1403,7 +1403,7 @@ static void bvhtree_intersect_plane_dfs_recursive(BVHIntersectPlaneData *__restr
|
|||
{
|
||||
if (tree_intersect_plane_test(node->bv, data->plane)) {
|
||||
/* check if node is a leaf */
|
||||
if (!node->totnode) {
|
||||
if (!node->node_num) {
|
||||
int *intersect = BLI_stack_push_r(data->intersect);
|
||||
*intersect = node->index;
|
||||
}
|
||||
|
|
@ -1417,18 +1417,18 @@ static void bvhtree_intersect_plane_dfs_recursive(BVHIntersectPlaneData *__restr
|
|||
}
|
||||
}
|
||||
|
||||
int *BLI_bvhtree_intersect_plane(BVHTree *tree, float plane[4], uint *r_intersect_tot)
|
||||
int *BLI_bvhtree_intersect_plane(BVHTree *tree, float plane[4], uint *r_intersect_num)
|
||||
{
|
||||
int *intersect = NULL;
|
||||
size_t total = 0;
|
||||
|
||||
if (tree->totleaf) {
|
||||
if (tree->leaf_num) {
|
||||
BVHIntersectPlaneData data;
|
||||
data.tree = tree;
|
||||
copy_v4_v4(data.plane, plane);
|
||||
data.intersect = BLI_stack_new(sizeof(int), __func__);
|
||||
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
bvhtree_intersect_plane_dfs_recursive(&data, root);
|
||||
|
||||
total = BLI_stack_count(data.intersect);
|
||||
|
|
@ -1438,7 +1438,7 @@ int *BLI_bvhtree_intersect_plane(BVHTree *tree, float plane[4], uint *r_intersec
|
|||
}
|
||||
BLI_stack_free(data.intersect);
|
||||
}
|
||||
*r_intersect_tot = (uint)total;
|
||||
*r_intersect_num = (uint)total;
|
||||
return intersect;
|
||||
}
|
||||
|
||||
|
|
@ -1473,7 +1473,7 @@ static float calc_nearest_point_squared(const float proj[3], BVHNode *node, floa
|
|||
/* Depth first search method */
|
||||
static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
if (data->callback) {
|
||||
data->callback(data->userdata, node->index, data->co, &data->nearest);
|
||||
}
|
||||
|
|
@ -1489,7 +1489,7 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
|
|||
|
||||
if (data->proj[node->main_axis] <= node->children[0]->bv[node->main_axis * 2 + 1]) {
|
||||
|
||||
for (i = 0; i != node->totnode; i++) {
|
||||
for (i = 0; i != node->node_num; i++) {
|
||||
if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >=
|
||||
data->nearest.dist_sq) {
|
||||
continue;
|
||||
|
|
@ -1498,7 +1498,7 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (i = node->totnode - 1; i >= 0; i--) {
|
||||
for (i = node->node_num - 1; i >= 0; i--) {
|
||||
if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >=
|
||||
data->nearest.dist_sq) {
|
||||
continue;
|
||||
|
|
@ -1522,7 +1522,7 @@ static void dfs_find_nearest_begin(BVHNearestData *data, BVHNode *node)
|
|||
/* Priority queue method */
|
||||
static void heap_find_nearest_inner(BVHNearestData *data, HeapSimple *heap, BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
if (data->callback) {
|
||||
data->callback(data->userdata, node->index, data->co, &data->nearest);
|
||||
}
|
||||
|
|
@ -1534,7 +1534,7 @@ static void heap_find_nearest_inner(BVHNearestData *data, HeapSimple *heap, BVHN
|
|||
else {
|
||||
float nearest[3];
|
||||
|
||||
for (int i = 0; i != node->totnode; i++) {
|
||||
for (int i = 0; i != node->node_num; i++) {
|
||||
float dist_sq = calc_nearest_point_squared(data->proj, node->children[i], nearest);
|
||||
|
||||
if (dist_sq < data->nearest.dist_sq) {
|
||||
|
|
@ -1574,7 +1574,7 @@ int BLI_bvhtree_find_nearest_ex(BVHTree *tree,
|
|||
axis_t axis_iter;
|
||||
|
||||
BVHNearestData data;
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
|
||||
/* init data to search */
|
||||
data.tree = tree;
|
||||
|
|
@ -1642,7 +1642,7 @@ static bool isect_aabb_v3(BVHNode *node, const float co[3])
|
|||
|
||||
static bool dfs_find_duplicate_fast_dfs(BVHNearestData *data, BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
if (isect_aabb_v3(node, data->co)) {
|
||||
if (data->callback) {
|
||||
const float dist_sq = data->nearest.dist_sq;
|
||||
|
|
@ -1658,7 +1658,7 @@ static bool dfs_find_duplicate_fast_dfs(BVHNearestData *data, BVHNode *node)
|
|||
int i;
|
||||
|
||||
if (data->proj[node->main_axis] <= node->children[0]->bv[node->main_axis * 2 + 1]) {
|
||||
for (i = 0; i != node->totnode; i++) {
|
||||
for (i = 0; i != node->node_num; i++) {
|
||||
if (isect_aabb_v3(node->children[i], data->co)) {
|
||||
if (dfs_find_duplicate_fast_dfs(data, node->children[i])) {
|
||||
return true;
|
||||
|
|
@ -1667,7 +1667,7 @@ static bool dfs_find_duplicate_fast_dfs(BVHNearestData *data, BVHNode *node)
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (i = node->totnode; i--;) {
|
||||
for (i = node->node_num; i--;) {
|
||||
if (isect_aabb_v3(node->children[i], data->co)) {
|
||||
if (dfs_find_duplicate_fast_dfs(data, node->children[i])) {
|
||||
return true;
|
||||
|
|
@ -1686,7 +1686,7 @@ int BLI_bvhtree_find_nearest_first(BVHTree *tree,
|
|||
void *userdata)
|
||||
{
|
||||
BVHNearestData data;
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
|
||||
/* init data to search */
|
||||
data.tree = tree;
|
||||
|
|
@ -1796,7 +1796,7 @@ static void dfs_raycast(BVHRayCastData *data, BVHNode *node)
|
|||
return;
|
||||
}
|
||||
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
if (data->callback) {
|
||||
data->callback(data->userdata, node->index, &data->ray, &data->hit);
|
||||
}
|
||||
|
|
@ -1809,12 +1809,12 @@ static void dfs_raycast(BVHRayCastData *data, BVHNode *node)
|
|||
else {
|
||||
/* pick loop direction to dive into the tree (based on ray direction and split axis) */
|
||||
if (data->ray_dot_axis[node->main_axis] > 0.0f) {
|
||||
for (i = 0; i != node->totnode; i++) {
|
||||
for (i = 0; i != node->node_num; i++) {
|
||||
dfs_raycast(data, node->children[i]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i = node->totnode - 1; i >= 0; i--) {
|
||||
for (i = node->node_num - 1; i >= 0; i--) {
|
||||
dfs_raycast(data, node->children[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -1837,7 +1837,7 @@ static void dfs_raycast_all(BVHRayCastData *data, BVHNode *node)
|
|||
return;
|
||||
}
|
||||
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
/* no need to check for 'data->callback' (using 'all' only makes sense with a callback). */
|
||||
dist = data->hit.dist;
|
||||
data->callback(data->userdata, node->index, &data->ray, &data->hit);
|
||||
|
|
@ -1847,12 +1847,12 @@ static void dfs_raycast_all(BVHRayCastData *data, BVHNode *node)
|
|||
else {
|
||||
/* pick loop direction to dive into the tree (based on ray direction and split axis) */
|
||||
if (data->ray_dot_axis[node->main_axis] > 0.0f) {
|
||||
for (i = 0; i != node->totnode; i++) {
|
||||
for (i = 0; i != node->node_num; i++) {
|
||||
dfs_raycast_all(data, node->children[i]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i = node->totnode - 1; i >= 0; i--) {
|
||||
for (i = node->node_num - 1; i >= 0; i--) {
|
||||
dfs_raycast_all(data, node->children[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -1904,7 +1904,7 @@ int BLI_bvhtree_ray_cast_ex(BVHTree *tree,
|
|||
int flag)
|
||||
{
|
||||
BVHRayCastData data;
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
|
||||
BLI_ASSERT_UNIT_V3(dir);
|
||||
|
||||
|
|
@ -1988,7 +1988,7 @@ void BLI_bvhtree_ray_cast_all_ex(BVHTree *tree,
|
|||
int flag)
|
||||
{
|
||||
BVHRayCastData data;
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
|
||||
BLI_ASSERT_UNIT_V3(dir);
|
||||
BLI_assert(callback != NULL);
|
||||
|
|
@ -2048,7 +2048,7 @@ typedef struct RangeQueryData {
|
|||
|
||||
static void dfs_range_query(RangeQueryData *data, BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
#if 0 /*UNUSED*/
|
||||
/* Calculate the node min-coords
|
||||
* (if the node was a point then this is the point coordinates) */
|
||||
|
|
@ -2060,12 +2060,12 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
|
|||
}
|
||||
else {
|
||||
int i;
|
||||
for (i = 0; i != node->totnode; i++) {
|
||||
for (i = 0; i != node->node_num; i++) {
|
||||
float nearest[3];
|
||||
float dist_sq = calc_nearest_point_squared(data->center, node->children[i], nearest);
|
||||
if (dist_sq < data->radius_sq) {
|
||||
/* Its a leaf.. call the callback */
|
||||
if (node->children[i]->totnode == 0) {
|
||||
if (node->children[i]->node_num == 0) {
|
||||
data->hits++;
|
||||
data->callback(data->userdata, node->children[i]->index, data->center, dist_sq);
|
||||
}
|
||||
|
|
@ -2080,7 +2080,7 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
|
|||
int BLI_bvhtree_range_query(
|
||||
BVHTree *tree, const float co[3], float radius, BVHTree_RangeQuery callback, void *userdata)
|
||||
{
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
|
||||
RangeQueryData data;
|
||||
data.tree = tree;
|
||||
|
|
@ -2096,7 +2096,7 @@ int BLI_bvhtree_range_query(
|
|||
float dist_sq = calc_nearest_point_squared(data.center, root, nearest);
|
||||
if (dist_sq < data.radius_sq) {
|
||||
/* Its a leaf.. call the callback */
|
||||
if (root->totnode == 0) {
|
||||
if (root->node_num == 0) {
|
||||
data.hits++;
|
||||
data.callback(data.userdata, root->index, co, dist_sq);
|
||||
}
|
||||
|
|
@ -2118,7 +2118,7 @@ int BLI_bvhtree_range_query(
|
|||
static void bvhtree_nearest_projected_dfs_recursive(BVHNearestProjectedData *__restrict data,
|
||||
const BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
if (data->callback) {
|
||||
data->callback(data->userdata, node->index, &data->precalc, NULL, 0, &data->nearest);
|
||||
}
|
||||
|
|
@ -2134,7 +2134,7 @@ static void bvhtree_nearest_projected_dfs_recursive(BVHNearestProjectedData *__r
|
|||
else {
|
||||
/* First pick the closest node to recurse into */
|
||||
if (data->closest_axis[node->main_axis]) {
|
||||
for (int i = 0; i != node->totnode; i++) {
|
||||
for (int i = 0; i != node->node_num; i++) {
|
||||
const float *bv = node->children[i]->bv;
|
||||
|
||||
if (dist_squared_to_projected_aabb(&data->precalc,
|
||||
|
|
@ -2146,7 +2146,7 @@ static void bvhtree_nearest_projected_dfs_recursive(BVHNearestProjectedData *__r
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (int i = node->totnode; i--;) {
|
||||
for (int i = node->node_num; i--;) {
|
||||
const float *bv = node->children[i]->bv;
|
||||
|
||||
if (dist_squared_to_projected_aabb(&data->precalc,
|
||||
|
|
@ -2163,7 +2163,7 @@ static void bvhtree_nearest_projected_dfs_recursive(BVHNearestProjectedData *__r
|
|||
static void bvhtree_nearest_projected_with_clipplane_test_dfs_recursive(
|
||||
BVHNearestProjectedData *__restrict data, const BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
if (data->callback) {
|
||||
data->callback(data->userdata,
|
||||
node->index,
|
||||
|
|
@ -2184,7 +2184,7 @@ static void bvhtree_nearest_projected_with_clipplane_test_dfs_recursive(
|
|||
else {
|
||||
/* First pick the closest node to recurse into */
|
||||
if (data->closest_axis[node->main_axis]) {
|
||||
for (int i = 0; i != node->totnode; i++) {
|
||||
for (int i = 0; i != node->node_num; i++) {
|
||||
const float *bv = node->children[i]->bv;
|
||||
const float bb_min[3] = {bv[0], bv[2], bv[4]};
|
||||
const float bb_max[3] = {bv[1], bv[3], bv[5]};
|
||||
|
|
@ -2206,7 +2206,7 @@ static void bvhtree_nearest_projected_with_clipplane_test_dfs_recursive(
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (int i = node->totnode; i--;) {
|
||||
for (int i = node->node_num; i--;) {
|
||||
const float *bv = node->children[i]->bv;
|
||||
const float bb_min[3] = {bv[0], bv[2], bv[4]};
|
||||
const float bb_max[3] = {bv[1], bv[3], bv[5]};
|
||||
|
|
@ -2240,7 +2240,7 @@ int BLI_bvhtree_find_nearest_projected(BVHTree *tree,
|
|||
BVHTree_NearestProjectedCallback callback,
|
||||
void *userdata)
|
||||
{
|
||||
BVHNode *root = tree->nodes[tree->totleaf];
|
||||
BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
if (root != NULL) {
|
||||
BVHNearestProjectedData data;
|
||||
dist_squared_to_projected_aabb_precalc(&data.precalc, projmat, winsize, mval);
|
||||
|
|
@ -2314,7 +2314,7 @@ typedef struct BVHTree_WalkData {
|
|||
*/
|
||||
static bool bvhtree_walk_dfs_recursive(BVHTree_WalkData *walk_data, const BVHNode *node)
|
||||
{
|
||||
if (node->totnode == 0) {
|
||||
if (node->node_num == 0) {
|
||||
return walk_data->walk_leaf_cb(
|
||||
(const BVHTreeAxisRange *)node->bv, node->index, walk_data->userdata);
|
||||
}
|
||||
|
|
@ -2322,7 +2322,7 @@ static bool bvhtree_walk_dfs_recursive(BVHTree_WalkData *walk_data, const BVHNod
|
|||
/* First pick the closest node to recurse into */
|
||||
if (walk_data->walk_order_cb(
|
||||
(const BVHTreeAxisRange *)node->bv, node->main_axis, walk_data->userdata)) {
|
||||
for (int i = 0; i != node->totnode; i++) {
|
||||
for (int i = 0; i != node->node_num; i++) {
|
||||
if (walk_data->walk_parent_cb((const BVHTreeAxisRange *)node->children[i]->bv,
|
||||
walk_data->userdata)) {
|
||||
if (!bvhtree_walk_dfs_recursive(walk_data, node->children[i])) {
|
||||
|
|
@ -2332,7 +2332,7 @@ static bool bvhtree_walk_dfs_recursive(BVHTree_WalkData *walk_data, const BVHNod
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (int i = node->totnode - 1; i >= 0; i--) {
|
||||
for (int i = node->node_num - 1; i >= 0; i--) {
|
||||
if (walk_data->walk_parent_cb((const BVHTreeAxisRange *)node->children[i]->bv,
|
||||
walk_data->userdata)) {
|
||||
if (!bvhtree_walk_dfs_recursive(walk_data, node->children[i])) {
|
||||
|
|
@ -2350,7 +2350,7 @@ void BLI_bvhtree_walk_dfs(BVHTree *tree,
|
|||
BVHTree_WalkOrderCallback walk_order_cb,
|
||||
void *userdata)
|
||||
{
|
||||
const BVHNode *root = tree->nodes[tree->totleaf];
|
||||
const BVHNode *root = tree->nodes[tree->leaf_num];
|
||||
if (root != NULL) {
|
||||
BVHTree_WalkData walk_data = {walk_parent_cb, walk_leaf_cb, walk_order_cb, userdata};
|
||||
/* first make sure the bv of root passes in the test too */
|
||||
|
|
|
|||
|
|
@ -159,9 +159,9 @@ BLI_INLINE BLI_mempool_chunk *mempool_chunk_find(BLI_mempool_chunk *head, uint i
|
|||
* \note for small pools 1 is a good default, the elements need to be initialized,
|
||||
* adding overhead on creation which is redundant if they aren't used.
|
||||
*/
|
||||
BLI_INLINE uint mempool_maxchunks(const uint totelem, const uint pchunk)
|
||||
BLI_INLINE uint mempool_maxchunks(const uint elem_num, const uint pchunk)
|
||||
{
|
||||
return (totelem <= pchunk) ? 1 : ((totelem / pchunk) + 1);
|
||||
return (elem_num <= pchunk) ? 1 : ((elem_num / pchunk) + 1);
|
||||
}
|
||||
|
||||
static BLI_mempool_chunk *mempool_chunk_alloc(BLI_mempool *pool)
|
||||
|
|
@ -250,7 +250,7 @@ static void mempool_chunk_free_all(BLI_mempool_chunk *mpchunk)
|
|||
}
|
||||
}
|
||||
|
||||
BLI_mempool *BLI_mempool_create(uint esize, uint totelem, uint pchunk, uint flag)
|
||||
BLI_mempool *BLI_mempool_create(uint esize, uint elem_num, uint pchunk, uint flag)
|
||||
{
|
||||
BLI_mempool *pool;
|
||||
BLI_freenode *last_tail = NULL;
|
||||
|
|
@ -268,7 +268,7 @@ BLI_mempool *BLI_mempool_create(uint esize, uint totelem, uint pchunk, uint flag
|
|||
esize = MAX2(esize, (uint)sizeof(BLI_freenode));
|
||||
}
|
||||
|
||||
maxchunks = mempool_maxchunks(totelem, pchunk);
|
||||
maxchunks = mempool_maxchunks(elem_num, pchunk);
|
||||
|
||||
pool->chunks = NULL;
|
||||
pool->chunk_tail = NULL;
|
||||
|
|
@ -301,7 +301,7 @@ BLI_mempool *BLI_mempool_create(uint esize, uint totelem, uint pchunk, uint flag
|
|||
#endif
|
||||
pool->totused = 0;
|
||||
|
||||
if (totelem) {
|
||||
if (elem_num) {
|
||||
/* Allocate the actual chunks. */
|
||||
for (i = 0; i < maxchunks; i++) {
|
||||
BLI_mempool_chunk *mpchunk = mempool_chunk_alloc(pool);
|
||||
|
|
@ -510,18 +510,18 @@ static void mempool_threadsafe_iternew(BLI_mempool *pool, BLI_mempool_threadsafe
|
|||
ts_iter->curchunk_threaded_shared = NULL;
|
||||
}
|
||||
|
||||
ParallelMempoolTaskData *mempool_iter_threadsafe_create(BLI_mempool *pool, const size_t num_iter)
|
||||
ParallelMempoolTaskData *mempool_iter_threadsafe_create(BLI_mempool *pool, const size_t iter_num)
|
||||
{
|
||||
BLI_assert(pool->flag & BLI_MEMPOOL_ALLOW_ITER);
|
||||
|
||||
ParallelMempoolTaskData *iter_arr = MEM_mallocN(sizeof(*iter_arr) * num_iter, __func__);
|
||||
ParallelMempoolTaskData *iter_arr = MEM_mallocN(sizeof(*iter_arr) * iter_num, __func__);
|
||||
BLI_mempool_chunk **curchunk_threaded_shared = MEM_mallocN(sizeof(void *), __func__);
|
||||
|
||||
mempool_threadsafe_iternew(pool, &iter_arr->ts_iter);
|
||||
|
||||
*curchunk_threaded_shared = iter_arr->ts_iter.iter.curchunk;
|
||||
iter_arr->ts_iter.curchunk_threaded_shared = curchunk_threaded_shared;
|
||||
for (size_t i = 1; i < num_iter; i++) {
|
||||
for (size_t i = 1; i < iter_num; i++) {
|
||||
iter_arr[i].ts_iter = iter_arr[0].ts_iter;
|
||||
*curchunk_threaded_shared = iter_arr[i].ts_iter.iter.curchunk =
|
||||
((*curchunk_threaded_shared) ? (*curchunk_threaded_shared)->next : NULL);
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ typedef struct ParallelMempoolTaskData {
|
|||
* See #BLI_task_parallel_mempool implementation for detailed usage example.
|
||||
*/
|
||||
ParallelMempoolTaskData *mempool_iter_threadsafe_create(BLI_mempool *pool,
|
||||
size_t num_iter) ATTR_WARN_UNUSED_RESULT
|
||||
size_t iter_num) ATTR_WARN_UNUSED_RESULT
|
||||
ATTR_NONNULL();
|
||||
void mempool_iter_threadsafe_destroy(ParallelMempoolTaskData *iter_arr) ATTR_NONNULL();
|
||||
|
||||
|
|
|
|||
|
|
@ -20,8 +20,8 @@ void BLI_bitmap_set_all(BLI_bitmap *bitmap, bool set, size_t bits)
|
|||
|
||||
void BLI_bitmap_flip_all(BLI_bitmap *bitmap, size_t bits)
|
||||
{
|
||||
size_t num_blocks = _BITMAP_NUM_BLOCKS(bits);
|
||||
for (size_t i = 0; i < num_blocks; i++) {
|
||||
size_t blocks_num = _BITMAP_NUM_BLOCKS(bits);
|
||||
for (size_t i = 0; i < blocks_num; i++) {
|
||||
bitmap[i] ^= ~(BLI_bitmap)0;
|
||||
}
|
||||
}
|
||||
|
|
@ -33,16 +33,16 @@ void BLI_bitmap_copy_all(BLI_bitmap *dst, const BLI_bitmap *src, size_t bits)
|
|||
|
||||
void BLI_bitmap_and_all(BLI_bitmap *dst, const BLI_bitmap *src, size_t bits)
|
||||
{
|
||||
size_t num_blocks = _BITMAP_NUM_BLOCKS(bits);
|
||||
for (size_t i = 0; i < num_blocks; i++) {
|
||||
size_t blocks_num = _BITMAP_NUM_BLOCKS(bits);
|
||||
for (size_t i = 0; i < blocks_num; i++) {
|
||||
dst[i] &= src[i];
|
||||
}
|
||||
}
|
||||
|
||||
void BLI_bitmap_or_all(BLI_bitmap *dst, const BLI_bitmap *src, size_t bits)
|
||||
{
|
||||
size_t num_blocks = _BITMAP_NUM_BLOCKS(bits);
|
||||
for (size_t i = 0; i < num_blocks; i++) {
|
||||
size_t blocks_num = _BITMAP_NUM_BLOCKS(bits);
|
||||
for (size_t i = 0; i < blocks_num; i++) {
|
||||
dst[i] |= src[i];
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ int BLI_convexhull_2d(const float (*points)[2], const int n, int r_points[])
|
|||
struct PointRef *points_ref = MEM_mallocN(sizeof(*points_ref) * (size_t)n, __func__);
|
||||
float(*points_sort)[2] = MEM_mallocN(sizeof(*points_sort) * (size_t)n, __func__);
|
||||
int *points_map;
|
||||
int tot, i;
|
||||
int points_hull_num, i;
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
points_ref[i].pt = points[i];
|
||||
|
|
@ -178,20 +178,20 @@ int BLI_convexhull_2d(const float (*points)[2], const int n, int r_points[])
|
|||
memcpy(points_sort[i], points_ref[i].pt, sizeof(float[2]));
|
||||
}
|
||||
|
||||
tot = BLI_convexhull_2d_sorted(points_sort, n, r_points);
|
||||
points_hull_num = BLI_convexhull_2d_sorted(points_sort, n, r_points);
|
||||
|
||||
/* map back to the original index values */
|
||||
points_map = (int *)points_sort; /* abuse float array for temp storage */
|
||||
for (i = 0; i < tot; i++) {
|
||||
for (i = 0; i < points_hull_num; i++) {
|
||||
points_map[i] = (int)((const float(*)[2])points_ref[r_points[i]].pt - points);
|
||||
}
|
||||
|
||||
memcpy(r_points, points_map, (size_t)tot * sizeof(*points_map));
|
||||
memcpy(r_points, points_map, (size_t)points_hull_num * sizeof(*points_map));
|
||||
|
||||
MEM_freeN(points_ref);
|
||||
MEM_freeN(points_sort);
|
||||
|
||||
return tot;
|
||||
return points_hull_num;
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
|
@ -252,24 +252,24 @@ float BLI_convexhull_aabb_fit_hull_2d(const float (*points_hull)[2], unsigned in
|
|||
float BLI_convexhull_aabb_fit_points_2d(const float (*points)[2], unsigned int n)
|
||||
{
|
||||
int *index_map;
|
||||
int tot;
|
||||
int points_hull_num;
|
||||
|
||||
float angle;
|
||||
|
||||
index_map = MEM_mallocN(sizeof(*index_map) * n * 2, __func__);
|
||||
|
||||
tot = BLI_convexhull_2d(points, (int)n, index_map);
|
||||
points_hull_num = BLI_convexhull_2d(points, (int)n, index_map);
|
||||
|
||||
if (tot) {
|
||||
if (points_hull_num) {
|
||||
float(*points_hull)[2];
|
||||
int j;
|
||||
|
||||
points_hull = MEM_mallocN(sizeof(*points_hull) * (size_t)tot, __func__);
|
||||
for (j = 0; j < tot; j++) {
|
||||
points_hull = MEM_mallocN(sizeof(*points_hull) * (size_t)points_hull_num, __func__);
|
||||
for (j = 0; j < points_hull_num; j++) {
|
||||
copy_v2_v2(points_hull[j], points[index_map[j]]);
|
||||
}
|
||||
|
||||
angle = BLI_convexhull_aabb_fit_hull_2d(points_hull, (unsigned int)tot);
|
||||
angle = BLI_convexhull_aabb_fit_hull_2d(points_hull, (unsigned int)points_hull_num);
|
||||
MEM_freeN(points_hull);
|
||||
}
|
||||
else {
|
||||
|
|
|
|||
|
|
@ -245,7 +245,7 @@ template<typename Arith_t> struct CDTArrangement {
|
|||
|
||||
/** Hint to how much space to reserve in the Vectors of the arrangement,
|
||||
* based on these counts of input elements. */
|
||||
void reserve(int num_verts, int num_edges, int num_faces);
|
||||
void reserve(int verts_num, int edges_num, int faces_num);
|
||||
|
||||
/**
|
||||
* Add a new vertex to the arrangement, with the given 2D coordinate.
|
||||
|
|
@ -318,7 +318,7 @@ template<typename T> class CDT_state {
|
|||
public:
|
||||
CDTArrangement<T> cdt;
|
||||
/** How many verts were in input (will be first in vert_array). */
|
||||
int input_vert_tot;
|
||||
int input_vert_num;
|
||||
/** Used for visiting things without having to initialized their visit fields. */
|
||||
int visit_count;
|
||||
/**
|
||||
|
|
@ -332,7 +332,7 @@ template<typename T> class CDT_state {
|
|||
bool need_ids;
|
||||
|
||||
explicit CDT_state(
|
||||
int num_input_verts, int num_input_edges, int num_input_faces, T epsilon, bool need_ids);
|
||||
int input_verts_num, int input_edges_num, int input_faces_num, T epsilon, bool need_ids);
|
||||
};
|
||||
|
||||
template<typename T> CDTArrangement<T>::~CDTArrangement()
|
||||
|
|
@ -859,20 +859,20 @@ template<typename T> CDTFace<T> *CDTArrangement<T>::add_face()
|
|||
return f;
|
||||
}
|
||||
|
||||
template<typename T> void CDTArrangement<T>::reserve(int num_verts, int num_edges, int num_faces)
|
||||
template<typename T> void CDTArrangement<T>::reserve(int verts_num, int edges_num, int faces_num)
|
||||
{
|
||||
/* These reserves are just guesses; OK if they aren't exactly right since vectors will resize. */
|
||||
this->verts.reserve(2 * num_verts);
|
||||
this->edges.reserve(3 * num_verts + 2 * num_edges + 3 * 2 * num_faces);
|
||||
this->faces.reserve(2 * num_verts + 2 * num_edges + 2 * num_faces);
|
||||
this->verts.reserve(2 * verts_num);
|
||||
this->edges.reserve(3 * verts_num + 2 * edges_num + 3 * 2 * faces_num);
|
||||
this->faces.reserve(2 * verts_num + 2 * edges_num + 2 * faces_num);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
CDT_state<T>::CDT_state(
|
||||
int num_input_verts, int num_input_edges, int num_input_faces, T epsilon, bool need_ids)
|
||||
int input_verts_num, int input_edges_num, int input_faces_num, T epsilon, bool need_ids)
|
||||
{
|
||||
this->input_vert_tot = num_input_verts;
|
||||
this->cdt.reserve(num_input_verts, num_input_edges, num_input_faces);
|
||||
this->input_vert_num = input_verts_num;
|
||||
this->cdt.reserve(input_verts_num, input_edges_num, input_faces_num);
|
||||
this->cdt.outer_face = this->cdt.add_face();
|
||||
this->epsilon = epsilon;
|
||||
this->need_ids = need_ids;
|
||||
|
|
@ -919,7 +919,7 @@ template<typename T> inline bool is_deleted_edge(const CDTEdge<T> *e)
|
|||
|
||||
template<typename T> inline bool is_original_vert(const CDTVert<T> *v, CDT_state<T> *cdt)
|
||||
{
|
||||
return (v->index < cdt->input_vert_tot);
|
||||
return (v->index < cdt->input_vert_num);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -2678,7 +2678,7 @@ CDT_result<T> get_cdt_output(CDT_state<T> *cdt_state,
|
|||
CDTVert<T> *v = cdt->verts[i];
|
||||
if (v->merge_to_index != -1) {
|
||||
if (cdt_state->need_ids) {
|
||||
if (i < cdt_state->input_vert_tot) {
|
||||
if (i < cdt_state->input_vert_num) {
|
||||
add_to_input_ids(cdt->verts[v->merge_to_index]->input_ids, i);
|
||||
}
|
||||
}
|
||||
|
|
@ -2696,7 +2696,7 @@ CDT_result<T> get_cdt_output(CDT_state<T> *cdt_state,
|
|||
if (v->merge_to_index == -1) {
|
||||
result.vert[i_out] = v->co.exact;
|
||||
if (cdt_state->need_ids) {
|
||||
if (i < cdt_state->input_vert_tot) {
|
||||
if (i < cdt_state->input_vert_num) {
|
||||
result.vert_orig[i_out].append(i);
|
||||
}
|
||||
for (int vert : v->input_ids) {
|
||||
|
|
@ -2765,7 +2765,7 @@ CDT_result<T> get_cdt_output(CDT_state<T> *cdt_state,
|
|||
*/
|
||||
template<typename T> void add_input_verts(CDT_state<T> *cdt_state, const CDT_input<T> &input)
|
||||
{
|
||||
for (int i = 0; i < cdt_state->input_vert_tot; ++i) {
|
||||
for (int i = 0; i < cdt_state->input_vert_num; ++i) {
|
||||
cdt_state->cdt.add_vert(input.vert[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ typedef struct {
|
|||
size_t in_buf_max_size;
|
||||
|
||||
struct {
|
||||
int num_frames;
|
||||
int frames_num;
|
||||
size_t *compressed_ofs;
|
||||
size_t *uncompressed_ofs;
|
||||
|
||||
|
|
@ -69,21 +69,21 @@ static bool zstd_read_seek_table(ZstdReader *zstd)
|
|||
return false;
|
||||
}
|
||||
|
||||
uint32_t num_frames;
|
||||
if (base->seek(base, -9, SEEK_END) < 0 || !zstd_read_u32(base, &num_frames)) {
|
||||
uint32_t frames_num;
|
||||
if (base->seek(base, -9, SEEK_END) < 0 || !zstd_read_u32(base, &frames_num)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Each frame has either 2 or 3 uint32_t, and after that we have
|
||||
* num_frames, flags and magic for another 9 bytes. */
|
||||
uint32_t expected_frame_length = num_frames * (has_checksums ? 12 : 8) + 9;
|
||||
* frames_num, flags and magic for another 9 bytes. */
|
||||
uint32_t expected_frame_length = frames_num * (has_checksums ? 12 : 8) + 9;
|
||||
/* The frame starts with another magic number and its length, but these
|
||||
* two fields are not included when counting length. */
|
||||
off64_t frame_start_ofs = 8 + expected_frame_length;
|
||||
/* Sanity check: Before the start of the seek table frame,
|
||||
* there must be num_frames frames, each of which at least 8 bytes long. */
|
||||
* there must be frames_num frames, each of which at least 8 bytes long. */
|
||||
off64_t seek_frame_start = base->seek(base, -frame_start_ofs, SEEK_END);
|
||||
if (seek_frame_start < num_frames * 8) {
|
||||
if (seek_frame_start < frames_num * 8) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -96,13 +96,13 @@ static bool zstd_read_seek_table(ZstdReader *zstd)
|
|||
return false;
|
||||
}
|
||||
|
||||
zstd->seek.num_frames = num_frames;
|
||||
zstd->seek.compressed_ofs = MEM_malloc_arrayN(num_frames + 1, sizeof(size_t), __func__);
|
||||
zstd->seek.uncompressed_ofs = MEM_malloc_arrayN(num_frames + 1, sizeof(size_t), __func__);
|
||||
zstd->seek.frames_num = frames_num;
|
||||
zstd->seek.compressed_ofs = MEM_malloc_arrayN(frames_num + 1, sizeof(size_t), __func__);
|
||||
zstd->seek.uncompressed_ofs = MEM_malloc_arrayN(frames_num + 1, sizeof(size_t), __func__);
|
||||
|
||||
size_t compressed_ofs = 0;
|
||||
size_t uncompressed_ofs = 0;
|
||||
for (int i = 0; i < num_frames; i++) {
|
||||
for (int i = 0; i < frames_num; i++) {
|
||||
uint32_t compressed_size, uncompressed_size;
|
||||
if (!zstd_read_u32(base, &compressed_size) || !zstd_read_u32(base, &uncompressed_size)) {
|
||||
break;
|
||||
|
|
@ -115,8 +115,8 @@ static bool zstd_read_seek_table(ZstdReader *zstd)
|
|||
compressed_ofs += compressed_size;
|
||||
uncompressed_ofs += uncompressed_size;
|
||||
}
|
||||
zstd->seek.compressed_ofs[num_frames] = compressed_ofs;
|
||||
zstd->seek.uncompressed_ofs[num_frames] = uncompressed_ofs;
|
||||
zstd->seek.compressed_ofs[frames_num] = compressed_ofs;
|
||||
zstd->seek.uncompressed_ofs[frames_num] = uncompressed_ofs;
|
||||
|
||||
/* Seek to the end of the previous frame for the following #BHead frame detection. */
|
||||
if (seek_frame_start != compressed_ofs || base->seek(base, seek_frame_start, SEEK_SET) < 0) {
|
||||
|
|
@ -135,9 +135,9 @@ static bool zstd_read_seek_table(ZstdReader *zstd)
|
|||
* Basically just bisection. */
|
||||
static int zstd_frame_from_pos(ZstdReader *zstd, size_t pos)
|
||||
{
|
||||
int low = 0, high = zstd->seek.num_frames;
|
||||
int low = 0, high = zstd->seek.frames_num;
|
||||
|
||||
if (pos >= zstd->seek.uncompressed_ofs[zstd->seek.num_frames]) {
|
||||
if (pos >= zstd->seek.uncompressed_ofs[zstd->seek.frames_num]) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -229,13 +229,13 @@ static off64_t zstd_seek(FileReader *reader, off64_t offset, int whence)
|
|||
new_pos = offset;
|
||||
}
|
||||
else if (whence == SEEK_END) {
|
||||
new_pos = zstd->seek.uncompressed_ofs[zstd->seek.num_frames] + offset;
|
||||
new_pos = zstd->seek.uncompressed_ofs[zstd->seek.frames_num] + offset;
|
||||
}
|
||||
else {
|
||||
new_pos = zstd->reader.offset + offset;
|
||||
}
|
||||
|
||||
if (new_pos < 0 || new_pos > zstd->seek.uncompressed_ofs[zstd->seek.num_frames]) {
|
||||
if (new_pos < 0 || new_pos > zstd->seek.uncompressed_ofs[zstd->seek.frames_num]) {
|
||||
return -1;
|
||||
}
|
||||
zstd->reader.offset = new_pos;
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ struct _GSQueue {
|
|||
size_t chunk_last_index; /* index into 'chunk_last' */
|
||||
size_t chunk_elem_max; /* number of elements per chunk */
|
||||
size_t elem_size; /* memory size of elements */
|
||||
size_t totelem; /* total number of elements */
|
||||
size_t elem_num; /* total number of elements */
|
||||
};
|
||||
|
||||
static void *queue_get_first_elem(GSQueue *queue)
|
||||
|
|
@ -97,7 +97,7 @@ void BLI_gsqueue_free(GSQueue *queue)
|
|||
void BLI_gsqueue_push(GSQueue *queue, const void *item)
|
||||
{
|
||||
queue->chunk_last_index++;
|
||||
queue->totelem++;
|
||||
queue->elem_num++;
|
||||
|
||||
if (UNLIKELY(queue->chunk_last_index == queue->chunk_elem_max)) {
|
||||
struct QueueChunk *chunk;
|
||||
|
|
@ -134,9 +134,9 @@ void BLI_gsqueue_pop(GSQueue *queue, void *r_item)
|
|||
|
||||
memcpy(r_item, queue_get_first_elem(queue), queue->elem_size);
|
||||
queue->chunk_first_index++;
|
||||
queue->totelem--;
|
||||
queue->elem_num--;
|
||||
|
||||
if (UNLIKELY(queue->chunk_first_index == queue->chunk_elem_max || queue->totelem == 0)) {
|
||||
if (UNLIKELY(queue->chunk_first_index == queue->chunk_elem_max || queue->elem_num == 0)) {
|
||||
struct QueueChunk *chunk_free = queue->chunk_first;
|
||||
|
||||
queue->chunk_first = queue->chunk_first->next;
|
||||
|
|
@ -153,7 +153,7 @@ void BLI_gsqueue_pop(GSQueue *queue, void *r_item)
|
|||
|
||||
size_t BLI_gsqueue_len(const GSQueue *queue)
|
||||
{
|
||||
return queue->totelem;
|
||||
return queue->elem_num;
|
||||
}
|
||||
|
||||
bool BLI_gsqueue_is_empty(const GSQueue *queue)
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ void BLI_jitterate2(float (*jit1)[2], float (*jit2)[2], int num, float radius2)
|
|||
void BLI_jitter_init(float (*jitarr)[2], int num)
|
||||
{
|
||||
float(*jit2)[2];
|
||||
float num_fl, num_fl_sqrt;
|
||||
float number_fl, number_fl_sqrt;
|
||||
float x, rad1, rad2, rad3;
|
||||
RNG *rng;
|
||||
int i;
|
||||
|
|
@ -135,20 +135,20 @@ void BLI_jitter_init(float (*jitarr)[2], int num)
|
|||
return;
|
||||
}
|
||||
|
||||
num_fl = (float)num;
|
||||
num_fl_sqrt = sqrtf(num_fl);
|
||||
number_fl = (float)num;
|
||||
number_fl_sqrt = sqrtf(number_fl);
|
||||
|
||||
jit2 = MEM_mallocN(12 + (unsigned int)num * sizeof(float[2]), "initjit");
|
||||
rad1 = 1.0f / num_fl_sqrt;
|
||||
rad2 = 1.0f / num_fl;
|
||||
rad3 = num_fl_sqrt / num_fl;
|
||||
rad1 = 1.0f / number_fl_sqrt;
|
||||
rad2 = 1.0f / number_fl;
|
||||
rad3 = number_fl_sqrt / number_fl;
|
||||
|
||||
rng = BLI_rng_new(31415926 + (unsigned int)num);
|
||||
|
||||
x = 0;
|
||||
for (i = 0; i < num; i++) {
|
||||
jitarr[i][0] = x + rad1 * (float)(0.5 - BLI_rng_get_double(rng));
|
||||
jitarr[i][1] = (float)i / num_fl + rad1 * (float)(0.5 - BLI_rng_get_double(rng));
|
||||
jitarr[i][1] = (float)i / number_fl + rad1 * (float)(0.5 - BLI_rng_get_double(rng));
|
||||
x += rad3;
|
||||
x -= floorf(x);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3404,7 +3404,7 @@ bool clip_segment_v3_plane(
|
|||
bool clip_segment_v3_plane_n(const float p1[3],
|
||||
const float p2[3],
|
||||
const float plane_array[][4],
|
||||
const int plane_tot,
|
||||
const int plane_num,
|
||||
float r_p1[3],
|
||||
float r_p2[3])
|
||||
{
|
||||
|
|
@ -3414,7 +3414,7 @@ bool clip_segment_v3_plane_n(const float p1[3],
|
|||
float dp[3];
|
||||
sub_v3_v3v3(dp, p2, p1);
|
||||
|
||||
for (int i = 0; i < plane_tot; i++) {
|
||||
for (int i = 0; i < plane_num; i++) {
|
||||
const float *plane = plane_array[i];
|
||||
const float div = dot_v3v3(dp, plane);
|
||||
|
||||
|
|
|
|||
|
|
@ -171,9 +171,9 @@ TriMeshTopology::TriMeshTopology(const IMesh &tm)
|
|||
/* If everything were manifold, `F+V-E=2` and `E=3F/2`.
|
||||
* So an likely overestimate, allowing for non-manifoldness, is `E=2F` and `V=F`. */
|
||||
const int estimate_num_edges = 2 * tm.face_size();
|
||||
const int estimate_num_verts = tm.face_size();
|
||||
const int estimate_verts_num = tm.face_size();
|
||||
edge_tri_.reserve(estimate_num_edges);
|
||||
vert_edges_.reserve(estimate_num_verts);
|
||||
vert_edges_.reserve(estimate_verts_num);
|
||||
for (int t : tm.face_index_range()) {
|
||||
const Face &tri = *tm.face(t);
|
||||
BLI_assert(tri.is_tri());
|
||||
|
|
@ -2607,18 +2607,18 @@ static void test_tri_inside_shapes(const IMesh &tm,
|
|||
* Perturb their directions slightly to make it less likely to hit a seam.
|
||||
* Ray-cast assumes they have unit length, so use r1 near 1 and
|
||||
* ra near 0.5, and rb near .01, but normalized so `sqrt(r1^2 + ra^2 + rb^2) == 1`. */
|
||||
constexpr int num_rays = 6;
|
||||
constexpr int rays_num = 6;
|
||||
constexpr float r1 = 0.9987025295199663f;
|
||||
constexpr float ra = 0.04993512647599832f;
|
||||
constexpr float rb = 0.009987025295199663f;
|
||||
const float test_rays[num_rays][3] = {
|
||||
const float test_rays[rays_num][3] = {
|
||||
{r1, ra, rb}, {-r1, -ra, -rb}, {rb, r1, ra}, {-rb, -r1, -ra}, {ra, rb, r1}, {-ra, -rb, -r1}};
|
||||
InsideShapeTestData data(tm, shape_fn, nshapes);
|
||||
data.hit_parity = Array<int>(nshapes, 0);
|
||||
Array<int> count_insides(nshapes, 0);
|
||||
const float co[3] = {
|
||||
float(offset_test_point[0]), float(offset_test_point[1]), float(offset_test_point[2])};
|
||||
for (int i = 0; i < num_rays; ++i) {
|
||||
for (int i = 0; i < rays_num; ++i) {
|
||||
if (dbg_level > 0) {
|
||||
std::cout << "shoot ray " << i << "(" << test_rays[i][0] << "," << test_rays[i][1] << ","
|
||||
<< test_rays[i][2] << ")\n";
|
||||
|
|
@ -2643,7 +2643,7 @@ static void test_tri_inside_shapes(const IMesh &tm,
|
|||
in_shape[j] = 1.0f; /* Let's say a shape is always inside itself. */
|
||||
}
|
||||
else {
|
||||
in_shape[j] = float(count_insides[j]) / float(num_rays);
|
||||
in_shape[j] = float(count_insides[j]) / float(rays_num);
|
||||
}
|
||||
if (dbg_level > 0) {
|
||||
std::cout << "shape " << j << " inside = " << in_shape[j] << "\n";
|
||||
|
|
@ -3400,19 +3400,19 @@ static void dissolve_verts(IMesh *imesh, const Array<bool> dissolve, IMeshArena
|
|||
for (int f : imesh->face_index_range()) {
|
||||
const Face &face = *imesh->face(f);
|
||||
face_pos_erase.clear();
|
||||
int num_erase = 0;
|
||||
int erase_num = 0;
|
||||
for (const Vert *v : face) {
|
||||
int v_index = imesh->lookup_vert(v);
|
||||
BLI_assert(v_index != NO_INDEX);
|
||||
if (dissolve[v_index]) {
|
||||
face_pos_erase.append(true);
|
||||
++num_erase;
|
||||
++erase_num;
|
||||
}
|
||||
else {
|
||||
face_pos_erase.append(false);
|
||||
}
|
||||
}
|
||||
if (num_erase > 0) {
|
||||
if (erase_num > 0) {
|
||||
any_faces_erased |= imesh->erase_face_positions(f, face_pos_erase, arena);
|
||||
}
|
||||
}
|
||||
|
|
@ -3475,8 +3475,8 @@ static IMesh polymesh_from_trimesh_with_dissolve(const IMesh &tm_out,
|
|||
if (dbg_level > 1) {
|
||||
std::cout << "merge tris for face " << in_f << "\n";
|
||||
}
|
||||
int num_out_tris_for_face = face_output_tris.size();
|
||||
if (num_out_tris_for_face == 0) {
|
||||
int out_tris_for_face_num = face_output_tris.size();
|
||||
if (out_tris_for_face_num == 0) {
|
||||
continue;
|
||||
}
|
||||
face_output_face[in_f] = merge_tris_for_face(face_output_tris[in_f], tm_out, imesh_in, arena);
|
||||
|
|
|
|||
|
|
@ -635,8 +635,8 @@ void IMesh::populate_vert()
|
|||
/* This is likely an overestimate, since verts are shared between
|
||||
* faces. It is ok if estimate is over or even under. */
|
||||
constexpr int ESTIMATE_VERTS_PER_FACE = 4;
|
||||
int estimate_num_verts = ESTIMATE_VERTS_PER_FACE * face_.size();
|
||||
populate_vert(estimate_num_verts);
|
||||
int estimate_verts_num = ESTIMATE_VERTS_PER_FACE * face_.size();
|
||||
populate_vert(estimate_verts_num);
|
||||
}
|
||||
|
||||
void IMesh::populate_vert(int max_verts)
|
||||
|
|
@ -693,16 +693,16 @@ bool IMesh::erase_face_positions(int f_index, Span<bool> face_pos_erase, IMeshAr
|
|||
{
|
||||
const Face *cur_f = this->face(f_index);
|
||||
int cur_len = cur_f->size();
|
||||
int num_to_erase = 0;
|
||||
int to_erase_num = 0;
|
||||
for (int i : cur_f->index_range()) {
|
||||
if (face_pos_erase[i]) {
|
||||
++num_to_erase;
|
||||
++to_erase_num;
|
||||
}
|
||||
}
|
||||
if (num_to_erase == 0) {
|
||||
if (to_erase_num == 0) {
|
||||
return false;
|
||||
}
|
||||
int new_len = cur_len - num_to_erase;
|
||||
int new_len = cur_len - to_erase_num;
|
||||
if (new_len < 3) {
|
||||
/* This erase causes removal of whole face.
|
||||
* Because this may be called from a loop over the face array,
|
||||
|
|
@ -2324,7 +2324,7 @@ class TriOverlaps {
|
|||
BVHTree *tree_b_{nullptr};
|
||||
BVHTreeOverlap *overlap_{nullptr};
|
||||
Array<int> first_overlap_;
|
||||
uint overlap_tot_{0};
|
||||
uint overlap_num_{0};
|
||||
|
||||
struct CBData {
|
||||
const IMesh &tm;
|
||||
|
|
@ -2386,16 +2386,16 @@ class TriOverlaps {
|
|||
if (two_trees_no_self) {
|
||||
BLI_bvhtree_balance(tree_b_);
|
||||
/* Don't expect a lot of trivial intersects in this case. */
|
||||
overlap_ = BLI_bvhtree_overlap(tree_, tree_b_, &overlap_tot_, nullptr, nullptr);
|
||||
overlap_ = BLI_bvhtree_overlap(tree_, tree_b_, &overlap_num_, nullptr, nullptr);
|
||||
}
|
||||
else {
|
||||
CBData cbdata{tm, shape_fn, nshapes, use_self};
|
||||
if (nshapes == 1) {
|
||||
overlap_ = BLI_bvhtree_overlap(tree_, tree_, &overlap_tot_, nullptr, nullptr);
|
||||
overlap_ = BLI_bvhtree_overlap(tree_, tree_, &overlap_num_, nullptr, nullptr);
|
||||
}
|
||||
else {
|
||||
overlap_ = BLI_bvhtree_overlap(
|
||||
tree_, tree_, &overlap_tot_, only_different_shapes, &cbdata);
|
||||
tree_, tree_, &overlap_num_, only_different_shapes, &cbdata);
|
||||
}
|
||||
}
|
||||
/* The rest of the code is simpler and easier to parallelize if, in the two-trees case,
|
||||
|
|
@ -2403,23 +2403,23 @@ class TriOverlaps {
|
|||
* in the repeated part, sorting will then bring things with indexB together. */
|
||||
if (two_trees_no_self) {
|
||||
overlap_ = static_cast<BVHTreeOverlap *>(
|
||||
MEM_reallocN(overlap_, 2 * overlap_tot_ * sizeof(overlap_[0])));
|
||||
for (uint i = 0; i < overlap_tot_; ++i) {
|
||||
overlap_[overlap_tot_ + i].indexA = overlap_[i].indexB;
|
||||
overlap_[overlap_tot_ + i].indexB = overlap_[i].indexA;
|
||||
MEM_reallocN(overlap_, 2 * overlap_num_ * sizeof(overlap_[0])));
|
||||
for (uint i = 0; i < overlap_num_; ++i) {
|
||||
overlap_[overlap_num_ + i].indexA = overlap_[i].indexB;
|
||||
overlap_[overlap_num_ + i].indexB = overlap_[i].indexA;
|
||||
}
|
||||
overlap_tot_ += overlap_tot_;
|
||||
overlap_num_ += overlap_num_;
|
||||
}
|
||||
/* Sort the overlaps to bring all the intersects with a given indexA together. */
|
||||
std::sort(overlap_, overlap_ + overlap_tot_, bvhtreeverlap_cmp);
|
||||
std::sort(overlap_, overlap_ + overlap_num_, bvhtreeverlap_cmp);
|
||||
if (dbg_level > 0) {
|
||||
std::cout << overlap_tot_ << " overlaps found:\n";
|
||||
std::cout << overlap_num_ << " overlaps found:\n";
|
||||
for (BVHTreeOverlap ov : overlap()) {
|
||||
std::cout << "A: " << ov.indexA << ", B: " << ov.indexB << "\n";
|
||||
}
|
||||
}
|
||||
first_overlap_ = Array<int>(tm.face_size(), -1);
|
||||
for (int i = 0; i < static_cast<int>(overlap_tot_); ++i) {
|
||||
for (int i = 0; i < static_cast<int>(overlap_num_); ++i) {
|
||||
int t = overlap_[i].indexA;
|
||||
if (first_overlap_[t] == -1) {
|
||||
first_overlap_[t] = i;
|
||||
|
|
@ -2442,7 +2442,7 @@ class TriOverlaps {
|
|||
|
||||
Span<BVHTreeOverlap> overlap() const
|
||||
{
|
||||
return Span<BVHTreeOverlap>(overlap_, overlap_tot_);
|
||||
return Span<BVHTreeOverlap>(overlap_, overlap_num_);
|
||||
}
|
||||
|
||||
int first_overlap_index(int t) const
|
||||
|
|
@ -2557,13 +2557,13 @@ static void calc_subdivided_non_cluster_tris(Array<IMesh> &r_tri_subdivided,
|
|||
int len;
|
||||
};
|
||||
Vector<OverlapTriRange> overlap_tri_range;
|
||||
int overlap_tot = overlap.size();
|
||||
overlap_tri_range.reserve(overlap_tot);
|
||||
int overlap_num = overlap.size();
|
||||
overlap_tri_range.reserve(overlap_num);
|
||||
int overlap_index = 0;
|
||||
while (overlap_index < overlap_tot) {
|
||||
while (overlap_index < overlap_num) {
|
||||
int t = overlap[overlap_index].indexA;
|
||||
int i = overlap_index;
|
||||
while (i + 1 < overlap_tot && overlap[i + 1].indexA == t) {
|
||||
while (i + 1 < overlap_num && overlap[i + 1].indexA == t) {
|
||||
++i;
|
||||
}
|
||||
/* Now overlap[overlap_index] to overlap[i] have indexA == t.
|
||||
|
|
@ -2581,8 +2581,8 @@ static void calc_subdivided_non_cluster_tris(Array<IMesh> &r_tri_subdivided,
|
|||
}
|
||||
overlap_index = i + 1;
|
||||
}
|
||||
int overlap_tri_range_tot = overlap_tri_range.size();
|
||||
Array<CDT_data> cd_data(overlap_tri_range_tot);
|
||||
int overlap_tri_range_num = overlap_tri_range.size();
|
||||
Array<CDT_data> cd_data(overlap_tri_range_num);
|
||||
int grain_size = 64;
|
||||
threading::parallel_for(overlap_tri_range.index_range(), grain_size, [&](IndexRange range) {
|
||||
for (int otr_index : range) {
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ static bool BLI_path_is_abs(const char *name);
|
|||
|
||||
/* implementation */
|
||||
|
||||
int BLI_path_sequence_decode(const char *string, char *head, char *tail, ushort *r_num_len)
|
||||
int BLI_path_sequence_decode(const char *string, char *head, char *tail, ushort *r_digits_len)
|
||||
{
|
||||
uint nums = 0, nume = 0;
|
||||
int i;
|
||||
|
|
@ -98,8 +98,8 @@ int BLI_path_sequence_decode(const char *string, char *head, char *tail, ushort
|
|||
strcpy(head, string);
|
||||
head[nums] = 0;
|
||||
}
|
||||
if (r_num_len) {
|
||||
*r_num_len = nume - nums + 1;
|
||||
if (r_digits_len) {
|
||||
*r_digits_len = nume - nums + 1;
|
||||
}
|
||||
return (int)ret;
|
||||
}
|
||||
|
|
@ -114,8 +114,8 @@ int BLI_path_sequence_decode(const char *string, char *head, char *tail, ushort
|
|||
*/
|
||||
BLI_strncpy(head, string, name_end + 1);
|
||||
}
|
||||
if (r_num_len) {
|
||||
*r_num_len = 0;
|
||||
if (r_digits_len) {
|
||||
*r_digits_len = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -750,14 +750,14 @@ bool BLI_path_frame_range(char *path, int sta, int end, int digits)
|
|||
return false;
|
||||
}
|
||||
|
||||
bool BLI_path_frame_get(char *path, int *r_frame, int *r_numdigits)
|
||||
bool BLI_path_frame_get(char *path, int *r_frame, int *r_digits_len)
|
||||
{
|
||||
if (*path) {
|
||||
char *file = (char *)BLI_path_slash_rfind(path);
|
||||
char *c;
|
||||
int len, numdigits;
|
||||
int len, digits_len;
|
||||
|
||||
numdigits = *r_numdigits = 0;
|
||||
digits_len = *r_digits_len = 0;
|
||||
|
||||
if (file == NULL) {
|
||||
file = path;
|
||||
|
|
@ -779,21 +779,21 @@ bool BLI_path_frame_get(char *path, int *r_frame, int *r_numdigits)
|
|||
/* find start of number */
|
||||
while (c != (file - 1) && isdigit(*c)) {
|
||||
c--;
|
||||
numdigits++;
|
||||
digits_len++;
|
||||
}
|
||||
|
||||
if (numdigits) {
|
||||
if (digits_len) {
|
||||
char prevchar;
|
||||
|
||||
c++;
|
||||
prevchar = c[numdigits];
|
||||
c[numdigits] = 0;
|
||||
prevchar = c[digits_len];
|
||||
c[digits_len] = 0;
|
||||
|
||||
/* was the number really an extension? */
|
||||
*r_frame = atoi(c);
|
||||
c[numdigits] = prevchar;
|
||||
c[digits_len] = prevchar;
|
||||
|
||||
*r_numdigits = numdigits;
|
||||
*r_digits_len = digits_len;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -812,7 +812,7 @@ void BLI_path_frame_strip(char *path, char *r_ext)
|
|||
char *file = (char *)BLI_path_slash_rfind(path);
|
||||
char *c, *suffix;
|
||||
int len;
|
||||
int numdigits = 0;
|
||||
int digits_len = 0;
|
||||
|
||||
if (file == NULL) {
|
||||
file = path;
|
||||
|
|
@ -836,7 +836,7 @@ void BLI_path_frame_strip(char *path, char *r_ext)
|
|||
/* find start of number */
|
||||
while (c != (file - 1) && isdigit(*c)) {
|
||||
c--;
|
||||
numdigits++;
|
||||
digits_len++;
|
||||
}
|
||||
|
||||
c++;
|
||||
|
|
@ -845,7 +845,7 @@ void BLI_path_frame_strip(char *path, char *r_ext)
|
|||
BLI_strncpy(r_ext, suffix, suffix_length + 1);
|
||||
|
||||
/* replace the number with the suffix and terminate the string */
|
||||
while (numdigits--) {
|
||||
while (digits_len--) {
|
||||
*c++ = '#';
|
||||
}
|
||||
*c = '\0';
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ struct KDTree2D {
|
|||
KDTreeNode2D *nodes;
|
||||
const float (*coords)[2];
|
||||
uint root;
|
||||
uint totnode;
|
||||
uint node_num;
|
||||
uint *nodes_map; /* index -> node lookup */
|
||||
};
|
||||
|
||||
|
|
@ -119,14 +119,14 @@ typedef struct PolyFill {
|
|||
struct PolyIndex *indices; /* vertex aligned */
|
||||
|
||||
const float (*coords)[2];
|
||||
uint coords_tot;
|
||||
uint coords_num;
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
uint coords_tot_concave;
|
||||
uint coords_num_concave;
|
||||
#endif
|
||||
|
||||
/* A polygon with n vertices has a triangulation of n-2 triangles. */
|
||||
uint (*tris)[3];
|
||||
uint tris_tot;
|
||||
uint tris_num;
|
||||
|
||||
#ifdef USE_KDTREE
|
||||
struct KDTree2D kdtree;
|
||||
|
|
@ -202,18 +202,18 @@ static void kdtree2d_new(struct KDTree2D *tree, uint tot, const float (*coords)[
|
|||
// tree->nodes = nodes;
|
||||
tree->coords = coords;
|
||||
tree->root = KDNODE_UNSET;
|
||||
tree->totnode = tot;
|
||||
tree->node_num = tot;
|
||||
}
|
||||
|
||||
/**
|
||||
* no need for kdtree2d_insert, since we know the coords array.
|
||||
*/
|
||||
static void kdtree2d_init(struct KDTree2D *tree, const uint coords_tot, const PolyIndex *indices)
|
||||
static void kdtree2d_init(struct KDTree2D *tree, const uint coords_num, const PolyIndex *indices)
|
||||
{
|
||||
KDTreeNode2D *node;
|
||||
uint i;
|
||||
|
||||
for (i = 0, node = tree->nodes; i < coords_tot; i++) {
|
||||
for (i = 0, node = tree->nodes; i < coords_num; i++) {
|
||||
if (indices[i].sign != CONVEX) {
|
||||
node->neg = node->pos = KDNODE_UNSET;
|
||||
node->index = indices[i].index;
|
||||
|
|
@ -223,26 +223,26 @@ static void kdtree2d_init(struct KDTree2D *tree, const uint coords_tot, const Po
|
|||
}
|
||||
}
|
||||
|
||||
BLI_assert(tree->totnode == (uint)(node - tree->nodes));
|
||||
BLI_assert(tree->node_num == (uint)(node - tree->nodes));
|
||||
}
|
||||
|
||||
static uint kdtree2d_balance_recursive(
|
||||
KDTreeNode2D *nodes, uint totnode, axis_t axis, const float (*coords)[2], const uint ofs)
|
||||
KDTreeNode2D *nodes, uint node_num, axis_t axis, const float (*coords)[2], const uint ofs)
|
||||
{
|
||||
KDTreeNode2D *node;
|
||||
uint neg, pos, median, i, j;
|
||||
|
||||
if (totnode <= 0) {
|
||||
if (node_num <= 0) {
|
||||
return KDNODE_UNSET;
|
||||
}
|
||||
if (totnode == 1) {
|
||||
if (node_num == 1) {
|
||||
return 0 + ofs;
|
||||
}
|
||||
|
||||
/* Quick-sort style sorting around median. */
|
||||
neg = 0;
|
||||
pos = totnode - 1;
|
||||
median = totnode / 2;
|
||||
pos = node_num - 1;
|
||||
median = node_num / 2;
|
||||
|
||||
while (pos > neg) {
|
||||
const float co = coords[nodes[pos].index][axis];
|
||||
|
|
@ -276,14 +276,14 @@ static uint kdtree2d_balance_recursive(
|
|||
axis = !axis;
|
||||
node->neg = kdtree2d_balance_recursive(nodes, median, axis, coords, ofs);
|
||||
node->pos = kdtree2d_balance_recursive(
|
||||
&nodes[median + 1], (totnode - (median + 1)), axis, coords, (median + 1) + ofs);
|
||||
&nodes[median + 1], (node_num - (median + 1)), axis, coords, (median + 1) + ofs);
|
||||
|
||||
return median + ofs;
|
||||
}
|
||||
|
||||
static void kdtree2d_balance(struct KDTree2D *tree)
|
||||
{
|
||||
tree->root = kdtree2d_balance_recursive(tree->nodes, tree->totnode, 0, tree->coords, 0);
|
||||
tree->root = kdtree2d_balance_recursive(tree->nodes, tree->node_num, 0, tree->coords, 0);
|
||||
}
|
||||
|
||||
static void kdtree2d_init_mapping(struct KDTree2D *tree)
|
||||
|
|
@ -291,7 +291,7 @@ static void kdtree2d_init_mapping(struct KDTree2D *tree)
|
|||
uint i;
|
||||
KDTreeNode2D *node;
|
||||
|
||||
for (i = 0, node = tree->nodes; i < tree->totnode; i++, node++) {
|
||||
for (i = 0, node = tree->nodes; i < tree->node_num; i++, node++) {
|
||||
if (node->neg != KDNODE_UNSET) {
|
||||
tree->nodes[node->neg].parent = i;
|
||||
}
|
||||
|
|
@ -319,7 +319,7 @@ static void kdtree2d_node_remove(struct KDTree2D *tree, uint index)
|
|||
tree->nodes_map[index] = KDNODE_UNSET;
|
||||
|
||||
node = &tree->nodes[node_index];
|
||||
tree->totnode -= 1;
|
||||
tree->node_num -= 1;
|
||||
|
||||
BLI_assert((node->flag & KDNODE_FLAG_REMOVED) == 0);
|
||||
node->flag |= KDNODE_FLAG_REMOVED;
|
||||
|
|
@ -435,14 +435,14 @@ static bool kdtree2d_isect_tri(struct KDTree2D *tree, const uint ind[3])
|
|||
|
||||
static uint *pf_tri_add(PolyFill *pf)
|
||||
{
|
||||
return pf->tris[pf->tris_tot++];
|
||||
return pf->tris[pf->tris_num++];
|
||||
}
|
||||
|
||||
static void pf_coord_remove(PolyFill *pf, PolyIndex *pi)
|
||||
{
|
||||
#ifdef USE_KDTREE
|
||||
/* avoid double lookups, since convex coords are ignored when testing intersections */
|
||||
if (pf->kdtree.totnode) {
|
||||
if (pf->kdtree.node_num) {
|
||||
kdtree2d_node_remove(&pf->kdtree, pi->index);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -458,7 +458,7 @@ static void pf_coord_remove(PolyFill *pf, PolyIndex *pi)
|
|||
pi->next = pi->prev = NULL;
|
||||
#endif
|
||||
|
||||
pf->coords_tot -= 1;
|
||||
pf->coords_num -= 1;
|
||||
}
|
||||
|
||||
static void pf_triangulate(PolyFill *pf)
|
||||
|
|
@ -473,7 +473,7 @@ static void pf_triangulate(PolyFill *pf)
|
|||
bool reverse = false;
|
||||
#endif
|
||||
|
||||
while (pf->coords_tot > 3) {
|
||||
while (pf->coords_num > 3) {
|
||||
PolyIndex *pi_prev, *pi_next;
|
||||
eSign sign_orig_prev, sign_orig_next;
|
||||
|
||||
|
|
@ -490,7 +490,7 @@ static void pf_triangulate(PolyFill *pf)
|
|||
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
if (pi_ear->sign != CONVEX) {
|
||||
pf->coords_tot_concave -= 1;
|
||||
pf->coords_num_concave -= 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -509,7 +509,7 @@ static void pf_triangulate(PolyFill *pf)
|
|||
pf_coord_sign_calc(pf, pi_prev);
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
if (pi_prev->sign == CONVEX) {
|
||||
pf->coords_tot_concave -= 1;
|
||||
pf->coords_num_concave -= 1;
|
||||
# ifdef USE_KDTREE
|
||||
kdtree2d_node_remove(&pf->kdtree, pi_prev->index);
|
||||
# endif
|
||||
|
|
@ -520,7 +520,7 @@ static void pf_triangulate(PolyFill *pf)
|
|||
pf_coord_sign_calc(pf, pi_next);
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
if (pi_next->sign == CONVEX) {
|
||||
pf->coords_tot_concave -= 1;
|
||||
pf->coords_num_concave -= 1;
|
||||
# ifdef USE_KDTREE
|
||||
kdtree2d_node_remove(&pf->kdtree, pi_next->index);
|
||||
# endif
|
||||
|
|
@ -551,7 +551,7 @@ static void pf_triangulate(PolyFill *pf)
|
|||
#endif
|
||||
}
|
||||
|
||||
if (pf->coords_tot == 3) {
|
||||
if (pf->coords_num == 3) {
|
||||
uint *tri = pf_tri_add(pf);
|
||||
pi_ear = pf->indices;
|
||||
tri[0] = pi_ear->index;
|
||||
|
|
@ -585,7 +585,7 @@ static PolyIndex *pf_ear_tip_find(PolyFill *pf
|
|||
)
|
||||
{
|
||||
/* localize */
|
||||
const uint coords_tot = pf->coords_tot;
|
||||
const uint coords_num = pf->coords_num;
|
||||
PolyIndex *pi_ear;
|
||||
|
||||
uint i;
|
||||
|
|
@ -596,7 +596,7 @@ static PolyIndex *pf_ear_tip_find(PolyFill *pf
|
|||
pi_ear = pf->indices;
|
||||
#endif
|
||||
|
||||
i = coords_tot;
|
||||
i = coords_num;
|
||||
while (i--) {
|
||||
if (pf_ear_tip_check(pf, pi_ear)) {
|
||||
return pi_ear;
|
||||
|
|
@ -626,7 +626,7 @@ static PolyIndex *pf_ear_tip_find(PolyFill *pf
|
|||
pi_ear = pf->indices;
|
||||
#endif
|
||||
|
||||
i = coords_tot;
|
||||
i = coords_num;
|
||||
while (i--) {
|
||||
if (pi_ear->sign != CONCAVE) {
|
||||
return pi_ear;
|
||||
|
|
@ -649,7 +649,7 @@ static bool pf_ear_tip_check(PolyFill *pf, PolyIndex *pi_ear_tip)
|
|||
#endif
|
||||
|
||||
#if defined(USE_CONVEX_SKIP) && !defined(USE_KDTREE)
|
||||
uint coords_tot_concave_checked = 0;
|
||||
uint coords_num_concave_checked = 0;
|
||||
#endif
|
||||
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
|
|
@ -657,19 +657,19 @@ static bool pf_ear_tip_check(PolyFill *pf, PolyIndex *pi_ear_tip)
|
|||
# ifdef USE_CONVEX_SKIP_TEST
|
||||
/* check if counting is wrong */
|
||||
{
|
||||
uint coords_tot_concave_test = 0;
|
||||
uint coords_num_concave_test = 0;
|
||||
PolyIndex *pi_iter = pi_ear_tip;
|
||||
do {
|
||||
if (pi_iter->sign != CONVEX) {
|
||||
coords_tot_concave_test += 1;
|
||||
coords_num_concave_test += 1;
|
||||
}
|
||||
} while ((pi_iter = pi_iter->next) != pi_ear_tip);
|
||||
BLI_assert(coords_tot_concave_test == pf->coords_tot_concave);
|
||||
BLI_assert(coords_num_concave_test == pf->coords_num_concave);
|
||||
}
|
||||
# endif
|
||||
|
||||
/* fast-path for circles */
|
||||
if (pf->coords_tot_concave == 0) {
|
||||
if (pf->coords_num_concave == 0) {
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -715,8 +715,8 @@ static bool pf_ear_tip_check(PolyFill *pf, PolyIndex *pi_ear_tip)
|
|||
}
|
||||
|
||||
# ifdef USE_CONVEX_SKIP
|
||||
coords_tot_concave_checked += 1;
|
||||
if (coords_tot_concave_checked == pf->coords_tot_concave) {
|
||||
coords_num_concave_checked += 1;
|
||||
if (coords_num_concave_checked == pf->coords_num_concave) {
|
||||
break;
|
||||
}
|
||||
# endif
|
||||
|
|
@ -743,7 +743,7 @@ static void pf_ear_tip_cut(PolyFill *pf, PolyIndex *pi_ear_tip)
|
|||
*/
|
||||
static void polyfill_prepare(PolyFill *pf,
|
||||
const float (*coords)[2],
|
||||
const uint coords_tot,
|
||||
const uint coords_num,
|
||||
int coords_sign,
|
||||
uint (*r_tris)[3],
|
||||
PolyIndex *r_indices)
|
||||
|
|
@ -756,32 +756,32 @@ static void polyfill_prepare(PolyFill *pf,
|
|||
/* assign all polyfill members here */
|
||||
pf->indices = r_indices;
|
||||
pf->coords = coords;
|
||||
pf->coords_tot = coords_tot;
|
||||
pf->coords_num = coords_num;
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
pf->coords_tot_concave = 0;
|
||||
pf->coords_num_concave = 0;
|
||||
#endif
|
||||
pf->tris = r_tris;
|
||||
pf->tris_tot = 0;
|
||||
pf->tris_num = 0;
|
||||
|
||||
if (coords_sign == 0) {
|
||||
coords_sign = (cross_poly_v2(coords, coords_tot) >= 0.0f) ? 1 : -1;
|
||||
coords_sign = (cross_poly_v2(coords, coords_num) >= 0.0f) ? 1 : -1;
|
||||
}
|
||||
else {
|
||||
/* check we're passing in correct args */
|
||||
#ifdef USE_STRICT_ASSERT
|
||||
# ifndef NDEBUG
|
||||
if (coords_sign == 1) {
|
||||
BLI_assert(cross_poly_v2(coords, coords_tot) >= 0.0f);
|
||||
BLI_assert(cross_poly_v2(coords, coords_num) >= 0.0f);
|
||||
}
|
||||
else {
|
||||
BLI_assert(cross_poly_v2(coords, coords_tot) <= 0.0f);
|
||||
BLI_assert(cross_poly_v2(coords, coords_num) <= 0.0f);
|
||||
}
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
if (coords_sign == 1) {
|
||||
for (i = 0; i < coords_tot; i++) {
|
||||
for (i = 0; i < coords_num; i++) {
|
||||
indices[i].next = &indices[i + 1];
|
||||
indices[i].prev = &indices[i - 1];
|
||||
indices[i].index = i;
|
||||
|
|
@ -789,22 +789,22 @@ static void polyfill_prepare(PolyFill *pf,
|
|||
}
|
||||
else {
|
||||
/* reversed */
|
||||
uint n = coords_tot - 1;
|
||||
for (i = 0; i < coords_tot; i++) {
|
||||
uint n = coords_num - 1;
|
||||
for (i = 0; i < coords_num; i++) {
|
||||
indices[i].next = &indices[i + 1];
|
||||
indices[i].prev = &indices[i - 1];
|
||||
indices[i].index = (n - i);
|
||||
}
|
||||
}
|
||||
indices[0].prev = &indices[coords_tot - 1];
|
||||
indices[coords_tot - 1].next = &indices[0];
|
||||
indices[0].prev = &indices[coords_num - 1];
|
||||
indices[coords_num - 1].next = &indices[0];
|
||||
|
||||
for (i = 0; i < coords_tot; i++) {
|
||||
for (i = 0; i < coords_num; i++) {
|
||||
PolyIndex *pi = &indices[i];
|
||||
pf_coord_sign_calc(pf, pi);
|
||||
#ifdef USE_CONVEX_SKIP
|
||||
if (pi->sign != CONVEX) {
|
||||
pf->coords_tot_concave += 1;
|
||||
pf->coords_num_concave += 1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -814,11 +814,11 @@ static void polyfill_calc(PolyFill *pf)
|
|||
{
|
||||
#ifdef USE_KDTREE
|
||||
# ifdef USE_CONVEX_SKIP
|
||||
if (pf->coords_tot_concave)
|
||||
if (pf->coords_num_concave)
|
||||
# endif
|
||||
{
|
||||
kdtree2d_new(&pf->kdtree, pf->coords_tot_concave, pf->coords);
|
||||
kdtree2d_init(&pf->kdtree, pf->coords_tot, pf->indices);
|
||||
kdtree2d_new(&pf->kdtree, pf->coords_num_concave, pf->coords);
|
||||
kdtree2d_init(&pf->kdtree, pf->coords_num, pf->indices);
|
||||
kdtree2d_balance(&pf->kdtree);
|
||||
kdtree2d_init_mapping(&pf->kdtree);
|
||||
}
|
||||
|
|
@ -828,14 +828,14 @@ static void polyfill_calc(PolyFill *pf)
|
|||
}
|
||||
|
||||
void BLI_polyfill_calc_arena(const float (*coords)[2],
|
||||
const uint coords_tot,
|
||||
const uint coords_num,
|
||||
const int coords_sign,
|
||||
uint (*r_tris)[3],
|
||||
|
||||
struct MemArena *arena)
|
||||
{
|
||||
PolyFill pf;
|
||||
PolyIndex *indices = BLI_memarena_alloc(arena, sizeof(*indices) * coords_tot);
|
||||
PolyIndex *indices = BLI_memarena_alloc(arena, sizeof(*indices) * coords_num);
|
||||
|
||||
#ifdef DEBUG_TIME
|
||||
TIMEIT_START(polyfill2d);
|
||||
|
|
@ -843,22 +843,22 @@ void BLI_polyfill_calc_arena(const float (*coords)[2],
|
|||
|
||||
polyfill_prepare(&pf,
|
||||
coords,
|
||||
coords_tot,
|
||||
coords_num,
|
||||
coords_sign,
|
||||
r_tris,
|
||||
/* cache */
|
||||
indices);
|
||||
|
||||
#ifdef USE_KDTREE
|
||||
if (pf.coords_tot_concave) {
|
||||
pf.kdtree.nodes = BLI_memarena_alloc(arena, sizeof(*pf.kdtree.nodes) * pf.coords_tot_concave);
|
||||
if (pf.coords_num_concave) {
|
||||
pf.kdtree.nodes = BLI_memarena_alloc(arena, sizeof(*pf.kdtree.nodes) * pf.coords_num_concave);
|
||||
pf.kdtree.nodes_map = memset(
|
||||
BLI_memarena_alloc(arena, sizeof(*pf.kdtree.nodes_map) * coords_tot),
|
||||
BLI_memarena_alloc(arena, sizeof(*pf.kdtree.nodes_map) * coords_num),
|
||||
0xff,
|
||||
sizeof(*pf.kdtree.nodes_map) * coords_tot);
|
||||
sizeof(*pf.kdtree.nodes_map) * coords_num);
|
||||
}
|
||||
else {
|
||||
pf.kdtree.totnode = 0;
|
||||
pf.kdtree.node_num = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -873,25 +873,25 @@ void BLI_polyfill_calc_arena(const float (*coords)[2],
|
|||
}
|
||||
|
||||
void BLI_polyfill_calc(const float (*coords)[2],
|
||||
const uint coords_tot,
|
||||
const uint coords_num,
|
||||
const int coords_sign,
|
||||
uint (*r_tris)[3])
|
||||
{
|
||||
/* Fallback to heap memory for large allocations.
|
||||
* Avoid running out of stack memory on systems with 512kb stack (macOS).
|
||||
* This happens at around 13,000 points, use a much lower value to be safe. */
|
||||
if (UNLIKELY(coords_tot > 8192)) {
|
||||
if (UNLIKELY(coords_num > 8192)) {
|
||||
/* The buffer size only accounts for the index allocation,
|
||||
* worst case we do two allocations when concave, while we should try to be efficient,
|
||||
* any caller that relies on this frequently should use #BLI_polyfill_calc_arena directly. */
|
||||
MemArena *arena = BLI_memarena_new(sizeof(PolyIndex) * coords_tot, __func__);
|
||||
BLI_polyfill_calc_arena(coords, coords_tot, coords_sign, r_tris, arena);
|
||||
MemArena *arena = BLI_memarena_new(sizeof(PolyIndex) * coords_num, __func__);
|
||||
BLI_polyfill_calc_arena(coords, coords_num, coords_sign, r_tris, arena);
|
||||
BLI_memarena_free(arena);
|
||||
return;
|
||||
}
|
||||
|
||||
PolyFill pf;
|
||||
PolyIndex *indices = BLI_array_alloca(indices, coords_tot);
|
||||
PolyIndex *indices = BLI_array_alloca(indices, coords_num);
|
||||
|
||||
#ifdef DEBUG_TIME
|
||||
TIMEIT_START(polyfill2d);
|
||||
|
|
@ -899,21 +899,21 @@ void BLI_polyfill_calc(const float (*coords)[2],
|
|||
|
||||
polyfill_prepare(&pf,
|
||||
coords,
|
||||
coords_tot,
|
||||
coords_num,
|
||||
coords_sign,
|
||||
r_tris,
|
||||
/* cache */
|
||||
indices);
|
||||
|
||||
#ifdef USE_KDTREE
|
||||
if (pf.coords_tot_concave) {
|
||||
pf.kdtree.nodes = BLI_array_alloca(pf.kdtree.nodes, pf.coords_tot_concave);
|
||||
pf.kdtree.nodes_map = memset(BLI_array_alloca(pf.kdtree.nodes_map, coords_tot),
|
||||
if (pf.coords_num_concave) {
|
||||
pf.kdtree.nodes = BLI_array_alloca(pf.kdtree.nodes, pf.coords_num_concave);
|
||||
pf.kdtree.nodes_map = memset(BLI_array_alloca(pf.kdtree.nodes_map, coords_num),
|
||||
0xff,
|
||||
sizeof(*pf.kdtree.nodes_map) * coords_tot);
|
||||
sizeof(*pf.kdtree.nodes_map) * coords_num);
|
||||
}
|
||||
else {
|
||||
pf.kdtree.totnode = 0;
|
||||
pf.kdtree.node_num = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -288,15 +288,15 @@ static void polyedge_rotate(struct HalfEdge *edges, struct HalfEdge *e)
|
|||
}
|
||||
|
||||
void BLI_polyfill_beautify(const float (*coords)[2],
|
||||
const uint coords_tot,
|
||||
const uint coords_num,
|
||||
uint (*tris)[3],
|
||||
|
||||
/* structs for reuse */
|
||||
MemArena *arena,
|
||||
Heap *eheap)
|
||||
{
|
||||
const uint coord_last = coords_tot - 1;
|
||||
const uint tris_len = coords_tot - 2;
|
||||
const uint coord_last = coords_num - 1;
|
||||
const uint tris_len = coords_num - 2;
|
||||
/* internal edges only (between 2 tris) */
|
||||
const uint edges_len = tris_len - 1;
|
||||
|
||||
|
|
|
|||
|
|
@ -117,18 +117,18 @@ void BLI_rng_get_tri_sample_float_v3(
|
|||
copy_v3_v3(r_pt, rng->rng.get_triangle_sample_3d(v1, v2, v3));
|
||||
}
|
||||
|
||||
void BLI_rng_shuffle_array(RNG *rng, void *data, unsigned int elem_size_i, unsigned int elem_tot)
|
||||
void BLI_rng_shuffle_array(RNG *rng, void *data, unsigned int elem_size_i, unsigned int elem_num)
|
||||
{
|
||||
if (elem_tot <= 1) {
|
||||
if (elem_num <= 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
const uint elem_size = elem_size_i;
|
||||
unsigned int i = elem_tot;
|
||||
unsigned int i = elem_num;
|
||||
void *temp = malloc(elem_size);
|
||||
|
||||
while (i--) {
|
||||
const unsigned int j = BLI_rng_get_uint(rng) % elem_tot;
|
||||
const unsigned int j = BLI_rng_get_uint(rng) % elem_num;
|
||||
if (i != j) {
|
||||
void *iElem = (unsigned char *)data + i * elem_size_i;
|
||||
void *jElem = (unsigned char *)data + j * elem_size_i;
|
||||
|
|
@ -141,15 +141,15 @@ void BLI_rng_shuffle_array(RNG *rng, void *data, unsigned int elem_size_i, unsig
|
|||
free(temp);
|
||||
}
|
||||
|
||||
void BLI_rng_shuffle_bitmap(struct RNG *rng, BLI_bitmap *bitmap, unsigned int bits_tot)
|
||||
void BLI_rng_shuffle_bitmap(struct RNG *rng, BLI_bitmap *bitmap, unsigned int bits_num)
|
||||
{
|
||||
if (bits_tot <= 1) {
|
||||
if (bits_num <= 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int i = bits_tot;
|
||||
unsigned int i = bits_num;
|
||||
while (i--) {
|
||||
const unsigned int j = BLI_rng_get_uint(rng) % bits_tot;
|
||||
const unsigned int j = BLI_rng_get_uint(rng) % bits_num;
|
||||
if (i != j) {
|
||||
const bool i_bit = BLI_BITMAP_TEST(bitmap, i);
|
||||
const bool j_bit = BLI_BITMAP_TEST(bitmap, j);
|
||||
|
|
@ -187,21 +187,21 @@ float BLI_hash_frand(unsigned int seed)
|
|||
|
||||
void BLI_array_randomize(void *data,
|
||||
unsigned int elem_size,
|
||||
unsigned int elem_tot,
|
||||
unsigned int elem_num,
|
||||
unsigned int seed)
|
||||
{
|
||||
RNG rng;
|
||||
|
||||
BLI_rng_seed(&rng, seed);
|
||||
BLI_rng_shuffle_array(&rng, data, elem_size, elem_tot);
|
||||
BLI_rng_shuffle_array(&rng, data, elem_size, elem_num);
|
||||
}
|
||||
|
||||
void BLI_bitmap_randomize(BLI_bitmap *bitmap, unsigned int bits_tot, unsigned int seed)
|
||||
void BLI_bitmap_randomize(BLI_bitmap *bitmap, unsigned int bits_num, unsigned int seed)
|
||||
{
|
||||
RNG rng;
|
||||
|
||||
BLI_rng_seed(&rng, seed);
|
||||
BLI_rng_shuffle_bitmap(&rng, bitmap, bits_tot);
|
||||
BLI_rng_shuffle_bitmap(&rng, bitmap, bits_num);
|
||||
}
|
||||
|
||||
/* ********* for threaded random ************** */
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ ScanFillVert *BLI_scanfill_vert_add(ScanFillContext *sf_ctx, const float vec[3])
|
|||
zero_v2(sf_v->xy);
|
||||
sf_v->keyindex = 0;
|
||||
sf_v->poly_nr = sf_ctx->poly_nr;
|
||||
sf_v->edge_tot = 0;
|
||||
sf_v->edge_count = 0;
|
||||
sf_v->f = SF_VERT_NEW;
|
||||
sf_v->user_flag = 0;
|
||||
|
||||
|
|
@ -373,14 +373,14 @@ static bool boundinsideEV(ScanFillEdge *eed, ScanFillVert *eve)
|
|||
|
||||
static void testvertexnearedge(ScanFillContext *sf_ctx)
|
||||
{
|
||||
/* only vertices with (->edge_tot == 1) are being tested for
|
||||
/* only vertices with (->edge_count == 1) are being tested for
|
||||
* being close to an edge, if true insert */
|
||||
|
||||
ScanFillVert *eve;
|
||||
ScanFillEdge *eed, *ed1;
|
||||
|
||||
for (eve = sf_ctx->fillvertbase.first; eve; eve = eve->next) {
|
||||
if (eve->edge_tot == 1) {
|
||||
if (eve->edge_count == 1) {
|
||||
/* find the edge which has vertex eve,
|
||||
* NOTE: we _know_ this will crash if 'ed1' becomes NULL
|
||||
* but this will never happen. */
|
||||
|
|
@ -398,14 +398,14 @@ static void testvertexnearedge(ScanFillContext *sf_ctx)
|
|||
if (eve != eed->v1 && eve != eed->v2 && eve->poly_nr == eed->poly_nr) {
|
||||
if (compare_v2v2(eve->xy, eed->v1->xy, SF_EPSILON)) {
|
||||
ed1->v2 = eed->v1;
|
||||
eed->v1->edge_tot++;
|
||||
eve->edge_tot = 0;
|
||||
eed->v1->edge_count++;
|
||||
eve->edge_count = 0;
|
||||
break;
|
||||
}
|
||||
if (compare_v2v2(eve->xy, eed->v2->xy, SF_EPSILON)) {
|
||||
ed1->v2 = eed->v2;
|
||||
eed->v2->edge_tot++;
|
||||
eve->edge_tot = 0;
|
||||
eed->v2->edge_count++;
|
||||
eve->edge_count = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -418,7 +418,7 @@ static void testvertexnearedge(ScanFillContext *sf_ctx)
|
|||
// printf("fill: vertex near edge %x\n", eve);
|
||||
ed1->poly_nr = eed->poly_nr;
|
||||
eed->v1 = eve;
|
||||
eve->edge_tot = 3;
|
||||
eve->edge_count = 3;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -597,14 +597,14 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
|
|||
/* Set connect-flags. */
|
||||
for (ed1 = sc->edge_first; ed1; ed1 = eed_next) {
|
||||
eed_next = ed1->next;
|
||||
if (ed1->v1->edge_tot == 1 || ed1->v2->edge_tot == 1) {
|
||||
if (ed1->v1->edge_count == 1 || ed1->v2->edge_count == 1) {
|
||||
BLI_remlink((ListBase *)&(sc->edge_first), ed1);
|
||||
BLI_addtail(&sf_ctx->filledgebase, ed1);
|
||||
if (ed1->v1->edge_tot > 1) {
|
||||
ed1->v1->edge_tot--;
|
||||
if (ed1->v1->edge_count > 1) {
|
||||
ed1->v1->edge_count--;
|
||||
}
|
||||
if (ed1->v2->edge_tot > 1) {
|
||||
ed1->v2->edge_tot--;
|
||||
if (ed1->v2->edge_count > 1) {
|
||||
ed1->v2->edge_count--;
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -628,8 +628,8 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
|
|||
// printf("just 1 edge to vert\n");
|
||||
BLI_addtail(&sf_ctx->filledgebase, ed1);
|
||||
ed1->v2->f = SF_VERT_NEW;
|
||||
ed1->v1->edge_tot--;
|
||||
ed1->v2->edge_tot--;
|
||||
ed1->v1->edge_count--;
|
||||
ed1->v2->edge_count--;
|
||||
}
|
||||
else {
|
||||
/* test rest of vertices */
|
||||
|
|
@ -697,8 +697,8 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
|
|||
BLI_insertlinkbefore((ListBase *)&(sc->edge_first), ed2, ed3);
|
||||
ed3->v2->f = SF_VERT_AVAILABLE;
|
||||
ed3->f = SF_EDGE_INTERNAL;
|
||||
ed3->v1->edge_tot++;
|
||||
ed3->v2->edge_tot++;
|
||||
ed3->v1->edge_count++;
|
||||
ed3->v2->edge_count++;
|
||||
}
|
||||
else {
|
||||
/* new triangle */
|
||||
|
|
@ -708,39 +708,39 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
|
|||
BLI_remlink((ListBase *)&(sc->edge_first), ed1);
|
||||
BLI_addtail(&sf_ctx->filledgebase, ed1);
|
||||
ed1->v2->f = SF_VERT_NEW;
|
||||
ed1->v1->edge_tot--;
|
||||
ed1->v2->edge_tot--;
|
||||
ed1->v1->edge_count--;
|
||||
ed1->v2->edge_count--;
|
||||
/* ed2 can be removed when it's a boundary edge */
|
||||
if (((ed2->f == SF_EDGE_NEW) && twoconnected) /* || (ed2->f == SF_EDGE_BOUNDARY) */) {
|
||||
BLI_remlink((ListBase *)&(sc->edge_first), ed2);
|
||||
BLI_addtail(&sf_ctx->filledgebase, ed2);
|
||||
ed2->v2->f = SF_VERT_NEW;
|
||||
ed2->v1->edge_tot--;
|
||||
ed2->v2->edge_tot--;
|
||||
ed2->v1->edge_count--;
|
||||
ed2->v2->edge_count--;
|
||||
}
|
||||
|
||||
/* new edge */
|
||||
ed3 = BLI_scanfill_edge_add(sf_ctx, v1, v3);
|
||||
BLI_remlink(&sf_ctx->filledgebase, ed3);
|
||||
ed3->f = SF_EDGE_INTERNAL;
|
||||
ed3->v1->edge_tot++;
|
||||
ed3->v2->edge_tot++;
|
||||
ed3->v1->edge_count++;
|
||||
ed3->v2->edge_count++;
|
||||
|
||||
// printf("add new edge %x %x\n", v1, v3);
|
||||
sc1 = addedgetoscanlist(scdata, ed3, verts);
|
||||
|
||||
if (sc1) { /* ed3 already exists: remove if a boundary */
|
||||
// printf("Edge exists\n");
|
||||
ed3->v1->edge_tot--;
|
||||
ed3->v2->edge_tot--;
|
||||
ed3->v1->edge_count--;
|
||||
ed3->v2->edge_count--;
|
||||
|
||||
for (ed3 = sc1->edge_first; ed3; ed3 = ed3->next) {
|
||||
if ((ed3->v1 == v1 && ed3->v2 == v3) || (ed3->v1 == v3 && ed3->v2 == v1)) {
|
||||
if (twoconnected /* || (ed3->f == SF_EDGE_BOUNDARY) */) {
|
||||
BLI_remlink((ListBase *)&(sc1->edge_first), ed3);
|
||||
BLI_addtail(&sf_ctx->filledgebase, ed3);
|
||||
ed3->v1->edge_tot--;
|
||||
ed3->v2->edge_tot--;
|
||||
ed3->v1->edge_count--;
|
||||
ed3->v2->edge_count--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -752,14 +752,14 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
|
|||
/* test for loose edges */
|
||||
for (ed1 = sc->edge_first; ed1; ed1 = eed_next) {
|
||||
eed_next = ed1->next;
|
||||
if (ed1->v1->edge_tot < 2 || ed1->v2->edge_tot < 2) {
|
||||
if (ed1->v1->edge_count < 2 || ed1->v2->edge_count < 2) {
|
||||
BLI_remlink((ListBase *)&(sc->edge_first), ed1);
|
||||
BLI_addtail(&sf_ctx->filledgebase, ed1);
|
||||
if (ed1->v1->edge_tot > 1) {
|
||||
ed1->v1->edge_tot--;
|
||||
if (ed1->v1->edge_count > 1) {
|
||||
ed1->v1->edge_count--;
|
||||
}
|
||||
if (ed1->v2->edge_tot > 1) {
|
||||
ed1->v2->edge_tot--;
|
||||
if (ed1->v2->edge_count > 1) {
|
||||
ed1->v2->edge_count--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -838,7 +838,7 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
* however they should always be zero'd so check instead */
|
||||
BLI_assert(eve->f == 0);
|
||||
BLI_assert(sf_ctx->poly_nr || eve->poly_nr == 0);
|
||||
BLI_assert(eve->edge_tot == 0);
|
||||
BLI_assert(eve->edge_count == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -964,10 +964,10 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
if (flag & BLI_SCANFILL_CALC_LOOSE) {
|
||||
unsigned int toggle = 0;
|
||||
for (eed = sf_ctx->filledgebase.first; eed; eed = eed->next) {
|
||||
if (eed->v1->edge_tot++ > 250) {
|
||||
if (eed->v1->edge_count++ > 250) {
|
||||
break;
|
||||
}
|
||||
if (eed->v2->edge_tot++ > 250) {
|
||||
if (eed->v2->edge_count++ > 250) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -979,7 +979,7 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* does it only for vertices with (->edge_tot == 1) */
|
||||
/* does it only for vertices with (->edge_count == 1) */
|
||||
testvertexnearedge(sf_ctx);
|
||||
|
||||
ok = true;
|
||||
|
|
@ -990,14 +990,14 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
for (eed = (toggle & 1) ? sf_ctx->filledgebase.first : sf_ctx->filledgebase.last; eed;
|
||||
eed = eed_next) {
|
||||
eed_next = (toggle & 1) ? eed->next : eed->prev;
|
||||
if (eed->v1->edge_tot == 1) {
|
||||
eed->v2->edge_tot--;
|
||||
if (eed->v1->edge_count == 1) {
|
||||
eed->v2->edge_count--;
|
||||
BLI_remlink(&sf_ctx->fillvertbase, eed->v1);
|
||||
BLI_remlink(&sf_ctx->filledgebase, eed);
|
||||
ok = true;
|
||||
}
|
||||
else if (eed->v2->edge_tot == 1) {
|
||||
eed->v1->edge_tot--;
|
||||
else if (eed->v2->edge_count == 1) {
|
||||
eed->v1->edge_count--;
|
||||
BLI_remlink(&sf_ctx->fillvertbase, eed->v2);
|
||||
BLI_remlink(&sf_ctx->filledgebase, eed);
|
||||
ok = true;
|
||||
|
|
@ -1012,14 +1012,14 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
else {
|
||||
/* skip checks for loose edges */
|
||||
for (eed = sf_ctx->filledgebase.first; eed; eed = eed->next) {
|
||||
eed->v1->edge_tot++;
|
||||
eed->v2->edge_tot++;
|
||||
eed->v1->edge_count++;
|
||||
eed->v2->edge_count++;
|
||||
}
|
||||
#ifdef DEBUG
|
||||
/* ensure we're right! */
|
||||
for (eed = sf_ctx->filledgebase.first; eed; eed = eed->next) {
|
||||
BLI_assert(eed->v1->edge_tot != 1);
|
||||
BLI_assert(eed->v2->edge_tot != 1);
|
||||
BLI_assert(eed->v1->edge_count != 1);
|
||||
BLI_assert(eed->v2->edge_count != 1);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -1027,7 +1027,7 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
/* CURRENT STATUS:
|
||||
* - `eve->f`: 1 = available in edges.
|
||||
* - `eve->poly_nr`: poly-number.
|
||||
* - `eve->edge_tot`: amount of edges connected to vertex.
|
||||
* - `eve->edge_count`: amount of edges connected to vertex.
|
||||
* - `eve->tmp.v`: store! original vertex number.
|
||||
*
|
||||
* - `eed->f`: 1 = boundary edge (optionally set by caller).
|
||||
|
|
@ -1058,7 +1058,7 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
|
|||
min_xy_p[1] = (min_xy_p[1]) < (eve->xy[1]) ? (min_xy_p[1]) : (eve->xy[1]);
|
||||
max_xy_p[0] = (max_xy_p[0]) > (eve->xy[0]) ? (max_xy_p[0]) : (eve->xy[0]);
|
||||
max_xy_p[1] = (max_xy_p[1]) > (eve->xy[1]) ? (max_xy_p[1]) : (eve->xy[1]);
|
||||
if (eve->edge_tot > 2) {
|
||||
if (eve->edge_count > 2) {
|
||||
pflist[eve->poly_nr].f = SF_POLY_VALID;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -359,7 +359,7 @@ bool BLI_scanfill_calc_self_isect(ScanFillContext *sf_ctx,
|
|||
ListBase *remvertbase,
|
||||
ListBase *remedgebase)
|
||||
{
|
||||
const unsigned int poly_tot = (unsigned int)sf_ctx->poly_nr + 1;
|
||||
const unsigned int poly_num = (unsigned int)sf_ctx->poly_nr + 1;
|
||||
unsigned int eed_index = 0;
|
||||
int totvert_new = 0;
|
||||
bool changed = false;
|
||||
|
|
@ -370,7 +370,7 @@ bool BLI_scanfill_calc_self_isect(ScanFillContext *sf_ctx,
|
|||
return false;
|
||||
}
|
||||
|
||||
poly_info = MEM_callocN(sizeof(*poly_info) * poly_tot, __func__);
|
||||
poly_info = MEM_callocN(sizeof(*poly_info) * poly_num, __func__);
|
||||
|
||||
/* get the polygon span */
|
||||
if (sf_ctx->poly_nr == 0) {
|
||||
|
|
@ -408,7 +408,7 @@ bool BLI_scanfill_calc_self_isect(ScanFillContext *sf_ctx,
|
|||
/* self-intersect each polygon */
|
||||
{
|
||||
unsigned short poly_nr;
|
||||
for (poly_nr = 0; poly_nr < poly_tot; poly_nr++) {
|
||||
for (poly_nr = 0; poly_nr < poly_num; poly_nr++) {
|
||||
changed |= scanfill_preprocess_self_isect(sf_ctx, poly_info, poly_nr, remedgebase);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ struct BLI_Stack {
|
|||
size_t chunk_elem_max; /* number of elements per chunk */
|
||||
size_t elem_size;
|
||||
#ifdef USE_TOTELEM
|
||||
size_t totelem;
|
||||
size_t elem_num;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -119,7 +119,7 @@ void *BLI_stack_push_r(BLI_Stack *stack)
|
|||
BLI_assert(stack->chunk_index < stack->chunk_elem_max);
|
||||
|
||||
#ifdef USE_TOTELEM
|
||||
stack->totelem++;
|
||||
stack->elem_num++;
|
||||
#endif
|
||||
|
||||
/* Return end of stack */
|
||||
|
|
@ -175,7 +175,7 @@ void BLI_stack_discard(BLI_Stack *stack)
|
|||
BLI_assert(BLI_stack_is_empty(stack) == false);
|
||||
|
||||
#ifdef USE_TOTELEM
|
||||
stack->totelem--;
|
||||
stack->elem_num--;
|
||||
#endif
|
||||
if (UNLIKELY(--stack->chunk_index == CHUNK_EMPTY)) {
|
||||
struct StackChunk *chunk_free;
|
||||
|
|
@ -193,10 +193,10 @@ void BLI_stack_discard(BLI_Stack *stack)
|
|||
void BLI_stack_clear(BLI_Stack *stack)
|
||||
{
|
||||
#ifdef USE_TOTELEM
|
||||
if (UNLIKELY(stack->totelem == 0)) {
|
||||
if (UNLIKELY(stack->elem_num == 0)) {
|
||||
return;
|
||||
}
|
||||
stack->totelem = 0;
|
||||
stack->elem_num = 0;
|
||||
#else
|
||||
if (UNLIKELY(stack->chunk_curr == NULL)) {
|
||||
return;
|
||||
|
|
@ -225,29 +225,29 @@ void BLI_stack_clear(BLI_Stack *stack)
|
|||
size_t BLI_stack_count(const BLI_Stack *stack)
|
||||
{
|
||||
#ifdef USE_TOTELEM
|
||||
return stack->totelem;
|
||||
return stack->elem_num;
|
||||
#else
|
||||
struct StackChunk *data = stack->chunk_curr;
|
||||
size_t totelem = stack->chunk_index + 1;
|
||||
size_t elem_num = stack->chunk_index + 1;
|
||||
size_t i;
|
||||
if (totelem != stack->chunk_elem_max) {
|
||||
if (elem_num != stack->chunk_elem_max) {
|
||||
data = data->next;
|
||||
}
|
||||
else {
|
||||
totelem = 0;
|
||||
elem_num = 0;
|
||||
}
|
||||
for (i = 0; data; data = data->next) {
|
||||
i++;
|
||||
}
|
||||
totelem += stack->chunk_elem_max * i;
|
||||
return totelem;
|
||||
elem_num += stack->chunk_elem_max * i;
|
||||
return elem_num;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool BLI_stack_is_empty(const BLI_Stack *stack)
|
||||
{
|
||||
#ifdef USE_TOTELEM
|
||||
BLI_assert((stack->chunk_curr == NULL) == (stack->totelem == 0));
|
||||
BLI_assert((stack->chunk_curr == NULL) == (stack->elem_num == 0));
|
||||
#endif
|
||||
return (stack->chunk_curr == NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1131,11 +1131,11 @@ void BLI_str_format_byte_unit(char dst[15], long long int bytes, const bool base
|
|||
const int base = base_10 ? 1000 : 1024;
|
||||
const char *units_base_10[] = {"B", "KB", "MB", "GB", "TB", "PB"};
|
||||
const char *units_base_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB"};
|
||||
const int tot_units = ARRAY_SIZE(units_base_2);
|
||||
const int units_num = ARRAY_SIZE(units_base_2);
|
||||
|
||||
BLI_STATIC_ASSERT(ARRAY_SIZE(units_base_2) == ARRAY_SIZE(units_base_10), "array size mismatch");
|
||||
|
||||
while ((fabs(bytes_converted) >= base) && ((order + 1) < tot_units)) {
|
||||
while ((fabs(bytes_converted) >= base) && ((order + 1) < units_num)) {
|
||||
bytes_converted /= base;
|
||||
order++;
|
||||
}
|
||||
|
|
@ -1155,9 +1155,9 @@ void BLI_str_format_attribute_domain_size(char dst[7], int number_to_format)
|
|||
int order = 0;
|
||||
const float base = 1000;
|
||||
const char *units[] = {"", "K", "M", "B"};
|
||||
const int tot_units = ARRAY_SIZE(units);
|
||||
const int units_num = ARRAY_SIZE(units);
|
||||
|
||||
while ((fabsf(number_to_format_converted) >= base) && ((order + 1) < tot_units)) {
|
||||
while ((fabsf(number_to_format_converted) >= base) && ((order + 1) < units_num)) {
|
||||
number_to_format_converted /= base;
|
||||
order++;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,8 +40,8 @@
|
|||
* \{ */
|
||||
|
||||
BLI_INLINE void task_parallel_calc_chunk_size(const TaskParallelSettings *settings,
|
||||
const int tot_items,
|
||||
int num_tasks,
|
||||
const int items_num,
|
||||
int tasks_num,
|
||||
int *r_chunk_size)
|
||||
{
|
||||
int chunk_size = 0;
|
||||
|
|
@ -50,7 +50,7 @@ BLI_INLINE void task_parallel_calc_chunk_size(const TaskParallelSettings *settin
|
|||
/* Some users of this helper will still need a valid chunk size in case processing is not
|
||||
* threaded. We can use a bigger one than in default threaded case then. */
|
||||
chunk_size = 1024;
|
||||
num_tasks = 1;
|
||||
tasks_num = 1;
|
||||
}
|
||||
else if (settings->min_iter_per_thread > 0) {
|
||||
/* Already set by user, no need to do anything here. */
|
||||
|
|
@ -61,24 +61,24 @@ BLI_INLINE void task_parallel_calc_chunk_size(const TaskParallelSettings *settin
|
|||
* The idea here is to increase the chunk size to compensate for a rather measurable threading
|
||||
* overhead caused by fetching tasks. With too many CPU threads we are starting
|
||||
* to spend too much time in those overheads.
|
||||
* First values are: 1 if num_tasks < 16;
|
||||
* else 2 if num_tasks < 32;
|
||||
* else 3 if num_tasks < 48;
|
||||
* else 4 if num_tasks < 64;
|
||||
* First values are: 1 if tasks_num < 16;
|
||||
* else 2 if tasks_num < 32;
|
||||
* else 3 if tasks_num < 48;
|
||||
* else 4 if tasks_num < 64;
|
||||
* etc.
|
||||
* NOTE: If we wanted to keep the 'power of two' multiplier, we'd need something like:
|
||||
* 1 << max_ii(0, (int)(sizeof(int) * 8) - 1 - bitscan_reverse_i(num_tasks) - 3)
|
||||
* 1 << max_ii(0, (int)(sizeof(int) * 8) - 1 - bitscan_reverse_i(tasks_num) - 3)
|
||||
*/
|
||||
const int num_tasks_factor = max_ii(1, num_tasks >> 3);
|
||||
const int tasks_num_factor = max_ii(1, tasks_num >> 3);
|
||||
|
||||
/* We could make that 'base' 32 number configurable in TaskParallelSettings too, or maybe just
|
||||
* always use that heuristic using TaskParallelSettings.min_iter_per_thread as basis? */
|
||||
chunk_size = 32 * num_tasks_factor;
|
||||
chunk_size = 32 * tasks_num_factor;
|
||||
|
||||
/* Basic heuristic to avoid threading on low amount of items.
|
||||
* We could make that limit configurable in settings too. */
|
||||
if (tot_items > 0 && tot_items < max_ii(256, chunk_size * 2)) {
|
||||
chunk_size = tot_items;
|
||||
if (items_num > 0 && items_num < max_ii(256, chunk_size * 2)) {
|
||||
chunk_size = items_num;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -95,7 +95,7 @@ typedef struct TaskParallelIteratorState {
|
|||
/* Common data also passed to the generator callback. */
|
||||
TaskParallelIteratorStateShared iter_shared;
|
||||
/* Total number of items. If unknown, set it to a negative number. */
|
||||
int tot_items;
|
||||
int items_num;
|
||||
} TaskParallelIteratorState;
|
||||
|
||||
static void parallel_iterator_func_do(TaskParallelIteratorState *__restrict state,
|
||||
|
|
@ -188,10 +188,10 @@ static void task_parallel_iterator_no_threads(const TaskParallelSettings *settin
|
|||
static void task_parallel_iterator_do(const TaskParallelSettings *settings,
|
||||
TaskParallelIteratorState *state)
|
||||
{
|
||||
const int num_threads = BLI_task_scheduler_num_threads();
|
||||
const int threads_num = BLI_task_scheduler_num_threads();
|
||||
|
||||
task_parallel_calc_chunk_size(
|
||||
settings, state->tot_items, num_threads, &state->iter_shared.chunk_size);
|
||||
settings, state->items_num, threads_num, &state->iter_shared.chunk_size);
|
||||
|
||||
if (!settings->use_threading) {
|
||||
task_parallel_iterator_no_threads(settings, state);
|
||||
|
|
@ -199,13 +199,13 @@ static void task_parallel_iterator_do(const TaskParallelSettings *settings,
|
|||
}
|
||||
|
||||
const int chunk_size = state->iter_shared.chunk_size;
|
||||
const int tot_items = state->tot_items;
|
||||
const size_t num_tasks = tot_items >= 0 ?
|
||||
(size_t)min_ii(num_threads, state->tot_items / chunk_size) :
|
||||
(size_t)num_threads;
|
||||
const int items_num = state->items_num;
|
||||
const size_t tasks_num = items_num >= 0 ?
|
||||
(size_t)min_ii(threads_num, state->items_num / chunk_size) :
|
||||
(size_t)threads_num;
|
||||
|
||||
BLI_assert(num_tasks > 0);
|
||||
if (num_tasks == 1) {
|
||||
BLI_assert(tasks_num > 0);
|
||||
if (tasks_num == 1) {
|
||||
task_parallel_iterator_no_threads(settings, state);
|
||||
return;
|
||||
}
|
||||
|
|
@ -223,10 +223,10 @@ static void task_parallel_iterator_do(const TaskParallelSettings *settings,
|
|||
TaskPool *task_pool = BLI_task_pool_create(state, TASK_PRIORITY_HIGH);
|
||||
|
||||
if (use_userdata_chunk) {
|
||||
userdata_chunk_array = MALLOCA(userdata_chunk_size * num_tasks);
|
||||
userdata_chunk_array = MALLOCA(userdata_chunk_size * tasks_num);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < num_tasks; i++) {
|
||||
for (size_t i = 0; i < tasks_num; i++) {
|
||||
if (use_userdata_chunk) {
|
||||
userdata_chunk_local = (char *)userdata_chunk_array + (userdata_chunk_size * i);
|
||||
memcpy(userdata_chunk_local, userdata_chunk, userdata_chunk_size);
|
||||
|
|
@ -243,7 +243,7 @@ static void task_parallel_iterator_do(const TaskParallelSettings *settings,
|
|||
|
||||
if (use_userdata_chunk) {
|
||||
if (settings->func_reduce != NULL || settings->func_free != NULL) {
|
||||
for (size_t i = 0; i < num_tasks; i++) {
|
||||
for (size_t i = 0; i < tasks_num; i++) {
|
||||
userdata_chunk_local = (char *)userdata_chunk_array + (userdata_chunk_size * i);
|
||||
if (settings->func_reduce != NULL) {
|
||||
settings->func_reduce(state->userdata, userdata_chunk, userdata_chunk_local);
|
||||
|
|
@ -253,7 +253,7 @@ static void task_parallel_iterator_do(const TaskParallelSettings *settings,
|
|||
}
|
||||
}
|
||||
}
|
||||
MALLOCA_FREE(userdata_chunk_array, userdata_chunk_size * num_tasks);
|
||||
MALLOCA_FREE(userdata_chunk_array, userdata_chunk_size * tasks_num);
|
||||
}
|
||||
|
||||
BLI_spin_end(&spin_lock);
|
||||
|
|
@ -264,13 +264,13 @@ void BLI_task_parallel_iterator(void *userdata,
|
|||
TaskParallelIteratorIterFunc iter_func,
|
||||
void *init_item,
|
||||
const int init_index,
|
||||
const int tot_items,
|
||||
const int items_num,
|
||||
TaskParallelIteratorFunc func,
|
||||
const TaskParallelSettings *settings)
|
||||
{
|
||||
TaskParallelIteratorState state = {0};
|
||||
|
||||
state.tot_items = tot_items;
|
||||
state.items_num = items_num;
|
||||
state.iter_shared.next_index = init_index;
|
||||
state.iter_shared.next_item = init_item;
|
||||
state.iter_shared.is_finished = false;
|
||||
|
|
@ -314,7 +314,7 @@ void BLI_task_parallel_listbase(ListBase *listbase,
|
|||
|
||||
TaskParallelIteratorState state = {0};
|
||||
|
||||
state.tot_items = BLI_listbase_count(listbase);
|
||||
state.items_num = BLI_listbase_count(listbase);
|
||||
state.iter_shared.next_index = 0;
|
||||
state.iter_shared.next_item = listbase->first;
|
||||
state.iter_shared.is_finished = false;
|
||||
|
|
@ -391,25 +391,25 @@ void BLI_task_parallel_mempool(BLI_mempool *mempool,
|
|||
|
||||
ParallelMempoolState state;
|
||||
TaskPool *task_pool = BLI_task_pool_create(&state, TASK_PRIORITY_HIGH);
|
||||
const int num_threads = BLI_task_scheduler_num_threads();
|
||||
const int threads_num = BLI_task_scheduler_num_threads();
|
||||
|
||||
/* The idea here is to prevent creating task for each of the loop iterations
|
||||
* and instead have tasks which are evenly distributed across CPU cores and
|
||||
* pull next item to be crunched using the threaded-aware BLI_mempool_iter.
|
||||
*/
|
||||
const int num_tasks = num_threads + 2;
|
||||
const int tasks_num = threads_num + 2;
|
||||
|
||||
state.userdata = userdata;
|
||||
state.func = func;
|
||||
|
||||
if (use_userdata_chunk) {
|
||||
userdata_chunk_array = MALLOCA(userdata_chunk_size * num_tasks);
|
||||
userdata_chunk_array = MALLOCA(userdata_chunk_size * tasks_num);
|
||||
}
|
||||
|
||||
ParallelMempoolTaskData *mempool_iterator_data = mempool_iter_threadsafe_create(
|
||||
mempool, (size_t)num_tasks);
|
||||
mempool, (size_t)tasks_num);
|
||||
|
||||
for (int i = 0; i < num_tasks; i++) {
|
||||
for (int i = 0; i < tasks_num; i++) {
|
||||
void *userdata_chunk_local = NULL;
|
||||
if (use_userdata_chunk) {
|
||||
userdata_chunk_local = (char *)userdata_chunk_array + (userdata_chunk_size * i);
|
||||
|
|
@ -429,7 +429,7 @@ void BLI_task_parallel_mempool(BLI_mempool *mempool,
|
|||
|
||||
if (use_userdata_chunk) {
|
||||
if ((settings->func_free != NULL) || (settings->func_reduce != NULL)) {
|
||||
for (int i = 0; i < num_tasks; i++) {
|
||||
for (int i = 0; i < tasks_num; i++) {
|
||||
if (settings->func_reduce) {
|
||||
settings->func_reduce(
|
||||
userdata, userdata_chunk, mempool_iterator_data[i].tls.userdata_chunk);
|
||||
|
|
@ -439,7 +439,7 @@ void BLI_task_parallel_mempool(BLI_mempool *mempool,
|
|||
}
|
||||
}
|
||||
}
|
||||
MALLOCA_FREE(userdata_chunk_array, userdata_chunk_size * num_tasks);
|
||||
MALLOCA_FREE(userdata_chunk_array, userdata_chunk_size * tasks_num);
|
||||
}
|
||||
|
||||
mempool_iter_threadsafe_destroy(mempool_iterator_data);
|
||||
|
|
|
|||
|
|
@ -31,14 +31,14 @@ static tbb::global_control *task_scheduler_global_control = nullptr;
|
|||
void BLI_task_scheduler_init()
|
||||
{
|
||||
#ifdef WITH_TBB_GLOBAL_CONTROL
|
||||
const int num_threads_override = BLI_system_num_threads_override_get();
|
||||
const int threads_override_num = BLI_system_num_threads_override_get();
|
||||
|
||||
if (num_threads_override > 0) {
|
||||
if (threads_override_num > 0) {
|
||||
/* Override number of threads. This settings is used within the lifetime
|
||||
* of tbb::global_control, so we allocate it on the heap. */
|
||||
task_scheduler_global_control = MEM_new<tbb::global_control>(
|
||||
__func__, tbb::global_control::max_allowed_parallelism, num_threads_override);
|
||||
task_scheduler_num_threads = num_threads_override;
|
||||
__func__, tbb::global_control::max_allowed_parallelism, threads_override_num);
|
||||
task_scheduler_num_threads = threads_override_num;
|
||||
}
|
||||
else {
|
||||
/* Let TBB choose the number of threads. For (legacy) code that calls
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ static pthread_mutex_t _fftw_lock = PTHREAD_MUTEX_INITIALIZER;
|
|||
static pthread_mutex_t _view3d_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_t mainid;
|
||||
static unsigned int thread_levels = 0; /* threads can be invoked inside threads */
|
||||
static int num_threads_override = 0;
|
||||
static int threads_override_num = 0;
|
||||
|
||||
/* just a max for security reasons */
|
||||
#define RE_MAX_THREAD BLENDER_MAX_THREADS
|
||||
|
|
@ -282,8 +282,8 @@ int BLI_system_thread_count()
|
|||
{
|
||||
static int t = -1;
|
||||
|
||||
if (num_threads_override != 0) {
|
||||
return num_threads_override;
|
||||
if (threads_override_num != 0) {
|
||||
return threads_override_num;
|
||||
}
|
||||
if (LIKELY(t != -1)) {
|
||||
return t;
|
||||
|
|
@ -316,12 +316,12 @@ int BLI_system_thread_count()
|
|||
|
||||
void BLI_system_num_threads_override_set(int num)
|
||||
{
|
||||
num_threads_override = num;
|
||||
threads_override_num = num;
|
||||
}
|
||||
|
||||
int BLI_system_num_threads_override_get()
|
||||
{
|
||||
return num_threads_override;
|
||||
return threads_override_num;
|
||||
}
|
||||
|
||||
/* Global Mutex Locks */
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ void BLI_uuid_format(char *buffer, const bUUID uuid)
|
|||
|
||||
bool BLI_uuid_parse_string(bUUID *uuid, const char *buffer)
|
||||
{
|
||||
const int num_fields_parsed = std::sscanf(
|
||||
const int fields_parsed_num = std::sscanf(
|
||||
buffer,
|
||||
"%8x-%4hx-%4hx-%2hhx%2hhx-%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx",
|
||||
&uuid->time_low,
|
||||
|
|
@ -116,7 +116,7 @@ bool BLI_uuid_parse_string(bUUID *uuid, const char *buffer)
|
|||
&uuid->node[3],
|
||||
&uuid->node[4],
|
||||
&uuid->node[5]);
|
||||
return num_fields_parsed == 11;
|
||||
return fields_parsed_num == 11;
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &stream, bUUID uuid)
|
||||
|
|
|
|||
|
|
@ -1788,7 +1788,7 @@ TEST(delaunay_d, CintTwoFaceNoIds)
|
|||
#if DO_TEXT_TESTS
|
||||
template<typename T>
|
||||
void text_test(
|
||||
int num_arc_points, int num_lets_per_line, int num_lines, CDT_output_type otype, bool need_ids)
|
||||
int arc_points_num, int lets_per_line_num, int lines_num, CDT_output_type otype, bool need_ids)
|
||||
{
|
||||
constexpr bool print_timing = true;
|
||||
/*
|
||||
|
|
@ -1810,7 +1810,7 @@ void text_test(
|
|||
*
|
||||
* Where the numbers are the first 13 vertices, and the rest of
|
||||
* the vertices are in arcs a0, a1, a2, a3, each of which have
|
||||
* num_arc_points per arc in them.
|
||||
* arc_points_num per arc in them.
|
||||
*/
|
||||
|
||||
const char *b_before_arcs = R"(13 0 3
|
||||
|
|
@ -1834,13 +1834,13 @@ void text_test(
|
|||
|
||||
CDT_input<T> b_before_arcs_in = fill_input_from_string<T>(b_before_arcs);
|
||||
constexpr int narcs = 4;
|
||||
int b_npts = b_before_arcs_in.vert.size() + narcs * num_arc_points;
|
||||
int b_npts = b_before_arcs_in.vert.size() + narcs * arc_points_num;
|
||||
constexpr int b_nfaces = 3;
|
||||
Array<vec2<T>> b_vert(b_npts);
|
||||
Array<Vector<int>> b_face(b_nfaces);
|
||||
std::copy(b_before_arcs_in.vert.begin(), b_before_arcs_in.vert.end(), b_vert.begin());
|
||||
std::copy(b_before_arcs_in.face.begin(), b_before_arcs_in.face.end(), b_face.begin());
|
||||
if (num_arc_points > 0) {
|
||||
if (arc_points_num > 0) {
|
||||
b_face[0].pop_last(); /* We'll add center point back between arcs for outer face. */
|
||||
for (int arc = 0; arc < narcs; ++arc) {
|
||||
int arc_origin_vert;
|
||||
|
|
@ -1875,10 +1875,10 @@ void text_test(
|
|||
vec2<T> center_co = 0.5 * (start_co + end_co);
|
||||
BLI_assert(start_co[0] == end_co[0]);
|
||||
double radius = abs(math_to_double<T>(end_co[1] - center_co[1]));
|
||||
double angle_delta = M_PI / (num_arc_points + 1);
|
||||
int start_vert = b_before_arcs_in.vert.size() + arc * num_arc_points;
|
||||
double angle_delta = M_PI / (arc_points_num + 1);
|
||||
int start_vert = b_before_arcs_in.vert.size() + arc * arc_points_num;
|
||||
Vector<int> &face = b_face[(arc <= 1) ? 0 : arc - 1];
|
||||
for (int i = 0; i < num_arc_points; ++i) {
|
||||
for (int i = 0; i < arc_points_num; ++i) {
|
||||
vec2<T> delta;
|
||||
float ang = ccw ? (-M_PI_2 + (i + 1) * angle_delta) : (M_PI_2 - (i + 1) * angle_delta);
|
||||
delta[0] = T(radius * cos(ang));
|
||||
|
|
@ -1893,7 +1893,7 @@ void text_test(
|
|||
}
|
||||
|
||||
CDT_input<T> in;
|
||||
int tot_instances = num_lets_per_line * num_lines;
|
||||
int tot_instances = lets_per_line_num * lines_num;
|
||||
if (tot_instances == 1) {
|
||||
in.vert = b_vert;
|
||||
in.face = b_face;
|
||||
|
|
@ -1906,8 +1906,8 @@ void text_test(
|
|||
T delta_x = T(2);
|
||||
T delta_y = T(3.25);
|
||||
int instance = 0;
|
||||
for (int line = 0; line < num_lines; ++line) {
|
||||
for (int let = 0; let < num_lets_per_line; ++let) {
|
||||
for (int line = 0; line < lines_num; ++line) {
|
||||
for (int let = 0; let < lets_per_line_num; ++let) {
|
||||
vec2<T> co_offset(cur_x, cur_y);
|
||||
int in_v_offset = instance * b_vert.size();
|
||||
for (int v = 0; v < b_vert.size(); ++v) {
|
||||
|
|
@ -1940,12 +1940,12 @@ void text_test(
|
|||
EXPECT_EQ(out.face_orig.size(), 0);
|
||||
}
|
||||
if (DO_DRAW) {
|
||||
std::string label = "Text arcpts=" + std::to_string(num_arc_points);
|
||||
if (num_lets_per_line > 1) {
|
||||
label += " linelen=" + std::to_string(num_lets_per_line);
|
||||
std::string label = "Text arcpts=" + std::to_string(arc_points_num);
|
||||
if (lets_per_line_num > 1) {
|
||||
label += " linelen=" + std::to_string(lets_per_line_num);
|
||||
}
|
||||
if (num_lines > 1) {
|
||||
label += " lines=" + std::to_string(num_lines);
|
||||
if (lines_num > 1) {
|
||||
label += " lines=" + std::to_string(lines_num);
|
||||
}
|
||||
if (!need_ids) {
|
||||
label += " no_ids";
|
||||
|
|
|
|||
|
|
@ -32,9 +32,9 @@ TEST(LockfreeLinkList, InsertSingle)
|
|||
|
||||
TEST(LockfreeLinkList, InsertMultiple)
|
||||
{
|
||||
static const int num_nodes = 128;
|
||||
static const int nodes_num = 128;
|
||||
LockfreeLinkList list;
|
||||
LockfreeLinkNode nodes[num_nodes];
|
||||
LockfreeLinkNode nodes[nodes_num];
|
||||
BLI_linklist_lockfree_init(&list);
|
||||
/* Insert all the nodes. */
|
||||
for (LockfreeLinkNode &node : nodes) {
|
||||
|
|
@ -42,13 +42,13 @@ TEST(LockfreeLinkList, InsertMultiple)
|
|||
}
|
||||
/* Check head and tail. */
|
||||
EXPECT_EQ(list.head, &list.dummy_node);
|
||||
EXPECT_EQ(list.tail, &nodes[num_nodes - 1]);
|
||||
EXPECT_EQ(list.tail, &nodes[nodes_num - 1]);
|
||||
/* Check rest of the nodes. */
|
||||
int node_index = 0;
|
||||
for (LockfreeLinkNode *node = BLI_linklist_lockfree_begin(&list); node != nullptr;
|
||||
node = node->next, ++node_index) {
|
||||
EXPECT_EQ(node, &nodes[node_index]);
|
||||
if (node_index != num_nodes - 1) {
|
||||
if (node_index != nodes_num - 1) {
|
||||
EXPECT_EQ(node->next, &nodes[node_index + 1]);
|
||||
}
|
||||
}
|
||||
|
|
@ -76,32 +76,32 @@ void concurrent_insert(TaskPool *__restrict pool, void *taskdata)
|
|||
|
||||
TEST(LockfreeLinkList, InsertMultipleConcurrent)
|
||||
{
|
||||
static const int num_nodes = 655360;
|
||||
static const int nodes_num = 655360;
|
||||
/* Initialize list. */
|
||||
LockfreeLinkList list;
|
||||
BLI_linklist_lockfree_init(&list);
|
||||
/* Initialize task scheduler and pool. */
|
||||
TaskPool *pool = BLI_task_pool_create_suspended(&list, TASK_PRIORITY_HIGH);
|
||||
/* Push tasks to the pool. */
|
||||
for (int i = 0; i < num_nodes; ++i) {
|
||||
for (int i = 0; i < nodes_num; ++i) {
|
||||
BLI_task_pool_push(pool, concurrent_insert, POINTER_FROM_INT(i), false, nullptr);
|
||||
}
|
||||
/* Run all the tasks. */
|
||||
BLI_task_pool_work_and_wait(pool);
|
||||
/* Verify we've got all the data properly inserted. */
|
||||
EXPECT_EQ(list.head, &list.dummy_node);
|
||||
bool *visited_nodes = (bool *)MEM_callocN(sizeof(bool) * num_nodes, "visited nodes");
|
||||
bool *visited_nodes = (bool *)MEM_callocN(sizeof(bool) * nodes_num, "visited nodes");
|
||||
/* First, we make sure that none of the nodes are added twice. */
|
||||
for (LockfreeLinkNode *node_v = BLI_linklist_lockfree_begin(&list); node_v != nullptr;
|
||||
node_v = node_v->next) {
|
||||
IndexedNode *node = (IndexedNode *)node_v;
|
||||
EXPECT_GE(node->index, 0);
|
||||
EXPECT_LT(node->index, num_nodes);
|
||||
EXPECT_LT(node->index, nodes_num);
|
||||
EXPECT_FALSE(visited_nodes[node->index]);
|
||||
visited_nodes[node->index] = true;
|
||||
}
|
||||
/* Then we make sure node was added. */
|
||||
for (int node_index = 0; node_index < num_nodes; ++node_index) {
|
||||
for (int node_index = 0; node_index < nodes_num; ++node_index) {
|
||||
EXPECT_TRUE(visited_nodes[node_index]);
|
||||
}
|
||||
MEM_freeN(visited_nodes);
|
||||
|
|
|
|||
|
|
@ -215,13 +215,13 @@ static int testsort_listbase_str_cmp_reverse(const void *a, const void *b)
|
|||
}
|
||||
|
||||
/* check array and listbase compare */
|
||||
static bool testsort_listbase_array_str_cmp(ListBase *lb, char **arr, int arr_tot)
|
||||
static bool testsort_listbase_array_str_cmp(ListBase *lb, char **arr, int arr_num)
|
||||
{
|
||||
LinkData *link_step;
|
||||
int i;
|
||||
|
||||
link_step = (LinkData *)lb->first;
|
||||
for (i = 0; i < arr_tot; i++) {
|
||||
for (i = 0; i < arr_num; i++) {
|
||||
if (strcmp(arr[i], (char *)link_step->data) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -255,7 +255,7 @@ TEST(listbase, Sort)
|
|||
{
|
||||
const int words_len = sizeof(words10k) - 1;
|
||||
char *words = BLI_strdupn(words10k, words_len);
|
||||
int words_tot;
|
||||
int words_num;
|
||||
char **words_arr; /* qsort for comparison */
|
||||
int i;
|
||||
char *w_step;
|
||||
|
|
@ -263,15 +263,15 @@ TEST(listbase, Sort)
|
|||
LinkData *words_linkdata_arr;
|
||||
|
||||
/* delimit words */
|
||||
words_tot = 1 + char_switch(words, ' ', '\0');
|
||||
words_num = 1 + char_switch(words, ' ', '\0');
|
||||
|
||||
words_arr = (char **)MEM_mallocN(sizeof(*words_arr) * words_tot, __func__);
|
||||
words_arr = (char **)MEM_mallocN(sizeof(*words_arr) * words_num, __func__);
|
||||
|
||||
words_linkdata_arr = (LinkData *)MEM_mallocN(sizeof(*words_linkdata_arr) * words_tot, __func__);
|
||||
words_linkdata_arr = (LinkData *)MEM_mallocN(sizeof(*words_linkdata_arr) * words_num, __func__);
|
||||
|
||||
/* create array */
|
||||
w_step = words;
|
||||
for (i = 0; i < words_tot; i++) {
|
||||
for (i = 0; i < words_num; i++) {
|
||||
words_arr[i] = w_step;
|
||||
w_step += strlen(w_step) + 1;
|
||||
}
|
||||
|
|
@ -296,7 +296,7 @@ TEST(listbase, Sort)
|
|||
/* create listbase */
|
||||
BLI_listbase_clear(&words_lb);
|
||||
w_step = words;
|
||||
for (i = 0; i < words_tot; i++) {
|
||||
for (i = 0; i < words_num; i++) {
|
||||
LinkData *link = &words_linkdata_arr[i];
|
||||
link->data = w_step;
|
||||
BLI_addtail(&words_lb, link);
|
||||
|
|
@ -306,37 +306,37 @@ TEST(listbase, Sort)
|
|||
|
||||
/* sort (forward) */
|
||||
{
|
||||
qsort(words_arr, words_tot, sizeof(*words_arr), testsort_array_str_cmp);
|
||||
qsort(words_arr, words_num, sizeof(*words_arr), testsort_array_str_cmp);
|
||||
|
||||
BLI_listbase_sort(&words_lb, testsort_listbase_str_cmp);
|
||||
EXPECT_TRUE(listbase_is_valid(&words_lb));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_tot));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
|
||||
EXPECT_TRUE(testsort_listbase_sort_is_stable(&words_lb, true));
|
||||
}
|
||||
|
||||
/* sort (reverse) */
|
||||
{
|
||||
qsort(words_arr, words_tot, sizeof(*words_arr), testsort_array_str_cmp_reverse);
|
||||
qsort(words_arr, words_num, sizeof(*words_arr), testsort_array_str_cmp_reverse);
|
||||
|
||||
BLI_listbase_sort(&words_lb, testsort_listbase_str_cmp_reverse);
|
||||
EXPECT_TRUE(listbase_is_valid(&words_lb));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_tot));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
|
||||
EXPECT_TRUE(testsort_listbase_sort_is_stable(&words_lb, true));
|
||||
}
|
||||
|
||||
/* sort (forward but after reversing, test stability in alternate direction) */
|
||||
{
|
||||
BLI_array_reverse(words_arr, words_tot);
|
||||
BLI_array_reverse(words_arr, words_num);
|
||||
BLI_listbase_reverse(&words_lb);
|
||||
|
||||
EXPECT_TRUE(listbase_is_valid(&words_lb));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_tot));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
|
||||
EXPECT_TRUE(testsort_listbase_sort_is_stable(&words_lb, false));
|
||||
|
||||
/* and again */
|
||||
BLI_array_reverse(words_arr, words_tot);
|
||||
BLI_array_reverse(words_arr, words_num);
|
||||
BLI_listbase_sort(&words_lb, testsort_listbase_str_cmp_reverse);
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_tot));
|
||||
EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
|
||||
EXPECT_TRUE(testsort_listbase_sort_is_stable(&words_lb, false));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,11 +16,11 @@ TEST(memiter, Nop)
|
|||
BLI_memiter_destroy(mi);
|
||||
}
|
||||
|
||||
static void memiter_empty_test(int num_elems, const int chunk_size)
|
||||
static void memiter_empty_test(int elems_num, const int chunk_size)
|
||||
{
|
||||
BLI_memiter *mi = BLI_memiter_create(chunk_size);
|
||||
void *data;
|
||||
for (int index = 0; index < num_elems; index++) {
|
||||
for (int index = 0; index < elems_num; index++) {
|
||||
data = BLI_memiter_alloc(mi, 0);
|
||||
}
|
||||
int index = 0, total_size = 0;
|
||||
|
|
@ -32,17 +32,17 @@ static void memiter_empty_test(int num_elems, const int chunk_size)
|
|||
total_size += elem_size;
|
||||
}
|
||||
EXPECT_EQ(0, total_size);
|
||||
EXPECT_EQ(num_elems, index);
|
||||
EXPECT_EQ(elems_num, index);
|
||||
|
||||
BLI_memiter_destroy(mi);
|
||||
}
|
||||
|
||||
#define MEMITER_NUMBER_TEST_FN(fn, number_type) \
|
||||
static void fn(int num_elems, const int chunk_size) \
|
||||
static void fn(int elems_num, const int chunk_size) \
|
||||
{ \
|
||||
BLI_memiter *mi = BLI_memiter_create(chunk_size); \
|
||||
number_type *data; \
|
||||
for (int index = 0; index < num_elems; index++) { \
|
||||
for (int index = 0; index < elems_num; index++) { \
|
||||
data = (number_type *)BLI_memiter_alloc(mi, sizeof(number_type)); \
|
||||
*data = index; \
|
||||
} \
|
||||
|
|
|
|||
|
|
@ -811,14 +811,14 @@ TEST(mesh_intersect, RectCross)
|
|||
# if DO_PERF_TESTS
|
||||
|
||||
static void get_sphere_params(
|
||||
int nrings, int nsegs, bool triangulate, int *r_num_verts, int *r_num_faces)
|
||||
int nrings, int nsegs, bool triangulate, int *r_verts_num, int *r_faces_num)
|
||||
{
|
||||
*r_num_verts = nsegs * (nrings - 1) + 2;
|
||||
*r_verts_num = nsegs * (nrings - 1) + 2;
|
||||
if (triangulate) {
|
||||
*r_num_faces = 2 * nsegs + 2 * nsegs * (nrings - 2);
|
||||
*r_faces_num = 2 * nsegs + 2 * nsegs * (nrings - 2);
|
||||
}
|
||||
else {
|
||||
*r_num_faces = nsegs * nrings;
|
||||
*r_faces_num = nsegs * nrings;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -832,11 +832,11 @@ static void fill_sphere_data(int nrings,
|
|||
int fid_start,
|
||||
IMeshArena *arena)
|
||||
{
|
||||
int num_verts;
|
||||
int num_faces;
|
||||
get_sphere_params(nrings, nsegs, triangulate, &num_verts, &num_faces);
|
||||
BLI_assert(num_faces == face.size());
|
||||
Array<const Vert *> vert(num_verts);
|
||||
int verts_num;
|
||||
int faces_num;
|
||||
get_sphere_params(nrings, nsegs, triangulate, &verts_num, &faces_num);
|
||||
BLI_assert(faces_num == face.size());
|
||||
Array<const Vert *> vert(verts_num);
|
||||
const bool nrings_even = (nrings % 2 == 0);
|
||||
int half_nrings = nrings / 2;
|
||||
const bool nsegs_even = (nsegs % 2) == 0;
|
||||
|
|
@ -847,12 +847,12 @@ static void fill_sphere_data(int nrings,
|
|||
double delta_theta = M_PI / nrings;
|
||||
int fid = fid_start;
|
||||
int vid = vid_start;
|
||||
auto vert_index_fn = [nrings, num_verts](int seg, int ring) {
|
||||
auto vert_index_fn = [nrings, verts_num](int seg, int ring) {
|
||||
if (ring == 0) { /* Top vert. */
|
||||
return num_verts - 2;
|
||||
return verts_num - 2;
|
||||
}
|
||||
if (ring == nrings) { /* Bottom vert. */
|
||||
return num_verts - 1;
|
||||
return verts_num - 1;
|
||||
}
|
||||
return seg * (nrings - 1) + (ring - 1);
|
||||
};
|
||||
|
|
@ -980,18 +980,18 @@ static void spheresphere_test(int nrings, double y_offset, bool use_self)
|
|||
double time_start = PIL_check_seconds_timer();
|
||||
IMeshArena arena;
|
||||
int nsegs = 2 * nrings;
|
||||
int num_sphere_verts;
|
||||
int num_sphere_tris;
|
||||
get_sphere_params(nrings, nsegs, true, &num_sphere_verts, &num_sphere_tris);
|
||||
Array<Face *> tris(2 * num_sphere_tris);
|
||||
arena.reserve(6 * num_sphere_verts / 2, 8 * num_sphere_tris);
|
||||
int sphere_verts_num;
|
||||
int sphere_tris_num;
|
||||
get_sphere_params(nrings, nsegs, true, &sphere_verts_num, &sphere_tris_num);
|
||||
Array<Face *> tris(2 * sphere_tris_num);
|
||||
arena.reserve(6 * sphere_verts_num / 2, 8 * sphere_tris_num);
|
||||
double3 center1(0.0, 0.0, 0.0);
|
||||
fill_sphere_data(nrings,
|
||||
nsegs,
|
||||
center1,
|
||||
1.0,
|
||||
true,
|
||||
MutableSpan<Face *>(tris.begin(), num_sphere_tris),
|
||||
MutableSpan<Face *>(tris.begin(), sphere_tris_num),
|
||||
0,
|
||||
0,
|
||||
&arena);
|
||||
|
|
@ -1001,9 +1001,9 @@ static void spheresphere_test(int nrings, double y_offset, bool use_self)
|
|||
center2,
|
||||
1.0,
|
||||
true,
|
||||
MutableSpan<Face *>(tris.begin() + num_sphere_tris, num_sphere_tris),
|
||||
num_sphere_verts,
|
||||
num_sphere_verts,
|
||||
MutableSpan<Face *>(tris.begin() + sphere_tris_num, sphere_tris_num),
|
||||
sphere_verts_num,
|
||||
sphere_verts_num,
|
||||
&arena);
|
||||
IMesh mesh(tris);
|
||||
double time_create = PIL_check_seconds_timer();
|
||||
|
|
@ -1013,7 +1013,7 @@ static void spheresphere_test(int nrings, double y_offset, bool use_self)
|
|||
out = trimesh_self_intersect(mesh, &arena);
|
||||
}
|
||||
else {
|
||||
int nf = num_sphere_tris;
|
||||
int nf = sphere_tris_num;
|
||||
out = trimesh_nary_intersect(
|
||||
mesh, 2, [nf](int t) { return t < nf ? 0 : 1; }, false, &arena);
|
||||
}
|
||||
|
|
@ -1028,14 +1028,14 @@ static void spheresphere_test(int nrings, double y_offset, bool use_self)
|
|||
}
|
||||
|
||||
static void get_grid_params(
|
||||
int x_subdiv, int y_subdiv, bool triangulate, int *r_num_verts, int *r_num_faces)
|
||||
int x_subdiv, int y_subdiv, bool triangulate, int *r_verts_num, int *r_faces_num)
|
||||
{
|
||||
*r_num_verts = x_subdiv * y_subdiv;
|
||||
*r_verts_num = x_subdiv * y_subdiv;
|
||||
if (triangulate) {
|
||||
*r_num_faces = 2 * (x_subdiv - 1) * (y_subdiv - 1);
|
||||
*r_faces_num = 2 * (x_subdiv - 1) * (y_subdiv - 1);
|
||||
}
|
||||
else {
|
||||
*r_num_faces = (x_subdiv - 1) * (y_subdiv - 1);
|
||||
*r_faces_num = (x_subdiv - 1) * (y_subdiv - 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1053,11 +1053,11 @@ static void fill_grid_data(int x_subdiv,
|
|||
if (x_subdiv <= 1 || y_subdiv <= 1) {
|
||||
return;
|
||||
}
|
||||
int num_verts;
|
||||
int num_faces;
|
||||
get_grid_params(x_subdiv, y_subdiv, triangulate, &num_verts, &num_faces);
|
||||
BLI_assert(face.size() == num_faces);
|
||||
Array<const Vert *> vert(num_verts);
|
||||
int verts_num;
|
||||
int faces_num;
|
||||
get_grid_params(x_subdiv, y_subdiv, triangulate, &verts_num, &faces_num);
|
||||
BLI_assert(face.size() == faces_num);
|
||||
Array<const Vert *> vert(verts_num);
|
||||
auto vert_index_fn = [x_subdiv](int ix, int iy) { return iy * x_subdiv + ix; };
|
||||
auto face_index_fn = [x_subdiv](int ix, int iy) { return iy * (x_subdiv - 1) + ix; };
|
||||
auto tri_index_fn = [x_subdiv](int ix, int iy, int tri) {
|
||||
|
|
@ -1119,24 +1119,24 @@ static void spheregrid_test(int nrings, int grid_level, double z_offset, bool us
|
|||
BLI_task_scheduler_init(); /* Without this, no parallelism. */
|
||||
double time_start = PIL_check_seconds_timer();
|
||||
IMeshArena arena;
|
||||
int num_sphere_verts;
|
||||
int num_sphere_tris;
|
||||
int sphere_verts_num;
|
||||
int sphere_tris_num;
|
||||
int nsegs = 2 * nrings;
|
||||
int num_grid_verts;
|
||||
int num_grid_tris;
|
||||
int grid_verts_num;
|
||||
int grid_tris_num;
|
||||
int subdivs = 1 << grid_level;
|
||||
get_sphere_params(nrings, nsegs, true, &num_sphere_verts, &num_sphere_tris);
|
||||
get_grid_params(subdivs, subdivs, true, &num_grid_verts, &num_grid_tris);
|
||||
Array<Face *> tris(num_sphere_tris + num_grid_tris);
|
||||
arena.reserve(3 * (num_sphere_verts + num_grid_verts) / 2,
|
||||
4 * (num_sphere_tris + num_grid_tris));
|
||||
get_sphere_params(nrings, nsegs, true, &sphere_verts_num, &sphere_tris_num);
|
||||
get_grid_params(subdivs, subdivs, true, &grid_verts_num, &grid_tris_num);
|
||||
Array<Face *> tris(sphere_tris_num + grid_tris_num);
|
||||
arena.reserve(3 * (sphere_verts_num + grid_verts_num) / 2,
|
||||
4 * (sphere_tris_num + grid_tris_num));
|
||||
double3 center(0.0, 0.0, z_offset);
|
||||
fill_sphere_data(nrings,
|
||||
nsegs,
|
||||
center,
|
||||
1.0,
|
||||
true,
|
||||
MutableSpan<Face *>(tris.begin(), num_sphere_tris),
|
||||
MutableSpan<Face *>(tris.begin(), sphere_tris_num),
|
||||
0,
|
||||
0,
|
||||
&arena);
|
||||
|
|
@ -1146,9 +1146,9 @@ static void spheregrid_test(int nrings, int grid_level, double z_offset, bool us
|
|||
4.0,
|
||||
double3(0, 0, 0),
|
||||
0.0,
|
||||
MutableSpan<Face *>(tris.begin() + num_sphere_tris, num_grid_tris),
|
||||
num_sphere_verts,
|
||||
num_sphere_tris,
|
||||
MutableSpan<Face *>(tris.begin() + sphere_tris_num, grid_tris_num),
|
||||
sphere_verts_num,
|
||||
sphere_tris_num,
|
||||
&arena);
|
||||
IMesh mesh(tris);
|
||||
double time_create = PIL_check_seconds_timer();
|
||||
|
|
@ -1158,7 +1158,7 @@ static void spheregrid_test(int nrings, int grid_level, double z_offset, bool us
|
|||
out = trimesh_self_intersect(mesh, &arena);
|
||||
}
|
||||
else {
|
||||
int nf = num_sphere_tris;
|
||||
int nf = sphere_tris_num;
|
||||
out = trimesh_nary_intersect(
|
||||
mesh, 2, [nf](int t) { return t < nf ? 0 : 1; }, false, &arena);
|
||||
}
|
||||
|
|
@ -1190,22 +1190,22 @@ static void gridgrid_test(int x_level_1,
|
|||
int y_subdivs_1 = 1 << y_level_1;
|
||||
int x_subdivs_2 = 1 << x_level_2;
|
||||
int y_subdivs_2 = 1 << y_level_2;
|
||||
int num_grid_verts_1;
|
||||
int num_grid_verts_2;
|
||||
int num_grid_tris_1;
|
||||
int num_grid_tris_2;
|
||||
get_grid_params(x_subdivs_1, y_subdivs_1, true, &num_grid_verts_1, &num_grid_tris_1);
|
||||
get_grid_params(x_subdivs_2, y_subdivs_2, true, &num_grid_verts_2, &num_grid_tris_2);
|
||||
Array<Face *> tris(num_grid_tris_1 + num_grid_tris_2);
|
||||
arena.reserve(3 * (num_grid_verts_1 + num_grid_verts_2) / 2,
|
||||
4 * (num_grid_tris_1 + num_grid_tris_2));
|
||||
int grid_verts_1_num;
|
||||
int grid_verts_2_num;
|
||||
int grid_tris_1_num;
|
||||
int grid_tris_2_num;
|
||||
get_grid_params(x_subdivs_1, y_subdivs_1, true, &grid_verts_1_num, &grid_tris_1_num);
|
||||
get_grid_params(x_subdivs_2, y_subdivs_2, true, &grid_verts_2_num, &grid_tris_2_num);
|
||||
Array<Face *> tris(grid_tris_1_num + grid_tris_2_num);
|
||||
arena.reserve(3 * (grid_verts_1_num + grid_verts_2_num) / 2,
|
||||
4 * (grid_tris_1_num + grid_tris_2_num));
|
||||
fill_grid_data(x_subdivs_1,
|
||||
y_subdivs_1,
|
||||
true,
|
||||
4.0,
|
||||
double3(0, 0, 0),
|
||||
0.0,
|
||||
MutableSpan<Face *>(tris.begin(), num_grid_tris_1),
|
||||
MutableSpan<Face *>(tris.begin(), grid_tris_1_num),
|
||||
0,
|
||||
0,
|
||||
&arena);
|
||||
|
|
@ -1215,9 +1215,9 @@ static void gridgrid_test(int x_level_1,
|
|||
4.0,
|
||||
double3(x_off, y_off, 0),
|
||||
rot_deg,
|
||||
MutableSpan<Face *>(tris.begin() + num_grid_tris_1, num_grid_tris_2),
|
||||
num_grid_verts_1,
|
||||
num_grid_tris_1,
|
||||
MutableSpan<Face *>(tris.begin() + grid_tris_1_num, grid_tris_2_num),
|
||||
grid_verts_1_num,
|
||||
grid_tris_1_num,
|
||||
&arena);
|
||||
IMesh mesh(tris);
|
||||
double time_create = PIL_check_seconds_timer();
|
||||
|
|
@ -1227,7 +1227,7 @@ static void gridgrid_test(int x_level_1,
|
|||
out = trimesh_self_intersect(mesh, &arena);
|
||||
}
|
||||
else {
|
||||
int nf = num_grid_tris_1;
|
||||
int nf = grid_tris_1_num;
|
||||
out = trimesh_nary_intersect(
|
||||
mesh, 2, [nf](int t) { return t < nf ? 0 : 1; }, false, &arena);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,19 +29,19 @@
|
|||
|
||||
static void polyfill_to_obj(const char *id,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot);
|
||||
const unsigned int tris_num);
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* test utility functions */
|
||||
|
||||
#define TRI_ERROR_VALUE (unsigned int)-1
|
||||
|
||||
static void test_valid_polyfill_prepare(unsigned int tris[][3], unsigned int tris_tot)
|
||||
static void test_valid_polyfill_prepare(unsigned int tris[][3], unsigned int tris_num)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; i < tris_tot; i++) {
|
||||
for (i = 0; i < tris_num; i++) {
|
||||
unsigned int j;
|
||||
for (j = 0; j < 3; j++) {
|
||||
tris[i][j] = TRI_ERROR_VALUE;
|
||||
|
|
@ -57,37 +57,37 @@ static void test_valid_polyfill_prepare(unsigned int tris[][3], unsigned int tri
|
|||
* - all verts used at least once.
|
||||
*/
|
||||
static void test_polyfill_simple(const float /*poly*/[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
unsigned int i;
|
||||
int *tot_used = (int *)MEM_callocN(poly_tot * sizeof(int), __func__);
|
||||
for (i = 0; i < tris_tot; i++) {
|
||||
int *used_num = (int *)MEM_callocN(poly_num * sizeof(int), __func__);
|
||||
for (i = 0; i < tris_num; i++) {
|
||||
unsigned int j;
|
||||
for (j = 0; j < 3; j++) {
|
||||
EXPECT_NE(TRI_ERROR_VALUE, tris[i][j]);
|
||||
tot_used[tris[i][j]] += 1;
|
||||
used_num[tris[i][j]] += 1;
|
||||
}
|
||||
EXPECT_NE(tris[i][0], tris[i][1]);
|
||||
EXPECT_NE(tris[i][1], tris[i][2]);
|
||||
EXPECT_NE(tris[i][2], tris[i][0]);
|
||||
}
|
||||
for (i = 0; i < poly_tot; i++) {
|
||||
EXPECT_NE(0, tot_used[i]);
|
||||
for (i = 0; i < poly_num; i++) {
|
||||
EXPECT_NE(0, used_num[i]);
|
||||
}
|
||||
MEM_freeN(tot_used);
|
||||
MEM_freeN(used_num);
|
||||
}
|
||||
|
||||
static void test_polyfill_topology(const float /*poly*/[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
EdgeHash *edgehash = BLI_edgehash_new(__func__);
|
||||
EdgeHashIterator *ehi;
|
||||
unsigned int i;
|
||||
for (i = 0; i < tris_tot; i++) {
|
||||
for (i = 0; i < tris_num; i++) {
|
||||
unsigned int j;
|
||||
for (j = 0; j < 3; j++) {
|
||||
const unsigned int v1 = tris[i][j];
|
||||
|
|
@ -101,11 +101,11 @@ static void test_polyfill_topology(const float /*poly*/[][2],
|
|||
}
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(BLI_edgehash_len(edgehash), poly_tot + (poly_tot - 3));
|
||||
EXPECT_EQ(BLI_edgehash_len(edgehash), poly_num + (poly_num - 3));
|
||||
|
||||
for (i = 0; i < poly_tot; i++) {
|
||||
for (i = 0; i < poly_num; i++) {
|
||||
const unsigned int v1 = i;
|
||||
const unsigned int v2 = (i + 1) % poly_tot;
|
||||
const unsigned int v2 = (i + 1) % poly_num;
|
||||
void **p = BLI_edgehash_lookup_p(edgehash, v1, v2);
|
||||
EXPECT_NE((void *)p, nullptr);
|
||||
EXPECT_EQ((intptr_t)*p, 1);
|
||||
|
|
@ -125,13 +125,13 @@ static void test_polyfill_topology(const float /*poly*/[][2],
|
|||
* Check all faces are flipped the same way
|
||||
*/
|
||||
static void test_polyfill_winding(const float poly[][2],
|
||||
const unsigned int /*poly_tot*/,
|
||||
const unsigned int /*poly_num*/,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned int count[2] = {0, 0};
|
||||
for (i = 0; i < tris_tot; i++) {
|
||||
for (i = 0; i < tris_num; i++) {
|
||||
float winding_test = cross_tri_v2(poly[tris[i][0]], poly[tris[i][1]], poly[tris[i][2]]);
|
||||
if (fabsf(winding_test) > FLT_EPSILON) {
|
||||
count[winding_test < 0.0f] += 1;
|
||||
|
|
@ -144,19 +144,19 @@ static void test_polyfill_winding(const float poly[][2],
|
|||
* Check the accumulated triangle area is close to the original area.
|
||||
*/
|
||||
static void test_polyfill_area(const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
unsigned int i;
|
||||
const float area_tot = area_poly_v2(poly, poly_tot);
|
||||
float area_tot_tris = 0.0f;
|
||||
const float area_total = area_poly_v2(poly, poly_num);
|
||||
float area_total_tris = 0.0f;
|
||||
const float eps_abs = 0.00001f;
|
||||
const float eps = area_tot > 1.0f ? (area_tot * eps_abs) : eps_abs;
|
||||
for (i = 0; i < tris_tot; i++) {
|
||||
area_tot_tris += area_tri_v2(poly[tris[i][0]], poly[tris[i][1]], poly[tris[i][2]]);
|
||||
const float eps = area_total > 1.0f ? (area_total * eps_abs) : eps_abs;
|
||||
for (i = 0; i < tris_num; i++) {
|
||||
area_total_tris += area_tri_v2(poly[tris[i][0]], poly[tris[i][1]], poly[tris[i][2]]);
|
||||
}
|
||||
EXPECT_NEAR(area_tot, area_tot_tris, eps);
|
||||
EXPECT_NEAR(area_total, area_total_tris, eps);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
|
@ -167,32 +167,32 @@ static void test_polyfill_area(const float poly[][2],
|
|||
static void test_polyfill_template_check(const char *id,
|
||||
bool is_degenerate,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
test_polyfill_simple(poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_topology(poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_simple(poly, poly_num, tris, tris_num);
|
||||
test_polyfill_topology(poly, poly_num, tris, tris_num);
|
||||
if (!is_degenerate) {
|
||||
test_polyfill_winding(poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_winding(poly, poly_num, tris, tris_num);
|
||||
|
||||
test_polyfill_area(poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_area(poly, poly_num, tris, tris_num);
|
||||
}
|
||||
polyfill_to_obj(id, poly, poly_tot, tris, tris_tot);
|
||||
polyfill_to_obj(id, poly, poly_num, tris, tris_num);
|
||||
}
|
||||
|
||||
static void test_polyfill_template(const char *id,
|
||||
bool is_degenerate,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
test_valid_polyfill_prepare(tris, tris_tot);
|
||||
BLI_polyfill_calc(poly, poly_tot, 0, tris);
|
||||
test_valid_polyfill_prepare(tris, tris_num);
|
||||
BLI_polyfill_calc(poly, poly_num, 0, tris);
|
||||
|
||||
/* check all went well */
|
||||
test_polyfill_template_check(id, is_degenerate, poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_template_check(id, is_degenerate, poly, poly_num, tris, tris_num);
|
||||
|
||||
#ifdef USE_BEAUTIFY
|
||||
/* check beautify gives good results too */
|
||||
|
|
@ -200,9 +200,9 @@ static void test_polyfill_template(const char *id,
|
|||
MemArena *pf_arena = BLI_memarena_new(BLI_POLYFILL_ARENA_SIZE, __func__);
|
||||
Heap *pf_heap = BLI_heap_new_ex(BLI_POLYFILL_ALLOC_NGON_RESERVE);
|
||||
|
||||
BLI_polyfill_beautify(poly, poly_tot, tris, pf_arena, pf_heap);
|
||||
BLI_polyfill_beautify(poly, poly_num, tris, pf_arena, pf_heap);
|
||||
|
||||
test_polyfill_template_check(id, is_degenerate, poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_template_check(id, is_degenerate, poly, poly_num, tris, tris_num);
|
||||
|
||||
BLI_memarena_free(pf_arena);
|
||||
BLI_heap_free(pf_heap, nullptr);
|
||||
|
|
@ -213,20 +213,20 @@ static void test_polyfill_template(const char *id,
|
|||
static void test_polyfill_template_flip_sign(const char *id,
|
||||
bool is_degenerate,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
float(*poly_copy)[2] = (float(*)[2])MEM_mallocN(sizeof(float[2]) * poly_tot, id);
|
||||
float(*poly_copy)[2] = (float(*)[2])MEM_mallocN(sizeof(float[2]) * poly_num, id);
|
||||
for (int flip_x = 0; flip_x < 2; flip_x++) {
|
||||
for (int flip_y = 0; flip_y < 2; flip_y++) {
|
||||
float sign_x = flip_x ? -1.0f : 1.0f;
|
||||
float sign_y = flip_y ? -1.0f : 1.0f;
|
||||
for (int i = 0; i < poly_tot; i++) {
|
||||
for (int i = 0; i < poly_num; i++) {
|
||||
poly_copy[i][0] = poly[i][0] * sign_x;
|
||||
poly_copy[i][1] = poly[i][1] * sign_y;
|
||||
}
|
||||
test_polyfill_template(id, is_degenerate, poly_copy, poly_tot, tris, tris_tot);
|
||||
test_polyfill_template(id, is_degenerate, poly_copy, poly_num, tris, tris_num);
|
||||
}
|
||||
}
|
||||
MEM_freeN(poly_copy);
|
||||
|
|
@ -236,32 +236,32 @@ static void test_polyfill_template_flip_sign(const char *id,
|
|||
static void test_polyfill_template_main(const char *id,
|
||||
bool is_degenerate,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
/* overkill? - try at _every_ offset & reverse */
|
||||
unsigned int poly_reverse;
|
||||
float(*poly_copy)[2] = (float(*)[2])MEM_mallocN(sizeof(float[2]) * poly_tot, id);
|
||||
float(*poly_copy)[2] = (float(*)[2])MEM_mallocN(sizeof(float[2]) * poly_num, id);
|
||||
float tmp[2];
|
||||
|
||||
memcpy(poly_copy, poly, sizeof(float[2]) * poly_tot);
|
||||
memcpy(poly_copy, poly, sizeof(float[2]) * poly_num);
|
||||
|
||||
for (poly_reverse = 0; poly_reverse < 2; poly_reverse++) {
|
||||
unsigned int poly_cycle;
|
||||
|
||||
if (poly_reverse) {
|
||||
BLI_array_reverse(poly_copy, poly_tot);
|
||||
BLI_array_reverse(poly_copy, poly_num);
|
||||
}
|
||||
|
||||
for (poly_cycle = 0; poly_cycle < poly_tot; poly_cycle++) {
|
||||
for (poly_cycle = 0; poly_cycle < poly_num; poly_cycle++) {
|
||||
// printf("polytest %s ofs=%d, reverse=%d\n", id, poly_cycle, poly_reverse);
|
||||
test_polyfill_template_flip_sign(id, is_degenerate, poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_template_flip_sign(id, is_degenerate, poly, poly_num, tris, tris_num);
|
||||
|
||||
/* cycle */
|
||||
copy_v2_v2(tmp, poly_copy[0]);
|
||||
memmove(&poly_copy[0], &poly_copy[1], (poly_tot - 1) * sizeof(float[2]));
|
||||
copy_v2_v2(poly_copy[poly_tot - 1], tmp);
|
||||
memmove(&poly_copy[0], &poly_copy[1], (poly_num - 1) * sizeof(float[2]));
|
||||
copy_v2_v2(poly_copy[poly_num - 1], tmp);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -271,22 +271,22 @@ static void test_polyfill_template_main(const char *id,
|
|||
static void test_polyfill_template_main(const char *id,
|
||||
bool is_degenerate,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
test_polyfill_template_flip_sign(id, is_degenerate, poly, poly_tot, tris, tris_tot);
|
||||
test_polyfill_template_flip_sign(id, is_degenerate, poly, poly_num, tris, tris_num);
|
||||
}
|
||||
#endif /* USE_COMBINATIONS_ALL */
|
||||
|
||||
#define TEST_POLYFILL_TEMPLATE_STATIC(poly, is_degenerate) \
|
||||
{ \
|
||||
unsigned int tris[POLY_TRI_COUNT(ARRAY_SIZE(poly))][3]; \
|
||||
const unsigned int poly_tot = ARRAY_SIZE(poly); \
|
||||
const unsigned int tris_tot = ARRAY_SIZE(tris); \
|
||||
const unsigned int poly_num = ARRAY_SIZE(poly); \
|
||||
const unsigned int tris_num = ARRAY_SIZE(tris); \
|
||||
const char *id = typeid(*this).name(); \
|
||||
\
|
||||
test_polyfill_template_main(id, is_degenerate, poly, poly_tot, tris, tris_tot); \
|
||||
test_polyfill_template_main(id, is_degenerate, poly, poly_num, tris, tris_num); \
|
||||
} \
|
||||
(void)0
|
||||
|
||||
|
|
@ -296,9 +296,9 @@ static void test_polyfill_template_main(const char *id,
|
|||
#ifdef USE_OBJ_PREVIEW
|
||||
static void polyfill_to_obj(const char *id,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
char path[1024];
|
||||
FILE *f;
|
||||
|
|
@ -311,11 +311,11 @@ static void polyfill_to_obj(const char *id,
|
|||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < poly_tot; i++) {
|
||||
for (i = 0; i < poly_num; i++) {
|
||||
fprintf(f, "v %f %f 0.0\n", UNPACK2(poly[i]));
|
||||
}
|
||||
|
||||
for (i = 0; i < tris_tot; i++) {
|
||||
for (i = 0; i < tris_num; i++) {
|
||||
fprintf(f, "f %u %u %u\n", UNPACK3_EX(1 +, tris[i], ));
|
||||
}
|
||||
|
||||
|
|
@ -324,13 +324,13 @@ static void polyfill_to_obj(const char *id,
|
|||
#else
|
||||
static void polyfill_to_obj(const char *id,
|
||||
const float poly[][2],
|
||||
const unsigned int poly_tot,
|
||||
const unsigned int poly_num,
|
||||
const unsigned int tris[][3],
|
||||
const unsigned int tris_tot)
|
||||
const unsigned int tris_num)
|
||||
{
|
||||
(void)id;
|
||||
(void)poly, (void)poly_tot;
|
||||
(void)tris, (void)tris_tot;
|
||||
(void)poly, (void)poly_num;
|
||||
(void)tris, (void)tris_num;
|
||||
}
|
||||
#endif /* USE_OBJ_PREVIEW */
|
||||
|
||||
|
|
|
|||
|
|
@ -324,35 +324,35 @@ TEST(string, StrPartitionExUtf8)
|
|||
/* BLI_str_format_int_grouped */
|
||||
TEST(string, StrFormatIntGrouped)
|
||||
{
|
||||
char num_str[16];
|
||||
int num;
|
||||
char number_str[16];
|
||||
int number;
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = 0);
|
||||
EXPECT_STREQ("0", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = 0);
|
||||
EXPECT_STREQ("0", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = 1);
|
||||
EXPECT_STREQ("1", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = 1);
|
||||
EXPECT_STREQ("1", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = -1);
|
||||
EXPECT_STREQ("-1", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = -1);
|
||||
EXPECT_STREQ("-1", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = -2147483648);
|
||||
EXPECT_STREQ("-2,147,483,648", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = -2147483648);
|
||||
EXPECT_STREQ("-2,147,483,648", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = 2147483647);
|
||||
EXPECT_STREQ("2,147,483,647", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = 2147483647);
|
||||
EXPECT_STREQ("2,147,483,647", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = 1000);
|
||||
EXPECT_STREQ("1,000", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = 1000);
|
||||
EXPECT_STREQ("1,000", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = -1000);
|
||||
EXPECT_STREQ("-1,000", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = -1000);
|
||||
EXPECT_STREQ("-1,000", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = 999);
|
||||
EXPECT_STREQ("999", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = 999);
|
||||
EXPECT_STREQ("999", number_str);
|
||||
|
||||
BLI_str_format_int_grouped(num_str, num = -999);
|
||||
EXPECT_STREQ("-999", num_str);
|
||||
BLI_str_format_int_grouped(number_str, number = -999);
|
||||
EXPECT_STREQ("-999", number_str);
|
||||
}
|
||||
|
||||
/* BLI_str_format_byte_unit */
|
||||
|
|
|
|||
|
|
@ -274,15 +274,15 @@ TEST(string, Utf8InvalidBytes)
|
|||
for (int i = 0; utf8_invalid_tests[i][0] != nullptr; i++) {
|
||||
const char *tst = utf8_invalid_tests[i][0];
|
||||
const char *tst_stripped = utf8_invalid_tests[i][1];
|
||||
const int num_errors = (int)utf8_invalid_tests[i][2][0];
|
||||
const int errors_num = (int)utf8_invalid_tests[i][2][0];
|
||||
|
||||
char buff[80];
|
||||
memcpy(buff, tst, sizeof(buff));
|
||||
|
||||
const int num_errors_found = BLI_str_utf8_invalid_strip(buff, sizeof(buff) - 1);
|
||||
const int errors_found_num = BLI_str_utf8_invalid_strip(buff, sizeof(buff) - 1);
|
||||
|
||||
printf("[%02d] -> [%02d] \"%s\" -> \"%s\"\n", num_errors, num_errors_found, tst, buff);
|
||||
EXPECT_EQ(num_errors_found, num_errors);
|
||||
printf("[%02d] -> [%02d] \"%s\" -> \"%s\"\n", errors_num, errors_found_num, tst, buff);
|
||||
EXPECT_EQ(errors_found_num, errors_num);
|
||||
EXPECT_STREQ(buff, tst_stripped);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#include "BLI_task.h"
|
||||
#include "BLI_task.hh"
|
||||
|
||||
#define NUM_ITEMS 10000
|
||||
#define ITEMS_NUM 10000
|
||||
|
||||
/* *** Parallel iterations over range of integer values. *** */
|
||||
|
||||
|
|
@ -34,12 +34,12 @@ static void task_range_iter_reduce_func(const void *__restrict UNUSED(userdata),
|
|||
int *join = (int *)join_v;
|
||||
int *chunk = (int *)userdata_chunk;
|
||||
*join += *chunk;
|
||||
// printf("%d, %d\n", data[NUM_ITEMS], *((int *)userdata_chunk));
|
||||
// printf("%d, %d\n", data[ITEMS_NUM], *((int *)userdata_chunk));
|
||||
}
|
||||
|
||||
TEST(task, RangeIter)
|
||||
{
|
||||
int data[NUM_ITEMS] = {0};
|
||||
int data[ITEMS_NUM] = {0};
|
||||
int sum = 0;
|
||||
|
||||
BLI_threadapi_init();
|
||||
|
|
@ -52,13 +52,13 @@ TEST(task, RangeIter)
|
|||
settings.userdata_chunk_size = sizeof(sum);
|
||||
settings.func_reduce = task_range_iter_reduce_func;
|
||||
|
||||
BLI_task_parallel_range(0, NUM_ITEMS, data, task_range_iter_func, &settings);
|
||||
BLI_task_parallel_range(0, ITEMS_NUM, data, task_range_iter_func, &settings);
|
||||
|
||||
/* Those checks should ensure us all items of the listbase were processed once, and only once
|
||||
* as expected. */
|
||||
|
||||
int expected_sum = 0;
|
||||
for (int i = 0; i < NUM_ITEMS; i++) {
|
||||
for (int i = 0; i < ITEMS_NUM; i++) {
|
||||
EXPECT_EQ(data[i], i);
|
||||
expected_sum += i;
|
||||
}
|
||||
|
|
@ -84,41 +84,41 @@ static void task_mempool_iter_func(void *userdata,
|
|||
|
||||
TEST(task, MempoolIter)
|
||||
{
|
||||
int *data[NUM_ITEMS];
|
||||
int *data[ITEMS_NUM];
|
||||
BLI_threadapi_init();
|
||||
BLI_mempool *mempool = BLI_mempool_create(
|
||||
sizeof(*data[0]), NUM_ITEMS, 32, BLI_MEMPOOL_ALLOW_ITER);
|
||||
sizeof(*data[0]), ITEMS_NUM, 32, BLI_MEMPOOL_ALLOW_ITER);
|
||||
|
||||
int i;
|
||||
|
||||
/* 'Randomly' add and remove some items from mempool, to create a non-homogeneous one. */
|
||||
int num_items = 0;
|
||||
for (i = 0; i < NUM_ITEMS; i++) {
|
||||
int items_num = 0;
|
||||
for (i = 0; i < ITEMS_NUM; i++) {
|
||||
data[i] = (int *)BLI_mempool_alloc(mempool);
|
||||
*data[i] = i - 1;
|
||||
num_items++;
|
||||
items_num++;
|
||||
}
|
||||
|
||||
for (i = 0; i < NUM_ITEMS; i += 3) {
|
||||
for (i = 0; i < ITEMS_NUM; i += 3) {
|
||||
BLI_mempool_free(mempool, data[i]);
|
||||
data[i] = nullptr;
|
||||
num_items--;
|
||||
items_num--;
|
||||
}
|
||||
|
||||
for (i = 0; i < NUM_ITEMS; i += 7) {
|
||||
for (i = 0; i < ITEMS_NUM; i += 7) {
|
||||
if (data[i] == nullptr) {
|
||||
data[i] = (int *)BLI_mempool_alloc(mempool);
|
||||
*data[i] = i - 1;
|
||||
num_items++;
|
||||
items_num++;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < NUM_ITEMS - 5; i += 23) {
|
||||
for (i = 0; i < ITEMS_NUM - 5; i += 23) {
|
||||
for (int j = 0; j < 5; j++) {
|
||||
if (data[i + j] != nullptr) {
|
||||
BLI_mempool_free(mempool, data[i + j]);
|
||||
data[i + j] = nullptr;
|
||||
num_items--;
|
||||
items_num--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -126,12 +126,12 @@ TEST(task, MempoolIter)
|
|||
TaskParallelSettings settings;
|
||||
BLI_parallel_mempool_settings_defaults(&settings);
|
||||
|
||||
BLI_task_parallel_mempool(mempool, &num_items, task_mempool_iter_func, &settings);
|
||||
BLI_task_parallel_mempool(mempool, &items_num, task_mempool_iter_func, &settings);
|
||||
|
||||
/* Those checks should ensure us all items of the mempool were processed once, and only once - as
|
||||
* expected. */
|
||||
EXPECT_EQ(num_items, 0);
|
||||
for (i = 0; i < NUM_ITEMS; i++) {
|
||||
EXPECT_EQ(items_num, 0);
|
||||
for (i = 0; i < ITEMS_NUM; i++) {
|
||||
if (data[i] != nullptr) {
|
||||
EXPECT_EQ(*data[i], i);
|
||||
}
|
||||
|
|
@ -189,19 +189,19 @@ static void task_mempool_iter_tls_free(const void *UNUSED(userdata),
|
|||
|
||||
TEST(task, MempoolIterTLS)
|
||||
{
|
||||
int *data[NUM_ITEMS];
|
||||
int *data[ITEMS_NUM];
|
||||
BLI_threadapi_init();
|
||||
BLI_mempool *mempool = BLI_mempool_create(
|
||||
sizeof(*data[0]), NUM_ITEMS, 32, BLI_MEMPOOL_ALLOW_ITER);
|
||||
sizeof(*data[0]), ITEMS_NUM, 32, BLI_MEMPOOL_ALLOW_ITER);
|
||||
|
||||
int i;
|
||||
|
||||
/* Add numbers negative `1..NUM_ITEMS` inclusive. */
|
||||
int num_items = 0;
|
||||
for (i = 0; i < NUM_ITEMS; i++) {
|
||||
/* Add numbers negative `1..ITEMS_NUM` inclusive. */
|
||||
int items_num = 0;
|
||||
for (i = 0; i < ITEMS_NUM; i++) {
|
||||
data[i] = (int *)BLI_mempool_alloc(mempool);
|
||||
*data[i] = -(i + 1);
|
||||
num_items++;
|
||||
items_num++;
|
||||
}
|
||||
|
||||
TaskParallelSettings settings;
|
||||
|
|
@ -218,15 +218,15 @@ TEST(task, MempoolIterTLS)
|
|||
|
||||
BLI_task_parallel_mempool(mempool, nullptr, task_mempool_iter_tls_func, &settings);
|
||||
|
||||
EXPECT_EQ(BLI_listbase_count(tls_data.accumulate_items), NUM_ITEMS);
|
||||
EXPECT_EQ(BLI_listbase_count(tls_data.accumulate_items), ITEMS_NUM);
|
||||
|
||||
/* Check that all elements are added into the list once. */
|
||||
int num_accum = 0;
|
||||
int number_accum = 0;
|
||||
for (LinkData *link = (LinkData *)tls_data.accumulate_items->first; link; link = link->next) {
|
||||
int *data = (int *)link->data;
|
||||
num_accum += *data;
|
||||
number_accum += *data;
|
||||
}
|
||||
EXPECT_EQ(num_accum, (NUM_ITEMS * (NUM_ITEMS + 1)) / 2);
|
||||
EXPECT_EQ(number_accum, (ITEMS_NUM * (ITEMS_NUM + 1)) / 2);
|
||||
|
||||
BLI_freelistN(tls_data.accumulate_items);
|
||||
MEM_freeN(tls_data.accumulate_items);
|
||||
|
|
@ -253,31 +253,31 @@ TEST(task, ListBaseIter)
|
|||
{
|
||||
ListBase list = {nullptr, nullptr};
|
||||
LinkData *items_buffer = (LinkData *)MEM_calloc_arrayN(
|
||||
NUM_ITEMS, sizeof(*items_buffer), __func__);
|
||||
ITEMS_NUM, sizeof(*items_buffer), __func__);
|
||||
BLI_threadapi_init();
|
||||
|
||||
int i;
|
||||
|
||||
int num_items = 0;
|
||||
for (i = 0; i < NUM_ITEMS; i++) {
|
||||
int items_num = 0;
|
||||
for (i = 0; i < ITEMS_NUM; i++) {
|
||||
BLI_addtail(&list, &items_buffer[i]);
|
||||
num_items++;
|
||||
items_num++;
|
||||
}
|
||||
|
||||
TaskParallelSettings settings;
|
||||
BLI_parallel_range_settings_defaults(&settings);
|
||||
|
||||
BLI_task_parallel_listbase(&list, &num_items, task_listbase_iter_func, &settings);
|
||||
BLI_task_parallel_listbase(&list, &items_num, task_listbase_iter_func, &settings);
|
||||
|
||||
/* Those checks should ensure us all items of the listbase were processed once, and only once -
|
||||
* as expected. */
|
||||
EXPECT_EQ(num_items, 0);
|
||||
EXPECT_EQ(items_num, 0);
|
||||
LinkData *item;
|
||||
for (i = 0, item = (LinkData *)list.first; i < NUM_ITEMS && item != nullptr;
|
||||
for (i = 0, item = (LinkData *)list.first; i < ITEMS_NUM && item != nullptr;
|
||||
i++, item = item->next) {
|
||||
EXPECT_EQ(POINTER_AS_INT(item->data), i);
|
||||
}
|
||||
EXPECT_EQ(NUM_ITEMS, i);
|
||||
EXPECT_EQ(ITEMS_NUM, i);
|
||||
|
||||
MEM_freeN(items_buffer);
|
||||
BLI_threadapi_exit();
|
||||
|
|
|
|||
|
|
@ -95,12 +95,12 @@ static void task_listbase_heavy_membarrier_iter_func(void *userdata,
|
|||
}
|
||||
|
||||
static void task_listbase_test_do(ListBase *list,
|
||||
const int num_items,
|
||||
int *num_items_tmp,
|
||||
const int items_num,
|
||||
int *items_tmp_num,
|
||||
const char *id,
|
||||
TaskParallelIteratorFunc func,
|
||||
const bool use_threads,
|
||||
const bool check_num_items_tmp)
|
||||
const bool check_items_tmp_num)
|
||||
{
|
||||
TaskParallelSettings settings;
|
||||
BLI_parallel_range_settings_defaults(&settings);
|
||||
|
|
@ -109,24 +109,24 @@ static void task_listbase_test_do(ListBase *list,
|
|||
double averaged_timing = 0.0;
|
||||
for (int i = 0; i < NUM_RUN_AVERAGED; i++) {
|
||||
const double init_time = PIL_check_seconds_timer();
|
||||
BLI_task_parallel_listbase(list, num_items_tmp, func, &settings);
|
||||
BLI_task_parallel_listbase(list, items_tmp_num, func, &settings);
|
||||
averaged_timing += PIL_check_seconds_timer() - init_time;
|
||||
|
||||
/* Those checks should ensure us all items of the listbase were processed once, and only once -
|
||||
* as expected. */
|
||||
if (check_num_items_tmp) {
|
||||
EXPECT_EQ(*num_items_tmp, 0);
|
||||
if (check_items_tmp_num) {
|
||||
EXPECT_EQ(*items_tmp_num, 0);
|
||||
}
|
||||
LinkData *item;
|
||||
int j;
|
||||
for (j = 0, item = (LinkData *)list->first; j < num_items && item != nullptr;
|
||||
for (j = 0, item = (LinkData *)list->first; j < items_num && item != nullptr;
|
||||
j++, item = item->next) {
|
||||
EXPECT_EQ(POINTER_AS_INT(item->data), j);
|
||||
item->data = POINTER_FROM_INT(0);
|
||||
}
|
||||
EXPECT_EQ(num_items, j);
|
||||
EXPECT_EQ(items_num, j);
|
||||
|
||||
*num_items_tmp = num_items;
|
||||
*items_tmp_num = items_num;
|
||||
}
|
||||
|
||||
printf("\t%s: done in %fs on average over %d runs\n",
|
||||
|
|
@ -144,40 +144,40 @@ static void task_listbase_test(const char *id, const int count, const bool use_t
|
|||
|
||||
BLI_threadapi_init();
|
||||
|
||||
int num_items = 0;
|
||||
int items_num = 0;
|
||||
for (int i = 0; i < count; i++) {
|
||||
BLI_addtail(&list, &items_buffer[i]);
|
||||
num_items++;
|
||||
items_num++;
|
||||
}
|
||||
int num_items_tmp = num_items;
|
||||
int items_tmp_num = items_num;
|
||||
|
||||
task_listbase_test_do(&list,
|
||||
num_items,
|
||||
&num_items_tmp,
|
||||
items_num,
|
||||
&items_tmp_num,
|
||||
"Light iter",
|
||||
task_listbase_light_iter_func,
|
||||
use_threads,
|
||||
false);
|
||||
|
||||
task_listbase_test_do(&list,
|
||||
num_items,
|
||||
&num_items_tmp,
|
||||
items_num,
|
||||
&items_tmp_num,
|
||||
"Light iter with mem barrier",
|
||||
task_listbase_light_membarrier_iter_func,
|
||||
use_threads,
|
||||
true);
|
||||
|
||||
task_listbase_test_do(&list,
|
||||
num_items,
|
||||
&num_items_tmp,
|
||||
items_num,
|
||||
&items_tmp_num,
|
||||
"Heavy iter",
|
||||
task_listbase_heavy_iter_func,
|
||||
use_threads,
|
||||
false);
|
||||
|
||||
task_listbase_test_do(&list,
|
||||
num_items,
|
||||
&num_items_tmp,
|
||||
items_num,
|
||||
&items_tmp_num,
|
||||
"Heavy iter with mem barrier",
|
||||
task_listbase_heavy_membarrier_iter_func,
|
||||
use_threads,
|
||||
|
|
|
|||
Loading…
Reference in New Issue