Merged 15170:15635 from trunk (no conflicts or even merges)
[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 "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
58 class GEN_HashedPtr;
59 class CListValue;
60 class CValue;
61 class SCA_LogicManager;
62 class SCA_KeyboardManager;
63 class SCA_TimeEventManager;
64 class SCA_MouseManager;
65 class SCA_ISystem;
66 class SCA_IInputDevice;
67 class SND_Scene;
68 class SND_IAudioDevice;
69 class NG_NetworkDeviceInterface;
70 class NG_NetworkScene;
71 class SG_IObject;
72 class SG_Node;
73 class SG_Tree;
74 class KX_WorldInfo;
75 class KX_Camera;
76 class KX_GameObject;
77 class KX_LightObject;
78 class RAS_BucketManager;
79 class RAS_BucketManager;
80 class RAS_MaterialBucket;
81 class RAS_IPolyMaterial;
82 class RAS_IRasterizer;
83 class RAS_IRenderTools;
84 class SCA_JoystickManager;
85 class btCollisionShape;
86 class KX_BlenderSceneConverter;
87 /**
88  * The KX_Scene holds all data for an independent scene. It relates
89  * KX_Objects to the specific objects in the modules.
90  * */
91 class KX_Scene : public PyObjectPlus, public SCA_IScene
92 {
93         Py_Header;
94 protected:
95         RAS_BucketManager*      m_bucketmanager;
96         CListValue*                     m_tempObjectList;
97
98         /**
99          * The list of objects which have been removed during the
100          * course of one frame. They are actually destroyed in 
101          * LogicEndFrame() via a call to RemoveObject().
102          */
103         CListValue*     m_euthanasyobjects;
104         /**
105         * The list of objects that couldn't be released during logic update.
106         * for example, AddObject actuator sometimes releases an object that was cached from previous frame
107         */
108         CListValue*     m_delayReleaseObjects;
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         /**
116          *  The tree of objects in the scene.
117          */
118         SG_Tree*                        m_objecttree;
119
120         /**
121          * The set of cameras for this scene
122          */
123         list<class KX_Camera*>       m_cameras;
124         /**
125          * The set of bullet shapes that must be deleted at the end of the scene
126          * to avoid memory leak (not deleted by bullet because shape are shared between replicas)
127          */
128         vector<class btCollisionShape*> m_shapes;
129         /**
130          * Various SCA managers used by the scene
131          */
132         SCA_LogicManager*               m_logicmgr;
133         SCA_KeyboardManager*    m_keyboardmgr;
134         SCA_MouseManager*               m_mousemgr;
135         SCA_TimeEventManager*   m_timemgr;
136
137         // Scene converter where many scene entities are registered
138         // Used to deregister objects that are deleted
139         class KX_BlenderSceneConverter*         m_sceneConverter;
140         /**
141         * physics engine abstraction
142         */
143         //e_PhysicsEngine m_physicsEngine; //who needs this ?
144         class PHY_IPhysicsEnvironment*          m_physicsEnvironment;
145
146         /**
147          * Does this scene clear the z-buffer?
148          */
149         bool m_isclearingZbuffer;
150
151         /**
152          * The name of the scene
153          */
154         STR_String      m_sceneName;
155         
156         /**
157          * stores the worldsettings for a scene
158          */
159         KX_WorldInfo* m_worldinfo;
160
161         /**
162          * @section Different scenes, linked to ketsji scene
163          */
164
165
166         /**
167          * Sound scenes
168          */
169         SND_Scene* m_soundScene;
170         SND_IAudioDevice* m_adi;
171
172         /** 
173          * Network scene.
174          */
175         NG_NetworkDeviceInterface*      m_networkDeviceInterface;
176         NG_NetworkScene* m_networkScene;
177
178         /**
179          * A temoprary variable used to parent objects together on
180          * replication. Don't get confused by the name it is not
181          * the scene's root node!
182          */
183         SG_Node* m_rootnode;
184
185         /**
186          * The active camera for the scene
187          */
188         KX_Camera* m_active_camera;
189
190         /** 
191          * The projection and view matrices of this scene 
192          * The projection matrix is computed externally by KX_Engine    
193          * The view mat is stored as a side effect of GetViewMatrix()
194          * and is totally unnessary.
195          */
196         MT_CmMatrix4x4                          m_projectionmat;
197         MT_CmMatrix4x4                          m_viewmat;
198
199         /** Desired canvas width set at design time. */
200         unsigned int m_canvasDesignWidth;
201         /** Desired canvas height set at design time. */
202         unsigned int m_canvasDesignHeight;
203
204         /**
205          * Another temporary variable outstaying its welcome
206          * used in AddReplicaObject to map game objects to their
207          * replicas so pointers can be updated.
208          */
209         GEN_Map <GEN_HashedPtr, void*> m_map_gameobject_to_replica;
210
211         /**
212          * Another temporary variable outstaying its welcome
213          * used in AddReplicaObject to keep a record of all added 
214          * objects. Logic can only be updated when all objects 
215          * have been updated. This stores a list of the new objects.
216          */
217         std::vector<KX_GameObject*>     m_logicHierarchicalGameObjects;
218         
219         /**
220          * This temporary variable will contain the list of 
221          * object that can be added during group instantiation.
222          * objects outside this list will not be added (can 
223          * happen with children that are outside the group).
224          * Used in AddReplicaObject. If the list is empty, it
225          * means don't care.
226          */
227         std::set<CValue*>       m_groupGameObjects;
228         
229         /** 
230          * Pointer to system variable passed in in constructor
231          * only used in constructor so we do not need to keep it
232          * around in this class.
233          */
234
235         SCA_ISystem* m_kxsystem;
236
237         /**
238          * The execution priority of replicated object actuators?
239          */     
240         int     m_ueberExecutionPriority;
241
242         /**
243          * Activity 'bubble' settings :
244          * Suspend (freeze) the entire scene.
245          */
246         bool m_suspend;
247
248         /**
249          * Radius in Manhattan distance of the box for activity culling.
250          */
251         float m_activity_box_radius;
252
253         /**
254          * Toggle to enable or disable activity culling.
255          */
256         bool m_activity_culling;
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
277         double                          m_suspendedtime;
278         double                          m_suspendeddelta;
279         
280         /**
281          * This stores anything from python
282          */
283         PyObject* m_attrlist;
284
285 public:
286         KX_Scene(class SCA_IInputDevice* keyboarddevice,
287                 class SCA_IInputDevice* mousedevice,
288                 class NG_NetworkDeviceInterface* ndi,
289                 class SND_IAudioDevice* adi,
290                 const STR_String& scenename     );
291
292         virtual 
293         ~KX_Scene();
294
295         RAS_BucketManager* GetBucketManager();
296         RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat, bool &bucketCreated);
297         void RenderBuckets(const MT_Transform& cameratransform,
298                                                 RAS_IRasterizer* rasty,
299                                                 RAS_IRenderTools* rendertools);
300         /**
301          * Update all transforms according to the scenegraph.
302          */
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         void DelayedReleaseObject(CValue* gameobj);
321
322         int NewRemoveObject(CValue* gameobj);
323         void ReplaceMesh(CValue* gameobj,
324                                          void* meshobj);
325         void AddShape(class btCollisionShape* shape);
326         /**
327          * @section Logic stuff
328          * Initiate an update of the logic system.
329          */
330         void LogicBeginFrame(double curtime);
331         void LogicUpdateFrame(double curtime, bool frame);
332
333                 void                                            
334         LogicEndFrame(
335         );
336
337                 CListValue*                             
338         GetObjectList(
339         );
340
341                 CListValue*                             
342         GetInactiveList(
343         );
344
345                 CListValue*                             
346         GetRootParentList(
347         );
348
349                 CListValue*                             
350         GetLightList(
351         );
352
353                 SCA_LogicManager*               
354         GetLogicManager(
355         );
356
357                 SCA_TimeEventManager*   
358         GetTimeEventManager(
359         );
360
361                 list<class KX_Camera*>*
362         GetCameras(
363         );
364  
365
366         /** Find a camera in the scene by pointer. */
367                 KX_Camera*              
368         FindCamera(
369                 KX_Camera*
370         );
371
372         /** Find a scene in the scene by name. */
373                 KX_Camera*              
374         FindCamera(
375                 STR_String&
376         );
377
378         /** Add a camera to this scene. */
379                 void                    
380         AddCamera(
381                 KX_Camera*
382         );
383
384         /** Find the currently active camera. */
385                 KX_Camera*                              
386         GetActiveCamera(
387         );
388
389         /** 
390          * Set this camera to be the active camera in the scene. If the
391          * camera is not present in the camera list, it will be added
392          */
393
394                 void                                    
395         SetActiveCamera(
396                 class KX_Camera*
397         );
398
399         /**
400          * Move this camera to the end of the list so that it is rendered last.
401          * If the camera is not on the list, it will be added
402          */
403                 void
404         SetCameraOnTop(
405                 class KX_Camera*
406         );
407
408         /** Return the viewmatrix as used by the last frame. */
409                 MT_CmMatrix4x4&                 
410         GetViewMatrix(
411         );
412
413         /** 
414          * Return the projectionmatrix as used by the last frame. This is
415          * set by hand :) 
416          */
417                 MT_CmMatrix4x4&                 
418         GetProjectionMatrix(
419         );
420
421         /** Sets the projection matrix. */
422                 void                                    
423         SetProjectionMatrix(
424                 MT_CmMatrix4x4& pmat
425         );
426
427         /**
428          * Activates new desired canvas width set at design time.
429          * @param width The new desired width.
430          */
431                 void                                    
432         SetCanvasDesignWidth(
433                 unsigned int width
434         );
435         /**
436          * Activates new desired canvas height set at design time.
437          * @param width The new desired height.
438          */
439                 void                                    
440         SetCanvasDesignHeight(
441                 unsigned int height
442         );
443         /**
444          * Returns the current desired canvas width set at design time.
445          * @return The desired width.
446          */
447                 unsigned int                    
448         GetCanvasDesignWidth(
449                 void
450         ) const;
451
452         /**
453          * Returns the current desired canvas height set at design time.
454          * @return The desired height.
455          */
456                 unsigned int                    
457         GetCanvasDesignHeight(
458                 void
459         ) const;
460
461         /**
462          * Set the framing options for this scene
463          */
464
465                 void
466         SetFramingType(
467                 RAS_FrameSettings & frame_settings
468         );
469
470         /**
471          * Return a const reference to the framing 
472          * type set by the above call.
473          * The contents are not guarenteed to be sensible
474          * if you don't call the above function.
475          */
476
477         const
478                 RAS_FrameSettings &
479         GetFramingType(
480         ) const;
481
482         /**
483          * Store the current scene's viewport on the 
484          * game engine canvas.
485          */
486         void SetSceneViewport(const RAS_Rect &viewport);
487
488         /**
489          * Get the current scene's viewport on the
490          * game engine canvas. This maintained 
491          * externally in KX_GameEngine
492          */
493         const RAS_Rect& GetSceneViewport() const;
494         
495         /**
496          * @section Accessors to different scenes of this scene
497          */
498         void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
499         void SetNetworkScene(NG_NetworkScene *newScene);
500         void SetWorldInfo(class KX_WorldInfo* wi);
501         KX_WorldInfo* GetWorldInfo();
502         void CalculateVisibleMeshes(RAS_IRasterizer* rasty, KX_Camera *cam, int layer=0);
503         void UpdateMeshTransformations();
504         KX_Camera* GetpCamera();
505         SND_Scene* GetSoundScene();
506         NG_NetworkDeviceInterface* GetNetworkDeviceInterface();
507         NG_NetworkScene* GetNetworkScene();
508
509         /**
510          * Replicate the logic bricks associated to this object.
511          */
512
513         void ReplicateLogic(class KX_GameObject* newobj);
514         static SG_Callbacks     m_callbacks;
515
516         const STR_String& GetName();
517         
518         // Suspend the entire scene.
519         void Suspend();
520
521         // Resume a suspended scene.
522         void Resume();
523         
524         // Update the activity box settings for objects in this scene, if needed.
525         void UpdateObjectActivity(void);
526
527         // Enable/disable activity culling.
528         void SetActivityCulling(bool b);
529
530         // Set the radius of the activity culling box.
531         void SetActivityCullingRadius(float f);
532         bool IsSuspended();
533         bool IsClearingZBuffer();
534         void EnableZBufferClearing(bool isclearingZbuffer);
535         
536         void SetSceneConverter(class KX_BlenderSceneConverter* sceneConverter);
537
538         class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
539         {
540                 return m_physicsEnvironment;
541         }
542
543         void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);
544
545         void    SetGravity(const MT_Vector3& gravity);
546         
547         /**
548          * Sets the node tree for this scene.
549          */
550         void SetNodeTree(SG_Tree* root);
551
552         KX_PYMETHOD_DOC(KX_Scene, getLightList);
553         KX_PYMETHOD_DOC(KX_Scene, getObjectList);
554         KX_PYMETHOD_DOC(KX_Scene, getName);
555 /*      
556         KX_PYMETHOD_DOC(KX_Scene, getActiveCamera);
557         KX_PYMETHOD_DOC(KX_Scene, getActiveCamera);
558         KX_PYMETHOD_DOC(KX_Scene, findCamera);
559         
560         KX_PYMETHOD_DOC(KX_Scene, getGravity);
561         
562         KX_PYMETHOD_DOC(KX_Scene, setActivityCulling);
563         KX_PYMETHOD_DOC(KX_Scene, setActivityCullingRadius);
564         
565         KX_PYMETHOD_DOC(KX_Scene, setSceneViewport);
566         KX_PYMETHOD_DOC(KX_Scene, setSceneViewport);
567         */
568
569         virtual PyObject* _getattr(const STR_String& attr); /* name, active_camera, gravity, suspended, viewport, framing, activity_culling, activity_culling_radius */
570         virtual int _setattr(const STR_String &attr, PyObject *pyvalue);
571         virtual int _delattr(const STR_String &attr);
572
573         /**
574          * Sets the time the scene was suspended
575          */ 
576         void setSuspendedTime(double suspendedtime);
577         /**
578          * Returns the "curtime" the scene was suspended
579          */ 
580         double getSuspendedTime();
581         /**
582          * Sets the difference between the local time of the scene (when it
583          * was running and not suspended) and the "curtime"
584          */ 
585         void setSuspendedDelta(double suspendeddelta);
586         /**
587          * Returns the difference between the local time of the scene (when it
588          * was running and not suspended) and the "curtime"
589          */
590         double getSuspendedDelta();
591 };
592
593 typedef std::vector<KX_Scene*> KX_SceneList;
594
595 #endif //__KX_SCENE_H
596