小杂程序（给自己看的）

#include<GL/glut.h>
#include <math.h>
#include "FreeImage.h"
float  angle=0.0;
float  angle1=0.0;
float r=0.0;
float xrot;
float yrot;
float zrot;
int wiggle_count=0;
float hold;
const char BACKWARD_STATE=1;
const char FORWARD_STATE=0;
const char LEFT=0;
const char RIGHT=1;
float points[45][45][3];
char legStates[2];
char armStates[2];
float Armangle[2];
float Legangle[2];
char* bmpfile[1]=//{("Data/Particle.bmp")};  
{  
	"H:\\program\\1\\Data\\2.jpg"  
};  
GLuint texture[1];
GLenum image_format = GL_BGR_EXT;        //format the image is in  
GLint internal_format = GL_RGB;        //format to store the image in  
GLint level = 0;                   //mipmapping level  
GLint border = 0;  
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;  
FIBITMAP *dib(0);  
BYTE* bits(0);  
unsigned char *imageData;  
unsigned int width(0), height(0);  

//加载图片
bool LoadImage(const char *filename)
{
#ifdef FREEIMAGE_LIB  
	FreeImage_Initalise();  
#endif  
	FIBITMAP *dib(0);  

	fif = FreeImage_GetFileType(filename, 0);  
	if(fif == FIF_UNKNOWN)   
		fif = FreeImage_GetFIFFromFilename(filename);  

	if(fif == FIF_UNKNOWN)  
		return false;  


	if(FreeImage_FIFSupportsReading(fif))  
		dib = FreeImage_Load(fif, filename);  

	if(!dib)  
		return false;  
	bool flipResult = FreeImage_FlipVertical(dib);  
	dib = FreeImage_ConvertTo24Bits(dib);  
	imageData = (unsigned char *)FreeImage_GetBits(dib);//获取图像位信息；  
	/*bits = FreeImage_GetBits(dib);*/  

	 width = FreeImage_GetWidth(dib);  
	 height = FreeImage_GetHeight(dib);  
	int p=FreeImage_GetBPP(dib);  

	if((imageData == 0) || (width == 0) || (height == 0))  
		return false;  
}
bool init(void)
{
	
	glClearColor(0.0,0.0,0.0,0.0);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_TEXTURE_2D);
	//Robot的初始化
	Armangle[LEFT] = 0.0;
	Armangle[RIGHT] = 0.0;
	Legangle[LEFT] = 0.0;
	Legangle[RIGHT] = 0.0;

	armStates[LEFT] = FORWARD_STATE;
	armStates[RIGHT] = BACKWARD_STATE;

	legStates[LEFT] = FORWARD_STATE;
	legStates[RIGHT] = BACKWARD_STATE;
	//飘动图片的初始化
	if(!LoadImage(bmpfile[0]))  
	{  
		return false;  
	}  
	glGenTextures(1,&texture[0]);  
	glBindTexture(GL_TEXTURE_2D,texture[0]);  
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);  
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);  
	glTexImage2D(GL_TEXTURE_2D, level, internal_format, width, height,border, image_format, GL_UNSIGNED_BYTE, imageData);  
	glPolygonMode(GL_BACK,GL_FILL);
	glPolygonMode(GL_FRONT,GL_LINEAR);
	for (int x=0;x<45;x++)
		for(int y=0;y<45;y++)
		{
			points[x][y][0]=float ((x/5.0)-4.5);
			points[x][y][1]=float ((y/5.0)-4.5);
			points[x][y][2]=float(sin((((x/5.0f)*40.0f)/360.0f)*3.141592654*2.0f));

		}
	return true;  
}
void DrawGround()
{
	float fExtent=20;
	float fStep=1.0f;
	float z=-0.0f;
	glBegin(GL_LINES);
	glColor3f(1.0,1.0,1.0);
	for(int i=-fExtent;i<=fExtent;i+=fStep)
	{
		glVertex3f(i,fExtent,z);
		glVertex3f(i,-fExtent,z);

		glVertex3f(fExtent,i,z);
		glVertex3f(-fExtent,i,z);

	}
	glEnd();
}
void Float_Flag()
{
	float float_x,float_y,float_xb,float_yb;
	glTranslatef(0.0f,0.0f,0.0f);				// 移入屏幕12个单位

	glRotatef(xrot,1.0f,0.0f,0.0f);				// 绕 X 轴旋转
	glRotatef(yrot,0.0f,1.0f,0.0f);				// 绕 Y 轴旋转
	glRotatef(zrot,0.0f,0.0f,1.0f);				// 绕 Z 轴旋转
	glEnable(GL_TEXTURE_2D);
	//glGenTextures(1,&texture[0]);
	glBindTexture(GL_TEXTURE_2D, texture[0]);		// 选择纹理
	glBegin(GL_QUADS);	
	// 四边形绘制开始
	for(int  x = 0; x < 44; x++ )				// 沿 X 平面 0-44 循环(45点)
	{
		for( int y = 0; y < 44; y++ )			// 沿 Y 平面 0-44 循环(45点)
		{
			float_x = float(x)/44.0f;		// 生成X浮点值
			float_y = float(y)/44.0f;		// 生成Y浮点值
			float_xb = float(x+1)/44.0f;		// X浮点值+0.0227f
			float_yb = float(y+1)/44.0f;		// Y浮点值+0.0227f
			glTexCoord2f( float_x, float_y);	// 第一个纹理坐标 (左下角)
			glVertex3f( points[x][y][0], points[x][y][1], points[x][y][2] );

			glTexCoord2f( float_x, float_yb );	// 第二个纹理坐标 (左上角)
			glVertex3f( points[x][y+1][0], points[x][y+1][1], points[x][y+1][2] );

			glTexCoord2f( float_xb, float_yb );	// 第三个纹理坐标 (右上角)
			glVertex3f( points[x+1][y+1][0], points[x+1][y+1][1], points[x+1][y+1][2] );

			glTexCoord2f( float_xb, float_y );	// 第四个纹理坐标 (右下角)
			glVertex3f( points[x+1][y][0], points[x+1][y][1], points[x+1][y][2] );
		}
	}
	glEnd();						// 四边形绘制结束

    }
void Airplane()
{
	glPushMatrix();
	glTranslatef(-5,0,0);
	glRotatef(-r,0.0,1.0,0.0);
	glColor3f(1.0,0.0,1.0);
	glScalef(0.1,0.3,0.05);
	glutSolidCube(16);
	glTranslatef(0.0,1.0,0.5);
	glutSolidSphere(1,15,15);
	glPopMatrix();
}
void Sun()
{
	float mat_specular[]={1.0,1.0,1.0,1.0};
	float mat_shininess[]={50.0};
	float light_position[]={10.0,10.0,10.0,0.0};
	float white_light[]={10.0,10.0,10.0,1.0};
	float lmodel_ambient[]={0.1,0.1,0.1,1.0};
	glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular);
	glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);
	glLightfv(GL_LIGHT1,GL_POSITION,light_position);
	glLightfv(GL_LIGHT1,GL_DIFFUSE,white_light);
	glLightfv(GL_LIGHT1,GL_SPECULAR,white_light);
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient);

	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glPushMatrix();
	glColor3f(1.0,0.0,1.0);
	glTranslated(0.0,0.0,0.0);
	glutSolidSphere(2,40,32);
	glPopMatrix();

	glPushMatrix();
	glColor3f(1.0,0.0,0.0);
	glRotatef(angle,0.0,1.0,0.0);
	glTranslated(5.0,0.0,0.0);
	glutSolidSphere(0.5,40,32);
	glColor3f(1.0,1.0,0.0);
	glRotatef(angle1,0.0,1.0,0.0);
	glTranslated(1.0,0.0,0.0);
	glutSolidSphere(0.1,40,32);
	glPopMatrix();
}
void DrawHead(float x,float y,float z)
{
	glPushMatrix();	
	glTranslatef(x,y,z);
	glColor3f(0.0,1.0,1.0);
	glScalef(2.0,2.0,1.0);
	glutSolidCube(1.0);
	glPopMatrix();
}
void DrawTorso(float x,float y,float z)
{
	glPushMatrix();	
	glTranslatef(x,y,z);
	glColor3f(0.0,0.8,0.6);
	glScalef(3,4,1.0);
	glutSolidCube(1.0);
	glPopMatrix();
}
void DrawArm(float x,float y,float z)
{
	glPushMatrix();
	glColor3f(1.0,0.0,0.0);
	glTranslatef(x,y,z);
	glScalef(1,2.5,1.0);
	glutSolidCube(1.0);
	glPopMatrix();
}
void DrawLeg(float x,float y,float z)
{
	glPushMatrix();
	glColor3f(1.0,0.0,1.0);
	glTranslatef(x,y,z);
	glScalef(0.5,5,1.0);
	glutSolidCube(1.0);
	glPopMatrix();
}
void Robot(float xPos,float yPos,float zPos)
{
glPushMatrix();
	glTranslatef(xPos,yPos,zPos);

	
	//DrawTorso(1.0,-1,0.0);

	glPushMatrix();	
	 // DrawTorso(1.0,-1,0.0);
	  glTranslatef(0.0,-2.5,0.0);
	  glRotatef(Legangle[LEFT],0.0,1.0,0.0);
	  DrawHead(1.0,5.0,0.0);
	  DrawTorso(1.0,2,0.0);
	  DrawLeg(0.0,-3,0);
	glPopMatrix();

	glPushMatrix();	
	  glTranslatef(0.0,-2.5,0.0);
	glRotatef(Legangle[RIGHT],0.0,1.0,0.0);
	  DrawLeg(2.0,-3,0);
	glPopMatrix();
	
	/*glPushMatrix();	
	glTranslatef(-1.0,2,0.0);
	glRotatef(Armangle[LEFT],1.0,0.0,0.0);
	DrawArm(0.0,-3,0);
	glPopMatrix();
	glPopMatrix();

	glPushMatrix();	
	glTranslatef(3.0,1,0.0);
	glRotatef(Armangle[RIGHT],1.0,0.0,0.0);
	DrawArm(0.0,0.0,0);
	glPopMatrix();*/
glPopMatrix();
}
void display()
{
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	//DrawGround();
	//Airplane();
	//Sun();
	//Robot(0.0,2.0,0.0);
	Float_Flag();
	glutSwapBuffers();
}
void idle()
{
	/*angle+=1;
	if(angle>360)
	{
	angle=0;
	}
	angle1+=2;
	if(angle1>360)
	{
	angle1=0;
	}
	r+=2;
	if(r>360)
	{
	r=0;
	}*/
	float dt=0.1;
	
	for(int side=0;side<2;++side)
	{   //臂摆动
		if(armStates[side]==FORWARD_STATE)
			Armangle[side]+=20*dt;
		else 
			Armangle[side]-=20*dt;

		if(Armangle[side]>=15.0)
			armStates[side]=BACKWARD_STATE;
		else if (armStates[side]<-15.0)
			armStates[side]=FORWARD_STATE;
		//腿摆动
		if(legStates[side]==FORWARD_STATE)
			Legangle[side]+=20*dt;
		else 
			Legangle[side]-=20*dt;

		if(Legangle[side]>=15.0)
			legStates[side]=BACKWARD_STATE;
		else if (legStates[side]<-15.0)
			legStates[side]=FORWARD_STATE;
	}
	//FLAG
	if( wiggle_count == 2 )					// 用来降低波浪速度(每隔2帧一次)
	{
		for( int y = 0; y < 45; y++ )			// 沿Y平面循环
		{
			hold=points[0][y][2];			// 存储当前左侧波浪值
			for( int x = 0; x < 44; x++)		// 沿X平面循环
			{
				// 当前波浪值等于其右侧的波浪值
				points[x][y][2] = points[x+1][y][2];
			}
			points[44][y][2]=hold;			// 刚才的值成为最左侧的波浪值
		}
		wiggle_count = 0;				// 计数器清零
	}
	wiggle_count++;						// 计数器加一
	xrot+=0.3f;						// X 轴旋转
	yrot+=0.2f;						// Y 轴旋转
	zrot+=0.4f;						// Z 轴旋转
	display();
	Sleep(30);
  }
void reshape(int w,int h)
{ 
	glViewport(0,0,(int)w,(int)h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	float ratio=w/h;
	if(w<=h)
		glOrtho(-10,10,-10*(float)h/(float)w,10*(float)h/(float)w,-10.0,10.0);
	else
		glOrtho(-10*(float)w/(float)h,10*(float)w/(float)h,-10,10,-10.0,10.0);
	
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

int main(int argc,char **argv)
{
	glutInit(&argc,argv);
	glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
	glutInitWindowSize(500,500);
	glutInitWindowPosition(100,100);
	glutCreateWindow(argv[0]);
	init();
	glutDisplayFunc(display);
	glutIdleFunc(idle);
	glutReshapeFunc(reshape);
	glutMainLoop();
	return 0;
}