style cleanup - remove unneeded ';'s
[blender.git] / source / gameengine / Ketsji / KX_Scene.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 /** \file KX_Scene.h
29  *  \ingroup ketsji
30  */
31
32 #ifndef __KX_SCENE_H__
33 #define __KX_SCENE_H__
34
35
36 #include "KX_PhysicsEngineEnums.h"
37
38 #include <vector>
39 #include <set>
40 #include <list>
41
42 #include "CTR_Map.h"
43 #include "CTR_HashedPtr.h"
44 #include "SG_IObject.h"
45 #include "SCA_IScene.h"
46 #include "MT_Transform.h"
47
48 #include "RAS_FramingManager.h"
49 #include "RAS_Rect.h"
50
51
52 #include "PyObjectPlus.h"
53 #include "RAS_2DFilterManager.h"
54
55 /**
56  * \section Forward declarations
57  */
58 struct SM_MaterialProps;
59 struct SM_ShapeProps;
60 struct Scene;
61
62 class CTR_HashedPtr;
63 class CListValue;
64 class CValue;
65 class SCA_LogicManager;
66 class SCA_KeyboardManager;
67 class SCA_TimeEventManager;
68 class SCA_MouseManager;
69 class SCA_ISystem;
70 class SCA_IInputDevice;
71 class NG_NetworkDeviceInterface;
72 class NG_NetworkScene;
73 class SG_IObject;
74 class SG_Node;
75 class SG_Tree;
76 class KX_WorldInfo;
77 class KX_Camera;
78 class KX_GameObject;
79 class KX_LightObject;
80 class RAS_BucketManager;
81 class RAS_MaterialBucket;
82 class RAS_IPolyMaterial;
83 class RAS_IRasterizer;
84 class RAS_IRenderTools;
85 class SCA_JoystickManager;
86 class btCollisionShape;
87 class KX_BlenderSceneConverter;
88 struct KX_ClientObjectInfo;
89 class KX_ObstacleSimulation;
90
91 #ifdef WITH_CXX_GUARDEDALLOC
92 #include "MEM_guardedalloc.h"
93 #endif
94
95 /* for ID freeing */
96 #define IS_TAGGED(_id) ((_id) && (((ID *)_id)->flag & LIB_DOIT))
97
98 /**
99  * The KX_Scene holds all data for an independent scene. It relates
100  * KX_Objects to the specific objects in the modules.
101  * */
102 class KX_Scene : public PyObjectPlus, public SCA_IScene
103 {
104         Py_Header
105
106 #ifdef WITH_PYTHON
107         PyObject*       m_attr_dict;
108         PyObject*       m_draw_call_pre;
109         PyObject*       m_draw_call_post;
110 #endif
111
112         struct CullingInfo {
113                 int m_layer;
114                 CullingInfo(int layer) : m_layer(layer) {}
115         };
116
117 protected:
118         RAS_BucketManager*      m_bucketmanager;
119         CListValue*                     m_tempObjectList;
120
121         /**
122          * The list of objects which have been removed during the
123          * course of one frame. They are actually destroyed in 
124          * LogicEndFrame() via a call to RemoveObject().
125          */
126         CListValue*     m_euthanasyobjects;
127
128         CListValue*                     m_objectlist;
129         CListValue*                     m_parentlist; // all 'root' parents
130         CListValue*                     m_lightlist;
131         CListValue*                     m_inactivelist; // all objects that are not in the active layer
132         CListValue*                     m_animatedlist; // all animated objects
133         
134         SG_QList                        m_sghead;               // list of nodes that needs scenegraph update
135                                                                                 // the Dlist is not object that must be updated
136                                                                                 // the Qlist is for objects that needs to be rescheduled
137                                                                                 // for updates after udpate is over (slow parent, bone parent)
138
139
140         /**
141          * The set of cameras for this scene
142          */
143         std::list<class KX_Camera*>       m_cameras;
144
145         /**
146          * The set of fonts for this scene
147          */
148         std::list<class KX_FontObject*>   m_fonts;
149
150
151         /**
152          * Various SCA managers used by the scene
153          */
154         SCA_LogicManager*               m_logicmgr;
155         SCA_KeyboardManager*    m_keyboardmgr;
156         SCA_MouseManager*               m_mousemgr;
157         SCA_TimeEventManager*   m_timemgr;
158
159         // Scene converter where many scene entities are registered
160         // Used to deregister objects that are deleted
161         class KX_BlenderSceneConverter*         m_sceneConverter;
162         /**
163         * physics engine abstraction
164         */
165         //e_PhysicsEngine m_physicsEngine; //who needs this ?
166         class PHY_IPhysicsEnvironment*          m_physicsEnvironment;
167
168         /**
169          * Does this scene clear the z-buffer?
170          */
171         bool m_isclearingZbuffer;
172
173         /**
174          * The name of the scene
175          */
176         STR_String      m_sceneName;
177         
178         /**
179          * stores the world-settings for a scene
180          */
181         KX_WorldInfo* m_worldinfo;
182
183         /**
184          * \section Different scenes, linked to ketsji scene
185          */
186
187         /**
188          * Network scene.
189          */
190         NG_NetworkDeviceInterface*      m_networkDeviceInterface;
191         NG_NetworkScene* m_networkScene;
192
193         /**
194          * A temporary variable used to parent objects together on
195          * replication. Don't get confused by the name it is not
196          * the scene's root node!
197          */
198         SG_Node* m_rootnode;
199
200         /**
201          * The active camera for the scene
202          */
203         KX_Camera* m_active_camera;
204
205         /**
206          * Another temporary variable outstaying its welcome
207          * used in AddReplicaObject to map game objects to their
208          * replicas so pointers can be updated.
209          */
210         CTR_Map <CTR_HashedPtr, void*> m_map_gameobject_to_replica;
211
212         /**
213          * Another temporary variable outstaying its welcome
214          * used in AddReplicaObject to keep a record of all added 
215          * objects. Logic can only be updated when all objects 
216          * have been updated. This stores a list of the new objects.
217          */
218         std::vector<KX_GameObject*>     m_logicHierarchicalGameObjects;
219         
220         /**
221          * This temporary variable will contain the list of 
222          * object that can be added during group instantiation.
223          * objects outside this list will not be added (can 
224          * happen with children that are outside the group).
225          * Used in AddReplicaObject. If the list is empty, it
226          * means don't care.
227          */
228         std::set<CValue*>       m_groupGameObjects;
229         
230         /** 
231          * Pointer to system variable passed in in constructor
232          * only used in constructor so we do not need to keep it
233          * around in this class.
234          */
235
236         SCA_ISystem* m_kxsystem;
237
238         /**
239          * The execution priority of replicated object actuators?
240          */     
241         int     m_ueberExecutionPriority;
242
243         /**
244          * Activity 'bubble' settings :
245          * Suspend (freeze) the entire scene.
246          */
247         bool m_suspend;
248
249         /**
250          * Radius in Manhattan distance of the box for activity culling.
251          */
252         float m_activity_box_radius;
253
254         /**
255          * Toggle to enable or disable activity culling.
256          */
257         bool m_activity_culling;
258         
259         /**
260          * Toggle to enable or disable culling via DBVT broadphase of Bullet.
261          */
262         bool m_dbvt_culling;
263         
264         /**
265          * Occlusion culling resolution
266          */ 
267         int m_dbvt_occlusion_res;
268
269         /**
270          * The framing settings used by this scene
271          */
272
273         RAS_FrameSettings m_frame_settings;
274
275         /** 
276          * This scenes viewport into the game engine
277          * canvas.Maintained externally, initially [0,0] -> [0,0]
278          */
279         RAS_Rect m_viewport;
280         
281         /**
282          * Visibility testing functions.
283          */
284         void MarkVisible(SG_Tree *node, RAS_IRasterizer* rasty, KX_Camera*cam,int layer=0);
285         void MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool visible, KX_Camera*cam,int layer=0);
286         void MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj, KX_Camera*cam, int layer=0);
287         static void PhysicsCullingCallback(KX_ClientObjectInfo* objectInfo, void* cullingInfo);
288
289         double                          m_suspendedtime;
290         double                          m_suspendeddelta;
291
292         struct Scene* m_blenderScene;
293
294         RAS_2DFilterManager m_filtermanager;
295
296         KX_ObstacleSimulation* m_obstacleSimulation;
297
298 public: 
299         KX_Scene(class SCA_IInputDevice* keyboarddevice,
300                 class SCA_IInputDevice* mousedevice,
301                 class NG_NetworkDeviceInterface* ndi,
302                 const STR_String& scenename,
303                 struct Scene* scene,
304                 class RAS_ICanvas* canvas);
305
306         virtual 
307         ~KX_Scene();
308
309         RAS_BucketManager* GetBucketManager();
310         RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat, bool &bucketCreated);
311         void RenderBuckets(const MT_Transform& cameratransform,
312                                                 RAS_IRasterizer* rasty,
313                                                 RAS_IRenderTools* rendertools);
314
315         /**
316          * Update all transforms according to the scenegraph.
317          */
318         static bool KX_ScenegraphUpdateFunc(SG_IObject* node,void* gameobj,void* scene);
319         static bool KX_ScenegraphRescheduleFunc(SG_IObject* node,void* gameobj,void* scene);
320         void UpdateParents(double curtime);
321         void DupliGroupRecurse(CValue* gameobj, int level);
322         bool IsObjectInGroup(CValue* gameobj)
323         { 
324                 return (m_groupGameObjects.empty() || 
325                                 m_groupGameObjects.find(gameobj) != m_groupGameObjects.end());
326         }
327         SCA_IObject* AddReplicaObject(CValue* gameobj,
328                                                                   CValue* locationobj,
329                                                                   int lifespan=0);
330         KX_GameObject* AddNodeReplicaObject(SG_IObject* node,
331                                                                                 CValue* gameobj);
332         void RemoveNodeDestructObject(SG_IObject* node,
333                                                                   CValue* gameobj);
334         void RemoveObject(CValue* gameobj);
335         void DelayedRemoveObject(CValue* gameobj);
336         
337         int NewRemoveObject(CValue* gameobj);
338         void ReplaceMesh(CValue* gameobj,
339                                          void* meshob, bool use_gfx, bool use_phys);
340
341         void AddAnimatedObject(CValue* gameobj);
342         void RemoveAnimatedObject(CValue* gameobj);
343
344         /**
345          * \section Logic stuff
346          * Initiate an update of the logic system.
347          */
348         void LogicBeginFrame(double curtime);
349         void LogicUpdateFrame(double curtime, bool frame);
350         void UpdateAnimations(double curtime);
351
352                 void                                            
353         LogicEndFrame(
354         );
355
356                 CListValue*                             
357         GetTempObjectList(
358         );
359
360                 CListValue*
361         GetObjectList(
362         );
363
364                 CListValue*                             
365         GetInactiveList(
366         );
367
368                 CListValue*                             
369         GetRootParentList(
370         );
371
372                 CListValue*                             
373         GetLightList(
374         );
375
376                 SCA_LogicManager*               
377         GetLogicManager(
378         );
379
380                 SCA_TimeEventManager*   
381         GetTimeEventManager(
382         );
383
384         /** Font Routines */
385                 
386                 std::list<class KX_FontObject*>*
387         GetFonts(
388         );
389
390         /** Find a font in the scene by pointer. */
391                 KX_FontObject*              
392         FindFont(
393                 KX_FontObject*
394         );
395
396         /** Add a camera to this scene. */
397                 void                    
398         AddFont(
399                 KX_FontObject*
400         );
401
402
403         /** Camera Routines */
404
405                 std::list<class KX_Camera*>*
406         GetCameras(
407         );
408  
409
410         /** Find a camera in the scene by pointer. */
411                 KX_Camera*              
412         FindCamera(
413                 KX_Camera*
414         );
415
416         /** Find a scene in the scene by name. */
417                 KX_Camera*              
418         FindCamera(
419                 STR_String&
420         );
421
422         /** Add a camera to this scene. */
423                 void                    
424         AddCamera(
425                 KX_Camera*
426         );
427
428         /** Find the currently active camera. */
429                 KX_Camera*                              
430         GetActiveCamera(
431         );
432
433         /** 
434          * Set this camera to be the active camera in the scene. If the
435          * camera is not present in the camera list, it will be added
436          */
437
438                 void                                    
439         SetActiveCamera(
440                 class KX_Camera*
441         );
442
443         /**
444          * Move this camera to the end of the list so that it is rendered last.
445          * If the camera is not on the list, it will be added
446          */
447                 void
448         SetCameraOnTop(
449                 class KX_Camera*
450         );
451
452         /**
453          * Activates new desired canvas width set at design time.
454          * \param width The new desired width.
455          */
456                 void                                    
457         SetCanvasDesignWidth(
458                 unsigned int width
459         );
460         /**
461          * Activates new desired canvas height set at design time.
462          * \param width The new desired height.
463          */
464                 void                                    
465         SetCanvasDesignHeight(
466                 unsigned int height
467         );
468         /**
469          * Returns the current desired canvas width set at design time.
470          * \return The desired width.
471          */
472                 unsigned int                    
473         GetCanvasDesignWidth(
474                 void
475         ) const;
476
477         /**
478          * Returns the current desired canvas height set at design time.
479          * \return The desired height.
480          */
481                 unsigned int                    
482         GetCanvasDesignHeight(
483                 void
484         ) const;
485
486         /**
487          * Set the framing options for this scene
488          */
489
490                 void
491         SetFramingType(
492                 RAS_FrameSettings & frame_settings
493         );
494
495         /**
496          * Return a const reference to the framing 
497          * type set by the above call.
498          * The contents are not guaranteed to be sensible
499          * if you don't call the above function.
500          */
501
502         const
503                 RAS_FrameSettings &
504         GetFramingType(
505         ) const;
506
507         /**
508          * Store the current scene's viewport on the 
509          * game engine canvas.
510          */
511         void SetSceneViewport(const RAS_Rect &viewport);
512
513         /**
514          * Get the current scene's viewport on the
515          * game engine canvas. This maintained 
516          * externally in KX_GameEngine
517          */
518         const RAS_Rect& GetSceneViewport() const;
519         
520         /**
521          * \section Accessors to different scenes of this scene
522          */
523         void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
524         void SetNetworkScene(NG_NetworkScene *newScene);
525         void SetWorldInfo(class KX_WorldInfo* wi);
526         KX_WorldInfo* GetWorldInfo();
527         void CalculateVisibleMeshes(RAS_IRasterizer* rasty, KX_Camera *cam, int layer=0);
528         void UpdateMeshTransformations();
529         KX_Camera* GetpCamera();
530         NG_NetworkDeviceInterface* GetNetworkDeviceInterface();
531         NG_NetworkScene* GetNetworkScene();
532         KX_BlenderSceneConverter *GetSceneConverter() { return m_sceneConverter; }
533
534         /**
535          * Replicate the logic bricks associated to this object.
536          */
537
538         void ReplicateLogic(class KX_GameObject* newobj);
539         static SG_Callbacks     m_callbacks;
540
541         const STR_String& GetName();
542         
543         // Suspend the entire scene.
544         void Suspend();
545
546         // Resume a suspended scene.
547         void Resume();
548         
549         // Update the activity box settings for objects in this scene, if needed.
550         void UpdateObjectActivity(void);
551
552         // Enable/disable activity culling.
553         void SetActivityCulling(bool b);
554
555         // Set the radius of the activity culling box.
556         void SetActivityCullingRadius(float f);
557         bool IsSuspended();
558         bool IsClearingZBuffer();
559         void EnableZBufferClearing(bool isclearingZbuffer);
560         // use of DBVT tree for camera culling
561         void SetDbvtCulling(bool b) { m_dbvt_culling = b; }
562         bool GetDbvtCulling() { return m_dbvt_culling; }
563         void SetDbvtOcclusionRes(int i) { m_dbvt_occlusion_res = i; }
564         int GetDbvtOcclusionRes() { return m_dbvt_occlusion_res; }
565         
566         void SetSceneConverter(class KX_BlenderSceneConverter* sceneConverter);
567
568         class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
569         {
570                 return m_physicsEnvironment;
571         }
572
573         void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);
574
575         void    SetGravity(const MT_Vector3& gravity);
576
577         short GetAnimationFPS();
578         
579         /**
580          * Sets the node tree for this scene.
581          */
582         void SetNodeTree(SG_Tree* root);
583
584         /**
585         * 2D Filters
586         */
587         void Update2DFilter(std::vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text);
588         void Render2DFilters(RAS_ICanvas* canvas);
589
590         KX_ObstacleSimulation* GetObstacleSimulation() { return m_obstacleSimulation; }
591
592 #ifdef WITH_PYTHON
593         /* --------------------------------------------------------------------- */
594         /* Python interface ---------------------------------------------------- */
595         /* --------------------------------------------------------------------- */
596
597         KX_PYMETHOD_DOC(KX_Scene, addObject);
598         KX_PYMETHOD_DOC(KX_Scene, end);
599         KX_PYMETHOD_DOC(KX_Scene, restart);
600         KX_PYMETHOD_DOC(KX_Scene, replace);
601         KX_PYMETHOD_DOC(KX_Scene, suspend);
602         KX_PYMETHOD_DOC(KX_Scene, resume);
603         KX_PYMETHOD_DOC(KX_Scene, get);
604         KX_PYMETHOD_DOC(KX_Scene, drawObstacleSimulation);
605
606
607         /* attributes */
608         static PyObject*        pyattr_get_name(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
609         static PyObject*        pyattr_get_objects(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
610         static PyObject*        pyattr_get_objects_inactive(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
611         static PyObject*        pyattr_get_lights(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
612         static PyObject*        pyattr_get_cameras(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
613         static PyObject*        pyattr_get_active_camera(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
614         static int                      pyattr_set_active_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
615         static PyObject*        pyattr_get_drawing_callback_pre(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
616         static int                      pyattr_set_drawing_callback_pre(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
617         static PyObject*        pyattr_get_drawing_callback_post(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
618         static int                      pyattr_set_drawing_callback_post(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
619
620         virtual PyObject* py_repr(void) { return PyUnicode_From_STR_String(GetName()); }
621         
622         /* getitem/setitem */
623         static PyMappingMethods Mapping;
624         static PySequenceMethods        Sequence;
625
626         /**
627          * Run the registered python drawing functions.
628          */
629         void RunDrawingCallbacks(PyObject* cb_list);
630         
631         PyObject* GetPreDrawCB() { return m_draw_call_pre; }
632         PyObject* GetPostDrawCB() { return m_draw_call_post; }
633 #endif
634
635         /**
636          * Sets the time the scene was suspended
637          */ 
638         void setSuspendedTime(double suspendedtime);
639         /**
640          * Returns the "curtime" the scene was suspended
641          */ 
642         double getSuspendedTime();
643         /**
644          * Sets the difference between the local time of the scene (when it
645          * was running and not suspended) and the "curtime"
646          */ 
647         void setSuspendedDelta(double suspendeddelta);
648         /**
649          * Returns the difference between the local time of the scene (when it
650          * was running and not suspended) and the "curtime"
651          */
652         double getSuspendedDelta();
653         /**
654          * Returns the Blender scene this was made from
655          */
656         struct Scene *GetBlenderScene() { return m_blenderScene; }
657
658         bool MergeScene(KX_Scene *other);
659
660
661         //void PrintStats(int verbose_level) {
662         //      m_bucketmanager->PrintStats(verbose_level)
663         //}
664 };
665
666 typedef std::vector<KX_Scene*> KX_SceneList;
667
668 #endif //__KX_SCENE_H__
669