KX_Scene.h

Go to the documentation of this file.

/*
 * $Id: KX_Scene.h 36523 2011-05-06 20:18:42Z blendix $
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __KX_SCENE_H
#define __KX_SCENE_H


#include "KX_PhysicsEngineEnums.h"

#include <vector>
#include <set>
#include <list>

#include "CTR_Map.h"
#include "CTR_HashedPtr.h"
#include "SG_IObject.h"
#include "SCA_IScene.h"
#include "MT_Transform.h"

#include "RAS_FramingManager.h"
#include "RAS_Rect.h"


#include "PyObjectPlus.h"
#include "RAS_2DFilterManager.h"

struct SM_MaterialProps;
struct SM_ShapeProps;
struct Scene;

class CTR_HashedPtr;
class CListValue;
class CValue;
class SCA_LogicManager;
class SCA_KeyboardManager;
class SCA_TimeEventManager;
class SCA_MouseManager;
class SCA_ISystem;
class SCA_IInputDevice;
class NG_NetworkDeviceInterface;
class NG_NetworkScene;
class SG_IObject;
class SG_Node;
class SG_Tree;
class KX_WorldInfo;
class KX_Camera;
class KX_GameObject;
class KX_LightObject;
class RAS_BucketManager;
class RAS_MaterialBucket;
class RAS_IPolyMaterial;
class RAS_IRasterizer;
class RAS_IRenderTools;
class SCA_JoystickManager;
class btCollisionShape;
class KX_BlenderSceneConverter;
struct KX_ClientObjectInfo;

#ifdef WITH_CXX_GUARDEDALLOC
#include "MEM_guardedalloc.h"
#endif

/* for ID freeing */
#define IS_TAGGED(_id) ((_id) && (((ID *)_id)->flag & LIB_DOIT))

class KX_Scene : public PyObjectPlus, public SCA_IScene
{
        Py_Header;

#ifdef WITH_PYTHON
        PyObject*       m_attr_dict;
        PyObject*       m_draw_call_pre;
        PyObject*       m_draw_call_post;
#endif

        struct CullingInfo {
                int m_layer;
                CullingInfo(int layer) : m_layer(layer) {}
        };

protected:
        RAS_BucketManager*      m_bucketmanager;
        CListValue*                     m_tempObjectList;

        CListValue*     m_euthanasyobjects;

        CListValue*                     m_objectlist;
        CListValue*                     m_parentlist; // all 'root' parents
        CListValue*                     m_lightlist;
        CListValue*                     m_inactivelist; // all objects that are not in the active layer
        
        SG_QList                        m_sghead;               // list of nodes that needs scenegraph update
                                                                                // the Dlist is not object that must be updated
                                                                                // the Qlist is for objects that needs to be rescheduled
                                                                                // for updates after udpate is over (slow parent, bone parent)


        list<class KX_Camera*>       m_cameras;

        list<class KX_FontObject*>       m_fonts;


        SCA_LogicManager*               m_logicmgr;
        SCA_KeyboardManager*    m_keyboardmgr;
        SCA_MouseManager*               m_mousemgr;
        SCA_TimeEventManager*   m_timemgr;

        // Scene converter where many scene entities are registered
        // Used to deregister objects that are deleted
        class KX_BlenderSceneConverter*         m_sceneConverter;
        //e_PhysicsEngine m_physicsEngine; //who needs this ?
        class PHY_IPhysicsEnvironment*          m_physicsEnvironment;

        bool m_isclearingZbuffer;

        STR_String      m_sceneName;
        
        KX_WorldInfo* m_worldinfo;

        NG_NetworkDeviceInterface*      m_networkDeviceInterface;
        NG_NetworkScene* m_networkScene;

        SG_Node* m_rootnode;

        KX_Camera* m_active_camera;

        CTR_Map	<CTR_HashedPtr, void*> m_map_gameobject_to_replica;

        std::vector<KX_GameObject*>     m_logicHierarchicalGameObjects;
        
        std::set<CValue*>       m_groupGameObjects;
        
        SCA_ISystem* m_kxsystem;

        int     m_ueberExecutionPriority;

        bool m_suspend;

        float m_activity_box_radius;

        bool m_activity_culling;
        
        bool m_dbvt_culling;
        
        int m_dbvt_occlusion_res;

        RAS_FrameSettings m_frame_settings;

        RAS_Rect m_viewport;
        
        void MarkVisible(SG_Tree *node, RAS_IRasterizer* rasty, KX_Camera*cam,int layer=0);
        void MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool visible, KX_Camera*cam,int layer=0);
        void MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj, KX_Camera*cam, int layer=0);
        static void PhysicsCullingCallback(KX_ClientObjectInfo* objectInfo, void* cullingInfo);

        double                          m_suspendedtime;
        double                          m_suspendeddelta;

        struct Scene* m_blenderScene;

        RAS_2DFilterManager m_filtermanager;
public: 
        KX_Scene(class SCA_IInputDevice* keyboarddevice,
                class SCA_IInputDevice* mousedevice,
                class NG_NetworkDeviceInterface* ndi,
                const STR_String& scenename,
                struct Scene* scene,
                class RAS_ICanvas* canvas);

        virtual 
        ~KX_Scene();

        RAS_BucketManager* GetBucketManager();
        RAS_MaterialBucket*     FindBucket(RAS_IPolyMaterial* polymat, bool &bucketCreated);
        void RenderBuckets(const MT_Transform& cameratransform,
                                                RAS_IRasterizer* rasty,
                                                RAS_IRenderTools* rendertools);

        static bool KX_ScenegraphUpdateFunc(SG_IObject* node,void* gameobj,void* scene);
        static bool KX_ScenegraphRescheduleFunc(SG_IObject* node,void* gameobj,void* scene);
        void UpdateParents(double curtime);
        void DupliGroupRecurse(CValue* gameobj, int level);
        bool IsObjectInGroup(CValue* gameobj)
        { 
                return (m_groupGameObjects.empty() || 
                                m_groupGameObjects.find(gameobj) != m_groupGameObjects.end());
        }
        SCA_IObject* AddReplicaObject(CValue* gameobj,
                                                                  CValue* locationobj,
                                                                  int lifespan=0);
        KX_GameObject* AddNodeReplicaObject(SG_IObject* node,
                                                                                CValue* gameobj);
        void RemoveNodeDestructObject(SG_IObject* node,
                                                                  CValue* gameobj);
        void RemoveObject(CValue* gameobj);
        void DelayedRemoveObject(CValue* gameobj);
        
        int NewRemoveObject(CValue* gameobj);
        void ReplaceMesh(CValue* gameobj,
                                         void* meshob, bool use_gfx, bool use_phys);
        void LogicBeginFrame(double curtime);
        void LogicUpdateFrame(double curtime, bool frame);

                void                                            
        LogicEndFrame(
        );

                CListValue*                             
        GetTempObjectList(
        );

                CListValue*
        GetObjectList(
        );

                CListValue*                             
        GetInactiveList(
        );

                CListValue*                             
        GetRootParentList(
        );

                CListValue*                             
        GetLightList(
        );

                SCA_LogicManager*               
        GetLogicManager(
        );

                SCA_TimeEventManager*   
        GetTimeEventManager(
        );

                list<class KX_FontObject*>*
        GetFonts(
        );

                KX_FontObject*              
        FindFont(
                KX_FontObject*
        );

                void                    
        AddFont(
                KX_FontObject*
        );


                list<class KX_Camera*>*
        GetCameras(
        );
 

                KX_Camera*              
        FindCamera(
                KX_Camera*
        );

                KX_Camera*              
        FindCamera(
                STR_String&
        );

                void                    
        AddCamera(
                KX_Camera*
        );

                KX_Camera*                              
        GetActiveCamera(
        );

                void                                    
        SetActiveCamera(
                class KX_Camera*
        );

                void
        SetCameraOnTop(
                class KX_Camera*
        );

                void                                    
        SetCanvasDesignWidth(
                unsigned int width
        );
                void                                    
        SetCanvasDesignHeight(
                unsigned int height
        );
                unsigned int                    
        GetCanvasDesignWidth(
                void
        ) const;

                unsigned int                    
        GetCanvasDesignHeight(
                void
        ) const;

                void
        SetFramingType(
                RAS_FrameSettings & frame_settings
        );

        const
                RAS_FrameSettings &
        GetFramingType(
        ) const;

        void SetSceneViewport(const RAS_Rect &viewport);

        const RAS_Rect& GetSceneViewport() const;
        
        void SetNetworkDeviceInterface(NG_NetworkDeviceInterface* newInterface);
        void SetNetworkScene(NG_NetworkScene *newScene);
        void SetWorldInfo(class KX_WorldInfo* wi);
        KX_WorldInfo* GetWorldInfo();
        void CalculateVisibleMeshes(RAS_IRasterizer* rasty, KX_Camera *cam, int layer=0);
        void UpdateMeshTransformations();
        KX_Camera* GetpCamera();
        NG_NetworkDeviceInterface* GetNetworkDeviceInterface();
        NG_NetworkScene* GetNetworkScene();
        KX_BlenderSceneConverter *GetSceneConverter() { return m_sceneConverter; }

        void ReplicateLogic(class KX_GameObject* newobj);
        static SG_Callbacks     m_callbacks;

        const STR_String& GetName();
        
        // Suspend the entire scene.
        void Suspend();

        // Resume a suspended scene.
        void Resume();
        
        // Update the activity box settings for objects in this scene, if needed.
        void UpdateObjectActivity(void);

        // Enable/disable activity culling.
        void SetActivityCulling(bool b);

        // Set the radius of the activity culling box.
        void SetActivityCullingRadius(float f);
        bool IsSuspended();
        bool IsClearingZBuffer();
        void EnableZBufferClearing(bool isclearingZbuffer);
        // use of DBVT tree for camera culling
        void SetDbvtCulling(bool b) { m_dbvt_culling = b; };
        bool GetDbvtCulling() { return m_dbvt_culling; };
        void SetDbvtOcclusionRes(int i) { m_dbvt_occlusion_res = i; };
        int GetDbvtOcclusionRes() { return m_dbvt_occlusion_res; };
        
        void SetSceneConverter(class KX_BlenderSceneConverter* sceneConverter);

        class PHY_IPhysicsEnvironment*          GetPhysicsEnvironment()
        {
                return m_physicsEnvironment;
        }

        void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*       physEnv);

        void    SetGravity(const MT_Vector3& gravity);
        
        void SetNodeTree(SG_Tree* root);

        void Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text);
        void Render2DFilters(RAS_ICanvas* canvas);

#ifdef WITH_PYTHON
        /* --------------------------------------------------------------------- */
        /* Python interface ---------------------------------------------------- */
        /* --------------------------------------------------------------------- */

        KX_PYMETHOD_DOC(KX_Scene, addObject);
        KX_PYMETHOD_DOC(KX_Scene, end);
        KX_PYMETHOD_DOC(KX_Scene, restart);
        KX_PYMETHOD_DOC(KX_Scene, replace);
        KX_PYMETHOD_DOC(KX_Scene, suspend);
        KX_PYMETHOD_DOC(KX_Scene, resume);
        KX_PYMETHOD_DOC(KX_Scene, get);

        /* attributes */
        static PyObject*        pyattr_get_name(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_objects(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_objects_inactive(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_lights(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_cameras(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_active_camera(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_active_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        static PyObject*        pyattr_get_drawing_callback_pre(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_drawing_callback_pre(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        static PyObject*        pyattr_get_drawing_callback_post(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_drawing_callback_post(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);

        virtual PyObject* py_repr(void) { return PyUnicode_FromString(GetName().ReadPtr()); }
        
        /* getitem/setitem */
        static PyMappingMethods Mapping;
        static PySequenceMethods        Sequence;

        void RunDrawingCallbacks(PyObject* cb_list);
        
        PyObject* GetPreDrawCB() { return m_draw_call_pre; };
        PyObject* GetPostDrawCB() { return m_draw_call_post; };
#endif

        void setSuspendedTime(double suspendedtime);
        double getSuspendedTime();
        void setSuspendedDelta(double suspendeddelta);
        double getSuspendedDelta();
        struct Scene *GetBlenderScene() { return m_blenderScene; }

        bool MergeScene(KX_Scene *other);


        //void PrintStats(int verbose_level) {
        //      m_bucketmanager->PrintStats(verbose_level)
        //}
};

typedef std::vector<KX_Scene*> KX_SceneList;

#endif //__KX_SCENE_H