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