Merging trunk up to revision 41245.
[blender-staging.git] / source / gameengine / Converter / KX_BlenderSceneConverter.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file KX_BlenderSceneConverter.h
29  *  \ingroup bgeconv
30  */
31
32 #ifndef __KX_BLENDERSCENECONVERTER_H
33 #define __KX_BLENDERSCENECONVERTER_H
34
35 #include "KX_HashedPtr.h"
36 #include "CTR_Map.h"
37 #include <stdio.h>
38
39 #include "KX_ISceneConverter.h"
40 #include "KX_IpoConvert.h"
41
42 class KX_WorldInfo;
43 class SCA_IActuator;
44 class SCA_IController;
45 class RAS_MeshObject;
46 class RAS_IPolyMaterial;
47 class BL_InterpolatorList;
48 class BL_Material;
49 struct Main;
50 struct Scene;
51
52 class KX_BlenderSceneConverter : public KX_ISceneConverter
53 {
54         // Use vector of pairs to allow removal of entities between scene switch
55         vector<pair<KX_Scene*,KX_WorldInfo*> >  m_worldinfos;
56         vector<pair<KX_Scene*,RAS_IPolyMaterial*> > m_polymaterials;
57         vector<pair<KX_Scene*,RAS_MeshObject*> > m_meshobjects;
58         vector<pair<KX_Scene*,BL_Material *> >  m_materials;
59         // Should also have a list of collision shapes. 
60         // For the time being this is held in KX_Scene::m_shapes
61
62         CTR_Map<CHashedPtr,KX_GameObject*>      m_map_blender_to_gameobject;            /* cleared after conversion */
63         CTR_Map<CHashedPtr,RAS_MeshObject*>     m_map_mesh_to_gamemesh;                         /* cleared after conversion */
64         CTR_Map<CHashedPtr,SCA_IActuator*>      m_map_blender_to_gameactuator;          /* cleared after conversion */
65         CTR_Map<CHashedPtr,SCA_IController*>m_map_blender_to_gamecontroller;    /* cleared after conversion */
66         
67         CTR_Map<CHashedPtr,BL_InterpolatorList*> m_map_blender_to_gameAdtList;
68         
69         Main*                                   m_maggie;
70         vector<struct Main*>    m_DynamicMaggie;
71
72         STR_String                              m_newfilename;
73         class KX_KetsjiEngine*  m_ketsjiEngine;
74         class KX_Scene*                 m_currentScene; // Scene being converted
75         bool                                    m_alwaysUseExpandFraming;
76         bool                                    m_usemat;
77         bool                                    m_useglslmat;
78
79 public:
80         KX_BlenderSceneConverter(
81                 Main* maggie,
82                 class KX_KetsjiEngine* engine
83         );
84
85         virtual ~KX_BlenderSceneConverter();
86
87         /* Scenename: name of the scene to be converted.
88          * destinationscene: pass an empty scene, everything goes into this
89          * dictobj: python dictionary (for pythoncontrollers)
90          */
91         virtual void    ConvertScene(
92                                                 class KX_Scene* destinationscene,
93                                                 class RAS_IRenderTools* rendertools,
94                                                 class RAS_ICanvas* canvas
95                                         );
96         virtual void RemoveScene(class KX_Scene *scene);
97
98         void SetNewFileName(const STR_String& filename);
99         bool TryAndLoadNewFile();
100
101         void SetAlwaysUseExpandFraming(bool to_what);
102         
103         void RegisterGameObject(KX_GameObject *gameobject, struct Object *for_blenderobject);
104         void UnregisterGameObject(KX_GameObject *gameobject);
105         KX_GameObject *FindGameObject(struct Object *for_blenderobject);
106
107         void RegisterGameMesh(RAS_MeshObject *gamemesh, struct Mesh *for_blendermesh);
108         RAS_MeshObject *FindGameMesh(struct Mesh *for_blendermesh/*, unsigned int onlayer*/);
109
110         void RegisterPolyMaterial(RAS_IPolyMaterial *polymat);
111
112         void RegisterBlenderMaterial(BL_Material *mat);
113         
114         void RegisterInterpolatorList(BL_InterpolatorList *actList, struct bAction *for_act);
115         BL_InterpolatorList *FindInterpolatorList(struct bAction *for_act);
116
117         void RegisterGameActuator(SCA_IActuator *act, struct bActuator *for_actuator);
118         SCA_IActuator *FindGameActuator(struct bActuator *for_actuator);
119
120         void RegisterGameController(SCA_IController *cont, struct bController *for_controller);
121         SCA_IController *FindGameController(struct bController *for_controller);
122
123         void RegisterWorldInfo(KX_WorldInfo *worldinfo);
124
125         virtual void    ResetPhysicsObjectsAnimationIpo(bool clearIpo);
126
127         ///this is for reseting the position,rotation and scale of the gameobjet that is not dynamic
128         virtual void    resetNoneDynamicObjectToIpo();
129         
130         ///this generates ipo curves for position, rotation, allowing to use game physics in animation
131         virtual void    WritePhysicsObjectToAnimationIpo(int frameNumber);
132         virtual void    TestHandlesPhysicsObjectToAnimationIpo();
133
134         // use blender materials
135         virtual void SetMaterials(bool val);
136         virtual bool GetMaterials();
137
138         // use blender glsl materials
139         virtual void SetGLSLMaterials(bool val);
140         virtual bool GetGLSLMaterials();
141
142         struct Scene* GetBlenderSceneForName(const STR_String& name);
143
144 //      struct Main* GetMain() { return m_maggie; };
145         struct Main*              GetMainDynamicPath(const char *path);
146         vector<struct Main*> &GetMainDynamic();
147         
148         bool LinkBlendFileMemory(void *data, int length, const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options);
149         bool LinkBlendFilePath(const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options);
150         bool LinkBlendFile(struct BlendHandle *bpy_openlib, const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options);
151         bool MergeScene(KX_Scene *to, KX_Scene *from);
152         RAS_MeshObject *ConvertMeshSpecial(KX_Scene* kx_scene, Main *maggie, const char *name);
153         bool FreeBlendFile(struct Main *maggie);
154         bool FreeBlendFile(const char *path);
155  
156         void PrintStats() {
157                 printf("BGE STATS!\n");
158
159                 printf("\nAssets...\n");
160                 printf("\t m_worldinfos: %d\n", (int)m_worldinfos.size());
161                 printf("\t m_polymaterials: %d\n", (int)m_polymaterials.size());
162                 printf("\t m_meshobjects: %d\n", (int)m_meshobjects.size());
163                 printf("\t m_materials: %d\n", (int)m_materials.size());
164
165                 printf("\nMappings...\n");
166                 printf("\t m_map_blender_to_gameobject: %d\n", (int)m_map_blender_to_gameobject.size());
167                 printf("\t m_map_mesh_to_gamemesh: %d\n", (int)m_map_mesh_to_gamemesh.size());
168                 printf("\t m_map_blender_to_gameactuator: %d\n", (int)m_map_blender_to_gameactuator.size());
169                 printf("\t m_map_blender_to_gamecontroller: %d\n", (int)m_map_blender_to_gamecontroller.size());
170                 printf("\t m_map_blender_to_gameAdtList: %d\n", (int)m_map_blender_to_gameAdtList.size());
171
172 #ifdef WITH_CXX_GUARDEDALLOC
173                 MEM_printmemlist_pydict();
174 #endif
175 //              /printf("\t m_ketsjiEngine->m_scenes: %d\n", m_ketsjiEngine->CurrentScenes()->size());
176         }
177         
178         /* LibLoad Options */
179         enum 
180         {
181                 LIB_LOAD_LOAD_ACTIONS = 1,
182                 LIB_LOAD_VERBOSE = 2,
183         };
184
185
186
187 #ifdef WITH_PYTHON
188         PyObject *GetPyNamespace();
189 #endif
190         
191 #ifdef WITH_CXX_GUARDEDALLOC
192 public:
193         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:KX_BlenderSceneConverter"); }
194         void operator delete( void *mem ) { MEM_freeN(mem); }
195 #endif
196 };
197
198 #endif //__KX_BLENDERSCENECONVERTER_H
199