void tag_main(struct Main *mainvar, const short tag)
{
ListBase *lbarray[MAX_LIBARRAY];
int a;
a= set_listbasepointers(mainvar, lbarray);
while(a--) {
tag_main_lb(lbarray[a], tag);
}
}
static int objects_add_active_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_context(C);
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
int group_object_index = RNA_enum_get(op->ptr, "group");
int is_cycle = FALSE;
if (ob) {
Group *group = group_object_active_find_index(ob, group_object_index);
/* now add all selected objects from the group */
if (group) {
/* for recursive check */
tag_main_lb(&bmain->group, TRUE);
CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
{
if (group_link_early_exit_check(group, base->object))
continue;
if (base->object->dup_group != group && !check_group_contains_object_recursive(group, base->object)) {
BKE_group_object_add(group, base->object, scene, base);
}
else {
is_cycle = TRUE;
}
}
CTX_DATA_END;
if (is_cycle) {
BKE_report(op->reports, RPT_WARNING, "Skipped some groups because of cycle detected");
}
DAG_relations_tag_update(bmain);
WM_event_add_notifier(C, NC_GROUP | NA_EDITED, NULL);
return OPERATOR_FINISHED;
}
}
return OPERATOR_CANCELLED;
}
void rna_Main_shape_keys_tag(Main *bmain, int value) { tag_main_lb(&bmain->key, value); }
void rna_Main_materials_tag(Main *bmain, int value) { tag_main_lb(&bmain->mat, value); }
void rna_Main_groups_tag(Main *bmain, int value) { tag_main_lb(&bmain->group, value); }
void rna_Main_particles_tag(Main *bmain, int value) { tag_main_lb(&bmain->particle, value); }
/* returns 0 if nothing was handled */
int RE_bake_shade_all_selected(Render *re, int type, Object *actob, short *do_update, float *progress)
{
BakeShade *handles;
ListBase threads;
Image *ima;
int a, vdone = false, result = BAKE_RESULT_OK;
bool use_mask = false;
bool use_displacement_buffer = false;
re->scene_color_manage = BKE_scene_check_color_management_enabled(re->scene);
/* initialize render global */
R = *re;
R.bakebuf = NULL;
/* initialize static vars */
get_next_bake_face(NULL);
/* do we need a mask? */
if (re->r.bake_filter)
use_mask = true;
/* do we need buffer to store displacements */
if (ELEM(type, RE_BAKE_DISPLACEMENT, RE_BAKE_DERIVATIVE)) {
if (((R.r.bake_flag & R_BAKE_NORMALIZE) && R.r.bake_maxdist == 0.0f) ||
(type == RE_BAKE_DERIVATIVE))
{
use_displacement_buffer = true;
use_mask = true;
}
}
/* baker uses this flag to detect if image was initialized */
if ((R.r.bake_flag & R_BAKE_VCOL) == 0) {
for (ima = G.main->image.first; ima; ima = ima->id.next) {
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL, IMA_IBUF_IMA);
ima->id.flag |= LIB_DOIT;
ima->flag &= ~IMA_USED_FOR_RENDER;
if (ibuf) {
ibuf->userdata = NULL; /* use for masking if needed */
}
BKE_image_release_ibuf(ima, ibuf, NULL);
}
}
if (R.r.bake_flag & R_BAKE_VCOL) {
/* untag all meshes */
tag_main_lb(&G.main->mesh, false);
}
BLI_init_threads(&threads, do_bake_thread, re->r.threads);
handles = MEM_callocN(sizeof(BakeShade) * re->r.threads, "BakeShade");
/* get the threads running */
for (a = 0; a < re->r.threads; a++) {
/* set defaults in handles */
handles[a].ssamp.shi[0].lay = re->lay;
if (type == RE_BAKE_SHADOW) {
handles[a].ssamp.shi[0].passflag = SCE_PASS_SHADOW;
}
else {
handles[a].ssamp.shi[0].passflag = SCE_PASS_COMBINED;
}
handles[a].ssamp.shi[0].combinedflag = ~(SCE_PASS_SPEC);
handles[a].ssamp.shi[0].thread = a;
handles[a].ssamp.tot = 1;
handles[a].type = type;
handles[a].actob = actob;
if (R.r.bake_flag & R_BAKE_VCOL)
handles[a].zspan = NULL;
else
handles[a].zspan = MEM_callocN(sizeof(ZSpan), "zspan for bake");
handles[a].use_mask = use_mask;
handles[a].use_displacement_buffer = use_displacement_buffer;
handles[a].do_update = do_update; /* use to tell the view to update */
handles[a].displacement_min = FLT_MAX;
handles[a].displacement_max = -FLT_MAX;
BLI_insert_thread(&threads, &handles[a]);
}
/* wait for everything to be done */
a = 0;
while (a != re->r.threads) {
PIL_sleep_ms(50);
/* calculate progress */
for (vdone = false, a = 0; a < re->r.threads; a++)
vdone += handles[a].vdone;
if (progress)
*progress = (float)(vdone / (float)re->totvlak);
for (a = 0; a < re->r.threads; a++) {
if (handles[a].ready == false) {
break;
}
}
}
/* filter and refresh images */
if ((R.r.bake_flag & R_BAKE_VCOL) == 0) {
float displacement_min = FLT_MAX, displacement_max = -FLT_MAX;
if (use_displacement_buffer) {
for (a = 0; a < re->r.threads; a++) {
displacement_min = min_ff(displacement_min, handles[a].displacement_min);
displacement_max = max_ff(displacement_max, handles[a].displacement_max);
}
}
for (ima = G.main->image.first; ima; ima = ima->id.next) {
if ((ima->id.flag & LIB_DOIT) == 0) {
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL, IMA_IBUF_IMA);
BakeImBufuserData *userdata;
if (ima->flag & IMA_USED_FOR_RENDER)
result = BAKE_RESULT_FEEDBACK_LOOP;
if (!ibuf)
continue;
userdata = (BakeImBufuserData *)ibuf->userdata;
if (userdata) {
if (use_displacement_buffer) {
if (type == RE_BAKE_DERIVATIVE) {
float user_scale = (R.r.bake_flag & R_BAKE_USERSCALE) ? R.r.bake_user_scale : -1.0f;
RE_bake_make_derivative(ibuf, userdata->displacement_buffer, userdata->mask_buffer,
displacement_min, displacement_max, user_scale);
}
else {
RE_bake_ibuf_normalize_displacement(ibuf, userdata->displacement_buffer, userdata->mask_buffer,
displacement_min, displacement_max);
}
}
RE_bake_ibuf_filter(ibuf, userdata->mask_buffer, re->r.bake_filter);
}
ibuf->userflags |= IB_BITMAPDIRTY;
BKE_image_release_ibuf(ima, ibuf, NULL);
}
}
/* calculate return value */
for (a = 0; a < re->r.threads; a++) {
zbuf_free_span(handles[a].zspan);
MEM_freeN(handles[a].zspan);
}
}
MEM_freeN(handles);
BLI_end_threads(&threads);
if (vdone == 0) {
result = BAKE_RESULT_NO_OBJECTS;
}
return result;
}
void rna_Main_speakers_tag(Main *bmain, int value) { tag_main_lb(&bmain->speaker, value); }
void rna_Main_armatures_tag(Main *bmain, int value) { tag_main_lb(&bmain->armature, value); }
void rna_Main_images_tag(Main *bmain, int value) { tag_main_lb(&bmain->image, value); }
void rna_Main_lattices_tag(Main *bmain, int value) { tag_main_lb(&bmain->latt, value); }
void rna_Main_screens_tag(Main *bmain, int value) { tag_main_lb(&bmain->screen, value); }
void rna_Main_window_managers_tag(Main *bmain, int value) { tag_main_lb(&bmain->wm, value); }
void rna_Main_libraries_tag(Main *bmain, int value) { tag_main_lb(&bmain->library, value); }
void rna_Main_lamps_tag(Main *bmain, int value) { tag_main_lb(&bmain->lamp, value); }
void rna_Main_node_groups_tag(Main *bmain, int value) { tag_main_lb(&bmain->nodetree, value); }
void rna_Main_scripts_tag(Main *bmain, int value) { tag_main_lb(&bmain->script, value); }
void rna_Main_curves_tag(Main *bmain, int value) { tag_main_lb(&bmain->curve, value); }
void rna_Main_texts_tag(Main *bmain, int value) { tag_main_lb(&bmain->text, value); }
void rna_Main_metaballs_tag(Main *bmain, int value) { tag_main_lb(&bmain->mball, value); }
void rna_Main_sounds_tag(Main *bmain, int value) { tag_main_lb(&bmain->sound, value); }
void rna_Main_fonts_tag(Main *bmain, int value) { tag_main_lb(&bmain->vfont, value); }
void rna_Main_actions_tag(Main *bmain, int value) { tag_main_lb(&bmain->action, value); }
void tag_main_idcode(struct Main *mainvar, const short type, const short tag)
{
ListBase *lb= which_libbase(mainvar, type);
tag_main_lb(lb, tag);
}
void rna_Main_gpencil_tag(Main *bmain, int value) { tag_main_lb(&bmain->gpencil, value); }
void rna_Main_scenes_tag(Main *bmain, int value) { tag_main_lb(&bmain->scene, value); }
void rna_Main_brushes_tag(Main *bmain, int value) { tag_main_lb(&bmain->brush, value); }
void rna_Main_objects_tag(Main *bmain, int value) { tag_main_lb(&bmain->object, value); }
void rna_Main_worlds_tag(Main *bmain, int value) { tag_main_lb(&bmain->world, value); }
/* tag functions, all the same */
void rna_Main_cameras_tag(Main *bmain, int value) { tag_main_lb(&bmain->camera, value); }
