source/gameengine/Converter/KX_BlenderSceneConverter.h

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