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