场景的组织及渲染（二）

  • 开发
  • 23

3.11 分页细节层次节点

        分页细节层次节点(osg：：PagedLOD)继承自osg::LOD 节点，它也是一个细节层次节点，用于实现动态分页加载，根据视点来加载所需要的,分页细节层次节点中还可以包含LOD节点。它与osg::LOD节点的区别是:osg::LOD节点存在于一个文件之中，osg::PagedLOD 的每个节点都是盘中的文件，可以根据需要来加载这些文件，加载过程中有单独的线程负责实时调度及加载。

        分页细节层次节点主要是用来处理大规模的数据，在地形和GIS方面有广泛的应用。可以把模型进行预处理，在渲染场景时，再根据需要来实时加载需要的数据及卸载无用的数据。

        在示例程序中我们会把PagedLOD节点写到磁盘上，以便与3.3.10节的程序输出的LOD节点相比较。通过比较可以看出，osg::LOD 节点存在于一个文件中，而PagedLOD节点只提供索引的作用，每个LOD节点存在于磁盘文件中，但不把文件存在一个文件中。

        osg::PagedLOD的继承关系图如图3-18所示。

图3-18 osg::PagedLOD的继承关系图

3.12 分页细节层次节点示例

        分页细节层次节点(osg::PagedLOD)示例的代码如程序清单3-7所示

  1. osg::ref_ptr<osg::Group> createPagedLOD(const string &strDataFolder)// 创建三级PagedLOD场景  
  2. {  
  3.     // 创建PagedLOD对象  
  4.     osg::ref_ptr<osg::PagedLOD> page = new osg::PagedLOD();     
  5.     page->setCenter(osg::Vec3(0.0f, 0.0f, 0.0f));// 设置中心位置  
  6.   
  7.     // 添加节点，设置0级的内容为cow.osg  
  8.     string strDataPath = strDataFolder + "cow.osg";  
  9.     page->setFileName(0, strDataPath);     
  10.     page->setRange(0, 0.0f, 50.0f);// 设置可视变化范围为0.0f-50.0f  
  11.   
  12.     // 添加节点，设置0级的内容为spaceship.osg  
  13.     strDataPath = strDataFolder + "glider.osg";  
  14.     page->setFileName(1, strDataPath);  
  15.     page->setRange(1, 50.0f, 100.0f);// 设置可视变化范围50.0f-100.0f  
  16.   
  17.     // 添加节点，设置0级的内容为cessna.osg  
  18.     strDataPath = strDataFolder + "cessna.osg";  
  19.     page->setFileName(2, strDataPath);     
  20.     page->setRange(2, 100.0f, 200.0f);// 设置可视变化范围100.0f-200.0f  
  21.   
  22.     return page.get();  
  23. }  
  24.   
  25. void pagedLOD_3_7(const string &strDataFolder)  
  26. {  
  27.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
  28.     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;  
  29.     traits->x = 40;  
  30.     traits->y = 40;  
  31.     traits->width = 600;  
  32.     traits->height = 480;  
  33.     traits->windowDecoration = true;  
  34.     traits->doubleBuffer = true;  
  35.     traits->sharedContext = 0;  
  36.   
  37.     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());  
  38.     osg::ref_ptr<osg::Camera> camera = new osg::Camera;  
  39.     camera->setGraphicsContext(gc.get());  
  40.     camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));  
  41.     GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;  
  42.     camera->setDrawBuffer(buffer);  
  43.     camera->setReadBuffer(buffer);  
  44.     viewer->addSlave(camera.get());  
  45.   
  46.     osg::ref_ptr<osg::Group> root = new osg::Group();  
  47.   
  48.     // 创建矩阵变换节点  
  49.     osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform();     
  50.     mt->addChild(createPagedLOD(strDataFolder));// 添加子节点   
  51.   
  52.     osg::Matrix m;  
  53.     m.makeRotate(60.0f, 0.0f, 0.0f, 1.0f);// 旋转一下，调整一下合适的角度   
  54.     mt->setMatrix(m);// 设置矩阵   
  55.     root->addChild(mt.get());//添加PagedLOD场景  
  56.   
  57.     // 写入PagedLOD  
  58.     string strDataPath = strDataFolder + "page.osg";  
  59.     osgDB::writeNodeFile(*root, strDataPath);  
  60.   
  61.     // 优化场景数据  
  62.     osgUtil::Optimizer optimizer;  
  63.     optimizer.optimize(root.get());  
  64.     viewer->setSceneData(root.get());  
  65.     viewer->realize();  
  66.     viewer->run();  
  67. }  

运行序，截图如图3-19 示(可以进行各种层次之间的切换)。

3-19分页细节层次节点示例截图

3.13 替代节点

        替代节点(osgSim::Impostor)继承自osg::LOD节点。替代节点也是一种布告板，它是通过从当前视点将一个复杂物体对象绘制到一幅图像纹理上来创建的，其中渲染的图像纹理映射到布告板上。值得注意的是，绘制过程与替代物在屏幕上覆盖的像素点数而不是顶点数或者物体的复杂程度成正比。替代节点可用于物体的一些实例或图形的一些画面，可以加速图像的绘制及渲染。替代节点的另一个优点是可以对纹理图像进行低通滤波，从而生成一张可用于景深效果的模糊图像。

        在实际运用中，绘制一个替代节点应该比绘制其所表示的物体要快很多，而且替代物应该和标识的物体非常相像。同样重要的是，替代节点应该可以重复用于挨在一起的多个视点，从而可以有效地利用帧与帧之间的相关性。随着视点距离的加大，物体的投影图像会随之变小，所以通常这种情形意味着可以使用替代节点方法来处理距离视点较远的缓慢运动的物体。就是距离视点比较近，而且运动时有一面总是面向视点的物体也比较适合用替代节点。

        但很多时候替代节点对当前几何形状的近似不是很好，当错误超过某个范围时，替代节点就会变得无效。通常，对替代物的有效限制就是它的分辨率。当一个远处的替代节点慢慢靠近时，纹理中的单个像素将变得越来越明显，原来的视觉效果就会慢慢消失，这时就需要根据视点和替代节点的当前位置生成新的替代物。这种情况下，图形纹理的分辨率绝对不能超过屏幕的当前分辨率。

        osgSim::Impostor的继承关系图如图3-20所示。

图3-20 osgSim::Impostor 的继承关系图

        osgSim::Impostor 的成员函数如下

         void setImpostorThreshold (float distance);

        这个函数用于设置开始启用Impostor 的距离，参数可以根据情况适当调节。它继承自LOD节点因此它同样可以有多个子节点来控制模型的层次显示。

3.14 替代节点示例

        替代节点(osgSim::Impostor)示例的代码如程序清单3-8所示。

 

  1. void impostor_3_8(const string &strDataFolder)  
  2. {  
  3.     // 创建Viewer对象，场景浏览器  
  4.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
  5.     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;  
  6.     traits->x = 40;  
  7.     traits->y = 40;  
  8.     traits->width = 600;  
  9.     traits->height = 480;  
  10.     traits->windowDecoration = true;  
  11.     traits->doubleBuffer = true;  
  12.     traits->sharedContext = 0;  
  13.   
  14.     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());  
  15.     osg::ref_ptr<osg::Camera> camera = new osg::Camera;  
  16.     camera->setGraphicsContext(gc.get());  
  17.     camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));  
  18.     GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;  
  19.     camera->setDrawBuffer(buffer);  
  20.     camera->setReadBuffer(buffer);  
  21.     viewer->addSlave(camera.get());  
  22.   
  23.     osg::ref_ptr<osg::Group> root = new osg::Group();  
  24.   
  25.     // 创建一个节点,读取牛的模型  
  26.     string strDataPath = strDataFolder + "cow.osg";  
  27.     osg::ref_ptr<osg::Node> node = osgDB::readNodeFile(strDataPath);  
  28.   
  29.     osg::ref_ptr<osgSim::Impostor> impostor = new osgSim::Impostor();// 创建一个替代节点  
  30.     impostor->setImpostorThreshold(50.0f);// 设置50.0f以后开始使用贴图  
  31.     impostor->addChild(node.get(), 0, 10000.0f);// 设置模型的显示的范围在0-10000内  
  32.     root->addChild(impostor.get());// 添加到场景  
  33.   
  34.     // 优化场景数据  
  35.     osgUtil::Optimizer optimizer;  
  36.     optimizer.optimize(root.get());  
  37.     viewer->setSceneData(root.get());  
  38.     viewer->realize();  
  39.     viewer->run();  
  40. }  

        运行程序，截图如图3-21 所示。

图3-21替代节点示例截图

3.15 遮挡裁剪节点

        遮挡裁剪节点 (osg::OccluderNode)继承自 osg::Group 节点。osg::OccluderNode 节点的主要作用是裁剪掉被遮挡的物体，也就是场景中被其他物体所遮挡的物体。最优的遮挡裁剪算法只选择其中可见的物体。从某种意义上来说，Z缓冲器只选择并绘制那些可见的物体，但是必须将这些物体都送入管线的大部分阶段。高效的逛挡算法背后的思想是:提前执行一些简单的测试，从而避免将所有的数据送入管线的大部分阶段。

        目前遮挡裁剪算法主要有两种，分别是基于点的遮挡裁剪和基于单元的遮挡裁剪。图 3-22将可以清晰地表达出这两种算法的区别。基于点的可见性通常用于绘制，也就是从单个视点位置看到所有的物体。基于单元的可见性判断主要针对一个方体或者圆体单元进行可见性判断，利用这种方法判断出的不可见物体在单元内部的所有点看上去是不可见的，它的优点是:一旦计算出一个单元的可见性只要视点在这个单元中，通常就可以将可见性判断结果用于很多真实画面。但这种算法有一个缺陷，就是所需计算的开销要比基于视点的可见性大得多。因此，通常将其作为一个预处理步骤。可以用这样一个形象的比喻来说明这两种算法，那就是基于点的可见性和基于单元的可见性可以认为分别是一个点光源和区域光源。

 

图 3-22基于点的可见性和基于单元的可见性遮挡

        osg::OccluderNode 主要采用的是基于点的遮挡算法，但节点本身不具备挡能力，因此，在判断时需要指定一个遮挡面，可以调用下面的函数:

        void setOccluder(ConvexPlanarOccluder*occluder)

        指定平面时需要注意，该平面应该为一个凸多边形。

        osg::OccluderNode 的继承关系图如图3-23 所示。

 

图3-23 osg::OccluderNode 的继承关系图

3.16 遮挡裁剪节点示例

        遮挡裁剪节点(osg::OccluderNode)示例的代码如程序清单3-9所示。

  1. osg::ref_ptr<osg::Node> createOccluder(const string &strDataFolder, const osg::Vec3& v1,   
  2.     const osg::Vec3& v2, const osg::Vec3& v3, const osg::Vec3& v4)// 创建遮挡节点  
  3. {  
  4.     // 创建遮挡节点对象  
  5.     osg::ref_ptr<osg::OccluderNode> occluderNode = new osg::OccluderNode();  
  6.   
  7.     // 创建遮挡平面  
  8.     osg::ref_ptr<osg::ConvexPlanarOccluder> cpo = new osg::ConvexPlanarOccluder;  
  9.   
  10.     // 关联遮挡板平面  
  11.     string strDataPath = strDataFolder + "occluder";  
  12.     occluderNode->setOccluder(cpo.get());  
  13.     occluderNode->setName(strDataPath);  
  14.   
  15.     // 初始化一个遮挡平面  
  16.     osg::ConvexPlanarPolygon& occluder = cpo->getOccluder();  
  17.     occluder.add(v1);  
  18.     occluder.add(v2);  
  19.     occluder.add(v3);  
  20.     occluder.add(v4);  
  21.   
  22.     // 为这当面画一个四边形  
  23.     osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;  
  24.     osg::ref_ptr<osg::Vec3Array> coords = new osg::Vec3Array(occluder.getVertexList().begin(), occluder.getVertexList().end());  
  25.     geom->setVertexArray(coords);  
  26.   
  27.     osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array(1);  
  28.     (*colors)[0].set(1.0f, 1.0f, 1.0f, 0.5f);  
  29.     geom->setColorArray(colors.get());  
  30.     geom->setColorBinding(osg::Geometry::BIND_OVERALL);  
  31.     geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0, 4));  
  32.   
  33.     osg::ref_ptr<osg::Geode> geode = new osg::Geode;  
  34.     geode->addDrawable(geom.get());  
  35.   
  36.     osg::ref_ptr<osg::StateSet> stateset = new osg::StateSet();     
  37.     stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);// 关闭光照   
  38.     stateset->setMode(GL_BLEND, osg::StateAttribute::ON);// 使用混合，以保证Alpha纹理正确  
  39.     stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);// 设置透明渲染元  
  40.     geom->setStateSet(stateset.get());  
  41.   
  42.     // 添加四边形作为遮挡节点，遮挡节点本身不具备遮挡能力  
  43.     occluderNode->addChild(geode.get());  
  44.     return occluderNode.get();  
  45. }  
  46.   
  47. osg::ref_ptr<osg::Group> createOccludersAroundModel(const string &strDataFolder, osg::ref_ptr<osg::Node> model)// 创建绕模型的遮挡场景  
  48. {  
  49.     // 创建场景组节点  
  50.     string strDataPath = strDataFolder + "OccluderScene";  
  51.     osg::ref_ptr<osg::Group> scene = new osg::Group();  
  52.     scene->setName(strDataPath);  
  53.   
  54.     // 添加子节点  
  55.     strDataPath = strDataFolder + "cow.osg";  
  56.     scene->addChild(model.get());  
  57.     model->setName(strDataPath);  
  58.   
  59.     // 计算模型的包围盒  
  60.     const osg::BoundingSphere bs = model->getBound();  
  61.   
  62.     // 根据包围盒来创建几个前后左右几个遮挡面  
  63.     osg::BoundingBox bb;  
  64.     bb.expandBy(bs);  
  65.   
  66.     // 前遮挡面  
  67.     scene->addChild(createOccluder(strDataFolder, bb.corner(0),  
  68.         bb.corner(1),  
  69.         bb.corner(5),  
  70.         bb.corner(4)));  
  71.   
  72.     //右遮挡面  
  73.     scene->addChild(createOccluder(strDataFolder, bb.corner(1),  
  74.         bb.corner(3),  
  75.         bb.corner(7),  
  76.         bb.corner(5)));  
  77.   
  78.     //左遮挡面  
  79.     scene->addChild(createOccluder(strDataFolder, bb.corner(2),  
  80.         bb.corner(0),  
  81.         bb.corner(4),  
  82.         bb.corner(6)));  
  83.   
  84.     //后遮挡面  
  85.     scene->addChild(createOccluder(strDataFolder, bb.corner(3),  
  86.         bb.corner(2),  
  87.         bb.corner(6),  
  88.         bb.corner(7)));  
  89.   
  90.     return scene.get();  
  91. }  
  92.   
  93. void occluderNode_3_9(const string &strDataFolder)  
  94. {  
  95.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
  96.     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;  
  97.     traits->x = 40;  
  98.     traits->y = 40;  
  99.     traits->width = 600;  
  100.     traits->height = 480;  
  101.     traits->windowDecoration = true;  
  102.     traits->doubleBuffer = true;  
  103.     traits->sharedContext = 0;  
  104.   
  105.     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());  
  106.     osg::ref_ptr<osg::Camera> camera = new osg::Camera;  
  107.     camera->setGraphicsContext(gc.get());  
  108.     camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));  
  109.     GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;  
  110.     camera->setDrawBuffer(buffer);  
  111.     camera->setReadBuffer(buffer);  
  112.     viewer->addSlave(camera.get());  
  113.   
  114.     osg::ref_ptr<osg::Group> root = new osg::Group();  
  115.   
  116.     string strDataPath = strDataFolder + "cow.osg";  
  117.     osg::ref_ptr<osg::Node> node = osgDB::readNodeFile(strDataPath);  
  118.   
  119.     // 添加遮挡场景  
  120.     root->addChild(createOccludersAroundModel(strDataFolder, node.get()));  
  121.   
  122.     // 优化场景数据  
  123.     osgUtil::Optimizer optimizer;  
  124.     optimizer.optimize(root.get());  
  125.   
  126.     viewer->setSceneData(root.get());  
  127.     viewer->realize();  
  128.     viewer->run();  
  129. }  

        运行程序，截图如图3-24所示

图3-24 挡剪节点示例截图

3.17 坐标系节点

        坐标系节点(osg::CoordinateSystemNode)继承自osg::Group 节点，它的主要作用是使一个场景的对象关联一个坐标系统。通常的坐标系统类型有 WKT、PROJ4和USGS。它通常与osg::EllipsoidModel节点一起使用，osg::EllipsoidModel节点(圆体模型节点)主要用来模拟天体，如太阳、行星和月亮等，其默认情况下是地球体。osg::EllipsoidModel 节点还有一个作用就是实现经纬度与坐标之间的转换，这样可以实现天体椭圆体模型子节点的精确定位。当读者建立地球数据库时，这个节点会非常有用，可以根据地球椭圆体模型实现子节点的精确定位。

        对于WKT坐标系，可能很多人都不理解，它的定义包括以下几个方面：

  • 一个全局的坐标系统名称。
  • 一个地理坐标系统的名称。
  • 一个数据识别器。
  • 一个椭球体的名称、长半轴、扁率。
  • 本初子午线的名称和它到格林尼治的偏移量。
  • 投影类型(如横轴墨卡托影)。
  • 投影参数(如中央子午线)。
  • 单位名称，到米或弧度的转换因数。
  • 各轴的名称和顺序。
  • 由授权单位(如EPSG)预先定义的大多数坐标系统的代码。

        这样解释可能比较好理解，关于地理坐标系的知识，读者可以参看本书第13.5.2节。

        osg::CoordinateSystemNode 的继承关系图如图3-25 所示。

3-25 osg::CoordinateSystemNode 的继承关系图

3.18  坐标系节点示例

        坐标系节点(osg::CoordinateSystemNode)示例的代码如程序清单3-10所示

  1. osg::ref_ptr<osg::Node> createEarth(const string &strDataFolder)// 绘制一个地球  
  2. {  
  3.     // 创建一个球体  
  4.     osg::ref_ptr<osg::ShapeDrawable> sd = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0.0, 0.0, 0.0), osg::WGS_84_RADIUS_POLAR));  
  5.   
  6.     // 添加到叶节点  
  7.     osg::ref_ptr<osg::Geode> geode = new osg::Geode;  
  8.     geode->addDrawable(sd.get());  
  9.   
  10.     // 设置纹理  
  11.     std::string filename = strDataFolder + "Images/land_shallow_topo_2048.jpg";  
  12.     geode->getOrCreateStateSet()->setTextureAttributeAndModes(0, new osg::Texture2D(osgDB::readImageFile(filename)));  
  13.   
  14.     // 创建坐标系节点  
  15.     osg::ref_ptr<osg::CoordinateSystemNode> csn = new osg::CoordinateSystemNode;    
  16.     csn->setEllipsoidModel(new osg::EllipsoidModel());// 设置椭圆体模型，默认的坐标系WGS_84      
  17.     csn->addChild(geode.get());//添加子节点  
  18.   
  19.     return csn.get();  
  20. }  
  21.   
  22. void coordinateSystemNode_3_10(const string &strDataFolder)  
  23. {  
  24.     //创建Viewer对象，场景浏览器  
  25.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
  26.     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;  
  27.     traits->x = 40;  
  28.     traits->y = 40;  
  29.     traits->width = 600;  
  30.     traits->height = 480;  
  31.     traits->windowDecoration = true;  
  32.     traits->doubleBuffer = true;  
  33.     traits->sharedContext = 0;  
  34.   
  35.     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());  
  36.     osg::ref_ptr<osg::Camera> camera = new osg::Camera;  
  37.     camera->setGraphicsContext(gc.get());  
  38.     camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));  
  39.     GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;  
  40.     camera->setDrawBuffer(buffer);  
  41.     camera->setReadBuffer(buffer);  
  42.     viewer->addSlave(camera.get());  
  43.   
  44.     osg::ref_ptr<osg::Group> root = new osg::Group();  
  45.   
  46.     // 添加到场景  
  47.     root->addChild(createEarth(strDataFolder));  
  48.   
  49.     // 优化场景数据  
  50.     osgUtil::Optimizer optimizer;  
  51.     optimizer.optimize(root.get());  
  52.   
  53.     viewer->setSceneData(root.get());  
  54.     viewer->realize();  
  55.     viewer->run();  
  56. }  

        运行程序，截图如图 3-26 所示

图3-26 坐标系节点示例截图

4. 场景中节点的拷贝 — osg::CopyOp 类

        osg::CopyOp类是一个拷贝类，主要负责场景中节点的拷贝，根据不同的需要，控制使用深拷贝或者浅拷贝来拷贝场景中的节点。关于深拷贝和浅拷贝在C++里面已经有很详细的介绍。这里再简单介绍一下。如果读者是熟练的C++程序员，则可以跳过下面这段文件。

        深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响，例如，一头牛的节点被拷贝了，对原来牛的节点做矩阵变换并不会影响拷贝对象。浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同(名称不同，对其中任何一个对象的改动都会影响另外一个对象，例如，一头牛的节点被拷贝了，对原来牛的节点做矩阵变换，拷贝对象的牛也会随之做相应的矩阵变换。深拷贝和浅拷贝的定义可以简单理解成:如果一个类拥有资源(堆或其他系统资源)，这个类的对象发生复制的过程就可以称为深拷贝:反之，对象存在资源但复制过程并未复制资源的情况视为浅拷贝。

        浅拷贝资源后，在释放资源时会产生资源归属不清的情况，这种情况会导致程序运行出错，所以定要注意。当在场景中共享一个节点时，确定使用深拷贝或浅拷贝时，尤其要注意。

        还有一个问题是，当场景中多父节点共享一个子节点时，进行深拷贝时也会出现问题，即默认情况下会改变原来树的结构，这时需要自定义控制子节点的拷贝，以避免多次重复拷贝而改变场景中的树的结构。通过图 3-27，读者可以清晰地看到这种情况下存在的问题，所以没有正确设置拷贝结构会导致场景树拷贝后的改变及场景树结构的变化，这种做法是明显错误的。

图3-27场景拷贝结构图

4.1 自定义场景拷贝示例(一)

        自定义场景拷贝示例主要演示如何拷贝场景中的一个或多个节点，了解深拷贝与浅拷贝的区别。通过自定义拷贝类，读者将深入了解节点拷贝的过程，也将明显看到深拷贝和浅拷贝之间的区别。

        代码如程序清单3-11所示。

 

  1. class MyCopyOp : public osg::CopyOp// 自定义Copy类，用于输出拷贝信息  
  2. {  
  3. public:  
  4.   
  5.     inline MyCopyOp(CopyFlags flags = SHALLOW_COPY) :  
  6.         osg::CopyOp(flags),  
  7.         _blank(2),  
  8.         _number(5)  
  9.     {  
  10.         //  
  11.     }  
  12.   
  13.     //内联函数用于控制输出信息格式,实现下三角规则输出  
  14.     inline void moveIn() const  
  15.     {  
  16.         _blank += _number;  
  17.     }  
  18.   
  19.     inline void moveOut() const  
  20.     {  
  21.         _blank -= _number;  
  22.     }  
  23.   
  24.     inline void writeIndent() const  
  25.     {  
  26.         for (int i = 0; i < _blank; ++i)  
  27.         {  
  28.             std::cout << " ";  
  29.         }  
  30.     }  
  31.   
  32.     //引用计数器copy  
  33.     virtual osg::Referenced* operator() (const osg::Referenced* ref) const  
  34.     {  
  35.         writeIndent();  
  36.         std::cout << "copying Referenced " << ref << std::endl;  
  37.         moveIn();  
  38.         osg::Referenced* ret_ref = CopyOp::operator()(ref);  
  39.         moveOut();  
  40.         return ret_ref;  
  41.     }  
  42.   
  43.     //对象copy  
  44.     virtual osg::Object* operator() (const osg::Object* obj) const  
  45.     {  
  46.         writeIndent();  
  47.         std::cout << "copying Object " << obj;  
  48.         if (obj)  
  49.         {  
  50.             std::cout << " " << obj->className();  
  51.         }  
  52.         std::cout << std::endl;  
  53.         moveIn();  
  54.         osg::Object* ret_obj = CopyOp::operator()(obj);  
  55.         moveOut();  
  56.         return ret_obj;  
  57.     }  
  58.   
  59.     //节点copy  
  60.     virtual osg::Node* operator() (const osg::Node* node) const  
  61.     {  
  62.         writeIndent();  
  63.         std::cout << "copying Node " << node;  
  64.         if (node)  
  65.         {  
  66.             std::cout << " " << node->className() << " '" << node->getName() << "'";  
  67.         }  
  68.         std::cout << std::endl;  
  69.         moveIn();  
  70.         osg::Node* ret_node = CopyOp::operator()(node);  
  71.         moveOut();  
  72.         return ret_node;  
  73.     }  
  74.   
  75.     //Drawable copy  
  76.     virtual osg::Drawable* operator() (const osg::Drawable* drawable) const  
  77.     {  
  78.         writeIndent();  
  79.         std::cout << "copying Drawable " << drawable;  
  80.         if (drawable)  
  81.         {  
  82.             std::cout << " " << drawable->className();  
  83.         }  
  84.         std::cout << std::endl;  
  85.         moveIn();  
  86.         osg::Drawable* ret_drawable = CopyOp::operator()(drawable);  
  87.         moveOut();  
  88.         return ret_drawable;  
  89.     }  
  90.   
  91.     //状态集copy  
  92.     virtual osg::StateSet* operator() (const osg::StateSet* stateset) const  
  93.     {  
  94.         writeIndent();  
  95.         std::cout << "copying StateSet " << stateset;  
  96.         if (stateset)  
  97.         {  
  98.             std::cout << " " << stateset->className();  
  99.         }  
  100.         std::cout << std::endl;  
  101.         moveIn();  
  102.         osg::StateSet* ret_stateset = CopyOp::operator()(stateset);  
  103.         moveOut();  
  104.         return ret_stateset;  
  105.     }  
  106.   
  107.     //状态属性copy  
  108.     virtual osg::StateAttribute* operator() (const osg::StateAttribute* attr) const  
  109.     {  
  110.         writeIndent();  
  111.         std::cout << "copying StateAttribute " << attr;  
  112.         if (attr)  
  113.         {  
  114.             std::cout << " " << attr->className();  
  115.         }  
  116.         std::cout << std::endl;  
  117.         moveIn();  
  118.         osg::StateAttribute* ret_attr = CopyOp::operator()(attr);  
  119.         moveOut();  
  120.         return ret_attr;  
  121.     }  
  122.   
  123.     //纹理信息copy  
  124.     virtual osg::Texture* operator() (const osg::Texture* text) const  
  125.     {  
  126.         writeIndent();  
  127.         std::cout << "copying Texture " << text;  
  128.         if (text)  
  129.         {  
  130.             std::cout << " " << text->className();  
  131.         }  
  132.         std::cout << std::endl;  
  133.         moveIn();  
  134.         osg::Texture* ret_text = CopyOp::operator()(text);  
  135.         moveOut();  
  136.         return ret_text;  
  137.     }  
  138.   
  139.     //贴图copy  
  140.     virtual osg::Image* operator() (const osg::Image* image) const  
  141.     {  
  142.         writeIndent();  
  143.         std::cout << "copying Image " << image;  
  144.         if (image)  
  145.         {  
  146.             std::cout << " " << image->className();  
  147.         }  
  148.         std::cout << std::endl;  
  149.         moveIn();  
  150.         osg::Image* ret_image = CopyOp::operator()(image);  
  151.         moveOut();  
  152.         return ret_image;  
  153.     }  
  154.   
  155. protected:  
  156.   
  157.     //此处两个必须是可变型变量，因为在const函数中使用，需要突破const的限制  
  158.     //空格增减变量  
  159.     mutable int _number;  
  160.     //空格总数数  
  161.     mutable int _blank;  
  162. };  
  163. void copyOp1_3_1(const string &strDataFolder)  
  164. {  
  165.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
  166.     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;  
  167.     traits->x = 40;  
  168.     traits->y = 40;  
  169.     traits->width = 600;  
  170.     traits->height = 480;  
  171.     traits->windowDecoration = true;  
  172.     traits->doubleBuffer = true;  
  173.     traits->sharedContext = 0;  
  174.   
  175.     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());  
  176.     osg::ref_ptr<osg::Camera> camera = new osg::Camera;  
  177.     camera->setGraphicsContext(gc.get());  
  178.     camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));  
  179.     GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;  
  180.     camera->setDrawBuffer(buffer);  
  181.     camera->setReadBuffer(buffer);  
  182.     viewer->addSlave(camera.get());  
  183.   
  184.     string strDataPath = strDataFolder + "glider.osg";  
  185.     osg::ref_ptr<osg::Node> rootnode = osgDB::readNodeFile(strDataPath);  
  186.   
  187.     // 优化场景数据  
  188.     osgUtil::Optimizer optimzer;  
  189.     optimzer.optimize(rootnode.get());  
  190.   
  191.     // 浅拷贝一个场景  
  192.     osg::ref_ptr<osg::Node> shallowCopy = dynamic_cast<osg::Node*>(rootnode->clone(osg::CopyOp::SHALLOW_COPY));  
  193.     std::cout << std::endl << "完成浅拷贝一个场景" << std::endl << std::endl;  
  194.   
  195.     // 深拷贝一个场景  
  196.     osg::ref_ptr<osg::Node> deepCopy = dynamic_cast<osg::Node*>(rootnode->clone(osg::CopyOp::DEEP_COPY_ALL));  
  197.     std::cout << std::endl << "完成深拷贝一个场景" << std::endl << std::endl;  
  198.   
  199.     // 自定义输出信息浅拷贝场景  
  200.     osg::ref_ptr<osg::Node> myShallowCopy = dynamic_cast<osg::Node*>(rootnode->clone(MyCopyOp(osg::CopyOp::SHALLOW_COPY)));  
  201.     std::cout << std::endl << "完成一个自定义输出信息浅拷贝场景" << std::endl << std::endl;  
  202.   
  203.     // 自定义输出信息深拷贝场景  
  204.     osg::ref_ptr<osg::Node> myDeepCopy = dynamic_cast<osg::Node*>(rootnode->clone(MyCopyOp(osg::CopyOp::DEEP_COPY_ALL)));  
  205.     std::cout << std::endl << "完成一个自定义输出信息深拷贝场景" << std::endl << std::endl;  
  206.   
  207.     viewer->setSceneData(rootnode.get());  
  208.     viewer->realize();  
  209.     viewer->run();  
  210. }  

        运行程序，截图如图3-28 所示。

图3-28自定场景示例(一)截图

4.2 自定义场景拷贝示例(二)

        通过第 3.4.1 节中的示例，相信读者已经理解了场景中节点的拷贝及拷贝应该注意的事项。本节的示例将更进一步向读者展示如何拷贝场景中多父节点的场景，这是读者在场景中拷贝节点树时非常值得注意的。

        代码如程序清单3-12 所示。

 

  1. class GraphCopyOp : public osg::CopyOp // 自定义Copy类，用于输出拷贝信息  
  2. {  
  3. public:  
  4.   
  5.     inline GraphCopyOp(CopyFlags flags = SHALLOW_COPY) : osg::CopyOp(flags)  
  6.     {  
  7.         _nodeCopyMap.clear();  
  8.     }  
  9.   
  10.     // 节点的copy  
  11.     virtual osg::Node* operator() (const osg::Node* node) const  
  12.     {  
  13.         //判断是否为深拷贝  
  14.         if (node && _flags&DEEP_COPY_NODES)  
  15.         {  
  16.             //判断节点的父节点是否有多个，如果只有一个，则直接深拷贝  
  17.             if (node->getNumParents() > 1)  
  18.             {  
  19.                 //判断是否已经拷贝  
  20.                 if (_nodeCopyMap.find(node) != _nodeCopyMap.end())  
  21.                 {  
  22.                     std::cout << "Copy of node " << node << " " << node->getName() << ", "  
  23.                         << _nodeCopyMap[node] << ", will be reused" << std::endl;  
  24.                     //直接返回拷贝对象的地址  
  25.                     return (osg::Node*)(_nodeCopyMap[node]);  
  26.                 }  
  27.                 else  
  28.                 {  
  29.                     //进行拷贝并在映射表中保存拷贝对象  
  30.                     osg::Node* newNode = dynamic_cast<osg::Node*>(node->clone(*this));  
  31.                     _nodeCopyMap[node] = newNode;  
  32.                     //返回地址  
  33.                     return newNode;  
  34.                 }  
  35.             }  
  36.             else  
  37.             {  
  38.                 //直接拷贝  
  39.                 return dynamic_cast<osg::Node*>(node->clone(*this));  
  40.             }  
  41.         }  
  42.         else  
  43.         {  
  44.             //直接返回地址  
  45.             return const_cast<osg::Node*>(node);  
  46.         }  
  47.     }  
  48.   
  49. protected:  
  50.   
  51.     //节点映射表，用来保存child和拷贝，分别作为原象和象  
  52.     mutable std::map<const osg::Node*, osg::Node*> _nodeCopyMap;  
  53. };  
  54.   
  55. void copyOp2_3_2(const string &strDataFolder)  
  56. {  
  57.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
  58.     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;  
  59.     traits->x = 40;  
  60.     traits->y = 40;  
  61.     traits->width = 600;  
  62.     traits->height = 480;  
  63.     traits->windowDecoration = true;  
  64.     traits->doubleBuffer = true;  
  65.     traits->sharedContext = 0;  
  66.   
  67.     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());  
  68.     osg::ref_ptr<osg::Camera> camera = new osg::Camera;  
  69.     camera->setGraphicsContext(gc.get());  
  70.     camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));  
  71.     GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;  
  72.     camera->setDrawBuffer(buffer);  
  73.     camera->setReadBuffer(buffer);  
  74.     viewer->addSlave(camera.get());  
  75.   
  76.     // 创建一个多父节点共享一个子节点的场景  
  77.     osg::ref_ptr<osg::Group> rootnode = new osg::Group();  
  78.     string strDataPath = strDataFolder + "glider.osg";  
  79.     osg::ref_ptr<osg::Node> node = osgDB::readNodeFile(strDataPath);  
  80.   
  81.     // 子节点pat，共享node  
  82.     osg::ref_ptr<osg::PositionAttitudeTransform> pat = new osg::PositionAttitudeTransform();  
  83.     pat->setPosition(osg::Vec3(5.0f, 0.0f, 0.0f));  
  84.     pat->addChild(node.get());  
  85.   
  86.     // 子节点mt，共享node  
  87.     osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform();  
  88.     osg::Matrix m;  
  89.     m.makeScale(2.0f, 2.0f, 2.0f);  
  90.     mt->setMatrix(m);  
  91.     mt->addChild(node.get());  
  92.   
  93.     // 添加子节点  
  94.     rootnode->addChild(pat.get());  
  95.     rootnode->addChild(mt.get());  
  96.   
  97.     // 优化场景数据  
  98.     osgUtil::Optimizer optimzer;  
  99.     optimzer.optimize(rootnode.get());  
  100.   
  101.     // 一个多父节点一个子节点的场景的默认深拷贝  
  102.     osg::ref_ptr<osg::Node> deepCopy = dynamic_cast<osg::Node*>(rootnode->clone(osg::CopyOp::DEEP_COPY_ALL));  
  103.     std::cout << std::endl << "完成一个多父节点一个子节点的场景的默认深拷贝" << std::endl << std::endl;  
  104.     osgDB::writeNodeFile(*(deepCopy.get()), "deepCopy.osg");  
  105.   
  106.     // 完成一个多父节点一个子节点的场景的浅拷贝  
  107.     osg::ref_ptr<osg::Node> myShallowCopy = dynamic_cast<osg::Node*>(rootnode->clone(GraphCopyOp(osg::CopyOp::SHALLOW_COPY)));  
  108.     std::cout << std::endl << "完成一个多父节点一个子节点的场景的浅拷贝" << std::endl << std::endl;  
  109.     osgDB::writeNodeFile(*(myShallowCopy.get()), "myShallowCopy.osg");  
  110.   
  111.     // 完成一个多父节点一个子节点的场景的深拷贝  
  112.     osg::ref_ptr<osg::Node> myDeepCopy = dynamic_cast<osg::Node*>(rootnode->clone(GraphCopyOp(osg::CopyOp::DEEP_COPY_ALL)));  
  113.     std::cout << std::endl << "完成一个多父节点一个子节点的场景的深拷贝" << std::endl << std::endl;  
  114.     osgDB::writeNodeFile(*(myDeepCopy.get()), "myDeepCopy.osg");  
  115.   
  116.     viewer->setSceneData(rootnode.get());  
  117.     viewer->realize();  
  118.     viewer->run();  
  119. }  

        运行程序，截图如图3-29所示。

 

3-29自定义场景拷贝示例(二)截图

阅读全部

相关推荐

  2. Vue中的组件通信方式及应用场景

    2023-12-15 00:42:01       42 阅读

  3. vue父组件给子组件传值，子组件不渲染的原因及解决方法

    2023-12-15 00:42:01       32 阅读

  8. UDP的特点及应用场景

    2023-12-15 00:42:01       35 阅读

最近更新

  4. TCP协议是安全的吗?

    2023-12-15 00:42:01       16 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2023-12-15 00:42:01       16 阅读

  13. 【Python教程】压缩PDF文件大小

    2023-12-15 00:42:01       15 阅读

  18. 通过文章id递归查询所有评论（xml）

    2023-12-15 00:42:01       18 阅读

热门阅读

  3. MybatisPlus的分页插件

    2023-12-15 00:42:01       35 阅读

  4. DatabaseMetaData详解

    2023-12-15 00:42:01       33 阅读

  5. AI元素深化人类发展之路：挑战与趋势

    2023-12-15 00:42:01       34 阅读

  6. static关键字详解

    2023-12-15 00:42:01       30 阅读

  7. Python的模块与包

    2023-12-15 00:42:01       45 阅读

  8. CAN静默回环模式测试

    2023-12-15 00:42:01       36 阅读

  10. Oracle开发和应用——基本SQL语句2（SELECT）

    2023-12-15 00:42:01       41 阅读

  11. python中的函数 #2

    2023-12-15 00:42:01       38 阅读

  12. WPF里面的Dispatcher详解

    2023-12-15 00:42:01       36 阅读

  17. Go HTTP 调用（上）

    2023-12-15 00:42:01       30 阅读

  19. Docker常用命令总结

    2023-12-15 00:42:01       43 阅读

  28. leetcode做题笔记2048. 下一个更大的数值平衡数

    2023-12-15 00:42:01       33 阅读