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