source/gameengine/Ketsji/KX_Scene.h

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