[转帖]SceneManager分析

Admin

最近以为写引擎，需要研究ogre，以下是研究场景管理的结果。
Ogre使用插件机制来实现场景管理功能。ScenceManager只是接口，他可以有很多具体的实现。Ogre允许在同一时刻同一场景中使用多个Scene Manager,这样在不同的场景类型切换时带来好处。（v1.4版本后加了一个SceneManagerEnumerator）。
 
场景管理主要工作包括以下几点：
1.可移动、不可移动和可渲染物体的创建删除。
2.场景查询。
3.渲染队列。
4.动态阴影。
 
一. 场景对象创建
场景中的所有对象，包括可移动与不可移动的：Camera、Light、SceneNode、Entity、ManualObject、BillboardChain、RibbonTrail、ParticleSystem、BillboardSet、Animation、AnimationState、StaticGeometry、MovableObject等13种物体的createXXX、getXXX、hasXXX、destroyXXX.都由场景管理器来创建。场景中的任何东西都由场景管理器来管理。任何通过场景管理器得到的东西，都必须由场景管理器来销毁。用户不能delete通过由场景管理器得到的指针。
 
SkyDome, SkyPlane, SkyBox
主要的相似点是它们与相机保持一个常量的距离。它们可以在场景中其它对象之前或是之后渲染。它们使用普通的ogre material,因此纹理动画与其他纹理没有什么不同。它们可以被场景管理器打开或关闭，与相机的距离也可以设置。
skyplane 是一个平面。用距离和法线定义它与相机的位置关系。可以弯曲，可以分多个段，可对纹理进行多次平铺。
skydome由五个平面组成，底部空。使用改变纹理坐标的方式来达到外观上的曲率变化。有一个值用来调节，值越低，曲率越柔和，值越高，越陡峭。
skybox 像skydome,但他不能“弯曲”材质坐标。它可以使用立方材质。可使用硬件加速功能达到很好渲染效率。
 
SkyDome, SkyPlane, SkyBox等3种天空形式的setSkyXXX、isSkyXXX、getSkyXXX、
getSkyXXXGenParameters.以及setFog和getFog等参数的操作。
 
以下是这些操作一览：
1.Create函数

 
2.Destroy函数

3.Set函数

4.Get函数

 
二. 场景查询
Ogre的场景查询目前分为3种，一种是相交查询，一种是射线查询，一种是区域查询。查询的结果分为两种，一种是可运动对象（movable objects），一种是关卡的一部分（world geometry）。对于不同的场景管理器，同种查询得到的结果是不一样的。
其实查询可以直接做到场景管理器中，不过Ogre另外开辟了一个类，专门负责处理查询，就是SceneQuery。这个类的查询操作，其实就是包装场景管理器的查询接口。
相交查询，主要是查询两两相交的可运动对象，以及可运动对象和关卡子部分。
射线查询也是这种。
区域查询，是设定一个区域，如AABB区域，或者球形区域，或者由多面体组成的区域，查询在该区域中的可运动对象。
所有这些查询都是 maskble的，这表明可以在查询时过滤掉不关心的对象类型。如球查询时，只想看看它包含了多少lights,其他的对象即使包含在球里也不必返回，实际上根本不用计算。以下是UML图

 

1. WorldFragmentType和WorldFragment
    前面说过查询的结果分两种， movable objects和world geometry。而world geometry根据不同的查询方式得到的结果又分几种。WorldFragment就是表示world geometry查询结果的结构。WorldFragmentType是指用那种查询方式得到的结果。
enum WorldFragmentType {
    WFT_NONE,
    WFT_PLANE_BOUNDED_REGION,    // Region Scene Query结果
    WFT_SINGLE_INTERSECTION,     // Ray Scene Query结果
    WFT_CUSTOM_GEOMETRY,         // 自定义结果
    WFT_RENDER_OPERATION         // ？没发现有用
};
struct WorldFragment {
    WorldFragmentType fragmentType;
    Vector3 singleIntersection;  // WFT_SINGLE_INTERSECTION
    std::list<lane>* planes;    // WFT_PLANE_BOUNDED_REGION
    void* geometry;              // WFT_CUSTOM_GEOMETRY
    RenderOperation* renderOp;   // ？没发现有用
};
 
2. SceneQuery和SceneQueryListener
    SceneQuery场景查询的基类，负责保存与之相关的SceneManager、查询掩码和查询类掩码（SceneQuery类型掩码需要自己定义，也自己解释）和场景查询支持的World Fragment Type。
SceneManager* mParentSceneMgr;
uint32 mQueryMask;
uint32 mQueryTypeMask;
std::set<WorldFragmentType> mSupportedWorldFragments;
WorldFragmentType mWorldFragmentType;
在SceneManager中定义了几种类型掩码，如下：
static uint32 WORLD_GEOMETRY_TYPE_MASK;   // for world geometry
static uint32 ENTITY_TYPE_MASK;           // for entities
static uint32 FX_TYPE_MASK;               // for effects like billboardsets / particle systems
static uint32 STATICGEOMETRY_TYPE_MASK;   // for StaticGeometry
static uint32 LIGHT_TYPE_MASK;            // for lights
static uint32 USER_TYPE_MASK_LIMIT;       // max limit
 
SceneQueryListener是负责执行场景查询的回调抽象类，在3种查询的执行中把
SceneQueryListener的指针传递给SceneQuery的子类。
virtual void execute(SceneQueryListener* listener);
以下是SceneQueryListener的定义
class _OgreExport SceneQueryListener
{
public:
    virtual ~SceneQueryListener() { }
    virtual bool queryResult(MovableObject* object) = 0;
    virtual bool queryResult(SceneQuery::WorldFragment* fragment) = 0;
};
 
3. RegionSceneQuery RaySceneQuery IntersectionSceneQuery
上面3个查询的功能很简单，主要负责执行查询和保存查询结果。RegionSceneQuery又分别派生AxisAlignedBoxSceneQuery、SphereSceneQuery和PlaneBoundedVolumeListSceneQuery。
 
4.SceneManager中的SceneQuery
上面提过SceneQuery其实就是包装场景管理器的查询接口。下面代码证明了这个说法：
class DefaultRaySceneQuery : public RaySceneQuery
{
public:
    DefaultRaySceneQuery(SceneManager* creator);
    ~DefaultRaySceneQuery();
    void execute(RaySceneQueryListener* listener);
};
class DefaultSphereSceneQuery : public SphereSceneQuery
{
public:
    DefaultSphereSceneQuery(SceneManager* creator);
    ~DefaultSphereSceneQuery();
    void execute(SceneQueryListener* listener);
};
class DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery
{
public:
    DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator);
    ~DefaultPlaneBoundedVolumeListSceneQuery();
    void execute(SceneQueryListener* listener);
};
class DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery
{
public:
    DefaultAxisAlignedBoxSceneQuery(SceneManager* creator);
    ~DefaultAxisAlignedBoxSceneQuery();
    void execute(SceneQueryListener* listener);
};
 
5. SceneManager中的接口
virtual AxisAlignedBoxSceneQuery*
    createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF);
 
virtual SphereSceneQuery*
    createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF);
 
virtual PlaneBoundedVolumeListSceneQuery*
    createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF);
 
virtual RaySceneQuery*
    createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);
 
virtual IntersectionSceneQuery*
    createIntersectionQuery(unsigned long mask = 0xFFFFFFFF);
 
virtual void destroyQuery(SceneQuery* query);
下图是整个SceneQuery家族的UML结构图
 
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/genius_wu/archive/2007/09/26/1801507.aspx

Admin

三. 渲染队列RenderQueue
1. RenderQueue的组成
RenderQueue由Ogre::RenderQueueGroup组成的，RenderQueue中有一个RenderQueueGroup的Map的数据成员：
typedef std::map< RenderQueueGroupID, RenderQueueGroup * > RenderQueueGroupMap
RenderQueueGroupMap mGroups
可见RenderQueueGroupMap 的key为RenderQueueGroupID，代表Objects的渲染先后顺序。RenderQueueGroupID是一个枚举量，根据场景内物体的渲染顺序由先及后定义，RenderQueueGroupID的定义如下
     enum RenderQueueGroupID
     {
         RENDER_QUEUE_BACKGROUND = 0,
         RENDER_QUEUE_SKIES_EARLY = 5,
         RENDER_QUEUE_1 = 10,
         RENDER_QUEUE_2 = 20,
         RENDER_QUEUE_WORLD_GEOMETRY_1 = 25,
         RENDER_QUEUE_3 = 30,
         RENDER_QUEUE_4 = 40,
         RENDER_QUEUE_MAIN = 50,
         RENDER_QUEUE_6 = 60,
         RENDER_QUEUE_7 = 70,
         RENDER_QUEUE_WORLD_GEOMETRY_2 = 75,
         RENDER_QUEUE_8 = 80,
         RENDER_QUEUE_9 = 90,
         RENDER_QUEUE_SKIES_LATE = 95,
         RENDER_QUEUE_OVERLAY = 100,
     }
RenderQueue通过成员函数addRenderable 添加物体到渲染队列中，在RenderQueue的 getQueueGroup成员负责RenderQueueGroup的查找创建。RenderQueueGroup的生命周期由RenderQueue来控制。
 
2. RenderQueueGroup的组成
RenderQueueGroup中有一个RenderPriorityGroup的Map的数据成员：
typedef std::map<ushort, RenderPriorityGroup*, std::less<ushort> > PriorityMap;
PriorityMap mPriorityGroups;
 
PriorityMap的key为一个ushort,它代表着RenderPriorityGroup渲染的优先级。对同一优先级的Objects，RenderQueueGroup会通过成员函数addRenderable 将它加入相同的RenderPriorityGroup中，RenderPriorityGroup的生命周期是由 RenderQueueGroup管理的。
 
3. RenderPriorityGroup的组成
RenderPriorityGroup中是存放需要渲染的Objects的最终场所。需要渲染的Objects——Renderable，RenderPriorityGroup组织将其组织为RenderableList，然后把RenderableList组织成SolidRenderablePassMap：
 
typedef std::vector<Renderable*> RenderableList;
typedef std::map<ass*, RenderableList*, SolidQueueItemLess> SolidRenderablePassMap;
SolidRenderablePassMap mSolidPasses;
SolidRenderablePassMap mSolidPassesDiffuseSpecular;
SolidRenderablePassMap mSolidPassesDecal;
SolidRenderablePassMap mSolidPassesNoShadow;
综上所述，需渲染的物体分别经过RenderPriorityGroup、RenderQueueGroup分类后，由RenderQueue统一管理。
 
 
4. QueuedRenderableCollection
RenderPriorityGroup有5个成员变量mSolidsBasicm、SolidsDiffuseSpecular、mSolidsDecal、mSolidsNoShadowReceive、mTransparents都是QueuedRenderableCollection，
QueuedRenderableCollection是存储Renderable和Pass的最终场所。通过多种排序实现Renderable和Pass的有序化。排序包括小于排序、深度递减排序和基数排序。
     typedef std::vector<RenderablePass> RenderablePassList;
     typedef std::vector<Renderable*> RenderableList;
     typedef std::map<ass*, RenderableList*, PassGroupLess> PassGroupRenderableMap;
     PassGroupRenderableMap mGrouped;
     RenderablePassList mSortedDescending;
mGrouped和mSortedDescending中存储的是Renderable和Pass。
QueuedRenderableCollection组织Renderable和Pass有三种，分别是按Pass分组、按与camera的距离升序和按与camera的距离减序。
         enum OrganisationMode{
              OM_PASS_GROUP = 1,
              OM_SORT_DESCENDING = 2,
              OM_SORT_ASCENDING = 6
         };
 
5.QueuedRenderableVisitor
QueuedRenderableVisitor是按访问者模式设计的抽象接口。在QueuedRenderableCollection中有一个公用接口和三个内部接口如下：
void acceptVisitor(QueuedRenderableVisitor* visitor, OrganisationMode om) const;
void acceptVisitorGrouped(QueuedRenderableVisitor* visitor) const;
void acceptVisitorDescending(QueuedRenderableVisitor* visitor) const;
void acceptVisitorAscending(QueuedRenderableVisitor* visitor) const;
 
acceptVisitor按OrganisationMode3种方式分别调用内部接口acceptVisitorGrouped、
acceptVisitorDescending和acceptVisitorAscending。
switch(om)
{
case OM_PASS_GROUP:
     acceptVisitorGrouped(visitor);
     break;
case OM_SORT_DESCENDING:
     acceptVisitorDescending(visitor);
     break;
case OM_SORT_ASCENDING:
     acceptVisitorAscending(visitor);
     break;
}
而acceptVisitorGrouped、acceptVisitorDescending和acceptVisitorAscending。内部调用如下
void QueuedRenderableCollection::acceptVisitorGrouped(QueuedRenderableVisitor* visitor) const
{
     RenderableList* rendList = ipass->second;
     RenderableList::const_iterator irend, irendend;
     irendend = rendList->end();
     for (irend = rendList->begin(); irend != irendend; ++irend)
     {
         visitor->visit(*irend);
     }
}
通过以上分析可以看到最终的渲染任务是交到QueuedRenderableVisitor手中。
而在SceneManager中有如下定义，具体实现了渲染任务。
class SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor
SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor;
SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor;
 
6. RenderTarget
RenderTarget用来接收渲染操作的结果，它可以是屏幕上的窗口、离屏面（如texture）等。FPS信息的统计也是由RenderTarget完成的。在RenderTarget每次更新完成后，将会更新统计信息（封装于FrameStats中）。 除了负责统计帧的信息外，RenderTarget还负责创建维护Viewport（视口）：
typedef std::map<int, Viewport*, std::less<int> > ViewportList;
    ViewportList mViewportList;
    Viewport* RenderTarget::addViewport(Camera* cam, int ZOrder, float left, float top ,
        float width , float height)
    {
        ViewportList::iterator it = mViewportList.find(ZOrder);
        if (it != mViewportList.end())
        {
              …
        }
        Viewport* vp = new Viewport(cam, this, left, top, width, height, ZOrder);
        mViewportList.insert(ViewportList::value_type(ZOrder, vp));
        fireViewportAdded(vp);
        return vp;
}
由上面的代码可以看出，每个Viewport都对应一个Camera和一个RenderTarget。当创建一个Viewport后，它会自动建立与Camera的联系。可以把Camera看作是图像的来源，而RenderTarget是图像渲染的目的地。一个Viewport只能对应一个Camera和一个RenderTarget，而一个Camera也只能对应一个Viewport，但RenderTarget却可以拥有几个Viewport。 
 

Admin

7. 渲染过程
OGRE通过WinMain或main调用go再通过Root调用startRendering进行消息循环，然后调用renderOneFrame，通过RenderSystem的_updateAllRenderTargets方法，更新所有的RenderTarget。RenderTarget通过update方法更新与之关联的Viewport并产生FPS统计信息。而Viewport则调用与之关联的Camera的_renderScene方法进行渲染，Camera此时把“球”踢给SceneManager。进入SceneManager的renderScene成员函数中后，在经过计算后，把需要渲染的场景送给RenderSystem去做真正的渲染，此时我们可以看到熟悉的_breginFrame和_endFrame。 一直下去经过RenderQueue、RenderQueueGroup、RenderPriorityGroup、QueuedRenderableCollection再通过访问者到达QueuedRenderableVisitor的子类SceneMgrQueuedRenderableVisitor，最终又回到SceneManager，由SceneManager再到RenderSystem完成整个渲染过程。过程伪码如下所示：
int WinMain or main(int argc, char **argv)
{
app.go();
}
virtual void go(void)
{
     Root->startRendering();
}
void Root::startRendering(void)
{
     renderOneFrame();
}
bool Root::renderOneFrame(void)
{
     _updateAllRenderTargets();
}
void Root::_updateAllRenderTargets(void)
{
     RenderSystem->_updateAllRenderTargets();
}
void RenderSystem::_updateAllRenderTargets(void)
{
     RenderTarget->update();
}
void RenderTarget::update(void)
{
     Viewport->update();
}
void Viewport::update(void)
{
     Camera->_renderScene(this, mShowOverlays);
}
void Camera::_renderScene(Viewport *vp, bool includeOverlays)
{
     SceneManager->_renderScene(this, vp, includeOverlays);
}
void SceneManager::_renderScene(Camera* camera, Viewport* vp, bool includeOverlays)
{
    RenderSystem->_beginFrame();
    _renderVisibleObjects();
    RenderSystem->_endFrame();
}
void SceneManager::_renderVisibleObjects(void)
{
//如果有阴影
renderVisibleObjectsCustomSequence();
//否则
renderVisibleObjectsDefaultSequence();
}
void SceneManager::renderVisibleObjectsDefaultSequence(void)
{
     fireRenderQueueStarted(qId,mIlluminationStage)
     _renderQueueGroupObjects(pGroup, QueuedRenderableCollection::OM_PASS_GROUP);
     fireRenderQueueEnded(qId, mIlluminationStage)
}
void SceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup, OrganisationMode om)
{
     renderBasicQueueGroupObjects(pGroup, om);
}
void SceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, OrganisationMode om)
{
     renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
}
void SceneManager::renderObjects(const QueuedRenderableCollection& objs, …)
{
     objs.acceptVisitor(mActiveQueuedRenderableVisitor, om);
}
void QueuedRenderableCollection::acceptVisitor(QueuedRenderableVisitor* visitor…)
{
     switch(om){
     case OM_PASS_GROUP:
         acceptVisitorGrouped(visitor);
…
     }
}
void QueuedRenderableCollection::acceptVisitorGrouped(QueuedRenderableVisitor* visitor)
{
     QueuedRenderableVisitor->visit(Renderable);
}
void SceneManager::SceneMgrQueuedRenderableVisitor::visit(const Renderable* r)
{
     SceneManager->renderSingleObject(r, mUsedPass, autoLights, manualLightList);
}
void SceneManager::renderSingleObject(const Renderable* rend, const Pass* pass…)
{
     RenderSystem->_render(RenderOperation);
}
最终进入的RenderSystem的子类D3D9RenderSystem or GLRenderSystem。
void D3D9RenderSystem::_render(const RenderOperation& op)
{
mpD3DDevice->DrawIndexedPrimitive or mpD3DDevice->DrawPrimitive
}
void GLRenderSystem::_render(const RenderOperation& op)
{
glDrawElements or glDrawArrays
}
 
 
8. RenderQueueListener
class _OgreExport RenderQueueListener
{
public:
     virtual ~RenderQueueListener() {}
 
     virtual void renderQueueStarted(uint8 queueGroupId, const String& invocation, bool& skip) = 0;
     virtual void renderQueueEnded(uint8 queueGroupId, const String& invocation, bool& repeat) = 0;
};
RenderQueueListener的作用就是在SceneManager开始渲染和结束渲染时改变render state和别的操作，比如检查本次RenderQueue是否skip，如果skip就直接break本次render。
在上面渲染过程中有如下：
void SceneManager::renderVisibleObjectsDefaultSequence(void)
{
     fireRenderQueueStarted(qId,mIlluminationStage)
     _renderQueueGroupObjects(pGroup, QueuedRenderableCollection::OM_PASS_GROUP);
     fireRenderQueueEnded(qId, mIlluminationStage)
}
fireRenderQueueStarted和fireRenderQueueEnded中遍列RenderQueueListener。
定义如下：
typedef std::vector<RenderQueueListener*> RenderQueueListenerList;
RenderQueueListenerList mRenderQueueListeners;
bool SceneManager::fireRenderQueueStarted(uint8 id, const String& invocation)
{
    RenderQueueListener->renderQueueStarted(id, invocation, skip);
}
bool SceneManager::fireRenderQueueEnded(uint8 id, const String& invocation)
{
     RenderQueueListener->renderQueueEnded(id, invocation, repeat);
}
 
9. SpecialCaseRenderQueue
SenceManager中的RenderQueue包含一种特殊情况的渲染队列（Special Case Render Queue）
enum SpecialCaseRenderQueueMode{
SCRQM_INCLUDE,     // 只渲染Special Case
     SCRQM_EXCLUDE      // 不渲染Special Case
};
通过setSpecialCaseRenderQueueMode可以设置。以下是跟Special Case Render Queue有关的变量和操作：
typedef std::set<uint8> SpecialCaseRenderQueueList;
SpecialCaseRenderQueueList mSpecialCaseQueueList;
SpecialCaseRenderQueueMode mSpecialCaseQueueMode;
 
virtual void addSpecialCaseRenderQueue(uint8 qid);
virtual void removeSpecialCaseRenderQueue(uint8 qid);
virtual void clearSpecialCaseRenderQueues(void);
virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode);
virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void);
这里面需要说明一下的是qid，qid是RenderQueueGroupID，RenderQueueGroupID的定义在上面已经提过。
 
总之，通过上面分析可以看出render queue是Renderable的集合。其实场景树和渲染队列都是对Renderable进行分类，只是分类的标准不同，场景树主要是从空间结构对Renderable进行分类，而渲染队列则是对Renderable从material以及blend上进行分类。
 
四. 动态阴影Shadow
Ogre支持两种主流的动态阴影技术，模板(stencil)阴影与纹理(texture)阴影,每一种都有两个变体：modulative 与additive。这四种技术完全兼容fixed-function pipeline，因此不需要可编程GPU支持。然而，可利用GPU程序进行加速。在场景中只能使用一种阴影Technique，应该在场景渲染这前进行阴影Technique相关设置（最好是在创建场景管理器之间）。通过调用SceneManager::setShadowTechnique来设置Technique，参数指定Technique的具体类型。阴影Technique缺省情况下被关闭。对于物体，投射与接收阴影可以在材质中控制，也可以控制物体自己对自己投射。由于模板阴影算法的本质特征，透明半透明的物体要么全部投射实心阴影要么根本不投影影，不可能得到半透明的阴影。而使用纹理阴影技术则可以。灯不能用来投射阴影。
 
1. ShadowRenderable
    ShadowRenderable是存储shadow volume材质和渲染数据的类。
 
2. ShadowCaster
    ShadowCaster是计算和产生shadow volume的类。
 
3. ShadowVolumeExtrudeProgram
    ShadowVolumeExtrudeProgram是存储asm shader代码的类。
 
4. ShadowListener
    ShadowListener可以在渲染阴影过程中定义一些自己的操作。这个类只在shadow texture时有用。
 
Shadow这块可以精简，ogre有点复杂。
 
 
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/genius_wu/archive/2007/09/26/1801507.aspx