/* for effector add primitive operators */
static Object *effector_add_type(bContext *C, int type)
{
Scene *scene= CTX_data_scene(C);
Object *ob;
/* for as long scene has editmode... */
if (CTX_data_edit_object(C))
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO); /* freedata, and undo */
/* deselects all, sets scene->basact */
if(type==PFIELD_GUIDE) {
ob = add_object(scene, OB_CURVE);
((Curve*)ob->data)->flag |= CU_PATH|CU_3D;
ED_object_enter_editmode(C, 0);
BLI_addtail(curve_get_editcurve(ob), add_nurbs_primitive(C, CU_NURBS|CU_PRIM_PATH, 1));
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
}
else
ob= add_object(scene, OB_EMPTY);
ob->pd= object_add_collision_fields(type);
/* editor level activate, notifiers */
ED_base_object_activate(C, BASACT);
/* more editor stuff */
ED_object_base_init_from_view(C, BASACT);
DAG_scene_sort(scene);
return ob;
}
static int object_add_surface_exec(bContext *C, wmOperator *op)
{
Object *obedit= CTX_data_edit_object(C);
ListBase *editnurb;
Nurb *nu;
int newob= 0;
if(obedit==NULL || obedit->type!=OB_SURF) {
ED_object_add_type(C, OB_SURF);
ED_object_enter_editmode(C, 0);
newob = 1;
}
else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
obedit= CTX_data_edit_object(C);
nu= add_nurbs_primitive(C, RNA_enum_get(op->ptr, "type"), newob);
editnurb= curve_get_editcurve(obedit);
BLI_addtail(editnurb, nu);
/* userdef */
if (newob && (U.flag & USER_ADD_EDITMODE)==0) {
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
}
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
static int object_metaball_add_exec(bContext *C, wmOperator *op)
{
Object *obedit= CTX_data_edit_object(C);
MetaBall *mball;
MetaElem *elem;
int newob= 0;
if(obedit==NULL || obedit->type!=OB_MBALL) {
ED_object_add_type(C, OB_MBALL);
ED_object_enter_editmode(C, 0);
newob = 1;
}
else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
obedit= CTX_data_edit_object(C);
elem= (MetaElem*)add_metaball_primitive(C, RNA_enum_get(op->ptr, "type"), newob);
mball= (MetaBall*)obedit->data;
BLI_addtail(mball->editelems, elem);
/* userdef */
if (newob && (U.flag & USER_ADD_EDITMODE)==0) {
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
}
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
/* ***************** add primitives *************** */
static int object_metaball_add_exec(bContext *C, wmOperator *op)
{
Object *obedit= CTX_data_edit_object(C);
/*MetaElem *elem;*/ /*UNUSED*/
int newob= 0;
int enter_editmode;
unsigned int layer;
float loc[3], rot[3];
float mat[4][4];
object_add_generic_invoke_options(C, op); // XXX these props don't get set right when only exec() is called
if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer))
return OPERATOR_CANCELLED;
if(obedit==NULL || obedit->type!=OB_MBALL) {
obedit= ED_object_add_type(C, OB_MBALL, loc, rot, TRUE, layer);
newob = 1;
}
else DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
/* elem= (MetaElem *) */ add_metaball_primitive(C, mat, RNA_enum_get(op->ptr, "type"), newob);
/* userdef */
if (newob && !enter_editmode) {
ED_object_exit_editmode(C, EM_FREEDATA);
}
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
static int object_armature_add_exec(bContext *C, wmOperator *op)
{
Object *obedit= CTX_data_edit_object(C);
View3D *v3d= CTX_wm_view3d(C);
RegionView3D *rv3d= NULL;
int newob= 0;
if ((obedit==NULL) || (obedit->type != OB_ARMATURE)) {
ED_object_add_type(C, OB_ARMATURE);
ED_object_enter_editmode(C, 0);
newob = 1;
}
else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
if(v3d)
rv3d= CTX_wm_region(C)->regiondata;
/* v3d and rv3d are allowed to be NULL */
add_primitive_bone(CTX_data_scene(C), v3d, rv3d);
/* userdef */
if (newob && (U.flag & USER_ADD_EDITMODE)==0) {
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
}
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
/* do not call undo push in this function (users of this function have to) */
Object *ED_object_add_type(bContext *C, int type, float *loc, float *rot, int enter_editmode, unsigned int layer)
{
Main *bmain= CTX_data_main(C);
Scene *scene= CTX_data_scene(C);
Object *ob;
/* for as long scene has editmode... */
if (CTX_data_edit_object(C))
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO); /* freedata, and undo */
/* deselects all, sets scene->basact */
ob= add_object(scene, type);
BASACT->lay = ob->lay = layer;
/* editor level activate, notifiers */
ED_base_object_activate(C, BASACT);
/* more editor stuff */
ED_object_base_init_transform(C, BASACT, loc, rot);
DAG_scene_sort(bmain, scene);
ED_render_id_flush_update(bmain, ob->data);
if(enter_editmode)
ED_object_enter_editmode(C, EM_IGNORE_LAYER);
WM_event_add_notifier(C, NC_SCENE|ND_LAYER_CONTENT, scene);
return ob;
}
void WM_write_file(bContext *C, char *target, int fileflags, ReportList *reports)
{
Library *li;
int len;
char di[FILE_MAX];
len = strlen(target);
if (len == 0) return;
if (len >= FILE_MAX) {
BKE_report(reports, RPT_ERROR, "Path too long, cannot save");
return;
}
/* send the OnSave event */
for (li= G.main->library.first; li; li= li->id.next) {
if (BLI_streq(li->name, target)) {
BKE_report(reports, RPT_ERROR, "Cannot overwrite used library");
return;
}
}
if (!BLO_has_bfile_extension(target) && (len+6 < FILE_MAX)) {
sprintf(di, "%s.blend", target);
} else {
strcpy(di, target);
}
// if (BLI_exists(di)) {
// XXX if(!saveover(di))
// XXX return;
// }
if (G.fileflags & G_AUTOPACK) {
packAll(G.main, reports);
}
ED_object_exit_editmode(C, EM_DO_UNDO);
do_history(di, reports);
if (BLO_write_file(CTX_data_main(C), di, fileflags, reports)) {
strcpy(G.sce, di);
G.relbase_valid = 1;
strcpy(G.main->name, di); /* is guaranteed current file */
G.save_over = 1; /* disable untitled.blend convention */
if(fileflags & G_FILE_COMPRESS) G.fileflags |= G_FILE_COMPRESS;
else G.fileflags &= ~G_FILE_COMPRESS;
writeBlog();
}
// XXX waitcursor(0);
}
static int editmode_toggle_exec(bContext *C, wmOperator *UNUSED(op))
{
ToolSettings *toolsettings = CTX_data_tool_settings(C);
if (!CTX_data_edit_object(C))
ED_object_enter_editmode(C, EM_WAITCURSOR);
else
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR); /* had EM_DO_UNDO but op flag calls undo too [#24685] */
ED_space_image_uv_sculpt_update(CTX_wm_manager(C), toolsettings);
return OPERATOR_FINISHED;
}
static void object_delete_cb(bContext *C, Scene *scene, TreeElement *te, TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem)
{
Base *base= (Base *)te->directdata;
if (base==NULL)
base= object_in_scene((Object *)tselem->id, scene);
if (base) {
// check also library later
if (scene->obedit==base->object)
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO);
ED_base_object_free_and_unlink(CTX_data_main(C), scene, base);
te->directdata= NULL;
tselem->id= NULL;
}
}
static int tree_element_set_active_object(bContext *C, Scene *scene, SpaceOops *soops, TreeElement *te, int set)
{
TreeStoreElem *tselem= TREESTORE(te);
Scene *sce;
Base *base;
Object *ob= NULL;
/* if id is not object, we search back */
if(te->idcode==ID_OB) ob= (Object *)tselem->id;
else {
ob= (Object *)outliner_search_back(soops, te, ID_OB);
if(ob==OBACT) return 0;
}
if(ob==NULL) return 0;
sce= (Scene *)outliner_search_back(soops, te, ID_SCE);
if(sce && scene != sce) {
ED_screen_set_scene(C, sce);
}
/* find associated base in current scene */
base= object_in_scene(ob, scene);
if(base) {
if(set==2) {
/* swap select */
if(base->flag & SELECT)
ED_base_object_select(base, BA_DESELECT);
else
ED_base_object_select(base, BA_SELECT);
}
else {
/* deleselect all */
scene_deselect_all(scene);
ED_base_object_select(base, BA_SELECT);
}
if(C) {
ED_base_object_activate(C, base); /* adds notifier */
WM_event_add_notifier(C, NC_SCENE|ND_OB_SELECT, scene);
}
}
if(ob!=scene->obedit)
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO);
return 1;
}
static void make_prim_finish(bContext *C, int *state, int enter_editmode)
{
Object *obedit = CTX_data_edit_object(C);
BMEditMesh *em = BMEdit_FromObject(obedit);
/* Primitive has all verts selected, use vert select flush
* to push this up to edges & faces. */
EDBM_selectmode_flush_ex(em, SCE_SELECT_VERTEX);
EDBM_update_generic(C, em, TRUE);
/* userdef */
if (*state && !enter_editmode) {
ED_object_exit_editmode(C, EM_FREEDATA); /* adding EM_DO_UNDO messes up operator redo */
}
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
}
/* for effector add primitive operators */
static Object *effector_add_type(bContext *C, wmOperator *op, int type)
{
Object *ob;
int enter_editmode;
unsigned int layer;
float loc[3], rot[3];
float mat[4][4];
object_add_generic_invoke_options(C, op);
if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer))
return NULL;
if(type==PFIELD_GUIDE) {
ob= ED_object_add_type(C, OB_CURVE, loc, rot, FALSE, layer);
rename_id(&ob->id, "CurveGuide");
((Curve*)ob->data)->flag |= CU_PATH|CU_3D;
ED_object_enter_editmode(C, 0);
ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
BLI_addtail(curve_get_editcurve(ob), add_nurbs_primitive(C, mat, CU_NURBS|CU_PRIM_PATH, 1));
if(!enter_editmode)
ED_object_exit_editmode(C, EM_FREEDATA);
}
else {
ob= ED_object_add_type(C, OB_EMPTY, loc, rot, FALSE, layer);
rename_id(&ob->id, "Field");
switch(type) {
case PFIELD_WIND:
case PFIELD_VORTEX:
ob->empty_drawtype = OB_SINGLE_ARROW;
break;
}
}
ob->pd= object_add_collision_fields(type);
DAG_scene_sort(CTX_data_main(C), CTX_data_scene(C));
return ob;
}
static int posemode_exec(bContext *C, wmOperator *UNUSED(op))
{
Base *base= CTX_data_active_base(C);
if (base->object->type==OB_ARMATURE) {
if (base->object==CTX_data_edit_object(C)) {
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
ED_armature_enter_posemode(C, base);
}
else if (base->object->mode & OB_MODE_POSE)
ED_armature_exit_posemode(C, base);
else
ED_armature_enter_posemode(C, base);
return OPERATOR_FINISHED;
}
return OPERATOR_PASS_THROUGH;
}
static int tree_element_active_pose(bContext *C, Scene *scene, TreeElement *UNUSED(te), TreeStoreElem *tselem, int set)
{
Object *ob= (Object *)tselem->id;
Base *base= object_in_scene(ob, scene);
if(set) {
if(scene->obedit)
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO);
if(ob->mode & OB_MODE_POSE)
ED_armature_exit_posemode(C, base);
else
ED_armature_enter_posemode(C, base);
}
else {
if(ob->mode & OB_MODE_POSE) return 1;
}
return 0;
}
/* for object add primitive operators */
Object *ED_object_add_type(bContext *C, int type)
{
Scene *scene= CTX_data_scene(C);
Object *ob;
/* for as long scene has editmode... */
if (CTX_data_edit_object(C))
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO); /* freedata, and undo */
/* deselects all, sets scene->basact */
ob= add_object(scene, type);
/* editor level activate, notifiers */
ED_base_object_activate(C, BASACT);
/* more editor stuff */
ED_object_base_init_from_view(C, BASACT);
DAG_scene_sort(scene);
return ob;
}
static void make_prim_ext(bContext *C, float *loc, float *rot, int enter_editmode, unsigned int layer,
int type, int tot, int seg,
int subdiv, float dia, float depth, int ext, int fill)
{
Object *obedit= CTX_data_edit_object(C);
int newob = 0;
float mat[4][4];
float scale;
if(obedit==NULL || obedit->type!=OB_MESH) {
obedit= ED_object_add_type(C, OB_MESH, loc, rot, FALSE, layer);
rename_id((ID *)obedit, get_mesh_defname(type));
rename_id((ID *)obedit->data, get_mesh_defname(type));
/* create editmode */
ED_object_enter_editmode(C, EM_DO_UNDO|EM_IGNORE_LAYER); /* rare cases the active layer is messed up */
newob = 1;
}
else DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
scale= ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
dia *= scale;
depth *= scale * 0.5f;
make_prim(obedit, type, mat, tot, seg, subdiv, dia, depth, ext, fill);
DAG_id_tag_update(obedit->data, 0);
WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
/* userdef */
if (newob && !enter_editmode) {
ED_object_exit_editmode(C, EM_FREEDATA); /* adding EM_DO_UNDO messes up operator redo */
}
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
}
static int object_armature_add_exec(bContext *C, wmOperator *op)
{
Object *obedit= CTX_data_edit_object(C);
View3D *v3d= CTX_wm_view3d(C);
RegionView3D *rv3d= CTX_wm_region_view3d(C);
int newob= 0;
int enter_editmode;
unsigned int layer;
float loc[3], rot[3];
object_add_generic_invoke_options(C, op); // XXX these props don't get set right when only exec() is called
if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer))
return OPERATOR_CANCELLED;
if ((obedit==NULL) || (obedit->type != OB_ARMATURE)) {
obedit= ED_object_add_type(C, OB_ARMATURE, loc, rot, TRUE, layer);
ED_object_enter_editmode(C, 0);
newob = 1;
}
else DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
if(obedit==NULL) {
BKE_report(op->reports, RPT_ERROR, "Cannot create editmode armature.");
return OPERATOR_CANCELLED;
}
/* v3d and rv3d are allowed to be NULL */
add_primitive_bone(CTX_data_scene(C), v3d, rv3d);
/* userdef */
if (newob && !enter_editmode)
ED_object_exit_editmode(C, EM_FREEDATA);
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
static Object* createRepresentation(bContext *C, struct recast_polyMesh *pmesh, struct recast_polyMeshDetail *dmesh, Base* base)
{
float co[3], rot[3];
EditMesh *em;
int i,j, k;
unsigned short* v;
int face[3];
Scene *scene= CTX_data_scene(C);
Object* obedit;
int createob= base==NULL;
int nverts, nmeshes, nvp;
unsigned short *verts, *polys;
unsigned int *meshes;
float bmin[3], cs, ch, *dverts;
unsigned char *tris;
zero_v3(co);
zero_v3(rot);
if(createob) {
/* create new object */
obedit= ED_object_add_type(C, OB_MESH, co, rot, FALSE, 1);
}
else {
obedit= base->object;
scene_select_base(scene, base);
copy_v3_v3(obedit->loc, co);
copy_v3_v3(obedit->rot, rot);
}
ED_object_enter_editmode(C, EM_DO_UNDO|EM_IGNORE_LAYER);
em= BKE_mesh_get_editmesh(((Mesh *)obedit->data));
if(!createob) {
/* clear */
if(em->verts.first) free_vertlist(em, &em->verts);
if(em->edges.first) free_edgelist(em, &em->edges);
if(em->faces.first) free_facelist(em, &em->faces);
if(em->selected.first) BLI_freelistN(&(em->selected));
}
/* create verts for polygon mesh */
verts= recast_polyMeshGetVerts(pmesh, &nverts);
recast_polyMeshGetBoundbox(pmesh, bmin, NULL);
recast_polyMeshGetCell(pmesh, &cs, &ch);
for(i= 0; i<nverts; i++) {
v= &verts[3*i];
co[0]= bmin[0] + v[0]*cs;
co[1]= bmin[1] + v[1]*ch;
co[2]= bmin[2] + v[2]*cs;
SWAP(float, co[1], co[2]);
addvertlist(em, co, NULL);
}
/* create custom data layer to save polygon idx */
CustomData_add_layer_named(&em->fdata, CD_RECAST, CD_CALLOC, NULL, 0, "createRepresentation recastData");
/* create verts and faces for detailed mesh */
meshes= recast_polyMeshDetailGetMeshes(dmesh, &nmeshes);
polys= recast_polyMeshGetPolys(pmesh, NULL, &nvp);
dverts= recast_polyMeshDetailGetVerts(dmesh, NULL);
tris= recast_polyMeshDetailGetTris(dmesh, NULL);
for(i= 0; i<nmeshes; i++) {
int uniquevbase= em->totvert;
unsigned int vbase= meshes[4*i+0];
unsigned short ndv= meshes[4*i+1];
unsigned short tribase= meshes[4*i+2];
unsigned short trinum= meshes[4*i+3];
const unsigned short* p= &polys[i*nvp*2];
int nv= 0;
for(j= 0; j < nvp; ++j) {
if(p[j]==0xffff) break;
nv++;
}
/* create unique verts */
for(j= nv; j<ndv; j++) {
copy_v3_v3(co, &dverts[3*(vbase + j)]);
SWAP(float, co[1], co[2]);
addvertlist(em, co, NULL);
}
EM_init_index_arrays(em, 1, 0, 0);
/* create faces */
for(j= 0; j<trinum; j++) {
unsigned char* tri= &tris[4*(tribase+j)];
EditFace* newFace;
int* polygonIdx;
for(k= 0; k<3; k++) {
if(tri[k]<nv)
face[k]= p[tri[k]]; /* shared vertex */
else
face[k]= uniquevbase+tri[k]-nv; /* unique vertex */
}
newFace= addfacelist(em, EM_get_vert_for_index(face[0]), EM_get_vert_for_index(face[2]),
EM_get_vert_for_index(face[1]), NULL, NULL, NULL);
/* set navigation polygon idx to the custom layer */
polygonIdx= (int*)CustomData_em_get(&em->fdata, newFace->data, CD_RECAST);
*polygonIdx= i+1; /* add 1 to avoid zero idx */
}
EM_free_index_arrays();
}
recast_destroyPolyMesh(pmesh);
recast_destroyPolyMeshDetail(dmesh);
BKE_mesh_end_editmesh((Mesh*)obedit->data, em);
DAG_id_tag_update((ID*)obedit->data, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
ED_object_exit_editmode(C, EM_FREEDATA);
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
if(createob) {
obedit->gameflag&= ~OB_COLLISION;
obedit->gameflag|= OB_NAVMESH;
obedit->body_type= OB_BODY_TYPE_NAVMESH;
rename_id((ID *)obedit, "Navmesh");
}
BKE_mesh_ensure_navmesh(obedit->data);
return obedit;
}
/* function used for WM_OT_save_mainfile too */
static int wm_collada_export_exec(bContext *C, wmOperator *op)
{
char filepath[FILE_MAX];
int apply_modifiers;
int export_mesh_type;
int selected;
int include_children;
int include_armatures;
int deform_bones_only;
int include_uv_textures;
int include_material_textures;
int use_texture_copies;
int active_uv_only;
int use_object_instantiation;
int sort_by_name;
int second_life;
if (!RNA_struct_property_is_set(op->ptr, "filepath")) {
BKE_report(op->reports, RPT_ERROR, "No filename given");
return OPERATOR_CANCELLED;
}
RNA_string_get(op->ptr, "filepath", filepath);
BLI_ensure_extension(filepath, sizeof(filepath), ".dae");
/* Options panel */
apply_modifiers = RNA_boolean_get(op->ptr, "apply_modifiers");
export_mesh_type = RNA_enum_get(op->ptr, "export_mesh_type_selection");
selected = RNA_boolean_get(op->ptr, "selected");
include_children = RNA_boolean_get(op->ptr, "include_children");
include_armatures = RNA_boolean_get(op->ptr, "include_armatures");
deform_bones_only = RNA_boolean_get(op->ptr, "deform_bones_only");
include_uv_textures = RNA_boolean_get(op->ptr, "include_uv_textures");
include_material_textures= RNA_boolean_get(op->ptr, "include_material_textures");
use_texture_copies = RNA_boolean_get(op->ptr, "use_texture_copies");
active_uv_only = RNA_boolean_get(op->ptr, "active_uv_only");
use_object_instantiation = RNA_boolean_get(op->ptr, "use_object_instantiation");
sort_by_name = RNA_boolean_get(op->ptr, "sort_by_name");
second_life = RNA_boolean_get(op->ptr, "second_life");
/* get editmode results */
ED_object_exit_editmode(C, 0); /* 0 = does not exit editmode */
if (collada_export(
CTX_data_scene(C),
filepath,
apply_modifiers,
export_mesh_type,
selected,
include_children,
include_armatures,
deform_bones_only,
active_uv_only,
include_uv_textures,
include_material_textures,
use_texture_copies,
use_object_instantiation,
sort_by_name,
second_life)) {
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
/* using context, starts job */
static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
{
/* new render clears all callbacks */
Main *mainp;
Scene *scene= CTX_data_scene(C);
SceneRenderLayer *srl=NULL;
bScreen *screen= CTX_wm_screen(C);
View3D *v3d= CTX_wm_view3d(C);
Render *re;
wmJob *steve;
RenderJob *rj;
Image *ima;
int jobflag;
const short is_animation= RNA_boolean_get(op->ptr, "animation");
const short is_write_still= RNA_boolean_get(op->ptr, "write_still");
struct Object *camera_override= v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
/* only one render job at a time */
if(WM_jobs_test(CTX_wm_manager(C), scene))
return OPERATOR_CANCELLED;
if(!RE_is_rendering_allowed(scene, camera_override, op->reports)) {
return OPERATOR_CANCELLED;
}
if(!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.imtype)) {
BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected.");
return OPERATOR_CANCELLED;
}
/* stop all running jobs, currently previews frustrate Render */
WM_jobs_stop_all(CTX_wm_manager(C));
/* get main */
if(G.rt == 101) {
/* thread-safety experiment, copy main from the undo buffer */
mainp= BKE_undo_get_main(&scene);
}
else
mainp= CTX_data_main(C);
/* cancel animation playback */
if (screen->animtimer)
ED_screen_animation_play(C, 0, 0);
/* handle UI stuff */
WM_cursor_wait(1);
/* flush multires changes (for sculpt) */
multires_force_render_update(CTX_data_active_object(C));
/* cleanup sequencer caches before starting user triggered render.
otherwise, invalidated cache entries can make their way into
the output rendering. We can't put that into RE_BlenderFrame,
since sequence rendering can call that recursively... (peter) */
seq_stripelem_cache_cleanup();
/* get editmode results */
ED_object_exit_editmode(C, 0); /* 0 = does not exit editmode */
// store spare
// get view3d layer, local layer, make this nice api call to render
// store spare
/* ensure at least 1 area shows result */
render_view_open(C, event->x, event->y);
jobflag= WM_JOB_EXCL_RENDER|WM_JOB_PRIORITY|WM_JOB_PROGRESS;
/* single layer re-render */
if(RNA_property_is_set(op->ptr, "layer")) {
SceneRenderLayer *rl;
Scene *scn;
char scene_name[MAX_ID_NAME-2], rl_name[RE_MAXNAME];
RNA_string_get(op->ptr, "layer", rl_name);
RNA_string_get(op->ptr, "scene", scene_name);
scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);
rl = (SceneRenderLayer *)BLI_findstring(&scene->r.layers, rl_name, offsetof(SceneRenderLayer, name));
if (scn && rl) {
/* camera switch wont have updated */
scn->r.cfra= scene->r.cfra;
scene_camera_switch_update(scn);
scene = scn;
srl = rl;
}
jobflag |= WM_JOB_SUSPEND;
}
/* job custom data */
rj= MEM_callocN(sizeof(RenderJob), "render job");
rj->main= mainp;
rj->scene= scene;
rj->win= CTX_wm_window(C);
rj->srl = srl;
rj->camera_override = camera_override;
rj->lay = (v3d)? v3d->lay: scene->lay;
rj->anim= is_animation;
rj->write_still= is_write_still && !is_animation;
rj->iuser.scene= scene;
rj->iuser.ok= 1;
rj->reports= op->reports;
/* setup job */
steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Render", jobflag);
WM_jobs_customdata(steve, rj, render_freejob);
WM_jobs_timer(steve, 0.2, NC_SCENE|ND_RENDER_RESULT, 0);
WM_jobs_callbacks(steve, render_startjob, NULL, NULL, render_endjob);
/* get a render result image, and make sure it is empty */
ima= BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
BKE_image_backup_render(rj->scene, ima);
rj->image= ima;
/* setup new render */
re= RE_NewRender(scene->id.name);
RE_test_break_cb(re, rj, render_breakjob);
RE_draw_lock_cb(re, rj, render_drawlock);
RE_display_draw_cb(re, rj, image_rect_update);
RE_stats_draw_cb(re, rj, image_renderinfo_cb);
RE_progress_cb(re, rj, render_progress_update);
rj->re= re;
G.afbreek= 0;
WM_jobs_start(CTX_wm_manager(C), steve);
WM_cursor_wait(0);
WM_event_add_notifier(C, NC_SCENE|ND_RENDER_RESULT, scene);
/* we set G.rendering here already instead of only in the job, this ensure
main loop or other scene updates are disabled in time, since they may
have started before the job thread */
G.rendering = 1;
/* add modal handler for ESC */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
int join_mesh_exec(bContext *C, wmOperator *op)
{
Main *bmain= CTX_data_main(C);
Scene *scene= CTX_data_scene(C);
Object *ob= CTX_data_active_object(C);
Material **matar, *ma;
Mesh *me;
MVert *mvert, *mv;
MEdge *medge = NULL;
MFace *mface = NULL;
Key *key, *nkey=NULL;
KeyBlock *kb, *okb, *kbn;
float imat[4][4], cmat[4][4], *fp1, *fp2, curpos;
int a, b, totcol, totmat=0, totedge=0, totvert=0, totface=0, ok=0;
int vertofs, *matmap=NULL;
int i, j, index, haskey=0, edgeofs, faceofs;
bDeformGroup *dg, *odg;
MDeformVert *dvert;
CustomData vdata, edata, fdata;
if(scene->obedit) {
BKE_report(op->reports, RPT_WARNING, "Cant join while in editmode");
return OPERATOR_CANCELLED;
}
/* ob is the object we are adding geometry to */
if(!ob || ob->type!=OB_MESH) {
BKE_report(op->reports, RPT_WARNING, "Active object is not a mesh");
return OPERATOR_CANCELLED;
}
/* count & check */
CTX_DATA_BEGIN(C, Base*, base, selected_editable_bases) {
if(base->object->type==OB_MESH) {
me= base->object->data;
totvert+= me->totvert;
totedge+= me->totedge;
totface+= me->totface;
totmat+= base->object->totcol;
if(base->object == ob)
ok= 1;
/* check for shapekeys */
if(me->key)
haskey++;
}
}
CTX_DATA_END;
/* that way the active object is always selected */
if(ok==0) {
BKE_report(op->reports, RPT_WARNING, "Active object is not a selected mesh");
return OPERATOR_CANCELLED;
}
/* only join meshes if there are verts to join, there aren't too many, and we only had one mesh selected */
me= (Mesh *)ob->data;
key= me->key;
if(totvert==0 || totvert==me->totvert) {
BKE_report(op->reports, RPT_WARNING, "No mesh data to join");
return OPERATOR_CANCELLED;
}
if(totvert > MESH_MAX_VERTS) {
BKE_reportf(op->reports, RPT_WARNING, "Joining results in %d vertices, limit is " STRINGIFY(MESH_MAX_VERTS), totvert);
return OPERATOR_CANCELLED;
}
/* new material indices and material array */
matar= MEM_callocN(sizeof(void*)*totmat, "join_mesh matar");
if (totmat) matmap= MEM_callocN(sizeof(int)*totmat, "join_mesh matmap");
totcol= ob->totcol;
/* obact materials in new main array, is nicer start! */
for(a=0; a<ob->totcol; a++) {
matar[a]= give_current_material(ob, a+1);
id_us_plus((ID *)matar[a]);
/* increase id->us : will be lowered later */
}
/* - if destination mesh had shapekeys, move them somewhere safe, and set up placeholders
* with arrays that are large enough to hold shapekey data for all meshes
* - if destination mesh didn't have shapekeys, but we encountered some in the meshes we're
* joining, set up a new keyblock and assign to the mesh
*/
if(key) {
/* make a duplicate copy that will only be used here... (must remember to free it!) */
nkey= copy_key(key);
/* for all keys in old block, clear data-arrays */
for(kb= key->block.first; kb; kb= kb->next) {
if(kb->data) MEM_freeN(kb->data);
kb->data= MEM_callocN(sizeof(float)*3*totvert, "join_shapekey");
kb->totelem= totvert;
kb->weights= NULL;
}
}
else if(haskey) {
/* add a new key-block and add to the mesh */
key= me->key= add_key((ID *)me);
key->type = KEY_RELATIVE;
}
/* first pass over objects - copying materials and vertexgroups across */
CTX_DATA_BEGIN(C, Base*, base, selected_editable_bases) {
/* only act if a mesh, and not the one we're joining to */
if((ob!=base->object) && (base->object->type==OB_MESH)) {
me= base->object->data;
/* Join this object's vertex groups to the base one's */
for(dg=base->object->defbase.first; dg; dg=dg->next) {
/* See if this group exists in the object (if it doesn't, add it to the end) */
if(!defgroup_find_name(ob, dg->name)) {
odg = MEM_callocN(sizeof(bDeformGroup), "join deformGroup");
memcpy(odg, dg, sizeof(bDeformGroup));
BLI_addtail(&ob->defbase, odg);
}
}
if(ob->defbase.first && ob->actdef==0)
ob->actdef=1;
if(me->totvert) {
/* Add this object's materials to the base one's if they don't exist already (but only if limits not exceeded yet) */
if(totcol < MAXMAT) {
for(a=1; a<=base->object->totcol; a++) {
ma= give_current_material(base->object, a);
for(b=0; b<totcol; b++) {
if(ma == matar[b]) break;
}
if(b==totcol) {
matar[b]= ma;
if(ma) {
id_us_plus(&ma->id);
}
totcol++;
}
if(totcol >= MAXMAT)
break;
}
}
/* if this mesh has shapekeys, check if destination mesh already has matching entries too */
if(me->key && key) {
for(kb= me->key->block.first; kb; kb= kb->next) {
/* if key doesn't exist in destination mesh, add it */
if(key_get_named_keyblock(key, kb->name) == NULL) {
/* copy this existing one over to the new shapekey block */
kbn= MEM_dupallocN(kb);
kbn->prev= kbn->next= NULL;
/* adjust adrcode and other settings to fit (allocate a new data-array) */
kbn->data= MEM_callocN(sizeof(float)*3*totvert, "joined_shapekey");
kbn->totelem= totvert;
kbn->weights= NULL;
okb= key->block.last;
curpos= (okb) ? okb->pos : -0.1f;
if(key->type == KEY_RELATIVE)
kbn->pos= curpos + 0.1f;
else
kbn->pos= curpos;
BLI_addtail(&key->block, kbn);
kbn->adrcode= key->totkey;
key->totkey++;
if(key->totkey==1) key->refkey= kbn;
// XXX 2.5 Animato
#if 0
/* also, copy corresponding ipo-curve to ipo-block if applicable */
if(me->key->ipo && key->ipo) {
// FIXME... this is a luxury item!
puts("FIXME: ignoring IPO's when joining shapekeys on Meshes for now...");
}
#endif
}
}
}
}
}
}
CTX_DATA_END;
/* setup new data for destination mesh */
memset(&vdata, 0, sizeof(vdata));
memset(&edata, 0, sizeof(edata));
memset(&fdata, 0, sizeof(fdata));
mvert= CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
medge= CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
mface= CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);
vertofs= 0;
edgeofs= 0;
faceofs= 0;
/* inverse transform for all selected meshes in this object */
invert_m4_m4(imat, ob->obmat);
CTX_DATA_BEGIN(C, Base*, base, selected_editable_bases) {
/* only join if this is a mesh */
if(base->object->type==OB_MESH) {
me= base->object->data;
if(me->totvert) {
/* standard data */
CustomData_merge(&me->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
CustomData_copy_data(&me->vdata, &vdata, 0, vertofs, me->totvert);
/* vertex groups */
dvert= CustomData_get(&vdata, vertofs, CD_MDEFORMVERT);
/* NB: vertex groups here are new version */
if(dvert) {
for(i=0; i<me->totvert; i++) {
for(j=0; j<dvert[i].totweight; j++) {
/* Find the old vertex group */
odg = BLI_findlink(&base->object->defbase, dvert[i].dw[j].def_nr);
if(odg) {
/* Search for a match in the new object, and set new index */
for(dg=ob->defbase.first, index=0; dg; dg=dg->next, index++) {
if(!strcmp(dg->name, odg->name)) {
dvert[i].dw[j].def_nr = index;
break;
}
}
}
}
}
}
/* if this is the object we're merging into, no need to do anything */
if(base->object != ob) {
/* watch this: switch matmul order really goes wrong */
mul_m4_m4m4(cmat, base->object->obmat, imat);
/* transform vertex coordinates into new space */
for(a=0, mv=mvert; a < me->totvert; a++, mv++) {
mul_m4_v3(cmat, mv->co);
}
/* for each shapekey in destination mesh:
* - if there's a matching one, copy it across (will need to transform vertices into new space...)
* - otherwise, just copy own coordinates of mesh (no need to transform vertex coordinates into new space)
*/
if(key) {
/* if this mesh has any shapekeys, check first, otherwise just copy coordinates */
for(kb= key->block.first; kb; kb= kb->next) {
/* get pointer to where to write data for this mesh in shapekey's data array */
fp1= ((float *)kb->data) + (vertofs*3);
/* check if this mesh has such a shapekey */
okb= key_get_named_keyblock(me->key, kb->name);
if(okb) {
/* copy this mesh's shapekey to the destination shapekey (need to transform first) */
fp2= ((float *)(okb->data));
for(a=0; a < me->totvert; a++, fp1+=3, fp2+=3) {
VECCOPY(fp1, fp2);
mul_m4_v3(cmat, fp1);
}
}
else {
/* copy this mesh's vertex coordinates to the destination shapekey */
mv= mvert;
for(a=0; a < me->totvert; a++, fp1+=3, mv++) {
VECCOPY(fp1, mv->co);
}
}
}
}
}
else {
/* for each shapekey in destination mesh:
* - if it was an 'original', copy the appropriate data from nkey
* - otherwise, copy across plain coordinates (no need to transform coordinates)
*/
if(key) {
for(kb= key->block.first; kb; kb= kb->next) {
/* get pointer to where to write data for this mesh in shapekey's data array */
fp1= ((float *)kb->data) + (vertofs*3);
/* check if this was one of the original shapekeys */
okb= key_get_named_keyblock(nkey, kb->name);
if(okb) {
/* copy this mesh's shapekey to the destination shapekey */
fp2= ((float *)(okb->data));
for(a=0; a < me->totvert; a++, fp1+=3, fp2+=3) {
VECCOPY(fp1, fp2);
}
}
else {
/* copy base-coordinates to the destination shapekey */
mv= mvert;
for(a=0; a < me->totvert; a++, fp1+=3, mv++) {
VECCOPY(fp1, mv->co);
}
}
}
}
}
/* advance mvert pointer to end of base mesh's data */
mvert+= me->totvert;
}
if(me->totface) {
/* make mapping for materials */
for(a=1; a<=base->object->totcol; a++) {
ma= give_current_material(base->object, a);
for(b=0; b<totcol; b++) {
if(ma == matar[b]) {
matmap[a-1]= b;
break;
}
}
}
if(base->object!=ob)
multiresModifier_prepare_join(scene, base->object, ob);
CustomData_merge(&me->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
CustomData_copy_data(&me->fdata, &fdata, 0, faceofs, me->totface);
for(a=0; a<me->totface; a++, mface++) {
mface->v1+= vertofs;
mface->v2+= vertofs;
mface->v3+= vertofs;
if(mface->v4) mface->v4+= vertofs;
if (matmap)
mface->mat_nr= matmap[(int)mface->mat_nr];
else
mface->mat_nr= 0;
}
faceofs += me->totface;
}
if(me->totedge) {
CustomData_merge(&me->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
CustomData_copy_data(&me->edata, &edata, 0, edgeofs, me->totedge);
for(a=0; a<me->totedge; a++, medge++) {
medge->v1+= vertofs;
medge->v2+= vertofs;
}
edgeofs += me->totedge;
}
/* vertofs is used to help newly added verts be reattached to their edge/face
* (cannot be set earlier, or else reattaching goes wrong)
*/
vertofs += me->totvert;
/* free base, now that data is merged */
if(base->object != ob)
ED_base_object_free_and_unlink(bmain, scene, base);
}
}
CTX_DATA_END;
/* return to mesh we're merging to */
me= ob->data;
CustomData_free(&me->vdata, me->totvert);
CustomData_free(&me->edata, me->totedge);
CustomData_free(&me->fdata, me->totface);
me->totvert= totvert;
me->totedge= totedge;
me->totface= totface;
me->vdata= vdata;
me->edata= edata;
me->fdata= fdata;
mesh_update_customdata_pointers(me);
/* old material array */
for(a=1; a<=ob->totcol; a++) {
ma= ob->mat[a-1];
if(ma) ma->id.us--;
}
for(a=1; a<=me->totcol; a++) {
ma= me->mat[a-1];
if(ma) ma->id.us--;
}
if(ob->mat) MEM_freeN(ob->mat);
if(ob->matbits) MEM_freeN(ob->matbits);
if(me->mat) MEM_freeN(me->mat);
ob->mat= me->mat= NULL;
ob->matbits= NULL;
if(totcol) {
me->mat= matar;
ob->mat= MEM_callocN(sizeof(void *)*totcol, "join obmatar");
ob->matbits= MEM_callocN(sizeof(char)*totcol, "join obmatbits");
}
else
MEM_freeN(matar);
ob->totcol= me->totcol= totcol;
ob->colbits= 0;
if (matmap) MEM_freeN(matmap);
/* other mesh users */
test_object_materials((ID *)me);
/* free temp copy of destination shapekeys (if applicable) */
if(nkey) {
// XXX 2.5 Animato
#if 0
/* free it's ipo too - both are not actually freed from memory yet as ID-blocks */
if(nkey->ipo) {
free_ipo(nkey->ipo);
BLI_remlink(&bmain->ipo, nkey->ipo);
MEM_freeN(nkey->ipo);
}
#endif
free_key(nkey);
BLI_remlink(&bmain->key, nkey);
MEM_freeN(nkey);
}
DAG_scene_sort(bmain, scene); // removed objects, need to rebuild dag before editmode call
#if 0
ED_object_enter_editmode(C, EM_WAITCURSOR);
ED_object_exit_editmode(C, EM_FREEDATA|EM_WAITCURSOR|EM_DO_UNDO);
#else
/* toggle editmode using lower level functions so this can be called from python */
make_editMesh(scene, ob);
load_editMesh(scene, ob);
free_editMesh(me->edit_mesh);
MEM_freeN(me->edit_mesh);
me->edit_mesh= NULL;
DAG_id_tag_update(&ob->id, OB_RECALC_OB|OB_RECALC_DATA);
#endif
WM_event_add_notifier(C, NC_SCENE|ND_OB_ACTIVE, scene);
return OPERATOR_FINISHED;
}
int WM_write_file(bContext *C, const char *target, int fileflags, ReportList *reports, int copy)
{
Library *li;
int len;
char filepath[FILE_MAX];
int *thumb = NULL;
ImBuf *ibuf_thumb = NULL;
len = strlen(target);
if (len == 0) {
BKE_report(reports, RPT_ERROR, "Path is empty, cannot save");
return -1;
}
if (len >= FILE_MAX) {
BKE_report(reports, RPT_ERROR, "Path too long, cannot save");
return -1;
}
BLI_strncpy(filepath, target, FILE_MAX);
BLI_replace_extension(filepath, FILE_MAX, ".blend");
/* don't use 'target' anymore */
/* send the OnSave event */
for (li = G.main->library.first; li; li = li->id.next) {
if (BLI_path_cmp(li->filepath, filepath) == 0) {
BKE_reportf(reports, RPT_ERROR, "Can't overwrite used library '%.240s'", filepath);
return -1;
}
}
/* blend file thumbnail */
/* save before exit_editmode, otherwise derivedmeshes for shared data corrupt #27765) */
if (U.flag & USER_SAVE_PREVIEWS) {
ibuf_thumb = blend_file_thumb(CTX_data_scene(C), CTX_wm_screen(C), &thumb);
}
BLI_exec_cb(G.main, NULL, BLI_CB_EVT_SAVE_PRE);
/* operator now handles overwrite checks */
if (G.fileflags & G_AUTOPACK) {
packAll(G.main, reports);
}
ED_object_exit_editmode(C, EM_DO_UNDO);
ED_sculpt_force_update(C);
/* don't forget not to return without! */
WM_cursor_wait(1);
fileflags |= G_FILE_HISTORY; /* write file history */
if (BLO_write_file(CTX_data_main(C), filepath, fileflags, reports, thumb)) {
if (!copy) {
G.relbase_valid = 1;
BLI_strncpy(G.main->name, filepath, sizeof(G.main->name)); /* is guaranteed current file */
G.save_over = 1; /* disable untitled.blend convention */
}
if (fileflags & G_FILE_COMPRESS) G.fileflags |= G_FILE_COMPRESS;
else G.fileflags &= ~G_FILE_COMPRESS;
if (fileflags & G_FILE_AUTOPLAY) G.fileflags |= G_FILE_AUTOPLAY;
else G.fileflags &= ~G_FILE_AUTOPLAY;
/* prevent background mode scripts from clobbering history */
if (!G.background) {
write_history();
}
BLI_exec_cb(G.main, NULL, BLI_CB_EVT_SAVE_POST);
/* run this function after because the file cant be written before the blend is */
if (ibuf_thumb) {
IMB_thumb_delete(filepath, THB_FAIL); /* without this a failed thumb overrides */
ibuf_thumb = IMB_thumb_create(filepath, THB_NORMAL, THB_SOURCE_BLEND, ibuf_thumb);
IMB_freeImBuf(ibuf_thumb);
}
if (thumb) MEM_freeN(thumb);
}
else {
if (ibuf_thumb) IMB_freeImBuf(ibuf_thumb);
if (thumb) MEM_freeN(thumb);
WM_cursor_wait(0);
return -1;
}
WM_cursor_wait(0);
return 0;
}
