a468a8d18619b285e6dd8bbd7dfdcf750e4e281c
[blender.git] / source / gameengine / Ketsji / KX_Scene.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32 #ifndef __KX_SCENE_H
33 #define __KX_SCENE_H
34
35
36 #include "KX_PhysicsEngineEnums.h"
37
38 #include "MT_CmMatrix4x4.h"
39
40 #include <vector>
41 #include <set>
42
43 #include "GEN_Map.h"
44 #include "GEN_HashedPtr.h"
45 #include "SG_IObject.h"
46 #include "SCA_IScene.h"
47 #include "MT_Transform.h"
48 #include "SND_Scene.h"
49 #include "RAS_FramingManager.h"
50 #include "RAS_Rect.h"
51
52 /**
53  * @section Forward declarations
54  */
55 struct SM_MaterialProps;
56 struct SM_ShapeProps;
57
58 class CListValue;
59 class RAS_BucketManager;
60 class KX_Camera;
61 class SCA_LogicManager;
62 class SCA_KeyboardManager;
63 class SCA_TimeEventManager;
64 class SCA_MouseManager;
65 class KX_WorldInfo;
66 class SND_Scene;
67 class SND_IAudioDevice;
68 class NG_NetworkDeviceInterface;
69 class NG_NetworkScene;
70 class SG_Node;
71 class SG_Tree;
72 class KX_Camera;
73 class GEN_HashedPtr;
74 class KX_GameObject;
75 class SCA_ISystem;
76 class SCA_IInputDevice;
77 class RAS_BucketManager;
78 class RAS_MaterialBucket;
79 class RAS_IPolyMaterial;
80 class RAS_IRasterizer;
81 class RAS_IRenderTools;
82 class CValue;
83 class SG_IObject;
84
85 /**
86  * The KX_Scene holds all data for an independent scene. It relates
87  * KX_Objects to the specific objects in the modules.
88  * */
89 class KX_Scene : public SCA_IScene
90 {
91         //Py_Header;
92 protected:
93         RAS_BucketManager*      m_bucketmanager;
94         CListValue*                     m_tempObjectList;
95
96         /**
97          * The list of objects which have been removed during the
98          * course of one frame. They are actually destroyed in 
99          * LogicEndFrame() via a call to RemoveObject().
100          */
101         CListValue*     m_euthanasyobjects;
102
103         CListValue*                     m_objectlist;
104         CListValue*                     m_parentlist; // all 'root' parents
105         CListValue*                     m_lightlist;
106
107         /**
108          *  The tree of objects in the scene.
109          */
110         SG_Tree*                        m_objecttree;
111
112         /**
113          * The set of cameras for this scene
114          */
115         set<class KX_Camera*>       m_cameras;
116         
117         /**
118          * Various SCA managers used by the scene
119          */
120         SCA_LogicManager*               m_logicmgr;
121         SCA_KeyboardManager*    m_keyboardmgr;
122         SCA_MouseManager*               m_mousemgr;
123         SCA_TimeEventManager*   m_timemgr;
124
125         /**
126         * physics engine abstraction
127         */
128
129         e_PhysicsEngine m_physicsEngine;
130         class PHY_IPhysicsEnvironment*          m_physicsEnvironment;
131
132         /**
133          * Does this scene clear the z-buffer?
134          */
135         bool m_isclearingZbuffer;
136
137         /**
138          * The name of the scene
139          */
140         STR_String      m_sceneName;
141         
142         /**
143          * stores the worldsettings for a scene
144          */
145         KX_WorldInfo* m_worldinfo;
146
147         /**
148          * @section Different scenes, linked to ketsji scene
149          */
150
151
152         /**
153          * Sound scenes
154          */
155         SND_Scene* m_soundScene;
156         SND_IAudioDevice* m_adi;
157
158         /** 
159          * Network scene.
160          */
161         NG_NetworkDeviceInterface*      m_networkDeviceInterface;
162         NG_NetworkScene* m_networkScene;
163
164         /**
165          * A temoprary variable used to parent objects together on
166          * replication. Don't get confused by the name it is not
167          * the scene's root node!
168          */
169         SG_Node* m_rootnode;
170
171         /**
172          * The active camera for the scene
173          */
174         KX_Camera* m_active_camera;
175
176         /** 
177          * The projection and view matrices of this scene 
178          * The projection matrix is computed externally by KX_Engine    
179          * The view mat is stored as a side effect of GetViewMatrix()
180          * and is totally unnessary.
181          */
182         MT_CmMatrix4x4                          m_projectionmat;
183         MT_CmMatrix4x4                          m_viewmat;
184
185         /** Desired canvas width set at design time. */
186         unsigned int m_canvasDesignWidth;
187         /** Desired canvas height set at design time. */
188         unsigned int m_canvasDesignHeight;
189
190         /**
191          * Another temporary variable outstaying its welcome
192          * used in AddReplicaObject to map game objects to their
193          * replicas so pointers can be updated.
194          */
195         GEN_Map <GEN_HashedPtr, void*> m_map_gameobject_to_replica;
196
197         /**
198          * Another temporary variable outstaying its welcome
199          * used in AddReplicaObject to keep a record of all added 
200          * objects. Logic can only be updated when all objects 
201          * have been updated. This stores a list of the new objects.
202          */
203         std::vector<KX_GameObject*>     m_logicHierarchicalGameObjects;
204         
205         /** 
206          * Pointer to system variable passed in in constructor
207          * only used in constructor so we do not need to keep it
208          * around in this class.
209          */
210
211         SCA_ISystem* m_kxsystem;
212
213         /**
214          * The execution priority of replicated object actuators?
215          */     
216         int     m_ueberExecutionPriority;
217
218         /**
219          * Activity 'bubble' settings :
220          * Suspend (freeze) the entire scene.
221          */
222         bool m_suspend;
223
224         /**
225          * Radius in Manhattan distance of the box for activity culling.
226          */
227         float m_activity_box_radius;
228
229         /**
230          * Toggle to enable or disable activity culling.
231          */
232         bool m_activity_culling;
233         
234         /**
235          * The framing settings used by this scene
236          */
237
238         RAS_FrameSettings m_frame_settings;
239
240         /** 
241          * This scenes viewport into the game engine
242          * canvas.Maintained externally, initially [0,0] -> [0,0]
243          */
244         RAS_Rect m_viewport;
245         
246         void MarkVisible(SG_Tree *node, RAS_IRasterizer* rasty);
247         void MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool visible);
248
249 public:
250         KX_Scene(class SCA_IInputDevice* keyboarddevice,
251                 class SCA_IInputDevice* mousedevice,
252                 class NG_NetworkDeviceInterface* ndi,
253                 class SND_IAudioDevice* adi,
254                 const STR_String& scenename     );
255
256         virtual 
257         ~KX_Scene();
258
259         RAS_BucketManager* GetBucketManager();
260         RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat);
261         void RenderBuckets(const MT_Transform& cameratransform,
262                                                 RAS_IRasterizer* rasty,
263                                                 RAS_IRenderTools* rendertools);
264         /**
265          * Update all transforms according to the scenegraph.
266          */
267         void UpdateParents(double curtime);
268         SCA_IObject* AddReplicaObject(CValue* gameobj,
269                                                                   CValue* locationobj,
270                                                                   int lifespan=0);
271         KX_GameObject* AddNodeReplicaObject(SG_IObject* node,
272                                                                                 CValue* gameobj);
273         void RemoveNodeDestructObject(SG_IObject* node,
274                                                                   CValue* gameobj);
275         void RemoveObject(CValue* gameobj);
276         void DelayedRemoveObject(CValue* gameobj);
277         void NewRemoveObject(CValue* gameobj);
278         void ReplaceMesh(CValue* gameobj,
279                                          void* meshobj);
280         /**
281          * @section Logic stuff
282          * Initiate an update of the logic system.
283          */
284         void LogicBeginFrame(double curtime,
285                                                  double deltatime);
286         void LogicUpdateFrame(double curtime,
287                                                   double deltatime);
288
289                 void                                            
290         LogicEndFrame(
291         );
292
293                 CListValue*                             
294         GetObjectList(
295         );
296
297                 CListValue*                             
298         GetRootParentList(
299         );
300
301                 CListValue*                             
302         GetLightList(
303         );
304
305                 SCA_LogicManager*               
306         GetLogicManager(
307         );
308
309                 SCA_TimeEventManager*   
310         GetTimeEventManager(
311         );
312
313
314         /** Find a camera in the scene by pointer. */
315                 KX_Camera*              
316         FindCamera(
317                 KX_Camera*
318         );
319
320         /** Find a scene in the scene by name. */
321                 KX_Camera*              
322         FindCamera(
323                 STR_String&
324         );
325
326         /** Add a camera to this scene. */
327                 void                    
328         AddCamera(
329                 KX_Camera*
330         );
331
332         /** Find the currently active camera. */
333                 KX_Camera*                              
334         GetActiveCamera(
335         );
336
337         /** 
338          * Set this camera to be the active camera in the scene. If the
339          * camera is not present in the camera list, it will be added
340          */
341
342                 void                                    
343         SetActiveCamera(
344                 class KX_Camera*
345         );
346
347         /** Return the viewmatrix as used by the last frame. */
348                 MT_CmMatrix4x4&                 
349         GetViewMatrix(
350         );
351
352         /** 
353          * Return the projectionmatrix as used by the last frame. This is
354          * set by hand :) 
355          */
356                 MT_CmMatrix4x4&                 
357         GetProjectionMatrix(
358         );
359
360         /** Sets the projection matrix. */
361                 void                                    
362         SetProjectionMatrix(
363                 MT_CmMatrix4x4& pmat
364         );
365
366         /**
367          * Activates new desired canvas width set at design time.
368          * @param width The new desired width.
369          */
370                 void                                    
371         SetCanvasDesignWidth(
372                 unsigned int width
373         );
374         /**
375          * Activates new desired canvas height set at design time.
376          * @param width The new desired height.
377          */
378                 void                                    
379         SetCanvasDesignHeight(
380                 unsigned int height
381         );
382         /**
383          * Returns the current desired canvas width set at design time.
384          * @return The desired width.
385          */
386                 unsigned int                    
387         GetCanvasDesignWidth(
388                 void
389         ) const;
390
391         /**
392          * Returns the current desired canvas height set at design time.
393          * @return The desired height.
394          */
395                 unsigned int                    
396         GetCanvasDesignHeight(
397                 void
398         ) const;
399
400         /**
401          * Set the framing options for this scene
402          */
403
404                 void
405         SetFramingType(
406                 RAS_FrameSettings & frame_settings
407         );
408
409         /**
410          * Return a const reference to the framing 
411          * type set by the above call.
412          * The contents are not guarenteed to be sensible
413          * if you don't call the above function.
414          */
415
416         const
417                 RAS_FrameSettings &
418         GetFramingType(
419         ) const;
420
421         /**
422          * Store the current scene's viewport on the 
423          * game engine canvas.
424          */
425         void SetSceneViewport(const RAS_Rect &viewport);
426
427         /**
428          * Get the current scene's viewport on the
429          * game engine canvas. This maintained 
430          * externally in KX_GameEngine
431          */
432         const RAS_Rect& GetSceneViewport() const;
433         
434         /**
435          * @section Accessors to different scenes of this scene
436          */
437         void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
438         void SetNetworkScene(NG_NetworkScene *newScene);
439         void SetWorldInfo(class KX_WorldInfo* wi);
440         KX_WorldInfo* GetWorldInfo();
441         void CalculateVisibleMeshes(RAS_IRasterizer* rasty);
442         void UpdateMeshTransformations();
443         KX_Camera* GetpCamera();
444         SND_Scene* GetSoundScene();
445         NG_NetworkDeviceInterface* GetNetworkDeviceInterface();
446         NG_NetworkScene* GetNetworkScene();
447
448         /**
449          * Replicate the logic bricks associated to this object.
450          */
451
452         void ReplicateLogic(class KX_GameObject* newobj);
453         static SG_Callbacks     m_callbacks;
454
455         const STR_String& GetName();
456         
457         // Suspend the entire scene.
458         void Suspend();
459
460         // Resume a suspended scene.
461         void Resume();
462         
463         // Update the activity box settings for objects in this scene, if needed.
464         void UpdateObjectActivity(void);
465
466         // Enable/disable activity culling.
467         void SetActivityCulling(bool b);
468
469         // Set the radius of the activity culling box.
470         void SetActivityCullingRadius(float f);
471         bool IsSuspended();
472         bool IsClearingZBuffer();
473         void EnableZBufferClearing(bool isclearingZbuffer);
474         
475         class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
476         {
477                 return m_physicsEnvironment;
478         }
479
480         void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);
481
482         void    SetGravity(const MT_Vector3& gravity);
483         
484         /**
485          * Sets the node tree for this scene.
486          */
487         void SetNodeTree(SG_Tree* root);
488
489 #if 0
490         KX_PYMETHOD_DOC(KX_Scene, GetLightList);
491         KX_PYMETHOD_DOC(KX_Scene, GetObjectList);
492         KX_PYMETHOD_DOC(KX_Scene, GetName);
493         
494         KX_PYMETHOD_DOC(KX_Scene, GetActiveCamera);
495         KX_PYMETHOD_DOC(KX_Scene, SetActiveCamera);
496         KX_PYMETHOD_DOC(KX_Scene, FindCamera);
497         
498         KX_PYMETHOD_DOC(KX_Scene, SetGravity);
499         
500         KX_PYMETHOD_DOC(KX_Scene, SetActivityCulling);
501         KX_PYMETHOD_DOC(KX_Scene, SetActivityCullingRadius);
502         
503         KX_PYMETHOD_DOC(KX_Scene, SetSceneViewport);
504         KX_PYMETHOD_DOC(KX_Scene, GetSceneViewport);
505
506         virtual PyObject* _getattr(const STR_String& attr); /* name, active_camera, gravity, suspended, viewport, framing, activity_culling, activity_culling_radius */
507 #endif
508 };
509
510 typedef std::vector<KX_Scene*> KX_SceneList;
511
512 #endif //__KX_SCENE_H
513