3 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version. The Blender
9 * Foundation also sells licenses for use in proprietary software under
10 * the Blender License. See http://www.blender.org/BL/ for information
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23 * All rights reserved.
25 * The Original Code is: all of this file.
27 * Contributor(s): none yet.
29 * ***** END GPL/BL DUAL LICENSE BLOCK *****
37 #pragma warning (disable:4786) // suppress stl-MSVC debug info warning
42 #include "KX_GameObject.h"
43 #include "KX_IpoConvert.h"
44 #include "RAS_MeshObject.h"
45 #include "KX_PhysicsEngineEnums.h"
47 #include "DummyPhysicsEnvironment.h"
49 //to decide to use sumo/ode or dummy physics - defines USE_ODE
50 #include "KX_ConvertPhysicsObject.h"
53 #include "OdePhysicsEnvironment.h"
57 #include "SumoPhysicsEnvironment.h"
60 #include "KX_BlenderSceneConverter.h"
61 #include "KX_BlenderScalarInterpolator.h"
62 #include "BL_BlenderDataConversion.h"
63 #include "BlenderWorldInfo.h"
66 /* This little block needed for linking to Blender... */
68 #include "BLI_winstuff.h"
71 /* This list includes only data type definitions */
72 #include "DNA_scene_types.h"
73 #include "DNA_world_types.h"
77 KX_BlenderSceneConverter::KX_BlenderSceneConverter(
79 class KX_KetsjiEngine* engine
82 m_ketsjiEngine(engine),
83 m_alwaysUseExpandFraming(false)
89 KX_BlenderSceneConverter::~KX_BlenderSceneConverter()
91 // clears meshes, and hashmaps from blender to gameengine data
96 int numipolists = m_map_blender_to_gameipolist.size();
97 for (i=0; i<numipolists; i++) {
98 BL_InterpolatorList *ipoList= *m_map_blender_to_gameipolist.at(i);
103 vector<KX_WorldInfo*>::iterator itw = m_worldinfos.begin();
104 while (itw != m_worldinfos.end()) {
109 vector<RAS_IPolyMaterial*>::iterator itp = m_polymaterials.begin();
110 while (itp != m_polymaterials.end()) {
115 vector<RAS_MeshObject*>::iterator itm = m_meshobjects.begin();
116 while (itm != m_meshobjects.end()) {
121 #ifdef USE_SUMO_SOLID
122 KX_ClearSumoSharedShapes();
128 void KX_BlenderSceneConverter::SetNewFileName(const STR_String& filename)
130 m_newfilename = filename;
135 bool KX_BlenderSceneConverter::TryAndLoadNewFile()
144 // if not, clear the newfilename
156 * Find the specified scene by name, or the first
157 * scene if nothing matches (shouldn't happen).
160 static struct Scene *GetSceneForName2(struct Main *maggie, const STR_String& scenename) {
163 for (sce= (Scene*) maggie->scene.first; sce; sce= (Scene*) sce->id.next)
164 if (scenename == (sce->id.name+2))
167 return (Scene*) maggie->scene.first;
171 void KX_BlenderSceneConverter::ConvertScene(const STR_String& scenename,
172 class KX_Scene* destinationscene,
174 class SCA_IInputDevice* keyinputdev,
175 class RAS_IRenderTools* rendertools,
176 class RAS_ICanvas* canvas)
178 //find out which physics engine
179 // Scene *blenderscene = GetSceneForName2(m_maggie, scenename); /*unused*/
181 e_PhysicsEngine physics_engine = UseSumo;
183 /* FIXME: Force physics engine = sumo.
184 This isn't really a problem - no other physics engines are available.
189 if (blenderscene->world)
191 switch (blenderscene->world->physicsEngine)
196 physics_engine = UseODE;
201 physics_engine = UseDynamo;
206 physics_engine = UseSumo;
211 physics_engine = UseNone;
218 switch (physics_engine)
221 #ifdef USE_SUMO_SOLID
223 destinationscene ->SetPhysicsEnvironment(new SumoPhysicsEnvironment());
228 destinationscene ->SetPhysicsEnvironment(new ODEPhysicsEnvironment());
238 physics_engine = UseNone;
239 destinationscene ->SetPhysicsEnvironment(new DummyPhysicsEnvironment());
243 BL_ConvertBlenderObjects(m_maggie,
253 m_alwaysUseExpandFraming
256 m_map_blender_to_gameactuator.clear();
257 m_map_blender_to_gamecontroller.clear();
259 m_map_blender_to_gameobject.clear();
260 m_map_mesh_to_gamemesh.clear();
261 m_map_gameobject_to_blender.clear();
266 void KX_BlenderSceneConverter::SetAlwaysUseExpandFraming(
269 m_alwaysUseExpandFraming= to_what;
274 void KX_BlenderSceneConverter::RegisterGameObject(
275 KX_GameObject *gameobject,
276 struct Object *for_blenderobject)
278 m_map_gameobject_to_blender.insert(CHashedPtr(gameobject),for_blenderobject);
279 m_map_blender_to_gameobject.insert(CHashedPtr(for_blenderobject),gameobject);
284 KX_GameObject *KX_BlenderSceneConverter::FindGameObject(
285 struct Object *for_blenderobject)
287 KX_GameObject **obp= m_map_blender_to_gameobject[CHashedPtr(for_blenderobject)];
289 return obp?*obp:NULL;
294 struct Object *KX_BlenderSceneConverter::FindBlenderObject(
295 KX_GameObject *for_gameobject)
297 struct Object **obp= m_map_gameobject_to_blender[CHashedPtr(for_gameobject)];
299 return obp?*obp:NULL;
304 void KX_BlenderSceneConverter::RegisterGameMesh(
305 RAS_MeshObject *gamemesh,
306 struct Mesh *for_blendermesh)
308 m_map_mesh_to_gamemesh.insert(CHashedPtr(for_blendermesh),gamemesh);
309 m_meshobjects.push_back(gamemesh);
314 RAS_MeshObject *KX_BlenderSceneConverter::FindGameMesh(
315 struct Mesh *for_blendermesh,
316 unsigned int onlayer)
318 RAS_MeshObject** meshp = m_map_mesh_to_gamemesh[CHashedPtr(for_blendermesh)];
320 if (meshp && onlayer==(*meshp)->GetLightLayer()) {
332 void KX_BlenderSceneConverter::RegisterPolyMaterial(RAS_IPolyMaterial *polymat)
334 m_polymaterials.push_back(polymat);
339 void KX_BlenderSceneConverter::RegisterInterpolatorList(
340 BL_InterpolatorList *ipoList,
343 m_map_blender_to_gameipolist.insert(CHashedPtr(for_ipo), ipoList);
348 BL_InterpolatorList *KX_BlenderSceneConverter::FindInterpolatorList(
351 BL_InterpolatorList **listp = m_map_blender_to_gameipolist[CHashedPtr(for_ipo)];
353 return listp?*listp:NULL;
358 void KX_BlenderSceneConverter::RegisterGameActuator(
360 struct bActuator *for_actuator)
362 m_map_blender_to_gameactuator.insert(CHashedPtr(for_actuator), act);
367 SCA_IActuator *KX_BlenderSceneConverter::FindGameActuator(
368 struct bActuator *for_actuator)
370 SCA_IActuator **actp = m_map_blender_to_gameactuator[CHashedPtr(for_actuator)];
372 return actp?*actp:NULL;
377 void KX_BlenderSceneConverter::RegisterGameController(
378 SCA_IController *cont,
379 struct bController *for_controller)
381 m_map_blender_to_gamecontroller.insert(CHashedPtr(for_controller), cont);
386 SCA_IController *KX_BlenderSceneConverter::FindGameController(
387 struct bController *for_controller)
389 SCA_IController **contp = m_map_blender_to_gamecontroller[CHashedPtr(for_controller)];
391 return contp?*contp:NULL;
396 void KX_BlenderSceneConverter::RegisterWorldInfo(
397 KX_WorldInfo *worldinfo)
399 m_worldinfos.push_back(worldinfo);