bool KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options)
{
Main *main_newlib; /* stored as a dynamic 'main' until we free it */
Main *main_tmp= NULL; /* created only for linking, then freed */
LinkNode *names = NULL;
int idcode= BKE_idcode_from_name(group);
short flag= 0; /* don't need any special options */
ReportList reports;
static char err_local[255];
/* only scene and mesh supported right now */
if (idcode!=ID_SCE && idcode!=ID_ME &&idcode!=ID_AC) {
snprintf(err_local, sizeof(err_local), "invalid ID type given \"%s\"\n", group);
*err_str= err_local;
BLO_blendhandle_close(bpy_openlib);
return false;
}
if (GetMainDynamicPath(path)) {
snprintf(err_local, sizeof(err_local), "blend file already open \"%s\"\n", path);
*err_str= err_local;
BLO_blendhandle_close(bpy_openlib);
return false;
}
if (bpy_openlib==NULL) {
snprintf(err_local, sizeof(err_local), "could not open blendfile \"%s\"\n", path);
*err_str= err_local;
return false;
}
main_newlib= (Main *)MEM_callocN( sizeof(Main), "BgeMain");
BKE_reports_init(&reports, RPT_STORE);
/* here appending/linking starts */
main_tmp = BLO_library_append_begin(main_newlib, &bpy_openlib, (char *)path);
int totnames_dummy;
names = BLO_blendhandle_get_datablock_names( bpy_openlib, idcode, &totnames_dummy);
int i=0;
LinkNode *n= names;
while(n) {
BLO_library_append_named_part(main_tmp, &bpy_openlib, (char *)n->link, idcode);
n= (LinkNode *)n->next;
i++;
}
BLI_linklist_free(names, free); /* free linklist *and* each node's data */
BLO_library_append_end(NULL, main_tmp, &bpy_openlib, idcode, flag);
/* now do another round of linking for Scenes so all actions are properly loaded */
if (idcode==ID_SCE && options & LIB_LOAD_LOAD_ACTIONS) {
main_tmp = BLO_library_append_begin(main_newlib, &bpy_openlib, (char *)path);
int totnames_dummy;
names = BLO_blendhandle_get_datablock_names( bpy_openlib, ID_AC, &totnames_dummy);
int i=0;
LinkNode *n= names;
while(n) {
BLO_library_append_named_part(main_tmp, &bpy_openlib, (char *)n->link, ID_AC);
n= (LinkNode *)n->next;
i++;
}
BLI_linklist_free(names, free); /* free linklist *and* each node's data */
BLO_library_append_end(NULL, main_tmp, &bpy_openlib, ID_AC, flag);
}
BLO_blendhandle_close(bpy_openlib);
BKE_reports_clear(&reports);
/* done linking */
/* needed for lookups*/
GetMainDynamic().push_back(main_newlib);
strncpy(main_newlib->name, path, sizeof(main_newlib->name));
if (idcode==ID_ME) {
/* Convert all new meshes into BGE meshes */
ID* mesh;
for (mesh= (ID *)main_newlib->mesh.first; mesh; mesh= (ID *)mesh->next ) {
if (options & LIB_LOAD_VERBOSE)
printf("MeshName: %s\n", mesh->name+2);
RAS_MeshObject *meshobj = BL_ConvertMesh((Mesh *)mesh, NULL, scene_merge, this);
scene_merge->GetLogicManager()->RegisterMeshName(meshobj->GetName(),meshobj);
}
}
else if (idcode==ID_AC) {
/* Convert all actions */
ID *action;
for (action= (ID *)main_newlib->action.first; action; action= (ID *)action->next) {
if (options & LIB_LOAD_VERBOSE)
printf("ActionName: %s\n", action->name+2);
scene_merge->GetLogicManager()->RegisterActionName(action->name+2, action);
}
}
else if (idcode==ID_SCE) {
/* Merge all new linked in scene into the existing one */
ID *scene;
for (scene= (ID *)main_newlib->scene.first; scene; scene= (ID *)scene->next ) {
if (options & LIB_LOAD_VERBOSE)
printf("SceneName: %s\n", scene->name+2);
/* merge into the base scene */
KX_Scene* other= m_ketsjiEngine->CreateScene((Scene *)scene);
scene_merge->MergeScene(other);
// RemoveScene(other); // Don't run this, it frees the entire scene converter data, just delete the scene
delete other;
}
/* Now handle all the actions */
if (options & LIB_LOAD_LOAD_ACTIONS) {
ID *action;
for (action= (ID *)main_newlib->action.first; action; action= (ID *)action->next) {
if (options & LIB_LOAD_VERBOSE)
printf("ActionName: %s\n", action->name+2);
scene_merge->GetLogicManager()->RegisterActionName(action->name+2, action);
}
}
}
return true;
}
/* This function merges a mesh from the current scene into another main
* it does not convert */
RAS_MeshObject *KX_BlenderSceneConverter::ConvertMeshSpecial(KX_Scene* kx_scene, Main *maggie, const char *name)
{
/* Find a mesh in the current main */
ID *me= static_cast<ID *>(BLI_findstring(&m_maggie->mesh, name, offsetof(ID, name) + 2));
if (me==NULL) {
printf("Could not be found \"%s\"\n", name);
return NULL;
}
/* Watch this!, if its used in the original scene can cause big troubles */
if (me->us > 0) {
printf("Mesh has a user \"%s\"\n", name);
me = (ID*)BKE_mesh_copy((Mesh*)me);
me->us--;
}
BLI_remlink(&m_maggie->mesh, me); /* even if we made the copy it needs to be removed */
BLI_addtail(&maggie->mesh, me);
/* Must copy the materials this uses else we cant free them */
{
Mesh *mesh= (Mesh *)me;
/* ensure all materials are tagged */
for (int i=0; i<mesh->totcol; i++)
if (mesh->mat[i])
mesh->mat[i]->id.flag &= ~LIB_DOIT;
for (int i=0; i<mesh->totcol; i++)
{
Material *mat_old= mesh->mat[i];
/* if its tagged its a replaced material */
if (mat_old && (mat_old->id.flag & LIB_DOIT)==0)
{
Material *mat_old= mesh->mat[i];
Material *mat_new= BKE_material_copy( mat_old );
mat_new->id.flag |= LIB_DOIT;
mat_old->id.us--;
BLI_remlink(&m_maggie->mat, mat_new);
BLI_addtail(&maggie->mat, mat_new);
mesh->mat[i]= mat_new;
/* the same material may be used twice */
for (int j=i+1; j<mesh->totcol; j++)
{
if (mesh->mat[j]==mat_old)
{
mesh->mat[j]= mat_new;
mat_new->id.us++;
mat_old->id.us--;
}
}
}
}
}
RAS_MeshObject *meshobj = BL_ConvertMesh((Mesh *)me, NULL, kx_scene, this);
kx_scene->GetLogicManager()->RegisterMeshName(meshobj->GetName(),meshobj);
m_map_mesh_to_gamemesh.clear(); /* This is at runtime so no need to keep this, BL_ConvertMesh adds */
return meshobj;
}
/* This function merges a mesh from the current scene into another main
* it does not convert */
RAS_MeshObject *KX_BlenderSceneConverter::ConvertMeshSpecial(KX_Scene *kx_scene, Main *maggie, const char *name)
{
/* Find a mesh in the current main */
ID *me= static_cast<ID *>(BLI_findstring(&m_maggie->mesh, name, offsetof(ID, name) + 2));
Main *from_maggie = m_maggie;
if (me == NULL) {
// The mesh wasn't in the current main, try any dynamic (i.e., LibLoaded) ones
vector<Main *>::iterator it;
for (it = GetMainDynamic().begin(); it != GetMainDynamic().end(); it++) {
me = static_cast<ID *>(BLI_findstring(&(*it)->mesh, name, offsetof(ID, name) + 2));
from_maggie = *it;
if (me)
break;
}
}
if (me == NULL) {
printf("Could not be found \"%s\"\n", name);
return NULL;
}
/* Watch this!, if its used in the original scene can cause big troubles */
if (me->us > 0) {
#ifdef DEBUG
printf("Mesh has a user \"%s\"\n", name);
#endif
me = (ID*)BKE_mesh_copy_ex(from_maggie, (Mesh*)me);
id_us_min(me);
}
BLI_remlink(&from_maggie->mesh, me); /* even if we made the copy it needs to be removed */
BLI_addtail(&maggie->mesh, me);
/* Must copy the materials this uses else we cant free them */
{
Mesh *mesh = (Mesh *)me;
/* ensure all materials are tagged */
for (int i = 0; i < mesh->totcol; i++) {
if (mesh->mat[i])
mesh->mat[i]->id.tag &= ~LIB_TAG_DOIT;
}
for (int i = 0; i < mesh->totcol; i++) {
Material *mat_old = mesh->mat[i];
/* if its tagged its a replaced material */
if (mat_old && (mat_old->id.tag & LIB_TAG_DOIT) == 0) {
Material *mat_old = mesh->mat[i];
Material *mat_new = BKE_material_copy(mat_old);
mat_new->id.tag |= LIB_TAG_DOIT;
id_us_min(&mat_old->id);
BLI_remlink(&G.main->mat, mat_new); // BKE_material_copy uses G.main, and there is no BKE_material_copy_ex
BLI_addtail(&maggie->mat, mat_new);
mesh->mat[i] = mat_new;
/* the same material may be used twice */
for (int j = i + 1; j < mesh->totcol; j++) {
if (mesh->mat[j] == mat_old) {
mesh->mat[j] = mat_new;
id_us_plus(&mat_new->id);
id_us_min(&mat_old->id);
}
}
}
}
}
m_currentScene = kx_scene; // This needs to be set in case we LibLoaded earlier
RAS_MeshObject *meshobj = BL_ConvertMesh((Mesh *)me, NULL, kx_scene, this, false);
kx_scene->GetLogicManager()->RegisterMeshName(meshobj->GetName(),meshobj);
m_map_mesh_to_gamemesh.clear(); /* This is at runtime so no need to keep this, BL_ConvertMesh adds */
return meshobj;
}
KX_LibLoadStatus *KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options)
{
Main *main_newlib; /* stored as a dynamic 'main' until we free it */
const int idcode = BKE_idcode_from_name(group);
ReportList reports;
static char err_local[255];
// TIMEIT_START(bge_link_blend_file);
KX_LibLoadStatus *status;
/* only scene and mesh supported right now */
if (idcode != ID_SCE && idcode != ID_ME && idcode != ID_AC) {
snprintf(err_local, sizeof(err_local), "invalid ID type given \"%s\"\n", group);
*err_str = err_local;
BLO_blendhandle_close(bpy_openlib);
return NULL;
}
if (GetMainDynamicPath(path)) {
snprintf(err_local, sizeof(err_local), "blend file already open \"%s\"\n", path);
*err_str = err_local;
BLO_blendhandle_close(bpy_openlib);
return NULL;
}
if (bpy_openlib == NULL) {
snprintf(err_local, sizeof(err_local), "could not open blendfile \"%s\"\n", path);
*err_str = err_local;
return NULL;
}
main_newlib = BKE_main_new();
BKE_reports_init(&reports, RPT_STORE);
short flag = 0; /* don't need any special options */
/* created only for linking, then freed */
Main *main_tmp = BLO_library_link_begin(main_newlib, &bpy_openlib, (char *)path);
load_datablocks(main_tmp, bpy_openlib, path, idcode);
if (idcode == ID_SCE && options & LIB_LOAD_LOAD_SCRIPTS) {
load_datablocks(main_tmp, bpy_openlib, path, ID_TXT);
}
/* now do another round of linking for Scenes so all actions are properly loaded */
if (idcode == ID_SCE && options & LIB_LOAD_LOAD_ACTIONS) {
load_datablocks(main_tmp, bpy_openlib, path, ID_AC);
}
BLO_library_link_end(main_tmp, &bpy_openlib, flag, NULL, NULL);
BLO_blendhandle_close(bpy_openlib);
BKE_reports_clear(&reports);
/* done linking */
/* needed for lookups*/
GetMainDynamic().push_back(main_newlib);
BLI_strncpy(main_newlib->name, path, sizeof(main_newlib->name));
status = new KX_LibLoadStatus(this, m_ketsjiEngine, scene_merge, path);
if (idcode == ID_ME) {
/* Convert all new meshes into BGE meshes */
ID *mesh;
for (mesh = (ID *)main_newlib->mesh.first; mesh; mesh = (ID *)mesh->next ) {
if (options & LIB_LOAD_VERBOSE)
printf("MeshName: %s\n", mesh->name + 2);
RAS_MeshObject *meshobj = BL_ConvertMesh((Mesh *)mesh, NULL, scene_merge, this, false); // For now only use the libloading option for scenes, which need to handle materials/shaders
scene_merge->GetLogicManager()->RegisterMeshName(meshobj->GetName(), meshobj);
}
}
else if (idcode == ID_AC) {
/* Convert all actions */
ID *action;
for (action= (ID *)main_newlib->action.first; action; action = (ID *)action->next) {
if (options & LIB_LOAD_VERBOSE)
printf("ActionName: %s\n", action->name + 2);
scene_merge->GetLogicManager()->RegisterActionName(action->name + 2, action);
}
}
else if (idcode == ID_SCE) {
/* Merge all new linked in scene into the existing one */
ID *scene;
// scenes gets deleted by the thread when it's done using it (look in async_convert())
vector<Scene *> *scenes = (options & LIB_LOAD_ASYNC) ? new vector<Scene *>() : NULL;
for (scene = (ID *)main_newlib->scene.first; scene; scene = (ID *)scene->next ) {
if (options & LIB_LOAD_VERBOSE)
printf("SceneName: %s\n", scene->name + 2);
if (options & LIB_LOAD_ASYNC) {
scenes->push_back((Scene *)scene);
}
else {
/* merge into the base scene */
KX_Scene* other = m_ketsjiEngine->CreateScene((Scene *)scene, true);
scene_merge->MergeScene(other);
// RemoveScene(other); // Don't run this, it frees the entire scene converter data, just delete the scene
delete other;
}
}
if (options & LIB_LOAD_ASYNC) {
status->SetData(scenes);
BLI_task_pool_push(m_threadinfo->m_pool, async_convert, (void *)status, false, TASK_PRIORITY_LOW);
}
#ifdef WITH_PYTHON
/* Handle any text datablocks */
if (options & LIB_LOAD_LOAD_SCRIPTS)
addImportMain(main_newlib);
#endif
/* Now handle all the actions */
if (options & LIB_LOAD_LOAD_ACTIONS) {
ID *action;
for (action = (ID *)main_newlib->action.first; action; action = (ID *)action->next) {
if (options & LIB_LOAD_VERBOSE)
printf("ActionName: %s\n", action->name + 2);
scene_merge->GetLogicManager()->RegisterActionName(action->name + 2, action);
}
}
}
if (!(options & LIB_LOAD_ASYNC))
status->Finish();
// TIMEIT_END(bge_link_blend_file);
m_status_map[main_newlib->name] = status;
return status;
}
/* Note m_map_*** are all ok and don't need to be freed
* most are temp and NewRemoveObject frees m_map_gameobject_to_blender */
bool KX_BlenderSceneConverter::FreeBlendFile(Main *maggie)
{
int maggie_index = -1;
int i = 0;
if (maggie == NULL)
return false;
// If the given library is currently in loading, we do nothing.
if (m_status_map.count(maggie->name)) {
BLI_mutex_lock(&m_threadinfo->m_mutex);
const bool finished = m_status_map[maggie->name]->IsFinished();
BLI_mutex_unlock(&m_threadinfo->m_mutex);
if (!finished) {
printf("Library (%s) is currently being loaded asynchronously, and cannot be freed until this process is done\n", maggie->name);
return false;
}
}
/* tag all false except the one we remove */
for (vector<Main *>::iterator it = m_DynamicMaggie.begin(); !(it == m_DynamicMaggie.end()); it++) {
Main *main = *it;
if (main != maggie) {
BKE_main_id_tag_all(main, LIB_TAG_DOIT, false);
}
else {
maggie_index = i;
}
i++;
}
/* should never happen but just to be safe */
if (maggie_index == -1)
return false;
m_DynamicMaggie.erase(m_DynamicMaggie.begin() + maggie_index);
BKE_main_id_tag_all(maggie, LIB_TAG_DOIT, true);
/* free all tagged objects */
KX_SceneList *scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
for (int scene_idx = 0; scene_idx < numScenes; scene_idx++) {
KX_Scene *scene = scenes->at(scene_idx);
if (IS_TAGGED(scene->GetBlenderScene())) {
m_ketsjiEngine->RemoveScene(scene->GetName());
m_mat_cache.erase(scene);
m_polymat_cache.erase(scene);
scene_idx--;
numScenes--;
}
else {
/* in case the mesh might be refered to later */
{
CTR_Map<STR_HashedString, void *> &mapStringToMeshes = scene->GetLogicManager()->GetMeshMap();
for (int i = 0; i < mapStringToMeshes.size(); i++) {
RAS_MeshObject *meshobj = (RAS_MeshObject *) *mapStringToMeshes.at(i);
if (meshobj && IS_TAGGED(meshobj->GetMesh())) {
STR_HashedString mn = meshobj->GetName();
mapStringToMeshes.remove(mn);
m_map_mesh_to_gamemesh.remove(CHashedPtr(meshobj->GetMesh()));
i--;
}
}
}
/* Now unregister actions */
{
CTR_Map<STR_HashedString, void *> &mapStringToActions = scene->GetLogicManager()->GetActionMap();
for (int i = 0; i < mapStringToActions.size(); i++) {
ID *action = (ID*) *mapStringToActions.at(i);
if (IS_TAGGED(action)) {
STR_HashedString an = action->name + 2;
mapStringToActions.remove(an);
m_map_blender_to_gameAdtList.remove(CHashedPtr(action));
i--;
}
}
}
//scene->FreeTagged(); /* removed tagged objects and meshes*/
CListValue *obj_lists[] = {scene->GetObjectList(), scene->GetInactiveList(), NULL};
for (int ob_ls_idx = 0; obj_lists[ob_ls_idx]; ob_ls_idx++) {
CListValue *obs = obj_lists[ob_ls_idx];
RAS_MeshObject *mesh;
for (int ob_idx = 0; ob_idx < obs->GetCount(); ob_idx++) {
KX_GameObject *gameobj = (KX_GameObject*)obs->GetValue(ob_idx);
if (IS_TAGGED(gameobj->GetBlenderObject())) {
int size_before = obs->GetCount();
/* Eventually calls RemoveNodeDestructObject
* frees m_map_gameobject_to_blender from UnregisterGameObject */
scene->RemoveObject(gameobj);
if (size_before != obs->GetCount())
ob_idx--;
else {
printf("ERROR COULD NOT REMOVE \"%s\"\n", gameobj->GetName().ReadPtr());
}
}
else {
gameobj->RemoveTaggedActions();
/* free the mesh, we could be referecing a linked one! */
int mesh_index = gameobj->GetMeshCount();
while (mesh_index--) {
mesh = gameobj->GetMesh(mesh_index);
if (IS_TAGGED(mesh->GetMesh())) {
gameobj->RemoveMeshes(); /* XXX - slack, should only remove meshes that are library items but mostly objects only have 1 mesh */
break;
}
else {
/* also free the mesh if it's using a tagged material */
int mat_index = mesh->NumMaterials();
while (mat_index--) {
if (IS_TAGGED(mesh->GetMeshMaterial(mat_index)->m_bucket->GetPolyMaterial()->GetBlenderMaterial())) {
gameobj->RemoveMeshes(); /* XXX - slack, same as above */
break;
}
}
}
}
/* make sure action actuators are not referencing tagged actions */
for (unsigned int act_idx = 0; act_idx < gameobj->GetActuators().size(); act_idx++) {
if (gameobj->GetActuators()[act_idx]->IsType(SCA_IActuator::KX_ACT_ACTION)) {
BL_ActionActuator *act = (BL_ActionActuator *)gameobj->GetActuators()[act_idx];
if (IS_TAGGED(act->GetAction()))
act->SetAction(NULL);
}
}
}
}
}
}
}
int size;
// delete the entities of this scene
/* TODO - */
#if 0
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator worldit;
size = m_worldinfos.size();
for (i=0, worldit=m_worldinfos.begin(); i<size; ) {
if ((*worldit).second) {
delete (*worldit).second;
*worldit = m_worldinfos.back();
m_worldinfos.pop_back();
size--;
} else {
i++;
worldit++;
}
}
#endif
/* Worlds don't reference original blender data so we need to make a set from them */
typedef std::set<KX_WorldInfo *> KX_WorldInfoSet;
KX_WorldInfoSet worldset;
for (int scene_idx = 0; scene_idx < numScenes; scene_idx++) {
KX_Scene *scene = scenes->at(scene_idx);
if (scene->GetWorldInfo())
worldset.insert(scene->GetWorldInfo());
}
vector<pair<KX_Scene *, KX_WorldInfo *> >::iterator worldit;
size = m_worldinfos.size();
for (i = 0, worldit = m_worldinfos.begin(); i < size;) {
if (worldit->second && (worldset.count(worldit->second)) == 0) {
delete worldit->second;
*worldit = m_worldinfos.back();
m_worldinfos.pop_back();
size--;
}
else {
i++;
worldit++;
}
}
worldset.clear();
/* done freeing the worlds */
vector<pair<KX_Scene *, RAS_IPolyMaterial *> >::iterator polymit;
size = m_polymaterials.size();
for (i = 0, polymit = m_polymaterials.begin(); i < size; ) {
RAS_IPolyMaterial *mat = polymit->second;
Material *bmat = NULL;
KX_BlenderMaterial *bl_mat = static_cast<KX_BlenderMaterial *>(mat);
bmat = bl_mat->GetBlenderMaterial();
if (IS_TAGGED(bmat)) {
/* only remove from bucket */
polymit->first->GetBucketManager()->RemoveMaterial(mat);
}
i++;
polymit++;
}
for (i = 0, polymit = m_polymaterials.begin(); i < size; ) {
RAS_IPolyMaterial *mat = polymit->second;
Material *bmat = NULL;
KX_BlenderMaterial *bl_mat = static_cast<KX_BlenderMaterial*>(mat);
bmat = bl_mat->GetBlenderMaterial();
if (IS_TAGGED(bmat)) {
// Remove the poly material coresponding to this Blender Material.
m_polymat_cache[polymit->first].erase(bmat);
delete polymit->second;
*polymit = m_polymaterials.back();
m_polymaterials.pop_back();
size--;
} else {
i++;
polymit++;
}
}
vector<pair<KX_Scene *, BL_Material *> >::iterator matit;
size = m_materials.size();
for (i = 0, matit = m_materials.begin(); i < size; ) {
BL_Material *mat = matit->second;
if (IS_TAGGED(mat->material)) {
// Remove the bl material coresponding to this Blender Material.
m_mat_cache[matit->first].erase(mat->material);
delete matit->second;
*matit = m_materials.back();
m_materials.pop_back();
size--;
}
else {
i++;
matit++;
}
}
vector<pair<KX_Scene *, RAS_MeshObject *> >::iterator meshit;
RAS_BucketManager::BucketList::iterator bit;
list<RAS_MeshSlot>::iterator msit;
RAS_BucketManager::BucketList buckets;
size = m_meshobjects.size();
for (i = 0, meshit = m_meshobjects.begin(); i < size;) {
RAS_MeshObject *me = meshit->second;
if (IS_TAGGED(me->GetMesh())) {
// Before deleting the mesh object, make sure the rasterizer is
// no longer referencing it.
buckets = meshit->first->GetBucketManager()->GetSolidBuckets();
for (bit = buckets.begin(); bit != buckets.end(); bit++) {
msit = (*bit)->msBegin();
while (msit != (*bit)->msEnd()) {
if (msit->m_mesh == meshit->second)
(*bit)->RemoveMesh(&(*msit++));
else
msit++;
}
}
// And now the alpha buckets
buckets = meshit->first->GetBucketManager()->GetAlphaBuckets();
for (bit = buckets.begin(); bit != buckets.end(); bit++) {
msit = (*bit)->msBegin();
while (msit != (*bit)->msEnd()) {
if (msit->m_mesh == meshit->second)
(*bit)->RemoveMesh(&(*msit++));
else
msit++;
}
}
// Now it should be safe to delete
delete meshit->second;
*meshit = m_meshobjects.back();
m_meshobjects.pop_back();
size--;
}
else {
i++;
meshit++;
}
}
#ifdef WITH_PYTHON
/* make sure this maggie is removed from the import list if it's there
* (this operation is safe if it isn't in the list) */
removeImportMain(maggie);
#endif
delete m_status_map[maggie->name];
m_status_map.erase(maggie->name);
BKE_main_free(maggie);
return true;
}