用OpenSceneGraph实现的NeHe OpenGL教程 - 第二十五课

最新推荐文章于 2016-08-17 14:15:17 发布
最新推荐文章于 2016-08-17 14:15:17 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： osgNeHe osgNeHe 文章标签： osg NeHe OpenGL Qt C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csxiaoshui/article/details/25101663
版权
osgNeHe 同时被 2 个专栏收录
52 篇文章 22 订阅
订阅专栏
osgNeHe
52 篇文章 38 订阅
订阅专栏

  • 简介

NeHe教程在这节课中向我们介绍了如何从文件加载3D模型，并且平滑的从一个模型变换为另一个模型。这个过程又称为逐点动画，点之间的变化过程算法十分简单，采用的是线性的算法。

  • 实现

首先我们仿照NeHe课程中定义了表示点的结构体以及读取文件的结构体OBJECT并读取文件 

void initMorphObject()
{
	objload("Data/sphere.txt",&morph1);
	objload("Data/torus.txt",&morph2);
	objload("Data/tube.txt",&morph3);

	objallocate(&morph4,486);	
	morph4.verts = 486;
	for(int i=0;i<486;i++)
	{
		morph4.points[i].x=((float)(rand()%14000)/1000)-7;
		morph4.points[i].y=((float)(rand()%14000)/1000)-7;
		morph4.points[i].z=((float)(rand()%14000)/1000)-7;	
	}
	
	morphGeometry1 = new osg::Geometry;
	osg::Vec3Array *vertexArray1 = new osg::Vec3Array;
	for (unsigned i = 0; i < morph1.verts; ++i)
	{
		vertexArray1->push_back(osg::Vec3(morph1.points[i].x, morph1.points[i].y, morph1.points[i].z));
	}
	morphGeometry1->setVertexArray(vertexArray1);
	morphGeometry1->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, 486));
	morphGeometry1->setUseDisplayList(false);
	srcMorphGeometry = dynamic_cast<osg::Geometry*>(morphGeometry1->clone(osg::CopyOp::DEEP_COPY_ALL));
	destMorphGeometry = morphGeometry1;
       ...
}
读取文件之后构建4个几何体对象，接着在几何体更新回调中处理逐个点的变化

上述的处理过程在几何体的更新回调MorphUpdateCallback之中

	virtual void update(osg::NodeVisitor*, osg::Drawable* drawable)
	{
		osg::Geometry *geom = dynamic_cast<osg::Geometry*>(drawable);
		if (!geom)
			return;
		
		osg::Vec3Array *vertices = dynamic_cast<osg::Vec3Array*>(geom->getVertexArray());
		osg::Vec3Array *destVertices = dynamic_cast<osg::Vec3Array*>(_destGeometry->getVertexArray());	
		if (vertices && destVertices)
		{
			for (unsigned i = 0; i < vertices->size(); ++i)
			{
				osg::Vec3 delta = (destVertices->at(i) - vertices->at(i)) / _steps;
				vertices->at(i) += delta;
			}
			vertices->dirty();
		}	
	}
在与键盘的交互中设置变换的几何体目标对象： 

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_1)
				{
					MorphUpdateCallback *muc = dynamic_cast<MorphUpdateCallback*>(srcMorphGeometry->getUpdateCallback());
					if (!muc)
						return false;
					muc->setDestGeometry(morphGeometry1);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_2)
				{
					MorphUpdateCallback *muc = dynamic_cast<MorphUpdateCallback*>(srcMorphGeometry->getUpdateCallback());
					if (!muc)
						return false;
					muc->setDestGeometry(morphGeometry2);
				}

通过设置几何体变换的开始形状(srcGeometry)和最终变换到的目标几何体(destGeometry)，在回调中不断调整顶点位置完成动画效果。

编译运行程序：


附：本课源码(源码中可能存在错误和不足，仅供参考)

/************************************************************************\
 * osgNeHe - Copyright (C) 2013-2014 Frank He
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*	A HUGE thanks to NeHe for the OpenGL tutorials< http://nehe.gamedev.net >
*
*  If you've found this code useful, Please let me know.
*  My E-mail: < hzhxfrank@gmail.com >
*  My Blog: < http://blog.csdn.net/csxiaoshui >
*
\************************************************************************/

#include "../osgNeHe.h"

#include <QtCore/QTimer>
#include <QtGui/QApplication>
#include <QtGui/QVBoxLayout>

#include <osgViewer/Viewer>
#include <osgDB/ReadFile>
#include <osgQt/GraphicsWindowQt>

#include <osg/MatrixTransform>
#include <osg/Geometry>
					
GLfloat		cx,cy,cz = -15.0f;
int				step=0;
int                steps = 200;
bool				morph = false;

osg::MatrixTransform *g_transMT = NULL;
osg::MatrixTransform	*g_rotateX = NULL;
osg::MatrixTransform	*g_rotateY = NULL;
osg::MatrixTransform	*g_rotateZ = NULL;


struct	VERTEX									
{
	float	x, y, z;								
};

struct OBJECT
{					
	int		        verts;
	VERTEX		*points;
} ;	


OBJECT		        morph1,morph2,morph3,morph4;

osg::Geometry     *morphGeometry1, *morphGeometry2, *morphGeometry3, *morphGeometry4;
osg::Geometry		*srcMorphGeometry, *destMorphGeometry;


void objallocate(OBJECT *k,int n)		
{
	k->points=(VERTEX*)malloc(sizeof(VERTEX)*n);
}

void objfree(OBJECT *k)							
{
	free(k->points);						
}

void readstr(FILE *f,char *string)					
{
	do												
	{
		fgets(string, 255, f);							
	} while ((string[0] == '/') || (string[0] == '\n'));
	return;
}

void objload(char *name,OBJECT *k)	
{
	int		ver;	
	float		rx,ry,rz;
	FILE	*filein;	
	char		 oneline[255];

	filein = fopen(name, "rt");
	readstr(filein,oneline);	
	sscanf(oneline, "Vertices: %d\n", &ver);	
	k->verts=ver;	
	objallocate(k,ver);

	for (int i=0;i<ver;i++)
	{
		readstr(filein,oneline);	
		sscanf(oneline, "%f %f %f", &rx, &ry, &rz);
		k->points[i].x = rx;
		k->points[i].y = ry;
		k->points[i].z = rz;
	}
	fclose(filein);
}


//

class MorphUpdateCallback : public osg::Drawable::UpdateCallback
{
public:
	MorphUpdateCallback(osg::Geometry *dest, int steps) : _destGeometry(dest), _steps(steps)
	{
	}

	void setDestGeometry(osg::Geometry *destGeometry)
	{
		_destGeometry = destGeometry;
	}

	virtual void update(osg::NodeVisitor*, osg::Drawable* drawable)
	{
		osg::Geometry *geom = dynamic_cast<osg::Geometry*>(drawable);
		if (!geom)
			return;
		
		osg::Vec3Array *vertices = dynamic_cast<osg::Vec3Array*>(geom->getVertexArray());
		osg::Vec3Array *destVertices = dynamic_cast<osg::Vec3Array*>(_destGeometry->getVertexArray());	
		if (vertices && destVertices)
		{
			for (unsigned i = 0; i < vertices->size(); ++i)
			{
				osg::Vec3 delta = (destVertices->at(i) - vertices->at(i)) / _steps;
				vertices->at(i) += delta;
			}
			vertices->dirty();
		}	
	}

	int							_steps;
	osg::Geometry*		_destGeometry;
};


void initMorphObject()
{
	objload("Data/sphere.txt",&morph1);
	objload("Data/torus.txt",&morph2);
	objload("Data/tube.txt",&morph3);

	objallocate(&morph4,486);	
	morph4.verts = 486;
	for(int i=0;i<486;i++)
	{
		morph4.points[i].x=((float)(rand()%14000)/1000)-7;
		morph4.points[i].y=((float)(rand()%14000)/1000)-7;
		morph4.points[i].z=((float)(rand()%14000)/1000)-7;	
	}
	
	morphGeometry1 = new osg::Geometry;
	osg::Vec3Array *vertexArray1 = new osg::Vec3Array;
	for (unsigned i = 0; i < morph1.verts; ++i)
	{
		vertexArray1->push_back(osg::Vec3(morph1.points[i].x, morph1.points[i].y, morph1.points[i].z));
	}
	morphGeometry1->setVertexArray(vertexArray1);
	morphGeometry1->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, 486));
	morphGeometry1->setUseDisplayList(false);
	srcMorphGeometry = dynamic_cast<osg::Geometry*>(morphGeometry1->clone(osg::CopyOp::DEEP_COPY_ALL));
	destMorphGeometry = morphGeometry1;
	
	morphGeometry2 = new osg::Geometry;
	osg::Vec3Array *vertexArray2 = new osg::Vec3Array;
	for (unsigned i = 0; i < morph2.verts; ++i)
	{
		vertexArray2->push_back(osg::Vec3(morph2.points[i].x, morph2.points[i].y, morph2.points[i].z));
	}
	morphGeometry2->setVertexArray(vertexArray2);
	morphGeometry2->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, 486));
	morphGeometry2->setUseDisplayList(false);

	morphGeometry3 = new osg::Geometry;
	osg::Vec3Array *vertexArray3 = new osg::Vec3Array;
	for (unsigned i = 0; i < morph3.verts; ++i)
	{
		vertexArray3->push_back(osg::Vec3(morph3.points[i].x, morph3.points[i].y, morph3.points[i].z));
	}
	morphGeometry3->setVertexArray(vertexArray3);
	morphGeometry3->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, 486));
	morphGeometry3->setUseDisplayList(false);
	
	morphGeometry4 = new osg::Geometry;
	osg::Vec3Array *vertexArray4 = new osg::Vec3Array;
	for (unsigned i = 0; i < morph4.verts; ++i)
	{
		vertexArray4->push_back(osg::Vec3(morph4.points[i].x, morph4.points[i].y, morph4.points[i].z));
	}
	morphGeometry4->setVertexArray(vertexArray4);
	morphGeometry4->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, 486));
	morphGeometry4->setUseDisplayList(false);
}


//
class RotAxisCallback : public osg::NodeCallback
{
public:
	RotAxisCallback(const osg::Vec3& axis, double rotSpeed = 0.0, double currentAngle = 0.0)
		: _rotAxis(axis), _rotSpeed(rotSpeed), _currentAngle(currentAngle){ }

	virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
	{
		osg::MatrixTransform *rotMT = dynamic_cast<osg::MatrixTransform*>(node);
		if (!rotMT)
			return;
		rotMT->setMatrix(osg::Matrix::rotate(_currentAngle, _rotAxis));
		_currentAngle += _rotSpeed;

		traverse(node, nv);
	}

	void setRotateSpeed(double speed)
	{
		_rotSpeed = speed;
	}

	double getRotateSpeed() const
	{
		return _rotSpeed;
	}


private:
	osg::Vec3		_rotAxis;
	double			_currentAngle;
	double			_rotSpeed;
};


//
class ManipulatorSceneHandler : public osgGA::GUIEventHandler
{
public:
	ManipulatorSceneHandler()
	{
	}

	virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
	{
		osgViewer::Viewer *viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
		if (!viewer)
			return false;
		if (!viewer->getSceneData())
			return false;
		if (ea.getHandled()) 
			return false;

		osg::Group *root = viewer->getSceneData()->asGroup();

		switch(ea.getEventType())
		{
		case(osgGA::GUIEventAdapter::KEYDOWN):
			{
				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Left)
				{
					if (!g_rotateX)
						return false;

					RotAxisCallback *rotCallback = dynamic_cast<RotAxisCallback*>(g_rotateX->getUpdateCallback());
					if (!rotCallback)
						return false;

					double speed = rotCallback->getRotateSpeed();
					speed -= 0.02;
					rotCallback->setRotateSpeed(speed);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Right)
				{
					if (!g_rotateX)
						return false;

					RotAxisCallback *rotCallback = dynamic_cast<RotAxisCallback*>(g_rotateX->getUpdateCallback());
					if (!rotCallback)
						return false;

					double speed = rotCallback->getRotateSpeed();
					speed += 0.02;
					rotCallback->setRotateSpeed(speed);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Up)
				{
					if (!g_rotateY)
						return false;

					RotAxisCallback *rotCallback = dynamic_cast<RotAxisCallback*>(g_rotateY->getUpdateCallback());
					if (!rotCallback)
						return false;

					double speed = rotCallback->getRotateSpeed();
					speed -= 0.02;
					rotCallback->setRotateSpeed(speed);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_Down)
				{
					if (!g_rotateY)
						return false;

					RotAxisCallback *rotCallback = dynamic_cast<RotAxisCallback*>(g_rotateY->getUpdateCallback());
					if (!rotCallback)
						return false;

					double speed = rotCallback->getRotateSpeed();
					speed += 0.02;
					rotCallback->setRotateSpeed(speed);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_Page_Up)
				{	
					if (!g_rotateZ)
						return false;

					RotAxisCallback *rotCallback = dynamic_cast<RotAxisCallback*>(g_rotateZ->getUpdateCallback());
					if (!rotCallback)
						return false;

					double speed = rotCallback->getRotateSpeed();
					speed -= 0.02;
					rotCallback->setRotateSpeed(speed);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_Page_Down)
				{
					if (!g_rotateZ)
						return false;

					RotAxisCallback *rotCallback = dynamic_cast<RotAxisCallback*>(g_rotateZ->getUpdateCallback());
					if (!rotCallback)
						return false;

					double speed = rotCallback->getRotateSpeed();
					speed += 0.02;
					rotCallback->setRotateSpeed(speed);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_A)
				{
					if (!g_transMT)
						return false;

					osg::Matrix transMatrix = g_transMT->getMatrix();
					transMatrix.setTrans(transMatrix.getTrans() + osg::Vec3(-0.1, 0, 0));
					g_transMT->setMatrix(transMatrix);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_D)
				{
					if (!g_transMT)
						return false;

					osg::Matrix transMatrix = g_transMT->getMatrix();
					transMatrix.setTrans(transMatrix.getTrans() + osg::Vec3(0.1, 0, 0));
					g_transMT->setMatrix(transMatrix);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_W)
				{
					if (!g_transMT)
						return false;

					osg::Matrix transMatrix = g_transMT->getMatrix();
					transMatrix.setTrans(transMatrix.getTrans() + osg::Vec3(0, 0.1, 0));
					g_transMT->setMatrix(transMatrix);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_S)
				{
					if (!g_transMT)
						return false;

					osg::Matrix transMatrix = g_transMT->getMatrix();
					transMatrix.setTrans(transMatrix.getTrans() + osg::Vec3(0, -0.1, 0));
					g_transMT->setMatrix(transMatrix);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_Q)
				{
					if (!g_transMT)
						return false;

					osg::Matrix transMatrix = g_transMT->getMatrix();
					transMatrix.setTrans(transMatrix.getTrans() + osg::Vec3(0, 0, -0.1));
					g_transMT->setMatrix(transMatrix);
				}

				if (ea.getKey()== osgGA::GUIEventAdapter::KEY_Z)
				{
					if (!g_transMT)
						return false;

					osg::Matrix transMatrix = g_transMT->getMatrix();
					transMatrix.setTrans(transMatrix.getTrans() + osg::Vec3(0, 0, 0.1));
					g_transMT->setMatrix(transMatrix);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_1)
				{
					MorphUpdateCallback *muc = dynamic_cast<MorphUpdateCallback*>(srcMorphGeometry->getUpdateCallback());
					if (!muc)
						return false;
					muc->setDestGeometry(morphGeometry1);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_2)
				{
					MorphUpdateCallback *muc = dynamic_cast<MorphUpdateCallback*>(srcMorphGeometry->getUpdateCallback());
					if (!muc)
						return false;
					muc->setDestGeometry(morphGeometry2);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_3)
				{
					MorphUpdateCallback *muc = dynamic_cast<MorphUpdateCallback*>(srcMorphGeometry->getUpdateCallback());
					if (!muc)
						return false;
					muc->setDestGeometry(morphGeometry3);
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_4)
				{
					MorphUpdateCallback *muc = dynamic_cast<MorphUpdateCallback*>(srcMorphGeometry->getUpdateCallback());
					if (!muc)
						return false;
					muc->setDestGeometry(morphGeometry4);
				}

			}
		default: break;
		}
		return false;
	}
};



class ViewerWidget : public QWidget, public osgViewer::Viewer
{
public:
	ViewerWidget(osg::Node *scene = NULL)
	{
		QWidget* renderWidget = getRenderWidget( createGraphicsWindow(0,0,640,480), scene);

		QVBoxLayout* layout = new QVBoxLayout;
		layout->addWidget(renderWidget);
		layout->setContentsMargins(0, 0, 0, 1);
		setLayout( layout );

		connect( &_timer, SIGNAL(timeout()), this, SLOT(update()) );
		_timer.start( 10 );
	}

	QWidget* getRenderWidget( osgQt::GraphicsWindowQt* gw, osg::Node* scene )
	{
		osg::Camera* camera = this->getCamera();
		camera->setGraphicsContext( gw );

		const osg::GraphicsContext::Traits* traits = gw->getTraits();

		camera->setClearColor( osg::Vec4(0.0, 0.0, 0.0, 1.0) );
		camera->setViewport( new osg::Viewport(0, 0, traits->width, traits->height) );
		camera->setProjectionMatrixAsPerspective(45.0f, static_cast<double>(traits->width)/static_cast<double>(traits->height), 0.1f, 100.0f );
		camera->setViewMatrixAsLookAt(osg::Vec3d(0, 0, 1), osg::Vec3d(0, 0, 0), osg::Vec3d(0, 1, 0));

		this->setSceneData( scene );
		this->addEventHandler(new ManipulatorSceneHandler);
		return gw->getGLWidget();
	}

	osgQt::GraphicsWindowQt* createGraphicsWindow( int x, int y, int w, int h, const std::string& name="", bool windowDecoration=false )
	{
		osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
		osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
		traits->windowName = name;
		traits->windowDecoration = windowDecoration;
		traits->x = x;
		traits->y = y;
		traits->width = w;
		traits->height = h;
		traits->doubleBuffer = true;
		traits->alpha = ds->getMinimumNumAlphaBits();
		traits->stencil = ds->getMinimumNumStencilBits();
		traits->sampleBuffers = ds->getMultiSamples();
		traits->samples = ds->getNumMultiSamples();

		return new osgQt::GraphicsWindowQt(traits.get());
	}

	virtual void paintEvent( QPaintEvent* event )
	{ 
		frame(); 
	}

protected:

	QTimer _timer;
};


osg::Node*	buildScene()
{
	initMorphObject();

	osg::Group *root = new osg::Group;
	root->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE);

	osg::MatrixTransform *mt = new osg::MatrixTransform;
	g_transMT = mt;
	mt->setMatrix(osg::Matrix::translate(0, 0, cz));

	osg::MatrixTransform *rotX = new osg::MatrixTransform;
	g_rotateX = rotX;
	rotX->addUpdateCallback(new RotAxisCallback(osg::X_AXIS));
	osg::MatrixTransform *rotY = new osg::MatrixTransform;
	g_rotateY = rotY;
	rotY->addUpdateCallback(new RotAxisCallback(osg::Y_AXIS));
	osg::MatrixTransform *rotZ = new osg::MatrixTransform;
	g_rotateZ = rotZ;
	rotZ->addUpdateCallback(new RotAxisCallback(osg::Z_AXIS));
	
	osg::Geode *geode = new osg::Geode;
	geode->addDrawable(srcMorphGeometry);
	srcMorphGeometry->setUpdateCallback(new MorphUpdateCallback(destMorphGeometry,200));
	
	root->addChild(mt);
	mt->addChild(rotX);
	rotX->addChild(rotY);
	rotY->addChild(rotZ);
	rotZ->addChild(geode);
	
	return root;
}


int main( int argc, char** argv )
{
	QApplication app(argc, argv);
	ViewerWidget* viewWidget = new ViewerWidget(buildScene());
	viewWidget->setGeometry( 100, 100, 640, 480 );
	viewWidget->show();
	return app.exec();
}

csxiaoshui
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NeHe的OpenGl教程 - 前5课总结
八戒的专栏
10-19 849
NeHe 的 OpenGL 教程浅显易懂，每行都有注释，适合入门学习用。不过，要想让教程中的程序运行在我的电脑上，需要做一些小小的设置我的电脑的软件配置：Windows XP Professional + Visual C++ 2008 Express1. “项目属性”的 Configuration Properties 选项卡：Character SetNeHe 教程用的全是
OpenSceneGraph-OpenSceneGraph-3.6.5.zip
01-09
OpenSceneGraph（简称osg）是一个开源的3D图形库，专为实时三维图形应用程序设计，如游戏、虚拟现实系统和科学可视化...通过深入学习和使用OpenSceneGraph，开发者能够构建出令人印象深刻的3D应用程序，满足各种需求。
用OpenSceneGraph实现的NeHe OpenGL教程 - 第四十二课
Frank的专栏
06-03 2688
简介 这节课NeHe课程
OpenSceneGraph实现的NeHe OpenGL教程 - 第二十五课
ALLENJIAO的专栏
08-17 816
简介 NeHe教程在这节课中向我们介绍了如何从文件加载3D模型，并且平滑的从一个模型变换为另一个模型。这个过程又称为逐点动画，点之间的变化过程算法十分简单，采用的是线性的算法。 实现 首先我们仿照NeHe课程中定义了表示点的结构体以及读取文件的结构体OBJECT并读取文件 [cpp] view plain copy  
OpenSceneGraph实现的NeHe OpenGL教程 - 第三十五课
ALLENJIAO的专栏
08-17 627
简介 这节课介绍了如何在三维场景中类似播放一段视频的效果。我们都知道视频实际上是由一帧帧的图片来构成的，因此我们将视频中的图片解析成图片格式，并将这些图片赋给几何体表面，让它们在很短的间隔内进行切换就实现了动态的效果。 实现 本课中使用了Windows解析视频格式AVI文件的API，代码中这部分内容都来自NeHe课程中的相应代码，读者可以查阅MSDN了解这些内容：
OpenSceneGraph-3.6.5-VC2019-64-Release.7z
08-11
6. **使用OpenSceneGraph**：开发人员可以使用OpenSceneGraph来创建3D交互界面，加载3D模型，实现复杂的光照效果，进行纹理映射，实现视口管理，以及利用动画和物理模拟。它还支持多种数据格式导入，如OBJ、COLLADA...
OSG(OpenSceneGraph)3.4.0-开发包-DEBUG
07-08
OpenSceneGraph（OSG）是一个开源的3D图形库，专为实时三维图形应用程序设计，如游戏、虚拟现实系统和科学可视化。版本3.4.0是OSG的一个重要里程碑，提供了许多性能优化和新特性。这个压缩包是专门为开发者准备的...
OpenSceneGraph-3.6.4-VC2017-64-Debug（117M）
12-17
从网站 https://objexx.com/OpenSceneGraph.html搬过来的，外网实在太慢，搬砖不易！ OpenSceneGraph 3.6.4 -- Visual C++ 2017 -- 64-bit -- Debug Plugins/Notes ...The default OpenGL GL2 level was used
OpenSceneGraph-3.6.5-VC2019-64-Debug.7z
01-26
OpenSceneGraph是一个强大的开源3D图形库，专为实时可视化和高级图形应用设计。这个压缩包"OpenSceneGraph-3.6.5-VC2019-64-Debug.7z"包含了OpenSceneGraph的3.6.5版本，针对Visual Studio 2019编译器和64位操作系统...
用OpenSceneGraph实现的NeHe OpenGL教程 - 第一课
Frank的专栏
01-16 9783
简介 OpenSceneGraph是一个开放源码，跨平台的图形开发包，它为诸如飞行器仿真，游戏，虚拟现实，科学计算可视化这样的高性能图形应用程序开发而设计。它基于场景图的概念，它提供一个在OpenGL之上的面向对象的框架，从而能把开发者从实现和优化底层图形的调用中解脱出来，并且它为图形应用程序的快速开发提供很多附加的实用工具。 NeHe教程是目前针对初学者来说最
用OpenSceneGraph实现的NeHe OpenGL教程 - 第十二课
Frank的专栏
02-20 7794
简介 本课NeHe教程主要是使用了OpenGL中的显示列表。OpenGL的显示列表是加速OpenGL性能的一种重要的手段。OpenGl的几何体绘制方法主要包括立即模式、顶点数组、显示列表和VBO。在OSG中显示列表是大部分OSG程序所使用的默认绘制优化行为，因此不需要我们去像OpenGL那样进行设置。 实现 首先创建整个场景，本课中我使用了OSG中预定义的几种基本形体，(os
用OpenSceneGraph实现的NeHe OpenGL教程 - 第二课
Frank的专栏
01-20 3681
这节课主要工作是在场景中添加一个三角形和一个四边形。本节新增加一个函数buildScene，这个函数将在场景中创建一个三角形和一个四边形。 osg场景介绍 在添加场景之前，先对osg的场景结果有一个了解，osg采用场景树的方式来组织场景，如下图所示： 场景已节点(Node)的方式来组织，包括组节点Group（用来管理节点），空间变换节点(MatrixTransform)，细节
osgNeHe开发环境搭建
Frank的专栏
10-05 3608
国庆出去了几天，今天有点时间，把上次承诺的环境搭建过程xy
用OpenSceneGraph实现的NeHe OpenGL教程 - 第六课
Frank的专栏
01-22 2912
简介 本节课要实现的内容是为立方体的六个面添加纹理 纹理映射(Texture Mapping)是OpenGL程序开发中的一个重要概念。纹理是一个数组的概念，其中每一个数据(RGB颜色以及Alpha值，或者其他系统及用户定义的类型)称为一个纹素(texel)。在描绘具有真实感无提示，使用一幅真实拍摄的照片作为纹理贴到几何体的表面，可以大大丰富物体的表现效果。 OSG使用派生自StateAt
用OpenSceneGraph实现的NeHe OpenGL教程 - 第十课
Frank的专栏
02-17 2901
简介
用OpenSceneGraph实现的NeHe OpenGL教程 - 第三课
Frank的专栏
01-20 2667
简介 这节课将在第二课的基础上讨论如何使用颜色。与OpenGL类似，OSG也提供了两种色彩模式。我们将对四边形只使用一种颜色显示，对三角形则要对每个顶点设置一个颜色。事实上在第二课中我们已经设置颜色了，只是我们设置的都是单一的白色，按照本课的要求，我们只需要在第二课的基础上修改少量的代码。 修改颜色 OpenGL是一个状态机，在OpenGL中需要设置很多状态量，一般由gl
用OpenSceneGraph实现的NeHe OpenGL教程 - 第四十四课
Frank的专栏
06-05 2613
简介 这节课NeHe教我们怎么在场景中实现
用OpenSceneGraph实现的NeHe OpenGL教程 - 第三十课
Frank的专栏
05-27 2607
简介 这节课NeHe课程实现了在场景中进行
OpenSceneGraph编程教程-基于OSG2.20的基础指南
这篇资源似乎是一本关于OpenSceneGraph (OSG) 程序设计的教程，由作者杨石兴编著。OpenSceneGraph 是一个高性能的3D图形库，常用于实时三维图形应用，如模拟、游戏开发、科学可视化等领域。书中的内容可能涵盖了如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值