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