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