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