KX_Scene.h

Go to the documentation of this file.

/*
 * ***** 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;
class KX_ObstacleSimulation;

#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
    CListValue*         m_animatedlist; // all animated objects
    
    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;

    KX_ObstacleSimulation* m_obstacleSimulation;

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 AddAnimatedObject(CValue* gameobj);
    void RemoveAnimatedObject(CValue* gameobj);

    void LogicBeginFrame(double curtime);
    void LogicUpdateFrame(double curtime, bool frame);
    void UpdateAnimations(double curtime);

        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);

    short GetAnimationFPS();
    
    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);

    KX_ObstacleSimulation* GetObstacleSimulation() {return m_obstacleSimulation;};

#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);
    KX_PYMETHOD_DOC(KX_Scene, drawObstacleSimulation);


    /* 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_From_STR_String(GetName()); }
    
    /* 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