C++博客-野猪世界专注图形技术-随笔分类-Ogre

Ogre Terrain LayerTexture 的混合方式

野猪红 — Thu, 13 Dec 2012 05:07:00 GMT

if (!layer)
        {
            outStream << "    diffuse = diffuseSpecTex0.rgb;\n";
            if (prof->isLayerSpecularMappingEnabled())
                outStream << "    specular = diffuseSpecTex0.a;\n";
        }
        else
        {
            outStream << "    diffuse = lerp(diffuse, diffuseSpecTex" << layer
                << ".rgb, " << blendWeightStr << ");\n";
            if (prof->isLayerSpecularMappingEnabled())
                outStream << "    specular = lerp(specular, diffuseSpecTex" << layer
                    << ".a, " << blendWeightStr << ");\n";

        }

可以看出第一张地形纹理默认是显示出来的纹理如果后面还有其他层纹理则和其进行lerp

野猪红 2012-12-13 13:07 发表评论

libnoise 的一些改动

野猪红 — Tue, 27 Nov 2012 01:51:00 GMT

让Ogre的地形能自动产生连续随机高度的方法用到libnoise 发现其生成函数似乎有些不合适
对其实用工具的一些改动

1  void NoiseMapBuilderPlane::Build ()
2  {
3      if ( m_upperXBound <= m_lowerXBound
4          || m_upperZBound <= m_lowerZBound
5          || m_destWidth <= 0
6          || m_destHeight <= 0
7          || m_pSourceModule == NULL
8          || m_pDestNoiseMap == NULL)
9      {
10          throw noise::ExceptionInvalidParam ();
11      }
12
13      // Resize the destination noise map so that it can store the new output
14      // values from the source model.
15      m_pDestNoiseMap->SetSize (m_destWidth, m_destHeight);
16
17      // Create the plane model.
18      model::Plane planeModel;
19      planeModel.SetModule (*m_pSourceModule);
20
21      double xExtent = m_upperXBound - m_lowerXBound;
22      double zExtent = m_upperZBound - m_lowerZBound;
23      double xDelta  = xExtent / (double)(m_destWidth-1) ;
24      double zDelta  = zExtent / (double)(m_destHeight-1);
25      double xCur    = m_lowerXBound;
26      double zCur    = m_lowerZBound;
27
28      // Fill every point in the noise map with the output values from the model.
29      for (int z = 0; z < m_destHeight; z++)
30      {
31          if(z==m_destHeight-1)
32              zCur=m_upperZBound;
33          float* pDest = m_pDestNoiseMap->GetSlabPtr (z);
34          xCur = m_lowerXBound;
35          for (int x = 0; x < m_destWidth; x++)
36          {
37              if(x==m_destWidth-1)
38                  xCur = m_upperXBound;
39              float finalValue;
40
41              finalValue = planeModel.GetValue (xCur, zCur);
42
43              *pDest++ = finalValue;
44              xCur += xDelta;
45          }
46          zCur += zDelta;
47          if (m_pCallback != NULL)
48          {
49              m_pCallback (z);
50          }
51      }
52  }
53

实现无缝的地形高度拼接

野猪红 2012-11-27 09:51 发表评论

ogre paging 的魔法

野猪红 — Mon, 19 Nov 2012 08:52:00 GMT

让子弹再飞一会
好的 ogre的page 本身比较复杂层次比较多 OgreTerrain简化了其实现
如下图：
                   ->pagedWord
                                       ->pagedWorldSection(TerrainGroup)->Terrains
pageManager->pagedWord->pagedWorldSection(TerrainGroup)->Terrains
                                      ->pagedWorldSection(TerrainGroup)->Terrains
                   .....

当然 pagedWorldSection含有page 其本身内部采用TerrainGroup的实现
好继续
看看ogre自带的terrain例子是个好的开始
我开始摇滚了
我们要paging 于是在terrain.h中打开#define paging（去掉注释就可以了）
编译运行我假设你的ogre是启用了boost thread的
好出错了吗没有？靠反正我是出错了 FileNotFound 仔细看是没找到类似terrain0000000.dat的文件靠靠靠
在其media下看看是没有这个文件嘛
好的先关掉paging 注释#define paging 编译运行一切OK 地形能出来如果你保存了该地形那么在media在会有一个类似terrain0000000000.dat的文件
好让我们来分析下
通过查看TerrainPagedWorldSection.cpp的代码
找到函数loadPage()
我们可以看到defineTerrain(x,y)的代码好这个函数会默认根据x,y产生一个文件名然后该terrain将会从该文件中载入地形高度等信息如果没有这个文件当然就报错了
解决思想是先看看有没有该文件如果没有就使用defineTerrain(x,y,0) 即默认高度为0的一个地形

1    void TerrainPagedWorldSection::loadPage(PageID pageID, bool forceSynchronous)
2    {
3        if (!mParent->getManager()->getPagingOperationsEnabled())
4            return;
5
6        PageMap::iterator i = mPages.find(pageID);
7        if (i == mPages.end())
8        {
9            // trigger terrain load
10            long x, y;
11            // pageID is the same as a packed index
12            mTerrainGroup->unpackIndex(pageID, &x, &y);
13
14            Ogre::String geneFileName = mTerrainGroup->generateFilename(x,y);
15            if(Ogre::ResourceGroupManager::getSingleton().resourceExistsInAnyGroup(geneFileName))
16            {
17                mTerrainGroup->defineTerrain(x, y);
18            }
19            else
20            {
21                mTerrainGroup->defineTerrain(x,y,0.0f);
22            }
23            mTerrainGroup->loadTerrain(x, y, forceSynchronous);
24        }
25
26        PagedWorldSection::loadPage(pageID, forceSynchronous);
27    }
28

再次打开#define paging
OK OVER

野猪红 2012-11-19 16:52 发表评论

ogre 中的线程 workqueue

野猪红 — Fri, 09 Nov 2012 08:01:00 GMT

好我开始ogre 线程
怎么说呢有个workqueue
初始化时创建几个线程这些线程监听请求队列和结果队列请求队列里面有一些请求
线程函数就是不断从其请求队列里弹出一个请求来处理处理完后把处理结果放结果队列里
主线程会不断查看结果队列处理相应结果
用户需要设置下请求和结果的回调函数看些例子：

1        WorkQueue* wq = Root::getSingleton().getWorkQueue();
2        mWorkQueueChannel = wq->getChannel("Ogre/TerrainGroup");
3        wq->addRequestHandler(mWorkQueueChannel, this);
4        wq->addResponseHandler(mWorkQueueChannel, this);

第二个参数就是那个继承了回调函数的类这样当有请求过来时就会在后台调用RequestHandler的回调函数完成后把结果放
结果队列主线程检测到后就调用我们设置的回调函数来处理
现在假如我们要加一个请求看些例子：

1 WorkQueue::RequestID DefaultWorkQueueBase::addRequest(uint16 channel, uint16 requestType,
2 const Any& rData, uint8 retryCount, bool forceSynchronous)

注意一个channel的参数在加回调函数和加请求时都有用到相同channel的请求都会使用那个请求所对应的handlers
如果有多个handlers 那会依次调用看下代码：

1for (RequestHandlerList::reverse_iterator j = handlers.rbegin(); j != handlers.rend(); ++j)
2            {
3                // threadsafe call which tests canHandleRequest and calls it if so
4                response = (*j)->handleRequest(r, this);
5
6                if (response)
7                    break;
8            }
9
10Response* handleRequest(const Request* req, const WorkQueue* srcQ)
11            {
12                // Read mutex so that multiple requests can be processed by the
13                // same handler in parallel if required
14                OGRE_LOCK_RW_MUTEX_READ(mRWMutex);
15                Response* response = 0;
16                if (mHandler)
17                {
18                    if (mHandler->canHandleRequest(req, srcQ))
19                    {
20                        response = mHandler->handleRequest(req, srcQ);
21                    }
22                }
23                return response;
24            }

每次处理请求之前会调用canHandleRequest()查看是否能用该handler处理当然只要返回一个结果后续的handler就不处理了
基本上就是这样子 GoodLuck

野猪红 2012-11-09 16:01 发表评论

ogre 渲染流程

野猪红 — Sat, 08 Jan 2011 10:31:00 GMT

ogre渲染流程：
    1. _fireFrameStarted()
    2. 按某种优先级更新所有渲染目标
      2.1 firePreUpdate()
      2.2 更新所有视口
        2.2.1 fireViewportPreUpdate()
        2.2.2 场景管理的渲染函数
          2.2.2.1 更新阴影
          2.2.2.2 更新动画
          2.2.2.3 更新节点
          2.2.2.4 更新一些参数
          2.2.2.5 清空渲染队列
          2.2.2.6 填充渲染队列进行可见性判别
            2.2.2.6.1 firePreFindVisibleObjects()
            2.2.2.6.2 查找可见节点并加入渲染队列
            2.2.2.6.3 firePostFindVisibleObjects()

firePreRenderQueues();

          2.2.2.7 依次渲染每个队列组
            2.2.2.7.1 fireRenderQueueStarted()
            2.2.2.7.2 渲染该队列组

fireRenderSingleObject()

                                   preRender()
                                   渲染
                                   postRender()

2.2.2.7.3 fireRenderQueueEnded()

firePostRenderQueues();

        2.2.3 fireViewportPostUpdate()
      2.3 firePostUpdate()
    3. _fireFrameRenderingQueued()
    4. swapBuffer()
    5. _fireFrameEnded()