Work on conversion of the navigation mesh: we build navmesh directly from blender...
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
49 #include "PyObjectPlus.h"
50 #include "RAS_2DFilterManager.h"
51
52 /**
53  * @section Forward declarations
54  */
55 struct SM_MaterialProps;
56 struct SM_ShapeProps;
57 struct Scene;
58
59 class GEN_HashedPtr;
60 class CListValue;
61 class CValue;
62 class SCA_LogicManager;
63 class SCA_KeyboardManager;
64 class SCA_TimeEventManager;
65 class SCA_MouseManager;
66 class SCA_ISystem;
67 class SCA_IInputDevice;
68 class NG_NetworkDeviceInterface;
69 class NG_NetworkScene;
70 class SG_IObject;
71 class SG_Node;
72 class SG_Tree;
73 class KX_WorldInfo;
74 class KX_Camera;
75 class KX_GameObject;
76 class KX_LightObject;
77 class RAS_BucketManager;
78 class RAS_MaterialBucket;
79 class RAS_IPolyMaterial;
80 class RAS_IRasterizer;
81 class RAS_IRenderTools;
82 class SCA_JoystickManager;
83 class btCollisionShape;
84 class KX_BlenderSceneConverter;
85 struct KX_ClientObjectInfo;
86 class KX_ObstacleSimulation;
87
88 /* for ID freeing */
89 #define IS_TAGGED(_id) ((_id) && (((ID *)_id)->flag & LIB_DOIT))
90
91 /**
92  * The KX_Scene holds all data for an independent scene. It relates
93  * KX_Objects to the specific objects in the modules.
94  * */
95 class KX_Scene : public PyObjectPlus, public SCA_IScene
96 {
97         Py_Header;
98
99 #ifndef DISABLE_PYTHON
100         PyObject*       m_attr_dict;
101         PyObject*       m_draw_call_pre;
102         PyObject*       m_draw_call_post;
103 #endif
104
105         struct CullingInfo {
106                 int m_layer;
107                 CullingInfo(int layer) : m_layer(layer) {}
108         };
109
110 protected:
111         RAS_BucketManager*      m_bucketmanager;
112         CListValue*                     m_tempObjectList;
113
114         /**
115          * The list of objects which have been removed during the
116          * course of one frame. They are actually destroyed in 
117          * LogicEndFrame() via a call to RemoveObject().
118          */
119         CListValue*     m_euthanasyobjects;
120
121         CListValue*                     m_objectlist;
122         CListValue*                     m_parentlist; // all 'root' parents
123         CListValue*                     m_lightlist;
124         CListValue*                     m_inactivelist; // all objects that are not in the active layer
125         
126         SG_QList                        m_sghead;               // list of nodes that needs scenegraph update
127                                                                                 // the Dlist is not object that must be updated
128                                                                                 // the Qlist is for objects that needs to be rescheduled
129                                                                                 // for updates after udpate is over (slow parent, bone parent)
130
131
132         /**
133          * The set of cameras for this scene
134          */
135         list<class KX_Camera*>       m_cameras;
136         /**
137          * Various SCA managers used by the scene
138          */
139         SCA_LogicManager*               m_logicmgr;
140         SCA_KeyboardManager*    m_keyboardmgr;
141         SCA_MouseManager*               m_mousemgr;
142         SCA_TimeEventManager*   m_timemgr;
143
144         // Scene converter where many scene entities are registered
145         // Used to deregister objects that are deleted
146         class KX_BlenderSceneConverter*         m_sceneConverter;
147         /**
148         * physics engine abstraction
149         */
150         //e_PhysicsEngine m_physicsEngine; //who needs this ?
151         class PHY_IPhysicsEnvironment*          m_physicsEnvironment;
152
153         /**
154          * Does this scene clear the z-buffer?
155          */
156         bool m_isclearingZbuffer;
157
158         /**
159          * The name of the scene
160          */
161         STR_String      m_sceneName;
162         
163         /**
164          * stores the worldsettings for a scene
165          */
166         KX_WorldInfo* m_worldinfo;
167
168         /**
169          * @section Different scenes, linked to ketsji scene
170          */
171
172         /**
173          * Network scene.
174          */
175         NG_NetworkDeviceInterface*      m_networkDeviceInterface;
176         NG_NetworkScene* m_networkScene;
177
178         /**
179          * A temoprary variable used to parent objects together on
180          * replication. Don't get confused by the name it is not
181          * the scene's root node!
182          */
183         SG_Node* m_rootnode;
184
185         /**
186          * The active camera for the scene
187          */
188         KX_Camera* m_active_camera;
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          * This temporary variable will contain the list of 
207          * object that can be added during group instantiation.
208          * objects outside this list will not be added (can 
209          * happen with children that are outside the group).
210          * Used in AddReplicaObject. If the list is empty, it
211          * means don't care.
212          */
213         std::set<CValue*>       m_groupGameObjects;
214         
215         /** 
216          * Pointer to system variable passed in in constructor
217          * only used in constructor so we do not need to keep it
218          * around in this class.
219          */
220
221         SCA_ISystem* m_kxsystem;
222
223         /**
224          * The execution priority of replicated object actuators?
225          */     
226         int     m_ueberExecutionPriority;
227
228         /**
229          * Activity 'bubble' settings :
230          * Suspend (freeze) the entire scene.
231          */
232         bool m_suspend;
233
234         /**
235          * Radius in Manhattan distance of the box for activity culling.
236          */
237         float m_activity_box_radius;
238
239         /**
240          * Toggle to enable or disable activity culling.
241          */
242         bool m_activity_culling;
243         
244         /**
245          * Toggle to enable or disable culling via DBVT broadphase of Bullet.
246          */
247         bool m_dbvt_culling;
248         
249         /**
250          * Occlusion culling resolution
251          */ 
252         int m_dbvt_occlusion_res;
253
254         /**
255          * The framing settings used by this scene
256          */
257
258         RAS_FrameSettings m_frame_settings;
259
260         /** 
261          * This scenes viewport into the game engine
262          * canvas.Maintained externally, initially [0,0] -> [0,0]
263          */
264         RAS_Rect m_viewport;
265         
266         /**
267          * Visibility testing functions.
268          */
269         void MarkVisible(SG_Tree *node, RAS_IRasterizer* rasty, KX_Camera*cam,int layer=0);
270         void MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool visible, KX_Camera*cam,int layer=0);
271         void MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj, KX_Camera*cam, int layer=0);
272         static void PhysicsCullingCallback(KX_ClientObjectInfo* objectInfo, void* cullingInfo);
273
274         double                          m_suspendedtime;
275         double                          m_suspendeddelta;
276
277         struct Scene* m_blenderScene;
278
279         RAS_2DFilterManager m_filtermanager;
280
281         KX_ObstacleSimulation* m_obstacleSimulation;
282
283 public: 
284         KX_Scene(class SCA_IInputDevice* keyboarddevice,
285                 class SCA_IInputDevice* mousedevice,
286                 class NG_NetworkDeviceInterface* ndi,
287                 const STR_String& scenename,
288                 struct Scene* scene,
289                 class RAS_ICanvas* canvas);
290
291         virtual 
292         ~KX_Scene();
293
294         RAS_BucketManager* GetBucketManager();
295         RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat, bool &bucketCreated);
296         void RenderBuckets(const MT_Transform& cameratransform,
297                                                 RAS_IRasterizer* rasty,
298                                                 RAS_IRenderTools* rendertools);
299
300         /**
301          * Update all transforms according to the scenegraph.
302          */
303         static bool KX_ScenegraphUpdateFunc(SG_IObject* node,void* gameobj,void* scene);
304         static bool KX_ScenegraphRescheduleFunc(SG_IObject* node,void* gameobj,void* scene);
305         void UpdateParents(double curtime);
306         void DupliGroupRecurse(CValue* gameobj, int level);
307         bool IsObjectInGroup(CValue* gameobj)
308         { 
309                 return (m_groupGameObjects.empty() || 
310                                 m_groupGameObjects.find(gameobj) != m_groupGameObjects.end());
311         }
312         SCA_IObject* AddReplicaObject(CValue* gameobj,
313                                                                   CValue* locationobj,
314                                                                   int lifespan=0);
315         KX_GameObject* AddNodeReplicaObject(SG_IObject* node,
316                                                                                 CValue* gameobj);
317         void RemoveNodeDestructObject(SG_IObject* node,
318                                                                   CValue* gameobj);
319         void RemoveObject(CValue* gameobj);
320         void DelayedRemoveObject(CValue* gameobj);
321         
322         int NewRemoveObject(CValue* gameobj);
323         void ReplaceMesh(CValue* gameobj,
324                                          void* meshob, bool use_gfx, bool use_phys);
325         /**
326          * @section Logic stuff
327          * Initiate an update of the logic system.
328          */
329         void LogicBeginFrame(double curtime);
330         void LogicUpdateFrame(double curtime, bool frame);
331
332                 void                                            
333         LogicEndFrame(
334         );
335
336                 CListValue*                             
337         GetTempObjectList(
338         );
339
340                 CListValue*
341         GetObjectList(
342         );
343
344                 CListValue*                             
345         GetInactiveList(
346         );
347
348                 CListValue*                             
349         GetRootParentList(
350         );
351
352                 CListValue*                             
353         GetLightList(
354         );
355
356                 SCA_LogicManager*               
357         GetLogicManager(
358         );
359
360                 SCA_TimeEventManager*   
361         GetTimeEventManager(
362         );
363
364                 list<class KX_Camera*>*
365         GetCameras(
366         );
367  
368
369         /** Find a camera in the scene by pointer. */
370                 KX_Camera*              
371         FindCamera(
372                 KX_Camera*
373         );
374
375         /** Find a scene in the scene by name. */
376                 KX_Camera*              
377         FindCamera(
378                 STR_String&
379         );
380
381         /** Add a camera to this scene. */
382                 void                    
383         AddCamera(
384                 KX_Camera*
385         );
386
387         /** Find the currently active camera. */
388                 KX_Camera*                              
389         GetActiveCamera(
390         );
391
392         /** 
393          * Set this camera to be the active camera in the scene. If the
394          * camera is not present in the camera list, it will be added
395          */
396
397                 void                                    
398         SetActiveCamera(
399                 class KX_Camera*
400         );
401
402         /**
403          * Move this camera to the end of the list so that it is rendered last.
404          * If the camera is not on the list, it will be added
405          */
406                 void
407         SetCameraOnTop(
408                 class KX_Camera*
409         );
410
411         /**
412          * Activates new desired canvas width set at design time.
413          * @param width The new desired width.
414          */
415                 void                                    
416         SetCanvasDesignWidth(
417                 unsigned int width
418         );
419         /**
420          * Activates new desired canvas height set at design time.
421          * @param width The new desired height.
422          */
423                 void                                    
424         SetCanvasDesignHeight(
425                 unsigned int height
426         );
427         /**
428          * Returns the current desired canvas width set at design time.
429          * @return The desired width.
430          */
431                 unsigned int                    
432         GetCanvasDesignWidth(
433                 void
434         ) const;
435
436         /**
437          * Returns the current desired canvas height set at design time.
438          * @return The desired height.
439          */
440                 unsigned int                    
441         GetCanvasDesignHeight(
442                 void
443         ) const;
444
445         /**
446          * Set the framing options for this scene
447          */
448
449                 void
450         SetFramingType(
451                 RAS_FrameSettings & frame_settings
452         );
453
454         /**
455          * Return a const reference to the framing 
456          * type set by the above call.
457          * The contents are not guarenteed to be sensible
458          * if you don't call the above function.
459          */
460
461         const
462                 RAS_FrameSettings &
463         GetFramingType(
464         ) const;
465
466         /**
467          * Store the current scene's viewport on the 
468          * game engine canvas.
469          */
470         void SetSceneViewport(const RAS_Rect &viewport);
471
472         /**
473          * Get the current scene's viewport on the
474          * game engine canvas. This maintained 
475          * externally in KX_GameEngine
476          */
477         const RAS_Rect& GetSceneViewport() const;
478         
479         /**
480          * @section Accessors to different scenes of this scene
481          */
482         void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
483         void SetNetworkScene(NG_NetworkScene *newScene);
484         void SetWorldInfo(class KX_WorldInfo* wi);
485         KX_WorldInfo* GetWorldInfo();
486         void CalculateVisibleMeshes(RAS_IRasterizer* rasty, KX_Camera *cam, int layer=0);
487         void UpdateMeshTransformations();
488         KX_Camera* GetpCamera();
489         NG_NetworkDeviceInterface* GetNetworkDeviceInterface();
490         NG_NetworkScene* GetNetworkScene();
491         KX_BlenderSceneConverter *GetSceneConverter() { return m_sceneConverter; }
492
493         /**
494          * Replicate the logic bricks associated to this object.
495          */
496
497         void ReplicateLogic(class KX_GameObject* newobj);
498         static SG_Callbacks     m_callbacks;
499
500         const STR_String& GetName();
501         
502         // Suspend the entire scene.
503         void Suspend();
504
505         // Resume a suspended scene.
506         void Resume();
507         
508         // Update the activity box settings for objects in this scene, if needed.
509         void UpdateObjectActivity(void);
510
511         // Enable/disable activity culling.
512         void SetActivityCulling(bool b);
513
514         // Set the radius of the activity culling box.
515         void SetActivityCullingRadius(float f);
516         bool IsSuspended();
517         bool IsClearingZBuffer();
518         void EnableZBufferClearing(bool isclearingZbuffer);
519         // use of DBVT tree for camera culling
520         void SetDbvtCulling(bool b) { m_dbvt_culling = b; };
521         bool GetDbvtCulling() { return m_dbvt_culling; };
522         void SetDbvtOcclusionRes(int i) { m_dbvt_occlusion_res = i; };
523         int GetDbvtOcclusionRes() { return m_dbvt_occlusion_res; };
524         
525         void SetSceneConverter(class KX_BlenderSceneConverter* sceneConverter);
526
527         class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
528         {
529                 return m_physicsEnvironment;
530         }
531
532         void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);
533
534         void    SetGravity(const MT_Vector3& gravity);
535         
536         /**
537          * Sets the node tree for this scene.
538          */
539         void SetNodeTree(SG_Tree* root);
540
541         /**
542         * 2D Filters
543         */
544         void Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text);
545         void Render2DFilters(RAS_ICanvas* canvas);
546
547         KX_ObstacleSimulation* GetObstacleSimulation() {return m_obstacleSimulation;};
548
549 #ifndef DISABLE_PYTHON
550         /* --------------------------------------------------------------------- */
551         /* Python interface ---------------------------------------------------- */
552         /* --------------------------------------------------------------------- */
553
554         KX_PYMETHOD_DOC(KX_Scene, addObject);
555         KX_PYMETHOD_DOC(KX_Scene, end);
556         KX_PYMETHOD_DOC(KX_Scene, restart);
557         KX_PYMETHOD_DOC(KX_Scene, replace);
558         KX_PYMETHOD_DOC(KX_Scene, suspend);
559         KX_PYMETHOD_DOC(KX_Scene, resume);
560         KX_PYMETHOD_DOC(KX_Scene, get);
561         KX_PYMETHOD_DOC(KX_Scene, drawObstacleSimulation);
562
563         /* attributes */
564         static PyObject*        pyattr_get_name(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
565         static PyObject*        pyattr_get_objects(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
566         static PyObject*        pyattr_get_objects_inactive(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
567         static PyObject*        pyattr_get_lights(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
568         static PyObject*        pyattr_get_cameras(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
569         static PyObject*        pyattr_get_active_camera(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
570         static int                      pyattr_set_active_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
571         static PyObject*        pyattr_get_drawing_callback_pre(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
572         static int                      pyattr_set_drawing_callback_pre(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
573         static PyObject*        pyattr_get_drawing_callback_post(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
574         static int                      pyattr_set_drawing_callback_post(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
575
576         virtual PyObject* py_repr(void) { return PyUnicode_FromString(GetName().ReadPtr()); }
577         
578         /* getitem/setitem */
579         static PyMappingMethods Mapping;
580         static PySequenceMethods        Sequence;
581
582         /**
583          * Run the registered python drawing functions.
584          */
585         void RunDrawingCallbacks(PyObject* cb_list);
586         
587         PyObject* GetPreDrawCB() { return m_draw_call_pre; };
588         PyObject* GetPostDrawCB() { return m_draw_call_post; };
589 #endif
590
591         /**
592          * Sets the time the scene was suspended
593          */ 
594         void setSuspendedTime(double suspendedtime);
595         /**
596          * Returns the "curtime" the scene was suspended
597          */ 
598         double getSuspendedTime();
599         /**
600          * Sets the difference between the local time of the scene (when it
601          * was running and not suspended) and the "curtime"
602          */ 
603         void setSuspendedDelta(double suspendeddelta);
604         /**
605          * Returns the difference between the local time of the scene (when it
606          * was running and not suspended) and the "curtime"
607          */
608         double getSuspendedDelta();
609         /**
610          * Returns the Blender scene this was made from
611          */
612         struct Scene *GetBlenderScene() { return m_blenderScene; }
613
614         bool MergeScene(KX_Scene *other);
615
616
617         //void PrintStats(int verbose_level) {
618         //      m_bucketmanager->PrintStats(verbose_level)
619         //}
620
621 };
622
623 typedef std::vector<KX_Scene*> KX_SceneList;
624
625 #endif //__KX_SCENE_H
626