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