SharpGL学习笔记(十三) 光源例子：环绕二次曲面球体的光源

这是根据徐明亮《OpenGL游戏编程》书上光灯一节的一个例子改编的．

从这个例子可以学习到二次曲面的参数设置，程序中提供了两个画球的函数，一个是用三角形画出来的，一个是二次曲面构成的．

你会发现，跟三角形版本不同，二次曲面要做一些设定，否则画出来的球体无法接受光照．

先上代码：

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Windows.Forms;
 using SharpGL;

 namespace light2
 {
     /// <summary>
     /// 原创文章,出自"博客园, 猪悟能'S博客" : http://www.cnblogs.com/hackpig/
     /// </summary>
     public partial class SharpGLForm : Form
     {
         private float rotation = 0.0f;
         float m_bReadX, m_bReadY;
         float m_bGreenX, m_bGreenY;
         float m_bBlueX, m_bBlueY;

         //3个光源位置
         float[] lightPosR = new float[] { 0f, 0f, 2f, 1f };
         float[] lightPosG = new float[] { 0f, 0f, 2f, 1f };
         float[] lightPosB = new float[] { 0f, 0f, 2f, 1f };

         //3个光源漫射光
         float[] diffLightR = { 1f, 0f, 0f, 1f };
         float[] diffLightG = { 0f, 1f, 0f, 1f };
         float[] diffLightB = { 0f, 0f, 1f, 1f };

         //定义3个光源我镜面光
         float[] specLightR = { 1f, 0f, 0f, 1f };
         float[] specLightG = { 0f, 1f, 0f, 1f };
         float[] specLightB = { 0f, 0f, 1f, 1f };

         //默认的光源, 灰色光源，用于默认照明
         float[] defDiffLight = new float[] { 0.8f, 0.8f, 0.8f, 1f };
         float[] defSpecLight = new float[] { 1f, 1f, 1f, 1f };
         float[] defLightPos = new float[] { 0f, 0f, 10f, 1f };

         public SharpGLForm()
         {
             InitializeComponent();
         }

         private void openGLControl_OpenGLDraw(object sender, PaintEventArgs e)
         {
             OpenGL gl = openGLControl.OpenGL;
             gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
             gl.LoadIdentity();
             gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);

             draw(gl);
             rotation += 3.0f;

             update(gl);
         }

         void update(OpenGL gl)
         {
             gl.Enable(OpenGL.GL_LIGHT1);
             m_bReadX += ;
             m_bReadY += ;
             gl.Enable(OpenGL.GL_LIGHT2);
             m_bGreenX += ;
             m_bGreenY += ;
             gl.Enable(OpenGL.GL_LIGHT3);
             m_bBlueX += ;
             m_bBlueY += ;
         }

         void draw(OpenGL gl)
         {
             gl.PushMatrix();
             //旋转红光
             gl.Rotate(m_bReadX, 1f, 0f, 0f);
             gl.Rotate(m_bReadY, 0f, 1f, 0f);
             //设置红光的位置
             gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_POSITION, lightPosR);
             //绘制光球
             gl.Translate(lightPosR[], lightPosR[], lightPosR[]);
             gl.Color(1f, 0f, 0f);
             gl.PushAttrib(OpenGL.GL_LIGHTING_BIT);
             gl.Disable(OpenGL.GL_LIGHTING);
             drawSphere(gl,lightPosR[], lightPosR[], lightPosR[],0.2f,,,false);
             gl.Enable(OpenGL.GL_LIGHTING);
             gl.PopAttrib();
             gl.PopMatrix();

             gl.PushMatrix();
             //旋转绿光
             gl.Rotate(m_bGreenX, 1f, 0f, 0f);
             gl.Rotate(m_bGreenY, 0f, 1f, 0f);
             //设置绿光的位置
             gl.Light(OpenGL.GL_LIGHT2, OpenGL.GL_POSITION, lightPosG);
             //绘制光球
             gl.Translate(lightPosG[], lightPosG[], lightPosG[]);
             gl.Color(0f, 1f, 0f);
             gl.PushAttrib(OpenGL.GL_LIGHTING_BIT);
             gl.Disable(OpenGL.GL_LIGHTING);
             drawSphere(gl, lightPosG[], lightPosG[], lightPosG[], 0.2f, ,  ,false);
             gl.Enable(OpenGL.GL_LIGHTING);
             gl.PopAttrib();
             gl.PopMatrix();

             gl.PushMatrix();
             //旋转蓝光
             gl.Rotate(m_bBlueX, 1f, 0f, 0f);
             gl.Rotate(m_bBlueY, 0f, 1f, 0f);
             //设置蓝光的位置
             gl.Light(OpenGL.GL_LIGHT3, OpenGL.GL_POSITION, lightPosB);
             //绘制光球
             gl.Translate(lightPosB[], lightPosB[], lightPosB[]);
             gl.Color(0f, 0f, 1f);
             gl.PushAttrib(OpenGL.GL_LIGHTING_BIT);
             gl.Disable(OpenGL.GL_LIGHTING);
             drawSphere(gl, lightPosB[], lightPosB[], lightPosB[], 0.2f, , ,false);
             gl.Enable(OpenGL.GL_LIGHTING);
             gl.PopAttrib();
             gl.PopMatrix();

             //绘制球体
             gl.PushMatrix();
             gl.Rotate(rotation, 1f, 0f, 0f);
             gl.Rotate(rotation, 0f, 1f, 0f);
             gl.Rotate(rotation, 0f, 0f, 1f);
             drawSphere(gl, , , , , , ,false);

             gl.PopMatrix();

             gl.Flush();

         }

         //二次曲面球体
         void drawSphere(OpenGL gl,float x,float y,float z, double radius, int segx, int segy, bool isLines)
         {
             gl.PushMatrix();
             gl.Translate(x, y, z);
             var sphere = gl.NewQuadric();
             if (isLines)
                 gl.QuadricDrawStyle(sphere, OpenGL.GL_LINES);
             else
                 gl.QuadricDrawStyle(sphere, OpenGL.GL_QUADS);
             gl.QuadricNormals(sphere, OpenGL.GLU_NONE);   //GLU_NONE,GLU_FLAT,GLU_SMOOTH
             gl.QuadricOrientation(sphere, (int)OpenGL.GLU_OUTSIDE);  //GLU_OUTSIDE,GLU_INSIDE
             gl.QuadricTexture(sphere, (int)OpenGL.GLU_FALSE);  //GL_TRUE,GLU_FALSE
             gl.Sphere(sphere, radius, segx, segy);
             gl.DeleteQuadric(sphere);
             gl.PopMatrix();
         }

         //球心坐标为（x，y，z），球的半径为radius，M，N分别表示球体的横纵向被分成多少份
         void drawSphere1(OpenGL gl, float xx, float yy, float zz, float radius, float M, float N,bool isLines)
         {
             const float PI = 3.1415926f;
             float step_z = (float)Math.PI / M;
             float step_xy =  * PI / N;
             float[] x = new float[] { , , ,  };
             float[] y = new float[] { , , ,  };
             float[] z = new float[] { , , ,  };

             float angle_z = 0.0f;
             float angle_xy = 0.0f;
             int i = , j = ;
             gl.Begin(OpenGL.GL_QUADS);
             for (i = ; i < M; i++)
             {
                 angle_z = i * step_z;
                 for (j = ; j < N; j++)
                 {
                     angle_xy = j * step_xy;

                     x[] = (float)(radius * Math.Sin(angle_z) * Math.Cos(angle_xy));
                     y[] = (float)(radius * Math.Sin(angle_z) * Math.Sin(angle_xy));
                     z[] = (float)(radius * Math.Cos(angle_z));

                     x[] = (float)(radius * Math.Sin(angle_z + step_z) * Math.Cos(angle_xy));
                     y[] = (float)(radius * Math.Sin(angle_z + step_z) * Math.Sin(angle_xy));
                     z[] = (float)(radius * Math.Cos(angle_z + step_z));

                     x[] = (float)(radius * Math.Sin(angle_z + step_z) * Math.Cos(angle_xy + step_xy));
                     y[] = (float)(radius * Math.Sin(angle_z + step_z) * Math.Sin(angle_xy + step_xy));
                     z[] = (float)(radius * Math.Cos(angle_z + step_z));

                     x[] = (float)(radius * Math.Sin(angle_z) * Math.Cos(angle_xy + step_xy));
                     y[] = (float)(radius * Math.Sin(angle_z) * Math.Sin(angle_xy + step_xy));
                     z[] = (float)(radius * Math.Cos(angle_z));

                     for (int k = ; k < ; k++)
                     {
                         gl.Vertex(xx + x[k], yy + y[k], zz + z[k]);
                     }
                 }
             }
             gl.End();
         }

         private void openGLControl_OpenGLInitialized(object sender, EventArgs e)
         {
             OpenGL gl = openGLControl.OpenGL;
             setLight(gl);
             //gl.Enable(OpenGL.GL_NORMALIZE);
             gl.ClearColor(, , , );
         }

         private void setLight(OpenGL gl)
         {
             //0号灯光，默认灯光
             gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, defDiffLight);
             gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPECULAR, defSpecLight);
             gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_POSITION, defLightPos);

             //1号灯光
             gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_DIFFUSE, diffLightR);
             gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_SPECULAR, specLightR);
             gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_POSITION, lightPosR);

             //2号灯光
             gl.Light(OpenGL.GL_LIGHT2, OpenGL.GL_DIFFUSE, diffLightG);
             gl.Light(OpenGL.GL_LIGHT2, OpenGL.GL_SPECULAR, specLightG);
             gl.Light(OpenGL.GL_LIGHT2, OpenGL.GL_POSITION, lightPosG);

             //3号灯光
             gl.Light(OpenGL.GL_LIGHT3, OpenGL.GL_DIFFUSE, diffLightB);
             gl.Light(OpenGL.GL_LIGHT3, OpenGL.GL_SPECULAR, specLightB);
             gl.Light(OpenGL.GL_LIGHT3, OpenGL.GL_POSITION, lightPosB);

             gl.Enable(OpenGL.GL_LIGHTING);
             gl.Enable(OpenGL.GL_LIGHT0);  //启用默认光源

         }

         private void openGLControl_Resized(object sender, EventArgs e)
         {
             OpenGL gl = openGLControl.OpenGL;
             gl.MatrixMode(OpenGL.GL_PROJECTION);
             gl.LoadIdentity();
             gl.Perspective(70.0f, (double)Width / (double)Height, 0.01, 100.0);
             gl.LookAt(-, , -, , , , , , );
             gl.MatrixMode(OpenGL.GL_MODELVIEW);
         }

     }
 }

截取了一帧的效果如下图：

有三个光球围绕球体旋转，三组光分别为红，绿，蓝，因此它们的组合可以在球面上生成所有可能的颜色效果．

函数drawSphere是二次曲面球体，函数drawSphere１是三角形构成的球体．

下面我们研究一下二次曲面的几个关键的需要注意的设置函数：

(１)　QuadricDrawStyle(IntPtr quadObject, uint drawStyle);

第一个参数是二次方程对象状态的指针，第二个参数的枚举值如下表：

常量	描述
GLU_FILL	二次方程对象画成实体
GLU_LINE	二次方程对象画成线框
GLU_POINT	二次方程对象画成一组顶点的集合
GLU_SILHOUETTE	类似于线框，但相邻的多边形的边不被绘制。

(２)　QuadricNormals(IntPtr quadricObject, uint normals);

这个函数指定二次方程对象如何生成法线。第二个参数可以是：GLU_NONE不生成法线，GLU_FLAT扁平法线，GLU_SMOOTH平滑法线。

(３)　QuadricOrientation(IntPtr quadricObject, int orientation);

这个函数可以指定法线的朝向，指向外面还是只想里面。orientation可以是GLU_OUTSIDE或者是GLU_INSIDE这两个值。OpenGL默认是以GL_CCW逆时针为正方向的

(４)　QuadricTexture(IntPtr quadricObject, int textureCoords);

这个函数可以指定二次方程表面的纹理坐标，textureCoords这个参数可以是GL_TRUE或者GL_FALSE.当为球体和圆柱体生成纹理坐标时，纹理是对称地环绕在球体和圆柱体的表面的。如果应用到圆盘上，那么纹理的中心就是圆盘的中心，然后以线性插值的方式扩展到圆盘的边界。

读者可以尝试改变这些函数的参数，会发现受光效果是不同的．

也可以尝试用drawSphere1()函数替换掉drawSphere()函数，它是不需要做任何设定，就有很好的效果．

本节源代码下载

原创文章,出自"博客园, 猪悟能'S博客" : http://www.cnblogs.com/hackpig/