计算机－＞游戏

SDL-IM: IM(输入法) 支援 in SDL（同下，转自http://sdl-im.csie.net/cn/index.html，应该是位台湾朋友)

Diviner — Fri, 16 Sep 2005 00:47:00 GMT

SDL-IM: IM(输入法) 支援 in SDL

(本页不保证最新，新讯息以英文网页为主 English main page )

哪里我可取得需要的档案？

您可取得 SDL-1.2.8 从: http://www.libsdl.org

您可取得 SDL_im for SDL-1.2.8 从: SDL_im-1.2.8-20050828.diff.gz

还有其它的吗？

是的！这里有一些使用了该修补的范例或程式库：

SDL_imm -- 一个提供更多 IM 支援的 Option Pack.

1.GuiChan/SDL-IM by harpy (感谢 harpy!)

2. patch for paraGUI-1.1.8

3. patch for aedGUI-0.1.8a

4. 用标准 C/C++ 实现 i18n 支援，以及一个简单易用的 ustring 程式库，这是 std::basic_string 的包覆模板。

5. patch for OGRE(> 1.0.3)，使其支援 i18n (可显示及输入中文、日文、韩文及多种语言)。

一些快照：

1. showfont.c(included in test.tar.gz) example for SDL_ttf. screenshot.

2. test.tar.gz: simple tests for SDL-IM. (update: 2005/08/28)

以SDL_im修补过的二进位元套件( 开发程式库 ):

SDL-devel-1.2.8-VC6.zip (Visual C++ 5,6,7)
SDL-devel-1.2.8-mingw32.tar.gz (Mingw32)

如何使用这份修补呢？

1. 下载 SDL-1.2.8 并解压缩它(ex. $tar zxvf SDL-1.2.8.tar.gz).
2. 下载修补，放到 SDL-1.2.8 方才解压的目录里，并解压缩它(ex. $gzip -d SDL_im-1.2.8-20050828.diff.gz).
3. 在 SDL-1.2.8 目录里 patch 这份 diff file(ex. $patch -p1 < SDL_im-1.2.8-20050211.diff).
4. 确定预先处理的巨集符号已定义(ENABLE_IM_EVENT).
5. 接下来，建造 SDL 并好好享用吧！ :-)

注意: 如果你在 Win32 环境下使用 Visual C++ ，加上 ENABLE_IM_EVENT 定义到你的 Makefile 或 Project file. 如果你在 Linux 环境下使用 automake ，当你下 “./configure” 指命时，只要检查 “--enable-im-event” 符号是否开启(default=yes).

There are the project files for VC6 and VC7.1: VisualC.zip, VisualC7.zip

There is the DirectX devel source for MinGW to build SDL: http://www.libsdl.org/extras/win32/common/

支援哪些平台？

这份修补支援 Win32 上的 IME(Input Method Editor)和 Linux(X11) 上的 XIM(X Input Method). 它也支援在全萤幕下显示 IME/XIM 视窗。

如何使用这些新的函式？

首先，确定您的输入法至少支援三种模式中的其中一种: Root, OverTheSpot, OnTheSpot.

然后，阅读以下的手册:

如果您有任何建议，问题或麻烦，请写信给小弟(请用英语或正体中文，谢谢). < >

我为何要使用这份 patch 呢？

小弟有两个理由来做这件事:

1. 如果您想开发一款线上游戏并且想要发布至全世界，特别是亚洲地区，那么 IM(输入法) 的支援是必要的。

2. 目前已有需多根植於 SDL 的优良 GUI 程式库。假若 SDL 支援 IM(输入法) ，那便表示我们不仅只可选择 MFC、 Qt 或 GTK+ 来写您的应用程式，而且还有许多其它的 GUI 程式库可用。没有什么比「能够自由自在地选择自己想要且需要的东西」还要更棒的了！

我自己有能力来 patch 吗？

当然罗！修补并不难。因为 SDL 的结构非常明析而且物件导向。您所需要知道的技术，只要知道如何在您的平台上，建立一个视窗并且让这个主视窗能够接收系统事件(event)。您若有兴趣来使得 SDL 得以支援 IM(输入法)，小弟会非常高兴。

除此之外，小弟希望有人愿意帮忙小弟来维护这专案，直到这份 patch 整合进 SDL 的官方释出版本。

你需要帮忙吗？

是的！我需要您的帮忙:

1. 在 Win32 DirectDraw 环境下，虽然小弟已成功地在全萤幕下显示 IME 视窗，但状态视窗仍然无法翻转出来。小弟不知道如何解决这个问题，如果您知道，请告诉小弟。(此问题已解决)

2. 这份修补还没有经过许多的测试。如果您可以用日文、韩文或任何其它使用多位元字组的语言来帮忙测试，小弟会很感激您的帮助。

3. 假若您有一些麦金塔、FreeBSD或其它平台的视窗程式设计经验，请加入小弟一同来实做IM(输入法)的支援！ :-)

修补的重点在哪？

(略)

本页的修改纪录:

2005/03/12: 新增本页。

ogre的中文及其他

Diviner — Fri, 16 Sep 2005 00:44:00 GMT

Some stuffs of the OGRE patch

I have to admit that if I had tried the CEGUI first, I would not make this patch. Since I have finished it, and this patch has something different with CEGUI, I decide to put it on the site at last.

What features the OGRE patch provides?

This patch provides these features:
1. A static and a dynamic code convertor class and convertor manager class.
2. A flexible UNICODE and multibyte code support natively.
3. An l10n Input Method support with SDL(SDL_im).

First, let us see the two pictures:

(picture 1 -- OGRE InputMethod support)

[About picture 1]
This is the InputMethod support with buffered or unbuffered input example.

(picture 2 -- OGRE multicode support)

[About picture 2]
The first line is Japanese with SHIFT_JIS code.
The second line is Korean with EUCKR code.
The third line is Arabic with WINDOWS-1256 code.
The fourth line is Thai with ISO-8859-11 code.
The fifth line is vietnamese with UTF8 code.
The sixth line is Hebrew with WINDOWS-1255 code.
The seventh line is Chinese with BIG5 code.

Where can I get this patch and how to apply it?

You can get OGRE patch from here, and the version(> 1.0.3) of OGRE I modify here , or you can get the OGRE source from OGRE official web site: http://www.ogre3d.org/ .

To apply this patch and compile:
1.$tar zxvf ogrenew-20050717cvs-20050730.tar.gz
2.$gzip -d ogre_patch-20050717cvs-20050730.diff.gz
3.$mv ogre_patch-20050717cvs-20050730.diff ogrenew/
4.$cd ogrenew/
5.$patch -p1 < ogre_patch-20050717cvs-20050730.diff
6.$./bootstrap
7.$./configure --with-platform=SDL
8.$make

Here is the sample of the new features:
ogretest
ogretest_full (with full Media pack)

The concepts of OGRE i18n patch

The implement of original Ogre::font is to make a texture which contains fonts' images all you may need, and to save the font's uv coordinate for this font texture in an array. When we need a character, just send the character code to get the coordinate of the font image texture.This is good enough for Latin system language, but not suitable for others' language, especially not for ideogram.

In the ideogram(ex. Chinese) system, there is no "alphabet" to be combined to a word. It's usually a character as a word. To see the character code range of CJK(Chinese, Japanese, Korean) language from http://www.unicode.org/ , the range is from 0x4E00 to 0x9FBF . It means that in order to create a CJK font texture by Ogre::font, we have to create 20927 fonts images. It's really a big texture!
So we have to create a part what we need of the CJK code set flexibly.

The improvement of Ogre::font

1. Add setExtCodeName() and getExtCodeName() members.
2. Add setCodeRange() and getCodeRange() members.
3. Re-define OGRE_GLYPH_INDEX(). If the character can not be found in Ogre::font, OGRE_GLYPH_INDEX() will return zero. It means that if the character can not be found, you will always receive the coordinate of the first font image.(Important!)
4. Add getUncreatedCode() to get a set which stores the code of the uncreated fonts you require.

After applying this patch, we have to check if the macro OGRE_UNICODE_STRINGS in ogrenew/OgreMain/include/OgreConfig.h is enabled as 1, then when we compile and install OGRE completely, we have to set the new identity "code" and "coderange" in the fontdef file in the Media pack.

For example:

TW
{
    type    truetype
    source     fireflysung.ttf
    code    BIG5
coderange 0xA141,0xA141.0xA143,0xA143.0xA4DF,0xA4DF.0xA7D3,0xA7D3.0xABE4,0xABE4.0xB4BC,0xB4BC.0xBC7B,0xBC7B.0xBCDD,0xBCDD.
    size 14
    resolution 96
    antialias_colour false
}

The string after the identity "code" is the code name which is the external code we want Ogre::font to receive, and OGRE will convert the external code to wchar_t UNICODE. The external code has to be the char type encoding code, like UTF8, BIG5, SHIFT_JIS....etc, and not the wide char type(wchar_t, unsigned short) encoding code, likes UCS, UTF16, UTF32...et.

The string after the identity "coderange", the code range of the "code", is the range which we want Ogre::font to create fonts image. The string is a line without space, and it uses comma(,) and decimal(.) to separate and to end the first code and the last code.

For example, it means to specify a BIG5 code 0xA141 to create:

code BIG5
coderange 0xA141,0xA141.

For example, it means to specify three BIG5 codes 0xA141, 0xA142, 0xA143 to create:

code BIG5
coderange 0xA141,0xA143.

Additionally, we can specify multi coderange like this:

code BIG5
coderange 0xA141,0xA143.0xA240,0xA2DD.0xA4AF,0xA4DF.

Note: If you do not specify code and coderange in the fontdef file, or not use the TrueType font, the behavior of the patched Ogre::font will be the same as the original one.

The little tools to make code range

There are two little tools to help us to make code range and export external code to octal string easily: mkcorg and mklit

The improvement of Ogre::TextAreaOverlayElement

In order to show UNICODE words, I modify the Ogre::TextAreaOverlayElement to convert external string to UNICODE automatically. Its interface is not changed.

The improvement of Ogre::Input

1. Add a new KeyCode define "KC_IM_FLUSH". "KC_IM_FLUSH" represents that the OGRE Application has received a string from IM(InputMethod). We could use "isKeyDown()" member function to check if the IM string is flushed.

2. Add a new member "getIMString()" to get the local code string from IM.

3. Add a new member "setIMPosition()" to set the absolute pixel position to IM widget.

You could see the sample 01_buffered_input and 02_unbuffered_input in ogretest to get the further information.

The Code Convertor system

Ogre::CodeConv(ogrenew/OgreMain/include/OgreCodeConv.h) provides an interface and a template wrapper for helping users to create code convertor that OGRE needs.

The sample 04_manual_conv demonstrates how to inherit the interface, use the template wrapper to create code convertors, and set convertors to Ogre::CodeConvManager manually.

Moreover, like the demonstration which the sample 03_multilang shows, we can usually let OGRE create code convertors automatically, not manually.

Changes log:
2005/07/25: commit this page.
2005/07/30: split ogretest and update patch.

Copyright 2004-2005 L.Y.C., Taiwan(Formosa).

ogre的游戏状态插件（转自OGRE的WIKI）

Diviner — Fri, 16 Sep 2005 00:33:00 GMT

Managing Game States with OGRE

From Ogre Wiki

This article will describe a simple technique which will help you to manage game states in OGRE, using the default rendering loop based on frame listeners. This technique is heavily inspired by the one described in the article Managing Game States in C++ (http://tonyandpaige.com/tutorials/game1.html). As I won't give many explanations about the mechanics of this technique, I invite you to read this article if you want a more thoroughful analysis of the system.

Table of contents [hide]

1 The GameState class

2 The InputManager class

3 The GameManager class

4 Game states

5 Gluing it all together

6 Conclusion

[edit]

The GameState class

First, you'll need to create the file GameState.h and put it in your include or src directory, depending on how your source tree is structured. Here are the contents of this file :

#ifndef GameState_H
#define GameState_H

#include <OGRE/Ogre.h>
 
#include "GameManager.h"

class GameState
{
public:
	virtual void enter() = 0;
	virtual void exit() = 0;

	virtual void pause() = 0;
	virtual void resume() = 0;

	virtual void keyClicked(Ogre::KeyEvent* e) = 0;
	virtual void keyPressed(Ogre::KeyEvent* e) = 0;
	virtual void keyReleased(Ogre::KeyEvent* e) = 0;
	virtual bool frameStarted(const Ogre::FrameEvent& evt) = 0;
	virtual bool frameEnded(const Ogre::FrameEvent& evt) = 0;

	void changeState(GameState* state) { GameManager::getSingletonPtr()->changeState(state); }
	void pushState(GameState* state) { GameManager::getSingletonPtr()->pushState(state); }
	void popState() { GameManager::getSingletonPtr()->popState(); }
protected:
	GameState() { }
};

#endif

This is a basic game state class, which you'll need to inherit from for all the game states you want to handle in your game. I'll give an example of such game states later.

[edit]

The InputManager class

The InputManager class, which is a singleton, will be the central point for input handling. Its role is to create an EventProcessor and expose an InputReader to the game states, which can be used for both buffered and unbuffered input. Unbuffered input will be used in the game itself and the buffered one will be use for states which should be treated as menus. More on that later when we come to the actual implementation of game states.

Definition of the class in InputManager.h :

#ifndef InputManager_H
#define InputManager_H

#include <OGRE/OgreSingleton.h>
#include <OGRE/OgreInput.h>

class InputManager : public Ogre::Singleton<InputManager>
{
public:
	InputManager(Ogre::RenderWindow* rwindow);
	virtual ~InputManager();
	inline Ogre::InputReader* getInputDevice() const { return mInputDevice; }
	inline Ogre::EventProcessor* getEventProcessor() const { return mEventProcessor; }
	static InputManager& getSingleton(void);
	static InputManager* getSingletonPtr(void);
private:
	Ogre::EventProcessor* mEventProcessor;
	Ogre::InputReader* mInputDevice;
};

#endif

Implementation of the class in InputManager.cpp :

#include <OGRE/OgreEventProcessor.h>

#include "InputManager.h"

template<> InputManager* Ogre::Singleton<InputManager>::ms_Singleton = 0;

InputManager::InputManager(Ogre::RenderWindow* window)
{
	mEventProcessor = new Ogre::EventProcessor();
	mEventProcessor->initialise(window);
	mEventProcessor->startProcessingEvents();
	mInputDevice = mEventProcessor->getInputReader();
}

InputManager::~InputManager()
{
	if (mEventProcessor)
		delete mEventProcessor;
}

InputManager* InputManager::getSingletonPtr(void)
{
	return ms_Singleton;
}

InputManager& InputManager::getSingleton(void)
{
	assert(ms_Singleton);
	return *ms_Singleton;
}

[edit]

The GameManager class

You'll need a game state manager to handle the game states and switch from one state to the other. This class, which is also a singleton, creates an InputManager and registers its EventProcessor to handle both buffered and unbuffered input. Here is the source code for the header file, named GameManager.h :

#ifndef GameManager_H
#define GameManager_H

#include <vector>
#include <OGRE/Ogre.h>
#include <OGRE/OgreEventListeners.h>
#include <OGRE/OgreSingleton.h>

#include "InputManager.h"

class GameState;

class GameManager : public Ogre::FrameListener, public Ogre::KeyListener,
	public Ogre::Singleton<GameManager>
{
public:
	GameManager();
	~GameManager();
	void start(GameState* state);
	void changeState(GameState* state);
	void pushState(GameState* state);
	void popState();
	static GameManager& getSingleton(void);
	static GameManager* getSingletonPtr(void);
protected:
	Ogre::Root* mRoot;
	Ogre::RenderWindow* mRenderWindow;
	InputManager* mInputManager;

	void setupResources(void);
	bool configure(void);

	void keyClicked(Ogre::KeyEvent* e);
	void keyPressed(Ogre::KeyEvent* e);
	void keyReleased(Ogre::KeyEvent* e);
	bool frameStarted(const Ogre::FrameEvent& evt);
	bool frameEnded(const Ogre::FrameEvent& evt);
private:
	std::vector<GameState*> mStates;
};

#endif

And here is the source code for the main source file, named GameManager.cpp :

#include <OGRE/Ogre.h>

#include "GameManager.h"
#include "InputManager.h"
#include "GameState.h"

using namespace Ogre;

template<> GameManager* Singleton<GameManager>::ms_Singleton = 0;

GameManager::GameManager()
{
	mRoot = 0;
	mInputManager = 0;
}

GameManager::~GameManager()
{
	// clean up all the states
	while (!mStates.empty()) {
		mStates.back()->exit();
		mStates.pop_back();
	}

	if (mInputManager)
		delete mInputManager;

	if (mRoot)
		delete mRoot;
}

void GameManager::start(GameState* state)
{
	mRoot = new Root();

	setupResources();

	if (!configure()) return;

	mRoot->addFrameListener(this);

	mInputManager = new InputManager(mRoot->getAutoCreatedWindow());
	mInputManager->getEventProcessor()->addKeyListener(this);

	changeState(state);

	mRoot->startRendering();
}

void GameManager::changeState(GameState* state)
{
	// cleanup the current state
	if ( !mStates.empty() ) {
		mStates.back()->exit();
		mStates.pop_back();
	}

	// store and init the new state
	mStates.push_back(state);
	mStates.back()->enter();
}

void GameManager::pushState(GameState* state)
{
	// pause current state
	if ( !mStates.empty() ) {
		mStates.back()->pause();
	}

	// store and init the new state
	mStates.push_back(state);
	mStates.back()->enter();
}

void GameManager::popState()
{
	// cleanup the current state
	if ( !mStates.empty() ) {
		mStates.back()->exit();
		mStates.pop_back();
	}

	// resume previous state
	if ( !mStates.empty() ) {
		mStates.back()->resume();
	}
}

void GameManager::setupResources(void)
{
	// load resource paths from config file
	ConfigFile cf;
	cf.load("resources.cfg");

	// go through all settings in the file
	ConfigFile::SectionIterator seci = cf.getSectionIterator();

	String secName, typeName, archName;
	while (seci.hasMoreElements())
	{
		secName = seci.peekNextKey();
		ConfigFile::SettingsMultiMap *settings = seci.getNext();
		ConfigFile::SettingsMultiMap::iterator i;
		for (i = settings->begin() ; i != settings->end() ; ++i)
		{
			typeName = i->first;
			archName = i->second;
			ResourceGroupManager::getSingleton().addResourceLocation(
				archName, typeName, secName);
		}
	}
}

bool GameManager::configure(void)
{
	// load config settings from ogre.cfg
	if (!mRoot->restoreConfig())
	{
		// if there is no config file, show the configuration dialog
		if (!mRoot->showConfigDialog())
		{
			return false;
		}
	}

	// initialise and create a default rendering window
	mRenderWindow = mRoot->initialise(true);

	ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

	return true;
}

void GameManager::keyClicked(KeyEvent* e)
{
	// call keyClicked of current state
	mStates.back()->keyClicked(e);
}

void GameManager::keyPressed(KeyEvent* e)
{
	// call keyPressed of current state
	mStates.back()->keyPressed(e);
}

void GameManager::keyReleased(KeyEvent* e)
{
	// call keyReleased of current state
	mStates.back()->keyReleased(e);
}

bool GameManager::frameStarted(const FrameEvent& evt)
{
	// call frameStarted of current state
	return mStates.back()->frameStarted(evt);
}

bool GameManager::frameEnded(const FrameEvent& evt)
{
	// call frameEnded of current state
	return mStates.back()->frameEnded(evt);
}

GameManager* GameManager::getSingletonPtr(void)
{
	return ms_Singleton;
}

GameManager& GameManager::getSingleton(void)
{  
	assert(ms_Singleton);
	return *ms_Singleton;
}

Note that you normally won't need to modify the GameState.h, GameManager.h, GameManager.cpp, InputManager.h and InputManager.cpp files as all your code will usually reside in the classes derived from GameState.

[edit]

Game states

I'll define three game states (Intro, Play and Pause) to show how this technique can be used, just like in the original source code for the article. Here is how these states are related to each other :

in the Intro state, <SPACE> will lead to the Play state, <ESC> will terminate the application ;
in the Play state, <ESC> will go back to the Intro state and <P> will go into the Pause state ;
in the Pause state, another key press on <P> will return to the Play state.

There won't be a lot of things happening in each state, I'll only change the background color so you know in which state you are (red for Intro, blue for Play and green for Pause). You can easily extend the code from this base, adding support for scene nodes, entities, overlays, etc. The code should be quite self-explanatory, if in doubt, read the article for which I gave a link in the introduction to clear things up.

Here is the source code for the Intro state :

IntroState.h

#ifndef IntroState_H
#define IntroState_H

#include <OGRE/Ogre.h>

#include "GameState.h"

class IntroState : public GameState
{
public:
	void enter();
	void exit();

	void pause();
	void resume();

	void keyClicked(Ogre::KeyEvent* e);
	void keyPressed(Ogre::KeyEvent* e);
	void keyReleased(Ogre::KeyEvent* e);
	bool frameStarted(const Ogre::FrameEvent& evt);
	bool frameEnded(const Ogre::FrameEvent& evt);

	static IntroState* getInstance() { return &mIntroState; }
protected:
	IntroState() { }

	Ogre::Root *mRoot;
	Ogre::SceneManager* mSceneMgr;
	Ogre::Viewport* mViewport;
	Ogre::InputReader* mInputDevice;
	Ogre::Camera* mCamera;
	bool mExitGame;
private:
	static IntroState mIntroState;
};

#endif

IntroState.cpp

#include <OGRE/Ogre.h>
#include <OGRE/OgreKeyEvent.h>

#include "IntroState.h"
#include "PlayState.h"

using namespace Ogre;

IntroState IntroState::mIntroState;

void IntroState::enter()
{
	mInputDevice = InputManager::getSingletonPtr()->getInputDevice();
	mRoot = Root::getSingletonPtr();

	mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
	mCamera = mSceneMgr->createCamera("IntroCamera");
	mViewport = mRoot->getAutoCreatedWindow()->addViewport(mCamera);
	mViewport->setBackgroundColour(ColourValue(1.0, 0.0, 0.0));

	mExitGame = false;
}

void IntroState::exit()
{
	mSceneMgr->clearScene();
	mSceneMgr->removeAllCameras();
	mRoot->getAutoCreatedWindow()->removeAllViewports();
}

void IntroState::pause()
{
}

void IntroState::resume()
{
}

void IntroState::keyClicked(KeyEvent* e)
{
}

void IntroState::keyPressed(KeyEvent* e)
{
	if (e->getKey() == KC_SPACE)
	{
		changeState(PlayState::getInstance());
	}

	if (e->getKey() == KC_ESCAPE)
	{
		mExitGame = true;
	}
}

void IntroState::keyReleased(KeyEvent* e)
{
}

bool IntroState::frameStarted(const FrameEvent& evt)
{
	return true;
}

bool IntroState::frameEnded(const FrameEvent& evt)
{
	if (mExitGame)
		return false;

	return true;
}

Here is the source code for the Play state :

PlayState.h

#ifndef PlayState_H
#define PlayState_H

#include <OGRE/Ogre.h>

#include "GameState.h"

class PlayState : public GameState
{
public:
	void enter();
	void exit();

	void pause();
	void resume();

	void keyClicked(Ogre::KeyEvent* e);
	void keyPressed(Ogre::KeyEvent* e);
	void keyReleased(Ogre::KeyEvent* e);
	bool frameStarted(const Ogre::FrameEvent& evt);
	bool frameEnded(const Ogre::FrameEvent& evt);

	static PlayState* getInstance() { return &mPlayState; }
protected:
	PlayState() { }

	Ogre::Root *mRoot;
	Ogre::SceneManager* mSceneMgr;
	Ogre::Viewport* mViewport;
	Ogre::InputReader* mInputDevice;
	Ogre::Camera* mCamera;
private:
	static PlayState mPlayState;
};

#endif

PlayState.cpp

#include <OGRE/Ogre.h>
#include <OGRE/OgreKeyEvent.h>

#include "PlayState.h"
#include "IntroState.h"
#include "PauseState.h"

using namespace Ogre;

PlayState PlayState::mPlayState;

void PlayState::enter()
{
	mInputDevice = InputManager::getSingletonPtr()->getInputDevice();
	mRoot = Root::getSingletonPtr();

	mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
	mCamera = mSceneMgr->createCamera("IntroCamera");
	mViewport = mRoot->getAutoCreatedWindow()->addViewport(mCamera);
	mViewport->setBackgroundColour(ColourValue(0.0, 0.0, 1.0));
}

void PlayState::exit()
{
	mSceneMgr->clearScene();
	mSceneMgr->removeAllCameras();
	mRoot->getAutoCreatedWindow()->removeAllViewports();
}

void PlayState::pause()
{
}

void PlayState::resume()
{
	mViewport->setBackgroundColour(ColourValue(0.0, 0.0, 1.0));
}

void PlayState::keyClicked(KeyEvent* e)
{
}

void PlayState::keyPressed(KeyEvent* e)
{
	if (e->getKey() == KC_P)
	{
		pushState(PauseState::getInstance());
	}

	if (e->getKey() == KC_ESCAPE)
	{
		changeState(IntroState::getInstance());
	}
}

void PlayState::keyReleased(KeyEvent* e)
{
}

bool PlayState::frameStarted(const FrameEvent& evt)
{
	return true;
}

bool PlayState::frameEnded(const FrameEvent& evt)
{
	return true;
}

Here is the source code for the Pause state :

PauseState.h

#ifndef PauseState_H
#define PauseState_H

#include <OGRE/Ogre.h>

#include "GameState.h"

class PauseState : public GameState
{
public:
	void enter();
	void exit();

	void pause();
	void resume();

	void keyClicked(Ogre::KeyEvent* e);
	void keyPressed(Ogre::KeyEvent* e);
	void keyReleased(Ogre::KeyEvent* e);
	bool frameStarted(const Ogre::FrameEvent& evt);
	bool frameEnded(const Ogre::FrameEvent& evt);

	static PauseState* getInstance() { return &mPauseState; }
protected:
	PauseState() { }

	Ogre::Root *mRoot;
	Ogre::SceneManager* mSceneMgr;
	Ogre::Viewport* mViewport;
	Ogre::InputReader* mInputDevice;
	Ogre::Camera* mCamera;
private:
	static PauseState mPauseState;
};

#endif

PauseState.cpp

#include <OGRE/Ogre.h>
#include <OGRE/OgreKeyEvent.h>

#include "PauseState.h"
#include "PlayState.h"

using namespace Ogre;

PauseState PauseState::mPauseState;

void PauseState::enter()
{
	mInputDevice = InputManager::getSingletonPtr()->getInputDevice();
	mRoot = Root::getSingletonPtr();

	mViewport = mRoot->getAutoCreatedWindow()->getViewport(0);
	mViewport->setBackgroundColour(ColourValue(0.0, 1.0, 0.0));
}

void PauseState::exit()
{
}

void PauseState::pause()
{
}

void PauseState::resume()
{
}

void PauseState::keyClicked(KeyEvent* e)
{
}

void PauseState::keyPressed(KeyEvent* e)
{
	if (e->getKey() == KC_P)
	{
		popState();
	}
}

void PauseState::keyReleased(KeyEvent* e)
{
}

bool PauseState::frameStarted(const FrameEvent& evt)
{
	return true;
}

bool PauseState::frameEnded(const FrameEvent& evt)
{
	return true;
}

Note that all the input code related to buffered input should be in the keyClicked, keyPressed and keyReleased functions, using the e->getKey() call as shown in the sources. This is needed for everything related to menus or GUI.

Input management for the game itself (unbuffered input) should be handled in the frameStarted and frameEnded functions, using the mInputDevice->isKeyDown() call like this :

if (mInputDevice->isKeyDown(KC_RIGHT)) x++;
if (mInputDevice->isKeyDown(KC_LEFT)) x--;
if (mInputDevice->isKeyDown(KC_UP)) y++;
if (mInputDevice->isKeyDown(KC_DOWN)) y--;

This is what you will use to control a character on the screen or to shoot a bullet for example.

[edit]

Gluing it all together

With all this files, we need a starting point for the application, it will be the Main.cpp file. It is very similar to the ones found in the OGRE samples. In this file, you'll only need to instantiate the game manager and start it in the first state.

Main.cpp

#include <OGRE/Ogre.h>

#include "GameManager.h"
#include "IntroState.h"

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"

INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
#else
int main(int argc, char **argv)
#endif
{
	GameManager* game = new GameManager();

	try
	{
		// initialize the game and switch to the first state
		game->start(IntroState::getInstance());
	}
	catch (Ogre::Exception& e)
	{
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
		MessageBox(NULL, e.getFullDescription().c_str(), "An exception has occurred!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
		std::cerr << "An exception has occured: " << e.getFullDescription();
#endif
	}

	delete game;

	return 0;
}

[edit]

Conclusion

This ends this short tutorial which described a way to handle game states within an OGRE application. I hope it has been clear and that it will be useful for someone. For now it does only handle keyboard as an input device, I'll maybe add mouse and joystick support later if it fits well in this architecture. I am aware that this may not be the best way to handle game states within an application, and I'm open to any critics or suggestions about the way it was implemented.

stateman-0.0.5.tar.gz (http://frederic.lopez.free.fr/ogre/stateman-0.0.5.tar.gz) - Source and autoconf/automake files for Linux (compatible with OGRE 1.0.4)
statemanVC7.zip (http://frederic.lopez.free.fr/ogre/statemanVC7.zip) - Source and project file for Visual C++ 7 (old version, deprecated)

Retrieved from "http://www.ogre3d.org/wiki/index.php/Managing_Game_States_with_OGRE"

脚本语言一览(ZT)

Diviner — Wed, 27 Apr 2005 23:45:00 GMT

Ruby

Author: Yukihiro Matsumoto, License: Ruby License

Ruby is an interpreted scripting language for quick and easy object-oriented programming. It has many features to process text files and to do system management tasks (as in Perl). It is simple, straight-forward, extensible, and portable.

Detailed information: http://www.ruby-lang.org/en/

0 Comments

Python

Author: Multiple, License: Python

Python is an interpreted, interactive, object-oriented programming language. It is often compared to Tcl, Perl, Scheme or Java.

Detailed information: http://python.org/

0 Comments

Squirrel Language

Author: Alberto Demichelis, License: zlib

Squirrel is a high level imperative/OO programming language, designed to be a powerful scripting tool that fits in the size, memory bandwidth, and real-time requirements of applications like games.

Detailed information: http://squirrel.sourceforge.net/

0 Comments

GYS Project

Author: Govoruschenko Yuri Y., License: LGPL

A library for developing interpreters of scripting languages.

Detailed information: http://gys.sourceforge.net

0 Comments

AngelScript

Author: Andreas J鰊sson, License: zlib

The AngelCode Scripting Library, or AngelScript as it is also known, is an extremely flexible cross-platform scripting library designed to allow applications to extend their functionality through external scripts. It has been designed from the beginning to be an easy to use component, both for the application programmer and the script writer.

Detailed information: http://www.angelcode.com/angelscript/

0 Comments

The Small Language

Author: CompuPhase, License: zlib

Small is a simple, typeless, 32-bit extension language with a C-like syntax. A Small "source" program is compiled to a binary file for optimal execution speed. The Small compiler outputs P-code (or bytecode) that subsequently runs on an abstract machine. Execution speed, stability, simplicity and a small footprint were essential design criteria for both the language and the abstract machine.

Detailed information: http://www.compuphase.com/small.htm

0 Comments

Lua

Author: Lua Team at Tecgraf, License: zlib/MIT

Lua is a powerful light-weight programming language designed for extending applications. Lua is also frequently used as a general-purpose, stand-alone language. Lua is free software. Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics.

Detailed information: http://www.lua.org

0 Comments

Simkin Language

Author: Simon Whiteside, License: Open Source

Simkin is a high-level lightweight embeddable scripting language which works with Java or C++ and XML. Simkin enables you to hand over control of part or all of your application to your users.

Detailed information: http://www.simkin.co.uk

0 Comments

//这个语言我没仔细看过，不过好像还支持symbian的手机