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