Differential D2457 Diff 8102 source/gameengine/Ketsji/KX_KetsjiEngine.h

Changeset View

Standalone View

source/gameengine/Ketsji/KX_KetsjiEngine.h

Context not available.

	#include "MT_CmMatrix4x4.h"	#include "MT_CmMatrix4x4.h"
	#include "MT_Matrix4x4.h"	#include "MT_Matrix4x4.h"
	#include "STR_String.h"	#include <string>
	#include "KX_ISystem.h"	#include "KX_ISystem.h"
	#include "KX_Scene.h"	#include "KX_Scene.h"
	#include "EXP_Python.h"	#include "EXP_Python.h"
Context not available.

	struct TaskScheduler;	struct TaskScheduler;
	class KX_TimeCategoryLogger;	class KX_TimeCategoryLogger;
		class KX_ISystem;
		class KX_ISceneConverter;
		class KX_NetworkMessageManager;
		class CListValue;
		class RAS_ICanvas;
		class RAS_IRasterizer;
		class SCA_IInputDevice;

	#define LEFT_EYE 1	#define LEFT_EYE 1
	#define RIGHT_EYE 2	#define RIGHT_EYE 2
Context not available.
	};	};

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

	/**	/**
	* KX_KetsjiEngine is the core game engine class.	* KX_KetsjiEngine is the core game engine class.
Context not available.
	{	{

	private:	private:
	class RAS_ICanvas* m_canvas; // 2D Canvas (2D Rendering Device Context)	/// 2D Canvas (2D Rendering Device Context)
	class RAS_IRasterizer* m_rasterizer; // 3D Rasterizer (3D Rendering)	RAS_ICanvas *m_canvas;
	class KX_ISystem* m_kxsystem;	/// 3D Rasterizer (3D Rendering)
	class KX_ISceneConverter* m_sceneconverter;	RAS_IRasterizer *m_rasterizer;
	class NG_NetworkDeviceInterface* m_networkdevice;	KX_ISystem *m_kxsystem;
		KX_ISceneConverter *m_sceneconverter;
		KX_NetworkMessageManager *m_networkMessageManager;
	#ifdef WITH_PYTHON	#ifdef WITH_PYTHON
	/* borrowed from sys.modules["__main__"], don't manage ref's */	/// \note borrowed from sys.modules["__main__"], don't manage ref's
	PyObject* m_pythondictionary;	PyObject *m_pythondictionary;
	PyObject* m_pyprofiledict;	PyObject *m_pyprofiledict;
	#endif	#endif
	class SCA_IInputDevice* m_keyboarddevice;	SCA_IInputDevice *m_inputDevice;
	class SCA_IInputDevice* m_mousedevice;
	class KX_Dome* m_dome; // dome stereo mode	/// Lists of scenes scheduled to be removed at the end of the frame.
		std::vector<std::string> m_removingScenes;
	/** Lists of scenes scheduled to be removed at the end of the frame. */	/// Lists of overley scenes scheduled to be added at the end of the frame.
	std::vector<STR_String> m_removingScenes;	std::vector<std::string> m_addingOverlayScenes;
	/** Lists of overley scenes scheduled to be added at the end of the frame. */	/// Lists of background scenes scheduled to be added at the end of the frame.
	std::vector<STR_String> m_addingOverlayScenes;	std::vector<std::string> m_addingBackgroundScenes;
	/** Lists of background scenes scheduled to be added at the end of the frame. */	/// Lists of scenes scheduled to be replaced at the end of the frame.
	std::vector<STR_String> m_addingBackgroundScenes;	std::vector<std::pair<std::string, std::string> > m_replace_scenes;
	/** Lists of scenes scheduled to be replaced at the end of the frame. */
	std::vector<std::pair<STR_String,STR_String> > m_replace_scenes;	/// The current list of scenes.
		CListValue *m_scenes;
	/* The current list of scenes. */	/// State variable recording the presence of object debug info in the current scene list.
	KX_SceneList m_scenes;	bool m_propertiesPresent;
	/* 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_bInitialized;	bool m_fixedFramerate;
	int m_activecam;	bool m_useExternalClock;
	bool m_bFixedTime;
	bool m_useExternalClock;	bool m_firstframe;
		int m_currentFrame;

	bool m_firstframe;	/// current logic game time
	int m_currentFrame;	double m_frameTime;
		/// game time for the next rendering step
	double m_frameTime; // current logic game time	double m_clockTime;
	double m_clockTime; // game time for the next rendering step	/// game time of the previous rendering step
	double m_previousClockTime; // game time of the previous rendering step	double m_previousClockTime;
	double m_previousAnimTime; //game time when the animations were last updated	///game time when the animations were last updated
	double m_remainingTime;	double m_previousAnimTime;
	double m_timescale; // time scaling parameter. if > 1.0, time goes faster than real-time. If < 1.0, times goes slower than real-time.	double m_remainingTime;
	double m_previousRealTime;	/// time scaling parameter. if > 1.0, time goes faster than real-time. If < 1.0, times goes slower than real-time.
		double m_timescale;
	static int m_maxLogicFrame; /* maximum number of consecutive logic frame */	double m_previousRealTime;
	static int m_maxPhysicsFrame; /* maximum number of consecutive physics frame */
	static double m_ticrate;	/// maximum number of consecutive logic frame
	static double m_anim_framerate; /* for animation playback only - ipo and action */	static int m_maxLogicFrame;
		/// maximum number of consecutive physics frame
	static bool m_restrict_anim_fps;	static int m_maxPhysicsFrame;
		static double m_ticrate;
	static double m_suspendedtime;	/// for animation playback only - ipo and action
	static double m_suspendeddelta;	static double m_anim_framerate;

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

		static double m_suspendedtime;
		static double m_suspendeddelta;

	static bool m_doRender; /* whether or not the scene should be rendered after the logic frame */	static bool m_doRender; /* whether or not the scene should be rendered after the logic frame */

	int m_exitcode;	/// Key used to exit the BGE
	STR_String m_exitstring;	static short m_exitkey;

	float m_cameraZoom;	int m_exitcode;
		std::string m_exitstring;
	bool m_overrideCam;
	STR_String m_overrideSceneName;	float m_cameraZoom;

	bool m_overrideCamUseOrtho;	bool m_overrideCam;
	MT_CmMatrix4x4 m_overrideCamProjMat;	std::string m_overrideSceneName;
	MT_CmMatrix4x4 m_overrideCamViewMat;
	float m_overrideCamNear;	bool m_overrideCamUseOrtho;
	float m_overrideCamFar;	MT_CmMatrix4x4 m_overrideCamProjMat;
	float m_overrideCamLens;	MT_CmMatrix4x4 m_overrideCamViewMat;
		float m_overrideCamNear;
		float m_overrideCamFar;
		float m_overrideCamLens;
	/// Default camera zoom.	/// Default camera zoom.
	float m_overrideCamZoom;	float m_overrideCamZoom;

	bool m_stereo;	bool m_stereo;
	int m_curreye;	int m_curreye;

	/** Categories for profiling display. */	/// Categories for profiling display.
	typedef enum {	typedef enum {
	tc_first = 0,	tc_first = 0,
	tc_physics = 0,	tc_physics = 0,
Context not available.
	tc_network,	tc_network,
	tc_scenegraph,	tc_scenegraph,
	tc_rasterizer,	tc_rasterizer,
	tc_services, // time spent in miscelaneous activities	tc_services, // time spent in miscelaneous activities
	tc_overhead, // profile info drawing overhead	tc_overhead, // profile info drawing overhead
	tc_outside, // time spent outside main loop	tc_outside, // time spent outside main loop
	tc_latency, // time spent waiting on the gpu	tc_latency, // time spent waiting on the gpu
	tc_numCategories	tc_numCategories
	} KX_TimeCategory;	} KX_TimeCategory;

	/** Time logger. */	/// Time logger.
	KX_TimeCategoryLogger* m_logger;	KX_TimeCategoryLogger *m_logger;

	/** Labels for profiling display. */	/// Labels for profiling display.
	static const char m_profileLabels[tc_numCategories][15];	static const char m_profileLabels[tc_numCategories][15];
	/** Last estimated framerate */	/// Last estimated framerate
	static double m_average_framerate;	static double m_average_framerate;
	/** Show the framerate on the game display? */	/// Show the framerate on the game display?
	bool m_show_framerate;	bool m_show_framerate;
	/** Show profiling info on the game display? */	/// Show profiling info on the game display?
	bool m_show_profile;	bool m_show_profile;
	/** Show any debug (scene) object properties on the game display? */	/// Show any debug (scene) object properties on the game display?
	bool m_showProperties;	bool m_showProperties;
	/** Show background behind text for readability? */	/// Show background behind text for readability?
	bool m_showBackground;	bool m_showBackground;
	/** Show debug properties on the game display*/	/// Show debug properties on the game display
	bool m_show_debug_properties;	bool m_show_debug_properties;
	/** Automatic add debug properties to the debug list*/	/// Automatic add debug properties to the debug list
	bool m_autoAddDebugProperties;	bool m_autoAddDebugProperties;

	/** record physics into keyframes */	/// Hide cursor every frame?
	bool m_animation_record;	bool m_hideCursor;

	/** Hide cursor every frame? */	/// Enable debug draw of culling bounding boxes.
	bool m_hideCursor;	bool m_showBoundingBox;
		/// Enable debug draw armatures.
	/** Override framing bars color? */	bool m_showArmature;
	bool m_overrideFrameColor;
	/** Red component of framing bar color. */	/// Override framing bars color?
	float m_overrideFrameColorR;	bool m_overrideFrameColor;
	/** Green component of framing bar color. */	/// Red component of framing bar color.
	float m_overrideFrameColorG;	float m_overrideFrameColorR;
	/** Blue component of framing bar color. */	/// Green component of framing bar color.
	float m_overrideFrameColorB;	float m_overrideFrameColorG;
	/** alpha component of framing bar color. */	/// Blue component of framing bar color.
	float m_overrideFrameColorA;	float m_overrideFrameColorB;
		/// Alpha component of framing bar color.
	/** Settings that doesn't go away with Game Actuator */	float m_overrideFrameColorA;

		/// Settings that doesn't go away with Game Actuator
	GlobalSettings m_globalsettings;	GlobalSettings m_globalsettings;

	/** Task scheduler for multi-threading */	/// Task scheduler for multi-threading
	TaskScheduler* m_taskscheduler;	TaskScheduler *m_taskscheduler;

		/** Set scene's total pause duration for animations process.
		* This is done in a separate loop to get the proper state of each scenes.
		* eg: There's 2 scenes, the first is suspended and the second is active.
		* If the second scene resume the first, the first scene will be not proceed
		* in 'NextFrame' for one frame, but set as active.
		* The render functions, called after and which update animations,
		* will see the first scene as active and will proceed to it,
		* but it will cause some negative current frame on actions because of the
		* total pause duration not setted.
		*/
		void UpdateSuspendedScenes();

	void RenderFrame(KX_Scene* scene, KX_Camera* cam);	void RenderFrame(KX_Scene scene, KX_Camera cam, unsigned short pass);
	void PostRenderScene(KX_Scene* scene);	void PostRenderScene(KX_Scene *scene, unsigned short target);
	void RenderDebugProperties();	void RenderDebugProperties();

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

	// set the devices and stuff. the client must take care of creating these	/// set the devices and stuff. the client must take care of creating these
	void SetKeyboardDevice(SCA_IInputDevice* keyboarddevice);	void SetInputDevice(SCA_IInputDevice *inputDevice);
	void SetMouseDevice(SCA_IInputDevice* mousedevice);	void SetCanvas(RAS_ICanvas *canvas);
	void SetNetworkDevice(NG_NetworkDeviceInterface* networkdevice);	void SetRasterizer(RAS_IRasterizer *rasterizer);
	void SetCanvas(RAS_ICanvas* canvas);	void SetNetworkMessageManager(KX_NetworkMessageManager *manager);
	void SetRasterizer(RAS_IRasterizer* rasterizer);
	#ifdef WITH_PYTHON	#ifdef WITH_PYTHON
	void SetPyNamespace(PyObject *pythondictionary);	void SetPyNamespace(PyObject *pythondictionary);
	PyObject* GetPyNamespace() { return m_pythondictionary; }	PyObject *GetPyNamespace()
	PyObject* GetPyProfileDict();	{
		return m_pythondictionary;
		}
		PyObject *GetPyProfileDict();
	#endif	#endif
	void SetSceneConverter(KX_ISceneConverter* sceneconverter);	void SetSceneConverter(KX_ISceneConverter *sceneconverter);
	KX_ISceneConverter* GetSceneConverter() { return m_sceneconverter; }	KX_ISceneConverter *GetSceneConverter()
	void SetAnimRecordMode(bool animation_record, int startFrame);	{
		return m_sceneconverter;
	int getAnimRecordFrame() const;	}
	void setAnimRecordFrame(int framenr);
		RAS_IRasterizer *GetRasterizer()
	RAS_IRasterizer* GetRasterizer() { return m_rasterizer; }	{
	RAS_ICanvas* GetCanvas() { return m_canvas; }	return m_rasterizer;
	SCA_IInputDevice* GetKeyboardDevice() { return m_keyboarddevice; }	}
	SCA_IInputDevice* GetMouseDevice() { return m_mousedevice; }	RAS_ICanvas *GetCanvas()
		{
	TaskScheduler* GetTaskScheduler() { return m_taskscheduler; }	return m_canvas;
		}
	/// Dome functions	SCA_IInputDevice *GetInputDevice()
	void InitDome(short res, short mode, short angle, float resbuf, short tilt, struct Text* text);	{
	void EndDome();	return m_inputDevice;
	void RenderDome();	}
	bool m_usedome;	KX_NetworkMessageManager *GetNetworkMessageManager() const
		{
	///returns true if an update happened to indicate -> Render	return m_networkMessageManager;
	bool NextFrame();	}
	void Render();
	void RenderShadowBuffers(KX_Scene *scene);	TaskScheduler *GetTaskScheduler()
		{
	void StartEngine(bool clearIpo);	return m_taskscheduler;
	void StopEngine();	}
	void Export(const STR_String& filename);
		/// returns true if an update happened to indicate -> Render
	void RequestExit(int exitrequestmode);	bool NextFrame();
	void SetNameNextGame(const STR_String& nextgame);	void Render();
	int GetExitCode();	void RenderShadowBuffers(KX_Scene *scene);
	const STR_String& GetExitString();
		void StartEngine(bool clearIpo);
	KX_SceneList* CurrentScenes();	void StopEngine();
	KX_Scene* FindScene(const STR_String& scenename);	void Export(const std::string& filename);
	void AddScene(class KX_Scene* scene);
	void ConvertAndAddScene(const STR_String& scenename,bool overlay);	void RequestExit(int exitrequestmode);
		void SetNameNextGame(const std::string& nextgame);
	void RemoveScene(const STR_String& scenename);	int GetExitCode();
	bool ReplaceScene(const STR_String& oldscene,const STR_String& newscene);	const std::string& GetExitString();
	void SuspendScene(const STR_String& scenename);
	void ResumeScene(const STR_String& scenename);	CListValue *CurrentScenes();
		KX_Scene *FindScene(const std::string& scenename);
	void GetSceneViewport(KX_Scene* scene, KX_Camera* cam, RAS_Rect& area, RAS_Rect& viewport);	void AddScene(KX_Scene *scene);
		void ConvertAndAddScene(const std::string& scenename, bool overlay);

		void RemoveScene(const std::string& scenename);
		bool ReplaceScene(const std::string& oldscene, const std::string& newscene);
		void SuspendScene(const std::string& scenename);
		void ResumeScene(const std::string& scenename);

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

	/// Sets zoom for camera objects, useful only with extend and scale framing mode.	/// Sets zoom for camera objects, useful only with extend and scale framing mode.
	void SetCameraZoom(float camzoom);	void SetCameraZoom(float camzoom);

	void EnableCameraOverride(const STR_String& forscene);	void EnableCameraOverride(const std::string& forscene);

	void SetCameraOverrideUseOrtho(bool useOrtho);	void SetCameraOverrideUseOrtho(bool useOrtho);
	void SetCameraOverrideProjectionMatrix(const MT_CmMatrix4x4& mat);	void SetCameraOverrideProjectionMatrix(const MT_CmMatrix4x4& mat);
	void SetCameraOverrideViewMatrix(const MT_CmMatrix4x4& mat);	void SetCameraOverrideViewMatrix(const MT_CmMatrix4x4& mat);
Context not available.

	// Update animations for object in this scene	// Update animations for object in this scene
	void UpdateAnimations(KX_Scene *scene);	void UpdateAnimations(KX_Scene *scene);

	/**	/**
	* Sets display of all frames.	* Sets display of fixed frames.
	* \param bUseFixedTime New setting for display all frames.	* \param fixedFramerate New setting for display all frames.
	*/	*/
	void SetUseFixedTime(bool bUseFixedTime);	void SetUseFixedFramerate(bool fixedFramerate);

	/**	/**
	* Returns display of all frames.	* Returns display of fixed frames.
	* \return Current setting for display all frames.	* \return Current setting for display all frames.
	*/	*/
	bool GetUseFixedTime(void) const;	bool GetUseFixedFramerate(void) const;

	/**	/**
	* Sets if the BGE relies on a external clock or its own internal clock	* Sets if the BGE relies on a external clock or its own internal clock
Context not available.
	* \param frameRate Display for frame rate on or off.	* \param frameRate Display for frame rate on or off.
	* \param profile Display for individual components on or off.	* \param profile Display for individual components on or off.
	* \param properties Display of scene object debug properties on or off.	* \param properties Display of scene object debug properties on or off.
	*/	*/
	void SetTimingDisplay(bool frameRate, bool profile, bool properties);	void SetTimingDisplay(bool frameRate, bool profile, bool properties);

	/**	/**
Context not available.
	* \param frameRate Display for frame rate on or off.	* \param frameRate Display for frame rate on or off.
	* \param profile Display for individual components on or off.	* \param profile Display for individual components on or off.
	* \param properties Display of scene object debug properties on or off.	* \param properties Display of scene object debug properties on or off.
	*/	*/
	void GetTimingDisplay(bool& frameRate, bool& profile, bool& properties) const;	void GetTimingDisplay(bool& frameRate, bool& profile, bool& properties) const;

	/**	/**
	* Sets cursor hiding on every frame.	* Sets cursor hiding on every frame.
	* \param hideCursor Turns hiding on or off.	* \param hideCursor Turns hiding on or off.
	*/	*/
	void SetHideCursor(bool hideCursor);	void SetHideCursor(bool hideCursor);

	/**	/**
	* Returns the current setting for cursor hiding.	* Returns the current setting for cursor hiding.
	* \return The current setting for cursor hiding.	* \return The current setting for cursor hiding.
	*/	*/
	bool GetHideCursor(void) const;	bool GetHideCursor(void) const;

	/**	/// Returns the current setting for bounding box debug.
		void SetShowBoundingBox(bool show);

		/// Allow debug bounding box debug.
		bool GetShowBoundingBox() const;

		/// Returns the current setting for armatures debug.
		void SetShowArmatures(bool show);

		/// Allow debug armatures.
		bool GetShowArmatures() const;

		/**
	* Enables/disables the use of the framing bar color of the Blender file's scenes.	* Enables/disables the use of the framing bar color of the Blender file's scenes.
	* \param overrideFrameColor The new setting.	* \param overrideFrameColor The new setting.
	*/	*/
	void SetUseOverrideFrameColor(bool overrideFrameColor);	void SetUseOverrideFrameColor(bool overrideFrameColor);

	/**	/**
	* Check if the frame color is being overridden.	* Check if the frame color is being overridden.
	*/	*/
	bool GetUseOverrideFrameColor(void) const;	bool GetUseOverrideFrameColor(void) const;

	/**	/**
	* Set the color used for framing bar color instead of the one in the Blender file's scenes.	* Set the color used for framing bar color instead of the one in the Blender file's scenes.
	* \param r Red component of the override color.	* \param r Red component of the override color.
	* \param g Green component of the override color.	* \param g Green component of the override color.
Context not available.
	*/	*/
	void SetOverrideFrameColor(float r, float g, float b, float a);	void SetOverrideFrameColor(float r, float g, float b, float a);

	/**	/**
	* Returns the color used for framing bar color instead of the one in the Blender file's scenes.	* Returns the color used for framing bar color instead of the one in the Blender file's scenes.
	* \param r Red component of the override color.	* \param r Red component of the override color.
	* \param g Green component of the override color.	* \param g Green component of the override color.
Context not available.
	*/	*/
	void GetOverrideFrameColor(float& r, float& g, float& b, float& a) const;	void GetOverrideFrameColor(float& r, float& g, float& b, float& a) const;

	KX_Scene* CreateScene(const STR_String& scenename);	KX_Scene *CreateScene(const std::string& scenename);
	KX_Scene* CreateScene(Scene *scene, bool libloading=false);	KX_Scene CreateScene(Scene scene, bool libloading = false);

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

	/**	/**
	* Invalidate all the camera matrices and handle other	* Invalidate all the camera matrices and handle other
	* needed changes when resized.	* needed changes when resized.
	* It's only called from Blenderplayer.	* It's only called from Blenderplayer.
	*/	*/
	void Resize();	void Resize();

	protected:	protected:
	/**	/**
Context not available.
	* SceneListsChanged(void) is called.	* SceneListsChanged(void) is called.
	* \see SceneListsChanged(void).	* \see SceneListsChanged(void).
	*/	*/
	void ProcessScheduledScenes(void);	void ProcessScheduledScenes(void);

	/**	/**
	* This method is invoked when the scene lists have changed.	* This method is invoked when the scene lists have changed.
	*/	*/
		void RemoveScheduledScenes(void);
		void AddScheduledScenes(void);
		void ReplaceScheduledScenes(void);
		void PostProcessScene(KX_Scene *scene);

		void BeginFrame();
		void EndFrame();

	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	#ifdef WITH_CXX_GUARDEDALLOC
	MEM_CXX_CLASS_ALLOC_FUNCS("GE:KX_KetsjiEngine")	MEM_CXX_CLASS_ALLOC_FUNCS("GE:KX_KetsjiEngine")
	#endif	#endif
Context not available.