update for MingW/CMake
[blender-staging.git] / source / gameengine / GameLogic / SCA_LogicManager.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  * Regulates the top-level logic behaviour for one scene.
29  */
30 #ifndef __KX_LOGICMANAGER
31 #define __KX_LOGICMANAGER
32
33 #if defined(WIN32) && !defined(FREE_WINDOWS)
34 #pragma warning (disable:4786)
35 #endif 
36
37 #include <vector>
38 //#include "GEN_Map.h"
39 #include <set>
40 #include <map>
41 #include <list>
42
43 #include "GEN_Map.h"
44 #include "STR_HashedString.h"
45 #include "Value.h"
46 #include "SG_QList.h"
47
48 #include "KX_HashedPtr.h"
49
50 using namespace std;
51 typedef std::list<class SCA_IController*> controllerlist;
52 typedef std::map<class SCA_ISensor*,controllerlist > sensormap_t;
53
54 /** 
55  * This manager handles sensor, controllers and actuators.
56  * logic executes each frame the following way:
57  * find triggering sensors
58  * build list of controllers that are triggered by these triggering sensors
59  * process all triggered controllers
60  * during this phase actuators can be added to the active actuator list
61  * process all active actuators
62  * clear triggering sensors
63  * clear triggered controllers
64  * (actuators may be active during a longer timeframe)
65 */
66
67 #include "SCA_ILogicBrick.h"
68 #include "SCA_IActuator.h"
69 #include "SCA_EventManager.h"
70
71
72 class SCA_LogicManager
73 {
74         vector<class SCA_EventManager*>         m_eventmanagers;
75         
76         // SG_DList: Head of objects having activated actuators
77         //           element: SCA_IObject::m_activeActuators
78         SG_DList                                                        m_activeActuators;
79         // SG_DList: Head of objects having activated controllers
80         //           element: SCA_IObject::m_activeControllers
81         SG_DList                                                        m_triggeredControllerSet;
82
83         // need to find better way for this
84         // also known as FactoryManager...
85         GEN_Map<STR_HashedString,CValue*>       m_mapStringToGameObjects;
86         GEN_Map<STR_HashedString,void*>         m_mapStringToMeshes;
87         GEN_Map<STR_HashedString,void*>         m_mapStringToActions;
88
89         GEN_Map<STR_HashedString,void*>         m_map_gamemeshname_to_blendobj;
90         GEN_Map<CHashedPtr,void*>                       m_map_blendobj_to_gameobj;
91 public:
92         SCA_LogicManager();
93         virtual ~SCA_LogicManager();
94
95         //void  SetKeyboardManager(SCA_KeyboardManager* keyboardmgr) { m_keyboardmgr=keyboardmgr;}
96         void    RegisterEventManager(SCA_EventManager* eventmgr);
97         void    RegisterToSensor(SCA_IController* controller,
98                                                          class SCA_ISensor* sensor);
99         void    RegisterToActuator(SCA_IController* controller,
100                                                            class SCA_IActuator* actuator);
101         
102         void    BeginFrame(double curtime, double fixedtime);
103         void    UpdateFrame(double curtime, bool frame);
104         void    EndFrame();
105         void    AddActiveActuator(SCA_IActuator* actua,bool event)
106         {
107                 actua->SetActive(true);
108                 actua->Activate(m_activeActuators);
109                 actua->AddEvent(event);
110         }
111
112         void    AddTriggeredController(SCA_IController* controller, SCA_ISensor* sensor);
113         SCA_EventManager*       FindEventManager(int eventmgrtype);
114         vector<class SCA_EventManager*> GetEventManagers() { return m_eventmanagers; }
115         
116         void    RemoveGameObject(const STR_String& gameobjname);
117
118         /**
119         * remove Logic Bricks from the running logicmanager
120         */
121         void    RemoveSensor(SCA_ISensor* sensor);
122         void    RemoveController(SCA_IController* controller);
123         void    RemoveActuator(SCA_IActuator* actuator);
124         
125
126         // for the scripting... needs a FactoryManager later (if we would have time... ;)
127         void    RegisterMeshName(const STR_String& meshname,void* mesh);
128         void    UnregisterMeshName(const STR_String& meshname,void* mesh);
129         GEN_Map<STR_HashedString,void*>&        GetMeshMap() { return m_mapStringToMeshes; };
130         
131         void    RegisterActionName(const STR_String& actname,void* action);
132
133         void*   GetActionByName (const STR_String& actname);
134         void*   GetMeshByName(const STR_String& meshname);
135
136         void    RegisterGameObjectName(const STR_String& gameobjname,CValue* gameobj);
137         class CValue*   GetGameObjectByName(const STR_String& gameobjname);
138
139         void    RegisterGameMeshName(const STR_String& gamemeshname, void* blendobj);
140         void*   FindBlendObjByGameMeshName(const STR_String& gamemeshname);
141
142         void    RegisterGameObj(void* blendobj, CValue* gameobj);
143         void    UnregisterGameObj(void* blendobj, CValue* gameobj);
144         CValue* FindGameObjByBlendObj(void* blendobj);
145         
146         
147 #ifdef WITH_CXX_GUARDEDALLOC
148 public:
149         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:SCA_LogicManager"); }
150         void operator delete( void *mem ) { MEM_freeN(mem); }
151 #endif
152 };
153
154 #endif //__KX_LOGICMANAGER
155