remove all python api functions deprecated in 2.49
[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 <vector>
36 #include <set>
37 #include <list>
38
39 #include "GEN_Map.h"
40 #include "GEN_HashedPtr.h"
41 #include "SG_IObject.h"
42 #include "SCA_IScene.h"
43 #include "MT_Transform.h"
44
45 #include "RAS_FramingManager.h"
46 #include "RAS_Rect.h"
47
48 #include "PyObjectPlus.h"
49
50 /**
51  * @section Forward declarations
52  */
53 struct SM_MaterialProps;
54 struct SM_ShapeProps;
55 struct Scene;
56
57 class GEN_HashedPtr;
58 class CListValue;
59 class CValue;
60 class SCA_LogicManager;
61 class SCA_KeyboardManager;
62 class SCA_TimeEventManager;
63 class SCA_MouseManager;
64 class SCA_ISystem;
65 class SCA_IInputDevice;
66 class NG_NetworkDeviceInterface;
67 class NG_NetworkScene;
68 class SG_IObject;
69 class SG_Node;
70 class SG_Tree;
71 class KX_WorldInfo;
72 class KX_Camera;
73 class KX_GameObject;
74 class KX_LightObject;
75 class RAS_BucketManager;
76 class RAS_BucketManager;
77 class RAS_MaterialBucket;
78 class RAS_IPolyMaterial;
79 class RAS_IRasterizer;
80 class RAS_IRenderTools;
81 class SCA_JoystickManager;
82 class btCollisionShape;
83 class KX_BlenderSceneConverter;
84 struct KX_ClientObjectInfo;
85
86 /**
87  * The KX_Scene holds all data for an independent scene. It relates
88  * KX_Objects to the specific objects in the modules.
89  * */
90 class KX_Scene : public PyObjectPlus, public SCA_IScene
91 {
92         Py_Header;
93         PyObject*       m_attr_dict;
94
95         struct CullingInfo {
96                 int m_layer;
97                 CullingInfo(int layer) : m_layer(layer) {}
98         };
99
100 protected:
101         RAS_BucketManager*      m_bucketmanager;
102         CListValue*                     m_tempObjectList;
103
104         /**
105          * The list of objects which have been removed during the
106          * course of one frame. They are actually destroyed in 
107          * LogicEndFrame() via a call to RemoveObject().
108          */
109         CListValue*     m_euthanasyobjects;
110
111         CListValue*                     m_objectlist;
112         CListValue*                     m_parentlist; // all 'root' parents
113         CListValue*                     m_lightlist;
114         CListValue*                     m_inactivelist; // all objects that are not in the active layer
115         
116         SG_QList                        m_sghead;               // list of nodes that needs scenegraph update
117                                                                                 // the Dlist is not object that must be updated
118                                                                                 // the Qlist is for objects that needs to be rescheduled
119                                                                                 // for updates after udpate is over (slow parent, bone parent)
120
121
122         /**
123          * The set of cameras for this scene
124          */
125         list<class KX_Camera*>       m_cameras;
126         /**
127          * Various SCA managers used by the scene
128          */
129         SCA_LogicManager*               m_logicmgr;
130         SCA_KeyboardManager*    m_keyboardmgr;
131         SCA_MouseManager*               m_mousemgr;
132         SCA_TimeEventManager*   m_timemgr;
133
134         // Scene converter where many scene entities are registered
135         // Used to deregister objects that are deleted
136         class KX_BlenderSceneConverter*         m_sceneConverter;
137         /**
138         * physics engine abstraction
139         */
140         //e_PhysicsEngine m_physicsEngine; //who needs this ?
141         class PHY_IPhysicsEnvironment*          m_physicsEnvironment;
142
143         /**
144          * Does this scene clear the z-buffer?
145          */
146         bool m_isclearingZbuffer;
147
148         /**
149          * The name of the scene
150          */
151         STR_String      m_sceneName;
152         
153         /**
154          * stores the worldsettings for a scene
155          */
156         KX_WorldInfo* m_worldinfo;
157
158         /**
159          * @section Different scenes, linked to ketsji scene
160          */
161
162         /**
163          * Network scene.
164          */
165         NG_NetworkDeviceInterface*      m_networkDeviceInterface;
166         NG_NetworkScene* m_networkScene;
167
168         /**
169          * A temoprary variable used to parent objects together on
170          * replication. Don't get confused by the name it is not
171          * the scene's root node!
172          */
173         SG_Node* m_rootnode;
174
175         /**
176          * The active camera for the scene
177          */
178         KX_Camera* m_active_camera;
179
180         /**
181          * Another temporary variable outstaying its welcome
182          * used in AddReplicaObject to map game objects to their
183          * replicas so pointers can be updated.
184          */
185         GEN_Map <GEN_HashedPtr, void*> m_map_gameobject_to_replica;
186
187         /**
188          * Another temporary variable outstaying its welcome
189          * used in AddReplicaObject to keep a record of all added 
190          * objects. Logic can only be updated when all objects 
191          * have been updated. This stores a list of the new objects.
192          */
193         std::vector<KX_GameObject*>     m_logicHierarchicalGameObjects;
194         
195         /**
196          * This temporary variable will contain the list of 
197          * object that can be added during group instantiation.
198          * objects outside this list will not be added (can 
199          * happen with children that are outside the group).
200          * Used in AddReplicaObject. If the list is empty, it
201          * means don't care.
202          */
203         std::set<CValue*>       m_groupGameObjects;
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          * Toggle to enable or disable culling via DBVT broadphase of Bullet.
236          */
237         bool m_dbvt_culling;
238         
239         /**
240          * Occlusion culling resolution
241          */ 
242         int m_dbvt_occlusion_res;
243
244         /**
245          * The framing settings used by this scene
246          */
247
248         RAS_FrameSettings m_frame_settings;
249
250         /** 
251          * This scenes viewport into the game engine
252          * canvas.Maintained externally, initially [0,0] -> [0,0]
253          */
254         RAS_Rect m_viewport;
255         
256         /**
257          * Visibility testing functions.
258          */
259         void MarkVisible(SG_Tree *node, RAS_IRasterizer* rasty, KX_Camera*cam,int layer=0);
260         void MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool visible, KX_Camera*cam,int layer=0);
261         void MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj, KX_Camera*cam, int layer=0);
262         static void PhysicsCullingCallback(KX_ClientObjectInfo* objectInfo, void* cullingInfo);
263
264         double                          m_suspendedtime;
265         double                          m_suspendeddelta;
266
267         struct Scene* m_blenderScene;
268
269 public: 
270         KX_Scene(class SCA_IInputDevice* keyboarddevice,
271                 class SCA_IInputDevice* mousedevice,
272                 class NG_NetworkDeviceInterface* ndi,
273                 const STR_String& scenename,
274                 struct Scene* scene);
275
276         virtual 
277         ~KX_Scene();
278
279         RAS_BucketManager* GetBucketManager();
280         RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat, bool &bucketCreated);
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         static bool KX_ScenegraphUpdateFunc(SG_IObject* node,void* gameobj,void* scene);
288         static bool KX_ScenegraphRescheduleFunc(SG_IObject* node,void* gameobj,void* scene);
289         void UpdateParents(double curtime);
290         void DupliGroupRecurse(CValue* gameobj, int level);
291         bool IsObjectInGroup(CValue* gameobj)
292         { 
293                 return (m_groupGameObjects.empty() || 
294                                 m_groupGameObjects.find(gameobj) != m_groupGameObjects.end());
295         }
296         SCA_IObject* AddReplicaObject(CValue* gameobj,
297                                                                   CValue* locationobj,
298                                                                   int lifespan=0);
299         KX_GameObject* AddNodeReplicaObject(SG_IObject* node,
300                                                                                 CValue* gameobj);
301         void RemoveNodeDestructObject(SG_IObject* node,
302                                                                   CValue* gameobj);
303         void RemoveObject(CValue* gameobj);
304         void DelayedRemoveObject(CValue* gameobj);
305         
306         int NewRemoveObject(CValue* gameobj);
307         void ReplaceMesh(CValue* gameobj,
308                                          void* meshob, bool use_gfx, bool use_phys);
309         /**
310          * @section Logic stuff
311          * Initiate an update of the logic system.
312          */
313         void LogicBeginFrame(double curtime);
314         void LogicUpdateFrame(double curtime, bool frame);
315
316                 void                                            
317         LogicEndFrame(
318         );
319
320                 CListValue*                             
321         GetObjectList(
322         );
323
324                 CListValue*                             
325         GetInactiveList(
326         );
327
328                 CListValue*                             
329         GetRootParentList(
330         );
331
332                 CListValue*                             
333         GetLightList(
334         );
335
336                 SCA_LogicManager*               
337         GetLogicManager(
338         );
339
340                 SCA_TimeEventManager*   
341         GetTimeEventManager(
342         );
343
344                 list<class KX_Camera*>*
345         GetCameras(
346         );
347  
348
349         /** Find a camera in the scene by pointer. */
350                 KX_Camera*              
351         FindCamera(
352                 KX_Camera*
353         );
354
355         /** Find a scene in the scene by name. */
356                 KX_Camera*              
357         FindCamera(
358                 STR_String&
359         );
360
361         /** Add a camera to this scene. */
362                 void                    
363         AddCamera(
364                 KX_Camera*
365         );
366
367         /** Find the currently active camera. */
368                 KX_Camera*                              
369         GetActiveCamera(
370         );
371
372         /** 
373          * Set this camera to be the active camera in the scene. If the
374          * camera is not present in the camera list, it will be added
375          */
376
377                 void                                    
378         SetActiveCamera(
379                 class KX_Camera*
380         );
381
382         /**
383          * Move this camera to the end of the list so that it is rendered last.
384          * If the camera is not on the list, it will be added
385          */
386                 void
387         SetCameraOnTop(
388                 class KX_Camera*
389         );
390
391         /**
392          * Activates new desired canvas width set at design time.
393          * @param width The new desired width.
394          */
395                 void                                    
396         SetCanvasDesignWidth(
397                 unsigned int width
398         );
399         /**
400          * Activates new desired canvas height set at design time.
401          * @param width The new desired height.
402          */
403                 void                                    
404         SetCanvasDesignHeight(
405                 unsigned int height
406         );
407         /**
408          * Returns the current desired canvas width set at design time.
409          * @return The desired width.
410          */
411                 unsigned int                    
412         GetCanvasDesignWidth(
413                 void
414         ) const;
415
416         /**
417          * Returns the current desired canvas height set at design time.
418          * @return The desired height.
419          */
420                 unsigned int                    
421         GetCanvasDesignHeight(
422                 void
423         ) const;
424
425         /**
426          * Set the framing options for this scene
427          */
428
429                 void
430         SetFramingType(
431                 RAS_FrameSettings & frame_settings
432         );
433
434         /**
435          * Return a const reference to the framing 
436          * type set by the above call.
437          * The contents are not guarenteed to be sensible
438          * if you don't call the above function.
439          */
440
441         const
442                 RAS_FrameSettings &
443         GetFramingType(
444         ) const;
445
446         /**
447          * Store the current scene's viewport on the 
448          * game engine canvas.
449          */
450         void SetSceneViewport(const RAS_Rect &viewport);
451
452         /**
453          * Get the current scene's viewport on the
454          * game engine canvas. This maintained 
455          * externally in KX_GameEngine
456          */
457         const RAS_Rect& GetSceneViewport() const;
458         
459         /**
460          * @section Accessors to different scenes of this scene
461          */
462         void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
463         void SetNetworkScene(NG_NetworkScene *newScene);
464         void SetWorldInfo(class KX_WorldInfo* wi);
465         KX_WorldInfo* GetWorldInfo();
466         void CalculateVisibleMeshes(RAS_IRasterizer* rasty, KX_Camera *cam, int layer=0);
467         void UpdateMeshTransformations();
468         KX_Camera* GetpCamera();
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         // use of DBVT tree for camera culling
499         void SetDbvtCulling(bool b) { m_dbvt_culling = b; };
500         bool GetDbvtCulling() { return m_dbvt_culling; };
501         void SetDbvtOcclusionRes(int i) { m_dbvt_occlusion_res = i; };
502         int GetDbvtOcclusionRes() { return m_dbvt_occlusion_res; };
503         
504         void SetSceneConverter(class KX_BlenderSceneConverter* sceneConverter);
505
506         class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
507         {
508                 return m_physicsEnvironment;
509         }
510
511         void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);
512
513         void    SetGravity(const MT_Vector3& gravity);
514         
515         /**
516          * Sets the node tree for this scene.
517          */
518         void SetNodeTree(SG_Tree* root);
519
520         /* --------------------------------------------------------------------- */
521         /* Python interface ---------------------------------------------------- */
522         /* --------------------------------------------------------------------- */
523
524         KX_PYMETHOD_DOC(KX_Scene, addObject);
525         KX_PYMETHOD_DOC(KX_Scene, get);
526
527         /* attributes */
528         static PyObject*        pyattr_get_name(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
529         static PyObject*        pyattr_get_objects(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
530         static PyObject*        pyattr_get_objects_inactive(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
531         static PyObject*        pyattr_get_lights(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
532         static PyObject*        pyattr_get_cameras(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
533         static PyObject*        pyattr_get_active_camera(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
534         static int                      pyattr_set_active_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
535
536         virtual PyObject* py_repr(void) { return PyUnicode_FromString(GetName().ReadPtr()); }
537         
538         /* getitem/setitem */
539         static PyMappingMethods Mapping;
540         static PySequenceMethods        Sequence;
541
542         /**
543          * Sets the time the scene was suspended
544          */ 
545         void setSuspendedTime(double suspendedtime);
546         /**
547          * Returns the "curtime" the scene was suspended
548          */ 
549         double getSuspendedTime();
550         /**
551          * Sets the difference between the local time of the scene (when it
552          * was running and not suspended) and the "curtime"
553          */ 
554         void setSuspendedDelta(double suspendeddelta);
555         /**
556          * Returns the difference between the local time of the scene (when it
557          * was running and not suspended) and the "curtime"
558          */
559         double getSuspendedDelta();
560         /**
561          * Returns the Blender scene this was made from
562          */
563         struct Scene *GetBlenderScene() { return m_blenderScene; }
564 };
565
566 typedef std::vector<KX_Scene*> KX_SceneList;
567
568 #endif //__KX_SCENE_H
569