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

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

  • 简介

这节课NeHe课程实现了在场景中进行碰撞检测以及简单的物理作用(碰撞之后的反弹)，碰撞检测三维图形学中一个比较高级的主题，本课只涉及了简单的规则几何体之间的碰撞检测，更复杂的实例需要读者去更深入的学习。

  • 实现

本课中碰撞检测的算法包括线与平面的求交检测、线与圆柱体的求交、以及球体之间的碰撞检测，这些碰撞检测的原理可以参考NeHe中的介绍。

具体实现在如下几个函数中：

///线面相交
//
int TestIntersionPlane(const Plane& plane,const TVector& position,const TVector& direction, double& lamda, TVector& pNormal)
/线与圆柱体相交///
//
int TestIntersionCylinder(const Cylinder& cylinder,const TVector& position,const TVector& direction, double& lamda, TVector& pNormal,TVector& newposition)
//球体相交/
//
int FindBallCol(TVector& point, double& TimePoint, double Time2, int& BallNr1, int& BallNr2)
之后再每帧中计算了各球体与不同几何体之间的碰撞，具体代码在idle函数中

接下来创建本课中的几何体(包括墙面、地面、圆柱体等)

osg::Geode*	createWalls()
osg::Geode*	createFloor()
osg::Geode*	createCylinder()
osg::Geode*	createCylinder2()
osg::Geode*	createBalls(int i)
在ManipulatorSceneHandler中的Frame时间中不断地进行计算和判断每个球体的位置（调用idle） 

		switch(ea.getEventType())
		{
		case (osgGA::GUIEventAdapter::FRAME):
			{
				idle();
				viewer->getCamera()->setViewMatrixAsLookAt(osg::Vec3(Pos.X(),Pos.Y(),Pos.Z()), osg::Vec3(Pos.X()+dir.X(),Pos.Y()+dir.Y(),Pos.Z()+dir.Z()), osg::Y_AXIS);
			}
最后把这些部分都添加到场景中：

在BuildScene中查看相应的代码

编译运行程序：


附：本课源码(源码中可能存在错误和不足，仅供参考)[其他头文件可以在NeHe课程中下载]

#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/Plane>
#include <osg/Texture2D>
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/CullFace>

#include <osgGA/TrackballManipulator>
#include <osg/ShapeDrawable>

#include <osgGA/GUIEventHandler>
#include <osgGA/GUIEventAdapter>
#include <osg/AnimationPath>
#include <osg/BlendFunc>
#include <osg/Switch>
#include <osg/Material>

#include "Tray.h"
#include "Tvector.h"

//
GLfloat spec[]={1.0, 1.0 ,1.0 ,1.0};      //sets specular highlight of balls
GLfloat posl[]={0,400,0,1};               //position of ligth source
GLfloat amb[]={0.2f, 0.2f, 0.2f ,1.0f};   //global ambient
GLfloat amb2[]={0.3f, 0.3f, 0.3f ,1.0f};  //ambient of lightsource

TVector dir(0,0,-10);                     //initial direction of camera
TVector Pos(0,-50,1000);                  //initial position of camera
float camera_rotation=0;                  //holds rotation around the Y axis


TVector veloc(0.5,-0.1,0.5);              //initial velocity of balls
TVector accel(0,-0.05,0);                 //acceleration ie. gravity of balls

TVector ArrayVel[10];                     //holds velocity of balls
TVector ArrayPos[10];                     //position of balls
TVector OldPos[10];                       //old position of balls
int NrOfBalls;                            //sets the number of balls
double Time=0.6;                          //timestep of simulation
int hook_toball1=0, sounds=1;             //hook camera on ball, and sound on/off
//Plane structure
struct Plane{
	TVector _Position;
	TVector _Normal;
};
//Cylinder structure
struct Cylinder{                          
	TVector _Position;
	TVector _Axis;
	double _Radius;
};
//Explosion structure
struct Explosion{
	TVector _Position;
	float   _Alpha;
	float   _Scale;
};

Plane pl1,pl2,pl3,pl4,pl5;                //the 5 planes of the room
Cylinder cyl1,cyl2,cyl3;                  //the 2 cylinders of the room

GLuint texture[4], dlist;                 //stores texture objects and display list
Explosion ExplosionArray[20];             //holds max 20 explosions at once
//Perform Intersection tests with primitives

osg::Switch *g_SwitchNode;
//
///线面相交
//
int TestIntersionPlane(const Plane& plane,const TVector& position,const TVector& direction, double& lamda, TVector& pNormal)
{
	double DotProduct=direction.dot(plane._Normal);
	double l2;

	//determine if ray paralle to plane
	if ((DotProduct<ZERO)&&(DotProduct>-ZERO)) 
		return 0;

	l2=(plane._Normal.dot(plane._Position-position))/DotProduct;

	if (l2<-ZERO) 
		return 0;

	pNormal=plane._Normal;
	lamda=l2;
	return 1;
}


//
/线与圆柱体相交///
//
int TestIntersionCylinder(const Cylinder& cylinder,const TVector& position,const TVector& direction, double& lamda, TVector& pNormal,TVector& newposition)
{
	TVector RC;
	double d;
	double t,s;
	TVector n,D,O;
	double ln;
	double in,out;


	TVector::subtract(position,cylinder._Position,RC);
	TVector::cross(direction,cylinder._Axis,n);

	ln=n.mag();

	if ( (ln<ZERO)&&(ln>-ZERO) ) return 0;

	n.unit();

	d= fabs( RC.dot(n) );

	if (d<=cylinder._Radius)
	{
		TVector::cross(RC,cylinder._Axis,O);
		t= - O.dot(n)/ln;
		TVector::cross(n,cylinder._Axis,O);
		O.unit();
		s= fabs( sqrt(cylinder._Radius*cylinder._Radius - d*d) / direction.dot(O) );

		in=t-s;
		out=t+s;

		if (in<-ZERO){
			if (out<-ZERO) return 0;
			else lamda=out;
		}
		else
			if (out<-ZERO) {
				lamda=in;
			}
			else
				if (in<out) lamda=in;
				else lamda=out;

				newposition=position+direction*lamda;
				TVector HB=newposition-cylinder._Position;
				pNormal=HB - cylinder._Axis*(HB.dot(cylinder._Axis));
				pNormal.unit();

				return 1;
	}

	return 0;
}

//
//球体相交/
//
int FindBallCol(TVector& point, double& TimePoint, double Time2, int& BallNr1, int& BallNr2)
{
	TVector RelativeV;
	TRay rays;
	double MyTime=0.0, Add=Time2/150.0, Timedummy=10000, Timedummy2=-1;
	TVector posi;

	//Test all balls against eachother in 150 small steps
	for (int i=0;i<NrOfBalls-1;i++)
	{
		for (int j=i+1;j<NrOfBalls;j++)
		{	
			RelativeV=ArrayVel[i]-ArrayVel[j];
			rays=TRay(OldPos[i],TVector::unit(RelativeV));
			MyTime=0.0;

			if ( (rays.dist(OldPos[j])) > 40) continue; 

			while (MyTime<Time2)
			{
				MyTime+=Add;
				posi=OldPos[i]+RelativeV*MyTime;
				if (posi.dist(OldPos[j])<=40) {
					point=posi;
					if (Timedummy>(MyTime-Add)) 
						Timedummy=MyTime-Add;
					BallNr1=i;
					BallNr2=j;
					break;
				}
			}
		}
	}

	if (Timedummy!=10000) { 
		TimePoint=Timedummy;
		return 1;
	}

	return 0;
}


void initVars()
{
	//create palnes
	pl1._Position=TVector(0,-300,0);
	pl1._Normal=TVector(0,1,0);
	pl2._Position=TVector(300,0,0);
	pl2._Normal=TVector(-1,0,0);
	pl3._Position=TVector(-300,0,0);
	pl3._Normal=TVector(1,0,0);
	pl4._Position=TVector(0,0,300);
	pl4._Normal=TVector(0,0,-1);
	pl5._Position=TVector(0,0,-300);
	pl5._Normal=TVector(0,0,1);


	//create cylinders
	cyl1._Position=TVector(0,0,0);
	cyl1._Axis=TVector(0,1,0);
	cyl1._Radius=60+20;
	cyl2._Position=TVector(200,-300,0);
	cyl2._Axis=TVector(0,0,1);
	cyl2._Radius=60+20;
	cyl3._Position=TVector(-200,0,0);
	cyl3._Axis=TVector(0,1,1);
	cyl3._Axis.unit();
	cyl3._Radius=30+20;

	//Set initial positions and velocities of balls
	//also initialize array which holds explosions
	NrOfBalls=10;
	ArrayVel[0]=veloc;
	ArrayPos[0]=TVector(199,180,10);
	ExplosionArray[0]._Alpha=0;
	ExplosionArray[0]._Scale=1;
	ArrayVel[1]=veloc;
	ArrayPos[1]=TVector(0,150,100);
	ExplosionArray[1]._Alpha=0;
	ExplosionArray[1]._Scale=1;
	ArrayVel[2]=veloc;
	ArrayPos[2]=TVector(-100,180,-100);
	ExplosionArray[2]._Alpha=0;
	ExplosionArray[2]._Scale=1;
	for (int i=3; i<10; i++)
	{
		ArrayVel[i]=veloc;
		ArrayPos[i]=TVector(-500+i*75, 300, -500+i*50);
		ExplosionArray[i]._Alpha=0;
		ExplosionArray[i]._Scale=1;
	}
	for (int i=10; i<20; i++)
	{
		ExplosionArray[i]._Alpha=0;
		ExplosionArray[i]._Scale=1;
	}
}


void idle()
{
	double rt,rt2,rt4,lamda=10000;
	TVector norm,uveloc;
	TVector normal,point,time;
	double RestTime,BallTime;
	TVector Pos2;
	int BallNr=0,dummy=0,BallColNr1,BallColNr2;
	TVector Nc;

	if (!hook_toball1)
	{
		camera_rotation+=0.1f;
		if (camera_rotation>360)
			camera_rotation=0;
	}

	RestTime=Time;
	lamda=1000;

	//Compute velocity for next timestep using Euler equations
	for (int j=0;j<NrOfBalls;j++)
		ArrayVel[j]+=accel*RestTime;

	//While timestep not over
	while (RestTime>ZERO)
	{
		lamda=10000;   //initialize to very large value

		//For all the balls find closest intersection between balls and planes/cylinders
		for (int i=0;i<NrOfBalls;i++)
		{
			//compute new position and distance
			OldPos[i]=ArrayPos[i];
			TVector::unit(ArrayVel[i],uveloc);
			ArrayPos[i]=ArrayPos[i]+ArrayVel[i]*RestTime;
			rt2=OldPos[i].dist(ArrayPos[i]);

			//Test if collision occured between ball and all 5 planes
			if (TestIntersionPlane(pl1,OldPos[i],uveloc,rt,norm))
			{  
				//Find intersection time
				rt4=rt*RestTime/rt2;

				//if smaller than the one already stored replace and in timestep
				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=OldPos[i]+uveloc*rt;
							lamda=rt4;
							BallNr=i;
						}
				}
			}

			if (TestIntersionPlane(pl2,OldPos[i],uveloc,rt,norm))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=OldPos[i]+uveloc*rt;
							lamda=rt4;
							BallNr=i;
							dummy=1;
						}
				}

			}

			if (TestIntersionPlane(pl3,OldPos[i],uveloc,rt,norm))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=OldPos[i]+uveloc*rt;
							lamda=rt4;
							BallNr=i;
						}
				}
			}

			if (TestIntersionPlane(pl4,OldPos[i],uveloc,rt,norm))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=OldPos[i]+uveloc*rt;
							lamda=rt4;
							BallNr=i;
						}
				}
			}

			if (TestIntersionPlane(pl5,OldPos[i],uveloc,rt,norm))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=OldPos[i]+uveloc*rt;
							lamda=rt4;
							BallNr=i;
						}
				}
			}

			//Now test intersection with the 3 cylinders
			if (TestIntersionCylinder(cyl1,OldPos[i],uveloc,rt,norm,Nc))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=Nc;
							lamda=rt4;
							BallNr=i;
						}
				}

			}
			if (TestIntersionCylinder(cyl2,OldPos[i],uveloc,rt,norm,Nc))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=Nc;
							lamda=rt4;
							BallNr=i;
						}
				}

			}
			if (TestIntersionCylinder(cyl3,OldPos[i],uveloc,rt,norm,Nc))
			{
				rt4=rt*RestTime/rt2;

				if (rt4<=lamda)
				{ 
					if (rt4<=RestTime+ZERO)
						if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
						{
							normal=norm;
							point=Nc;
							lamda=rt4;
							BallNr=i;
						}
				}

			}
		}

		//After all balls were teste with planes/cylinders test for collision
		//between them and replace if collision time smaller
		if (FindBallCol(Pos2,BallTime,RestTime,BallColNr1,BallColNr2))
		{
			//if (sounds)
			//	PlaySound("Data/Explode.wav",NULL,SND_FILENAME|SND_ASYNC);

			if ( (lamda==10000) || (lamda>BallTime) )
			{
				RestTime=RestTime-BallTime;

				TVector pb1,pb2,xaxis,U1x,U1y,U2x,U2y,V1x,V1y,V2x,V2y;
				double a,b;

				pb1=OldPos[BallColNr1]+ArrayVel[BallColNr1]*BallTime;
				pb2=OldPos[BallColNr2]+ArrayVel[BallColNr2]*BallTime;
				xaxis=(pb2-pb1).unit();

				a=xaxis.dot(ArrayVel[BallColNr1]);
				U1x=xaxis*a;
				U1y=ArrayVel[BallColNr1]-U1x;

				xaxis=(pb1-pb2).unit();
				b=xaxis.dot(ArrayVel[BallColNr2]);
				U2x=xaxis*b;
				U2y=ArrayVel[BallColNr2]-U2x;

				V1x=(U1x+U2x-(U1x-U2x))*0.5;
				V2x=(U1x+U2x-(U2x-U1x))*0.5;
				V1y=U1y;
				V2y=U2y;

				for (int j=0;j<NrOfBalls;j++)
					ArrayPos[j]=OldPos[j]+ArrayVel[j]*BallTime;

				ArrayVel[BallColNr1]=V1x+V1y;
				ArrayVel[BallColNr2]=V2x+V2y;

				//Update explosion array
				for(int j=0;j<20;j++)
				{
					if (ExplosionArray[j]._Alpha<=0)
					{
						ExplosionArray[j]._Alpha=1;
						ExplosionArray[j]._Position=ArrayPos[BallColNr1];
						ExplosionArray[j]._Scale=1;
						break;
					}
				}

				continue;
			}
		}

		//End of tests 
		//If test occured move simulation for the correct timestep
		//and compute response for the colliding ball
		if (lamda!=10000)
		{		 
			RestTime-=lamda;

			for (int j=0;j<NrOfBalls;j++)
				ArrayPos[j]=OldPos[j]+ArrayVel[j]*lamda;

			rt2=ArrayVel[BallNr].mag();
			ArrayVel[BallNr].unit();
			ArrayVel[BallNr]=TVector::unit( (normal*(2*normal.dot(-ArrayVel[BallNr]))) + ArrayVel[BallNr] );
			ArrayVel[BallNr]=ArrayVel[BallNr]*rt2;

			//Update explosion array
			for(int j=0;j<20;j++)
			{
				if (ExplosionArray[j]._Alpha<=0)
				{
					ExplosionArray[j]._Alpha=1;
					ExplosionArray[j]._Position=point;
					ExplosionArray[j]._Scale=1;
					break;
				}
			}
		}
		else RestTime=0;

	}

}

//
//
//


osg::Geode*	createWalls()
{
	osg::Geode *geode = new osg::Geode;
	osg::Geometry *geometry = new osg::Geometry;
	osg::Vec3Array *vertexArray = new osg::Vec3Array;
	osg::Vec2Array *textureArray = new osg::Vec2Array;
	osg::Vec3Array *colorArray = new osg::Vec3Array;

	colorArray->push_back(osg::Vec3(1,1,1));

	vertexArray->push_back(osg::Vec3(320,320,320));
	vertexArray->push_back(osg::Vec3(320,-320,320));
	vertexArray->push_back(osg::Vec3(-320,-320,320));
	vertexArray->push_back(osg::Vec3(-320,320,320));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));

	vertexArray->push_back(osg::Vec3(-320,320,-320));
	vertexArray->push_back(osg::Vec3(-320,-320,-320));
	vertexArray->push_back(osg::Vec3(320,-320,-320));
	vertexArray->push_back(osg::Vec3(320,320,-320));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));

	vertexArray->push_back(osg::Vec3(320,320,-320));
	vertexArray->push_back(osg::Vec3(320,-320,-320));
	vertexArray->push_back(osg::Vec3(320,-320,320));
	vertexArray->push_back(osg::Vec3(320,320,320));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));

	vertexArray->push_back(osg::Vec3(-320,320,320));
	vertexArray->push_back(osg::Vec3(-320,-320,320));
	vertexArray->push_back(osg::Vec3(-320,-320,-320));
	vertexArray->push_back(osg::Vec3(-320,320,-320));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));

	geometry->setVertexArray(vertexArray);
	geometry->setColorArray(colorArray, osg::Array::BIND_OVERALL);
	geometry->setTexCoordArray(0, textureArray, osg::Array::BIND_PER_VERTEX);

	osg::Texture2D *texture2D = new osg::Texture2D;
	texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
	texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
	texture2D->setImage(osgDB::readImageFile("Data/wand.bmp"));
	geometry->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture2D);
	geometry->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace());

	geometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0, vertexArray->size()));
	geode->addDrawable(geometry);

	return geode;
}


osg::Geode*	createFloor()
{
	osg::Geode *geode = new osg::Geode;
	osg::Geometry *geometry = new osg::Geometry;

	osg::Vec3Array *vertexArray = new osg::Vec3Array;
	osg::Vec2Array *textureArray = new osg::Vec2Array;
	osg::Vec3Array *colorArray = new osg::Vec3Array;
	colorArray->push_back(osg::Vec3(1,1,1));
	vertexArray->push_back(osg::Vec3(-320,-320,320));
	vertexArray->push_back(osg::Vec3(320,-320,320));
	vertexArray->push_back(osg::Vec3(320,-320,-320));
	vertexArray->push_back(osg::Vec3(-320,-320,-320));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));
	geometry->setVertexArray(vertexArray);
	geometry->setColorArray(colorArray, osg::Array::BIND_OVERALL);
	geometry->setTexCoordArray(0, textureArray, osg::Array::BIND_PER_VERTEX);

	osg::Texture2D *texture2D = new osg::Texture2D;
	texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
	texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
	texture2D->setImage(osgDB::readImageFile("Data/boden.bmp"));
	geometry->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture2D);

	geometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0, vertexArray->size()));
	geode->addDrawable(geometry);

	return geode;
}



osg::Geode*	createCylinder()
{
	osg::Geode *cylinderGeode = new osg::Geode;
	osg::ShapeDrawable *shapeDrawable = new osg::ShapeDrawable;
	osg::Texture2D *texture2D = new osg::Texture2D;
	texture2D->setImage(osgDB::readImageFile("Data/Marble.bmp"));
	shapeDrawable->getOrCreateStateSet()->setTextureAttributeAndModes(0,texture2D);
	shapeDrawable->setColor(osg::Vec4(0.5,0.5,0.5, 1.0));
	shapeDrawable->setShape(new osg::Cylinder(osg::Vec3(), 60, 2000));
	cylinderGeode->addDrawable(shapeDrawable);
	
	return cylinderGeode;
}

osg::Geode*	createCylinder2()
{
	osg::Geode *cylinderGeode = new osg::Geode;
	osg::ShapeDrawable *shapeDrawable = new osg::ShapeDrawable;

	osg::Texture2D *texture2D = new osg::Texture2D;
	texture2D->setImage(osgDB::readImageFile("Data/Marble.bmp"));
	shapeDrawable->getOrCreateStateSet()->setTextureAttributeAndModes(0,texture2D);
	shapeDrawable->setColor(osg::Vec4(0.5,0.5,0.5, 1.0));
	shapeDrawable->setShape(new osg::Cylinder(osg::Vec3(), 30, 2000));
	cylinderGeode->addDrawable(shapeDrawable);

	return cylinderGeode;
}

osg::Geode*	createBalls(int i)
{
	osg::Geode *cylinderSphere = new osg::Geode;
	osg::ShapeDrawable *shapeDrawable = new osg::ShapeDrawable;

	switch(i){
		case 1: shapeDrawable->setColor(osg::Vec4(1.0f,1.0f,1.0f, 1.0f));
			break;
		case 2: shapeDrawable->setColor(osg::Vec4(1.0f,1.0f,0.0f, 1.0f));
			break;
		case 3: shapeDrawable->setColor(osg::Vec4(0.0f,1.0f,1.0f, 1.0f));
			break;
		case 4: shapeDrawable->setColor(osg::Vec4(0.0f,1.0f,0.0f, 1.0f));
			break;
		case 5: shapeDrawable->setColor(osg::Vec4(0.0f,0.0f,1.0f, 1.0f));
			break;
		case 6: shapeDrawable->setColor(osg::Vec4(0.65f,0.2f,0.3f, 1.0f));
			break;
		case 7: shapeDrawable->setColor(osg::Vec4(1.0f,0.0f,1.0f, 1.0f));
			break;
		case 8: shapeDrawable->setColor(osg::Vec4(0.0f,0.7f,0.4f,1.0f));
			break;
		default: shapeDrawable->setColor(osg::Vec4(1.0f, 0.0, 0.0, 1.0));
	}
	shapeDrawable->setShape(new osg::Sphere(osg::Vec3(), 20));
	cylinderSphere->addDrawable(shapeDrawable);

	return cylinderSphere;
}


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

public:
	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::FRAME):
			{
				idle();
				viewer->getCamera()->setViewMatrixAsLookAt(osg::Vec3(Pos.X(),Pos.Y(),Pos.Z()), osg::Vec3(Pos.X()+dir.X(),Pos.Y()+dir.Y(),Pos.Z()+dir.Z()), osg::Y_AXIS);
			}
		case(osgGA::GUIEventAdapter::KEYDOWN):
			{
				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Left)
				{
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Right)
				{
				}

				if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Space)
				{
				}
			}
		default: break;
		}
		return false;
	}
};

//

class PostionUpdateCallback : public osg::NodeCallback
{
public:
	PostionUpdateCallback(int index) : _index(index){ }

	virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
	{
		osg::MatrixTransform *mt = dynamic_cast<osg::MatrixTransform*>(node);
		if (!mt)
			return;

		mt->setMatrix(osg::Matrix::translate(ArrayPos[_index].X(),ArrayPos[_index].Y(),ArrayPos[_index].Z()));
		
		traverse(node, nv);
	}
	
	int _index;
};


class CollisionSwitchUpdateCallback : public osg::NodeCallback
{
public:
	CollisionSwitchUpdateCallback(int index) : _index(index){ }

	virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
	{
		osg::Switch *st = dynamic_cast<osg::Switch*>(node);
		if (!st)
			return;

		if (ExplosionArray[_index]._Alpha >= 0)
		{
			ExplosionArray[_index]._Alpha-=0.01f;
			ExplosionArray[_index]._Scale+=0.03f;
			st->setAllChildrenOn();
		}
		else
		{
			st->setAllChildrenOff();
		}
		
		

		traverse(node, nv);
	}

	int _index;
};




class CollisionScaleUpdateCallback : public osg::NodeCallback
{
public:
	CollisionScaleUpdateCallback(int index) : _index(index){ }

	virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
	{
		osg::MatrixTransform *mt = dynamic_cast<osg::MatrixTransform*>(node);
		if (!mt)
			return;
		
		if (ExplosionArray[_index]._Alpha >= 0)
		{
			mt->setMatrix(osg::Matrix::scale(ExplosionArray[_index]._Scale,ExplosionArray[_index]._Scale,ExplosionArray[_index]._Scale));
		}

		traverse(node, nv);
	}

	int _index;
};


class CollisionTransUpdateCallback : public osg::NodeCallback
{
public:
	CollisionTransUpdateCallback(int index) : _index(index){ }

	virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
	{
		osg::MatrixTransform *mt = dynamic_cast<osg::MatrixTransform*>(node);
		if (!mt)
			return;

		if (ExplosionArray[_index]._Alpha >= 0)
		{
			mt->setMatrix(osg::Matrix::translate(ArrayPos[_index].X(),ArrayPos[_index].Y(),ArrayPos[_index].Z()));
		}	

		traverse(node, nv);
	}

	int _index;
};


class CollisionGeometryUpdateCallback : public  osg::Drawable::UpdateCallback
{
public:
	CollisionGeometryUpdateCallback(int index) : _index(index){ }

	virtual void update(osg::NodeVisitor*, osg::Drawable* drawable)
	{
		osg::Geometry *geo = dynamic_cast<osg::Geometry*>(drawable);
		if (!geo)
			return;

		osg::Vec4Array *colorArray = dynamic_cast<osg::Vec4Array*>(geo->getColorArray());
		if(!colorArray)
			return;
		
		colorArray->clear();
		colorArray->push_back(osg::Vec4(1,1,0,ExplosionArray[_index]._Alpha));
		geo->setColorArray(colorArray, osg::Array::BIND_OVERALL);
	}

	int _index;
};



//
osg::Node*	createExplorsionNode(int i)
{
	osg::MatrixTransform *rotMT = new osg::MatrixTransform;
	rotMT->setMatrix(osg::Matrix::rotate(osg::DegreesToRadians(-45.0), osg::Y_AXIS));

	osg::Geode *geode = new osg::Geode;
	osg::Geometry *geometry = new osg::Geometry;
	geometry->setUpdateCallback(new CollisionGeometryUpdateCallback(i));
	osg::Vec3Array *vertexArray = new osg::Vec3Array;
	osg::Vec3Array *normalArray = new osg::Vec3Array;
	osg::Vec2Array *textureArray = new osg::Vec2Array;
	osg::Vec4Array *colorArray = new osg::Vec4Array;
	colorArray->push_back(osg::Vec4(0,0,0,1));

	vertexArray->push_back(osg::Vec3(-50,-40,0));
	vertexArray->push_back(osg::Vec3(50,-40,0));
	vertexArray->push_back(osg::Vec3(50,40,0));
	vertexArray->push_back(osg::Vec3(-50,40,0));
	for (int j = 0; j < 4; ++j)
	{
		normalArray->push_back(osg::Vec3(0,0,1));
	}
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));

	vertexArray->push_back(osg::Vec3(-50,40,0));
	vertexArray->push_back(osg::Vec3(50,40,0));
	vertexArray->push_back(osg::Vec3(50,-40,0));
	vertexArray->push_back(osg::Vec3(-50,-40,0));
	for (int j = 0; j < 4; ++j)
	{
		normalArray->push_back(osg::Vec3(0,0,-1));
	}
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));

	vertexArray->push_back(osg::Vec3(0,-40,50));
	vertexArray->push_back(osg::Vec3(0,-40,-50));
	vertexArray->push_back(osg::Vec3(0,40,-50));
	vertexArray->push_back(osg::Vec3(0,40,50));
	for (int j = 0; j < 4; ++j)
	{
		normalArray->push_back(osg::Vec3(1,0,0));
	}
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));

	vertexArray->push_back(osg::Vec3(0,40,50));
	vertexArray->push_back(osg::Vec3(0,40,-50));
	vertexArray->push_back(osg::Vec3(0,-40,-50));
	vertexArray->push_back(osg::Vec3(0,-40,50));
	for (int j = 0; j < 4; ++j)
	{
		normalArray->push_back(osg::Vec3(-1,0,0));
	}
	textureArray->push_back(osg::Vec2(0.0f, 0.0f));
	textureArray->push_back(osg::Vec2(0.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 1.0f));
	textureArray->push_back(osg::Vec2(1.0f, 0.0f));

	osg::Texture2D *texture2D = new osg::Texture2D;
	texture2D->setImage(osgDB::readImageFile("Data/spark.bmp"));

	osg::BlendFunc *blendFunc = new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE);

	osg::Material *material = new osg::Material();
	material->setShininess(osg::Material::FRONT,100.0);
	material->setSpecular(osg::Material::FRONT, osg::Vec4(1.0, 1.0 ,1.0 ,1.0));
	material->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);

	geometry->setVertexArray(vertexArray);
	geometry->setNormalArray(normalArray, osg::Array::BIND_PER_VERTEX);
	geometry->setTexCoordArray(0, textureArray, osg::Array::BIND_PER_VERTEX);
	geometry->setColorArray(colorArray, osg::Array::BIND_OVERALL);
	geometry->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture2D);
	geometry->getOrCreateStateSet()->setAttributeAndModes(blendFunc);
	geometry->getOrCreateStateSet()->setAttributeAndModes(material);
	geometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0, vertexArray->size()));
	geometry->setUseDisplayList(false);
	geode->addDrawable(geometry);
	rotMT->addChild(geode);

	return rotMT;
}

//
/osgNeHe框架/
//

class ViewerWidget : public QWidget, public osgViewer::Viewer
{
public:
	ViewerWidget(osg::Node *scene = NULL)
	{
		QWidget* renderWidget = getRenderWidget( createGraphicsWindow(0,0,100,100), 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, 0.0) );
		camera->setViewport( new osg::Viewport(0, 0, traits->width, traits->height) );
		camera->setProjectionMatrixAsPerspective(50.0f, static_cast<double>(traits->width)/static_cast<double>(traits->height), 10.0f, 1000.0f);
		this->setSceneData(scene);
		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()
{
	initVars();
	osg::Group *root = new osg::Group;

	osg::Light *light = new osg::Light;
	light->setAmbient(osg::Vec4(amb2[0], amb2[1],amb2[2], amb2[3]));
	light->setLightNum(0);
	light->setPosition(osg::Vec4(posl[0],posl[1],posl[2],posl[3]) );
	osg::LightSource *lightSource = new osg::LightSource;
	lightSource->setLight(light);
	root->addChild(lightSource);
	

	osg::MatrixTransform *rotMT = new osg::MatrixTransform;
	rotMT->addUpdateCallback(new osg::AnimationPathCallback(osg::Vec3(), osg::Y_AXIS, 0.5));
	rotMT->addChild(createWalls());
	rotMT->addChild(createFloor());

	osg::MatrixTransform *cylinderRotMT1 = new osg::MatrixTransform;
	osg::MatrixTransform *cylinderTransMT1 = new osg::MatrixTransform;
	cylinderRotMT1->setMatrix(osg::Matrix::rotate(osg::PI_2, osg::X_AXIS));
	cylinderTransMT1->setMatrix(osg::Matrix::translate(0, 0, -500));
	cylinderTransMT1->addChild(createCylinder());
	cylinderRotMT1->addChild(cylinderTransMT1);
	
	osg::MatrixTransform *cylinderTransMT2 = new osg::MatrixTransform;
	cylinderTransMT2->setMatrix(osg::Matrix::translate(200,-300,-500));
	cylinderTransMT2->addChild(createCylinder());

	osg::MatrixTransform *cylinderTransMT31 = new osg::MatrixTransform;
	osg::MatrixTransform *cylinderRotMT3 = new osg::MatrixTransform;
	osg::MatrixTransform *cylinderTransMT32 = new osg::MatrixTransform;
	cylinderTransMT31->setMatrix(osg::Matrix::translate(-200, 0, 0));
	cylinderRotMT3->setMatrix(osg::Matrix::rotate(osg::DegreesToRadians(135.0), osg::X_AXIS));
	cylinderTransMT32->setMatrix(osg::Matrix::translate(0, 0, -500));
	cylinderTransMT32->addChild(createCylinder2());
	cylinderTransMT31->addChild(cylinderRotMT3);
	cylinderRotMT3->addChild(cylinderTransMT32);

	rotMT->addChild(cylinderRotMT1);
	rotMT->addChild(cylinderTransMT2);
	rotMT->addChild(cylinderTransMT31);


	for (int i = 0; i < NrOfBalls; ++i)
	{
		osg::MatrixTransform *mt = new osg::MatrixTransform;
		mt->addUpdateCallback(new PostionUpdateCallback(i));
		mt->addChild(createBalls(i));
		rotMT->addChild(mt);
	}

	//
	
	for (int i = 0; i < 20; ++i)
	{
		osg::Switch *switchNode = new osg::Switch;
		g_SwitchNode = switchNode;
		switchNode->addUpdateCallback(new CollisionSwitchUpdateCallback(i));
		osg::MatrixTransform *collisionScale = new osg::MatrixTransform;
		collisionScale->addUpdateCallback(new CollisionScaleUpdateCallback(i));
		osg::MatrixTransform *collisionMT = new osg::MatrixTransform;
		collisionMT->addUpdateCallback(new CollisionTransUpdateCallback(i));
		osg::Node *collisionNode = createExplorsionNode(i);
		collisionScale->addChild(collisionMT);
		collisionMT->addChild(collisionNode);
		switchNode->addChild(collisionScale);
		rotMT->addChild(switchNode);
	}
	
	root->addChild(rotMT);

	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
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenSceneGraph-3.6.5-VC2019-64-Release.7z
08-11
6. **使用OpenSceneGraph**：开发人员可以使用OpenSceneGraph来创建3D交互界面，加载3D模型，实现复杂的光照效果，进行纹理映射，实现视口管理，以及利用动画和物理模拟。它还支持多种数据格式导入，如OBJ、COLLADA...
OpenSceneGraph编译、安装、开发环境
国产CAx(CAD/CAE/CAM)软件研发
12-24 6866
详细描述WIndows 10下使用Visual Studio 2019编译OpenSceneGraph 3.6.5的操作流程
OpenSceneGraph几何基础教程【OSG】
新缸中之脑
01-08 3017
默认情况下，OSG 使用顶点数组法和显示列表法来渲染几何体。但是，渲染策略可能会发生变化，具体取决于几何数据的呈现方式。在本文中，我们将了解在 OSG 中处理几何体的基本技术。OpenSceneGraph 后端的 OpenGL 使用几何图元（例如点、线、三角形和多边形面）来构建三维世界中的所有对象。这些图元由它们的顶点指定，包括顶点坐标、法线分量、颜色数据和纹理坐标。此数据存储在特殊数组中。例如，可以通过为描述它们的对象指定顶点索引列表来形成图元。这种方法称为顶点数组法；
OpenSceneGraph（简称osg）
源代码视界的专栏
08-25 454
除了这些基本功能，osg还采用了场景图（Scene Graph）的数据结构，这使得3D模型、纹理、光照等元素能够以一种层次化的方式组织和管理，从而方便进行3D场景的渲染和管理。OpenSceneGraph（简称osg）是一个具有强大功能的3D图形应用程序开发库，它不仅提供了跨平台的C++类库和工具，还支持多种操作系统和图形硬件，如Windows、Linux、Mac OS X等操作系统以及OpenGL、Direct3D等图形硬件。
Windows10编译安装OpenSceneGraph(OSG)教程
sinat_29890433的博客
07-12 1761
Windows10编译安装OpenSceneGraph(OSG)教程 保存记录一下
OpenSceneGraph-OpenSceneGraph-3.6.5.zip
01-09
OpenSceneGraph（简称osg）是一个开源的3D图形库，专为实时三维图形应用程序设计，如游戏、虚拟现实系统和科学可视化应用。OpenSceneGraph 3.6.5是该库的一个稳定版本，提供了丰富的功能和优化，确保了在各种项目中...
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.4.0网盘地址.rar
09-08
OpenSceneGraph是一个强大的开源图形库，专为实时3D应用程序设计，如模拟、游戏和科学可视化。这个"OpenSceneGraph-3.4.0.zip"压缩包包含了OpenSceneGraph的3.4.0版本源码，是开发人员进行图形渲染和场景管理的重要...
OSG编程指南＜一＞：OpenSceneGraph 概述
欧特GO
11-15 501
OSG编程指南：OpenSceneGraph 概述及功能介绍
OpenSceneGraph 教程
热门推荐
doing5552的专栏
09-01 1万+
  Open Scene Graph教程1——使用Open Scene Graph几何原文出处：http://www.nps.navy.mil/cs/sullivan/osgtutorials/osgGeometry.htm摘要     本节涵盖了生成基本几何形状的一些方法。生成几何物体的方法有这么几种：在最底层对OpenGL基本几何进行松散的包装，中级是使用Open Sc
OpenSceneGraph图形状态管理内幕
新缸中之脑
01-19 2111
如前所述，你可能不会在普通的 OSG 代码中使用 State 对象，但是如果使用自定义的 drawImplementation() 方法编写自己的 Drawable 类，就会用到State。有关使用 State 的示例，请查看 Open Scene Graph 类的源代码，如 osgText::Text，它在其绘制方法中进行了许多 OpenGL 调用。除了管理 StateSet 对象中保存的图形状态外，State 还控制较低级别的 OpenGL 状态，例如顶点属性数组的使用。
osg自学笔记1——《OpenSceneGraph 快速入门指导》
jean7155的专栏
03-11 3815
这里写自定义目录标题《OpenSceneGraph Quick Start Guide》学习笔记1、 1.3 运行 osgviewer2、1.5 场景图形初步3、 1.6 OpenSceneGraph 概览4、2.1 内存管理5、2.2 叶节点（Geode）和几何信息1、osg::Vec2，osg::Vec2Array，osg::Vec3Array2、Drawables 类 《OpenSceneGraph Quick Start Guide》学习笔记 《OpenSceneGraph Quick Start
OpenSceneGraph介绍
LuckyHanMo的博客
05-08 1269
osg：OpenSceneGraph
OpenSceneGraph源码分析：osg模块
国产CAx(CAD/CAE/CAM)软件研发
02-11 1853
济南友泉软件有限公司 osg库是OpenSceneGraph最为重要的一个模块，也是OS从第一个版本到当前版本一直都存在的库。osg库提供了场景节点管理、图形绘制、渲染状态管理等功能。 一、内存管理 OSG通过引用计数提供了一种自动管理内存的机制。在OSG中，引用计数机制由osg::ref_ptr和 osg::Referenced实现。 所有的OSG的节点和场景图形数据（状态信息 顶点数组 法线 纹理坐标）都派生于osg::Referenced类进行内存引用计数。 二、场景管理 OS..
osg::BlendFunc
boqing的专栏
09-12 4099
osg::BlendFunc介绍      混合是什么呢？混合就是把两种颜色混在一起。具体一点，就是把某一像素位置原来的颜色和将要画上去的颜色，通过某种方式混在一起，从而实现特殊的效果。      假设我们需要绘制这样一个场景：透过红色的玻璃去看绿色的物体，那么可以先绘制绿色的物体，再绘制红色玻璃。在绘制红色玻璃的时候，利用“混合”功能，把将要绘制上去的红色和原来的绿色进行混合，于是得到一种新
OpenSceneGraph：学习笔记
学习脚印
05-02 5565
Geometry类型：纹理坐标的设置：设置该几何体的顶点（按顺序）所对应纹理图片上的哪一处位置（二维XY坐标均默认为0.0~1.0） texture-&gt;setImage(image); //设置纹理图片 //纹理环绕：当纹理坐标超出默认范围（0.0~1.0）时，该怎么输出(还有CLAMP_TO_EDGE，CLAMP_TO_BORDER) texture-...
OpenSceneGraph开发预备知识
最新发布
qq_56109699的博客
01-19 808
本文介绍了：OpenSceneGraph开发的预备知识，向量，四元数，矩阵，数组，智能指针，包围体，OSG内存管理机制的基本概念和运用。
openscenegraph-openscenegraph-3.6.4编译运行
08-11
编译运行 OpenSceneGraph-OpenSceneGraph-3.6.4 需要按照以下步骤进行操作： 1. 首先，确保你的计算机上已经安装了 CMake，C++ 编译器和 OpenGL 兼容的图形驱动程序。这些是编译和运行 OpenSceneGraph 所必需的工具...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值