/**
* \brief Reset Walker
*
* Frees all states from the worklist, resetting the walker
* for reuse in a new walk.
*/
void BMW_reset(BMWalker *walker)
{
while (BMW_current_state(walker)) {
BMW_state_remove(walker);
}
walker->depth = 0;
BLI_ghash_free(walker->visithash, NULL, NULL);
BLI_ghash_free(walker->secvisithash, NULL, NULL);
walker->visithash = BLI_ghash_ptr_new("bmesh walkers 1");
walker->secvisithash = BLI_ghash_ptr_new("bmesh walkers sec 1");
}
static void prepare_export_data(Object *object_left, DerivedMesh *dm_left, const DMArrays *dm_left_arrays,
Object *object_right, DerivedMesh *dm_right, const DMArrays *dm_right_arrays,
ExportMeshData *export_data)
{
float object_right_imat[4][4];
invert_m4_m4(export_data->obimat, object_left->obmat);
export_data->ob_left = object_left;
export_data->ob_right = object_right;
export_data->dm_left = dm_left;
export_data->dm_right = dm_right;
export_data->mvert_left = dm_left_arrays->mvert;
export_data->medge_left = dm_left_arrays->medge;
export_data->mloop_left = dm_left_arrays->mloop;
export_data->mpoly_left = dm_left_arrays->mpoly;
export_data->mvert_right = dm_right_arrays->mvert;
export_data->medge_right = dm_right_arrays->medge;
export_data->mloop_right = dm_right_arrays->mloop;
export_data->mpoly_right = dm_right_arrays->mpoly;
export_data->material_hash = BLI_ghash_ptr_new("CSG_mat gh");
/* Matrix to convert coord from left object's loca; space to
* right object's local space.
*/
invert_m4_m4(object_right_imat, object_right->obmat);
mul_m4_m4m4(export_data->left_to_right_mat, object_left->obmat,
object_right_imat);
}
/**
* \brief Init Walker
*
* Allocates and returns a new mesh walker of
* a given type. The elements visited are filtered
* by the bitmask 'searchmask'.
*/
void BMW_init(BMWalker *walker, BMesh *bm, int type,
short mask_vert, short mask_edge, short mask_face,
BMWFlag flag,
int layer)
{
memset(walker, 0, sizeof(BMWalker));
walker->layer = layer;
walker->flag = flag;
walker->bm = bm;
walker->mask_vert = mask_vert;
walker->mask_edge = mask_edge;
walker->mask_face = mask_face;
walker->visithash = BLI_ghash_ptr_new("bmesh walkers 1");
walker->secvisithash = BLI_ghash_ptr_new("bmesh walkers sec 1");
if (UNLIKELY(type >= BMW_MAXWALKERS || type < 0)) {
fprintf(stderr,
"Invalid walker type in BMW_init; type: %d, "
"searchmask: (v:%d, e:%d, f:%d), flag: %d, layer: %d\n",
type, mask_vert, mask_edge, mask_face, flag, layer);
BMESH_ASSERT(0);
}
if (type != BMW_CUSTOM) {
walker->begin = bm_walker_types[type]->begin;
walker->yield = bm_walker_types[type]->yield;
walker->step = bm_walker_types[type]->step;
walker->structsize = bm_walker_types[type]->structsize;
walker->order = bm_walker_types[type]->order;
walker->valid_mask = bm_walker_types[type]->valid_mask;
/* safety checks */
/* if this raises an error either the caller is wrong or
* 'bm_walker_types' needs updating */
BLI_assert(mask_vert == 0 || (walker->valid_mask & BM_VERT));
BLI_assert(mask_edge == 0 || (walker->valid_mask & BM_EDGE));
BLI_assert(mask_face == 0 || (walker->valid_mask & BM_FACE));
}
walker->worklist = BLI_mempool_create(walker->structsize, 100, 100, BLI_MEMPOOL_SYSMALLOC);
walker->states.first = walker->states.last = NULL;
}
static void ui_editsource_active_but_set(uiBut *but)
{
BLI_assert(ui_editsource_info == NULL);
ui_editsource_info = MEM_callocN(sizeof(uiEditSourceStore), __func__);
memcpy(&ui_editsource_info->but_orig, but, sizeof(uiBut));
ui_editsource_info->hash = BLI_ghash_ptr_new(__func__);
}
void make_sss_tree(Render *re)
{
Material *mat;
bool infostr_set = false;
const char *prevstr = NULL;
free_sss(re);
re->sss_hash= BLI_ghash_ptr_new("make_sss_tree gh");
re->stats_draw(re->sdh, &re->i);
for (mat= re->main->mat.first; mat; mat= mat->id.next) {
if (mat->id.us && (mat->flag & MA_IS_USED) && (mat->sss_flag & MA_DIFF_SSS)) {
if (!infostr_set) {
prevstr = re->i.infostr;
re->i.infostr = IFACE_("SSS preprocessing");
infostr_set = true;
}
sss_create_tree_mat(re, mat);
}
}
/* XXX preview exception */
/* localizing preview render data is not fun for node trees :( */
if (re->main!=G.main) {
for (mat= G.main->mat.first; mat; mat= mat->id.next) {
if (mat->id.us && (mat->flag & MA_IS_USED) && (mat->sss_flag & MA_DIFF_SSS)) {
if (!infostr_set) {
prevstr = re->i.infostr;
re->i.infostr = IFACE_("SSS preprocessing");
infostr_set = true;
}
sss_create_tree_mat(re, mat);
}
}
}
if (infostr_set)
re->i.infostr = prevstr;
}
TracksMap *tracks_map_new(const char *object_name, bool is_camera, int num_tracks, int customdata_size)
{
TracksMap *map = MEM_callocN(sizeof(TracksMap), "TrackingsMap");
BLI_strncpy(map->object_name, object_name, sizeof(map->object_name));
map->is_camera = is_camera;
map->num_tracks = num_tracks;
map->customdata_size = customdata_size;
map->tracks = MEM_callocN(sizeof(MovieTrackingTrack) * num_tracks, "TrackingsMap tracks");
if (customdata_size)
map->customdata = MEM_callocN(customdata_size * num_tracks, "TracksMap customdata");
map->hash = BLI_ghash_ptr_new("TracksMap hash");
BLI_spin_init(&map->spin_lock);
return map;
}
void make_sss_tree(Render *re)
{
Material *mat;
re->sss_hash= BLI_ghash_ptr_new("make_sss_tree gh");
re->i.infostr = IFACE_("SSS preprocessing");
re->stats_draw(re->sdh, &re->i);
for (mat= re->main->mat.first; mat; mat= mat->id.next)
if (mat->id.us && (mat->flag & MA_IS_USED) && (mat->sss_flag & MA_DIFF_SSS))
sss_create_tree_mat(re, mat);
/* XXX preview exception */
/* localizing preview render data is not fun for node trees :( */
if (re->main!=G.main) {
for (mat= G.main->mat.first; mat; mat= mat->id.next)
if (mat->id.us && (mat->flag & MA_IS_USED) && (mat->sss_flag & MA_DIFF_SSS))
sss_create_tree_mat(re, mat);
}
}
static void codegen_set_unique_ids(ListBase *nodes)
{
GHash *bindhash, *definehash;
GPUNode *node;
GPUInput *input;
GPUOutput *output;
int id = 1, texid = 0;
bindhash= BLI_ghash_ptr_new("codegen_set_unique_ids1 gh");
definehash= BLI_ghash_ptr_new("codegen_set_unique_ids2 gh");
for (node=nodes->first; node; node=node->next) {
for (input=node->inputs.first; input; input=input->next) {
/* set id for unique names of uniform variables */
input->id = id++;
input->bindtex = 0;
input->definetex = 0;
/* set texid used for settings texture slot with multitexture */
if (codegen_input_has_texture(input) &&
((input->source == GPU_SOURCE_TEX) || (input->source == GPU_SOURCE_TEX_PIXEL)))
{
if (input->link) {
/* input is texture from buffer, assign only one texid per
* buffer to avoid sampling the same texture twice */
if (!BLI_ghash_haskey(bindhash, input->link)) {
input->texid = texid++;
input->bindtex = 1;
BLI_ghash_insert(bindhash, input->link, SET_INT_IN_POINTER(input->texid));
}
else
input->texid = GET_INT_FROM_POINTER(BLI_ghash_lookup(bindhash, input->link));
}
else if (input->ima) {
/* input is texture from image, assign only one texid per
* buffer to avoid sampling the same texture twice */
if (!BLI_ghash_haskey(bindhash, input->ima)) {
input->texid = texid++;
input->bindtex = 1;
BLI_ghash_insert(bindhash, input->ima, SET_INT_IN_POINTER(input->texid));
}
else
input->texid = GET_INT_FROM_POINTER(BLI_ghash_lookup(bindhash, input->ima));
}
else if (input->prv) {
/* input is texture from preview render, assign only one texid per
* buffer to avoid sampling the same texture twice */
if (!BLI_ghash_haskey(bindhash, input->prv)) {
input->texid = texid++;
input->bindtex = 1;
BLI_ghash_insert(bindhash, input->prv, SET_INT_IN_POINTER(input->texid));
}
else
input->texid = GET_INT_FROM_POINTER(BLI_ghash_lookup(bindhash, input->prv));
}
else {
if (!BLI_ghash_haskey(bindhash, input->tex)) {
/* input is user created texture, check tex pointer */
input->texid = texid++;
input->bindtex = 1;
BLI_ghash_insert(bindhash, input->tex, SET_INT_IN_POINTER(input->texid));
}
else
input->texid = GET_INT_FROM_POINTER(BLI_ghash_lookup(bindhash, input->tex));
}
/* make sure this pixel is defined exactly once */
if (input->source == GPU_SOURCE_TEX_PIXEL) {
if (input->ima) {
if (!BLI_ghash_haskey(definehash, input->ima)) {
input->definetex = 1;
BLI_ghash_insert(definehash, input->ima, SET_INT_IN_POINTER(input->texid));
}
}
else {
if (!BLI_ghash_haskey(definehash, input->link)) {
input->definetex = 1;
BLI_ghash_insert(definehash, input->link, SET_INT_IN_POINTER(input->texid));
}
}
}
}
}
for (output=node->outputs.first; output; output=output->next)
/* set id for unique names of tmp variables storing output */
output->id = id++;
}
BLI_ghash_free(bindhash, NULL, NULL);
BLI_ghash_free(definehash, NULL, NULL);
}
static bool scanfill_preprocess_self_isect(
ScanFillContext *sf_ctx,
PolyInfo *poly_info,
const unsigned short poly_nr,
ListBase *filledgebase)
{
PolyInfo *pi = &poly_info[poly_nr];
GHash *isect_hash = NULL;
ListBase isect_lb = {NULL};
/* warning, O(n2) check here, should use spatial lookup */
{
ScanFillEdge *eed;
for (eed = pi->edge_first;
eed;
eed = (eed == pi->edge_last) ? NULL : eed->next)
{
ScanFillEdge *eed_other;
for (eed_other = eed->next;
eed_other;
eed_other = (eed_other == pi->edge_last) ? NULL : eed_other->next)
{
if (!ELEM(eed->v1, eed_other->v1, eed_other->v2) &&
!ELEM(eed->v2, eed_other->v1, eed_other->v2) &&
(eed != eed_other))
{
/* check isect */
float pt[2];
BLI_assert(eed != eed_other);
if (isect_seg_seg_v2_point(eed->v1->co, eed->v2->co,
eed_other->v1->co, eed_other->v2->co,
pt) == 1)
{
ScanFillIsect *isect;
if (UNLIKELY(isect_hash == NULL)) {
isect_hash = BLI_ghash_ptr_new(__func__);
}
isect = MEM_mallocN(sizeof(ScanFillIsect), __func__);
BLI_addtail(&isect_lb, isect);
copy_v2_v2(isect->co, pt);
isect->co[2] = eed->v1->co[2];
isect->v = BLI_scanfill_vert_add(sf_ctx, isect->co);
isect->v->poly_nr = eed->v1->poly_nr; /* NOTE: vert may belong to 2 polys now */
VFLAG_SET(isect->v, V_ISISECT);
edge_isect_ls_add(isect_hash, eed, isect);
edge_isect_ls_add(isect_hash, eed_other, isect);
}
}
}
}
}
if (isect_hash == NULL) {
return false;
}
/* now subdiv the edges */
{
ScanFillEdge *eed;
for (eed = pi->edge_first;
eed;
eed = (eed == pi->edge_last) ? NULL : eed->next)
{
if (eed->user_flag & E_ISISECT) {
ListBase *e_ls = BLI_ghash_lookup(isect_hash, eed);
LinkData *isect_link;
/* maintain coorect terminating edge */
if (pi->edge_last == eed) {
pi->edge_last = NULL;
}
if (BLI_listbase_is_single(e_ls) == false) {
BLI_sortlist_r(e_ls, eed->v2->co, edge_isect_ls_sort_cb);
}
/* move original edge to filledgebase and add replacement
* (which gets subdivided next) */
{
ScanFillEdge *eed_tmp;
eed_tmp = BLI_scanfill_edge_add(sf_ctx, eed->v1, eed->v2);
BLI_remlink(&sf_ctx->filledgebase, eed_tmp);
BLI_insertlinkafter(&sf_ctx->filledgebase, eed, eed_tmp);
BLI_remlink(&sf_ctx->filledgebase, eed);
BLI_addtail(filledgebase, eed);
if (pi->edge_first == eed) {
pi->edge_first = eed_tmp;
}
eed = eed_tmp;
}
for (isect_link = e_ls->first; isect_link; isect_link = isect_link->next) {
ScanFillIsect *isect = isect_link->data;
ScanFillEdge *eed_subd;
eed_subd = BLI_scanfill_edge_add(sf_ctx, isect->v, eed->v2);
eed_subd->poly_nr = poly_nr;
eed->v2 = isect->v;
BLI_remlink(&sf_ctx->filledgebase, eed_subd);
BLI_insertlinkafter(&sf_ctx->filledgebase, eed, eed_subd);
/* step to the next edge and continue dividing */
eed = eed_subd;
}
BLI_freelistN(e_ls);
MEM_freeN(e_ls);
if (pi->edge_last == NULL) {
pi->edge_last = eed;
}
}
}
}
BLI_freelistN(&isect_lb);
BLI_ghash_free(isect_hash, NULL, NULL);
{
ScanFillEdge *e_init;
ScanFillEdge *e_curr;
ScanFillEdge *e_next;
ScanFillVert *v_prev;
ScanFillVert *v_curr;
int inside = false;
/* first vert */
#if 0
e_init = pi->edge_last;
e_curr = e_init;
e_next = pi->edge_first;
v_prev = e_curr->v1;
v_curr = e_curr->v2;
#else
/* find outside vertex */
{
ScanFillEdge *eed;
ScanFillEdge *eed_prev;
float min_x = FLT_MAX;
e_curr = pi->edge_last;
e_next = pi->edge_first;
eed_prev = pi->edge_last;
for (eed = pi->edge_first;
eed;
eed = (eed == pi->edge_last) ? NULL : eed->next)
{
if (eed->v2->co[0] < min_x) {
min_x = eed->v2->co[0];
e_curr = eed_prev;
e_next = eed;
}
eed_prev = eed;
}
e_init = e_curr;
v_prev = e_curr->v1;
v_curr = e_curr->v2;
}
#endif
BLI_assert(e_curr->poly_nr == poly_nr);
BLI_assert(pi->edge_last->poly_nr == poly_nr);
do {
ScanFillVert *v_next;
v_next = (e_next->v1 == v_curr) ? e_next->v2 : e_next->v1;
BLI_assert(ELEM(v_curr, e_next->v1, e_next->v2));
/* track intersections */
if (inside) {
EFLAG_SET(e_next, E_ISDELETE);
}
if (v_next->user_flag & V_ISISECT) {
inside = !inside;
}
/* now step... */
v_prev = v_curr;
v_curr = v_next;
e_curr = e_next;
e_next = edge_step(poly_info, poly_nr, v_prev, v_curr, e_curr);
} while (e_curr != e_init);
}
return true;
}
static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
{
Main *bmain = CTX_data_main(BPy_GetContext());
Main *mainl = NULL;
int err = 0;
BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, true);
/* here appending/linking starts */
mainl = BLO_library_link_begin(bmain, &(self->blo_handle), self->relpath);
{
int idcode_step = 0, idcode;
while ((idcode = BKE_idcode_iter_step(&idcode_step))) {
if (BKE_idcode_is_linkable(idcode)) {
const char *name_plural = BKE_idcode_to_name_plural(idcode);
PyObject *ls = PyDict_GetItemString(self->dict, name_plural);
// printf("lib: %s\n", name_plural);
if (ls && PyList_Check(ls)) {
/* loop */
Py_ssize_t size = PyList_GET_SIZE(ls);
Py_ssize_t i;
for (i = 0; i < size; i++) {
PyObject *item_src = PyList_GET_ITEM(ls, i);
PyObject *item_dst; /* must be set below */
const char *item_idname = _PyUnicode_AsString(item_src);
// printf(" %s\n", item_idname);
if (item_idname) {
ID *id = BLO_library_link_named_part(mainl, &(self->blo_handle), idcode, item_idname);
if (id) {
#ifdef USE_RNA_DATABLOCKS
/* swap name for pointer to the id */
item_dst = PyCapsule_New((void *)id, NULL, NULL);
#else
/* leave as is */
continue;
#endif
}
else {
bpy_lib_exit_warn_idname(self, name_plural, item_idname);
/* just warn for now */
/* err = -1; */
item_dst = Py_INCREF_RET(Py_None);
}
/* ID or None */
}
else {
/* XXX, could complain about this */
bpy_lib_exit_warn_type(self, item_src);
PyErr_Clear();
item_dst = Py_INCREF_RET(Py_None);
}
/* item_dst must be new or already incref'd */
Py_DECREF(item_src);
PyList_SET_ITEM(ls, i, item_dst);
}
}
}
}
}
if (err == -1) {
/* exception raised above, XXX, this leaks some memory */
BLO_blendhandle_close(self->blo_handle);
self->blo_handle = NULL;
BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, false);
return NULL;
}
else {
Library *lib = mainl->curlib; /* newly added lib, assign before append end */
BLO_library_link_end(mainl, &(self->blo_handle), self->flag, NULL, NULL);
BLO_blendhandle_close(self->blo_handle);
self->blo_handle = NULL;
GHash *old_to_new_ids = BLI_ghash_ptr_new(__func__);
/* copied from wm_operator.c */
{
/* mark all library linked objects to be updated */
BKE_main_lib_objects_recalc_all(bmain);
/* append, rather than linking */
if ((self->flag & FILE_LINK) == 0) {
BKE_library_make_local(bmain, lib, old_to_new_ids, true, false);
}
}
BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, false);
/* finally swap the capsules for real bpy objects
* important since BLO_library_append_end initializes NodeTree types used by srna->refine */
#ifdef USE_RNA_DATABLOCKS
{
int idcode_step = 0, idcode;
while ((idcode = BKE_idcode_iter_step(&idcode_step))) {
if (BKE_idcode_is_linkable(idcode)) {
const char *name_plural = BKE_idcode_to_name_plural(idcode);
PyObject *ls = PyDict_GetItemString(self->dict, name_plural);
if (ls && PyList_Check(ls)) {
Py_ssize_t size = PyList_GET_SIZE(ls);
Py_ssize_t i;
PyObject *item;
for (i = 0; i < size; i++) {
item = PyList_GET_ITEM(ls, i);
if (PyCapsule_CheckExact(item)) {
PointerRNA id_ptr;
ID *id;
id = PyCapsule_GetPointer(item, NULL);
id = BLI_ghash_lookup_default(old_to_new_ids, id, id);
Py_DECREF(item);
RNA_id_pointer_create(id, &id_ptr);
item = pyrna_struct_CreatePyObject(&id_ptr);
PyList_SET_ITEM(ls, i, item);
}
}
}
}
}
}
#endif /* USE_RNA_DATABLOCKS */
BLI_ghash_free(old_to_new_ids, NULL, NULL);
Py_RETURN_NONE;
}
}
