ogre 学习笔记系列（二）三大模块及事件处理

一、三大模块


1 SceneManager 基础

　　SceneManager管理出现在屏幕上的所有物体。当你把一个物体放到场景中，SceneManager就将对这个物体的坐标进行跟踪。当你建立一个摄象机时，SceneManager就将对他们所有东西进行跟踪。当你建立木块，广告牌，灯光...，SceneManager 还是会对他们进行跟踪。

　　SceneManager也有许多的类型，有渲染地形的，有渲染BSP树的，等等。在这篇文章中，你将学到许多类型的SceneManager。

2 Entity 基础

　　Entity是你在场景中渲染的物体的形状。你能把他想象成3D网格。一个机器人有网格，一条鱼有网格，你的角色行走的地形有一个大的网格。而如灯光，广告牌（Billboards），粒子，摄象机等没有Entity。

　　值得注意的一件事是，OGRE是根据物体的坐标和方向的可渲染性分别进行渲染的。这就意味着你不能直接到场景中的一个网格进行渲染。你必须将要渲染的物体的网格给予SceneNode ，SceneNode 包含诸如坐标和方向等信息。

3 SceneNode 基础

　　在上面已经提到，SceneNode 用于保持对所有与它联系的物体的坐标和方向进行跟踪。当你建立一个网格，他并不会在场景中进行渲染，除非你将这个网格赋予SceneNode 。相似的，SceneNode 不是你要在屏幕上显示的物体，只有当你建立一个SceneNode，并将一个网格赋予他，他才会在屏幕上显示一个物体。

　　SceneNode 能将许多的物体赋予他。例如，你在屏幕上有一个行走的物体，并且你想产生一个灯光环绕着他。首先，你需要建立一个SceneNode ，然后建立角色的网格，并将他赋予SceneNode 。下一步建立灯光，并将他赋予SceneNode 。SceneNode也允许你将他赋予其他SceneNode，这样就建立了一个有等级的节点系统。在下一篇文章中，我们将更详细的讲解SceneNode的功能。
　　一个重要的概念是，SceneNode的位置总是和他的父SceneNode有关，并且SceneManager包含所有被赋值的SceneNodes的根节点。

二、FrameListener, WindowEventListener, OIS::MultiTouchListener, OIS::KeyListener

1、FrameListener  渲染事件：

/** A interface class defining a listener which can be used to receive
notifications of frame events.
@remarks
A 'listener' is an interface designed to be called back when
particular events are called. This class defines the
interface relating to frame events. In order to receive
notifications of frame events, you should create a subclass of
FrameListener and override the methods for which you would like
to customise the resulting processing. You should then call
Root::addFrameListener passing an instance of this class.
There is no limit to the number of frame listeners you can register,
allowing you to register multiple listeners for different purposes.
Frame events only occur when Ogre is in continuous rendering mode,
i.e. after Root::startRendering is called. If the application is
doing ad-hoc rendering without entering a rendering loop, frame
events are not generated. Note that a frame event occurs once for
all rendering targets, not once per target.
*/
class _OgreExport FrameListener
{
/*
Note that this could have been an abstract class, but I made
the explicit choice not to do this, because I wanted to give
people the option of only implementing the methods they wanted,
rather than having to create 'do nothing' implementations for
those they weren't interested in. As such this class follows
the 'Adapter' classes in Java rather than pure interfaces.
*/
public:
/** Called when a frame is about to begin rendering.
@remarks
This event happens before any render targets have begun updating.
@return
True to go ahead, false to abort rendering and drop
out of the rendering loop.
*/
virtual bool frameStarted(const FrameEvent& evt)
{ (void)evt; return true; }

/** Called after all render targets have had their rendering commands
issued, but before render windows have been asked to flip their
buffers over.
@remarks
The usefulness of this event comes from the fact that rendering
commands are queued for the GPU to process. These can take a little
while to finish, and so while that is happening the CPU can be doing
useful things. Once the request to 'flip buffers' happens, the thread
requesting it will block until the GPU is ready, which can waste CPU
cycles. Therefore, it is often a good idea to use this callback to
perform per-frame processing. Of course because the frame's rendering
commands have already been issued, any changes you make will only
take effect from the next frame, but in most cases that's not noticeable.
@return
True to continue rendering, false to drop out of the rendering loop.
*/
virtual bool frameRenderingQueued(const FrameEvent& evt)
{ (void)evt; return true; }

/** Called just after a frame has been rendered.
@remarks
This event happens after all render targets have been fully updated
and the buffers switched.
@return
True to continue with the next frame, false to drop
out of the rendering loop.
*/
virtual bool frameEnded(const FrameEvent& evt)
{ (void)evt; return true; }

virtual ~FrameListener() {}

};
/** @} */
/** @} */
}

2、WindowEventListener 窗口相关事件

/** \addtogroup Core
* @{
*/
/** \addtogroup RenderSystem
* @{
*/
/**
@Remarks
Callback class used to send out window events to client app
*/
class _OgreExport WindowEventListener
{
public:
virtual ~WindowEventListener() {}

/**
@Remarks
Window has moved position
@param rw
The RenderWindow which created this events
*/
virtual void windowMoved(RenderWindow* rw)
{ (void)rw; }

/**
@Remarks
Window has resized
@param rw
The RenderWindow which created this events
*/
virtual void windowResized(RenderWindow* rw)
{ (void)rw; }

/**
@Remarks
Window is closing (Only triggered if user pressed the [X] button)
@param rw
The RenderWindow which created this events
@return True will close the window(default).
*/
virtual bool windowClosing(RenderWindow* rw)
{ (void)rw; return true; }

/**
@Remarks
Window has been closed (Only triggered if user pressed the [X] button)
@param rw
The RenderWindow which created this events
@note
The window has not actually close yet when this event triggers. It's only closed after
all windowClosed events are triggered. This allows apps to deinitialise properly if they
have services that needs the window to exist when deinitialising.
*/
virtual void windowClosed(RenderWindow* rw)
{ (void)rw; }

/**
@Remarks
Window has lost/gained focus
@param rw
The RenderWindow which created this events
*/
virtual void windowFocusChange(RenderWindow* rw)
{ (void)rw; }
};

3、MultiTouchListener触摸事件

   /**
To receive buffered touch input, derive a class from this, and implement the
methods here. Then set the call back to your MultiTouch instance with MultiTouch::setEventCallback
*/
class _OISExport MultiTouchListener
{
public:
virtual ~MultiTouchListener() {}
virtual bool touchMoved( const MultiTouchEvent &arg ) = 0;
virtual bool touchPressed( const MultiTouchEvent &arg ) = 0;
virtual bool touchReleased( const MultiTouchEvent &arg ) = 0;
virtual bool touchCancelled( const MultiTouchEvent &arg ) = 0;
};

4、KeyListener键盘事件

   /**
To recieve buffered keyboard input, derive a class from this, and implement the
methods here. Then set the call back to your Keyboard instance with Keyboard::setEventCallback
*/
class _OISExport KeyListener
{
public:
virtual ~KeyListener() {}
virtual bool keyPressed(const KeyEvent &arg) = 0;
virtual bool keyReleased(const KeyEvent &arg) = 0;
};