分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow
也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！
                
//球心坐标为（x，y，z），球的半径为radius，M，N分别表示球体的横纵向被分成多少份void drawSphere(GLfloat xx, GLfloat yy, GLfloat zz, GLfloat radius, GLfloat M, GLfloat N){ float step_z = PI/M; float step_xy = 2*PI/N; float x[4],y[4],z[4]; float angle_z = 0.0; float angle_xy = 0.0; int i=0, j=0; glBegin(GL_QUADS);  for(i=0; i<M; i++)  {   angle_z = i * step_z;      for(j=0; j<N; j++)   {    angle_xy = j * step_xy;    x[0] = radius * sin(angle_z) * cos(angle_xy);    y[0] = radius * sin(angle_z) * sin(angle_xy);    z[0] = radius * cos(angle_z);    x[1] = radius * sin(angle_z + step_z) * cos(angle_xy);    y[1] = radius * sin(angle_z + step_z) * sin(angle_xy);    z[1] = radius * cos(angle_z + step_z);    x[2] = radius*sin(angle_z + step_z)*cos(angle_xy + step_xy);    y[2] = radius*sin(angle_z + step_z)*sin(angle_xy + step_xy);    z[2] = radius*cos(angle_z + step_z);    x[3] = radius * sin(angle_z) * cos(angle_xy + step_xy);    y[3] = radius * sin(angle_z) * sin(angle_xy + step_xy);    z[3] = radius * cos(angle_z);    for(int k=0; k<4; k++)    {     glVertex3f(xx+x[k], yy+y[k],zz+z[k]);    }   }  } glEnd();}

 
            
给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow

创建GLSurfaceView，并调用setRenderer(GLSurfaceView.Renderer)方法注册其渲染器.

GLSurfaceView.Renderer 定义了一个统一图形绘制的接口，它定义了如下三个接口函数： 

onSurfaceCreated：在这个方法中主要用来设置一些绘制时不常变化的参数.

onSurfaceChanged：如果设备支持屏幕横向和纵向切换，这个方法将发生在横向<->纵向互换时。此时可以重新设置绘制的纵横比率。

onDrawFrame：定义实际的绘图操作.

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
	// 设置背景色：白色
	gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    // 启动阴影平滑
    gl.glShadeModel(GL10.GL_SMOOTH);
    // 复位深度缓存
    gl.glClearDepthf(1f);
    // 所做深度测试的类型
    gl.glDepthFunc(GL10.GL_LEQUAL);
    // 启动深度测试
    gl.glEnable(GL10.GL_DEPTH_TEST);
    // 对透视进行修正
    gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);

    //计算球面顶点坐标
    makeSphereVertices();
}
				
@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {
    // 设置输出屏幕大小
    gl.glViewport(0, 0, width, height);
    // 设置投影矩阵
    gl.glMatrixMode(GL10.GL_PROJECTION);
    // 重置投影矩阵
    gl.glLoadIdentity();
    // 设置视口大小
    GLU.gluPerspective(gl, 50, (float) width / (float) height, 0.1f, 100.0f);
    // 设置透视图视口大小
    gl.glMatrixMode(GL10.GL_MODELVIEW);
    // 重置投影矩阵
    gl.glLoadIdentity();
}


@Override
public void onDrawFrame(GL10 gl) {
    // 清除屏幕和深度缓存
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
    // 重置当前的模型观察矩阵
    l.glLoadIdentity();
    //设置画笔颜色
    gl.glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
    //设置视图点
    GLU.gluLookAt(gl, 0.0f, 5.0f, 15.0f,
    	 				0.0f, 0.0f, 0.0f, 
    	 				0.0f, 1.0f, 0.0f);
    //画图
    draw(gl);
}


makeSphereVertices()是用来计算球面顶点坐标的方法。
球体的绘制，实际上就是绘制一个多面体，当多面体的边数够多，看起来就像是一个球了。

private void makeSphereVertices() {
    float altitude;//纬度
    float altitudeDelta;//下一层纬度
    float azimuth;//经度
    float ex;//点坐标x
    float ey;//点坐标y
    float ez;//点坐标z
    //将纬度等分成divide份，这样就能计算出每一等份的纬度值
    for(int i = 0; i <= divide; i++) {
    	//获取当前等份的纬度值
        altitude = (float) (Math.PI/2.0 - i * (Math.PI) / divide);
        //获取下一等份的纬度值
        altitudeDelta = (float) (Math.PI/2.0 - (i + 1) * (Math.PI) / divide);

        //当前纬度和下一纬度的点坐标
        float[] vertices = new float[divide*6+6];

        //将经度等分成divide份，这样就能得到当前纬度值和下一纬度值的每一份经度值
        for(int j = 0; j <= divide; j++) {
        	//计算经度值
            azimuth = (float)(j * (Math.PI*2) / divide);

            ex = (float) (Math.cos(altitude) * Math.cos(azimuth));
            ey = (float)  Math.sin(altitude);
            ez = (float) -(Math.cos(altitude) * Math.sin(azimuth));

            //此经度值下的当前纬度的点坐标
            vertices[6*j+0] = radius * ex;
            vertices[6*j+1] = radius * ey;
            vertices[6*j+2] = radius * ez;

            ex = (float) (Math.cos(altitudeDelta) * Math.cos(azimuth));
            ey = (float) Math.sin(altitudeDelta);
            ez = (float) -(Math.cos(altitudeDelta) * Math.sin(azimuth));

            //此经度值下的下一纬度的点坐标
            vertices[6*j+3] = radius * ex;
            vertices[6*j+4] = radius * ey;
            vertices[6*j+5] = radius * ez;

        }
        //将点坐标转换成FloatBuffer类型添加到点坐标集合ArrayList<FloatBuffer>里
        mVertices.add(makeFloatBufferFromArray(vertices));
    }
}


makeFloatBufferFromArray()用来将点坐标数组转换成绘画时声明点坐标的FloatBuffer类型
private FloatBuffer makeFloatBufferFromArray(float[] array) {
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(array.length * Float.SIZE);
    byteBuffer.order(ByteOrder.nativeOrder());
    FloatBuffer floatBuffer = byteBuffer.asFloatBuffer();
    floatBuffer.put(array);
    floatBuffer.position(0);
    return floatBuffer;
}


最后是draw()方法，当点坐标都获取、所有数据都初始化之后，就可以将球画出来啦。
<pre name="code" class="java"> private void draw(GL10 gl) {
        //打开顶点开关
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        //每次声明两条临近的纬度线的点坐标并绘制出来
        for(int i = 0;i <= divide ; i++){
            //将顶点坐标传给 OpenGL 管道
            gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertices.get(i));
            //用画线的方式将点连接并画出来
            gl.glDrawArrays(GL10.GL_LINE_STRIP, 0, divide*2+2);
        }
        //关闭顶点开关
        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    }



最后就长这样啦~~~(✿◡‿◡)



完整代码下载地址：点击打开链接

自由落体的物理公式想必大家都清楚(y=vt+0.5gt^2)。
但是用程序如何模拟这个过程呢？
1、其中比较关键的是设定一个计时器，在一个视觉暂留时间段（dt=0.02s）内根据小球的位置坐标绘制小球。
2、在小球弹到地面的时候会因为碰撞而有能量损耗，其表现形式为速度减小并反向，而速度减小则可以通过改变加速度a的大小来控制（F=ma嘛，不知道这样解释合不合理，迷）
3、终止条件的判断:
    if(ball.vy<1 && ball.y<-2.0){       //中止条件
        ball.vy=0;
        ball.y=-2.0;
        G=0;
}
这里ball.vy为速度大小，ball.y为高度坐标（地面位置为-2.0），条件为什么不是ball.vy<0呢？这是因为速度的减少或增加是以dt为单位的（非连续），不一定能取到0值，如果条件设为0那么小球会一直在一个很小的范围内震动。（不信你可以试试）

下面附上我的程序实现：（因为考试复习原因没有给小球添加纹理，后面有时间了再补上）
widget.h
QTimer *timer;  //定时器
    //GLuint texName; //材质路径
    GLdouble dt;    //间隔时间
    bool direction; //小球运动方向，向下为true
    double G;
    GLuint *tex0;//纹理
    QString bmpfile;
    QPoint m_last;
    double dist,horizontal,vertical;
    typedef struct b //定义储存球体的结构
    {
        GLdouble y;
        GLdouble vy;
    } Ball;
    Ball ball;
public slots:
    void updataScene();
widget.cpp
Widget::Widget(QWidget *parent)
    : QGLWidget(parent)
{
    timer = new QTimer(this);
    connect(timer,SIGNAL(timeout()),this,SLOT(updataScene()));
    timer->start(10);
}
void Widget::initializeGL(){
    dt=0.02;
    ball.y = 10 ; //初始化球体属性
    ball.vy = 0 ;
    direction = true;
    G = 9.8;
    bmpfile = "://floor.jpg";
    tex0 = new GLuint;
    dist = 2.0;
    vertical=45.0;
    horizontal=45.0;
        glClearColor(0.0,0.0,0.0,0.0);
        glEnable(GL_DEPTH_TEST);
        glShadeModel(GL_SMOOTH);
        //glEnable(GL_LIGHTING); //开启光照
        // glEnable(GL_LIGHT0); //开启光源0
         glEnable(GL_AUTO_NORMAL);
         glEnable(GL_NORMALIZE);
         glMaterialf(GL_FRONT,GL_SHININESS,64.0);
         loadTexture(bmpfile,tex0);
}
void Widget::paintGL(){
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    glClearColor(0.6,0.6,0.6,1);
    glLoadIdentity();
    float eyex=dist*cos(vertical/180.0*PI)*sin(horizontal/180.0*PI);
    float eyey=dist*sin(vertical/180.0*PI);
    float eyez=dist*cos(vertical/180.0*PI)*cos(horizontal/180.0*PI);
    gluLookAt(eyex, eyey,eyez, 0.0, 0.0, 0.0, 0, 1, 0);
    //gluLookAt(1,2,1,0,0,0,0,1,0);
    glDisable(GL_TEXTURE_2D);   //画小球时先不使用纹理
    glPushMatrix();
    glTranslated(0,ball.y,0.0);
    glutWireSphere(2,50,50);
    if(ball.vy<1 && ball.y<-2.0){       //中止条件
        ball.vy=0;
        ball.y=-2.0;
        G=0;
    }
    if(direction){  //向下运动
        G=9.8;
        if(ball.y-(ball.vy*dt+0.5*G*dt*dt) <=-2){
            direction = false; //触发转向条件，改变direction的值，使球体运动方向改变
                        G += 6.0;
        }
        ball.y = ball.y-(ball.vy*dt+0.5*G*dt*dt); //根据牛顿运动定律计算出球的位移公式
        ball.vy = ball.vy + G*dt; //根据牛顿运动定律计算出球体的速度
    }
    else{   //向上运动
        if(ball.y >-2 && ball.vy<0){
            direction = true;
        }
        ball.y = ball.y+(ball.vy*dt-0.5*G*dt*dt);
        ball.vy = ball.vy-G*dt;
    }
        glPopMatrix(); //将当前矩阵弹出
        glPushMatrix();
       // glPushAttrib(GL_ALL_ATTRIB_BITS);
        // glColor3f(0.0, 0.0, 1.0);
        glEnable(GL_TEXTURE_2D);
       // loadTexture(bmpfile,tex0);
         glBegin(GL_QUADS);
         glTexCoord2f( 0.0, 0.0 );glVertex3f(10.0,-4.0,0.0);
         glTexCoord2f( 1.0, 0.0 );glVertex3f(0.0,-4.0,-6.0);
         glTexCoord2f( 1.0, 1.0 );glVertex3f(-6.0,-4.0,0.0);
         glTexCoord2f( 0.0, 1.0 );glVertex3f(0.0, -4.0,10.0);
         glEnd();
         //glPopAttrib();
       glPopMatrix();
        glFlush();
}
void Widget::loadTexture(QString filepath, GLuint *texture){    //加载纹理
            QImage tex, buf;
            if(!buf.load(filepath))
            {
                qDebug()<<"Error: failed to load image!";
                exit(1);
            }
            tex = convertToGLFormat(buf);   //转化为rgba类型的数据集
            glGenTextures(1, texture);
            glBindTexture(GL_TEXTURE_2D, *texture);
            gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, tex.width(), tex.height(), GL_RGBA, GL_UNSIGNED_BYTE,tex.bits());
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,3);
}
void Widget::mousePressEvent(QMouseEvent *e)
{
    m_last = e->pos();
}
void Widget::mouseMoveEvent(QMouseEvent *e)
{
    if(e->buttons() & Qt::LeftButton)
    {
        QPoint m_now = e->pos();
        float disx = m_now.x() - m_last.x();//两个鼠标x坐标的差
        float disy = m_now.y() - m_last.y();  //m_last是之前点击事件取得的鼠标位置
        //更改观察方向
        horizontal -= disx/25;
        vertical += disy/25;
        m_last = m_now;
        updateGL();
    }
}
运行结果截图：

此处只截取从一定高度落下并来回弹跳的最终结果。以下为完整工程代码的链接：
https://download.csdn.net/download/did_you/10406118

步骤
1-初始化：
GLFW窗口，GLAD
2-计算球体顶点：
通过数学方法计算球体的每个顶点坐标
3-数据处理：
通过球体顶点坐标构造三角形网络，生成并绑定VAO&VBO&EBO（准备再GPU中进行处理)，设置顶点属性指针（本质上就是告诉OpenGL如何处理数据）
4-着色器：
给出顶点和片段着色器，然后链接为着色器程序，渲染时使用着色器程序
5-渲染：
使用画线模式画圆，开启面剔除，剔除背面，使用线框模式画球,清空缓冲，交换缓冲区检查触发事件
6-结束：
释放资源
结果
填充模式和线框模式效果对比




开启面剔除和线框模式效果对比
只需要展示一个面，否则会有重合，此处剔除背面为例




代码
此处只给出main.cpp,具体工程参考本人的github
main.cpp
/*
步骤：
1-初始化： GLFW窗口，GLAD
2-计算球体顶点：通过数学方法计算球体的每个顶点坐标
3-数据处理： 通过球体顶点坐标构造三角形网络，生成并绑定VAO&VBO&EBO（准备再GPU中进行处理)，设置顶点属性指针（本质上就是告诉OpenGL如何处理数据）
4-着色器：给出顶点和片段着色器，然后链接为着色器程序，渲染时使用着色器程序
5-渲染：使用画线模式画圆，开启面剔除，剔除背面，使用线框模式画球,清空缓冲，交换缓冲区检查触发事件
6-结束：释放资源
*/
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include "Shader.h"
#include <iostream>
#include <math.h>
#include <vector>

const unsigned int screen_width = 780;
const unsigned int screen_height = 780;
const GLfloat PI= 3.14159265358979323846f;
//将球横纵划分成50*50的网格
const int Y_SEGMENTS = 50;
const int X_SEGMENTS = 50;

int main()
{
	/*1-初始化*/
	//初始化GLFW
	glfwInit();//初始化GLFW
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//opengl版本号3.3
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);// 次版本号3
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//使用核心模式(无序向后兼容性)
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);//如果使用的是Mac OS X系统，需加上这行
	glfwWindowHint(GLFW_RESIZABLE, false);//不可改变窗口大小

	//创建窗口（宽、高、窗口名称）
	auto window = glfwCreateWindow(screen_width, screen_height,"Sphere",nullptr,nullptr);
	//检测窗口是否创建成功
	if (window==nullptr)
	{
		std::cout << "Failed to Create OpenGL Context" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);//将窗口的上下文设置为当前进程的主上下文

	//初始化GLAD，加载OpenGL指针地址的函数
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout<<"Failed to initialize GLAD"<<std::endl;
			return -1;
	}
	//指定当前视口尺寸（前两个参数为左下角位置，后两个参数是渲染窗口宽、高）
	glViewport(0, 0, screen_width, screen_height);

	
	std::vector<float> sphereVertices;
	std::vector<int> sphereIndices;

	/*2-计算球体顶点*/
	//生成球的顶点
	for (int y=0;y<=Y_SEGMENTS;y++)
	{
		for (int x=0;x<=X_SEGMENTS;x++)
		{
			float xSegment = (float)x / (float)X_SEGMENTS;
			float ySegment = (float)y / (float)Y_SEGMENTS;
			float xPos = std::cos(xSegment * 2.0f * PI) * std::sin(ySegment * PI);
			float yPos = std::cos(ySegment * PI);
			float zPos = std::sin(xSegment * 2.0f * PI) * std::sin(ySegment * PI);
			sphereVertices.push_back(xPos);
			sphereVertices.push_back(yPos);
			sphereVertices.push_back(zPos);
		}
	}

	//生成球的Indices
	for (int i=0;i<Y_SEGMENTS;i++)
	{
		for (int j=0;j<X_SEGMENTS;j++)
		{
			sphereIndices.push_back(i * (X_SEGMENTS + 1) + j);
			sphereIndices.push_back((i + 1) * (X_SEGMENTS + 1) + j);
			sphereIndices.push_back((i + 1) * (X_SEGMENTS + 1) + j+1);
			sphereIndices.push_back(i* (X_SEGMENTS + 1) + j);
			sphereIndices.push_back((i + 1) * (X_SEGMENTS + 1) + j + 1);
			sphereIndices.push_back(i * (X_SEGMENTS + 1) + j + 1);
		}
	}


	/*3-数据处理*/
	unsigned int VBO, VAO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	//生成并绑定球体的VAO和VBO
	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	//将顶点数据绑定至当前默认的缓冲中
	glBufferData(GL_ARRAY_BUFFER, sphereVertices.size() * sizeof(float), &sphereVertices[0], GL_STATIC_DRAW);

	GLuint element_buffer_object;//EBO
	glGenBuffers(1, &element_buffer_object);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, element_buffer_object);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphereIndices.size() * sizeof(int), &sphereIndices[0], GL_STATIC_DRAW);

	//设置顶点属性指针
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);

	//解绑VAO和VBO
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);
	/*4-着色器*/
	Shader shader("task3.vs", "task3.fs");

	/*5-渲染*/
	//渲染循环
	while (!glfwWindowShouldClose(window))
	{
		//清空颜色缓冲
		glClearColor(0.0f, 0.34f, 0.57f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		shader.Use();
		//绘制球
		//开启面剔除(只需要展示一个面，否则会有重合)
		glEnable(GL_CULL_FACE);
		glCullFace(GL_BACK);
		glBindVertexArray(VAO);
		//使用线框模式绘制
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		glDrawElements(GL_TRIANGLES, X_SEGMENTS * Y_SEGMENTS * 6, GL_UNSIGNED_INT, 0);
		//点阵模式绘制
		//glPointSize(5);
		//glDrawElements(GL_POINTS, X_SEGMENTS * Y_SEGMENTS * 6, GL_UNSIGNED_INT, 0);
		//交换缓冲并且检查是否有触发事件(比如键盘输入、鼠标移动)
		glfwSwapBuffers(window);
		glfwPollEvents();
	}
	
	/*6-结束*/
	//删除VAO和VBO，EBO
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &element_buffer_object);

	//清理所有的资源并正确退出程序
	glfwTerminate();
	return 0;

}