synched with trunk at revision 32129
[blender.git] / source / gameengine / Ketsji / KX_KetsjiEngine.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 #ifndef __KX_KETSJI_ENGINE
31 #define __KX_KETSJI_ENGINE
32
33 #include "MT_CmMatrix4x4.h"
34 #include "MT_Matrix4x4.h"
35 #include "STR_String.h"
36 #include "KX_ISystem.h"
37 #include "KX_Scene.h"
38 #include "KX_Python.h"
39 #include "KX_WorldInfo.h"
40 #include <vector>
41 #include <set>
42
43 class KX_TimeCategoryLogger;
44
45 #define LEFT_EYE  1
46 #define RIGHT_EYE 2
47
48 enum KX_ExitRequestMode
49 {
50         KX_EXIT_REQUEST_NO_REQUEST = 0,
51         KX_EXIT_REQUEST_QUIT_GAME,
52         KX_EXIT_REQUEST_RESTART_GAME,
53         KX_EXIT_REQUEST_START_OTHER_GAME,
54         KX_EXIT_REQUEST_NO_SCENES_LEFT,
55         KX_EXIT_REQUEST_BLENDER_ESC,
56         KX_EXIT_REQUEST_OUTSIDE,
57         KX_EXIT_REQUEST_MAX
58 };
59
60 /**
61  * KX_KetsjiEngine is the core game engine class.
62  */
63 class KX_KetsjiEngine
64 {
65
66 private:
67         class RAS_ICanvas*                              m_canvas; // 2D Canvas (2D Rendering Device Context)
68         class RAS_IRasterizer*                          m_rasterizer;  // 3D Rasterizer (3D Rendering)
69         class KX_ISystem*                               m_kxsystem;
70         class RAS_IRenderTools*                         m_rendertools;
71         class KX_ISceneConverter*                       m_sceneconverter;
72         class NG_NetworkDeviceInterface*                m_networkdevice;
73 #ifndef DISABLE_PYTHON
74         /* borrowed from sys.modules["__main__"], dont manage ref's */
75         PyObject*                                       m_pythondictionary;
76 #endif
77         class SCA_IInputDevice*                         m_keyboarddevice;
78         class SCA_IInputDevice*                         m_mousedevice;
79         class KX_Dome*                                          m_dome; // dome stereo mode
80
81         /** Lists of scenes scheduled to be removed at the end of the frame. */
82         std::set<STR_String> m_removingScenes;
83         /** Lists of overley scenes scheduled to be added at the end of the frame. */
84         std::set<STR_String> m_addingOverlayScenes;
85         /** Lists of background scenes scheduled to be added at the end of the frame. */
86         std::set<STR_String> m_addingBackgroundScenes;
87         /** Lists of scenes scheduled to be replaced at the end of the frame. */
88         std::set<std::pair<STR_String,STR_String> >     m_replace_scenes;
89
90         /* The current list of scenes. */
91         KX_SceneList            m_scenes;
92         /* State variable recording the presence of object debug info in the current scene list. */
93         bool                            m_propertiesPresent;    
94
95         bool                            m_bInitialized;
96         int                                     m_activecam;
97         bool                            m_bFixedTime;
98         
99         
100         bool                            m_firstframe;
101         int                                     m_currentFrame;
102
103         double                          m_frameTime;//discrete timestamp of the 'game logic frame'
104         double                          m_clockTime;//current time
105         double                          m_previousClockTime;//previous clock time
106         double                          m_remainingTime;
107
108         static int                              m_maxLogicFrame;        /* maximum number of consecutive logic frame */
109         static int                              m_maxPhysicsFrame;      /* maximum number of consecutive physics frame */
110         static double                   m_ticrate;
111         static double                   m_anim_framerate; /* for animation playback only - ipo and action */
112
113         static double                   m_suspendedtime;
114         static double                   m_suspendeddelta;
115
116         int                                     m_exitcode;
117         STR_String                      m_exitstring;
118                 /**
119                  * Some drawing parameters, the drawing mode
120                  * (wire/flat/texture), and the camera zoom
121                  * factor.
122                  */
123         int                             m_drawingmode;
124         float                   m_cameraZoom;
125         
126         bool                    m_overrideCam;  
127         STR_String              m_overrideSceneName;
128         
129         bool                    m_overrideCamUseOrtho;
130         MT_CmMatrix4x4  m_overrideCamProjMat;
131         MT_CmMatrix4x4  m_overrideCamViewMat;
132         float                   m_overrideCamNear;
133         float                   m_overrideCamFar;
134         float                   m_overrideCamLens;
135
136         bool m_stereo;
137         int m_curreye;
138
139         /** Categories for profiling display. */
140         typedef enum
141         {
142                 tc_first = 0,
143                 tc_physics = 0,
144                 tc_logic,
145                 tc_network,
146                 tc_scenegraph,
147                 tc_sound,
148                 tc_rasterizer,
149                 tc_services,    // time spend in miscelaneous activities
150                 tc_overhead,    // profile info drawing overhead
151                 tc_outside,             // time spend outside main loop
152                 tc_numCategories
153         } KX_TimeCategory;
154
155         /** Time logger. */
156         KX_TimeCategoryLogger*  m_logger;
157         
158         /** Labels for profiling display. */
159         static const char               m_profileLabels[tc_numCategories][15];
160         /** Last estimated framerate */
161         static double                   m_average_framerate;
162         /** Show the framerate on the game display? */
163         bool                                    m_show_framerate;
164         /** Show profiling info on the game display? */
165         bool                                    m_show_profile;
166         /** Show any debug (scene) object properties on the game display? */
167         bool                                    m_showProperties;
168         /** Show background behind text for readability? */
169         bool                                    m_showBackground;
170
171         bool                                    m_show_debug_properties;
172
173         /** record physics into keyframes */
174         bool                                    m_animation_record;
175
176         /** Hide cursor every frame? */
177         bool                                    m_hideCursor;
178
179         /** Override framing bars color? */
180         bool                                    m_overrideFrameColor;
181         /** Red component of framing bar color. */
182         float                                   m_overrideFrameColorR;
183         /** Green component of framing bar color. */
184         float                                   m_overrideFrameColorG;
185         /** Blue component of framing bar color. */
186         float                                   m_overrideFrameColorB;
187
188         void                                    RenderFrame(KX_Scene* scene, KX_Camera* cam);
189         void                                    PostRenderScene(KX_Scene* scene);
190         void                                    RenderDebugProperties();
191         void                                    RenderShadowBuffers(KX_Scene *scene);
192         void                                    SetBackGround(KX_WorldInfo* worldinfo);
193         void                                    DoSound(KX_Scene* scene);
194
195 public:
196         KX_KetsjiEngine(class KX_ISystem* system);
197         virtual ~KX_KetsjiEngine();
198
199         // set the devices and stuff. the client must take care of creating these
200         void                    SetWorldSettings(KX_WorldInfo* worldinfo);
201         void                    SetKeyboardDevice(SCA_IInputDevice* keyboarddevice);
202         void                    SetMouseDevice(SCA_IInputDevice* mousedevice);
203         void                    SetNetworkDevice(NG_NetworkDeviceInterface* networkdevice);
204         void                    SetCanvas(RAS_ICanvas* canvas);
205         void                    SetRenderTools(RAS_IRenderTools* rendertools);
206         void                    SetRasterizer(RAS_IRasterizer* rasterizer);
207 #ifndef DISABLE_PYTHON
208         void                    SetPyNamespace(PyObject* pythondictionary);
209         PyObject*               GetPyNamespace(){return m_pythondictionary;};
210 #endif
211         void                    SetSceneConverter(KX_ISceneConverter* sceneconverter);
212         void                    SetAnimRecordMode(bool animation_record, int startFrame);
213
214         RAS_IRasterizer*                GetRasterizer(){return m_rasterizer;};
215         RAS_ICanvas*                GetCanvas(){return m_canvas;};
216         RAS_IRenderTools*           GetRenderTools(){return m_rendertools;};
217         SCA_IInputDevice*               GetKeyboardDevice(){return m_keyboarddevice;};
218         SCA_IInputDevice*               GetMouseDevice(){return m_mousedevice;};
219
220         /// Dome functions
221         void                    InitDome(short res, short mode, short angle, float resbuf, short tilt, struct Text* text); 
222         void                    EndDome();
223         void                    RenderDome();
224         bool                    m_usedome;
225
226         ///returns true if an update happened to indicate -> Render
227         bool                    NextFrame();
228         void                    Render();
229         
230         void                    StartEngine(bool clearIpo);
231         void                    StopEngine();
232         void                    Export(const STR_String& filename);
233
234         void                    RequestExit(int exitrequestmode);
235         void                    SetNameNextGame(const STR_String& nextgame);
236         int                             GetExitCode();
237         const STR_String&       GetExitString();
238
239         KX_SceneList*   CurrentScenes();
240         KX_Scene*       FindScene(const STR_String& scenename);
241         void                    AddScene(class KX_Scene* scene);
242         void                    ConvertAndAddScene(const STR_String& scenename,bool overlay);
243
244         void                    RemoveScene(const STR_String& scenename);
245         void                    ReplaceScene(const STR_String& oldscene,const STR_String& newscene);
246         void                    SuspendScene(const STR_String& scenename);
247         void                    ResumeScene(const STR_String& scenename);
248
249         void                    GetSceneViewport(KX_Scene* scene, KX_Camera* cam, RAS_Rect& area, RAS_Rect& viewport);
250
251         void SetDrawType(int drawingtype);
252         int  GetDrawType(){return m_drawingmode;};
253
254         void SetCameraZoom(float camzoom);
255         
256         void EnableCameraOverride(const STR_String& forscene);
257         
258         void SetCameraOverrideUseOrtho(bool useOrtho);
259         void SetCameraOverrideProjectionMatrix(const MT_CmMatrix4x4& mat);
260         void SetCameraOverrideViewMatrix(const MT_CmMatrix4x4& mat);
261         void SetCameraOverrideClipping(float near, float far);
262         void SetCameraOverrideLens(float lens);
263         
264         /**
265          * Sets display of all frames.
266          * @param bUseFixedTime New setting for display all frames.
267          */ 
268         void SetUseFixedTime(bool bUseFixedTime);
269
270         /**
271          * Returns display of all frames.
272          * @return Current setting for display all frames.
273          */ 
274         bool GetUseFixedTime(void) const;
275
276         /**
277          * Returns current render frame clock time
278          */
279         double GetClockTime(void) const;
280         /**
281          * Returns current logic frame clock time
282          */
283         double GetFrameTime(void) const;
284
285         double GetRealTime(void) const;
286         /**
287          * Returns the difference between the local time of the scene (when it
288          * was running and not suspended) and the "curtime"
289          */
290         static double GetSuspendedDelta();
291
292         /**
293          * Gets the number of logic updates per second.
294          */
295         static double GetTicRate();
296         /**
297          * Sets the number of logic updates per second.
298          */
299         static void SetTicRate(double ticrate);
300         /**
301          * Gets the maximum number of logic frame before render frame
302          */
303         static int GetMaxLogicFrame();
304         /**
305          * Sets the maximum number of logic frame before render frame
306          */
307         static void SetMaxLogicFrame(int frame);
308         /**
309          * Gets the maximum number of physics frame before render frame
310          */
311         static int GetMaxPhysicsFrame();
312         /**
313          * Sets the maximum number of physics frame before render frame
314          */
315         static void SetMaxPhysicsFrame(int frame);
316
317         /**
318          * Gets the framerate for playing animations. (actions and ipos)
319          */
320         static double GetAnimFrameRate();
321         /**
322          * Sets the framerate for playing animations. (actions and ipos)
323          */
324         static void SetAnimFrameRate(double framerate);
325
326         /**
327          * Gets the last estimated average framerate
328          */
329         static double GetAverageFrameRate();
330
331         /**
332          * Activates or deactivates timing information display.
333          * @param frameRate             Display for frame rate on or off.
334          * @param profile               Display for individual components on or off.
335          * @param properties    Display of scene object debug properties on or off.
336          */ 
337         void SetTimingDisplay(bool frameRate, bool profile, bool properties);
338
339         /**
340          * Returns status of timing information display.
341          * @param frameRate             Display for frame rate on or off.
342          * @param profile               Display for individual components on or off.
343          * @param properties    Display of scene object debug properties on or off.
344          */ 
345         void GetTimingDisplay(bool& frameRate, bool& profile, bool& properties) const;
346
347         /** 
348          * Sets cursor hiding on every frame.
349          * @param hideCursor Turns hiding on or off.
350          */
351         void SetHideCursor(bool hideCursor);
352
353         /** 
354          * Returns the current setting for cursor hiding.
355          * @return The current setting for cursor hiding.
356          */
357         bool GetHideCursor(void) const;
358
359         /** 
360          * Enables/disables the use of the framing bar color of the Blender file's scenes.
361          * @param overrideFrameColor The new setting.
362          */
363         void SetUseOverrideFrameColor(bool overrideFrameColor);
364
365         /** 
366          * Enables/disables the use of the framing bar color of the Blender file's scenes.
367          * @param useSceneFrameColor The new setting.
368          */
369         bool GetUseOverrideFrameColor(void) const; 
370
371         /** 
372          * Set the color used for framing bar color instead of the one in the Blender file's scenes.
373          * @param r Red component of the override color.
374          * @param g Green component of the override color.
375          * @param b Blue component of the override color.
376          */
377         void SetOverrideFrameColor(float r, float g, float b);
378
379         /** 
380          * Returns the color used for framing bar color instead of the one in the Blender file's scenes.
381          * @param r Red component of the override color.
382          * @param g Green component of the override color.
383          * @param b Blue component of the override color.
384          */
385         void GetOverrideFrameColor(float& r, float& g, float& b) const;
386
387         KX_Scene*               CreateScene(const STR_String& scenename);
388         KX_Scene*               CreateScene(Scene *scene);
389         
390 protected:
391         /**
392          * Processes all scheduled scene activity.
393          * At the end, if the scene lists have changed,
394          * SceneListsChanged(void) is called.
395          * @see SceneListsChanged(void).
396          */
397         void                    ProcessScheduledScenes(void);
398
399         /**
400          * This method is invoked when the scene lists have changed.
401          */
402         void                    SceneListsChanged(void);
403
404         void                    RemoveScheduledScenes(void);
405         void                    AddScheduledScenes(void);
406         void                    ReplaceScheduledScenes(void);
407         void                    PostProcessScene(class KX_Scene* scene);
408         
409         bool                    BeginFrame();
410         void                    ClearFrame();
411         void                    EndFrame();
412         
413         
414 #ifdef WITH_CXX_GUARDEDALLOC
415 public:
416         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:KX_KetsjiEngine"); }
417         void operator delete( void *mem ) { MEM_freeN(mem); }
418 #endif
419 };
420
421 #endif //__KX_KETSJI_ENGINE
422
423