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