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