KX_KetsjiEngine.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_KETSJI_ENGINE
#define __KX_KETSJI_ENGINE

#include "MT_CmMatrix4x4.h"
#include "MT_Matrix4x4.h"
#include "STR_String.h"
#include "KX_ISystem.h"
#include "KX_Scene.h"
#include "KX_Python.h"
#include "KX_WorldInfo.h"
#include <vector>
#include <set>

class KX_TimeCategoryLogger;

#define LEFT_EYE  1
#define RIGHT_EYE 2

enum KX_ExitRequestMode
{
    KX_EXIT_REQUEST_NO_REQUEST = 0,
    KX_EXIT_REQUEST_QUIT_GAME,
    KX_EXIT_REQUEST_RESTART_GAME,
    KX_EXIT_REQUEST_START_OTHER_GAME,
    KX_EXIT_REQUEST_NO_SCENES_LEFT,
    KX_EXIT_REQUEST_BLENDER_ESC,
    KX_EXIT_REQUEST_OUTSIDE,
    KX_EXIT_REQUEST_MAX
};

typedef struct {
    short matmode;
    short glslflag;
}   GlobalSettings;

class KX_KetsjiEngine
{

private:
    class RAS_ICanvas*              m_canvas; // 2D Canvas (2D Rendering Device Context)
    class RAS_IRasterizer*              m_rasterizer;  // 3D Rasterizer (3D Rendering)
    class KX_ISystem*               m_kxsystem;
    class RAS_IRenderTools*             m_rendertools;
    class KX_ISceneConverter*           m_sceneconverter;
    class NG_NetworkDeviceInterface*        m_networkdevice;
#ifdef WITH_PYTHON
    /* borrowed from sys.modules["__main__"], dont manage ref's */
    PyObject*                   m_pythondictionary;
#endif
    class SCA_IInputDevice*             m_keyboarddevice;
    class SCA_IInputDevice*             m_mousedevice;
    class KX_Dome*                      m_dome; // dome stereo mode

    std::set<STR_String> m_removingScenes;
    std::set<STR_String> m_addingOverlayScenes;
    std::set<STR_String> m_addingBackgroundScenes;
    std::set<std::pair<STR_String,STR_String> > m_replace_scenes;

    /* The current list of scenes. */
    KX_SceneList        m_scenes;
    /* State variable recording the presence of object debug info in the current scene list. */
    bool                m_propertiesPresent;    

    bool                m_bInitialized;
    int                 m_activecam;
    bool                m_bFixedTime;
    
    
    bool                m_firstframe;
    int                 m_currentFrame;

    double              m_frameTime;//discrete timestamp of the 'game logic frame'
    double              m_clockTime;//current time
    double              m_previousClockTime;//previous clock time
    double              m_previousAnimTime; //the last time animations were updated
    double              m_remainingTime;

    static int              m_maxLogicFrame;    /* maximum number of consecutive logic frame */
    static int              m_maxPhysicsFrame;  /* maximum number of consecutive physics frame */
    static double           m_ticrate;
    static double           m_anim_framerate; /* for animation playback only - ipo and action */

    static bool             m_restrict_anim_fps;

    static double           m_suspendedtime;
    static double           m_suspendeddelta;

    static short            m_exitkey; /* Key used to exit the BGE */

    int                 m_exitcode;
    STR_String          m_exitstring;
    int             m_drawingmode;
    float           m_cameraZoom;
    
    bool            m_overrideCam;  
    STR_String      m_overrideSceneName;
    
    bool            m_overrideCamUseOrtho;
    MT_CmMatrix4x4  m_overrideCamProjMat;
    MT_CmMatrix4x4  m_overrideCamViewMat;
    float           m_overrideCamNear;
    float           m_overrideCamFar;
    float           m_overrideCamLens;

    bool m_stereo;
    int m_curreye;

    typedef enum
    {
        tc_first = 0,
        tc_physics = 0,
        tc_logic,
        tc_animations,
        tc_network,
        tc_scenegraph,
        tc_rasterizer,
        tc_services,    // time spend in miscelaneous activities
        tc_overhead,    // profile info drawing overhead
        tc_outside,     // time spend outside main loop
        tc_numCategories
    } KX_TimeCategory;

    KX_TimeCategoryLogger*  m_logger;
    
    static const char       m_profileLabels[tc_numCategories][15];
    static double           m_average_framerate;
    bool                    m_show_framerate;
    bool                    m_show_profile;
    bool                    m_showProperties;
    bool                    m_showBackground;

    bool                    m_show_debug_properties;

    bool                    m_animation_record;

    bool                    m_hideCursor;

    bool                    m_overrideFrameColor;
    float                   m_overrideFrameColorR;
    float                   m_overrideFrameColorG;
    float                   m_overrideFrameColorB;

    GlobalSettings m_globalsettings;

    void                    RenderFrame(KX_Scene* scene, KX_Camera* cam);
    void                    PostRenderScene(KX_Scene* scene);
    void                    RenderDebugProperties();
    void                    RenderShadowBuffers(KX_Scene *scene);
    void                    SetBackGround(KX_WorldInfo* worldinfo);
    void                    RenderFonts(KX_Scene* scene);

public:
    KX_KetsjiEngine(class KX_ISystem* system);
    virtual ~KX_KetsjiEngine();

    // set the devices and stuff. the client must take care of creating these
    void            SetWorldSettings(KX_WorldInfo* worldinfo);
    void            SetKeyboardDevice(SCA_IInputDevice* keyboarddevice);
    void            SetMouseDevice(SCA_IInputDevice* mousedevice);
    void            SetNetworkDevice(NG_NetworkDeviceInterface* networkdevice);
    void            SetCanvas(RAS_ICanvas* canvas);
    void            SetRenderTools(RAS_IRenderTools* rendertools);
    void            SetRasterizer(RAS_IRasterizer* rasterizer);
#ifdef WITH_PYTHON
    void            SetPyNamespace(PyObject* pythondictionary);
    PyObject*       GetPyNamespace(){return m_pythondictionary;};
#endif
    void            SetSceneConverter(KX_ISceneConverter* sceneconverter);
    void            SetAnimRecordMode(bool animation_record, int startFrame);

    RAS_IRasterizer*        GetRasterizer(){return m_rasterizer;};
    RAS_ICanvas*            GetCanvas(){return m_canvas;};
    RAS_IRenderTools*       GetRenderTools(){return m_rendertools;};
    SCA_IInputDevice*       GetKeyboardDevice(){return m_keyboarddevice;};
    SCA_IInputDevice*       GetMouseDevice(){return m_mousedevice;};

    void            InitDome(short res, short mode, short angle, float resbuf, short tilt, struct Text* text); 
    void            EndDome();
    void            RenderDome();
    bool            m_usedome;

    bool            NextFrame();
    void            Render();
    
    void            StartEngine(bool clearIpo);
    void            StopEngine();
    void            Export(const STR_String& filename);

    void            RequestExit(int exitrequestmode);
    void            SetNameNextGame(const STR_String& nextgame);
    int             GetExitCode();
    const STR_String&   GetExitString();

    KX_SceneList*   CurrentScenes();
    KX_Scene*       FindScene(const STR_String& scenename);
    void            AddScene(class KX_Scene* scene);
    void            ConvertAndAddScene(const STR_String& scenename,bool overlay);

    void            RemoveScene(const STR_String& scenename);
    void            ReplaceScene(const STR_String& oldscene,const STR_String& newscene);
    void            SuspendScene(const STR_String& scenename);
    void            ResumeScene(const STR_String& scenename);

    void            GetSceneViewport(KX_Scene* scene, KX_Camera* cam, RAS_Rect& area, RAS_Rect& viewport);

    void SetDrawType(int drawingtype);
    int  GetDrawType(){return m_drawingmode;};

    void SetCameraZoom(float camzoom);
    
    void EnableCameraOverride(const STR_String& forscene);
    
    void SetCameraOverrideUseOrtho(bool useOrtho);
    void SetCameraOverrideProjectionMatrix(const MT_CmMatrix4x4& mat);
    void SetCameraOverrideViewMatrix(const MT_CmMatrix4x4& mat);
    void SetCameraOverrideClipping(float near, float far);
    void SetCameraOverrideLens(float lens);
    
    void SetUseFixedTime(bool bUseFixedTime);

    bool GetUseFixedTime(void) const;

    double GetClockTime(void) const;
    double GetFrameTime(void) const;

    double GetRealTime(void) const;
    static double GetSuspendedDelta();

    static double GetTicRate();
    static void SetTicRate(double ticrate);
    static int GetMaxLogicFrame();
    static void SetMaxLogicFrame(int frame);
    static int GetMaxPhysicsFrame();
    static void SetMaxPhysicsFrame(int frame);

    static bool GetRestrictAnimationFPS();

    static void SetRestrictAnimationFPS(bool bRestrictAnimFPS);

    static double GetAnimFrameRate();
    static void SetAnimFrameRate(double framerate);

    static double GetAverageFrameRate();

    static void SetExitKey(short key);

    static short GetExitKey();

    void SetTimingDisplay(bool frameRate, bool profile, bool properties);

    void GetTimingDisplay(bool& frameRate, bool& profile, bool& properties) const;

    void SetHideCursor(bool hideCursor);

    bool GetHideCursor(void) const;

    void SetUseOverrideFrameColor(bool overrideFrameColor);

    bool GetUseOverrideFrameColor(void) const; 

    void SetOverrideFrameColor(float r, float g, float b);

    void GetOverrideFrameColor(float& r, float& g, float& b) const;

    KX_Scene*       CreateScene(const STR_String& scenename);
    KX_Scene*       CreateScene(Scene *scene);

    GlobalSettings* GetGlobalSettings(void);    
    void            SetGlobalSettings(GlobalSettings* gs);

protected:
    void            ProcessScheduledScenes(void);

    void            SceneListsChanged(void);

    void            RemoveScheduledScenes(void);
    void            AddScheduledScenes(void);
    void            ReplaceScheduledScenes(void);
    void            PostProcessScene(class KX_Scene* scene);
    
    bool            BeginFrame();
    void            ClearFrame();
    void            EndFrame();
    
    
#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:KX_KetsjiEngine"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

#endif //__KX_KETSJI_ENGINE