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