source/gameengine/Ketsji/KX_Scene.h

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL/BL DUAL 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. The Blender
  10  * Foundation also sells licenses for use in proprietary software under
  11  * the Blender License.  See http://www.blender.org/BL/ for information
  12  * about this.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22  *
  23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  24  * All rights reserved.
  25  *
  26  * The Original Code is: all of this file.
  27  *
  28  * Contributor(s): none yet.
  29  *
  30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  31  */
  32 #ifndef __KX_SCENE_H
  33 #define __KX_SCENE_H
  34
  35
  36 #include "KX_PhysicsEngineEnums.h"
  37
  38 #include "MT_CmMatrix4x4.h"
  39
  40 #include <vector>
  41 #include <set>
  42
  43 #include "GEN_Map.h"
  44 #include "GEN_HashedPtr.h"
  45 #include "SG_IObject.h"
  46 #include "SCA_IScene.h"
  47 #include "MT_Transform.h"
  48 #include "SND_Scene.h"
  49 #include "RAS_FramingManager.h"
  50 #include "RAS_Rect.h"
  51
  52 #include "PyObjectPlus.h"
  53
  54 /**
  55  * @section Forward declarations
  56  */
  57 struct SM_MaterialProps;
  58 struct SM_ShapeProps;
  59
  60 class GEN_HashedPtr;
  61 class CListValue;
  62 class CValue;
  63 class SCA_LogicManager;
  64 class SCA_KeyboardManager;
  65 class SCA_TimeEventManager;
  66 class SCA_MouseManager;
  67 class SCA_ISystem;
  68 class SCA_IInputDevice;
  69 class SND_Scene;
  70 class SND_IAudioDevice;
  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_BucketManager;
  82 class RAS_MaterialBucket;
  83 class RAS_IPolyMaterial;
  84 class RAS_IRasterizer;
  85 class RAS_IRenderTools;
  86 class SCA_JoystickManager;
  87 /**
  88  * The KX_Scene holds all data for an independent scene. It relates
  89  * KX_Objects to the specific objects in the modules.
  90  * */
  91 class KX_Scene : public PyObjectPlus, public SCA_IScene
  92 {
  93         Py_Header;
  94 protected:
  95         RAS_BucketManager*      m_bucketmanager;
  96         CListValue*                     m_tempObjectList;
  97
  98         /**
  99          * The list of objects which have been removed during the
 100          * course of one frame. They are actually destroyed in
 101          * LogicEndFrame() via a call to RemoveObject().
 102          */
 103         CListValue*     m_euthanasyobjects;
 104
 105         CListValue*                     m_objectlist;
 106         CListValue*                     m_parentlist; // all 'root' parents
 107         CListValue*                     m_lightlist;
 108
 109         /**
 110          *  The tree of objects in the scene.
 111          */
 112         SG_Tree*                        m_objecttree;
 113
 114         /**
 115          * The set of cameras for this scene
 116          */
 117         set<class KX_Camera*>       m_cameras;
 118
 119         /**
 120          * Various SCA managers used by the scene
 121          */
 122         SCA_LogicManager*               m_logicmgr;
 123         SCA_KeyboardManager*    m_keyboardmgr;
 124         SCA_MouseManager*               m_mousemgr;
 125         SCA_TimeEventManager*   m_timemgr;
 126
 127         /**
 128         * physics engine abstraction
 129         */
 130
 131         e_PhysicsEngine m_physicsEngine;
 132         class PHY_IPhysicsEnvironment*          m_physicsEnvironment;
 133
 134         /**
 135          * Does this scene clear the z-buffer?
 136          */
 137         bool m_isclearingZbuffer;
 138
 139         /**
 140          * The name of the scene
 141          */
 142         STR_String      m_sceneName;
 143
 144         /**
 145          * stores the worldsettings for a scene
 146          */
 147         KX_WorldInfo* m_worldinfo;
 148
 149         /**
 150          * @section Different scenes, linked to ketsji scene
 151          */
 152
 153
 154         /**
 155          * Sound scenes
 156          */
 157         SND_Scene* m_soundScene;
 158         SND_IAudioDevice* m_adi;
 159
 160         /**
 161          * Network scene.
 162          */
 163         NG_NetworkDeviceInterface*      m_networkDeviceInterface;
 164         NG_NetworkScene* m_networkScene;
 165
 166         /**
 167          * A temoprary variable used to parent objects together on
 168          * replication. Don't get confused by the name it is not
 169          * the scene's root node!
 170          */
 171         SG_Node* m_rootnode;
 172
 173         /**
 174          * The active camera for the scene
 175          */
 176         KX_Camera* m_active_camera;
 177
 178         /**
 179          * The projection and view matrices of this scene
 180          * The projection matrix is computed externally by KX_Engine
 181          * The view mat is stored as a side effect of GetViewMatrix()
 182          * and is totally unnessary.
 183          */
 184         MT_CmMatrix4x4                          m_projectionmat;
 185         MT_CmMatrix4x4                          m_viewmat;
 186
 187         /** Desired canvas width set at design time. */
 188         unsigned int m_canvasDesignWidth;
 189         /** Desired canvas height set at design time. */
 190         unsigned int m_canvasDesignHeight;
 191
 192         /**
 193          * Another temporary variable outstaying its welcome
 194          * used in AddReplicaObject to map game objects to their
 195          * replicas so pointers can be updated.
 196          */
 197         GEN_Map <GEN_HashedPtr, void*> m_map_gameobject_to_replica;
 198
 199         /**
 200          * Another temporary variable outstaying its welcome
 201          * used in AddReplicaObject to keep a record of all added
 202          * objects. Logic can only be updated when all objects
 203          * have been updated. This stores a list of the new objects.
 204          */
 205         std::vector<KX_GameObject*>     m_logicHierarchicalGameObjects;
 206
 207         /**
 208          * Pointer to system variable passed in in constructor
 209          * only used in constructor so we do not need to keep it
 210          * around in this class.
 211          */
 212
 213         SCA_ISystem* m_kxsystem;
 214
 215         /**
 216          * The execution priority of replicated object actuators?
 217          */
 218         int     m_ueberExecutionPriority;
 219
 220         /**
 221          * Activity 'bubble' settings :
 222          * Suspend (freeze) the entire scene.
 223          */
 224         bool m_suspend;
 225
 226         /**
 227          * Radius in Manhattan distance of the box for activity culling.
 228          */
 229         float m_activity_box_radius;
 230
 231         /**
 232          * Toggle to enable or disable activity culling.
 233          */
 234         bool m_activity_culling;
 235
 236         /**
 237          * The framing settings used by this scene
 238          */
 239
 240         RAS_FrameSettings m_frame_settings;
 241
 242         /**
 243          * This scenes viewport into the game engine
 244          * canvas.Maintained externally, initially [0,0] -> [0,0]
 245          */
 246         RAS_Rect m_viewport;
 247
 248         /**
 249          * Visibility testing functions.
 250          */
 251         void MarkVisible(SG_Tree *node, RAS_IRasterizer* rasty);
 252         void MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool visible);
 253         void MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj);
 254
 255         /**
 256          * This stores anything from python
 257          */
 258         PyObject* m_attrlist;
 259
 260 public:
 261         KX_Scene(class SCA_IInputDevice* keyboarddevice,
 262                 class SCA_IInputDevice* mousedevice,
 263                 class NG_NetworkDeviceInterface* ndi,
 264                 class SND_IAudioDevice* adi,
 265                 const STR_String& scenename     );
 266
 267         virtual
 268         ~KX_Scene();
 269
 270         RAS_BucketManager* GetBucketManager();
 271         RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat);
 272         void RenderBuckets(const MT_Transform& cameratransform,
 273                                                 RAS_IRasterizer* rasty,
 274                                                 RAS_IRenderTools* rendertools);
 275         /**
 276          * Update all transforms according to the scenegraph.
 277          */
 278         void UpdateParents(double curtime);
 279         SCA_IObject* AddReplicaObject(CValue* gameobj,
 280                                                                   CValue* locationobj,
 281                                                                   int lifespan=0);
 282         KX_GameObject* AddNodeReplicaObject(SG_IObject* node,
 283                                                                                 CValue* gameobj);
 284         void RemoveNodeDestructObject(SG_IObject* node,
 285                                                                   CValue* gameobj);
 286         void RemoveObject(CValue* gameobj);
 287         void DelayedRemoveObject(CValue* gameobj);
 288         void NewRemoveObject(CValue* gameobj);
 289         void ReplaceMesh(CValue* gameobj,
 290                                          void* meshobj);
 291         /**
 292          * @section Logic stuff
 293          * Initiate an update of the logic system.
 294          */
 295         void LogicBeginFrame(double curtime);
 296         void LogicUpdateFrame(double curtime, bool frame);
 297
 298                 void
 299         LogicEndFrame(
 300         );
 301
 302                 CListValue*
 303         GetObjectList(
 304         );
 305
 306                 CListValue*
 307         GetRootParentList(
 308         );
 309
 310                 CListValue*
 311         GetLightList(
 312         );
 313
 314                 SCA_LogicManager*
 315         GetLogicManager(
 316         );
 317
 318                 SCA_TimeEventManager*
 319         GetTimeEventManager(
 320         );
 321
 322
 323         /** Find a camera in the scene by pointer. */
 324                 KX_Camera*
 325         FindCamera(
 326                 KX_Camera*
 327         );
 328
 329         /** Find a scene in the scene by name. */
 330                 KX_Camera*
 331         FindCamera(
 332                 STR_String&
 333         );
 334
 335         /** Add a camera to this scene. */
 336                 void
 337         AddCamera(
 338                 KX_Camera*
 339         );
 340
 341         /** Find the currently active camera. */
 342                 KX_Camera*
 343         GetActiveCamera(
 344         );
 345
 346         /**
 347          * Set this camera to be the active camera in the scene. If the
 348          * camera is not present in the camera list, it will be added
 349          */
 350
 351                 void
 352         SetActiveCamera(
 353                 class KX_Camera*
 354         );
 355
 356         /** Return the viewmatrix as used by the last frame. */
 357                 MT_CmMatrix4x4&
 358         GetViewMatrix(
 359         );
 360
 361         /**
 362          * Return the projectionmatrix as used by the last frame. This is
 363          * set by hand :)
 364          */
 365                 MT_CmMatrix4x4&
 366         GetProjectionMatrix(
 367         );
 368
 369         /** Sets the projection matrix. */
 370                 void
 371         SetProjectionMatrix(
 372                 MT_CmMatrix4x4& pmat
 373         );
 374
 375         /**
 376          * Activates new desired canvas width set at design time.
 377          * @param width The new desired width.
 378          */
 379                 void
 380         SetCanvasDesignWidth(
 381                 unsigned int width
 382         );
 383         /**
 384          * Activates new desired canvas height set at design time.
 385          * @param width The new desired height.
 386          */
 387                 void
 388         SetCanvasDesignHeight(
 389                 unsigned int height
 390         );
 391         /**
 392          * Returns the current desired canvas width set at design time.
 393          * @return The desired width.
 394          */
 395                 unsigned int
 396         GetCanvasDesignWidth(
 397                 void
 398         ) const;
 399
 400         /**
 401          * Returns the current desired canvas height set at design time.
 402          * @return The desired height.
 403          */
 404                 unsigned int
 405         GetCanvasDesignHeight(
 406                 void
 407         ) const;
 408
 409         /**
 410          * Set the framing options for this scene
 411          */
 412
 413                 void
 414         SetFramingType(
 415                 RAS_FrameSettings & frame_settings
 416         );
 417
 418         /**
 419          * Return a const reference to the framing
 420          * type set by the above call.
 421          * The contents are not guarenteed to be sensible
 422          * if you don't call the above function.
 423          */
 424
 425         const
 426                 RAS_FrameSettings &
 427         GetFramingType(
 428         ) const;
 429
 430         /**
 431          * Store the current scene's viewport on the
 432          * game engine canvas.
 433          */
 434         void SetSceneViewport(const RAS_Rect &viewport);
 435
 436         /**
 437          * Get the current scene's viewport on the
 438          * game engine canvas. This maintained
 439          * externally in KX_GameEngine
 440          */
 441         const RAS_Rect& GetSceneViewport() const;
 442
 443         /**
 444          * @section Accessors to different scenes of this scene
 445          */
 446         void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
 447         void SetNetworkScene(NG_NetworkScene *newScene);
 448         void SetWorldInfo(class KX_WorldInfo* wi);
 449         KX_WorldInfo* GetWorldInfo();
 450         void CalculateVisibleMeshes(RAS_IRasterizer* rasty);
 451         void UpdateMeshTransformations();
 452         KX_Camera* GetpCamera();
 453         SND_Scene* GetSoundScene();
 454         NG_NetworkDeviceInterface* GetNetworkDeviceInterface();
 455         NG_NetworkScene* GetNetworkScene();
 456
 457         /**
 458          * Replicate the logic bricks associated to this object.
 459          */
 460
 461         void ReplicateLogic(class KX_GameObject* newobj);
 462         static SG_Callbacks     m_callbacks;
 463
 464         const STR_String& GetName();
 465
 466         // Suspend the entire scene.
 467         void Suspend();
 468
 469         // Resume a suspended scene.
 470         void Resume();
 471
 472         // Update the activity box settings for objects in this scene, if needed.
 473         void UpdateObjectActivity(void);
 474
 475         // Enable/disable activity culling.
 476         void SetActivityCulling(bool b);
 477
 478         // Set the radius of the activity culling box.
 479         void SetActivityCullingRadius(float f);
 480         bool IsSuspended();
 481         bool IsClearingZBuffer();
 482         void EnableZBufferClearing(bool isclearingZbuffer);
 483
 484         class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
 485         {
 486                 return m_physicsEnvironment;
 487         }
 488
 489         void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);
 490
 491         void    SetGravity(const MT_Vector3& gravity);
 492
 493         /**
 494          * Sets the node tree for this scene.
 495          */
 496         void SetNodeTree(SG_Tree* root);
 497
 498         KX_PYMETHOD_DOC(KX_Scene, getLightList);
 499         KX_PYMETHOD_DOC(KX_Scene, getObjectList);
 500         KX_PYMETHOD_DOC(KX_Scene, getName);
 501 /*
 502         KX_PYMETHOD_DOC(KX_Scene, getActiveCamera);
 503         KX_PYMETHOD_DOC(KX_Scene, getActiveCamera);
 504         KX_PYMETHOD_DOC(KX_Scene, findCamera);
 505
 506         KX_PYMETHOD_DOC(KX_Scene, getGravity);
 507
 508         KX_PYMETHOD_DOC(KX_Scene, setActivityCulling);
 509         KX_PYMETHOD_DOC(KX_Scene, setActivityCullingRadius);
 510
 511         KX_PYMETHOD_DOC(KX_Scene, setSceneViewport);
 512         KX_PYMETHOD_DOC(KX_Scene, setSceneViewport);
 513         */
 514
 515         virtual PyObject* _getattr(const STR_String& attr); /* name, active_camera, gravity, suspended, viewport, framing, activity_culling, activity_culling_radius */
 516         virtual int _setattr(const STR_String &attr, PyObject *pyvalue);
 517         virtual int _delattr(const STR_String &attr);
 518 };
 519
 520 typedef std::vector<KX_Scene*> KX_SceneList;
 521
 522 #endif //__KX_SCENE_H
 523