国产日韩三区,国产主播精品在线,国产精品久久久久久av福利软件

Ogre3D嵌入Qt框架之　��结

清源游民 — Mon, 21 May 2007 03:57:00 GMT

摘要: 阅读全文

清源游民 2007-05-21 11:57 发表评论

清源游民 — Sun, 20 May 2007 17:26:00 GMT

环境�Q�WindowsXp Pro SP2, VS2003.NET, Ogre1.4.1(Eihort), Qt 4.2.2 开源版
参考：ShowMesh,MAGE,两款工具源码
先把囄��出来�Q�有旉��文字�ȝ��一下，隑ֺ�虽然不高�Q�但也折腾不��时�?也算�q�来学习Qt与Ogre的一个小�l��?br>

清源游民 2007-05-21 01:26 发表评论

清源游民 — Wed, 21 Mar 2007 09:07:00 GMT

清源游民　　gameogre@gmail.com

阴媄技�?/font>
Ogre支持两种��L��的动态阴影技术，模板(stencil)阴媄与纹�?texture)阴媄,每一�U�都有两个变体：modulative 与additive。这四种技术完全兼容固定函数图形流水线�Q�因此不需要可�~�程GPU支持。然而，可利用GPU�E�序�q�行加速。在场景中只有��用一�U�阴影技术，应该在场景渲染这前进行阴影技术相兌��|�（最好是在创建场景管理器之间�Q�。通过调用SceneManager::setShadowTechnique()来设�|�技术，参数指定技术的具体�c�d��。阴影技术缺省情况下被关闭。对于物体，投射与接攉��影可以在材质中控�Ӟ��也可以控制物体自己对自己投射。由于模杉K��q��法的本质特征�Q�透明半透明的物体要么全部投��实心阴��p��么根本不投媄影，不可能得到半透明的阴影。而��用纹理阴影技术则可以。灯不能用来投射阴媄�?br />模板阴媄��法
模板阴媄��法原理上来讲比较简单：从光源的角度看一个可以投��阴��q��物体�Q�可以看到物体最外轮廓的
形状�Q�把�q�个轮廓沿光的方向�g伸，形成一个空间体�Q�就是所谓的阴媄�?shadow volume),很显�Ӟ��如果一
个物体被�q�个阴媄锥包��_��那么�q�个物体��处于前面那个物体所投射的阴�׃��了。既焉��影锥是通过延��的方式来增长的，那么可以在�g伸方向对锥体的�g伸范围作出控制。在延��方向上，有一端不能�g伸，另外一端的延��范围控制按照下面两个规则。第一�Q�如果��用可�~�程囑�Ş��g�Q�顶点程序可以对��点�q�行无限延��。第二，如果使用固定函数囑�Ş��水�U�，延��的范围由光线衰减讄��(点光源和聚光灯）或��?br />SceneManager::setShadowDirectionalLightExtrusionDistance()来控制。在不��用加速图形硬件的情况下，应该��量避免物体��d��源过�q�，�q�样会��生过于宽的阴影锥�Q�导致不正确的阴影效果。根据算法原理，产生的阴��p��界非常明显：一个像素要么在阴媄中，要么不在。这带来的好处是�Q�即佉K��影锥的�g伸距��d��大，也不会媄响精度。可以讲�q�种技术��生的阴媄是一�U�“硬阴媄"。纹理阴影技术可以”��Y化“阴影。��用模杉K��影技术需要边列表(edge lists),标准的�{换工具在产生二进制mesh文�g时会创徏边列表，如果没有�Q�在�E�序中也可以用Mesh::buildEdgeList()来��生。因为有时候，我们会代码的方式来生成mesh,如果�q�时我们想��用模杉K��影技术，那么��p��保产生��列表数据。如果边列表数据不存在，那么ogre会认��Z��不希望这个物体投��阴影�?br />模板阴媄优化
Ogre能进行一些一般的优化。例如可使用��g加速，可能通过光的方向与范围来��它是否会对�q�x��头体
(frustum)产生影响�Q�从面避免了计算那些不必要的阴媄几何体。ogre支持双面模板�Q�stencil-wrapping扩展�Q?br />�q�些都能��L��不必要的原型安装(primitive setup)与驱动过�?driver overhead)。ogre使用相对廉�h的Z-pass��法代替Z-Fail��法�Q�当Z�Q�Fail��法不必要时�Q�假如相机处于一个阴影锥中，使用Z-pass��法会有问题�Q�这�U�情况下应该使用Z-fail��法�Q��?br />阴媄锥不受封闭几何的影响。在下图中，

卫兵投射到地板上�Q�投��的范围内有个封闭的��子�Q�此例中讑֮��子不投��阴影）。根据现实世界的�l�验�Q�箱子上会有卫兵投射的阴影，如图中所�C�。但光线�l�过��子��L��后应该不再前�q�，也就是说阴媄锥经�q�箱子阻挡后不应该�g�怺��Q�于是箱子后面的地板上不应该再出现卫�늚�阴媄�Q�真实世界中出现��子的阴影，但是此例讑֮��子不��生阴�?。图中的地板上出��C��卫兵投射的阴影，�q�说明了阴媄不会受到延��方向上物体的影响�?br />在屏�q�上看不到的物体也可以把阴媄投媄到可视的�q�x��头体(view frustum)中。虽然看不到�Q�但是这些物�?br />也必��d��被渲染，渲染他们�U��a是�ؓ了得��C�生阴��q��相关数据。在不��用硬件加速的情况下，��量避免物体��d��源过�q��?br />�U�理阴媄
�U�理阴媄��法的基本原理是�Q�首先从光源的角度观察场景，把观察到�l�果渲染��C��个纹理，�U�理中只保存
深度��|��深度�~�冲中的��|��。这样做的意义是�Q�在�U�理中保存了场景中的物体与光源之间的最短距��R��然后从相机的角度进行正常渲染场景，计算每个像素与光源的距离,�q�与�U�理对应的��D��行比较，如果大于�Q�那么说明它不是光线方向上离光源的最�q�的�Q�会有阴�׃��?font color="#008000">�?*可以有点疑惑�Q�每个需要测试的像素如何与纹理中的像素一一对应呢？�q�是按照生成�U�理囄��原理�Q�需要把��试��点的位�|�坐标，转换到光源�ؓ视点的空��_��也就是说从光源的角度�Q�看看顶点应该在哪里。这样就可以一一对应比较了。当然这仅仅是�ؓ了比较的目的�Q�真正渲染时��点�q�是要先转换到视�I�间�?从相��度看)*/�?br />�U�理阴媄速度上要比模杉K��q��法快�Q�但因�ؓ阴媄被渲染到�U�理中，而纹理具有确定的解析度，因此当阴��p��扩展�Q�拉伸时�Q�效果会较差�Q�如产生锯��边等�?br />因�ؓ使用了纹理内存，因此它的��寸军_��了纹理阴影数的上限。ogre中可以管理一帧中可以使用的阴��q��理数�Q�SceneManager::setShadowTextureCount()。每个光源都需要一个纹理。假如指定的�U�理数少于光源数�Q�ogre采用”先来先服务“的原则分配�U�理。假如不能增加纹理尺寸来提高视觉效果�Q�最好减��投��阴��q��距离。阴�׃��会突然终�l�，ogre会��E化纹理阴��q��边缘��L��有阴�׃��无阴�׃��间剧烈过渡。可以控制��E化半径�?br />Modulative阴媄混合
正常场景渲染的颜色与阴媄的颜色相乘来创徏暗的、表�C�阴��q��颜色。这�U�方法有从已�l�渲染的场景中”减厠Z��光照媄响的效果。阴影区域一律变暗，与进入阴影区的光�U�数无关。当有多个光源��生的阴媄�?br />重叠�Ӟ��阴媄会非常暗�Q�视觉效果很差�?br />Additive Shadow Masking
Modulative的方法是通过影响阴媄区实现的。而Additive�Ҏ��是只对处于光照中的区域有影响�Q�对阴媄区没
有媄响。这样阴影区会受到别的光源的影响而变得稍亮，而相互重叠的阴媄��Z��不会更暗�?br />ogre会把一个通道分�ؓ三个通道.
Ambietn,应用环境光到场景中，在这个通道没有�U�理被渲染�?br /> Diffuse and specular, �q�个通道�Ҏ��个灯都渲染一�ơ，当前灯��生的阴媄区域不受影响。其余的区域与场景进行�؜合。同样也不��用�Q何脓��q��理�?br />Decal。纹理被应用到前面篏�U�的颜色上�?/p>

清源游民 2007-03-21 17:07 发表评论

《Pro Ogre 3D Programming》读书笔�?�?�W�十�?布告板与�_�子　�W�二部分

清源游民 — Tue, 20 Mar 2007 10:04:00 GMT

清源游民　　gameogre@gmail.com

�_�子�pȝ��
ogre中的�_�子�pȝ��既可用脚本描�q�ͼ�也可用代码完成。用�_�子脚本定义的粒子系�l�实际上是个模板�Q�因此它定义的粒子系�l�可在程序中方便地重用�?br />�_�子�pȝ��与场�?/font>
�_�子�pȝ��会被挂到场景�l�点上，因此�Q�结点的�q�移�Q�羃放，旋�{会关联到�_�子�pȝ��Q�媄响粒子反��的向�?br />�_�子会被发射��C��界空间中�Q�这意味着当场景移动时�Q�它会牵�q�到发射器，但已�l�发��出�ȝ��_�子不受影响。假如需要这些粒子受�l�点的媄响，可以把粒子发��到本地�I�间(local space)中。粒子系�l�不能无限制的发��粒子，它有一个限额（quota)。一旦到��N��额，�_�子�pȝ��不会再发��粒子，直到已经存在的粒子消亡。缺省的限额�?0�?br />�_�子�pȝ��U�束(Bounds)
�_�子�pȝ��的动态特征意味着它们的绑定盒必须规律地被重新计算。缺省情况下�Q�ogre会在10�U�之后，停止
更新�l�定盒。可以用ParticleSystem::setBoundsAutoUpdated( bool autoUpdate, Real stopIn = 0.0f )来改变缺省行为。stopIn�q�个参数告诉ogre多长旉��后停止更新。假如有个粒子系�l�，可以知道它的增长不会��过某个范围�Q�可以事先用ParticleSystem::setBounds()讄��l�定盒尺寸。这样做效率很高�Q�如果无法事先确定粒子系�l�的增长情况�Q�可先用setBounds()讑֮�一个初始尺寸，而用setBoundsAutoUpdated()让它在一�D�|��间之后更新�?br />�_�子�pȝ��更新
对于�_�子�pȝ��的更斎ͼ�ogre采用适度启发式的�{�略。�D例来��_��当粒子系�l�不在视锥体之内�Q�ogre仍会对粒子系�l�进行更斎ͼ��q�是考虑��C��久之后，�_�子�pȝ��有可能会重新�q�入视锥体之内。这��避免了�q�种情况下的视觉上的不和谐。但是出于性能上的考虑�Q�当�_�子�pȝ��退��锥体一�D�|��间之后，�_�子��实会停止更新。这又会��到上面的问题：被冻�l�的�_�子�pȝ��H�然重新�q�入视锥体的情况。ogre提供了一个所谓的
"fast-forward"机制�Q�允许粒子系�l�在被冻�l�之后，快速超��当前状态。这�U�特性也可以用在刚创建的�_�子�pȝ��Q��它们状态提前一�D�|��_��使用的方法是ParticleSystem::fastForward ();
�_�子�pȝ��排序
可以指示ogre�Ҏ��与相��Z��间的距离�Q�对�_�子�q�行排序。虽然这会媄响性能�Q�但有时不得不用。在烟的
例子中，不��用排序的�l�果是，从烟的顶部依然清晰地看到火苗�Q�而��用了排序之后火苗被烟雾模�p�掉了。显然后者更加真实�?br />发射�?br />点发��器从空间中单一点发��粒子。box发射器可以从规则四方体的��M��位置发射�_�子。cylinder定义了一个圆�׃��。ellipsoid定义了一个椭球体。hollow elipsoid只是椭球体的外壳。ring只出�q�面圆环的边发射。被发射�_�子的速度�Q�方向也可以配置。粒子系�l�会被挂到场景结点上�Q�因此发��器与父�l�点有一个相对的位置。粒子通常不会沿直�U�发��，它们在发��器方向的一个锥内发��，有一个angle参数来定义。假如希望沿直线发射�Q�angle应该设�ؓ0,假如希望全方向发��，angle设�ؓ180, 90表示会在方向向量的半球内随机发射�?br />发射率用　�_�子�?�U�　表示。发��器可以按某个发��率发射�Q�也可以使用一个范围内的随机倹{��粒子可
以有固定的生命期�Q�也可以从一个范围随机指定。颜色也一��P��固定��|��随机值都可以。也可以在运动时�Q�以插�g的�Ş式提供定制发��器�Q�这是扩展ogre�_�子�pȝ��最��单的�Ҏ��?br />影响�?br />�_�子一旦被发射��C��界中�Q�媄响器可被用来影响�_�子的运动�\径与生命期�?br />LinearForce:加一个力到粒子上�Q�力是一个向量，有方向与大小�Q�模�Q��?br />ColourFader:用于改变�_�子颜色。表�C�每�U�减��的��|��是一个绝对倹{�?br />ColorFader2:与ColourFader�怼��Q�但是粒子生命到到达其生命期的某个阶�D�|��Q�可以�{换到另一个褪色函数�?br />ColourInterpolator:与上面两个相��|��但是它最多可以有6个阶�D�，分别�Ҏ��个阶�D늚�旉��与颜色进行定义，然后不同阶段之间�q�行插��|��q�与关键帧动�ȝ��思想有点像�?br />Scaler:用来�~�放�_�子��寸�Q�以旉��为函数来定义一个羃攑֛�子�?br />Rotator:通过一�l�随机数量，或是随机速率来旋转粒子的�U�理�Q�这些被定义在某个范围之内�?br />colourImage:从图像中��d��颜色,方向从左到右�Q�适合一�l�纹�?�?br />

清源游民 2007-03-20 18:04 发表评论

《Pro Ogre 3D Programming》读书笔�?�?�W�十�?布告板与�_�子　�W�一部分

清源游民 — Tue, 20 Mar 2007 07:31:00 GMT

清源游民　gameogre@gmail.com

布告�?Billboard)
Ogre中的布告板简单的来讲��是场景中的一个四边�Ş�Q�但它的朝向与相机有兟뀂通常布告杉K��着相机的视方向旋�{以便与相机的视线方向寚w��。把布告板放在场景的��M��地方�Q�它��会朝向相机。�ؓ了效率考虑�Q�布告板与相机的视线方向寚w��Q�而不是与从布告板到相机的向量寚w��。大部分情况下两者没有明昄��区别。如果想使用后一�U�的寚w��形式�Q�也可以办到�Q�但在性能会有所降低�?br />布告杉K��(Billboard Sets)
布告板不能独立存在，他们也不能自我渲染。他们必��d��于某个布告板集。布告板集可认�ؓ是一�l�布告板
的管理器�Q�布告板集内的所有布告板有相同的��寸�Q��用相同的材质。相同的��寸�Q�相同的�U�理会带来计��与渲染效率的提升。可以在一个布告板集内单独改变某个公告板的��寸�Q�但�q�样做会��D��性能下降ogre
认�ؓ一个布告板集是一个操作的单位�Q�它们要么都不渲染，要么全部�q�行渲染�Q�换句话��_��它们以同��L��
方式�q�行剔除处理�Q�也可以寚w��合的个体�q�行单独剔除�Q�但最好不要这么做�Q�同栯��也是��Z��效率的虑。在大范围的应用布告杉K��来模拟草的例子中�Q�就有可能出现在布告杉K��内的许多布告板落在视角之外的情况�Q�在�q�种情况下也�怼�惛_��用单独剔除的方式�Q�但�q�样做同样不可避免地会媄响性能。更好的做法是��用多个布告板集而不是在一个巨大的布告杉K��q�行单独剔除。布告板集内的布告板是相对于布告杉K��attached到的场景�l�点�q�行定位的。既�Ӟ��布告杉K��内的布告板��用相同的材质�Q�那么它们会在同一batch�q�行渲染�?br />布告板创�?br />布告板可以用与本布告杉K��的中心的偏移与尺寸（宽，高）来描�q�。它的方向是它到相机向量的函数。缺省，创徏的布告板是所谓的point布告�ѝ��这�U�布告板��L��完全地面对相��且垂直。布告板的原点缺省位�|�是它的中心�Q�可以在九个规范的位�|�范围内改变原点位置。第二种�c�d��的布告板是oriented布告板，它即可以沿各自的Y轴旋转，也可沿共同的��_��通常是Y��_��旋�{。第三种是perpendicular布告板，它与方向向量�Q�布告板与相��Z��间的向量�Q�垂直。这个方向向量可以是�׃�n的向量（通常是Z��_��Q�也可以是各自的Z轴。这�U�类型的布告板也需要一个上方向辅助定位�?br />point布告板相对于其他�c�d��的布告板有一些优炏V��一般，ogre为每个布告板产生一个quad(四个��点�Q�每�?br />��点都有位置�Q�纹理坐标）�Q��ƈ把生成的几何体送入GPU�q�行渲染。对于point 布告板，可以废除其中的三个，让GPU挑选，以及军_��如何�q�行��Z��点绘制纹理属性的渲染。进行硬件点渲染有一些限�Ӟ��只支�?br />point布告板，其中只限于以中心为原点的那一�c�R��尺�怸�外观在材质中定义�Q�不在布告板集，��寸是有�?br />的，不可能与软�g创徏的一样大。不支持单独的布告板旋�{与改变大��，但可以对�U�理单元旋�{�?br />布告板池
创徏布告板时需要告诉布告板集中布告板的数量。布告板被分别放在active与free列表中，�q��得定位非常快。当创徏的布告板的数量超�q�了布告板池的尺寸，池的��寸会增加一倍。最好事先确定池的大��，避免在��用中使池的大��不合理地增�ѝ�?br />布告板纹理坐�?/font>
支持非全范围的纹理坐标分配。�D个例子，假如你有个纹理，它包含几个子�U�理。每个纹理都包含一�?br />英文字母。这�Ӟ��你想创徏几个公告板，每个公告板上昄��不同的字母，当然它们都来自同一个纹理�?br />可以先创��Z��个包含纹理坐标的数组�Q�然后把�q�个数组提供�l�布告板集。当利用布告杉K��创徏布告板时�Q?br />可以�l�这个布告板一个存攄��理坐标的数组的烦引。图片与代码如下�Q?br />
// create a new billboard set with a pool of 4 billboards
BillboardSet* bbset = sceneMgr->createBillboardSet("BBSet", 4);
// create a texture coordinate array to address the texture
FloatRect texCoordArray[] = {
FloatRect(0.0, 0.0, 0.5, 0.5), // address the "A"
FloatRect(0.5, 0.0, 1.0, 0.5), // address the "B"
FloatRect(0.0, 0.5, 0.5, 1.0), // address the "C"
FloatRect(0.5, 0.5, 1.0, 1.0), // address the "D"
};
// provide this array to the billboard set
bbset->setTextureCoords(texCoordArray, 4);
// now create a billboard to display the "D"; this
// is the fourth entry in the array, index=3
Billboard* bb = bbset->createBillboard(Vector3(0, 0, 0));
bb->setTexcoordIndex(3);
也可以直接对�U�理坐标�q�行赋�?br />FloatRect coords(0.5, 0.5, 1.0, 1.0);
bb->setTexcoordRect(coords);
布告板��用的材质脚本与可以包括正常材质脚本中的所有东西，而且可以使用布告板与点纹理特有的一�?br />指��o与参数�?br />布告杉K��与丝带跟�t�（Ribbon Trails�Q?br />布告杉K��一�l�前后相联结的一�l�布告板�Q�可以联想“老鹰抓小鸡”的游戏中小鸡们的组�l�结构）。ogre
提供了一个ribbon-trail引用�c�，它��用了布告杉K��Q�可以追逐场景中的结点，�q�留下一条尾巴。布告板铑֏�以分多个节，因此可以很好来模拟灯的效果　。布告板铄��~�点是必��L��动更新。可以�ؓ布告杉K��的每个节的尾部添加项�Q�每个节有最大的长度�Q�假如超�q�了那个长度�Q�尾部项被移除，重新做�ؓ节的头�?br />ribbon trail有类似的行�ؓ�Q�从��N��U�除��作为头来增长，从头到尾颜色逐渐褪化。图片与代码如下�Q?br />

void setupTrailLights(void)
{
NameValuePairList pairList;
pairList["numberOfChains"] = "2";
pairList["maxElements"] = "80";
RibbonTrail* trail = static_cast(
mSceneMgr->createMovableObject("1", "RibbonTrail", &pairList));
trail->setMaterialName("Examples/LightRibbonTrail");
trail->setTrailLength(400);
mSceneMgr->getRootSceneNode()->
createChildSceneNode()->attachObject(trail);
// Create nodes for trail to follow
SceneNode* animNode = mSceneMgr->getRootSceneNode()->
createChildSceneNode();
animNode->setPosition(50,30,0);
Animation* anim = mSceneMgr->createAnimation("an1", 14);
anim->setInterpolationMode(Animation::IM_SPLINE);
NodeAnimationTrack* track = anim->createNodeTrack(1, animNode);
TransformKeyFrame* kf = track->createNodeKeyFrame(0);
kf->setTranslate(Vector3(50,30,0));
kf = track->createNodeKeyFrame(2);
kf->setTranslate(Vector3(100, -30, 0));
kf = track->createNodeKeyFrame(4);
kf->setTranslate(Vector3(120, -100, 150));
kf = track->createNodeKeyFrame(6);
kf->setTranslate(Vector3(30, -100, 50));
kf = track->createNodeKeyFrame(8);
kf->setTranslate(Vector3(-50, 30, -50));
kf = track->createNodeKeyFrame(10);
kf->setTranslate(Vector3(-150, -20, -100));
kf = track->createNodeKeyFrame(12);
kf->setTranslate(Vector3(-50, -30, 0));
kf = track->createNodeKeyFrame(14);
kf->setTranslate(Vector3(50,30,0));
AnimationState* animState = mSceneMgr->createAnimationState("an1");
animState->setEnabled(true);
mAnimStateList.push_back(animState);
trail->setInitialColour(0, 1.0, 0.8, 0);
trail->setColourChange(0, 0.5, 0.5, 0.5, 0.5);
trail->setInitialWidth(0, 5);
trail->addNode(animNode);
// Add light
Light* l2 = mSceneMgr->createLight("l2");
l2->setDiffuseColour(trail->getInitialColour(0));
animNode->attachObject(l2);
// Add billboard
BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
bbs->createBillboard(Vector3::ZERO, trail->getInitialColour(0));
bbs->setMaterialName("Examples/Flare");
animNode->attachObject(bbs);

}
首先�Q�RibbonTrail创徏了两个链�Q�每个最多包�?0个元素，��ַ��?00个世界单位。创��Z��一个结点animNoade。�ؓ�q�个�l�点创徏了一个动�?使得�q�个�l�点可以�Ҏ��关键帧的设计在场景中不断变化位置。�ƈ把一个RibbonTrail与这个结点联�l��v来，于是RibbonTrail可与animNode一赯��动。又创徏了一个灯�Q��ƈ联结到这个结点，灯随�l�点也一赯��动，于是怪物头会有明暗变化。最后用一个布告板来�Ş象表�C�刚创徏的灯�Q�因为灯在场景中是不可见的。因为灯被挂到animNode�l�点上，所以布告板bbs也挂到同��L��l�点上。当然别忘了使用了动�ȝ��态来推进动画�?/p>

清源游民 2007-03-20 15:31 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�九�?动画 �W�一部分

清源游民 — Fri, 16 Mar 2007 09:33:00 GMT

清源游民　gameogre@gmail.com
概述
动画�Q��ȝ��来讲�Q�在计算机发展的各个阶段�Q�与艺术家们快速浏览一�p�d��彼此�E�微不同的图片从而��生运动的�q�觉的行为没有什么不同�?872�q�_��Eadweard Muybridge�l�奔跑的马拍了一�l�连�l�的照片�Q�从而证明了马在奔跑时会四脚同时��d��。这是一�p�d��的图片流可以产生�q�动�q�觉的最早的文档化的记录�?br />现在在Ogre中，不必��题大作地装配一些设备来创造这�U�运动��觉了。只需要每帧少量地�U�d��或变形场景中的数据，�q�觉��׃�生了。它��实只是�q�觉。ogre不跟�t�对象的速度�Q�加速度�Q�或是角色的背��是在抬�v
或是叉着腰。ogre逐��来处理位�|�与朝向。ogre能�ؓ你做的是帮你重新播放�q�些动画。这些动��d��以是用离�U�工具制作的�Q�或是运行时产生的，或仅是�ؓ了实现相机�O游而填充了一�p�d��位置的曲�Uѝ�?br />场景的每帧都会被重画�Q�两帧之间没有什么会被保存下来。ogre中的动画仅仅是根据关于�Q意变量（通常
是时��_��的函敎ͼ�来定位与定向角色。每一帧，在ogre动画�pȝ��的控制之下，场景中的实体与动画被�E�稍
�U�d��或��生变形，然后场景被重甅R��这�U��生动�ȝ��方式�Q�与华纳兄弟的动��d��队做卡通动��L��什么同�?br />一行画24个卡通兔�Q�彼此稍微不同，然后�?�U�钟的时间连�l�播放�?br />Ogre中的动画�c�d��
�Ҏ��控制物体的不同方式分��Z��U�：��Z��关键帧的动画�Q�控制器�?br />抽象地来看，ogre中的动画是相关tracks的集合。track是作为时间函数存储的一�l�数据倹{��一对“track值”与"旉��点“，构成了关键��(keyframe)�Q�更好的一�U�说法是�Q�在旉��轴线上对对象全部或部分的位置�Q�朝向，�~�放�Q�进行采栗��根据动�ȝ��c�d��Q�ogre支持好几�U�关键��?关键帧”这个名�U�来源于手工制作动画的时代（像上面提到的制作卡通兔动画�Q�，首席艺术家会�l�他的下�U�提供一�l�关键的帧。这些��l�出了场景中角色的位�|�，然后下��艺术家们�Ҏ��q�些��d��帧之间角色的位置。在ogre中，你就是首席艺术家�Q�需要提供这些关键��Q�ogre是你的下�U�，它帮你完成��之间的过渡�?br />ogre中支持的track有下面这几种�c�d��Q�一个track中的所有关键��必须有一致的�c�d��Q?
NumericAnimaitonTrack(NumericKeyFrame):
关键帧包含一个AnyNumeric�c�d��的标量倹{��Any是ogre中定义的�l�构�Q�和COM中的variant　�c�d��一��P��允许数据�c�d��的多态化。AnyNumeric限定了可能的数据�c�d��只能是数字的(实数�Q�整�?�?br />NodeAnimationTrack(TransformKeyFrame):
关键帧包含两�?�l�向量，一个四元数�Q�分别表�C�结点的位置�Q�羃放与朝向�?br />VertexAnimationTrack(VertexMorphKeyFrame,VertexPoseKeyFrame):
关键帧包含或是引用在一个特定时间点上（在pose 动画中）��点位置和�؜合权�?VertexPoseKeyFrame)�?br />动画状�?br />�E�序与ogre中的动画主要的交互是通过动画状态来完成�?animation state)。在建模工具中，可以为骨骼或��点�|�格沿时间��u�U�定义多个动画，导出时每个动画都可以定义一个名字，通过�q�个名字来定位Entity中同的动甅R��通过动画状态可以访问动�ȝ��许多属性：长度�Q�当前位�|?动画名，是否循环�Q�有否有效，权重�Q�用于�؜合动画）。权重根据�؜合动�ȝ��c�d��q�行不同的处理�?br />混合权��^均：
告诉ogre做这�U��؜合时�Q�所有权重之和�ؓ1。如果不�?�Q�ogre会进行正规化处理�Q��得它们的��d��?。这�U�方式只寚w��骼动��L��效，它也是默认的混合方式�?br />混合权篏�U�：
ogre只是��单地把所有引用权重的效果�q�行累加�Q�不会再�q��。这�U�方式只寚w��点动��L��效（pose, morph),用到骨骼动画时也可以�?br />动画状态也是也�l�动甠Z��加旉��”推动它向前变化的地斏V��基本上��L��l�一个时间增量，意味着从上�ơ调用到现在增长了的旉��。本质上�Q�加一个时间增量与直接讑֮�旉��位置没有什么不同�?br />骨骼动画
骨骼动画是最常用的动�ȝ��型。网�?mesh)中的��点被绑定到骨骼上，如同我们�w�体的肌肉绑定到骨上�?br />不同的是�Q�计��机动画中的“骨头”不是真实存在的。它们用一些（无对应实体）变换来表�C�骨头的位置�Q�朝向与�~�放�Q�经常是用矩阉|��表示。骨骼动�ȝ��关键帧，仅是相对于骨骼恢复位�|�的偏移。它们被�l�合��h��形成了沿着旉��轴线上某一�l�定点的骨骼�?br />Ogre中的骨骼是有层次关系的，如脚骨与胫骨相连�Q�胫骨又与膝盖骨相连。在�q�种层次关系下，除了root外，每个骨头都有父亲。但�q�不限于只有一个root,�q�种层次关系仅仅是用来传递�{�?自上而下)。改变一栚w��头会影响它所有孩子的位置。反向的�q�动ogre不支持：当一个骨头运动时�Q�它不会影响父辈�?br />��点�l�定
��点被绑定到骨骼时会指定一个权重，权重说明了骨头运动对��点的媄响效果。典型的是把一个顶点绑
定到多个骨头�Q�赋于不同的权重。ogre仅支持每��点四个骨头�Q�但每个骨头可以与�Q意多个顶点关联�?br />��点动画
与通过计算动画骨骼�Q�再�Ҏ��骨骼位置计算��点位置的动��L��式不同。顶点动�ȝ��接对��点�q�行动画操作。它是资源密集型的解��x��案，对于每个动画位置都要转送完整的��点数据的拷贝。有时这�U�方式是�l�一的办法，例如实现逼真的面部表情动甅R�?br />��点动画在动画track�q�个层次上被��理、操�U�c��这意味着我们可以对角色的��_��脔R��分��用复杂的pose动画�Q�而角色的剩余部分使用相对��单的morph动画。但是不能对相同的顶点��用不同的动画�c�d��。顶点动��d��引用一�l�顶炚w��Ӟ��要么全部引用�Q�要么一个也不引用。这意味着�Q�在�|�格�U�别上来看，所有的�׃�n几何(shared geometry)构成了顶点动�ȝ��点数据。在子网格��别上来看�Q�所有子�|�格的顶�Ҏ��成了��点动画的顶�Ҏ��据。�D例来�Ԍ��一个子�|�格的某些顶点参与morph动画�Q�而剩余顶点参与pose动画�Q�这�U�情冉|��不允许的�?br />变�Ş动画(Morph Animation)
变�Ş动画是两�U�顶点动��L��术中最��单最直观的一�U�。实际的��点位置做�ؓ"快照"被保存。这与前面说�?br />的卡通兔动画的过�E�是一��L��。这�U�方法比较消耗资源，但是计算效率最高。关键之间数据通过插值得�?br />主要的缺�Ҏ��不能混合多个变�Ş动画�Q�因��Z��们保存的是顶点的�l�对位置。当�Ӟ��如果有两个动画，它们
影响的顶�Ҏ��有交集，那么��实可以对这两个动画�q�行混合�?br />姿势动画(Pose Animation)
模型的各�U�姿势被保存在动画tracks中。这些姿势可以被混合来创建更复杂的动甅R��顶点的位置是相对于
复原位置的偏�U�量�Q�而不是顶点的�l�对位置。而且只有变化的数据才被保存。因此，它不仅更灉|��Q�而且
对资源��用也更高效�?br />pose动画的关键��引用一个或多个pose tracks�Q�每个引用对姿势有一个媄响权重。权重决定了当pose被�؜合时每个��点偏移�Ҏ��l�的��点位置产生多大的媄响。不必在每一帧都引用一个pose。在实践中，pose混合会碰��C��些限�Ӟ��每个附加的pose需要更多的处理旉��?br />混合动画
不能混合pose与morph动画��C��P��也不能�؜合多个morph动画�?br />当�؜合骨骼动��M��点动画�Ӟ��ogre��首先计��?混合��点动画�Q�然后应用骨骼变形到混合��点上�?br />规范的pose与骨骼动��L؜合的�E�序,会�؜合全�w�体的骨骼动��M��复杂的面部表情。例如，可以对角色的面部��点使用pose动画�Q�而角色的剩余部分(包括�?使用相对��单的骨骼动画�?br />混合两个骨骼动画对于动画之间的切换是最有用的。例如角色可能在循环地执�?跑步"�q�个动画�Q�一会儿
他可能要停下来（执行"idle"动画�Q�，那么�q�时需要对两个动画�q�行混合�?br />Morph与骨骼动�ȝ��混合�Q�对于给骨骼动画的角色增�?外皮"�|�格变�Ş是很合适的。例�?��一个衣服动��M��角色实际的骨��D��动动��L؜合，�q�样��避免了对衣服进行实时模拟的高额代�h�?br />��gvs软�g
应用��g加速时最应该��C��的是�Q�硬件动�ȝ��格数据不能被CPU使用。这相当重要�Q�假如你依赖�|�格数据
�q�行别的计算(体积阴媄计算�Q�物理模拟）�Q�一旦顶点变形计��被�U�d��GPU中，��点��永�q�消�׃��Q�不在代码中使用了，假如需要变形之后的��点数据�Q�那么你�q�得用CPU�q�行与GPU同样的计��！�q�确实也可以做到,告诉ogre做吧�Q�　Entity::addSoftwareAnimationRequest()�?br />��g加速的骨骼动画与顶点动��L؜合，会在��点�E�序中执行�؜合。假如你刚才�q�没有注意到上面曄��提到
�q�的执行��序的话�Q�现在又有机会让你意识到�q�点�Q�先��点�Q�然后骨骹{��这同样也意味着�Q�所有的动画技术都应该是基于硬件加速的�Q�不能让��g加速的骨骼动画与基于��Y件的��点动画混合�?br />使用GPU加�?font color="#ff1493">骨骼动画�Ӟ��应该考虑刎ͼ�骨骼动画��法的本质上要求�Q�在计算每个��点�Ӟ��骨架中所有骨头的数据必须都被提供。老旧的硬件仅仅支�?4　bones或更��的skinning通道。这时应把mesh分�ؓ几段�Q�在多个通道中skin它们。ogre只会把submesh引用到的bones发送到skinning shader,而不是骨��g��所有的bones,�q��得多个skinnig pass成�ؓ可能�?br />在CPU中对morph动画��点�q�行插值的主要优点是利用了GPU�q�行计算的本质。morph计算��h��也不复杂�Q?br />主要的输入是两个��点位置与一个插值因子，��点�E�序产生插值后的顶点位�|�做��出�?br />pose动画与morph�c�M��Q�而且有与骨骼动画�c�M��的限�Ӟ��它提供给�E�序的pose数目如何�q�行传递�?br />标签�?br />标签本��n不是动画的一部分�Q�但它们常被用于联结��L��对象�Q�例如武器）到存在的动画模型上。标�{��
的概忉|��较简单：它是骨架中一块特�D�的骨头�Q�它能在�q�行�Ӟ��控制�l�定对象的位�|�与朝向。不必事�?br />创徏标签点，可以在运动期attched一个可�U�d��对象到骨架中一个命名的骨头上。Entity有这样一个方法：
attachObjectToBone();一旦物体被�l�到骨头上，它就会随着标签点移动。需要知道的是，对象�q�不是真�?br />地被attched到标�{��上。它被attched到用那个骨骼的Entity上�?br />动画与控制器
两者都是基于一个一�l�的变量来控制对象的状态，把变量输入一个函��C�生输出。对于动��L��_��输入变量是时��_��而对于控制器来说�Q�输入变量是��M��你想要的东西�?br />动画的特点：
通过插值函数计��给定时间点上track值来产生输出�Q�从而改变顶点位�|��?br />动画被认为是个封闭的�pȝ��Q�你讄��输入��|��ogre 使用它来更新相关对象的属性�?br />插值函数较为固定：要么�U��|��要么三次��h��插倹{�?br />动画有ogre提供的许多工��L��支持�?br />控制器的特点�Q?br />对于输出的计��更为灵�z�，工作函数需要提供，因此有更多选择�?br />控制器可以�Ş成一个链�Q�一个输出可作�ؓ另一个输入�?br />控制器自�׃��U�d��M��东西�Q�对于输出可以不做�Q何事情。ogre用控制器来驱动纹理动甅R�?br />控制器自动逐��更新�Q�然而必��L��工添加代码��每��的动��d��前变化�?img src ="http://m.shnenglu.com/yuanyajie/aggbug/19974.html" width = "1" height = "1" />

清源游民 2007-03-16 17:33 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�八�?渲染对象

清源游民 — Thu, 15 Mar 2007 09:25:00 GMT

清源游民　gameogre@gmail.com

OGRE渲染对象
Ogre中的render target 只是�׃�nAGP内存或显存的某个区域的抽象，�q�个区域中保存着全部或部分场�?D渲染�l�果。最普通的render target是主渲染�H�口�Q�这是应用程序的�ȝ��口。��用这个render target不需要做太多另外的努力，ogre可以帮我们创建它。还可以把场景中的全部或部分�Q�甚��x��场景中不可见的部分）渲染��C��个纹理，�q�个�U�理可以被场景中的其他多边�Ş使用。目标硬件缓冲在ogre中抽象�ؓrender target,它的物理昄��可以��Z��渲染�H�口�Q�也可以是副�H�口�Q�也可以是非可视的：�U�理�?br />渲染对象也是事�g源，假如�E�序注册了这事�g�Q�ogre会在pre- �?postrender旉��知�E�序�Q�这�l�程序改变设�|�，做出响应的机会。甚臛_��视口(viewport)�U�别上pre-,post- 渲染时也有上�q�通知机制。ogre提供了计��渲染状态信息的功能,如多长时间渲染一帧，渲染对象上有多少三角形等�?br />渲染�H�口
�H�口是由渲染�pȝ��的具体实现创��Z��l�护的（D3D9下是个标准的Win32 Window)。Ogre允许�Ҏ��染窗口进行很��的配置�Q�限于尺寸，标题栏文字等。假如希望开发的�E�序有菜单，工具栏等�Q�把ogre的渲染输出到
�H�口的客户区�Q�这是可能的。ogre可以提供你系�l�相关的�H�口句柄�l�渲染窗口，也允�怽�提供句柄�l�父�H�口。第一个创建的ogre渲染�H�口�U�Cؓ�ȝ��口。另外创建的是副�H�口。窗口不像主�H�口那么重要。假如在�E�序中有三个�H�口�Q�那么�ؓ了正��的�q�行资源清理�Q�必��d��销毁主�H�口前把另外两个副窗口销毁�?br />视口
渲染�H�口包含一个或多个视口。视口是一个长方�Ş区域�Q�场景管理器把从一个相��Z��看到的场景可见内�?br />的透视图渲染到�q�个区域中。视口创建时会引用一个相机，但这不是视口的静态属性，可以随时改变用于
渲染视口的相机。每个视口拥有一个z序数�Q�z序高的位于Z序低之上。z�?�Q��L��被一个能覆盖整个渲染对象的视口所拥有。缺省，ogre会清理视口的颜色与深度缓册Ӏ�然而，可以关闭�q�些�~�冲清理。视口是渲染对象�Q�也��是特定的渲染系�l�，如OpenGL)与相机（也就是特定场景管理器与它的内容）之间的唯一交互炏V��视口不必占用整个渲染对象的表面�?D渲染相机不是真正的相机，所有的几何LoD计算是以相机的位�|�算的，因此不能��单的改变相机的焦点属性来辑ֈ�“更�q�”的渲染效果�?br />渲染到纹�?br />使用步骤是：创徏一个纹理渲染对象，配置它的渲染属性，加纹理到渲染对象列表�Q�设�|�纹理到被��用的材质。纹理对象先于其他渲染对象类型更斎ͼ��q�就保证了��用了渲染�U�理的对象正��地被渲染。渲染纹理可以像其他普通纹理一栯��处理。对于那些不需要每帧都更新的渲染纹理，可以关闭自动逐��更新而采用手动更新。从底层看，�U�理对象��是一块硬件缓册Ӏ��ؓ了性能考虑�Q�认为它们是只写与静态的。渲染到�U�理会渲染场景中的几何，需要一些时间执行，会降低应用程序��率。但是很多有用的技术现在离不开渲染到纹理的使用。实旉��影，实时反射�{�。ogre支持渲染到多个纹理，唯一的限制是它们��具有相同的寸�?br />渲染对象�c?br />RenderTarget是RenderWindow,MultiRenderTarget,与RenderTexture的基�c�R�?br />RenderWindow通过子类化来实现�Q�D3D9RenderWindow,GLXWindow�{�。在windows操作�pȝ��中，�׃��可以使用Direct3D 9或是OpenGL,于是可以分别使用D3D9RenderWindow�Q�Win32Window�?br />RenderSystem::createRenderWindow()来创建窗口�?br />virtual RenderWindow* Ogre::RenderSystem::createRenderWindow ( const String & name,
unsigned int width,
unsigned int height,
bool fullScreen,
const NameValuePairList * miscParams = 0
)
通过最后一个参敎ͼ�可以讄��H�口的一些属性�?br />��渲染窗口嵌入外部窗口的代码
NameValuePairList params; // is just a typedef std::map
// set external window handle -- assume that you have
// already created a window to embed the Ogre render window, and its handle is
// stored in an integer variable called "mParent"
params["externalWindowHandle"] = StringConverter::toString(mParent);
// window can be resized later to fit within parent client area if needed
RenderWindow* window = createRenderWindow("MyWindow", 800, 600, false, ¶ms);
渲染到纹理Demo
demo在原点创��Z��一个倾斜的��^面，讄��相机�Q�把场景�Q�场景由一个魔��D��袋与几个环面�U�结�l�成�Q?br />相对于��^面的倒媄渲染到纹理中。渲染纹理与�q�面已经应用的静态纹理�؜合，�q�样��实��C��反射效果�?br />创徏渲染�U�理:
TexturePtr texture = TextureManager::getSingleton().createManual( "RttTex",
                               ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D,
                              512, 512, 0, PF_R8G8B8, TU_RENDERTARGET );
创徏相机与视口用于渲染到�U�理:
           mReflectCam = mSceneMgr->createCamera("ReflectCam");
            mReflectCam->setNearClipDistance(mCamera->getNearClipDistance());
            mReflectCam->setFarClipDistance(mCamera->getFarClipDistance());
            mReflectCam->setAspectRatio(
                (Real)mWindow->getViewport(0)->getActualWidth() /
                (Real)mWindow->getViewport(0)->getActualHeight());
            Viewport *v = rttTex->addViewport( mReflectCam );
            v->setClearEveryFrame( true );
            v->setBackgroundColour( ColourValue::Black );
创徏使用渲染�U�理的材�?/font>�Q?/font>
MaterialPtr mat = MaterialManager::getSingleton().create("RttMat",
                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
            TextureUnitState* t = mat->getTechnique(0)->getPass(0)->createTextureUnitState("RustedMetal.jpg");
            t = mat->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex");
            // Blend with base texture
            t->setColourOperationEx(LBX_BLEND_MANUAL, LBS_TEXTURE, LBS_CURRENT, ColourValue::White,
                ColourValue::White, 0.25);
            t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
            t->setProjectiveTexturing(true, mReflectCam);
            rttTex->addListener(this);
材质名�ؓRttMat,包含一个技术，后者有一个通道。通道有两个纹理单�?一个�ؓ静态纹�?RustedMetal.jpg)
,另一个纹理单元�ؓ渲染�U�理,两个�U�理按比例�؜合。设�|�了合适的�U�理��d��模式�Q�开启了透视�U�理支持�?br />�q��ؓ渲染�U�理�Q�它是渲染对象）注册了侦听器�?br />相机倒置使用材质:
            // set up linked reflection
            mReflectCam->enableReflection(mPlane);
            // Also clip
            mReflectCam->enableCustomNearClipPlane(mPlane);
        }
           // Give the plane a texture
         mPlaneEnt->setMaterialName("RttMat");
相机�q�样讄��后，渲染出的��是场景的倒媄�Q�这是以指定�q�面为参照的。定制最�q�裁剪��^面的作用是：
那些低于反射面的对象��不会再被渲染。渲染纹理时�Q��ƈ不想把��^面也渲染�q�去�Q�可以在上边已经注册
侦听器做�Ҏ��?/font>�Q?br />void preRenderTargetUpdate(const RenderTargetEvent& evt)
    {
        // Hide plane
        mPlaneEnt->setVisible(false);

    }
    void postRenderTargetUpdate(const RenderTargetEvent& evt)
    {
        // Show plane
        mPlaneEnt->setVisible(true);
    }
最后要提的是，在每一帧，都要使两个相机的位置�Q�朝向保持一�?
frameStarted:
mReflectCam->setOrientation(mCamera->getOrientation());
mReflectCam->setPosition(mCamera->getPosition());

清源游民 2007-03-15 17:25 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�七�?资源��理 �W�一部分

清源游民 — Wed, 14 Mar 2007 09:09:00 GMT

清源游民　　gameogre@gmail.com

资源�l?/font>
命名�l�可以作��Z��个整体加载与卸蝲。在加蝲�Q�卸载，初始化时把把�l�中的所有资源作��Z��个执行单位来
看待�Q�而不是逐个�q�行处理。资源组��理�U��a是了��Z��理上的方便�Q�是否��用组的方式与性能无关。假
如向资源�l�管理器中加入了资源位置而没有指定组名，那么�q�些资源位置被放�?General"�l�中�?br />资源�l�与世界几何
�~�省情况下，ogre把加载的世界几何攑օ�"General"�l�。也可以覆盖(override)�q�种方式�Q��得对世界几何的管理像其他资源的管理方式一栗��统一的场景管理器可以提供关于装蝲世界��L��骤的�U�烦�Q�这样就可以在关卡加载时�Q�提供精��的以进度条昄��的反馈信息�?br />资源位置(location)
资源位置是ogre��L��找资源进行烦引的地方。烦引指的是在某个位�|�的所有资源通过它们的名字被映射�Q�这样可以方便进行更快的查找资源。可以在�E�序的�Q何时候添加或删除资源位置,不必事先�Ҏ��以可能用到的�q�行定义。资源位�|�在ogre中实际上是个archive,它的意思就是“文件的集合”。磁盘上的文件系�l�是
archive的一�U�类型。另外一�U�是zip archive。可以自定义archive格式。这通过改写archive�c�d��现来完成,必须支持对命名的leaf文�g�q�行枚�D操作�Q�必��L��持通配�W�，支持�l�点递归�Q�给ogre提供一个流讉K��archive中文件的数据。ogre中的archive是只�ȝ��。ogre资源��理器利用archive枚�D�Ҏ��来索引archive的内容，当ogre对archive�q�行索引�Ӟ��不会实际加蝲��M��资源�?br />资源生命周期
资源有四�U�状�?各状态之间的转换关系如下图：

Undefined:�q�是�E�序开始时�Q�所有资源的�~�省状态。除非它们被声明�Q�ogre对程序用到的资源一无所知，手工调用代码 ResourceGroupManager::declareResource()或在脚本中被解析之后�Q�资源的状态变为Declared
Declared:声明��是告诉ogre惌��加蝲某些资源。ResourceGroupManager::declareResource()��L��有效的，包括在渲染系�l�初始之前，�q�与ResourceManager::create()不同�Q�因为后者依赖于渲染�pȝ��?br />Unloaded:通过调用ResourceGroupManager::initialiseAllResourceGroup(), ResourceGroupManager::
initialiseResourceGroup(),或Root::initialise()(它会初始化在此调用之前所有声明的资源)�Q�资源状态进入到Unloaded,资源会占用一点内存来保存它的定义的实例，但是资源本��n�q�没有加载到内存。从另一角度�?从Loaded到Unloaded),引�v状态变化的调用有：ResourceManager::unload(),ResourceManager::unloadAll(), ResourceManager::unloadAllUnreferencedResources(),ResourceGroupManager::unloadResourceGroup(), or Resource::unload().所有这些调用仍会保存资源实例，但真正的资源数据会从内存中卸载�?br />Loaded: �q�种状态下�Q�所有数据都变得有效。与此状态有关的调用有Resource::load(), Resource::reload(),
ResourceManager::load(), ResourceManager::reload(), ResourceManager::reloadAll(),
ResourceManager::reloadAllUnreferencedResources(), and ResourceGroupManager::
loadResourceGroup().
逻辑资源��理
资源以命名组的�Ş式组�l�，每组可以包括��M��c�d��的资源，每种资源都有自己的资源管理器�Q�后者负责加载与卸蝲特定�c�d��的资源。ogre对它的资源没有实现特定的内存��理�Ҏ��Q�如果你需要对某种资源实“最�q�最��用算法”方案来�q�行��理�Q�那么需要自��q��代码来实现。值的一提的是，现在的大多数昑֍�驱动�Q�对于大多数重要的资源已�l�实��C��q�种LRU��法��理�?br />资源加蝲
假如没有预加载，当资源被讉K��时会�q�行加蝲。实际的加蝲�Q�卸载是资源自己的责仅R�?br />手动加蝲资源
资源��理层不负责实际的加载与卸蝲。通常�Q�不必担心资源是否存在于易失性媒介。然而，手工方式旉��要考虑。手工资源加载器必须在�Q何时候准备好重新加蝲资源。假如某个资源是通过�E�序生成的，那么手工资源加蝲器必��d��存中�~�冲�q�些资源�Q�或者是当资源管理加载时重新创徏它。ogre认�ؓ手工加蝲与自动加载没有区别�?br />后台资源��理
�~�省�Q�ogre不是�U�程安全的。假如在OgreConfig.h�?#define OGRE_THREAD_SUPPORT 1 ,那么资源��理
代码的线�E�同步功能变得有效，我们��可以在包含Root实例的线�E�之外，开启新的线�E�对资源��理�c�M��Ҏ��q�行操作,从而实现灵�zȝ��资源加蝲�Ҏ��。　
非后台资源管�?br />Ogre中大量��用了Observer模式,资源��理�pȝ��也不例外。ResourceGroupListene 回调接口包含了几个方�?br />允许对资源加载过�E�进行细�_�度的监听�?br />资源卸蝲
资源被加载后��d��在于内存中，直到被应用程序强行卸�?通过资源�l�管理器或是被资源直接释�?。资源管理组��理会把�l�中所有的资源都卸载掉。在资源被引用时不能��卸蝲�?br />Resource Locations
// 配置文�g方式
ConfigFile cf;
cf.load("resources.cfg");
// Go through all sections & 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);
}
}
//��编码方�?br />ResourceGroupManager *rgm = ResourceGroupManager::getSingletonPtr();
rgm->addResourceLocation("../../media/packs/OgreCore.zip", "Zip", "Bootstrap");
rgm->addResourceLocation("../../media", "FileSystem", "General");
rgm->addResourceLocation("../../media/fonts", "FileSystem", "General");

初始�?/font>
在初始化之前�Q�必��d��一个渲染窗口。因为在分析脚本时可能会创徏GPU资源�Q�而后者需要渲�?br />上下文�?br />// initialize all of the previously defined resource groups
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// or, alternately, initialize the defined resource groups one at a time
ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
ResourceGroupManager::getSingleton().initialiseResourceGroup("Bootstrap");
卸蝲
可以在�Q何时候卸载资源（以组或单个的方式�Q?正在使用的资源不会被卸蝲�?br />以组的方式卸�?/font>
ResourceGroupManager::getSingleton().unloadResourceGroup("Bootstrap", true);
ResourceGroupManager::getSingleton().
unloadUnreferencedResourcesInGroup("Bootstrap", true);
true表示只卸载资源数据，不删除资源实例，它可以被reloaded。有些资源在创徏时被标�ؓ
"nonreloadable",�q�种�c�d��的资源不能��用上�q�方法卸载�?br />清理或销毁资源组
清理仅是卸蝲资源与分��资源烦引，销毁不仅做清理的工作，�q�包括从资源�l�中把自��q��除�?br />ResourceGroupManager::geSingleton().clearResourceGroup("Bootstrap");
ResourceGroupManager::geSingleton().destroyResourceGroup("Bootstrap");
以个体方式卸�?/font>
// assume that pEntity is a valid pointer to an instance of Entity
MeshPtr meshPtr = pEntity->getMesh();
meshPtr->unload();
加蝲/重蝲资源�l?/font>
ResourceGroupManager::getSingleton().loadResourceGroup("Bootstrap", false, true)
二个布尔变量不同资源�c�d��资源加蝲开养I��一针对"Normal"资源�Q�二针对"World geometry"
资源�l�加载通知
class LoadingProgressListener : public ResourceGroupListener
{
   public:
        // fired when a group begins parsing scripts
                void resourceGroupScriptingStarted(const String& groupName,
                                                                        size_t scriptCount) {}
       // fired when a script is about to be parsed
               void scriptParseStarted(const String& scriptName) {}
       // fired when the script has been parsed
               void scriptParseEnded() {}
     // fired when all scripts in the group have been parsed
              void resourceGroupScriptingEnded(const String& groupName) {}
      //�q�有一些接�?br />}
//实现之后�Q�进行注�?br />LoadingProgressListener listener(m_progressMeter);
ResourceGroupManager::getSingleton().addResourceGroupListener(&listener);

清源游民 2007-03-14 17:09 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�六�?材质　材质复制

清源游民 — Tue, 13 Mar 2007 07:57:00 GMT

清源游民　gameogre@gmail.com

材质复制
如果新的脚本只是�Ҏ��个已�l�存在的脚本�q�行��部分的变化�Q�那么可�q�行从旧脚本复制�Q�而不是C�Q�P。新材质可以修改特定technique,pass,texture,或是��d��新项�?br />格式: material :
当材质脚本被加蝲到ogre中，�q�种�l�承关系不再�l�系�Q�假如父材质在运行时被修改，不会影响到子材质。如果在一个technique中有5个pass,而我们只想修改第5个pass,我们可以用pass指定或是它的索引(�?计）
meterial test2: test1
{
technique 0
    {
      pass 4
        {
          ambient 0.5 0.7 0.3 1.0
        }
    }
}
加入一个新的technique或pass到material中，可以通过赋于它们新的名称来实玎ͼ�新名�U�必��d��父材质中没有出现�q�。指定新索引也一栗��新technique或pass会被加蝲到父材质相应technique或pass末尾.
material BumpMap2 : BumpMap1
{
technique ati8500
{
    pass 0
    {
      texture_unit NormalMap
      {
        texture BumpyMetalNM.png
      }
    }
}
}
在上面的例子中，如果texture_unit的名�U�NormalMap在父材质中指定过�Q�那么现在的行�ؓ表示override,如果它是一个新的名字，那么表示在pass的最后新加一个texture unit。　

�U�理别名

在源材质被clone�Ӟ��每个texture unit可以被赋于一个Texture alias(别名�Q�。可以用�q�个别名来指定��用什么纹理。格式： texture_alias �~�省�Q?texutre_unit ( �U�理单元的名�?
texture_unit DiffuseTex
{
texture diffuse.jpg
}
在这�U�情况下�Q�texture_alias为DiffuseTex.
material TSNormalSpecMapping
{
technique GLSL
{
    pass
    {
      texture_unit NormalMap
      {
        texture defaultNM.png
        tex_coord_set 0
        filtering trilinear
      }

       texture_unit DiffuseMap
      {
        texture defaultDiff.png
        filtering trilinear
        tex_coord_set 1
      }

        texture_unit SpecMap
      {
        texture defaultSpec.png
        filtering trilinear
        tex_coord_set 2
      }
    }
}

technique HLSL_DX9
{
    pass
    {
        texture_unit
      {
        texture_alias NormalMap
        texture defaultNM.png
        tex_coord_set 0
        filtering trilinear
      }

      texture_unit
      {
        texture_alias DiffuseMap
        texture defaultDiff.png
        filtering trilinear
        tex_coord_set 1
      }

      texture_unit
      {
        texture_alias SpecMap
        texture defaultSpec.png
        filtering trilinear
        tex_coord_set 2
      }
    }
}
}
例子中有两个技术，都��用相同的�U�理,�W�一个技术��用缺省的方式定义了纹理别名，�W�二个技术显式地指定�U�理别名。两者都有相对应的同��L��U�理别名。如果想定义一个材质只是想使用不同的纹�?那么copy父材质时可以使用set_texture_alias来重新指定新�U�理�?br />material fxTest : TSNormalSpecMapping
{
set_texture_alias NormalMap fxTestNMap.png
set_texture_alias DiffuseMap fxTestDiff.png
set_texture_alias SpecMap fxTestMap.png
}
上面代码��对拥有指定别名的texture unit所使用的纹理图片进行了重新指定�?br />

清源游民 2007-03-13 15:57 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�六�?材质　概念

清源游民 — Tue, 13 Mar 2007 03:31:00 GMT

基本对象着�?br />材质�Q�简单的来讲��是定义了被赋于此材质的对象如何反射光。ogre中的光照采用局部光照模型，�q�意味着�Q�对计算有媄响的因素有：光照的角度与光的颜色�Q�相机的视角�Q�对象的材质。ogre支持四种�c�d��用来描述材质的颜�?表述了光照对它的影响�Q�环境光�Q��O反射�Q�发散，镜面反射。环境光是对全局光照的近��|��漫反��是指当物体被光照射后在物体各方向上反射的光的颜艌Ӏ�发散指物体本��n自发光的颜色。镜面反��，指的是在某个视角看到的被光反��出的“高光”。镜面高光有两个参数可以控power,shininess.power用来控制“加亮点”的��寸(影响的范围越�?。而shininess��D��大的表面�Q�高光越�Ҏ��聚集�?br />�U�理映射
通过�U�理坐标�Q�用一�?D囄��l?D对象着色的技术�?br />可编�E�着�?/font>
通过写高�U�或低��的顶点程序，片段�E�序代替固定��线的功能。支持可�~�程囑�Ş��g也可以当做固定函数流水线��g来用。可�~�程��g允许更灵�zȝ��计算��点的的颜色�Q�位�|�等。纹理也可用于可�~�程��g。纹理中包含的数据，不仅仅可以表�C�颜�Ԍ��也可以表�C�Z�Q何其他程序员知道如何处理的数据�?br />Batching
材质与mesh之间的关�p�L��带来的最大媄响是渲染状态的改变。ogre中的渲染单元大多数情况下指的是renderable,它是SubEntity的父�c�R��渲染单元这个概�늚�重要性在于，正是在这里，ogre��调用显卡驱动开始�ƈ且会�l�束“画操作”。一�ơ画操作�Q�batch),指的是清除颜料（color,texture,etc)与材料（vertexof display lists)�Q�从头开始一�l�新的操作的�q�程。就像一个画家每�ơ在��L��上做��L��会洗净他的调色板一栗��对�?D��g来讲�Q�这个过�E�包括发送新的顶点列表与数据索引到GPU(或者引用还存在的）�Q�用�U�理�Q�颜�Ԍ��以及光栅化这些顶点组成的面需要的一些元数据来设�|�GPU。因此，最有效率的做法是一�ơ尽可能多的�?br />使用同样渲染数据的顶点发送到GPU�q�行处理。ogre会尽量减��状态改变带来的影响�Q�但它遵重你如何构成一个renderable的决定。假如你有一个模型它�?0个块�l�成�Q�它们都使用相同的材质，�q�时应该把他们整合到相同的renderable中去�Q�而不是分20�ơbatch发送到昑֍�。每帧的batch��C��有个上限�?br />材质克隆
ogre中的材质是共享的。当你从材质��理器获得一个指针，它与从��用这�U�材质的其他对象所拥有的材�?br />指针是相同的。因此改变一处会影响其他�Q��ؓ了避免媄响其他应该克隆材质�?br />Technique & Scheme
Technique允许针对不同的硬件��^台定制不同的材质。Scheme允许对特定一�l�技术进行更一般化的描�q�。Ogre选择技术时有明��的��序。首先，它寻扑ֱ�于某个命名Scheme中的技术。然后在选好的scheme中查��N��些应用了特定材质lod的技术。最后在�q�些技术列表中�Q�选择最能适应当前��g讄��的技术。缺省，所有的技术属于细节��?,它对应最高细节��别�?br />Material LoD
层次�l�节�q�个术语常用来讨论随场景中的物体的几何复杂性是相机与物体之间距��ȝ��函数。类似的概念被应用到材质定义上。ogre提供了在哪个层次�l�节上��用特定技术的手段。可以在材质中定义层�ơ细节发生变化时的距��，赋于材质中的每个技术一个细节烦引。每个细节烦引也可以有多个技术，用来支持scheme或是��g能力fallback�?br />材质�l�成
一个materail�׃��个或多个technique�l�成�Q�后者又�׃��个或多个pass�l�成�Q�一个时��d��有一个technique是活动的。pass对于在GPU上执行画操作的renderable来讲�Q�是完整的原子渲染状态。假如选择的技术有三pass�Q�那么每帧会对renderable�q�行三次��L��作。pass可以引用�U�理单元定义�Q�而不必包含�Q何纹理单元定义�?br />�U�理单元
ogre materail中的�U�理单元实际引用GPU上的texture sampler.多数��C��囑�Ş��g有多个texture sampler,
ogre支持的硬件至��有一个有效的texture sampler。纹理单元包括一个纹理的引用�Q�可以来自一个磁盘文�Ӟ��或是�q�行时渲染，或是来自外部视频��。可以在每个pass中指定多个纹理单元。ogre会检��硬件支持的能力�Q�必要时把一个pass折分成多个pass。�D例来��_��假设pass中指�?个纹理单元，而硬件只支持4个，那么ogre会把�q�个pass拆分成两个，对这两个pass执行�U�理混合以达到相同的设计功能。纹理通常保存在video memory中，直到它们不再需要。ogre不会每次需要时都通过�ȝ��传输�U�理�Q�除非纹理经常地�?br />video memory中剔除。（�q�时发生了纹理震荡，原因是有太多或太大的�U�理同时存在于vedio memory中）�?br />�U�理压羃
��C��囑�Ş��g支持压羃�U�理。ogre只是��单地把纹理按原样传送他们到囑�Ş��g中去�Q�它不会压羃�U�理�?br />对于那些压羃�q�的�U�理�Q�也不必事先处理它，如果��g不支持压�~�纹理，ogre会在�q�行时解压羃�?br />实体
在渲染期��_��Entity主要作�ؓsubentities的容器来用，subentities是实际的渲染单元�Q�renderable�Q��?br />subentity与submesh有一一对应的关�p�，后者提供原始的材质引用。概念上来讲�Q�entity(subentity)提供了对象的渲染属性，而mesh(submesh)提供了对象的�l�构属性�?img src ="http://m.shnenglu.com/yuanyajie/aggbug/19703.html" width = "1" height = "1" />

清源游民 2007-03-13 11:31 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理　场景查询

清源游民 — Sun, 11 Mar 2007 09:24:00 GMT

场景查询
创徏查询的代��h��较大�Q�而执行不是。SceneQueryResualt只定义了两种成员�Q�movables与worldFragments.
掩码也需要自己定义，自己解释。在一个��u寚w��盒子中查询灯光的例子如下�Q?br />const unsigned int LIGHT_QUERY_MASK = 0x00000001;　//掩码定义
Light* light1 = mSceneMgr->createLight("Light1");
Light* light2 = mSceneMgr->createLight("Light2");
light1->setPosition(12, 12, 12);
light2->setPosition(5, 5, 5);
light1->setQueryFlags(LIGHT_QUERY_MASK);
light2->setQueryFlags(LIGHT_QUERY_MASK);
AxisAlignedBoxSceneQuery* lightQuery =
mSceneMgr->createAABBQuery(
AxisAlignedBox(0, 0, 0, 10, 10, 10), LIGHT_QUERY_MASK);
// sometime later in the application's code, find out what lights are in the box
SceneQueryResult& results = lightQuery->execute(); //查询
// iterate through the list of items returned; there should only be one, and it
// should be light2 created above. The list iterator is MovableObject type.
SceneQueryResultMovableList::iterator it = results.movables.begin();
for (; it != results.movables.end(); it++)
{
// act only on the lights, which should be all we have
assert ((*it)->getQueryFlags() & LIGHT_QUERY_MASK) != 0);
// do whatever it was we needed to do with the lights
}
// destroy the query when we are done with it
mSceneMgr->destroyQuery(lightQuery);

我们知道地�Ş��L��起伏不��^的，当主角在上面行走旉��要根据地形的高度调整�Q�可以光�U�查询来实现�?br />原理比较��单：向主角脚下执行光�U�查询，与地形有一个交点，�Ҏ��交点的高度调整主角位�|��?br />Terrain Clamping
void Entity::clampToTerrain() {
static Ogre::Ray updateRay;
updateRay.setOrigin(m_controlledNode->getPosition() + Ogre::Vector3(0, 15, 0));
updateRay.setDirection(Ogre::Vector3::NEGATIVE_UNIT_Y);
m_raySceneQuery->setRay(updateRay);
Ogre::RaySceneQueryResult& qryResult = m_raySceneQuery->execute();
if (qryResult.size() == 0) {
// then we are under the terrain and need to pop above it
updateRay.setOrigin(m_controlledNode->getPosition());
updateRay.setDirection(Ogre::Vector3::UNIT_Y);
m_raySceneQuery->setRay(updateRay);
}
qryResult = m_raySceneQuery->execute();
Ogre::RaySceneQueryResult::iterator i = qryResult.begin();
if (i != qryResult.end() && i->worldFragment)
{
Ogre::SceneQuery::WorldFragment* wf = i->worldFragment;
m_controlledNode->setPosition(m_controlledNode->getPosition().x,
i->worldFragment->singleIntersection.y,
m_controlledNode->getPosition().z);
}
}
void Entity::init()
{
// lots of other irrelevant entity init stuff goes here
m_raySceneQuery = sm->createRayQuery(
Ogre::Ray(m_controlledNode->getPosition(),
Ogre::Vector3::NEGATIVE_UNIT_Y));
// move this node is such a way that it is above the terrain
clampToTerrain();
}

清源游民 2007-03-11 17:24 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理　地�Ş

清源游民 — Fri, 09 Mar 2007 09:25:00 GMT

Ogre中的地�Ş

使用terrain.cfg
WorldTexture=terrain_texture.jpg //地�Ş�U�理
DetailTexture=terrain_detail.jpg //�l�节�U�理
DetailTile=3                      //�l�节�U�理在一个地形小块中的��^铺数
PageSource=Heightmap              //高度图数据源
Heightmap.image=terrain.png       //高度囑֐��U?�W�合2^n+1
PageSize=513                      //高度囑֤��?br />TileSize=65                       //地�Ş��块大小
MaxPixelError=3                   //军_��使用层次�l�节时充许误�?br />PageWorldX=1500                   //地�Ş在世界中的范围x方向
PageWorldZ=1500                   //z方向
MaxHeight=100                     //世界中地形最大映��高�?br />MaxMipMapLevel=5                  //层次�l�节上限
#VertexNormals=yes                //在缓冲中计算��点法线�Q�计��机光照或GPU�E�序用到时打开
#VertexColors=yes　　　　　　　　 //在缓冲中讄��点颜色�Q�假如有GPU�E�序需要时打开
#UseTriStrips=yes                 //对于现在的硬�Ӟ��x��
VertexProgramMorph=yes　　　      //使用��点�E�序�q�行LOD融合处理
LODMorphStart=0.2                 //LOD融合开始点�Q�高�Q�低LOD之间距离之比

下列参数用于提供自己的着色程序时使用�Q�这会提供自己定义的material�Q�那么先前定义的
WorldTexture �?DetailTexture的设�|�不再用刎ͼ�多余的了�?/p>

MorphLODFactorParamName=morphFactor　
//假设VertexProgramMorph被设为yes,定制的material中包括一个高�U�顶点程序。它指定了一个顶�?br />//�E�序的参数名�Q�这个参数用于融合LOD,参数��g��0�Q?�Q?表示不调��_��1表示完全调整��C��一�U�LOD
MorphLODFactorParamIndex //用于materail中包含低�U�顶点程序的情况�Q�意义同�?br />CustomMaterialName //指定的materail名字

上述配置文�g定义了基于高度图的地形。这些参数定义可概括��Z��c�：Ogre使用�W�一�c�M��高度图��生地�?br />mesh与材质。第二类是定制材质与GPU��点�E�序�Q�这可以代替ogre自动产生的着色程序�?br />另外的说明：
TerrainScenceManager会把高度囑ֈ�为向个pages,每个page由几个tiles�l�成.而它们也不过是个方便的名字，
它们都定义了在��生的mesh中一�l�构成正方�Ş的顶炚w��?br />WorldTexture定义的纹理不必与目标地�Ş一样大�?br />PageWorldX�Q�PageWorldZ可以�~�放世界中的地�Ş�?br />MaxHeight 在Y方向�~�放地�Ş�?br />DetailTexture 只��用一个纹理，如��用多层纹理，应该使用自定义materail�?br />
从程序加载地�?/font>
setWorldGeometry()有重载�Ş式，一�U�用于加载配�|�文�Ӟ��另一�U�我们可在程序中使用�Q�以
辑ֈ�手工加蝲的功能。这里，SceneData�?typedef 为std:map,它存储了如我们在terrain.cfg
中看到那些值对。假设我们已�l�从某个二进制文件读入我们想要的内容到SceneData中。我们要�?br />的就是把��d��的内容�{换成setWorldGeometry()需要的�c�d��。先看一下函数原型：
Ogre::SceneManager::setWorldGeometry ( DataStreamPtr & stream,
const String & typeName = StringUtil::BLANK
)
DataStreamPtr是一个智能指�?因此从局部变量中�q�回是安全的,�E�序相当直观�Q�不再多说了�?/p>

Ogre::DataStreamPtr Process_Loader::getSceneDataStream(SceneData &data) {
// create what looks like a config file for the edification of Ogre
std::string mem;
SceneData::iterator it;
for (it=data.begin(); it!=data.end(); it++) {
mem += it->first;
mem += "=";
mem += it->second;
mem += "\n";
}
void *pMem = (void *)new unsigned char[mem.length()+1];
memset(pMem, 0, mem.length()+1);
memcpy(pMem, mem.c_str(), mem.length() + 1);
// stuff this into a MemoryDataStream
Ogre::DataStreamPtr pStr(new Ogre::MemoryDataStream(pMem, mem.length() + 1));
return pStr;
}
// and then elsewhere in the world loader:
Ogre::DataStreamPtr pStr = getSceneDataStream(terrainDef);
m_sceneMgr->setWorldGeometry(pStr);

清源游民 2007-03-09 17:25 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理 �W�二部分

清源游民 — Fri, 09 Mar 2007 06:25:00 GMT

场景对象创徏
场景中的所有对象，包括可移动与不可�U�d��的：lights, cameras, entities,particle system,
billboards, skyboxes, static geometry , world geometry.都由场景��理器来创徏。场景中�?br />��M��东西都由场景��理器来��理。�Q何通过场景��理器得到的东西�Q�都必须由场景管理器来销毁�?br />用户不能delete通过由场景管理器得到的指针�?br />场景�l�点只有一个父�l�点�Q�可能有多个子结炏V��可以随意的attach �?detach �q�些场景中的�l�点�?br />在明��告诉场景管理器销毁这些结点前�Q�它们��L��存在。如果不��x��染场景中的某些结点上的内容，
我们可以很方便地对她们进行detach.场景中��L��存在一个Root�l�点。可以把多个内容对象attach�?br />同一个结点上。不能同时把一个实例对象挂��C��个场景结点上�Q�一个场景结点也不能有两个父�l�点�?br />��L��场景�l�点在执行空间操作（�q�移�Q�旋转，�~�放�Q�而不是实体对象�?br />场景查询
场景��理器的�W�二个最常用的功能是�q�行场景查询。包括射�U�查询，球查询，�l�定盒查询，�l�定�q�面
查询�Q�相交查询。Terrain clamping�Q�在崎岖不��^的�\上，勇敢地向下发��一束光�Q�不��你告诉我你�?br />多高�Q�我永远把你�t�在脚下..�Q�是不是不太像笔讎ͼ�^_^)。所有这些查询都�?maskble的，�q�表明可
以在查询时过滤掉不关心的对象�c�d��。如球查询时�Q�只想看看它包含了多��lights,其他的对象即使包�?br />在球里也不必�q�回�Q�实际上�Ҏ��不用计算�?br />�I�间关系�?D变换
world , parent , local世界�I�间中的变换是相对于全局坐标�pȝ��源点(0,0,0),�q�也是root scene node的位�|�。因此可以认��Z��界空间中的变换是相对于Root scene node的。父�I�间中的变换是相对于场点�l�点的父�l�点的，本地�I�间的变换是相对于物体所挂接的结点的。大多数情况下，我们会在父空间中做��^�U�，在本地空间中做旋转，ogre中的�q�些操作�Q�都是在上述的这�U�方式下�?br />object space
从模型导出的��点数据与它的源点之间的关系是不变的�Q�当它被挂到场景�l�点上，�q�个�l�点��是认�ؓ�?br />它的源点。徏模时与导出时不假设测量单位，以世界单位导出（也就是无单位�Q��?br />ogre�q�移与设�|�位�|�不同：�q�移可以有多个参照点�Q�world,local,parent space),而用setPosition()
�Ӟ��L��相对于parent-space　坐标�pȝ��?br />可移动的场景对象
��Z��资源的对象：最普通的是mesh(陪伴着skeleton)�Q�这�U�类型的对象被资源管理系�l�管理�?br />场景��理器不负责实际的装载，它调用Ogreuq资源��理器来完成�?br />��Z��四边形的对象�Q�粒子系�l�，公告板，ribbon trail,overlay,天空盒。它们通常是面向相机的�Q?br />使用动态材质。它们的主要资源是脚本，�q�些脚本定义了如何映��材质，以及它们的生命期�Q�对于粒子系�l�与ribbon trail来说)。天�I�盒直接用场景管理器来定义�?br />skyplane,skydome,skybox
主要的相似点是它们与相机保持一个常量的距离。它们可以在场景中其它对�?br />之前或是之后渲染。它们��用普通的ogre material,因此�U�理动画与其他纹理没有什么不同。它们可�?br />被场景管理器打开或关闭，与相机的距离也可以设�|��?br />skyplane 是一个��^面。用距离和法�U�定义它与相机的位置关系。可以弯�Ԍ��可以分多个段�Q�可对纹理进行多�ơ��^铺。skydome�׃��个��^面组成，底部�I�。��用改变纹理坐标的方式来达到外观上的曲率变化。有一个值用来调节，��D��低，曲率��柔和，��D��高，��陡峭。skybox 像skydome,但他不能“弯曜y��材质坐标。它可以使用立方材质。可使用��g加速功能达到很好渲染效率�?br />�?/font>
使用光的限制�Q�单个通道通常最大支�?个灯。��用更多的灯，通过多通道�?br />光与物体之间的距��，军_��光对物体实际的媄响。Ogre支持点光源，�q�等光，聚光灯�?br />世界几何
当创建基于mesh的景物或兛_��Q�应该分成较��的部分�Q�以便于裁减。Paging Scene Manager提供了这��L��工具�?br />�I�间分割�Ҏ��
Ogre是基于硬件加速渲染引擎，因此以最大化几何体batching的方式会比基于实际多边�Ş�q�行�I�间分割
效果要好的多。Modern GPUs prefer to render a few large batches　of geometry instead of
many small batches.
The more visible geometry you can render in a single batch, the better your application’s
performance is likely to be (within reason, of course; other classic issues such as fillrate and
overdraw can still take over if you just blindly blast polygons at the GPU, batched or not).
静态几何��用注�?/font>�Q?br />静态几何在使用之间必须被徏立�?br />使用相同材质的几何体��被攑ֈ�同一渲染操作�?batch):different materials still require a separate batch.
努力的方向是�Q�最大化一个调用的三角形数�Q�最��化调用的次数�?br />不能�U�d��被包含在static geometry中的对象。只有一个世界�{换应用到完整的static geometry对象�?
比同栯��模的movable geometry占用更多的内存�?br />假如�l�中的�Q何东西在视锥之内�Q�那么组中的所有对象都��被渲染�?/p>

清源游民 2007-03-09 14:25 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理 �W�一部分

清源游民 — Thu, 08 Mar 2007 07:08:00 GMT

Ogre 场景��理

每个3D引擎都会用scene graph 来组�l�它的可渲染对象。scene graph　��L��会�ؓ了更快地搜烦与查询做
优化�Q�提供给用户查找目标对象附近特定对象的功能，允许查找�Q�排序，剔除多边形，以实现更高效的渲染。偶��，scene graph也用于碰撞检��。有�Ӟ��一个单独的scene graph可被用于�E�序中的所有子�pȝ��Q�包�?br />��x��与物理�?br />Ogre使用插�g机制来实现场景管理功能。ScenceManager只是接口�Q�他可以有很多具体的实现。Ogre允许
在同一时刻同一场景中��用多个Scene Manager,�q�样在不同的场景�c�d��切换时带来好处�?br />
场景��理器的责�Q
1�Q�创建，攄��场景中的可移动对象，light,camera�Q��ƈ可以在图形遍历中有效地访问它们�?br />2�Q�加载，装配world geometry(它通常很大�Q�向四处延��Q�不可移动）
3�Q�完成场景查询，例如可以回答�q�样的问题：在世界空间的特定点画一个球体，它会包含哪些对象�Q?br />4�Q�剔除不可见对象�Q�把可见对象攑օ�渲染队列�q�行渲染
5�Q�从当前可渲染的透视图中�l�织�Q�拣选各方向光照
6�Q�设�|�，渲染场景中的所有阴�?br />7　讄��Q�渲染场景中的其他对象（如背景，天空盒）
8　传递组�l�良好的内容到渲染系�l�进行渲�?/p>

场景��理器类�?br />
以分析源码的方式讨论一下插件的加蝲机制与特定场景管理器是如何进行运用的�?br />上一章提��C��以手工的方式初始化ogre,包括手工加蝲场景��理器：
root->loadPlugin("Plugin_OctreeSceneManager");
其实所谓的自动方式下，Root:Root()中也会间接调用到loadPlugin()�Ҏ��Q�这已在前面的笔�?br />(配置文�gPlugins.cfg )中提到过。既然特定管理器以插件的形式�Q�dll文�g�Q�给出，下面先看如何
加蝲dll. �q�入源码�Q�标可��明执行顺序�?br />void Root::loadPlugin(const String& pluginName)
{
// Load plugin library
　　　 DynLib* lib = DynLibManager::getSingleton().load( pluginName ); //(1)
// Store for later unload
mPluginLibs.push_back(lib); //(4)
// Call startup function
　　　　DLL_START_PLUGIN pFunc = (DLL_START_PLUGIN)lib->getSymbol("dllStartPlugin"); //(5)
// This must call installPlugin
pFunc(); //(6)

}
DynLib* DynLibManager::load( const String& filename) //(2)
{
        DynLib* pLib = new DynLib(filename);
pLib->load();
       mLibList[filename] = pLib;
return pLib;
}
void DynLib::load() //(3)
{
m_hInst = (DYNLIB_HANDLE)DYNLIB_LOAD( name.c_str() );
}
�W?font color="#ff0000">(3)中的宏定义如下：
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#    define DYNLIB_HANDLE hInstance
#    define DYNLIB_LOAD( a ) LoadLibrary( a )
到此�Q�DLL被加载到内存,�W?font color="#ff0000">(4)步，mPluginLibs是个STL容器�Q�它存放动态库指针�?br />�W?font color="#ff0000">(5)步，�q�入源码可以看到
void* DynLib::getSymbol( const String& strName ) const throw()
    {
        return (void*)DYNLIB_GETSYM( m_hInst, strName.c_str() );
    }
其中宏定义：define DYNLIB_GETSYM( a, b ) GetProcAddress( a, b )�Q�很昄��Q�它取得一个名�?br />dllStartPlugin的函数指针：不防再看看宏定义�Q?typedef void (*DLL_START_PLUGIN)(void);
说明DLL_START_PLUGIN为参��Cؓ�I�，�q�回��gؓ�I�的函数指针�?br />每个注册到ogre的dll都实��C��q�个�U�定函数。对于我们当前讨论的场景��理器Plugin_OctreeSceneManager
来讲�Q�我们可以找到其相应的定�?它在�W?font color="#ff0000">(6)步中执行

OctreePlugin* octreePlugin;
extern "C" void _OgreOctreePluginExport dllStartPlugin( void )
{
// Create new scene manager
octreePlugin = new OctreePlugin();　//(6-1)

// Register
Root::getSingleton().installPlugin(octreePlugin); //(6-2)

}
�E�序执行�?font color="#ff0000">(6-1)步，new 来一个OctreePlugin,我们看一下它的定义：
class OctreePlugin : public Plugin
{
public:
  OctreePlugin();
  const String& getName() const;
  void install();
   void initialise();
   void shutdown();
   void uninstall();
protected:
  OctreeSceneManagerFactory* mOctreeSMFactory;
  TerrainSceneManagerFactory* mTerrainSMFactory;
  TerrainPageSourceListenerManager* mTerrainPSListenerManager;

};

我们会注意到它包含两个工厂类指针:OctreeSceneManagerFactory,TerrainSceneManagerFactory
他们��是用来生��特定ScenManager的，�E�后讨论。先�?font color="#ff0000">(6-2)步：
void Root::installPlugin(Plugin* plugin)
{
mPlugins.push_back(plugin);　　//(6-2-1)
plugin->install();             //(6-2-2)
// if rendersystem is already initialised, call rendersystem init too
if (mIsInitialised)
{
plugin->initialise();         //(6-2-3)
}
}
//(6-2-1)步把插�g攑ֈ�容器中。看�?font color="#ff0000">(6-2-2)做了什么：
void OctreePlugin::install()
{
  // Create objects
  mOctreeSMFactory = new OctreeSceneManagerFactory();
  mTerrainSMFactory = new TerrainSceneManagerFactory();
  mTerrainPSListenerManager = new TerrainPageSourceListenerManager();

}
呵，刚才�q�说两个工厂�c�L��针，现在把两个工厂徏��h��Q�以后可以用来生产东西了�?br />�l�箋看看(6-2-3):
void OctreePlugin::initialise()
{
  // Register
  Root::getSingleton().addSceneManagerFactory(mOctreeSMFactory);
  Root::getSingleton().addSceneManagerFactory(mTerrainSMFactory);
}
哦，把这两个工厂注册到Root中，让Root可以使用它们。啊�q�句话有炚w��题，Root只是间接的用刎ͼ�
直接雇主�?SceneManagerEnumerator* mSceneManagerEnum;它被包含在Root中。于是我们可以看�?br />void Root::addSceneManagerFactory(SceneManagerFactory* fact) //(6-2-3-1)
{
  mSceneManagerEnum->addFactory(fact);
}

工厂已经有了�Q�我们如何利用这个工厂生产出我们惛_��的东�?SceneManager)呢？
回忆上一章的手工初始化过�E�中�Q�我们一般用以下语句来创建SceneManager:
SceneManager *sceneMgr = root->createSceneManager(ST_GENERIC); //(A)
也可以这��L��
sceneMgr = ogre->createSceneManager("OctreeSceneManager"); //(B)
每个工厂�c�都用一个字�W�串表示其类型。上面说的两个工厂分别��用的字符串�ؓ�Q�“TerrainSceneManager”，"OctreeSceneManager"
(A)语句肯定会调用工厂类的方法来产生实际的SceneManager,下面看源码验证一下：
SceneManager* Root::createSceneManager(const String& typeName,
  const String& instanceName)
{
  return mSceneManagerEnum->createSceneManager(typeName, instanceName);
}
�l�箋挖：
SceneManager* SceneManagerEnumerator::createSceneManager(
  const String& typeName, const String& instanceName)
{
  SceneManager* inst = 0;
  for(Factories::iterator i = mFactories.begin(); i != mFactories.end(); ++i)
  {
   if ((*i)->getMetaData().typeName == typeName)
   {
    if (instanceName.empty())
    {
     // generate a name
     StringUtil::StrStreamType s;
     s << "SceneManagerInstance" << ++mInstanceCreateCount;
     inst = (*i)->createInstance(s.str());
    }
    else
    {
     inst = (*i)->createInstance(instanceName);
    }
    break;
   }
  }
}
上述代码很简单：因�ؓ执行(6-2-3-1)已经�q�实际工厂类实例�q�行了注册。于是遍历每个工厂实例，
扑ֈ��c�d��相符的。找��C��后，如果没有传场景管理器实例的名字，��p�v个名字。然后用�q�个名字
生��Z��个实例来。CreateInstance没干什么，new　呗�?br />SceneManager* OctreeSceneManagerFactory::createInstance(
const String& instanceName)
{
return new OctreeSceneManager(instanceName);
}
��是�q�样。OctreeSceneManager and TerrainSceneManager 的功能都是由一个DLL提供的。它们的关系是：class _OgreOctreePluginExport TerrainSceneManager : public OctreeSceneManager�Q�按照一般的�c�d��p�逻辑�Q?br />我们知道�z��c�M��般功能都比父�c�d��大，父类应用于一般场景，子类针对特定场景。这个逻辑在这里是对的。本来是写读书笔讎ͼ�跑题了，打住�?/p>

清源游民 2007-03-08 15:08 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�四�?开始��用OGRE

清源游民 — Wed, 07 Mar 2007 06:14:00 GMT

清源游民　gameogre@gmail.com
日志�pȝ��Q?br />日志记录了基于ogre的程序每�ơ运行时的所有事�Ӟ��pȝ��初始化，状态，性能信息。输出的内容被放在磁盘文件上�Q�文件缺省名是ogre.log。也可以手动昄��创徏日志�pȝ��,�q�需要在创徏Root对象之前实施�?br />// create an instance of LogManager prior to using LogManager::getSingleton()
LogManager* logMgr = new LogManager;
Log *log = LogManager::getSingleton().createLog("mylog.log", true, true, false);
// third param is not used since we already created a log in the previous step
Root *root = new Root("", "");
可以用Ogre LogManager注册一个Log Listener, 以�Q何方式重定向log data。可以用�q�种方式来屏蔽�Q何日志信息。然后还一个更��单的�Ҏ��辑ֈ�上述目的�Q�在实例化Root之前�Q�当实例化一个LogManager后，不调用createLog()�Ҏ��?br />以下是实现日志信息截��的代码片断�Q?br />class MyLogListener : public LogListener
{
public:
void write (const String& name, const String& message,
LogMessageLevel level, bool maskDebug)
{
// redirect log output here as needed
};
MyLogListener *myListener = new MyLogListener;
// this is the same as calling LogManager::getSingletonPtr() after the
// LogManager has first been instanced; the same pointer value is returned
LogManager *logMgr = new LogManager;
LogMgr->addListener(myListener);
logMgr->createLog("mylog.log", true, false, true);
logMgr->setLogDetail(LL_NORMAL);
Root *root = new Root("", "", "mylog.log");
Ogre手动初始�?/font>
int main(int argc, char *argv[])
{

// tell Root not to load from any plugins or settings file
Root *root = new Root("", "");

// Load feature plugins. Scene managers will register
// themselves for all scene types they support
root->loadPlugin("Plugin_CgProgramManager");
root->loadPlugin("Plugin_OctreeSceneManager");

// load rendersystem plugin(s). The order is important in that GL
// should be available on on platforms, while D3D9 would be available
// only on Windows -- the try/catch will intercept the exception in this
// case where D3D9 is not available and continue gracefully.
try {
root->loadPlugin("RenderSystem_GL");
root->loadPlugin("RenderSystem_Direct3D9");
}
catch (...) {}

try {
  // We'll simulate the selection of a rendersystem on an arbirtary basis; normally
  // you would have your own code to present the user with options and select the
  // rendersystem on that basis. Since a GUI is beyond the scope of this example, we'll
  // just assume the user selected OpenGL.
  RenderSystemList *rList = root->getAvailableRenderers();
  RenderSystemList::iterator it = rList->begin();
  RenderSystem *rSys = 0;

  while (it != rList->end()) {

   rSys = *(it++);
   if (rSys->getName().find("OpenGL")) {

    root->setRenderSystem(rSys);
    break;
   }
  }

  // check to see if a render system was selected; if we reached the end of the list
  // without selecting a render system then none was found.
  if (rSys == 0) {
   delete root;
   std::cerr << "No RenderSystem available, exiting..." << std::endl;
   return -1;
  }

  // We can initialize Root here if we want. "false" tells Root NOT to create
  // a render window for us
  root->initialise(false);

  // set up the render window with all default params
  RenderWindow *window = rSys->createRenderWindow(
   "Manual Ogre Window", // window title
   800,     // window width, in pixels
   600,     // window height, in pixels
   false,     // fullscreen or not
   0);      // use defaults for all other values

  // from here you can set up your camera and viewports as normal
  // get a pointer to the default base scene manager -- sufficient for our purposes
  SceneManager *sceneMgr = root->createSceneManager(ST_GENERIC);

  // create a single camera, and a viewport that takes up the whole window (default behavior)
  Camera *camera = sceneMgr->createCamera("MainCam");
  Viewport *vp = window->addViewport(camera);
  vp->setDimensions(0.0f, 0.0f, 1.0f, 1.0f);
  camera->setAspectRatio((float)vp->getActualWidth() / (float) vp->getActualHeight());
  camera->setFarClipDistance(1000.0f);
  camera->setNearClipDistance(5.0f);

  // Run the manual render loop. Since we are not using a frame listener in this case, we
  // will count to 15 seconds and then instead of exiting, we'll change the render window settings
  // and re-initialize it.
  bool renderLoop = true;
  Timer *timer = Ogre::PlatformManager::getSingleton().createTimer();
  timer->reset();
  float s = 0.0f;

while (renderLoop && window->isActive()) {

renderLoop = root->renderOneFrame();

// accumulate total elapsed time
s += (float)timer->getMilliseconds() / 1000.0f;

   // if greater than 15 seconds, break out of the loop
   if (s >= 15.0f)
    renderLoop = false;

   // we must call the windowing system's message pump each frame to
   // allow Ogre to process messages
   //PlatformManager::getSingleton().messagePump();
  }
}
catch (Exception &e) {
  std::cerr << e.getFullDescription() << std::endl;
}

delete root;
return 0;
}

视口
通过视口上的一点与相机的原点��生世界空间中的一条光�U?br />// x and y are in "normalized" (0.0 to 1.0) screen coordinates
Ray getCameraToViewportRay(Real x, Real y) const;

视口,创徏多个视口�Q�通过Z序（��高��在上）　��定覆盖效果�Q�每个视口可以有不同的背景�?br />// assume window is a valid pointer to an existing render window, and
// a valid pointer to an existing camera instance
Viewport *vpTop, *vpBottom;
// second parameter is z-order, remaining params are position and size,
vpBottom = window->addViewport(camera, 0);
// create a smaller viewport on top, in the center, 25% of main vp size
vpTop = window->addViewport(camera, 1,
0.375f, 0.375f,
0.25, 0.25);
// set the background of the top window to blue (the default is black
// need to set the bottom window explicitly)
vpTop->setBackgroundColour(ColourValue(0.0f, 0.0f, 1.0f));
// an alternate way to set the color is to use the manifest constant
// vpTop->setBackgroundColour(ColourValue::Blue);
在多视口情况下，overlay�~�省在每个视口中渲染。可以关掉。Skybox, Shadow也是如此�?br />vpTop->setOverlaysEnabled(false);
vpTop->setSkiesEnabled(false);
vpTop->setShadowsEnabled(true);

清源游民 2007-03-07 14:14 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�三�?设计概要 �W�二部分

清源游民 — Tue, 06 Mar 2007 03:18:00 GMT

清源游民　 mailto:gameogre@gmail.com

子系�l�概�?/font>
Root Object
Root 是程序进入点�Q�它是一个façade �c�，提供了访问子�pȝ��的方便的�Ҏ��。通过它可以开启ogre,也可能通过它关闭ogre�?/font>
资源��理
在渲染场景中使用的�Q何东襉K��被视��源。所有的资源最�l�都被一个单个类对象��理�Q�ResourceGroupManager�Q�它负责定位资源�Q�初始化资源�Q�不真正装蝲�Q��?
在缺省情况下�Q�Ogre认识以下�c�d��的资源：
Mesh: 二进制格式，它也可包�?morph 和　pose 动画数据
Skeleton: 　可以被Mesh文�g引用�Q�也可单独��用，包含骨骼层次�l�构信息�Q�关键��信息�?
Material: 　定义了渲染一�l�几何体时的渲染状态，可以被mesh文�g引用�Q�也可以手工使用�?
GPU �E�序�Q?program 支持HLSL, GLSL,Cg 与低�U�的 .asm �Q�这些文件会在�Q�?material之间被剖析，因此在一个material之中被引用的Gpu�E�序��L��有效的�?
Compositor: 与Material很相��|��扩展名不�?
Font: 用字体定义文件去定义在overlay中��用的字体�Q�扩展名 .fontdef
每种资源都有自己的特定的ResourceManager,如，MaterialManager, FontManager。ResourceGroupManager负责通过名字查找资源�Q�它不负责实际的内存��理��d��。这些�Q务是由ResourceManager基类来完成的。ResourceGroupManager允许通过�l�名来加载，释放整组资源�?
默认情况下，Ogre认�ؓ资源以一个磁盘文件的形式存在。然而，有些�c�d��的资源可以手工管理，当前只有mesh, font 有手工资源加载的实现。其他类型的可以自己实现�Q�Ogre已经在它的框架中保留了这�U�功能�?
场景��理
所有的具体实现都从SceneManager�z��而来�Q�程序中�怸�此类交互。，可以有多个活动的SceneManager。它们用来管理SceneNode, SceneNode可以在场景中被移动。SceneNode也可以有层次�l�构�?
场景实际内容�l�常也Entity实例的�Ş式存在。它们被Scene Manager创徏�Q�MovableObject实现。一个有效的Entity可以被attach 到SceneNode上面。Entity �l�常从磁盘上�?mesh文�g加蝲。然后也可以手工创徏内容对象�Q�如plane.当Entity被attach到SceneNode上时�Q�进行移动等操作是针对SceneNode的，而不是内容对象�?
也可以把非内容对�?灯，相机�{?attach 到SceneNode上面�?
渲染�pȝ��与渲染对�?
RenderSystem 是Ogre与底层API的接�? RenderTarget 是　渲染�H�口与渲染纹理的概括�?
Ogre 扶持多个渲染�H�口。窗口可以通过Root对象自动、手动地创徏�Q�也可能通过RenderSystem创徏�?

Ogre ��理�?/font>
Manager 是一个可以访问相关类型对象，��理其生命周期的�c�R��例如，ArchiveManager��理Archive实现的创��Z��注册�Q�访问注册的Archive实现实例。Root对象创徏的副作用之一��是初始化所有ogre Manager对象�?
LogManager : 发送日志信息到输出��?
ControllerManager: ��理 controllers,后者是��Z��各种输入�Q��ؓ别的�c�M�生状态��g��供��用�?
DynLibManager: 　��理动态链接库
PlatformManager: 把抽象的讉K��转换成底层硬件与操作�pȝ��相关的细节�?
CompositorManager: 讉K��理　Compoitor framework.
ArchiveManager: 　文�g�pȝ��目录�Q�ZIP文�g
ParticleSystemManager: �_�子�pȝ��Q�发��器�Q�媄响器�Q�affector�Q?
SkeletonManager: 允许同名的skeleton对象重用
MeshManager : ��理mesh, 允许同名mesh重用
HighLevelGpuProgramManager: �l�护�Q�加载，�~�译高��GPU�E�序
GpuProgramManager: �l�护低��GPU�E�序�Q�把�~�译的高�U�GPU�E�序转�ؓ汇编
ExternalTextureSourceManager: ��理外部�U�理源类实例�Q�如视频��?
FontManager: ��理Overlay中��用的字体
ResourceGroupManager: 加蝲�Q�生命期��理�Q�所有注册的�E�序资源
OverlayManager: 加蝲�Q�创建，2D Overlay �c�d��?
HardwareBufferManager: ��理�׃�n��g�~�冲�Q�　��点�~�冲�Q�像素缓�Ԍ��索引�~�冲�{��?
TextureManager: ��理�U�理
�ȝ��Q?�q�一章无意覆盖关于Ogre的所有东西，只说明了一些普遍需要的Ogre对象�Q�和一些不太常打交道的ogre 对象�?

清源游民 2007-03-06 11:18 发表评论

《Pro Ogre 3D Programming�?��M��W�记 �?�W�三�?设计概要　　�W�一部分

清源游民 — Mon, 05 Mar 2007 15:22:00 GMT

清源游民　 gameogre@gmail.com

设计哲学
传统上，使用 Direct3D �?OpenGL 来渲染场景和对象�Q�需要遵循一�p�d��E�序处理��的步骤�Q�调�?API 讄��渲染状态，调用 API 发送几何体信息�Q�通知 API �?GPU ��L��染几何体。对每个几何体都是如此返复，直到当前帧被完全渲染。在一下��同样如此�?
使用面向对象的方法来渲染几何体简化了上述�q�程。通过处理�l�成场景的各�U�对象而不是原始的几何体。这些对象包括：可运动对象，静态对象（构成世界布局�Q�，光，相机�{�。那�?3D API 则不再需要：只是把这些对象放到场景中�Q?Ogre 负责处理琐碎的细节。而且�Q�可以用更加直观的方法来操纵对象�Q�而不是��用矩��c��ȝ��说来�Q�我们可以处理对象，它的属性，调用更直观的�Ҏ��Q�而不再用��点列表�Q�三角�Ş列表�Q�旋转矩�늭�手段来管理了�?
Ogre 提供了面向对象的框架�Q�包括了对象模型中的渲染处理的所有部分。渲染系�l�抽象了底层 3D 　 API 的复杂性。场景图形功能被抽象成单独的接口�Q�这样一来，各种不同的场景图形管理算法可以即插即用。在场景中的所有可渲染对象�Q�无论是可移动的�Q�还是静态的�Q�都被一�l�公共接口抽象，�q�些接口提供了实际的渲染操作�Q�例�?techniques 和它所包含�?passes �Q?.
设计亮点
一“设计模式”的合理使用
Ogre 中大量��用了�l�典的设计模式。例如，使用�?Observer ”模式来通知应用�E�序特定事�g的发生，�?demo �?FrameListener 的��用��得程序可以接收　 frame-started and frame-ended 　事�g通知。�?Singleton ”模式强制实现类的单实例。�?Iterator ”模式用来遍历数据结构的内容�?
“Visitor�?模式用来在对象上执行某种操作�?Façade 模式用来抽象底层�Q�提供一个单一�c�L��口�?
�?Factory�?　用来创徏实例�?
�?场景图与内容分离
传统上，场景图与内容同处于同一�l�承体系下。它要求从场景结点子�c�d��内容�c�，也就是说内容�c�M��场景�l�点�l�承。实践证明这�U�设计非常糟�p��?首先�Q?Ogre 操作场景囑�Ş在接口层 , 它不假设特定囑�Ş��法的实现。实际上�Q?Ogre 操作场景囑�Ş仅仅通过它的�{�֐��Q�方法）�Q�完全忽略底层的��法实现�?
�W�二�Q?Ogre 的图形接口只兛_��囑�Ş�l�构�Q�不包含��M��内在的访问或��理功能。后者被推到 Renderable 中，场景中的所有几何（ movable or otherwise �Q�都从它�l�承。这�?Renderalbes 的渲染属性（材质�Q?materials �Q�被包含�?Entity 对象中去�?Entity 可以包含一个或多个 SubEntity 。这些子实体是实际的可渲染对象。下面是各对象的一个关�p�d��Q?br />
通过�q�样的设计，场景��理与场景内容充分解藕。过于场景图来说�Q�通过 Movable Object 几何�Q�渲染属性变得有效。注意到 Movable 不是�?Scene Node �l�承而来的�?Movable Object �?attached �?Scene Node 上去�?. 当扩展，改变�Q�重构场景图形实现时对场景内容对象的设计与实现没有�Q何媄响�?
从另一斚w��来说�Q�由于场景图形不需要知道内容类的�Q何变化。只要实��C��些简单的场景囑�Ş“确实“需要知道的一些接口。因此，我们可以��L��?attached 一些自定义的东西到场景�l�点上，比如声音信息�{�。（听说有个 OgreAL, 它包装了 OepnAL �Q�猜惛_��是这样做的吧�Q��?
三　插�g�l�构
OGRe 被设计成可扩展的�?Ogre 通过“基于契�U�的设计 �?来完成�?Ogre 可以被设计成一�l�共同工作的�l��g�Q�它们通过一些已知接口来�怺�交流。这带来极大的灵�z�L��，某种功能的不同实��C��改变非常�Ҏ��。�D例来�Ԍ��׃�� ogre 处理场景囑օ��理是在接口�U�，用户可以随意的选择特定��法的实现。而且�Q�当用户创徏一个新的实玎ͼ�可以很容易的以插件的形式提供�l?Ogre, 　实现时只要遵�?ogre 定义的一些接�?. File archives , render systems 也以插�g的�Ş式提供，�_�子�pȝ��也是�?插�g形式的吸引�h之处是，��Z��加入插�g�Q�不需要重新编�?Ogre �?. 插�g可以在运行时加蝲�?
四　��g加速的渲染支持
Ogre 被设计成只支持硬件加速图形渲染，直接软�g渲染不是它的选项�?Ogre 使用完整的硬件加速能力，包括可编�E?shaders �?Unreal 引擎能做什么， Ogre ��p��做什么！�Q�（ ^_^, 作者说的）。引擎直接支持的全局光照 (precomputed Radiance Transfer �{?) �q�没有实玎ͼ�因�ؓ�q�些多数用于非实时计��场合，因此不是什么问�?.Ogre 现在和未来将可能只��?Direct3D �?OpenGL �?
五，灉|��的渲染队列结�?
Ogre 　采取一个新�Ҏ��来解军_��景中各部分渲染次序问题。粗略地看，标准�q�程通常如下工作�Q�渲染地形或世界几何�Q�渲染可�U�d��对象�Q�渲染各�U�特效，渲染 OverLay, 渲染背景或天�I�盒 . 然而，正如典型的实��C��P��像集成电路处理模块）�Q�这个过�E�很难改�?. 在许多例子中�Q?很难改变渲染的顺序，��D��难以�l�护与不灉|��的设计的�?渲染队列的概忉|��Q?Ogre 以一�ơ一个的方式渲染一�l�可以排序的队列�Q�也已同��L��方式渲染每个队列中的内容。也��是队列本��n有优先��Q�同样队列中的对象也有自��q��优先�U��?br />
上图中，队列由后向前渲染�Q?Background à OveryLay �Q?, 在最前的队列中从左至��x��染�?
在这�U�机制下重新�l�织渲染��序非常��单，只要重新分配优先�U�就可以了。队列可以定�Ӟ��队列中的对象也可以。整个队列可以�?turned on�?and “turned off�?�Q�队列中的对象也可以�?每个队列提供了事仉��知�Q�如 prerender and postrender �Q?, 应用�E�序有机会改变队列中的对象渲染。这个机制对于开发和�l�护复杂�E�序都相当有用�?
六　健壮的材质系�l?
Ogre 的材质由一个或多个 technique �l�成�Q?technique �?pass 的集合�?Pass 是材质��别的渲染单元�Q�导致一�ơ图形硬件的 ”draw�?调用。可以有多个 pass, 每个 pass 是一�ơ全新的渲染操作�Q�包括硬件渲染状态改变�?
最吸引人的�Ҏ��是 automatic fallback �?Ogre 自上向下圎ͼ� technique 列出的顺序）��L��最适当�?technique.Ogre �q�能��力地重新组�l?technique 中的 pass, 以迎合最��的技术需求。例如，当前��g只支持单�U�理单元�Q�而你�E�序中最��复杂度的技术，需要至��两个纹理单元，那么 ogre 会把一�?pass 拆分成两个，通过混合两个单元�U�理的方式达到同��L��效果�?
Ogre 材质�pȝ��也支�?schemes 的概��c�?Schemes 可以理解作�ؓ普遍的“非帔R��Q�高�Q�中�Q�低“不同等�U�的囑�Ş讄��。在�q�种情况下，可以定义四个 schemes , �q��ؓ每一个分�?techniques( 复数 ) 。这样就可以 ogre 的所�?technique fallback 查找那些属于特定 schemes �?techniques 。��得材质管理更�Ҏ��炏V�?
用材质脚本完成的事，同样也可以用代码的方式完成。代码的方式也支�?schemes �?technique fallback �?
七　本地优化的几何与骨骼格式
Ogre 使用它单独的 mesh 与骨骼格式。不能直接加载第三��Y件包生成的数据。社��Z��有�{换第三文件格式的工具�Q�但它不�?Ogre 库的一部分�?Ogre 使用自己的格式是��Z��效率�?
八　　多种�c�d��的动�?
Ogre 支持三种�c�d��的动画：骨骼动画�Q�变形动画， Pose 动画
骨骼动画�Q�把��点�l�定到骨��g��。对象的每个��点可以受到四个独立的骨头媄响。每�U�媄响被赋于一个用数量表示的权重。骨骼动��d��在关键��上执行前向运动学模式�?Ogre 当前不支持逆向动画 .
Morph 动画是一�U�顶点动��L��术，他储存关键��上的�l�对的顶点位�|�信息，在运行时在两个关键��之间插倹{��这�?Pose 动画不同�Q?Pose 动画存储的是偏移数据而不是绝对位�|��?Pose 动画可以混合以�Ş成复杂动甅R�?Morph 动画�?Pose 动画功能有限�Q�因��Z��存储的是�l�对��|��因此难以与其�?Morph 动画混合�?Morph 动画�?Pose 动画之间也不能�؜�?.
所有的动画�c�d��都可以与骨骼动画混合使用 .
所有动�ȝ��型都可��用��Y件执行或是利�?GPU ��g执行�?
Ogre 动画是基于关键��的，内插方式有线性与立方��h��q�两�U�选择�?
九　 Compositor Postprocessing ( 怎么��译 ~?)
用来在一个视口中创徏二维的，全屏的后处理效果 . 例如模糊�Q�黑白电视，�{�等效果�Q?Ogre 有个很好的示例） Compositor 也有�c�M��于材质系�l�的 technique �?pass 的概��c��在视口最�l�被输出前，多个计算与渲染可被执行。像材质�?fallbacks,Compositor framework 提供�?fallback 处理�Q�例如，当输出的像素格式无效时。理�?compositor 最�Ҏ��的方法是把它当成片段�E�序�Q�像素渲染）的扩展。不同之处在于：传统的图形管�U�每个材�?pass 只充�怸�个片�D늨�序，�?Compositor framework 则可以像打乒乓球一��h��来回回好多次�?Compositor 脚本扫行�?ViewPort 上，因此它可以面向�Q何的 render target, 可以是可渲染�U�理�Q�主�Q�副渲染�H�口。与材质�pȝ��一��P��它除了利用脚本实玎ͼ�也可以��用代码实现�?
十 �?扩展资源��理
�?ogre 中，资源定义为：渲染几何体到可渲染目标上用到��M��东西。很明显包括�Q?mesh, 　 skeleton, material , overlay script , font , Compositor script, GPU program , texture �?
每种资源都有自己�?manager, 它主要负责控制特定类型资源在内存中的占用数量。换句话��_��它控制着资源实例的生命期。不�q�仅仅在一点上控制�Q�首先，它只能储存同样多的实例，取决于这�U�类型的资源所分配的内存。第二， ogre 不会删除正被其他部分引用的实例�?
资源本��n实际负责加蝲自己。这是资源系�l�的一个设计特性：手工资源加蝲。手工加载意味着资源加蝲�Q�处理，是利用一个方法调用实现的而不是从文�g�pȝ��中隐式地加蝲�?
资源�?ogre 中有四种状态：未定义，　声明�Q�未加蝲�Q�　加蝲�?
未定义，说明 ogre 对它一无所知�?
声明�Q�它已经在档案中�q�行了烦引�?
未加载，已经�q�行了初始化�Q�脚本，已经被解析过了）�Q�引用已�l�被创徏
加蝲�Q�已�l�在它的资源 manager 所��理的内存池中占用空间了�?
可以用“组”来��理��理各类资源。组中资源之间的关系是�Q意的�Q�完全取决于�E�序员：创徏 GUI 的所有资源可以分��Z��l�，�?A 字母开头的资源也可以分��Z��l�，�{�等。有�?�~�省的组�Q�General
�?ogre 中查找某个资源实例时�Q�不会考虑�Q�资源所在的�l�。有�Ӟ��我们可以��资源组命当成某�U�的 �?命名�I�间来用“�?
Archives 中的资源是非手动加蝲的�?Archives 是普通文件容器的��单抽象。它包括文�g�pȝ��?ZIP 档案。用户可以实现自定义�c�d��?archive �?

清源游民 2007-03-05 23:22 发表评论

ORGE(Eihort)学习�W�记之GUI Demo �W�三部分 CEGUI初步

清源游民 — Mon, 05 Mar 2007 04:43:00 GMT

清源游民 gameogre@gmail.com

在以前的�W�记中已�l�对 CEGUI 的��用做了简单的介绍�Q�这里�ؓ了完整性还是把�?C �Q?P 一下：
使用 cegui 来制作界�?, 不论在何�U��^��C�� , 有基本的三大步骤要做 :
1, 创徏一�?CEGUI::Render 实例
2, 创徏 CEGUI::System 对象
3, 调用各种�Ҏ��来渲染用��L��?
�W�一�?, 在我使用�?ogre 环境下��用以下代码来创徏 CEGUI::Render 实例
Ogre3D
CEGUI::OgreCEGUIRenderer* myRenderer =
new CEGUI::OgreCEGUIRenderer(myRenderWindow);
�W�二步相当简�?, 可��?new CEGUI::System(myRenderer);
�W�三步，基本上来�Ԍ��大部分��^��C��Q�如 direct3D, OpenGL, 我们在渲染��@环的��N��调用 CEGUI::System::renderGUI 来开始界面的渲染。如果我们��?ogre3d 引擎�Q�这一步不需�?我们昄��的执行�?创徏 CEGUI �H�口�Q�我们可以��用两�U��Ş式，一�?C �Q�＋代码�Q�二是编�?XML layout 文�g�?
CEGUI 本��n侦测用户输入�Q�这些不�?CEGUI 的责任，而是�E�序的员的责仅R��当有用户外部输入时�Q�我们可以选择��这些消息告�?CEGUI �Q�这�?CEGUI 才会响应�?
CEGUI 使用回调机制来进行消息处理。可以�ؓ某个�H�体的特定事件注册一个函敎ͼ�当窗体事件发生时�Q?CEGUI 会自动调用所注册的函数�?
DEMO 中需要注意的�?Render To Texture 的实现�?
先创建在 ogre 中的 RTT:
RenderTexture * rttTex = mRoot->getRenderSystem()->createRenderTexture( "RttTex", 512, 512, TEX_
TYPE_2D , PF_R8G8B8 );
再�{换成CEGUI可识别的:
// Retrieve CEGUI texture for the RTT
CEGUI::Texture* rttTexture = mGUIRenderer->createTexture((CEGUI::utf8*)"RttTex");
�Ҏ��q�个Texture生成了一个ImageSet;
在ImageSet中定义了一个Image�Q�名为RttImage�Q?其大��与上边的Texutre同样大小�?
当在�H�口中增加一个static Image�Ӟ��把其image属性设�?�?RttImage �?卛_��?

清源游民 2007-03-05 12:43 发表评论

Ogre 学习�W�记之　�Q�Ｇ�QԌ�I轨迹动画

清源游民 — Fri, 02 Mar 2007 09:36:00 GMT

轨迹动画(Animation Track)�Q�是 OGRE 所支持的几�U�动��L��?包括骨骼动画)中的一�U�。通过让节�?node)沿着一条预设了关键�?Key Frame)的轨�q�移动来实现节点的动甅R�?

　　OGRE 中创建和实施轨迹动画的步骤大致如下：

　　1. 在主�E�序�cȝ�� Application :: createScene ( ) 场景创徏�Ҏ��中进行以下工作：

　　Animation * Ogre::SceneManager::createAnimation (
　　 const String & name, // 动画名称
　　 Real length // 动画长度(�U?
　　 ) [virtual]

　　(2) 使用 createTrack �Ҏ��为动��d��q�动画：
　　 AnimationTrack * Ogre::Animation::createTrack (
　　 unsigned short handle, // 分配�l�轨�q�动�ȝ��索引句柄�Q�用于以后可能的调用
　　 Node * node // 指定要沿着�q�条轨迹�q�动的节�?br />　　 )

　　(3) 使用 createKeyFrame �Ҏ��q�动��d��Z��p�d��关键帧：
　　 KeyFrame * Ogre::AnimationTrack::createKeyFrame (
　　 Real timePos // 旉��位置
　　 )
　　
　　 (4) 使用 setTranslate �?setScale �?setRotation 三个�Ҏ��来设�|�关键��每个旉��位置上节点的位置、羃放、旋转属性：
　　 void Ogre::KeyFrame::setTranslate ( const Vector3 & trans )
　　 void Ogre::KeyFrame::setScale ( const Vector3 & scale )
　　 void Ogre::KeyFrame::setRotation ( const Quaternion & rot )
　　
　　 (5) 使用 createAnimationState �Ҏ��创徏一个动�ȝ��态来�q�踪�q�个轨迹�Q?br />　　 AnimationState * Ogre::SceneManager::createAnimationState ( const String & animName ) [virtual]
　　
　　 (6) 使用 setEnabled �Ҏ��来激�z�d��ȝ��态：
　　 void Ogre::AnimationState::setEnabled ( bool enabled )

　　2. 在接收器�cȝ�� Listener::frameStarted(const FrameEvent& evt) �Ҏ��中刷新动�ȝ��态：
　　 void Ogre::AnimationState::addTime ( Real offset )

清源游民 2007-03-02 17:36 发表评论

OGRE学习�W�记�?配置文�g Resources.cfg

清源游民 — Fri, 02 Mar 2007 09:33:00 GMT

resources.cfg

资源�?OGRE 应用�E�序渲染�q�程中需要用到的�U�理囄��、网格模型文件、骨骼动��L��件的�ȝ��?OGRE 应用�E�序需要在渲染前将�q�些资源载入内存�Q�那��需要让 OGRE 引擎知道资源的搜索�\径。特别的�?OGRE 引擎支持直接��d�� Zip 压羃文�g中的内容�Q�所�?Zip 文�g也必��被当成搜烦路径来指定。在 OGRE 引擎中具有虚拟文件系�l�的概念�Q�引擎内部蝲入资源文仉��是通过虚拟文�g�pȝ��来进行的�Q�引擎�ƈ不关心资源文件来自一个普通文件夹�?zip 压羃包甚至网�l�映��。真正的文�g��d��功能是通过插�g来实现的�Q�所以大家在�q�行环境里可以发�?Plugin_FileSystem.dll �Q�早期的 OGRE 版本�q�有 Plugin_Zip.dll �Q�在新的版本里被实现到引擎内部了。目前还没有实现对网�l�文件的直接讉K��?

��Z��方便 OGRE �E�序在运行期间查找资源，使用了资源配�|�文�?resources.cfg 。这是一个文本文�Ӟ��我们可以�?OGRE �E�序的可执行文�g的同一文�g夹下扑ֈ�它。它的内容就是对资源路径的指定，�C�Z��如下�Q?

Zip=../../../Media/dragon.zip

Zip=../../../Media/knot.zip

Zip=../../../Media/skybox.zip

FileSystem=../../../Media/

如果资源在一�?Zip 文�g中，��写 Zip=****** �Q�如果资源在一个普通的��盘文�g多w��写 FileSystem=****** �Q�通常�q�两�U�情况都有。例如在 OGRE 自带�?Demo 中，��将大部分资源放在一个文件夹里，�Ҏ��的资源该文�g夹中�?Zip 文�g里�?

�?OGRE 自带的例子框�?setupResources() 展示�?Resources.cfg 文�g的��用：先利�?ConfigFile �c�d��文�g内容�q�行了解析，��资源目录用ResourceGroupManager:: addResourceLocation()向OGRE�q�行提交;

清源游民 2007-03-02 17:33 发表评论

OGRE学习�W�记�?配置文�gPlugins.cfg

清源游民 — Fri, 02 Mar 2007 09:31:00 GMT

Plugins.cfg

Ogre的许多功能是以插件的形式提供�?Ogre提供的以Plugin_开头的许多.DLL文�g都是所谓的插�g�?br />Plugins.cfg指定了插件的路径和插件文件名, 它们可以攑֜�其它文�g多w��Q�但必须在本文�g里指定�\径�?/p>

�?windows �q�_��插�g的装入过�E�如下：
Root::()
{
   if(!pluginFileName.empty())
   loadPlugins(pluginFileName);
�?
――――――＞
void Root::loadPlugins(const String& pluginsfile)
{
   ConfigFile cfg;
   cfg.load(pluginsfile);
    ...........................
   // 解析文�g�Q�处理后��目录与文�g名联�?
for(;;)
   loadPlugin(plugindir + (*it))

} ――――――＞

Root::loadplugin(const string& pluginName)
{
DyLibmanager::getsinleton.load(pluginName);
}
――――――＞

DynLibManager::load(const string& filename)

{
DynLib* pLib=new DynLib(filename);
pLib->load();
}

――――――＞

void DynLib::load()

{
m_hInst=(DYNLIB_HANDLE)DYNLIB_LOAD(name.cstr());
}

�?windows �q�_��下有如下定义�Q?

#define DYNLIB_LOAD(a) LoadLibrary(a)

到此�Q?x.dll 插�g被加载到内存中，可以使用插�g的功能了^_^
以下��Z��个典型的 Plugins.cfg 文�g的内容：

# Defines plugins to load
# Define plugin folder
PluginFolder=.
# Define plugins

Plugin=RenderSystem_Direct3D9
Plugin=RenderSystem_GL
Plugin=Plugin_ParticleFX
Plugin=Plugin_BSPSceneManager
Plugin=Plugin_OctreeSceneManager
Plugin=Plugin_CgProgramManager
Plugins.cfg 文�g内容相当直观�Q�不再赘�q��?

清源游民 2007-03-02 17:31 发表评论

OGRE学习�W�记�?配置文�g Ogre.cfg

清源游民 — Fri, 02 Mar 2007 09:28:00 GMT

Ogre.cfg
OGRE 引擎��会在可执行文�g所在的文�g夹中生成一�?ogre.cfg 文�g该文件保存了本次对话框的讄��l�果�Q�下�ơ显�C�对话框时会��上�ơ的配置�l�果��d��q�直接显�C�。例子框架用 mRoot->showConfigDialog() 来调出配�|�对话框。如果你认�ؓ在程序运行之前显�C�Z��个对话框很难看，或者希望采用另外的形式�Q�比如专门的配置界面�Q�就象在大部分游戏中那样�Q�来配置渲染�pȝ��Q�只要你��保在可执行文�g的同一文�g夹下存在有效�?Ogre.cfg 配置文�g�Q�就可以直接调用 Root 对象�?restoreConfig() 函数来直接读入渲染系�l�配�|�信息，而不昄��配置对话框�?

Ogre::Root::showConfigDialog() 会有下述行�ؓ�Q�如果程序运行之间已存在一个有效的 ogre.cfg �Q�那么它会在昄��对话框之前将配置文�g的内容蝲入，如果用户对对话框�q�行了操行，改变的配�|�参敎ͼ� showConfigDialog() 会根据用��L��新选择依次调用 Root::setRenderSystem, RenderSystem::setConfigOption and Root::saveConfig �Q�在 ogreWin32ConfigDialog.cpp 中实玎ͼ�写自��q��配置对话框时可以参考）�Q�需要注意的是配�|�好的参敎ͼ�只是�?RenderSystem::initialise or RenderSystem::reinitialise 调用之后才被�Ȁ�z�R�?以下为典型的 ogre.cfg 文�g的内�?
Render System=Direct3D9 Rendering Subsystem
[Direct3D9 Rendering Subsystem]
Allow NVPerfHUD=No
Anti aliasing=None
Floating-point mode=Fastest
Full Screen=No
Rendering Device=ATI MOBILITY RADEON X300
VSync=No
Video Mode=800 x 600 @ 32-bit colour

[OpenGL Rendering Subsystem]
Colour Depth=32
Display Frequency=N/A
FSAA=0
Full Screen=No
RTT Preferred Mode=FBO
VSync=No
Video Mode=1024 x 768

�Ҏ��号中为可以选择的渲染子�pȝ��Q�而第一行指��Z��当前的选择是哪个子�pȝ��Q�方括号下面为各子系�l�的可选参敎ͼ�在上的例子中分别列出�?Direct3D 9 �?OpenGL 子系�l�的可选配�|�参数�?br />Root(const String& pluginFileName = "plugins.cfg", const String& configFileName = "ogre.cfg", const String& logFileName = "Ogre.log"); ~Root();
Root 的构造函��C��递了ogre.cfg,只是��单的��文件名保存下来�Q�供其它�Ҏ��使用�Q�如上面曄��提到�q�的 Root:saveConfig(void);

清源游民 2007-03-02 17:28 发表评论

ORGE(Eihort)学习�W�记之GUI Demo �W�二部分 OIS输入

清源游民 — Fri, 02 Mar 2007 07:27:00 GMT

清源游民　 gameogre@gmail.com
在第一部分里分析了 ExampleFrameListener 大部内容�Q�不�q�没有穷��，它其实也包含了输入部分。因�?CEGUI 本��n没输入侦��功能，他需要外部力量的帮助。在 ogre1.4 之间�?demo 中，输入部分�?ogre 自带的，功能有限�Q�对于我�q�个菜鸟�Q�暂时还用不到特别的功能 ^_^ �Q�。新版本里，�q�脆把这部分��L��了，输入部分采用了新的类�?OIS �Q?Object-oriented Input Library . 他的作者本�w�就�?OGRE team 的成员，我们可以�怿��Q�他可以�?Ogre 一起工作得很好 .OIS 支持键盘�Q�鼠标，游戏杆，最后一��Ҏ��时不讨论 . �?windows �q�_��下， OIS 提供了对 DirectInput 的封装，基本的输入功能是由后者来实现的。既然是学习�Q�我们不防先大概理解一�?DirectInput 基本功能与��用流�E�以�?OIS 是如何将�q�些功能��装�q�去的。我的目的是要讨�?CEGUI 的，现在转到�?OIS, 又�{��C�� DirectxInput, ��g��是离目标��来��远了。呵�Q�在菜鸟的眼中，什么东襉K��是菜�Q�都有营养，不防咀��g��一下下�?CEGUI 固然是好东西�Q�但是如果我们菜鸟整天只会学一堆堆没完没了的类库，那么我们可能永远��只是个菜鸟了，一句话�Q�知道他做了些什么，比光知道他怎么用那可是相当有效�Q�费话少说了�Q�先看一�?DirectInput, �?MSDN 上直接抄了一�D�，懒得��译�? 下面�W�一�D�话�Q�说了理解directInput需要了解的一些基本概念与术语�Q�因��Z��前看�q�一点，大概知道是些什么。而我现在主要是做学习�W�记�Q�不是教�E�，所以不解释了�?br />To understand DirectInput, it is essential to understand the following terms.
DirectInput object: The root DirectInput interface. · Device: A keyboard, mouse, joystick, or other input device. · DirectInputDevice object: Code representing a keyboard, mouse, joystick, or other input device.·
Device object: Code representing a key, button, trigger, and so on found on a DirectInput device object. Also called device object instance.
�W�二�D�话说明了��?DirectInput 的基本步骤， OIS 把这些东西封装�v来了 .
The following steps represent a simple implementation of DirectInput in which the application takes responsibility for ascertaining what device object (button, axis, and so on) generated each item of data.

1. Create the DirectInput object. You use methods of this object to enumerate devices and create DirectInput device objects.

2. Enumerate devices. This is not an essential step if you intend to use only the system mouse or keyboard. To ascertain what other input devices are available on the user's system, have DirectInput enumerate them. Each time DirectInput finds a device that matches the criteria you set, it gives you the opportunity to examine the device's capabilities. It also retrieves a unique identifier that you can use to create a DirectInput device object representing the device.

3. Create a DirectInputDevice object for each device you want to use. To do this, you need the unique identifier retrieved during enumeration. For the system mouse or keyboard, you can use a standard GUID.

4. Set up the device. For each device, first set the cooperative level, which determines the way the device is shared with other applications or the system. You must also set the data format used for identifying device objects, such as buttons and axes, within data packets. If you intend to retrieve buffered data—that is, events rather than states—you also need to set a buffer size. Optionally, at this stage you can retrieve information about the device and tailor the application's behavior accordingly. You can also set properties such as the range of values returned by joystick axes.

5. Acquire the device. At this stage you tell DirectInput that you are ready to receive data from the device.

6. Retrieve data. At regular intervals, typically on each pass through the message loop or rendering loop, get either the current state of each device or a record of events that have taken place since the last retrieval. If you prefer, you can have DirectInput notify you whenever an event occurs.

7. Act on the data. The application can respond either to the state of buttons and axes or to events such as a key being pressed or released.

8. Close DirectInput. Before exiting, your application should unacquire all devices and release them, then release the DirectInput object.

了解了这些基本步骤，下面我们打开OIS的源码，看看上面�q?步骤��装��C��哪里。然后我们返�?ExampleFrameListener, 看看 demo 中是如何使用 OIS �?.
�W�一个要看的是InputManager�c�R��他提供了��^台无关的接口�Q�负责输入系�l�的创徏。没啥好说的�Q�看源码�?只列出核心代�?�Q?br />InputManager * InputManager::createInputSystem( ParamList ¶mList )
{
     InputManager* im = 0;
      #elif defined OIS_WIN32_PLATFORM
           im = newWin32InputManager();
    #endif
       im->_initialize(paramList);
    return im;
}
自然�Q�我们只兛_��windows�q�_��下的。于是找到源码��l�看:
void Win32InputManager::_initialize( ParamList ¶mList )
{
//Create the device
   hr = DirectInput8Create(hInst, DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&mDirectInput, NULL );
   /Ok, now we have DirectInput, parse whatever extra settings were sent to us
    _parseConfigSettings( paramList );
    _enumerateDevices();
}

首先�Q�完成了8步骤中的�W?步， Create the DirectInput object �?在_parseConfigSettings ( paramList ); 中对以后��要创徏的设备（键盘�Q�鼠标等�Q�的属性，例如独占模式�Q�前台模式等。这些属性列表paramList   �l�过处理后，之后在创��备的时候传入�?
void Win32InputManager::_enumerateDevices()
{     //Enumerate all attached devices
    mDirectInput->EnumDevices(NULL, _DIEnumKbdCallback, this, DIEDFL_ATTACHEDONLY);
}

完成�?步骤中的�W?　部分 Enumerate devices �Q�它是针�Ҏ��戏杆�q�类设计的，对于键盘�Q�鼠标�ƈ不需要。InputManager 创徏之后�Q�就可以用它来创建键盘，鼠标了。它提供了如下的�Ҏ��Q?
Object * Win32InputManager::createInputObject( TypeiType, boolbufferMode )
{
Object* obj = 0;
    switch( iType )
    {
    case OISKeyboard: obj = newWin32Keyboard( this, mDirectInput, bufferMode, kbSettings ); break;
    case OISMouse: obj = newWin32Mouse( this, mDirectInput, bufferMode, mouseSettings ); break;
    obj->_initialize();
    return obj;
}

鼠标�Q�键盘都有各自的�c�d��装。下面以键盘��Z��Q�看看它的源码中都做了些什么：
void Win32Keyboard::_initialize()
{

1 mDirectInput->CreateDevice(GUID_SysKeyboard, &mKeyboard, NULL);

2 mKeyboard->SetDataFormat(&c_dfDIKeyboard)

3 HWNDhwin = ((Win32InputManager*)mCreator)->getWindowHandle();

4 mKeyboard->SetCooperativeLevel( hwin, coopSetting)))

5 mKeyboard ->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph )))

6 HRESULThr = mKeyboard->Acquire();

}

�q�里可是做了不少的工�?看看�Ҏ��名就可以明白。�ؓ说明方便加上了标受��?br />1�Q?它做�?步骤中的�W?步， Create a DirectInputDevice object for each device you want to use �?
2, 3 4,5它们共同做了8步骤中的�W?步－ Set up the device 。这里面包括�Q�设�|�键盘的数据格式�Q�协作模式，其他属性。很明显�Q?做了8　步步骤中的第5步－ Acquire the device �?意思是告诉DirectInput,我准备从讑֤�上获取数据了�Q�给我做好生��Z��着。准备工作都做好了，可以获取数据了，通过讑֤�提供的下面这个方法来做这件事。这��是8　步骤中的�W?件事- Retrieve data
void Win32Keyboard::capture()
{     if( mBuffered )
       _readBuffered();
     else
       _read();
}

从源码中我们可以看到�Q�根据数据的不同�Q�进行了不同的处理。呵�Q�什么不同呢�Q�再从MSDN上抄一�D�吧�Q�一看就明白�Q?Buffered and Immediate Data
DirectInput supplies two types of data: buffered and immediate. Buffered data is a record of events that are stored until an application retrieves them. Immediate data is a snapshot of the current state of a device. You might use immediate data in an application that is concerned only with the current state of a device - for example, a flight combat simulation that responds to the current position of the joystick and the state of one or more buttons. Buffered data might be the better choice where events are more important than states - for example, in an application that responds to movement of the mouse and button clicks. You can also use both types of data, as you might, for example, if you wanted to get immediate data for joystick axes but buffered data for the buttons.

呵，清楚了吧。��l�看代码, capture()有两个分枝，分别处理�~�冲数据与立��x��据�?br />首先是缓冲数据，��d��代码如下�Q?
void Win32Keyboard::_readBuffered()
{
DIDEVICEOBJECTDATA diBuff[KEYBOARD_DX_BUFFERSIZE];
    DWORD entries = KEYBOARD_DX_BUFFERSIZE;
   mKeyboard->GetDeviceData( sizeof(DIDEVICEOBJECTDATA), diBuff, &entries, 0 );
    //Update keyboard and modifier states.. And, if listener, fire events
    for(unsignedinti = 0; i < entries; ++i )
    {
       KeyCode kc = (KeyCode)diBuff[ i ].dwOfs;
                     if( diBuff[ i ].dwData & 0x80 )
       {
          if( listener )
            istener->keyPressed( KeyEvent( this,kc,_translateText(kc) ) );
       }
       else
       {
           //Fire off event
           if( listener )
            listener->keyReleased( KeyEvent( this, kc, 0 ) );
       }
    }
}

�q�段代码中，GetDeviceData( sizeof(DIDEVICEOBJECTDATA), diBuff, &entries, 0 );取得了缓冲数�?��d��了一个数�l�：��寸是EYBOARD_DX_BUFFERSIZE,可以看到entries也等于此倹{��Entries的作用除了开始调用时说明数组的大��，同时在函数调用返回时说明数组里有多少个数据填入（没有��_��多的�~�冲数据�Q�当然填不满啦，假如entries�q�回6�Q�说明还�?个按键信息在�~�冲里等待处理）。很明显�Q�for循环��是对这些未处理的信息进行处理。KeyCode kc = (KeyCode)diBuff[ i ].dwOfs; �q�是看看�Q�这个事件是由哪个键引走.KeyCode是个枚�D型：
enum KeyCode
    {
    　 C_1           = 0x02,
       KC_2            = 0x03,
       KC_3            = 0x04,
       KC_A            = 0x1E,
       KC_S            = 0x1F,
       KC_D            = 0x20,
    }

��定了是哪个键，接下来就要问了，是按下还是释放？
if ( diBuff[ i ].dwData & 0x80 ) 　回答了这个问�?下面做的�?
if ( listener )
istener->keyPressed( KeyEvent( this,kc,_translateText(kc) ) );

它把相关的信息内容包装成KeyEvent�Q�作为参数发�l�了�Q�已�l�注册了的侦听�?可能不太明白�Q�解释一下：当我们按下了某个键，可以认�ؓ是发生了个KeyEvent,�E�序里会响应�q�个事�g�Q�方法就是把某个�c�d��例注册�ؓ侦听�?listener),说白了就是告诉OIS,当键盘按下释攄��时候你告诉我啊�Q�我要响应他。这里OIS��到按键事�g发生了，�Ҏ��侦听者的��h��Q�调用侦听者的�Ҏ��(keyPressed)。也许有疑问�Q�OIS 怎么知道侦听者实��C��keypressed�Q�）�Ҏ��呢？不急先看以下代码，在GUI demo里：
class GuiFrameListener : publicExampleFrameListener, publicOIS::KeyListener, publicOIS::MouseListener
看到了吧�Q�它�l�承自�?OIS:KeyListener ,从OIS的源码中扑ֈ�它：
class _OISExport KeyListener
    {
    public:
       virtual ~KeyListener() {}
       virtual bool keyPressed( constKeyEvent &arg ) = 0;
       virtual bool keyReleased( constKeyEvent &arg ) = 0;
    };
哈哈�Q�他正是定义了这两个接口�Q�既然��承自他，当然也就拥有了这两个接口�Q�于是GuiFrameListener成了合理合法的Listener了�?
哦，它在哪里注册的呢�Q�很��?在GuiFrameListener的构造函数里我们看到�Q?
{
       mMouse ->setEventCallback(this);
       mKeyboard->setEventCallback(this);
}
�l�箋挖源码：
virtual void Keyboard : �Q�setEventCallback ( KeyListener *keyListener ) {listener=keyListener;}
�q�下应该��明白了吧。很明显GUI Demo里��用了�~�冲模式.
剩下来就是立��x��式的数据了，他很好理解：
void Win32Keyboard::_read()
{
mKeyboard->GetDeviceState( sizeof(KeyBuffer), &KeyBuffer );
}
它把键盘当下的状态保存到�~�冲中去�Q�要想知道哪个键是否按下�Q�只要对照缓农y��按囄��骥”就可以了�?br /> bool Win32Keyboard::isKeyDown( KeyCodekey )
{
    return (KeyBuffer[key] & 0x80) != 0;
}
�q�个键按下了吗？那个键按下了吗？那那个呢�Q�呵�Q�真啰嗦�Q�得一个个的问�?
于是我们 GUI Demo 中可以看��C��列的代码�Q?
virtual bool processUnbufferedKeyInput(const FrameEvent& evt)
       {

            if(mKeyboard->isKeyDown(KC_A))
                     mTranslateVector.x = -mMoveScale;    // Move camera left
            if(mKeyboard->isKeyDown(KC_D))
                   mTranslateVector.x = mMoveScale;      // Move camera RIGHT
              if(mKeyboard->isKeyDown(KC_UP) || mKeyboard->isKeyDown(KC_W) )
                     mTranslateVector.z = -mMoveScale;     // Move camera forward
              if(mKeyboard->isKeyDown(KC_DOWN) || mKeyboard->isKeyDown(KC_S) )
                    mTranslateVector.z = mMoveScale;      // Move camera backward
�?

我们用键盘要不是�~�冲模式�Q�要么立��x��式，不可能一起上�Q�这所有在 demo 中都能看刎ͼ� demo 的作者懒得多写代�?( 嘿嘿 ) �Q�它�l�承�?ExampleFrameListener 的许多功能，�?ExampleFrameListener 也实��C��些立��x��式的按键处理�?Demo 没有用到。写了这么多了，�q�得 8 　大步骤？�Q?该第 7 步了吧： ―�?Act on the data �Q?�q�有什么好说的呢？爱咋咋地�Q�最后一步，�W?8 步――天龙八�?! 呵错了，�?Close DirectInput 其实很简单， OIS 把他们封装在各个�cȝ��析构函数里了�Q�想当然�Q�源码也不用贴了 . 说了 OIS 　如何�?DirectInput ��装��h��Q�参�?8 大步骤，如何使用 OIS 也基本很明白了。OIS �Q�就学到�q�里�Q�接下来该主角上�?CEGUI 得休息了�Q�打字，��资料，看代码，很篏了�?

清源游民 2007-03-02 15:27 发表评论

ORGE(Eihort)学习�W�记之GUI Demo �W�一部分例子框架

清源游民 — Thu, 01 Mar 2007 13:47:00 GMT

清源游民　 gameogre@gmail.com

下面直接涉及到相关类

首先看一�?/span> ExampleFrameListener, 下面是类间关�p�d��

ExampleFrameListener �l�承�?FrameListener, 因此拥有了它的两个方�?

virtual bool frameStarted(constFrameEvent& evt)

virtual bool frameEnded(constFrameEvent& evt)

�?ExampleApplication 中将它们注册�?ogre 中，在适当的时候， ogre 会调用这两个�Ҏ�� . 下面是注册地点与时机

virtual void ExampleApplication::createFrameListener(void)

{

mFrameListener= newExampleFrameListener(mWindow, mCamera);

mFrameListener->showDebugOverlay(true);

mRoot->addFrameListener(mFrameListener);

}

createFrameListener �?ExampleApplication::setup() 中被调用.

ExampleFrameListener 又��承了 WindowEventListener.

WindowEventListerner 在ogre 1.4中是新加的。按照手册：它是一�?Callback class used to send out window events to client app. 它定义以下四个接�?而显然例子程序中只用��C��两个
virtual void windowMoved(RenderWindow* rw) {}

virtual void windowResized(RenderWindow* rw) {}

virtual void windowClosed(RenderWindow* rw) {}

virtual void windowFocusChange(RenderWindow* rw) {}

�q�种所谓的回调�c�d��何实玎ͼ�下面只说明windows操作�pȝ��的情��c�?

我们知道�Q�windows操作�pȝ��监视�pȝ��中发生的一切，通过消息的方式通知相应的窗口。每个窗口类注册的时候，都指明一个回调过�E�，在那里处理传来的消息。应用程序又有各自的消息队列�Q�从消息队列中取得消息，然后分开�l�各�H�口.

不防从ogre的源码中看看上述windows基本�q�程如何实现�Q�这有助理解回调�cȝ��实现�q�程�Q?

首先�Q�ogre可以为我们创��Z��个窗口：

mWindow = mRoot->initialise(true);//

于是我们�q�入到initialise()中看看吧�Q�它倒底做了些什么事情�?

RenderWindow * Root::initialise(boolautoCreateWindow, constString& windowTitle)

{

// ……

mAutoWindow = mActiveRenderer->initialise(autoCreateWindow, windowTitle);

// �q�里�Q�RenderSystem* mActiveRenderer

// ……

}

mActivaRenderer 只是接口�Q�不用实际的事情�Q�实际的工作由它的子�c�d��成，现只看DirectX实现:

RenderWindow * D3D9RenderSystem::initialise( boolautoCreateWindow, constString& windowTitle )

{

// ……………………

autoWindow = this->createRenderWindow( windowTitle, width, height,

fullScreen, &miscParams );

// ………………… ..

}

好，�l�箋下去,看看createRenderWindow做了些什�?

RenderWindow * D3D9RenderSystem::createRenderWindow(constString &name,

unsigned int width, unsignedintheight, boolfullScreen,

const NameValuePairList *miscParams)

{

// …………… ..

RenderWindow * win = newD3D9RenderWindow(mhInstance, mActiveD3DDriver,

mPrimaryWindow ? mpD3DDevice : 0);

win ->create( name, width, height, fullScreen, miscParams);

// ………………

}

�l�箋

void D3D9RenderWindow::create(constString& name, unsignedintwidth, unsignedintheight,

bool fullScreen, constNameValuePairList *miscParams)

{

// Register the window class

// NB allow 4 bytes of window data for D3D9RenderWindow pointer

WNDCLASS wc = { 0, WindowEventUtilities::_WndProc, 0, 0, hInst,

LoadIcon(0, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW),

(HBRUSH)GetStockObject(BLACK_BRUSH), 0, "OgreD3D9Wnd" };

RegisterClass(&wc);

// 定义了窗口类�Q��ƈ且进行注册，需要注意的是，你看看它把窗口类的回调函数的��D��Z��什么？先记住，一会儿讨论它吧�?

// Create our main window

// Pass pointer to self

mIsExternal = false;

mHWnd = CreateWindow("OgreD3D9Wnd", title.c_str(), dwStyle,

mLeft, mTop, mWidth, mHeight, parentHWnd, 0, hInst, this);

// 调用win32API把窗口真正Create出来�?

WindowEventUtilities ::_addRenderWindow(this);

// �q�一步也要注意到

}

�l�箋

void WindowEventUtilities::_addRenderWindow(RenderWindow* window)

{

_msWindows.push_back(window);

}

_msWindows 定义为：

typedef std::vector Windows;

static Windows _msWindows;

�Q�没什么，只是个stl容器�Q�把生成的窗口放�q�去�?

到现在，容器�c�L��册好了，回调函数也指定了�Q�窗口也创徏出来了。现在我们��l�思考我们最最初的问题�Q?WindowEventListerner �q�个回调�c�L��如何实现所谓的回调机制的，也就是说windowEventListerner不是定义了四个接口，它响应特定的windows事�g�Q�我们要讨论的就是这四个接口�Ҏ��如何被调用�v来，实现所谓的回调机制�?�q�记得注册窗口类的回调函数是什么吧�Q?

WindowEventUtilities::_WndProc �Q?呵呵�Q�只要在那里调用上述四个接口函数��好了�?

哪问题又来了�Q�_WndProc到哪里找�q�四个接口函数呢�Q?

�?ExampleFrameListener �cȝ��构造函数里我们可以看到如下代码

//Register as a Window listener

WindowEventUtilities::addWindowEventListener(mWindow, this);

啊，�q�就是奥�U�所�?到源码中看看吧�?

void WindowEventUtilities::addWindowEventListener( RenderWindow* window, WindowEventListener* listener )

{

_msListeners.inser t(std::make_pair(window, listener));

}

-msListeners 被定义成�q�样子：

typedef std::multimap WindowEventListeners;

static WindowEventListeners _msListeners;

没有什么，��是STL容器�Q�它使得�H�口(RenderWindow)�?WindowEventListener)

�l�成了亲密派对，�H�口有了什么消息，��可以用对应的回调类响应�?

只剩下一点秘密了�Q�到底怎么调用��h��的呢�Q�某某某说过�Q�源码之下，了无�U�密�Q�那��q��源码吧：

LRESULT CALLBACK WindowEventUtilities::_WndProc(HWNDhWnd, UINTuMsg, WPARAMwParam, LPARAMlParam)

{

WindowEventListeners ::iteratorstart = _msListeners.lower_bound(win),

end = _msListeners.upper_bound(win);

// 为遍历做准备

switch( uMsg ) // 消息真的来了

{

case WM_MOVE:

//log->logMessage("WM_MOVE");

win->windowMovedOrResized();

for( ; start != end; ++start )

(start->second)->windowMoved(win);

break;

case WM_SIZE:

//log->logMessage("WM_SIZE");

win->windowMovedOrResized();

for( ; start != end; ++start )

(start->second)->windowResized(win);

break;

}

��p��P��四个接口函数被调用�v来了�Q?

也许�Q�也许，关于消息�q�有些要说明的。消息如何�܇出来的？

当看��C��如下代码�Q�突然就��x��个朋友，会心一�W?

void WindowEventUtilities::messagePump()

{

MSG msg;

while( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )

{

TranslateMessage( &msg );

DispatchMessage( &msg );

}

打破铁锅问到底吧�Q�它又如何被调用��h��Q?

void Root::startRendering(void)

{

while( !mQueuedEnd )

{

//Pump messages in all registered RenderWindow windows

WindowEventUtilities::messagePump();

if (!renderOneFrame())

break;

}

��是�q�里了。写的�ؕ七八�p�，脑子也�ؕ七八�p�，梳理一下吧�?

首先�Q�mWindow = mRoot->initialise(true);初始化，随便通过一�pȝ��q�锁反应create出来一个窗口，�q�把它的回调函数讑֮��?WindowEventUtilities::_WndProc.

ExampleFrameListener �l�承�?WindowEventListener 的四个约定接口函数。�ƈ且在它的构造函数里调用 WindowEventUtilities::addWindowEventListener(mWindow, this); �q�行了注册，以便特定�H�口消息发生时进行响�? Root ::startRendering �Q�）�q�入了渲染��@环，渲染每一帧前�Q�检��widnows消息�Q��ƈ�q�行分发。于是消息进入到�H�口�cȝ��回调函数_WndProc,在函数内部根据消息的不同�Q�分别调用已注册的侦听器的约定接口函数�?br>先写到这里吧�Q�原来只是想写写CEGUI的��用，谁知已经写了�q�么多了�Q�CEGUI�q�一字未提。脑子�ؕ了，先休息吧。下面还得说说OIS,CEGUI又得靠后�?

清源游民 2007-03-01 21:47 发表评论

�Q��{�Q�CEGUI 中文输入

清源游民 — Wed, 28 Feb 2007 02:25:00 GMT

刚刚搞CEGUI的时候大体看了一下CEGUI。原以�ؓ其不支持中文�?br />而且�|�上很多人都说不支持。。我也就没有�l�细看了�?br />当用到Editbox的时候。又不得不用中文。这时候问题就来了�?br />先是用utf8方式转换辑ֈ�中文昄��的目的。可是中文输入却不行。网上有一�U�说法是��两个字节链接�v来即可。看了一下编译器讄��Q�当前��用的是多字节模式。就不得不这样做了。不�q�估计我对C++�q�不��深。搞了一会，�q�是��p�|了。不�q�后来在�|�上有一个朋友说CEGUI本来��支持中文的。但又看到其它�h说的�Q�不解其�a�啊。再后来有一个叫老妖�_��|�友�l�了我一份代码。结果真的成功了。可昄��可输入中文。对于中文的字表�׃��个font文�g创徏。方法如下：
1:找一个中文字体文�?.ttf)
2:创徏一个文本文�Ӟ��其存�ؓ.font文�g.
3:�?font文�g里写如下代码(我个假设一个chinese.ttf文�g):

// 说明:Name��是在程序中要用到的名字, Filename��是文�g�?FreeType可以是自定义�?具体到官方网有说�?Size��是字体的大��?�E�序中是不能调大��的.因�ؓ字体生成�U�理后就是固定的.
4:在你写的�E�序的键盘和事�g上处理上面正常情况下是这样子�?CEGUI::System->injectChar((CEGUI::utf32)Key); // Key值就是你�E�序捉到的按键�?我们需要将其改�?

    if (ImmIsIME(GetKeyboardLayout(0)))
    {
     CEGUI::DbcsSupport::injectChar(Key);
    }
    else
    {
     CEGUI::System->injectChar((CEGUI::utf32)Key);
    }

    ImmIsIME(GetKeyboardLayout(0))目的是用于检则现在的输入法是否打开的。如果是在输英文状态我想你不会画蛇添��的。��用这个需要imm32.lib的支持。MSDN上面也有说明�?br />5:最后就是添加一份代码到你的CEGUI使用��目里，如下�Q?br />namespace CEGUI{
bool DbcsSupport::injectChar(utf32 code_point )
{
#ifndef UNICODE
  static char     s_tempChar[3] = "";
  static wchar_t s_tempWchar[2] = L"";
  static bool s_flag = false;
  unsigned char uch = (unsigned char)code_point;
  if( uch >= 0xA1 )
  {
   if( !s_flag )
   {
    s_tempChar[0] = (char)uch; //�W�一个字�?br />    s_flag = true;
    return true;
   }
   else if( uch >= 0xA1 )
   {
    s_tempChar[1] = (char)uch; //�W�二个字�?br />    s_flag = false;
    MultiByteToWideChar( 0, 0, s_tempChar, 2, s_tempWchar, 1); //转成宽字�?br />    s_tempWchar[1] = L'\0';
    utf32 code = (utf32)s_tempWchar[0];
    //Font* fnt = System::getSingleton().getDefaultFont();
    return CEGUI::System::getSingleton().injectChar( code );
   }
   else
   {
    return CEGUI::System::getSingleton().injectChar(code_point);
   }
  }
  else
  {
   s_flag = false;
   return CEGUI::System::getSingleton().injectChar(code_point);
  }
#else
  return CEGUI::System::getSingleton().injectChar(code_point );
#endif
}
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1509217

清源游民 2007-02-28 10:25 发表评论

清源游民 — Wed, 01 Nov 2006 07:32:00 GMT

使用 cegui 来制作界�?, 不论在何�U��^��C�� , 有基本的三大步骤要做 :
1, 创徏一�?CEGUI::Render 实例
2, 创徏 CEGUI::System 对象
3, 调用各种�Ҏ��来渲染用��L��?
�W�一�?, 在我使用�?ogre 环境下��用以下代码来创徏 CEGUI::Render 实例
Ogre3D
CEGUI::OgreCEGUIRenderer* myRenderer =
       new CEGUI::OgreCEGUIRenderer(myRenderWindow);
�W�二步相当简�?, 可��?
new CEGUI::System(myRenderer);
�W�三步，基本上来�Ԍ��大部分��^��C��Q�如 direct3D, OpenGL, 我们在渲染��@环的��N��调用
CEGUI::System::renderGUI 来开始界面的渲染。如果我们��?ogre3d 引擎�Q�这一步不需�?
我们昄��的执行。因�?ogre 引擎已经考虑了�?
除了�q�三大步之外�Q�我们还有一些工作要做，首先�Q�我们需要加载数据文�Ӟ��q�且完成初始化工作�?
CEGUI 使用了许多类型的文�g�?CEGUI 使用一个称�?ResourceProvider 的帮助对象，用它来做为核�?CEGUI 库与外部文�g加蝲�pȝ��的接口。通过实现一个特定的 ResourceProvider 对象�Q?cegui 的渲染模块就可以与外部系�l�的资源��理器、文件加载子�pȝ��无缝地集成�?CEGUI 需要的数据文�g便可以通过外部�pȝ��提供的功能来�q�行加蝲�?CEGUI 中的大部分文件是�?XML 的文件格式来保存的。缺省情况下�Q?CEGUI 在内部��?Xerces-C++ 库来分析 XML 文�g�Q��?schema 来对 xml �q�行校验�Q?schema 文�g以标准的 .xsd 扩展名来保存 . 许多文�g本质上都�?XML 格式的文�Ӟ��但是�Ҏ��其意义不同，分别使用了不同的文�g扩展名�?
.Imageset 文�g可将一�q�图像看做若�q�小囑փ�的集合。换名话��_��是��一�q�图像的某个区域看做一�q�独立的囄��来��用�?
.Font 定义了在 CEGUI 中所使用的字体类型�?
.scheme 　可以��许多数据组合在一起��用，它也是装载与注册 widget 最方便的方法。在一�?.scheme 文�g中可以包括下列几�U�数据：
Imagest,font, window Set, window Alias
window set 指定了装载模块（ .dll �{�）的名�U�ͼ�和一�l�可以注册到�pȝ��中的 widget.
window alias 提供了别名的功能�Q�实现已�l�注册的 window/widget 的�Ş式上的隐藏�?
.Layout 　包含了窗口布局�?xml 表示。每个嵌套的 'window' 元素定义了被创徏�?window 或是 widget."Property" 元素定义了窗口的讄��与属性倹{�?
.config 是可供选择的配�|�文�Ӟ��他可指定一些缺省的属性�?
我们使用 CEGUI 来制作图形界面，臛_��要��用以下三�U�文�Ӟ��
.imageset, .Font . Scheme;
当然�Q�我们知道在一�?Scheme 中是可以包括 imageset �?Font 的�?
CEGUI::SchemeManager::getSingleton().loadScheme(�?./datafiles/schemes/TaharezLook.scheme�?;
// load in a font. The first font loaded automatically becomes the default font.
CEGUI::FontManager::getSingleton().createFont(�?./datafiles/fonts/Commonwealth-10.font�?;
对于 ogre 的��用者来�Ԍ��应该�?resources.cfg ��这些资源所在的目录加进厅R�?
我们可用下面的语句来指定 cegui 所需要的�~�省�?font �?cursor 资源�?
�?cegui 的概念里�Q�每�?widget 都是一�?window, 从编�E�的角度来讲�Q�每�?widget �c�都是从同一个相同的 window 基类�l�承而来�?. 因此�Q?widget �?window 有着基本相同的行为�?
�H�体的许多属性与讄��在窗口层树上是可以遗传的。高一�U�窗口的属性与行�ؓ会媄响到下一�U�窗口的属性与行�ؓ。例如附着在某�?window 上的 window �?widget 会被�?window 影响。当父窗口被 destroy �Ӟ��它所附属的所有的子窗口与 widget 也都��被 destroy.
创徏 CEGUI �H�口�Q�我们可以��用两�U��Ş式，一�?C �Q�＋代码�Q�二是编�?XML layout 文�g�?
注意�Q�在 CEGUI 中，所有的 window 都是�?WindowManager singleton object 来统一创徏的。我们首先得到这个对象：
using namespace CEGUI;
WindowManager& wmgr = WindowManager::getSingleton();
一般来�Ԍ��我们��L��创徏一�?DefaultWindow 来做为我们将使用的窗口的 Root, 在这�U�方式下�Q�我们会有比较好的灵�z�L��?
Window* myRoot = wmgr.createWindow(“DefaultWindow�? “root�?;
System::getSingleton().setGUISheet(myRoot);
createwindows() 函数所使用的第一个参敎ͼ�指明了将要创建的�H�口�c�d��Q�它一般是在我们��用的 .scheme 文�g中所注册�q�的�Q�当然还有一些系�l�定义的�Q��L��有效的窗口类型如上面所提到�?DefaultWindow.DefualtWindow 是不可见的，它只是做为所有窗口的 root 来��用�?
一般我们��L��要创��Z��?Framewindow, 它可以包括其他窗口与 widget �Q�本�w�也是可视的�?
FrameWindow* fWnd = (FrameWindow*)wmgr.createWindow(“TaharezLook/FrameWindow�? “testWindow�?;
之后�Q�我们将创徏的窗口挂�?root 上，形成一个层�ơ关�p�R�?
myRoot->addChildWindow(fWnd);
�~�辑 xml layout 文�g�Q�可使用专门提供的制作工兗��具体的使用�Ҏ��可以参阅相关文档�Q�这里说一下如何��用制作好�?xml layout 文�g�?
using namespace CEGUI;
Window* myRoot = WindowManager::getSingleton().loadWindowLayout(“test.layout�?;
System::getSingleton().setGUISheet(myRoot);
首先�Q�将 layout 文�g装蝲�q�来�Q�再指定根结炏V�?
CEGUI 本��n侦测用户输入�Q�这些不�?CEGUI 的责任，而是�E�序的员的责仅R��当有用户外部输入时�Q�我
们可以选择��这些消息告�?CEGUI �Q�这�?CEGUI 才会响应�?
�?ceguir::System �c�M��定义了一�l�函敎ͼ�它作为我们进行消息传递的接口�?
bool injectMouseMove(float delta_x, float delta_y);
bool injectMousePosition(float x_pos, float y_pos);
bool injectMouseLeaves(void);
bool injectMouseButtonDown(MouseButton button);
bool injectMouseButtonUp(MouseButton button);
bool injectKeyDown(uint key_code);
bool injectKeyUp(uint key_code);
bool injectChar(utf32 code_point);
bool injectMouseWheelChange(float delta);
bool injectTimePulse(float timeElapsed);
�q�些函数的返回��D��明了 CEGUI 是否已经��传入的消息 consume 掉了�?
CEGUI 使用回调机制来进行消息处理。可以�ؓ某个�H�体的特定事件注册一个函敎ͼ�当窗体事件发生时�Q?CEGUI 会自动调用所注册的函数�?
bool TutorialApplication::handlePopMenu(constCEGUI::EventArgs& e)
�?
// 。。。。。进行事件响�?
�?
void setupEventHandlers(void)
    {
       CEGUI::WindowManager& wmgr = CEGUI::WindowManager::getSingleton();
       wmgr .getWindow((CEGUI::utf8*)"MyButton")->subscribeEvent(
       CEGUI ::PushButton::EventClicked, CEGUI::Event::Subscriber(&TutorialApplication::handlePopMenu, this));
   }

EventClicked :: �pȝ��预定义的事�g . subscribeEvent:: 注册函数�Q�它事�g与响应函数联接在一赗��?
�?ogre �E�序中，当侦听器收到键盘�Q�鼠标消息时�Q�首先经�q�适当的�{换（ CEGUI 可以识别�Q�再传递给 CEGUI 。下面这个函数执行鼠标键标识转换�?
CEGUI::MouseButton convertOgreButtonToCegui(int buttonID)
{
       switch (buttonID)
       {
       case MouseEvent::BUTTON0_MASK:
              return CEGUI::LeftButton;
       case MouseEvent::BUTTON1_MASK:
              return CEGUI::RightButton;
       case MouseEvent::BUTTON2_MASK:
              return CEGUI::MiddleButton;
       case MouseEvent::BUTTON3_MASK:
              return CEGUI::X1Button;
       default:
              return CEGUI::LeftButton;
       }
}

��?CEGUI 需要知道的键盘�Q�鼠标消息告知它。即�?OGRE 处理�q�些消息旉��知 CEGUI 。以下这函数说明了用法�?
       void mouseMoved (MouseEvent *e)// 鼠标�U�d��
       {
              CEGUI::System::getSingleton().injectMouseMove(
                   e->getRelX() * mGUIRenderer->getWidth(),
                   e->getRelY() * mGUIRenderer->getHeight());
                   e->consume();
       }

       void mousePressed (MouseEvent *e)// 鼠标按下
       {
              CEGUI::System::getSingleton().injectMouseButtonDown(
               convertOgreButtonToCegui(e->getButtonID()));
             e->consume();
       }
       void mouseReleased (MouseEvent *e)// 鼠标弹�v
       {
              CEGUI::System::getSingleton().injectMouseButtonUp(
              convertOgreButtonToCegui(e->getButtonID()));
              e->consume();
       }

       void keyPressed(KeyEvent* e)// 键按�?
       {
              CEGUI::System::getSingleton().injectKeyDown(e->getKey());
              CEGUI::System::getSingleton().injectChar(e->getKeyChar());
              e->consume();
       }
       void keyReleased(KeyEvent* e)// 键弹�?
       {
             CEGUI::System::getSingleton().injectKeyUp(e->getKey());
             e->consume();

       }
�?CEGUI 中��用中文的问题�Q� �?现在�ȝ��了一下在 CEGUI 中显�C�Z��文需要注意的事项 :
    1 、将 simhei.ttf copy to \ogrenew\Samples\Media\gui
    2 、将 simhei-12.font 拷到上目录内容�ؓ

AutoScaled="true">
�Q?<---- 自己要用到的汉字�Q?

注意大小写！�Q?GlyphSet Glyphs 是在�E�序中要用到的汉字，它是�?cegui 预生成一个字�W�图像集用的�Q�想当然�?:-P �Q�如果修改了�q�个文�g�Q�注意要�?Unicode �Q?UTF-8 �Q�的�~�码来保存，�?vc7.1 中：文�g -> 高��保存选项   的 �?�~�码   栏中选择�?
    3 、在 TaharezLook.scheme �?
     后加�?
     注意大小�?
     以上是一些准备工�?
    4 、在自己的应用中讄��默认字体
    mGUISystem->setDefaultFont((CEGUI::utf8*)"Tahoma-12"); 改�ؓ
    mGUISystem->setDefaultFont((CEGUI::utf8*)"SimHei-12");
    5 、在自己的应用程序中��可以把相关�?Text 属性该��Z��文了�Q�如�Q?
    item = new CEGUI::ListboxTextItem((CEGUI::utf8*)" 退�?", 6);
    同样要注意的是要保存�?Unicode �Q?UTF-8 �Q�的�~�码。同时这些字要是�?simhei-12.font 中定义过的字�Q�当然也可以象那�?CEGUIChieseDemo
那样用动态生成如�Q?
    gfont->defineFontGlyphs(gfont->getAvailableGlyphs() + (utf8*)" 当前最佛_��q�_��的框架率三角 ");
    �~�译自己的程序，应该��可以看��C��文了�Q�罗嗦一下，��C��只要有汉字出现的文�g��׃��存�ؓ Unicode �Q?UTF-8 �Q�编码的�Q�！�Q?

清源游民 2006-11-01 15:32 发表评论

人物动画与绑定盒

清源游民 — Thu, 26 Oct 2006 08:30:00 GMT

在ogre�?当mesh被动�ȝ��时�?它的BoundingBox(AABB)是不更新�?由此不能用它�Ҏ��做�ؓ��撞��的代理.�q�个问题�ȝ��了好几天.最后是在论坛上扑ֈ�了答�?不能更新的原因有二。一是代价太高。二是有�?br />能硬件做skinng�Q�蒙皮）�Q�不能用软�g的方法访问硬件的数据�?/p>

清源游民 2006-10-26 16:30 发表评论

清源游民 — Tue, 24 Oct 2006 06:13:00 GMT

如果一个�h物有几个动画状�?而在�E�序中需要对动画状态作切换�?一定要��先前的那个状态关�?然后再作切换.
    //假设先前的动�ȝ��态是Wait,在切换到新的动画状态时,应该先将Wait��x��.��是�W�一句话:以下为可能的代码片断.
    mAnimationState->setEnabled(false);
    mAnimationState = mEntity->getAnimationState( "Walk" );
    mAnimationState->setLoop( true );
    mAnimationState->setEnabled( true);
   //2006.10.24

清源游民 2006-10-24 14:13 发表评论

国产日韩三区,国产主播精品在线,国产精品久久久久久av福利软件

Ogre3D嵌入Qt框架 之 ���结

《Pro Ogre 3D Programming》读书笔�?�?�W�十�?布告板与�_�子 �W�二部分

《Pro Ogre 3D Programming》读书笔�?�?�W�十�?布告板与�_�子 �W�一部分

《Pro Ogre 3D Programming�?��M���W�记 �?�W�九�?动画 �W�一部分

《Pro Ogre 3D Programming�?��M���W�记 �?�W�八�?渲染对象

《Pro Ogre 3D Programming�?��M���W�记 �?�W�七�?资源���理 �W�一部分

《Pro Ogre 3D Programming�?��M���W�记 �?�W�六�?材质 材质复制

《Pro Ogre 3D Programming�?��M���W�记 �?�W�六�?材质 概念

《Pro Ogre 3D Programming�?��M���W�记 �?�W�五�?场景���理 场景查询

《Pro Ogre 3D Programming�?��M���W�记 �?�W�五�?场景���理 地�Ş

《Pro Ogre 3D Programming�?��M���W�记 �?�W�五�?场景���理 �W�二部分

《Pro Ogre 3D Programming�?��M���W�记 �?�W�五�?场景���理 �W�一部分

《Pro Ogre 3D Programming�?��M���W�记 �?�W�四�?开始��用OGRE

《Pro Ogre 3D Programming�?��M���W�记 �?�W�三�?设计概要 �W�二部分

《Pro Ogre 3D Programming�?��M���W�记 �?�W�三�?设计概要 �W�一部分

ORGE(Eihort)学习�W�记之GUI Demo �W�三部分 CEGUI初步

Ogre 学习�W�记之 �Q�Ｇ�QԌ�I轨迹动画

OGRE学习�W�记�?配置文�g Resources.cfg

OGRE学习�W�记�?配置文�gPlugins.cfg

OGRE学习�W�记�?配置文�g Ogre.cfg

ORGE(Eihort)学习�W�记之GUI Demo �W�二部分 OIS输入

ORGE(Eihort)学习�W�记之GUI Demo �W�一部分 例子框架

�Q��{�Q�CEGUI 中文输入

人物动画与绑定盒

Ogre3D嵌入Qt框架之　��结

《Pro Ogre 3D Programming》读书笔�?�?�W�十�?布告板与�_�子　�W�二部分

《Pro Ogre 3D Programming》读书笔�?�?�W�十�?布告板与�_�子　�W�一部分

《Pro Ogre 3D Programming�?��M��W�记 �?�W�九�?动画 �W�一部分

《Pro Ogre 3D Programming�?��M��W�记 �?�W�八�?渲染对象

《Pro Ogre 3D Programming�?��M��W�记 �?�W�七�?资源��理 �W�一部分

《Pro Ogre 3D Programming�?��M��W�记 �?�W�六�?材质　材质复制

《Pro Ogre 3D Programming�?��M��W�记 �?�W�六�?材质　概念

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理　场景查询

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理　地�Ş

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理 �W�二部分

《Pro Ogre 3D Programming�?��M��W�记 �?�W�五�?场景��理 �W�一部分

《Pro Ogre 3D Programming�?��M��W�记 �?�W�四�?开始��用OGRE

《Pro Ogre 3D Programming�?��M��W�记 �?�W�三�?设计概要 �W�二部分

《Pro Ogre 3D Programming�?��M��W�记 �?�W�三�?设计概要　　�W�一部分

Ogre 学习�W�记之　�Q�Ｇ�QԌ�I轨迹动画

ORGE(Eihort)学习�W�记之GUI Demo �W�一部分例子框架