osg实例介绍

glAccum介绍如下：
引用内容
void glAccum(GLenum op, GLfloat value)
op值用于指定操作类型，包括：
GL_ACCUM    从指定的颜色缓存里面读取像素数据，将其像素值（R, G, B, A）乘以value的结果加上累积缓存里面的值以后再保存到累积缓存；
GL_LOAD     从指定的颜色缓存里面读取像素数据，将其像素值乘以value的结果直接保存到累积缓存；
GL_ADD      将累积缓存里面的像素值与value相加以后保存到累积缓存；
GL_MULT     将累积缓存里面的像素值与value相乘以后保存到累积缓存；
GL_RETURN   将累积缓存里面的像素值乘以value以后保存到指定的颜色缓存；
在这个例子中，用到了GL_MULT、GL_ACCUM、GL_RETURN。
在主程序中osg::DisplaySettings::instance()->setMinimumNumAccumBits(8,8,8,8);设置了积累缓冲区各位数。
然后，osgViewer::Viewer::Windows windows;
    viewer.getWindows(windows);
    for
(osgViewer::Viewer::Windows::iterator itr = windows.begin();
        itr != 
windows.end();
        ++itr)
    {
        (*itr)->add(new MotionBlurOperation

(persistence));
    }在视景体中每个图形窗体都添加了MotionBlurOperation类，MotionBlurOperation继承Operation，在virtual void operator () (osg::Object* object)方
法中如果是第一次渲染，则清楚积累缓冲区的值，glClearColor(0, 0, 0, 0);         
glClear(GL_ACCUM_BUFFER_BIT);
之后，glAccum(GL_MULT, s);
        glAccum(GL_ACCUM, 1 - s);
        glAccum(GL_RETURN, 1.0f);通过这三个函数计算。
我们一个一个的进行说明，首先，glAccum(GL_MULT, s);积累缓冲区中的值乘以s，结果写进积累缓冲区中，glAccum(GL_ACCUM, 1 - s);然后，颜色缓冲区中的值乘以1-s，结果写入积累缓冲区中，最后，glAccum(GL_RETURN, 1.0f);把积累缓存区中的值乘以1，写入颜色缓存区中，完成运动模糊的效果，这里可以看出积累缓冲区中的值只有一份，是每一帧不同比率的一个累计，也就是说第一帧的累计效果也是存在的，只是随着帧数的增加，第一帧的影像比率趋近于0了。这几个函数中不难得出，s值越大，前几帧的效果存在的时间越长，运动模糊效果越明显，如果s趋近于1，程序将很长时间是黑屏，因为glClearColor(0, 0, 0, 0);glClear(GL_ACCUM_BUFFER_BIT);积累缓冲区颜色值为黑色，s趋近于1，第一帧的影像非常大，所以很长时间一直为最初的颜色——黑色。

这里必须要深入研究一下，glAccum应用的时刻，以上的说明中可以看出，glAccum应该是一帧中颜色缓冲区中的值计算完之后应用，在这个例子中用了otionBlurOperation，
MotionBlurOperation继承Operation。我们就看看Operation是做什么的。到了Operation的定义，说它是实现图形操作的基类，子类必须重写virtual void operator () (Object*) = 0;方法，实现相应的功能。在GraphicsContext类中typedef std::list< ref_ptr<Operation> > GraphicsOperationQueue; GraphicsOperationQueue              _operations;定义了一个Operation类型的一个链表，这个链表又在什么地方应用的了？还回到GraphicsContext::runOperations()中，记得上一篇osgmemorytest例子中，提到过GraphicsContext::runOperations()，在这里实现(*(camera->getRenderer()))(this);渲染工作。这一次我们又找的了这个函数，(*_currentOperation)(this);遍历_operations这个链表，然后执行每个Operation中的operator () (Object*)方法，从runOperations()这个函数中，我们知道了osg的渲染过程，先进行渲染，然后在执行_operations中的操作。
我们回到例子中，MotionBlurOperation这个类，把它加入到了所有的图形上下文中osgViewer::Viewer::Windows windows;    viewer.getWindows(windows);
    for

(osgViewer::Viewer::Windows::iterator itr = windows.begin();
        itr != 
windows.end();
        ++itr)
    {
        (*itr)->add(new MotionBlurOperation
(persistence));
    }，glAccum函数执行的时候正好和我们之前所判断的一样，先渲染，渲染后对颜色缓存区中的值进行累积。

对这个例子和积累缓冲区总算有了一些理解，但这里还存在一个问题，如果想只对场景中的某个部分做运动模糊应该如何处理？？？比如有一个足球场，一个运动中的足球，只对这个足球进行运动模糊处理，如何去做？？？

这个问题自己还没有去验证，自己想的一个大概方法是，相同位置的的两个相机，一个关注足球之外的场景，不做运动模糊处理；另外一个只关注足球，做运动模糊处理，然后，两幅场景融合为一个场景。

作者：yungis 发表于2013/7/30 23:44:12 原文链接

阅读：518 评论：1 查看评论

renderingTraversals中最主要的还进行了剔除（CullVisitor），这里不多说，主要说OSG中OpenGL的状态的执行。

进入renderingTraversals函数内部，找到(*itr)->runOperations();（对于单线程来说），这句话进行了场景的绘制工作。顺着这个藤一直摸下去，为了思路清晰，列出序号：
1、调用了GraphicsContext::runOperations()；
2、在GraphicsContext::runOperations()中找到(*(camera->getRenderer()))(this);
3、跟到了Renderer中的void Renderer:perator () (osg::GraphicsContext* context)
{  
if (_graphicsThreadDoesCull)
    {
        cull_draw();
    }
    else
    {
        draw();
    }
}。
4、在Renderer的draw方法中找到了 sceneView->draw();
5、如果不需要立体显示，在 sceneView->draw();中会找到_renderStage->drawPreRenderStages(_renderInfo,previous);
_renderStage->draw(_renderInfo,previous);
6、然后执行了RenderStage中的drawInner
7、RenderBin::draw(renderInfo,previous);
8、drawImplementation(renderInfo,previous);
9、RenderLeaf* rl = dw_itr->get();     rl->render(renderInfo,previous);
10、state.apply(rg->getStateSet());_drawable->draw(renderInfo);最终实现绘制
好复杂的一条路了，对于多线程而言与以上的步骤有些不同，但大体差不多。

几个重要的类，GraphicsContext--Renderer--SceneView--RenderStage（RenderBin）--RenderLeaf--Drawable。

最终的实现都在具体的Drawable中，就像上面说的，无论是加载的模型还是自己绘制的几何体，最后都是Drawable。这样最终会调用可用的Drawable实现绘制。
以上这么一条复杂的路线，要重点说的是第10步中的state.apply(rg->getStateSet());

下面从这个调用说起，State存储了OpenGL需要的所有的状态，是OSG与OpenGL状态的接口，进入这个函数中看看做了什么。
在这个函数中找到了applyAttributeList(_attributeMap,dstate->getAttributeList());这么一句话，深入下去。循环调用了applyAttribute这个函数，而传递的就是StateAttribute，这就是OSG中某个状态属性，在applyAttribute中找到了attribute->apply(*this);状态属性执行了apply把State传入进去。进入StateAttribute中的apply，不禁大失所望，什么也没有？？

StateAttribute是基类，打开API文档，看看继承StateAttribute的状态属性吧，有几十个之多，我们重点找几个看看。
Fog，进入Fog的Fog::apply(State& state)，在这里看见了OpenGL函数，glFogi以及一系列的设置。
PolygonOffset，进入PolygonOffset的PolygonOffset::apply(State&)，在这里看见了glPolygonOffset执行多边形偏移。
Texture2D，进入Texture2D::apply(State& state)，在这里看见了glTexImage2D。
...
attribute->apply(*this)这么短短的一句话，就执行了所有状态属性的设置。
这篇文章的标题是osgmemorytest，怎么绕了这么多？下面回到osgmemorytest例子中。

定义了好多的基类，MemoryTest、GLObject、GLMemoryTest。
有用的是ContextTest，osg::ref_ptr<osg::GraphicsContext> window = osg::GraphicsContext::createGraphicsContext(traits.get());创建了GraphicsContext，根据pbuffer来决定是PixelBuffer还是Window。
StateAttributeObject中执行了_attribute->apply(*renderInfo.getState());看到这里就知道了为什么上面说了那么多，都是在说这个类的作用。
TextureTest中最终都调用了StateAttributeObject。
FboTest中也调用了StateAttributeObject。
DrawableObject调用了_drawable->draw(renderInfo);
GeometryTest调用了DrawableObject中的函数。

从以上几个类的功能来说，不难看出他们所作的事情，1、创建窗口；2、设置状态；3、绘制；
因此整个的例子大体上描绘了OSG渲染的一个过程，而main函数中所做的就是创建窗口、设置状态、绘制。打印出contexts数目，objects applied次数已经执行所用的实际。

作者：yungis 发表于2013/6/7 23:32:32 原文链接

阅读：600 评论：0 查看评论

作者：yungis 发表于2013/6/6 23:47:56 原文链接

阅读：580 评论：1 查看评论

作者：yungis 发表于2013/4/27 7:58:37 原文链接

阅读：2025 评论：0 查看评论

(eyevector*_normal,eyevector*side);
                billboardRotation.makeRotate
(osg::PI_2-angle,_axis);
            }
            matrix.preMultTranslate(_position);

matrix.preMultRotate(billboardRotation);
            matrix.preMultRotate
(_attitude);
            matrix.preMultTranslate(-_pivotPoint);
            return 
true;
        }实现节点一直朝向屏幕
看看Billboard
Billboard是在CullVisitor  void CullVisitor::apply(Billboard& node)的时候也是获取视点
坐标，调用computeMatrix来实现的，根据不同的设置方法计算computeMatrix(Matrix& 
modelview, const Vec3& eye_local, const Vec3& pos_local) const中的modelview。
AutoTransform也是在AutoTransform::computeLocalToWorldMatrix(Matrix& 
matrix,NodeVisitor*)中计算computeMatrix()修改_cachedMatrix.makeRotate(_rotation);
    
_cachedMatrix.postMultTranslate(_position);
    _cachedMatrix.preMultScale(_scale);
   
 _cachedMatrix.preMultTranslate(-_pivotPoint);这几个影响节点编号的属性来实现的。
总结起来，他们都是在剔除的过程中通过CullVisitor的apply方法，调用各自的方法来完成朝向

屏幕矩阵的计算。

作者：yungis 发表于2013/4/23 7:55:50 原文链接

阅读：645 评论：0 查看评论

作者：yungis 发表于2013/4/22 7:36:58 原文链接

阅读：371 评论：0 查看评论

_sector;
        osg::ref_ptr<BlinkSequence> _blinkSequence;
        BlendingMode      
          _blendingMode;
是否打开、位置、颜色、强度、半径、扇区、闪烁、模式
从以上的属性可以指定，这个光点可以调整大小位置，可以运动可以变换颜色，闪烁效果。
而LightPointNode是光点节点，里面保存了一个光点列表typedef std::vector< LightPoint > 
LightPointList;
SequenceGroup用于关联一组序列，内部只有一个基本时刻double      _baseTime;
BlinkSequence闪烁序列，内部的属性：double                      _pulsePeriod;
       
double                      _phaseShift;
        PulseData                   
_pulseData;
        osg::ref_ptr<SequenceGroup> _sequenceGroup;从中可以看出可以添加很
多脉冲，每个脉冲的间隔、停顿等。它属于LightPoint光点的一个属性，也就说一个光点可以以
SequenceGroup定义的基本时间为基本仿真时间，根据BlinkSequence中设置的变换颜色和光点强
度和脉冲。
明白了以上几个类之间的关系，这个例子就很好理解了。
在createLightPointsDatabase函数中创建了很多光点，设定了位置和颜色的变换范围，里面有
一个：
lpn->setPointSprite设置了光点添加纹理使用模糊的效果，必须指定0纹理单元（后面研究实现
方法）。
CreateBlinkSequenceLightNode函数创建了闪烁的光点，设置序列组，添加脉冲，设置强度位置
等等。
我们详细的研究一下LightPointNode，说是光点节点，但是它本身不发光，但可以通过其他方式
模拟出发光的效果。这个节点很特别，在osg中节点组成场景树，通过剔除遍历场景树构建状态
树和渲染树，如果让我们自己实现这个LightPointNode节点，我们想到的方式可能是
LightPointNode : public osg:Geode让他继承geode，然后adddrawable把光点的drawable添加
进去进行渲染。
而实际中LightPointNode并没有采用这种方法，而是继承Node，并且没有add任何的子节点。所
有的的功能都是在traverse递归的时候实现的。
这就涉及到了如何跳过场景树去绘制节点，答案是在剔除的时候去手动构建状态树，我们进入代
码看看是怎么样手动构建的。
首先 osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);用于判断只
有在剔除遍历的时候才继续运行下面的代码，
osg::Matrix matrix = *(cv->getModelViewMatrix());
        osg::RefMatrix& projection 
= *(cv->getProjectionMatrix());
        osgUtil::StateGraph* rg = cv-
>getCurrentStateGraph();
        if (rg->leaves_empty())
        {
            // this 
is first leaf to be added to StateGraph
            // and therefore should not 
already know current render bin,
            // so need to add it.
            cv-
>getCurrentRenderBin()->addStateGraph(rg);
        }
获取模型视图矩阵、获取投影矩阵、获取当前的渲染根节点。
typeid(*object)==typeid(LightPointDrawable)
用于判断object是否是(LightPointDrawable)类型的，如果是返回true否则返回false。
接下来 drawable = _pointSprites ? new LightPointSpriteDrawable : new 
LightPointDrawable;
这里我们看到了_pointSprites ，这就是是否让LightPointNode使用纹理，如果使用纹理则new 
LightPointSpriteDrawable否则new LightPointDrawable。并且把这个drawable设置成了当前的
userdata。
接下来把这个drawable收到的添加到rg->addLeaf(new osgUtil::RenderLeaf
(drawable,&projection,NULL,FLT_MAX));渲染叶中，到目前为止需要注意，这个drawable中还
没有任何内容，接下来就需要根据_lightPointList去向这个drawable添加绘制的内容，注意添
加addBlendedLightPoint和addAdditiveLightPoint。
现在我们进入LightPointDrawable中一看究竟，LightPointDrawable继承Drawable，需实现
drawImplementation接口，关于drawImplementation我们会在不久的以后进行详细的研究。
这里根据_sizedOpaqueLightPointList、_sizedBlendedLightPointList、
_sizedAdditiveLightPointList中的内容进行了绘制，在这里面看到了状态的切换，看到了
opengl的代码。
再补充一下，LightPointDrawable中没有应用模糊纹理，因此state.applyTextureMode
(0,GL_TEXTURE_1D,false);
    state.applyTextureMode(0,GL_TEXTURE_2D,false);
而看看LightPointSpriteDrawable，state.applyTextureMode(0,GL_TEXTURE_2D,true);这里应
用了纹理，这就是两者差别的体现。
研究完了这一趟，似乎触及到了osg中核心的一些东西。至于我们刚才提出的问题为什么没有把
他设计成Geode，而是继承Node，接下来大家一起思考。

作者：yungis 发表于2013/4/19 7:43:24 原文链接

阅读：510 评论：0 查看评论

matrix,NodeVisitor*) const
{
    if (_referenceFrame==RELATIVE_RF)
    {
        
matrix.preMultTranslate(_position);
        matrix.preMultRotate(_attitude);
        
matrix.preMultScale(_scale);
        matrix.preMultTranslate(-_pivotPoint);
    }
    
else // absolute
    {
        matrix.makeRotate(_attitude);
        
matrix.postMultTranslate(_position);
        matrix.preMultScale(_scale);
        
matrix.preMultTranslate(-_pivotPoint);
    }
    return true;
}
则与顺序无关，完全是按着_scale*_attitude*_position*matrix
而_pivotPoint指定了变换轴，最终把节点移动到变换轴处。
关于RELATIVE_RF和ABSOLUTE_RF我们前面的例子介绍过。
我们回到例子中:
createRoom函数中创建了一个正方体，里面有个
osg::PositionAttitudeTransform* pat = new osg::PositionAttitudeTransform();
pat添加了ModelTransformCallback根据仿真时间重新计算姿态。       pat->setPivotPoint
(loaded_bs.center());
有了上面的介绍我们就很容易理解了，设置节点的包围球中心为轴心。
osg::StateSet* wall = new osg::StateSet;
    wall->setMode
(GL_CULL_FACE,osg::StateAttribute::ON);
设置GL_CULL_FACE打开，即节点的正面被裁切，实现朝着观察者的面不绘制的效果。
createWall绘制一面墙
osgUtil::SmoothingVisitor::smooth(*geom);自动计算了法向量。
createLights创建灯。
我们着重研究一下这个函数
LightSource继承Group，是场景中的光源节点，保存了一个ref_ptr<Light>                  
_light;Light是具体的光照类，内部保存了如下属性：
int _lightnum;                           // OpenGL light number
        Vec4

_ambient;                           // r, g, b, w
        Vec4 _diffuse;

// r, g, b, w
        Vec4 _specular;                          // r, g,

b, w
        Vec4 _position;                          // x, y, z, w
        Vec3

_direction;                         // x, y, z
        float _constant_attenuation;

// constant
        float _linear_attenuation;               // linear
      
  float _quadratic_attenuation;            // quadratic
        float _spot_exponent;

// exponent
        float _spot_cutoff;                      //

spread
一个光源的基本属性颜色衰减等，_lightnum是与opengl的光源id相对于，默认为0。
在createLights这个函数中创建了两个光源，把一个点和一个光源添加到MatrixTransform中，
这样模拟了点就是光源的效果，MatrixTransform中添加了AnimationPathCallback一个动画，
光源AnimationPathCallback我们之前的例子中研究过，很按着指定的路径运动。
最后一点    viewer.getCamera()->setCullingMode( viewer.getCamera()->getCullingMode() 
& ~osg::CullStack::SMALL_FEATURE_CULLING);
去除了细节裁剪，这样在场景剔除的时候就不会用到SMALL_FEATURE_CULLING。

作者：yungis 发表于2013/4/17 7:54:12 原文链接

阅读：615 评论：1 查看评论

作者：yungis 发表于2013/4/12 7:37:23 原文链接

阅读：343 评论：0 查看评论

(iv.getProjectionMatrix()) matrix.preMult( *iv.getProjectionMatrix() );
            
if (iv.getViewMatrix()) matrix.preMult( *iv.getViewMatrix() );
            if 
(iv.getModelMatrix()) matrix.preMult( *iv.getModelMatrix() );
            break;
      
  case(PROJECTION):
            if (iv.getProjectionMatrix()) matrix.preMult(

*iv.getProjectionMatrix() );
            if (iv.getViewMatrix()) matrix.preMult(

*iv.getViewMatrix() );
            if (iv.getModelMatrix()) matrix.preMult(

*iv.getModelMatrix() );
            break;
        case(VIEW):
            if

(iv.getViewMatrix()) matrix.preMult( *iv.getViewMatrix() );
            if

(iv.getModelMatrix()) matrix.preMult( *iv.getModelMatrix() );
            break;
      
  case(MODEL):
            if (iv.getModelMatrix()) matrix = *iv.getModelMatrix();
    
        break;
    }
无论是哪一种方式，最终都转换到了世界坐标。
2、LineSegmentIntersector；使用构造函数LineSegmentIntersector(CoordinateFrame cf, 
double x, double y);指定一点求交。
所以为了更精确的球交，应使用osgUtil::Intersector::WINDOW窗口坐标，viewer->getCamera
()->accept(iv);
toggleScribe函数就是使用osgFX::Scribe实现框体选中的效果。

作者：yungis 发表于2013/4/11 7:05:25 原文链接

阅读：499 评论：0 查看评论

作者：yungis 发表于2013/4/11 6:18:42 原文链接

阅读：313 评论：0 查看评论

if (kdtree_str)
    {
        bool switchOff = (strcmp(kdtree_str, "off")==0 ||

strcmp(kdtree_str, "OFF")==0 || strcmp(kdtree_str, "Off")==0 );
        if

(switchOff) _buildKdTreesHint = Options::DO_NOT_BUILD_KDTREES;
        else 
_buildKdTreesHint = Options::BUILD_KDTREES;
    }
从这里可以看出KdTreeBuilder是构建KDTree的地方，首先，KDTree没有指定，读取环境变量，
如果环境变量中没有off字样的就设置Options::BUILD_KDTREES;可见在osg默认是构建了KDTree
的。顺着这些信息看看，KDTree是在什么地方构建的？
在DatabasePager中我们可以看到如下的代码：
_kdTreeBuilder = osgDB::Registry::instance()->getKdTreeBuilder()->clone();
virtual void apply(osg::Geode& geode)
    {
        StateToCompile::apply(geode);

if (_kdTreeBuilder.valid())
        {
            geode.accept(*_kdTreeBuilder);
   }
    }
他们都在FindCompileableGLObjectsVisitor这个类中，DatabasePager分页数据库，管理
PagedLOD和ProxyNode的，里面存放了数据请求列表、数据等待删除列表、数据等待编译列表、
数据等待融合场景列表、而这个类就是查找需要编译的数据。（具体内容看《最长的一帧》）
KDTree就是在这里构建的。
KdTreeBuilder是构建的关键类，不用说继承自NodeVisitor，要遍历场景的。里面只有void 
apply(osg::Geode& geode);因为它只对几何体感兴趣。
KDTree的构建把我们带到了KDTree这个类中，具体的算法不做分析了，KDTree的用法在上次求交
的例子中有了应用，求交更加精确。
Registry是一个单例，在程序的运行中只有一个对象，因此这个的程序中又有一个
KdTreeBuilder。

作者：yungis 发表于2013/4/9 7:36:45 原文链接

阅读：1030 评论：0 查看评论

(traversalMask);
    _intersectionVisitor.setIntersector( intersectorGroup.get() );
相交访问器重置，设置掩码，添加相交的数据Intersector，Intersector有四个子类，用于和场
景求交。
 scene->accept(_intersectionVisitor);
通过这个函数遍历场景计算相交的点。在IntersectionVisitor中，inline void intersect
(osg::Drawable* drawable) { _intersectorStack.back()->intersect(*this, drawable); }
是具体的求交的方法，具体的算法隐藏在子类中，线段相交的算法在
LineSegmentIntersector::intersect(osgUtil::IntersectionVisitor& iv, osg::Drawable* 
drawable)中，具体的实现算法我们不做研究，从中可以看到KdTree，这个类为场景的求交提供
了更加精确的工具，之后我们马上就会研究这个东西。
接下来，就可以获取相交的成果了，
 osgUtil::LineSegmentIntersector::Intersections& intersections = lsi-
>getIntersections();
            
            for
(osgUtil::LineSegmentIntersector::Intersections::iterator itr = intersections.begin
();
                itr != intersections.end();
                ++itr)
            {
   
            const osgUtil::LineSegmentIntersector::Intersection& intersection = 
*itr;
                if (intersection.matrix.valid()) intersectionsLOS.push_back( 
intersection.localIntersectionPoint * (*intersection.matrix) );
                else 
intersectionsLOS.push_back( intersection.localIntersectionPoint  );
            }
从中获取相交的点。
这里我们不妨思考一下，在osg中为什么有那么多的visitor和callback存在呢？无论什么功能都
使用的visitor，我想osg作为一种非常成熟的渲染引擎，必须从构架上清晰，这些visitor都是
osg的扩展功能，不能影响总体架构。更重要是是osg采用的是树状结构构建场景、进行渲染的，
通过这个visitor很容易实现递归遍历场景，这就是访问者模式应用之所在，而callback提供了
一种扩展的接口。而且在visitor过程中存在很多成对的东西，如：push/pop、在求交访问器中
存在enter/leave，这就是访问者进入-离开，没有改变场景。访问者模式的缺点也就清除了，他
必须重载所有的节点类，如果osg中有新的节点类型添加，改动会很大。
离题万里了，回到例子中，看看HeightAboveTerrain，功能也类似，求的是和地形的交点，这个
地形就具有具体的空间参考了。
接下来，求出求交时间，打印交点。
ElevationSlice求的面与地形的交点。
else if中没有应用osg封装的类，直接使用LineSegmentIntersector求交，当然，这样只会对当
前场景进行计算，如果有PagedLOD，则不会加载，然后打印出结果。

作者：yungis 发表于2013/4/8 7:55:42 原文链接

阅读：1503 评论：0 查看评论

itr=_children.begin();
        itr!=_children.end();
        ++itr)
    {
(*itr)->accept(nv);
    }
}
这是Group的递归，直接遍历所有的子节点。
再来看看LOD的递归调用，
for(unsigned int i=0;i<numChildren;++i)
            {    
                if 
(_rangeList[i].first<=required_range && required_range<_rangeList[i].second)
         
       {
                    _children[i]->accept(nv);
                }
            }
是的，判断了该节点是否在指定的视野内，如果不在就不进行递归调用，这样在osg中无论是更
行回调、事件回调、裁切回调，包括自己实现的回调，都会进行判断，不在视野内就忽略。
而在Impostor中的traverse呢，通过ImpostorSprite创建图片代替，在createImpostorSprite这
个函数中实现具体的图片创建过程，通过帧缓存对象，把节点选择到纹理中。
回到例子中，CreateHouses()创建了一个房子模型，加入到nodes中，LayoutAsGrid()函数通过
代替节点加入400个模型，
osgSim::Impostor * impostor = new osgSim::Impostor();
            impostor-
>setImpostorThreshold(static_cast<float> (Threshold));
            impostor-
>addChild(groups[i]);
            impostor->setRange(0, 0.0f, 1e7f);
         
impostor->setCenter(groups[i]->getBound().center());
设置代替节点的参数。
TestManipulator继承CameraManipulator，测试的操作器。写自己的操作器只需重写几个类就可
以实现，
 /** set the position of the matrix manipulator using a 4x4 Matrix.*/
        virtual 
void setByMatrix(const osg::Matrixd& matrix);
        /** set the position of the 
matrix manipulator using a 4x4 Matrix.*/
        virtual void setByInverseMatrix
(const osg::Matrixd& matrix) { setByMatrix(osg::Matrixd::inverse(matrix)); 
/** get the position of the manipulator as 4x4 Matrix.*/
        virtual osg::Matrixd 
getMatrix() const;
        /** get the position of the manipulator as a inverse 
matrix of the manipulator, typically used as a model view matrix.*/
        virtual 
osg::Matrixd getInverseMatrix() const;
最重要的是getInverseMatrix这个函数，osg中每一帧的更新回调会调用操作器的这个函数赋值
给相机，实现相机的更新。
virtual void setNode(osg::Node*);
/** Move the camera to the default position. 
            May be ignored by 
manipulators if home functionality is not appropriate.*/
        virtual void home
(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
      
        /** 
Start/restart the manipulator.*/
        virtual void init(const 
osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
        /** handle events, 
return true if handled, false otherwise.*/
        virtual bool handle(const 
osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
这几个函数在重写的时候也经常用到，设置中心节点，初始位置、初始化，事件处理。

作者：yungis 发表于2013/4/2 7:17:31 原文链接

阅读：672 评论：1 查看评论

PAGE_AND_RETAIN_IMAGES,
            PAGE_AND_DISCARD_USED_IMAGES
        };
全部提前加载、用到时候加载和用完后舍去。imageSequence->play();之后就可以按着设定的模
式播放图片。
FindImageStreamsVisitor类把所有的ImageStream放置到_imageStreamList中，然后通过
MovieEventHandler进行暂停、播放、循环等设置。

作者：yungis 发表于2013/3/27 7:25:24 原文链接

阅读：400 评论：1 查看评论

作者：yungis 发表于2013/3/25 7:29:24 原文链接

阅读：831 评论：0 查看评论

作者：yungis 发表于2013/3/25 7:02:49 原文链接

阅读：493 评论：1 查看评论

1/10th of millisecond, min size 256
    _arrayDrawCost.set(min_time,

1.0/gpu_bandwidth, 256); // min time 1/10th of millisecond, min size 256;
   
_primtiveSetDrawCost.set(min_time, 1.0/gpu_bandwidth, 256); // min time 1/10th of 
millisecond, min size 256;
    _displayListCompileConstant = 0.0;
    
_displayListCompileFactor = 10.0;
}
通过这些基本的单位时间，计算总体的时间。

作者：yungis 发表于2013/3/24 11:23:19 原文链接

阅读：391 评论：0 查看评论

作者：yungis 发表于2013/3/22 6:50:36 原文链接

阅读：530 评论：0 查看评论

作者：yungis 发表于2013/3/22 6:16:15 原文链接

阅读：485 评论：0 查看评论