1187b98d48
`INSERT_FAST` implies you call `calchandles_fcurve()` at the end... For now, since we do not store edited FCurves nor can we get them easily (requires RNA...), just update handles of all fcurves, it's much more performant than removing usage of `INSERT_FAST` anyway.
1595 lines
44 KiB
C++
1595 lines
44 KiB
C++
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/** \file gameengine/Converter/KX_BlenderSceneConverter.cpp
|
|
* \ingroup bgeconv
|
|
*/
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma warning (disable:4786) /* suppress stl-MSVC debug info warning */
|
|
#endif
|
|
|
|
#include "KX_Scene.h"
|
|
#include "KX_GameObject.h"
|
|
#include "KX_IpoConvert.h"
|
|
#include "RAS_MeshObject.h"
|
|
#include "KX_PhysicsEngineEnums.h"
|
|
#include "PHY_IPhysicsEnvironment.h"
|
|
#include "KX_KetsjiEngine.h"
|
|
#include "KX_PythonInit.h" // So we can handle adding new text datablocks for Python to import
|
|
#include "BL_Material.h"
|
|
#include "BL_ActionActuator.h"
|
|
#include "KX_BlenderMaterial.h"
|
|
|
|
|
|
#include "BL_System.h"
|
|
|
|
#include "DummyPhysicsEnvironment.h"
|
|
|
|
|
|
#ifdef WITH_BULLET
|
|
#include "CcdPhysicsEnvironment.h"
|
|
#endif
|
|
|
|
#include "KX_LibLoadStatus.h"
|
|
#include "KX_BlenderScalarInterpolator.h"
|
|
#include "BL_BlenderDataConversion.h"
|
|
#include "BlenderWorldInfo.h"
|
|
|
|
/* This little block needed for linking to Blender... */
|
|
#ifdef WIN32
|
|
#include "BLI_winstuff.h"
|
|
#endif
|
|
|
|
/* This list includes only data type definitions */
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_world_types.h"
|
|
#include "BKE_main.h"
|
|
#include "BKE_fcurve.h"
|
|
|
|
#include "BLI_math.h"
|
|
|
|
extern "C"
|
|
{
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_curve_types.h"
|
|
#include "DNA_mesh_types.h"
|
|
#include "DNA_material_types.h"
|
|
#include "BLI_blenlib.h"
|
|
#include "MEM_guardedalloc.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_animsys.h"
|
|
#include "BKE_library.h"
|
|
#include "BKE_material.h" // BKE_material_copy
|
|
#include "BKE_mesh.h" // BKE_mesh_copy
|
|
#include "DNA_space_types.h"
|
|
#include "DNA_anim_types.h"
|
|
#include "DNA_action_types.h"
|
|
#include "RNA_define.h"
|
|
#include "../../blender/editors/include/ED_keyframing.h"
|
|
}
|
|
|
|
/* Only for dynamic loading and merging */
|
|
#include "RAS_BucketManager.h" // XXX cant stay
|
|
#include "KX_BlenderSceneConverter.h"
|
|
#include "KX_MeshProxy.h"
|
|
extern "C" {
|
|
#include "PIL_time.h"
|
|
#include "BKE_context.h"
|
|
#include "BLO_readfile.h"
|
|
#include "BKE_idcode.h"
|
|
#include "BKE_report.h"
|
|
#include "DNA_space_types.h"
|
|
#include "DNA_windowmanager_types.h" /* report api */
|
|
#include "../../blender/blenlib/BLI_linklist.h"
|
|
}
|
|
|
|
#include <pthread.h>
|
|
|
|
/* This is used to avoid including pthread.h in KX_BlenderSceneConverter.h */
|
|
typedef struct ThreadInfo {
|
|
vector<pthread_t> threads;
|
|
pthread_mutex_t merge_lock;
|
|
} ThreadInfo;
|
|
|
|
KX_BlenderSceneConverter::KX_BlenderSceneConverter(
|
|
struct Main* maggie,
|
|
class KX_KetsjiEngine* engine
|
|
)
|
|
: m_maggie(maggie),
|
|
/*m_maggie_dyn(NULL),*/
|
|
m_ketsjiEngine(engine),
|
|
m_alwaysUseExpandFraming(false),
|
|
m_usemat(false),
|
|
m_useglslmat(false),
|
|
m_use_mat_cache(true)
|
|
{
|
|
BKE_main_id_tag_all(maggie, false); /* avoid re-tagging later on */
|
|
m_newfilename = "";
|
|
m_threadinfo = new ThreadInfo();
|
|
pthread_mutex_init(&m_threadinfo->merge_lock, NULL);
|
|
}
|
|
|
|
|
|
KX_BlenderSceneConverter::~KX_BlenderSceneConverter()
|
|
{
|
|
// clears meshes, and hashmaps from blender to gameengine data
|
|
int i;
|
|
// delete sumoshapes
|
|
|
|
if (m_threadinfo) {
|
|
vector<pthread_t>::iterator pit = m_threadinfo->threads.begin();
|
|
while (pit != m_threadinfo->threads.end()) {
|
|
pthread_join((*pit), NULL);
|
|
pit++;
|
|
}
|
|
|
|
pthread_mutex_destroy(&m_threadinfo->merge_lock);
|
|
delete m_threadinfo;
|
|
}
|
|
|
|
int numAdtLists = m_map_blender_to_gameAdtList.size();
|
|
for (i=0; i<numAdtLists; i++) {
|
|
BL_InterpolatorList *adtList= *m_map_blender_to_gameAdtList.at(i);
|
|
|
|
delete (adtList);
|
|
}
|
|
|
|
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator itw = m_worldinfos.begin();
|
|
while (itw != m_worldinfos.end()) {
|
|
delete (*itw).second;
|
|
itw++;
|
|
}
|
|
m_worldinfos.clear();
|
|
|
|
vector<pair<KX_Scene*,RAS_IPolyMaterial*> >::iterator itp = m_polymaterials.begin();
|
|
while (itp != m_polymaterials.end()) {
|
|
//m_polymat_cache.erase((*itp).second->GetBlenderMaterial());
|
|
delete (*itp).second;
|
|
itp++;
|
|
}
|
|
m_polymaterials.clear();
|
|
|
|
// delete after RAS_IPolyMaterial
|
|
vector<pair<KX_Scene*,BL_Material *> >::iterator itmat = m_materials.begin();
|
|
while (itmat != m_materials.end()) {
|
|
//m_mat_cache.erase((*itmat).second->material);
|
|
delete (*itmat).second;
|
|
itmat++;
|
|
}
|
|
m_materials.clear();
|
|
|
|
|
|
vector<pair<KX_Scene*,RAS_MeshObject*> >::iterator itm = m_meshobjects.begin();
|
|
while (itm != m_meshobjects.end()) {
|
|
delete (*itm).second;
|
|
itm++;
|
|
}
|
|
m_meshobjects.clear();
|
|
|
|
|
|
/* free any data that was dynamically loaded */
|
|
while (m_DynamicMaggie.size() != 0)
|
|
{
|
|
FreeBlendFile(m_DynamicMaggie[0]);
|
|
}
|
|
|
|
m_DynamicMaggie.clear();
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::SetNewFileName(const STR_String& filename)
|
|
{
|
|
m_newfilename = filename;
|
|
}
|
|
|
|
|
|
|
|
bool KX_BlenderSceneConverter::TryAndLoadNewFile()
|
|
{
|
|
bool result = false;
|
|
|
|
// find the file
|
|
/* if ()
|
|
{
|
|
result = true;
|
|
}
|
|
// if not, clear the newfilename
|
|
else
|
|
{
|
|
m_newfilename = "";
|
|
}
|
|
*/
|
|
return result;
|
|
}
|
|
|
|
Scene *KX_BlenderSceneConverter::GetBlenderSceneForName(const STR_String& name)
|
|
{
|
|
Scene *sce;
|
|
|
|
/**
|
|
* Find the specified scene by name, or NULL if nothing matches.
|
|
*/
|
|
if ((sce= (Scene *)BLI_findstring(&m_maggie->scene, name.ReadPtr(), offsetof(ID, name) + 2)))
|
|
return sce;
|
|
|
|
for (vector<Main*>::iterator it=m_DynamicMaggie.begin(); !(it==m_DynamicMaggie.end()); it++) {
|
|
Main *main= *it;
|
|
|
|
if ((sce= (Scene *)BLI_findstring(&main->scene, name.ReadPtr(), offsetof(ID, name) + 2)))
|
|
return sce;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::ConvertScene(class KX_Scene* destinationscene,
|
|
class RAS_IRasterizer* rendertools,
|
|
class RAS_ICanvas* canvas,
|
|
bool libloading)
|
|
{
|
|
//find out which physics engine
|
|
Scene *blenderscene = destinationscene->GetBlenderScene();
|
|
|
|
PHY_IPhysicsEnvironment *phy_env = NULL;
|
|
|
|
e_PhysicsEngine physics_engine = UseBullet;
|
|
// hook for registration function during conversion.
|
|
m_currentScene = destinationscene;
|
|
destinationscene->SetSceneConverter(this);
|
|
|
|
// This doesn't really seem to do anything except cause potential issues
|
|
// when doing threaded conversion, so it's disabled for now.
|
|
// SG_SetActiveStage(SG_STAGE_CONVERTER);
|
|
|
|
switch (blenderscene->gm.physicsEngine)
|
|
{
|
|
#ifdef WITH_BULLET
|
|
case WOPHY_BULLET:
|
|
{
|
|
SYS_SystemHandle syshandle = SYS_GetSystem(); /*unused*/
|
|
int visualizePhysics = SYS_GetCommandLineInt(syshandle,"show_physics",0);
|
|
|
|
phy_env = CcdPhysicsEnvironment::Create(blenderscene, visualizePhysics);
|
|
physics_engine = UseBullet;
|
|
break;
|
|
}
|
|
#endif
|
|
default:
|
|
case WOPHY_NONE:
|
|
{
|
|
// We should probably use some sort of factory here
|
|
phy_env = new DummyPhysicsEnvironment();
|
|
physics_engine = UseNone;
|
|
break;
|
|
}
|
|
}
|
|
|
|
destinationscene->SetPhysicsEnvironment(phy_env);
|
|
|
|
BL_ConvertBlenderObjects(m_maggie,
|
|
destinationscene,
|
|
m_ketsjiEngine,
|
|
physics_engine,
|
|
rendertools,
|
|
canvas,
|
|
this,
|
|
m_alwaysUseExpandFraming,
|
|
libloading
|
|
);
|
|
|
|
//These lookup are not needed during game
|
|
m_map_blender_to_gameactuator.clear();
|
|
m_map_blender_to_gamecontroller.clear();
|
|
m_map_blender_to_gameobject.clear();
|
|
|
|
//Clearing this lookup table has the effect of disabling the cache of meshes
|
|
//between scenes, even if they are shared in the blend file.
|
|
//This cache mecanism is buggy so I leave it disable and the memory leak
|
|
//that would result from this is fixed in RemoveScene()
|
|
m_map_mesh_to_gamemesh.clear();
|
|
}
|
|
|
|
// This function removes all entities stored in the converter for that scene
|
|
// It should be used instead of direct delete scene
|
|
// Note that there was some provision for sharing entities (meshes...) between
|
|
// scenes but that is now disabled so all scene will have their own copy
|
|
// and we can delete them here. If the sharing is reactivated, change this code too..
|
|
// (see KX_BlenderSceneConverter::ConvertScene)
|
|
void KX_BlenderSceneConverter::RemoveScene(KX_Scene *scene)
|
|
{
|
|
int i, size;
|
|
// delete the scene first as it will stop the use of entities
|
|
delete scene;
|
|
// delete the entities of this scene
|
|
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator worldit;
|
|
size = m_worldinfos.size();
|
|
for (i=0, worldit=m_worldinfos.begin(); i<size; ) {
|
|
if ((*worldit).first == scene) {
|
|
delete (*worldit).second;
|
|
*worldit = m_worldinfos.back();
|
|
m_worldinfos.pop_back();
|
|
size--;
|
|
} else {
|
|
i++;
|
|
worldit++;
|
|
}
|
|
}
|
|
|
|
vector<pair<KX_Scene*,RAS_IPolyMaterial*> >::iterator polymit;
|
|
size = m_polymaterials.size();
|
|
for (i=0, polymit=m_polymaterials.begin(); i<size; ) {
|
|
if ((*polymit).first == scene) {
|
|
m_polymat_cache[scene].erase((*polymit).second->GetBlenderMaterial());
|
|
delete (*polymit).second;
|
|
*polymit = m_polymaterials.back();
|
|
m_polymaterials.pop_back();
|
|
size--;
|
|
} else {
|
|
i++;
|
|
polymit++;
|
|
}
|
|
}
|
|
|
|
m_polymat_cache.erase(scene);
|
|
|
|
vector<pair<KX_Scene*,BL_Material*> >::iterator matit;
|
|
size = m_materials.size();
|
|
for (i=0, matit=m_materials.begin(); i<size; ) {
|
|
if ((*matit).first == scene) {
|
|
m_mat_cache[scene].erase((*matit).second->material);
|
|
delete (*matit).second;
|
|
*matit = m_materials.back();
|
|
m_materials.pop_back();
|
|
size--;
|
|
} else {
|
|
i++;
|
|
matit++;
|
|
}
|
|
}
|
|
|
|
m_mat_cache.erase(scene);
|
|
|
|
vector<pair<KX_Scene*,RAS_MeshObject*> >::iterator meshit;
|
|
size = m_meshobjects.size();
|
|
for (i=0, meshit=m_meshobjects.begin(); i<size; ) {
|
|
if ((*meshit).first == scene) {
|
|
delete (*meshit).second;
|
|
*meshit = m_meshobjects.back();
|
|
m_meshobjects.pop_back();
|
|
size--;
|
|
} else {
|
|
i++;
|
|
meshit++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// use blender materials
|
|
void KX_BlenderSceneConverter::SetMaterials(bool val)
|
|
{
|
|
m_usemat = val;
|
|
m_useglslmat = false;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::SetGLSLMaterials(bool val)
|
|
{
|
|
m_usemat = val;
|
|
m_useglslmat = val;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::SetCacheMaterials(bool val)
|
|
{
|
|
m_use_mat_cache = val;
|
|
}
|
|
|
|
bool KX_BlenderSceneConverter::GetMaterials()
|
|
{
|
|
return m_usemat;
|
|
}
|
|
|
|
bool KX_BlenderSceneConverter::GetGLSLMaterials()
|
|
{
|
|
return m_useglslmat;
|
|
}
|
|
|
|
bool KX_BlenderSceneConverter::GetCacheMaterials()
|
|
{
|
|
return m_use_mat_cache;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::RegisterBlenderMaterial(BL_Material *mat)
|
|
{
|
|
// First make sure we don't register the material twice
|
|
vector<pair<KX_Scene*,BL_Material*> >::iterator it;
|
|
for (it = m_materials.begin(); it != m_materials.end(); ++it)
|
|
if (it->second == mat)
|
|
return;
|
|
|
|
m_materials.push_back(pair<KX_Scene*,BL_Material *>(m_currentScene,mat));
|
|
}
|
|
|
|
|
|
|
|
void KX_BlenderSceneConverter::SetAlwaysUseExpandFraming(
|
|
bool to_what)
|
|
{
|
|
m_alwaysUseExpandFraming= to_what;
|
|
}
|
|
|
|
|
|
|
|
void KX_BlenderSceneConverter::RegisterGameObject(
|
|
KX_GameObject *gameobject,
|
|
struct Object *for_blenderobject)
|
|
{
|
|
/* only maintained while converting, freed during game runtime */
|
|
m_map_blender_to_gameobject.insert(CHashedPtr(for_blenderobject),gameobject);
|
|
}
|
|
|
|
/* only need to run this during conversion since
|
|
* m_map_blender_to_gameobject is freed after conversion */
|
|
void KX_BlenderSceneConverter::UnregisterGameObject(
|
|
KX_GameObject *gameobject)
|
|
{
|
|
struct Object *bobp= gameobject->GetBlenderObject();
|
|
if (bobp) {
|
|
CHashedPtr bptr(bobp);
|
|
KX_GameObject **gobp= m_map_blender_to_gameobject[bptr];
|
|
if (gobp && *gobp == gameobject)
|
|
{
|
|
// also maintain m_map_blender_to_gameobject if the gameobject
|
|
// being removed is matching the blender object
|
|
m_map_blender_to_gameobject.remove(bptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
KX_GameObject *KX_BlenderSceneConverter::FindGameObject(
|
|
struct Object *for_blenderobject)
|
|
{
|
|
KX_GameObject **obp= m_map_blender_to_gameobject[CHashedPtr(for_blenderobject)];
|
|
|
|
return obp?*obp:NULL;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::RegisterGameMesh(
|
|
RAS_MeshObject *gamemesh,
|
|
struct Mesh *for_blendermesh)
|
|
{
|
|
if (for_blendermesh) { /* dynamically loaded meshes we don't want to keep lookups for */
|
|
m_map_mesh_to_gamemesh.insert(CHashedPtr(for_blendermesh),gamemesh);
|
|
}
|
|
m_meshobjects.push_back(pair<KX_Scene*,RAS_MeshObject*>(m_currentScene,gamemesh));
|
|
}
|
|
|
|
|
|
|
|
RAS_MeshObject *KX_BlenderSceneConverter::FindGameMesh(
|
|
struct Mesh *for_blendermesh/*,
|
|
unsigned int onlayer*/)
|
|
{
|
|
RAS_MeshObject** meshp = m_map_mesh_to_gamemesh[CHashedPtr(for_blendermesh)];
|
|
|
|
if (meshp/* && onlayer==(*meshp)->GetLightLayer()*/) {
|
|
return *meshp;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::RegisterPolyMaterial(RAS_IPolyMaterial *polymat)
|
|
{
|
|
// First make sure we don't register the material twice
|
|
vector<pair<KX_Scene*,RAS_IPolyMaterial*> >::iterator it;
|
|
for (it = m_polymaterials.begin(); it != m_polymaterials.end(); ++it)
|
|
if (it->second == polymat)
|
|
return;
|
|
m_polymaterials.push_back(pair<KX_Scene*,RAS_IPolyMaterial*>(m_currentScene,polymat));
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::CachePolyMaterial(KX_Scene *scene, Material *mat, RAS_IPolyMaterial *polymat)
|
|
{
|
|
if (m_use_mat_cache && mat)
|
|
m_polymat_cache[scene][mat] = polymat;
|
|
}
|
|
|
|
RAS_IPolyMaterial *KX_BlenderSceneConverter::FindCachedPolyMaterial(KX_Scene *scene, struct Material *mat)
|
|
{
|
|
return (m_use_mat_cache) ? m_polymat_cache[scene][mat] : NULL;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::CacheBlenderMaterial(KX_Scene *scene, struct Material *mat, BL_Material *blmat)
|
|
{
|
|
if (m_use_mat_cache && mat)
|
|
m_mat_cache[scene][mat] = blmat;
|
|
}
|
|
|
|
BL_Material *KX_BlenderSceneConverter::FindCachedBlenderMaterial(KX_Scene *scene, struct Material *mat)
|
|
{
|
|
return (m_use_mat_cache) ? m_mat_cache[scene][mat] : NULL;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::RegisterInterpolatorList(
|
|
BL_InterpolatorList *actList,
|
|
struct bAction *for_act)
|
|
{
|
|
m_map_blender_to_gameAdtList.insert(CHashedPtr(for_act), actList);
|
|
}
|
|
|
|
|
|
|
|
BL_InterpolatorList *KX_BlenderSceneConverter::FindInterpolatorList(
|
|
struct bAction *for_act)
|
|
{
|
|
BL_InterpolatorList **listp = m_map_blender_to_gameAdtList[CHashedPtr(for_act)];
|
|
|
|
return listp?*listp:NULL;
|
|
}
|
|
|
|
|
|
|
|
void KX_BlenderSceneConverter::RegisterGameActuator(
|
|
SCA_IActuator *act,
|
|
struct bActuator *for_actuator)
|
|
{
|
|
m_map_blender_to_gameactuator.insert(CHashedPtr(for_actuator), act);
|
|
}
|
|
|
|
|
|
|
|
SCA_IActuator *KX_BlenderSceneConverter::FindGameActuator(
|
|
struct bActuator *for_actuator)
|
|
{
|
|
SCA_IActuator **actp = m_map_blender_to_gameactuator[CHashedPtr(for_actuator)];
|
|
|
|
return actp?*actp:NULL;
|
|
}
|
|
|
|
|
|
|
|
void KX_BlenderSceneConverter::RegisterGameController(
|
|
SCA_IController *cont,
|
|
struct bController *for_controller)
|
|
{
|
|
m_map_blender_to_gamecontroller.insert(CHashedPtr(for_controller), cont);
|
|
}
|
|
|
|
|
|
|
|
SCA_IController *KX_BlenderSceneConverter::FindGameController(
|
|
struct bController *for_controller)
|
|
{
|
|
SCA_IController **contp = m_map_blender_to_gamecontroller[CHashedPtr(for_controller)];
|
|
|
|
return contp?*contp:NULL;
|
|
}
|
|
|
|
|
|
|
|
void KX_BlenderSceneConverter::RegisterWorldInfo(
|
|
KX_WorldInfo *worldinfo)
|
|
{
|
|
m_worldinfos.push_back(pair<KX_Scene*,KX_WorldInfo*>(m_currentScene,worldinfo));
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo(bool clearIpo)
|
|
{
|
|
|
|
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
|
|
int numScenes = scenes->size();
|
|
int i;
|
|
for (i=0;i<numScenes;i++)
|
|
{
|
|
KX_Scene* scene = scenes->at(i);
|
|
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
|
|
CListValue* parentList = scene->GetRootParentList();
|
|
int numObjects = parentList->GetCount();
|
|
int g;
|
|
for (g=0;g<numObjects;g++)
|
|
{
|
|
KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
|
|
if (gameObj->IsRecordAnimation()) {
|
|
|
|
Object* blenderObject = gameObj->GetBlenderObject();
|
|
if (blenderObject)
|
|
{
|
|
#if 0
|
|
//erase existing ipo's
|
|
Ipo* ipo = blenderObject->ipo;//findIpoForName(blenderObject->id.name+2);
|
|
if (ipo)
|
|
{ //clear the curve data
|
|
if (clearIpo) {//rcruiz
|
|
IpoCurve *icu1;
|
|
|
|
int numCurves = 0;
|
|
for ( icu1 = (IpoCurve*)ipo->curve.first; icu1; ) {
|
|
|
|
IpoCurve* tmpicu = icu1;
|
|
|
|
/*int i;
|
|
BezTriple *bezt;
|
|
for ( bezt = tmpicu->bezt, i = 0; i < tmpicu->totvert; i++, bezt++) {
|
|
printf("(%f,%f,%f),(%f,%f,%f),(%f,%f,%f)\n",bezt->vec[0][0],bezt->vec[0][1],bezt->vec[0][2],bezt->vec[1][0],bezt->vec[1][1],bezt->vec[1][2],bezt->vec[2][0],bezt->vec[2][1],bezt->vec[2][2]);
|
|
}*/
|
|
|
|
icu1 = icu1->next;
|
|
numCurves++;
|
|
|
|
BLI_remlink( &( blenderObject->ipo->curve ), tmpicu );
|
|
if ( tmpicu->bezt )
|
|
MEM_freeN( tmpicu->bezt );
|
|
MEM_freeN( tmpicu );
|
|
localDel_ipoCurve( tmpicu );
|
|
}
|
|
}
|
|
} else
|
|
{ ipo = NULL; // XXX add_ipo(blenderObject->id.name+2, ID_OB);
|
|
blenderObject->ipo = ipo;
|
|
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::resetNoneDynamicObjectToIpo()
|
|
{
|
|
if (addInitFromFrame) {
|
|
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
|
|
int numScenes = scenes->size();
|
|
if (numScenes>=0) {
|
|
KX_Scene* scene = scenes->at(0);
|
|
CListValue* parentList = scene->GetRootParentList();
|
|
for (int ix=0;ix<parentList->GetCount();ix++) {
|
|
KX_GameObject* gameobj = (KX_GameObject*)parentList->GetValue(ix);
|
|
if (!gameobj->IsRecordAnimation()) {
|
|
Object* blenderobject = gameobj->GetBlenderObject();
|
|
if (!blenderobject)
|
|
continue;
|
|
if (blenderobject->type==OB_ARMATURE)
|
|
continue;
|
|
float eu[3];
|
|
mat4_to_eul(eu,blenderobject->obmat);
|
|
MT_Point3 pos = MT_Point3(
|
|
blenderobject->obmat[3][0],
|
|
blenderobject->obmat[3][1],
|
|
blenderobject->obmat[3][2]
|
|
);
|
|
MT_Vector3 eulxyz = MT_Vector3(
|
|
eu[0],
|
|
eu[1],
|
|
eu[2]
|
|
);
|
|
MT_Vector3 scale = MT_Vector3(
|
|
blenderobject->size[0],
|
|
blenderobject->size[1],
|
|
blenderobject->size[2]
|
|
);
|
|
gameobj->NodeSetLocalPosition(pos);
|
|
gameobj->NodeSetLocalOrientation(MT_Matrix3x3(eulxyz));
|
|
gameobj->NodeSetLocalScale(scale);
|
|
gameobj->NodeUpdateGS(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
///this generates ipo curves for position, rotation, allowing to use game physics in animation
|
|
void KX_BlenderSceneConverter::WritePhysicsObjectToAnimationIpo(int frameNumber)
|
|
{
|
|
|
|
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
|
|
int numScenes = scenes->size();
|
|
int i;
|
|
for (i=0;i<numScenes;i++)
|
|
{
|
|
KX_Scene* scene = scenes->at(i);
|
|
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
|
|
CListValue* parentList = scene->GetObjectList();
|
|
int numObjects = parentList->GetCount();
|
|
int g;
|
|
for (g=0;g<numObjects;g++)
|
|
{
|
|
KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
|
|
Object* blenderObject = gameObj->GetBlenderObject();
|
|
if (blenderObject && blenderObject->parent==NULL && gameObj->IsRecordAnimation()) {
|
|
|
|
if (blenderObject->adt==NULL)
|
|
BKE_id_add_animdata(&blenderObject->id);
|
|
|
|
if (blenderObject->adt)
|
|
{
|
|
const MT_Point3& position = gameObj->NodeGetWorldPosition();
|
|
//const MT_Vector3& scale = gameObj->NodeGetWorldScaling();
|
|
const MT_Matrix3x3& orn = gameObj->NodeGetWorldOrientation();
|
|
|
|
position.getValue(blenderObject->loc);
|
|
|
|
float tmat[3][3];
|
|
for (int r=0;r<3;r++)
|
|
for (int c=0;c<3;c++)
|
|
tmat[r][c] = (float)orn[c][r];
|
|
|
|
mat3_to_compatible_eul(blenderObject->rot, blenderObject->rot, tmat);
|
|
|
|
insert_keyframe(NULL, &blenderObject->id, NULL, NULL, "location", -1, (float)frameNumber, INSERTKEY_FAST);
|
|
insert_keyframe(NULL, &blenderObject->id, NULL, NULL, "rotation_euler", -1, (float)frameNumber, INSERTKEY_FAST);
|
|
|
|
#if 0
|
|
const MT_Point3& position = gameObj->NodeGetWorldPosition();
|
|
//const MT_Vector3& scale = gameObj->NodeGetWorldScaling();
|
|
const MT_Matrix3x3& orn = gameObj->NodeGetWorldOrientation();
|
|
|
|
float eulerAngles[3];
|
|
float eulerAnglesOld[3] = {0.0f, 0.0f, 0.0f};
|
|
float tmat[3][3];
|
|
|
|
// XXX animato
|
|
Ipo* ipo = blenderObject->ipo;
|
|
|
|
//create the curves, if not existing, set linear if new
|
|
|
|
IpoCurve *icu_lx = findIpoCurve((IpoCurve *)ipo->curve.first,"LocX");
|
|
if (!icu_lx) {
|
|
icu_lx = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_LOC_X, 1);
|
|
if (icu_lx) icu_lx->ipo = IPO_LIN;
|
|
}
|
|
IpoCurve *icu_ly = findIpoCurve((IpoCurve *)ipo->curve.first,"LocY");
|
|
if (!icu_ly) {
|
|
icu_ly = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_LOC_Y, 1);
|
|
if (icu_ly) icu_ly->ipo = IPO_LIN;
|
|
}
|
|
IpoCurve *icu_lz = findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ");
|
|
if (!icu_lz) {
|
|
icu_lz = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_LOC_Z, 1);
|
|
if (icu_lz) icu_lz->ipo = IPO_LIN;
|
|
}
|
|
IpoCurve *icu_rx = findIpoCurve((IpoCurve *)ipo->curve.first,"RotX");
|
|
if (!icu_rx) {
|
|
icu_rx = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_ROT_X, 1);
|
|
if (icu_rx) icu_rx->ipo = IPO_LIN;
|
|
}
|
|
IpoCurve *icu_ry = findIpoCurve((IpoCurve *)ipo->curve.first,"RotY");
|
|
if (!icu_ry) {
|
|
icu_ry = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_ROT_Y, 1);
|
|
if (icu_ry) icu_ry->ipo = IPO_LIN;
|
|
}
|
|
IpoCurve *icu_rz = findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ");
|
|
if (!icu_rz) {
|
|
icu_rz = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_ROT_Z, 1);
|
|
if (icu_rz) icu_rz->ipo = IPO_LIN;
|
|
}
|
|
|
|
if (icu_rx) eulerAnglesOld[0] = eval_icu( icu_rx, frameNumber - 1 ) / ((180 / 3.14159265f) / 10);
|
|
if (icu_ry) eulerAnglesOld[1] = eval_icu( icu_ry, frameNumber - 1 ) / ((180 / 3.14159265f) / 10);
|
|
if (icu_rz) eulerAnglesOld[2] = eval_icu( icu_rz, frameNumber - 1 ) / ((180 / 3.14159265f) / 10);
|
|
|
|
// orn.getValue((float *)tmat); // uses the wrong ordering, cant use this
|
|
for (int r = 0; r < 3; r++)
|
|
for (int c = 0; c < 3; c++)
|
|
tmat[r][c] = orn[c][r];
|
|
|
|
// mat3_to_eul( eulerAngles,tmat); // better to use Mat3ToCompatibleEul
|
|
mat3_to_compatible_eul( eulerAngles, eulerAnglesOld,tmat);
|
|
|
|
//eval_icu
|
|
for (int x = 0; x < 3; x++)
|
|
eulerAngles[x] *= (float) ((180 / 3.14159265f) / 10.0);
|
|
|
|
//fill the curves with data
|
|
if (icu_lx) insert_vert_icu(icu_lx, frameNumber, position.x(), 1);
|
|
if (icu_ly) insert_vert_icu(icu_ly, frameNumber, position.y(), 1);
|
|
if (icu_lz) insert_vert_icu(icu_lz, frameNumber, position.z(), 1);
|
|
if (icu_rx) insert_vert_icu(icu_rx, frameNumber, eulerAngles[0], 1);
|
|
if (icu_ry) insert_vert_icu(icu_ry, frameNumber, eulerAngles[1], 1);
|
|
if (icu_rz) insert_vert_icu(icu_rz, frameNumber, eulerAngles[2], 1);
|
|
|
|
// Handles are corrected at the end, testhandles_ipocurve isn't needed yet
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void KX_BlenderSceneConverter::TestHandlesPhysicsObjectToAnimationIpo()
|
|
{
|
|
|
|
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
|
|
int numScenes = scenes->size();
|
|
int i;
|
|
for (i=0;i<numScenes;i++)
|
|
{
|
|
KX_Scene* scene = scenes->at(i);
|
|
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
|
|
CListValue* parentList = scene->GetRootParentList();
|
|
int numObjects = parentList->GetCount();
|
|
int g;
|
|
for (g=0;g<numObjects;g++)
|
|
{
|
|
KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
|
|
if (gameObj->IsRecordAnimation()) {
|
|
Object* blenderObject = gameObj->GetBlenderObject();
|
|
if (blenderObject && blenderObject->adt)
|
|
{
|
|
bAction *act = verify_adt_action(&blenderObject->id, false);
|
|
FCurve *fcu;
|
|
|
|
if (!act) {
|
|
continue;
|
|
}
|
|
|
|
/* for now, not much choice but to run this on all curves... */
|
|
for (fcu = (FCurve *)act->curves.first; fcu; fcu = fcu->next) {
|
|
/* Note: calling `sort_time_fcurve()` here is not needed, since
|
|
* all keys have been added in 'right' order. */
|
|
calchandles_fcurve(fcu);
|
|
}
|
|
#if 0
|
|
// XXX animato
|
|
Ipo* ipo = blenderObject->ipo;
|
|
|
|
//create the curves, if not existing
|
|
//testhandles_ipocurve checks for NULL
|
|
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocX"));
|
|
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocY"));
|
|
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ"));
|
|
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotX"));
|
|
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotY"));
|
|
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ"));
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef WITH_PYTHON
|
|
PyObject *KX_BlenderSceneConverter::GetPyNamespace()
|
|
{
|
|
return m_ketsjiEngine->GetPyNamespace();
|
|
}
|
|
#endif
|
|
|
|
vector<Main*> &KX_BlenderSceneConverter::GetMainDynamic()
|
|
{
|
|
return m_DynamicMaggie;
|
|
}
|
|
|
|
Main* KX_BlenderSceneConverter::GetMainDynamicPath(const char *path)
|
|
{
|
|
for (vector<Main*>::iterator it=m_DynamicMaggie.begin(); !(it==m_DynamicMaggie.end()); it++)
|
|
if (BLI_path_cmp((*it)->name, path) == 0)
|
|
return *it;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::MergeAsyncLoads()
|
|
{
|
|
vector<KX_Scene*> *merge_scenes;
|
|
|
|
vector<KX_LibLoadStatus*>::iterator mit;
|
|
vector<KX_Scene*>::iterator sit;
|
|
|
|
pthread_mutex_lock(&m_threadinfo->merge_lock);
|
|
|
|
for (mit=m_mergequeue.begin(); mit!=m_mergequeue.end(); ++mit) {
|
|
merge_scenes = (vector<KX_Scene*>*)(*mit)->GetData();
|
|
|
|
for (sit=merge_scenes->begin(); sit!=merge_scenes->end(); ++sit) {
|
|
(*mit)->GetMergeScene()->MergeScene(*sit);
|
|
delete (*sit);
|
|
}
|
|
|
|
|
|
delete merge_scenes;
|
|
(*mit)->SetData(NULL);
|
|
|
|
(*mit)->Finish();
|
|
}
|
|
|
|
m_mergequeue.clear();
|
|
|
|
pthread_mutex_unlock(&m_threadinfo->merge_lock);
|
|
}
|
|
|
|
void KX_BlenderSceneConverter::AddScenesToMergeQueue(KX_LibLoadStatus *status)
|
|
{
|
|
pthread_mutex_lock(&m_threadinfo->merge_lock);
|
|
m_mergequeue.push_back(status);
|
|
pthread_mutex_unlock(&m_threadinfo->merge_lock);
|
|
}
|
|
|
|
static void *async_convert(void *ptr)
|
|
{
|
|
KX_Scene *new_scene = NULL;
|
|
KX_LibLoadStatus *status = (KX_LibLoadStatus*)ptr;
|
|
vector<Scene*> *scenes = (vector<Scene*>*)status->GetData();
|
|
vector<KX_Scene*> *merge_scenes = new vector<KX_Scene*>(); // Deleted in MergeAsyncLoads
|
|
|
|
for (unsigned int i=0; i<scenes->size(); ++i) {
|
|
new_scene = status->GetEngine()->CreateScene((*scenes)[i], true);
|
|
|
|
if (new_scene)
|
|
merge_scenes->push_back(new_scene);
|
|
|
|
status->AddProgress((1.f/scenes->size())*0.9f); // We'll call conversion 90% and merging 10% for now
|
|
}
|
|
|
|
delete scenes;
|
|
status->SetData(merge_scenes);
|
|
|
|
status->GetConverter()->AddScenesToMergeQueue(status);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
KX_LibLoadStatus *KX_BlenderSceneConverter::LinkBlendFileMemory(void *data, int length, const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options)
|
|
{
|
|
BlendHandle *bpy_openlib = BLO_blendhandle_from_memory(data, length);
|
|
|
|
// Error checking is done in LinkBlendFile
|
|
return LinkBlendFile(bpy_openlib, path, group, scene_merge, err_str, options);
|
|
}
|
|
|
|
KX_LibLoadStatus *KX_BlenderSceneConverter::LinkBlendFilePath(const char *filepath, char *group, KX_Scene *scene_merge, char **err_str, short options)
|
|
{
|
|
BlendHandle *bpy_openlib = BLO_blendhandle_from_file(filepath, NULL);
|
|
|
|
// Error checking is done in LinkBlendFile
|
|
return LinkBlendFile(bpy_openlib, filepath, group, scene_merge, err_str, options);
|
|
}
|
|
|
|
static void load_datablocks(Main *main_newlib, BlendHandle *bpy_openlib, const char *path, int idcode)
|
|
{
|
|
Main *main_tmp= NULL; /* created only for linking, then freed */
|
|
LinkNode *names = NULL;
|
|
short flag= 0; /* don't need any special options */
|
|
|
|
/* 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);
|
|
}
|
|
|
|
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);
|
|
|
|
load_datablocks(main_newlib, bpy_openlib, path, idcode);
|
|
|
|
if (idcode==ID_SCE && options & LIB_LOAD_LOAD_SCRIPTS) {
|
|
load_datablocks(main_newlib, 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_newlib, bpy_openlib, path, ID_AC);
|
|
}
|
|
|
|
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) {
|
|
pthread_t id;
|
|
status->SetData(scenes);
|
|
pthread_create(&id, NULL, &async_convert, (void*)status);
|
|
m_threadinfo->threads.push_back(id);
|
|
}
|
|
|
|
#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(struct Main *maggie)
|
|
{
|
|
int maggie_index= -1;
|
|
int i=0;
|
|
|
|
if (maggie==NULL)
|
|
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, 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, 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);
|
|
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 {
|
|
/* 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 (bmat) {
|
|
//printf("FOUND MAT '%s' !!! ", ((ID*)bmat)->name+2);
|
|
}
|
|
else {
|
|
//printf("LOST MAT !!!");
|
|
}
|
|
|
|
if (IS_TAGGED(bmat)) {
|
|
delete (*polymit).second;
|
|
*polymit = m_polymaterials.back();
|
|
m_polymaterials.pop_back();
|
|
size--;
|
|
//printf("tagged !\n");
|
|
} else {
|
|
i++;
|
|
polymit++;
|
|
//printf("(un)tagged !\n");
|
|
}
|
|
}
|
|
|
|
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)) {
|
|
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;
|
|
}
|
|
|
|
bool KX_BlenderSceneConverter::FreeBlendFile(const char *path)
|
|
{
|
|
return FreeBlendFile(GetMainDynamicPath(path));
|
|
}
|
|
|
|
bool KX_BlenderSceneConverter::MergeScene(KX_Scene *to, KX_Scene *from)
|
|
{
|
|
|
|
{
|
|
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator itp = m_worldinfos.begin();
|
|
while (itp != m_worldinfos.end()) {
|
|
if ((*itp).first==from)
|
|
(*itp).first= to;
|
|
itp++;
|
|
}
|
|
}
|
|
|
|
{
|
|
vector<pair<KX_Scene*,RAS_IPolyMaterial*> >::iterator itp = m_polymaterials.begin();
|
|
while (itp != m_polymaterials.end()) {
|
|
if ((*itp).first==from) {
|
|
(*itp).first= to;
|
|
|
|
/* also switch internal data */
|
|
RAS_IPolyMaterial*mat= (*itp).second;
|
|
mat->Replace_IScene(to);
|
|
}
|
|
itp++;
|
|
}
|
|
}
|
|
|
|
{
|
|
vector<pair<KX_Scene*,RAS_MeshObject*> >::iterator itp = m_meshobjects.begin();
|
|
while (itp != m_meshobjects.end()) {
|
|
if ((*itp).first==from)
|
|
(*itp).first= to;
|
|
itp++;
|
|
}
|
|
}
|
|
|
|
{
|
|
vector<pair<KX_Scene*,BL_Material*> >::iterator itp = m_materials.begin();
|
|
while (itp != m_materials.end()) {
|
|
if ((*itp).first==from)
|
|
(*itp).first= to;
|
|
itp++;
|
|
}
|
|
}
|
|
|
|
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));
|
|
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);
|
|
me->us--;
|
|
}
|
|
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.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(&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;
|
|
mat_new->id.us++;
|
|
mat_old->id.us--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|