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