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