opengl学习

#include"stdafx.h"

#define GLUT_DISABLE_ATEXIT_HACK  

#include <GL/glut.h>

//glut自动将gl.h和glu.h包含了

#include"math.h"

#include <time.h>



const int n = 20; 

const GLfloat R = 20.0f; 

const GLfloat Pi = 3.1415926536f;

// 太阳、地球和月亮 

// 假设每个月都是30天 

// 一年12个月，共是360天 

static int day = 200; // day的变化：从0到359



#define WIDTH 400 

#define HEIGHT 400 

static GLfloat angle = 0.0f;



#define ColoredVertex(c, v) do{ glColor3fv(c); glVertex3fv(v); }while(0)



void myDisplay5(void) 

{ 

    static int list = 0; 

    if( list == 0 ) 

    {

        // 如果显示列表不存在，则创建 

        /* GLfloat PointA[] = {-0.5, -5*sqrt(5)/48, sqrt(3)/6}, 

                   PointB[] = { 0.5, -5*sqrt(5)/48, sqrt(3)/6}, 

                   PointC[] = { 0, -5*sqrt(5)/48, -sqrt(3)/3}, 

                   PointD[] = { 0, 11*sqrt(6)/48, 0}; 

                   */ 

        // 2007年4月27日修改 

        GLfloat PointA[] = { 0.5f, -sqrt(6.0f)/12, -sqrt(3.0f)/6}, 

                PointB[] = {-0.5f, -sqrt(6.0f)/12, -sqrt(3.0f)/6},

                PointC[] = { 0.0f, -sqrt(6.0f)/12, sqrt(3.0f)/3},

                PointD[] = { 0.0f, sqrt(6.0f)/4, 0}; 

        

        GLfloat ColorR[] = {1, 0, 0}, 

                ColorG[] = {0, 1, 0}, 

                ColorB[] = {0, 0, 1}, 

                ColorY[] = {1, 1, 0};

        //一、分配显示列表编号

        //要分配i个连续的未使用的显示列表编号,返回的是分配的若干连续编号中最小的一个。

        //。如果函数返回零，表示分配失败。

        list = glGenLists(1); 

        

        //二、创建显示列表

        //glNewList有两个参数，

        //第一个参数是一个正整数表示装入到哪个显示列表。

        //第二个参数有两种取值，如果为GL_COMPILE，则表示以下的内容只是装入到显示列表，但现在不执行它们；

        //如果为GL_COMPILE_AND_EXECUTE，表示在装入的同时，把装入的内容执行一遍。

        glNewList(list, GL_COMPILE); 

        //显示列表只能装入OpenGL函数，而不能装入其它内容

        glBegin(GL_TRIANGLES); 

        // 平面ABC 

        ColoredVertex(ColorR, PointA); 

        ColoredVertex(ColorG, PointB); 

        ColoredVertex(ColorB, PointC);

        // 平面ACD 

        ColoredVertex(ColorR, PointA); 

        ColoredVertex(ColorB, PointC);

        ColoredVertex(ColorY, PointD); 

        // 平面CBD 

        ColoredVertex(ColorB, PointC); 

        ColoredVertex(ColorG, PointB);

        ColoredVertex(ColorY, PointD); 

        // 平面BAD 

        ColoredVertex(ColorG, PointB);

        ColoredVertex(ColorR, PointA);

        ColoredVertex(ColorY, PointD); 

        glEnd(); 

        glEndList(); 

        glEnable(GL_DEPTH_TEST);

        } 

        // 已经创建了显示列表，在每次绘制正四面体时将调用它 

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glPushMatrix(); 

        glRotatef(angle, 1, 0.5, 0); 

        

        //三、调用显示列表

        //使用glCallList函数可以调用一个显示列表。该函数有一个参数，表示要调用的显示列表的编号。

        glCallList(list); 

        glPopMatrix(); 

        

        //

        //使用glDeleteLists来销毁一串编号连续的显示列表。

        glutSwapBuffers();

}

void myIdle2(void) 

{ 

    ++angle; 

    if( angle >= 360.0f ) 

        angle = 0.0f; 

    myDisplay5(); 

}



void myDisplay4(void)

{

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    // 创建透视效果视图 

    glMatrixMode(GL_PROJECTION); 

    glLoadIdentity(); 

    //透视投影

    gluPerspective(90.0f, 1.0f, 1.0f, 20.0f); 

    glMatrixMode(GL_MODELVIEW); 

    glLoadIdentity(); 

    gluLookAt(0.0, 5.0, -10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); 

    // 定义太阳光源，它是一种白色的光源 

    { 

        GLfloat sun_light_position[] = {0.0f, 0.0f, 0.0f, 1.0f};

        GLfloat sun_light_ambient[] = {0.0f, 0.0f, 0.0f, 1.0f};

        GLfloat sun_light_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f}; 

        GLfloat sun_light_specular[] = {1.0f, 1.0f, 1.0f, 1.0f};

        glLightfv(GL_LIGHT0, GL_POSITION, sun_light_position); 

        glLightfv(GL_LIGHT0, GL_AMBIENT, sun_light_ambient); 

        glLightfv(GL_LIGHT0, GL_DIFFUSE, sun_light_diffuse); 

        glLightfv(GL_LIGHT0, GL_SPECULAR, sun_light_specular); 

        glEnable(GL_LIGHT0); 

        glEnable(GL_LIGHTING); 

        glEnable(GL_DEPTH_TEST);

    }

    // 定义太阳的材质并绘制太阳 

    { 

        GLfloat sun_mat_ambient[] = {0.0f, 0.0f, 0.0f, 1.0f}; 

        GLfloat sun_mat_diffuse[] = {0.0f, 0.0f, 0.0f, 1.0f}; 

        GLfloat sun_mat_specular[] = {0.0f, 0.0f, 0.0f, 1.0f}; 

        GLfloat sun_mat_emission[] = {0.5f, 0.0f, 0.0f, 1.0f}; 

        GLfloat sun_mat_shininess = 0.0f; 

        glMaterialfv(GL_FRONT, GL_AMBIENT, sun_mat_ambient); 

        glMaterialfv(GL_FRONT, GL_DIFFUSE, sun_mat_diffuse); 

        glMaterialfv(GL_FRONT, GL_SPECULAR, sun_mat_specular); 

        glMaterialfv(GL_FRONT, GL_EMISSION, sun_mat_emission); 

        glMaterialf (GL_FRONT, GL_SHININESS, sun_mat_shininess); 

        glutSolidSphere(2.0, 40, 32); 

    } 

    // 定义地球的材质并绘制地球 

    { 

        GLfloat earth_mat_ambient[] = {0.0f, 0.0f, 0.5f, 1.0f}; 

        GLfloat earth_mat_diffuse[] = {0.0f, 0.0f, 0.5f, 1.0f}; 

        GLfloat earth_mat_specular[] = {0.0f, 0.0f, 1.0f, 1.0f};

        GLfloat earth_mat_emission[] = {0.0f, 0.0f, 0.0f, 1.0f}; 

        GLfloat earth_mat_shininess = 30.0f; 

        glMaterialfv(GL_FRONT, GL_AMBIENT, earth_mat_ambient); 

        glMaterialfv(GL_FRONT, GL_DIFFUSE, earth_mat_diffuse);

        glMaterialfv(GL_FRONT, GL_SPECULAR, earth_mat_specular); 

        glMaterialfv(GL_FRONT, GL_EMISSION, earth_mat_emission);

        glMaterialf (GL_FRONT, GL_SHININESS, earth_mat_shininess); 

        glRotatef(angle, 0.0f, -1.0f, 0.0f); 

        glTranslatef(5.0f, 0.0f, 0.0f); 

        glutSolidSphere(2.0, 40, 32); 

    } 

        glutSwapBuffers();



        //使用glLight*函数可设置光源的属性，使用glMaterial*函数可设置材质的属性，使用glLightModel*函数可设置光照模式。

}

double CalFrequency() 

{ 

    static int count; 

    static double save;

    static clock_t last, current; 

    double timegap; 

    ++count; 

    if( count <= 50 ) 

        return save; 

    count = 0; 

    last = current; 

    current = clock();

    timegap = (current-last)/(double)CLK_TCK; 

    save = 50.0/timegap; 

    return save;

}

void myDisplay2(void) 

{ 

    glEnable(GL_DEPTH_TEST); 

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glMatrixMode(GL_PROJECTION); 

    glLoadIdentity(); 

    gluPerspective(75, 1, 1, 400000000);

    glMatrixMode(GL_MODELVIEW); 

    glLoadIdentity(); 

    gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);

    // 绘制红色的“太阳” 

    glColor3f(1.0f, 0.0f, 0.0f); 

    glutSolidSphere(69600000, 20, 20); 

    // 绘制蓝色的“地球” 

    glColor3f(0.0f, 0.0f, 1.0f); 

    glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f); 

    glTranslatef(150000000, 0.0f, 0.0f); 

    glutSolidSphere(15945000, 20, 20); 

    // 绘制黄色的“月亮” 

    glColor3f(1.0f, 1.0f, 0.0f); 

    glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0f, 0.0f, -1.0f); 

    glTranslatef(38000000, 0.0f, 0.0f); 

    glutSolidSphere(4345000, 20, 20); 

    

    glFlush();



    //小结：本课开始，我们正式进入了三维的OpenGL世界。

    //OpenGL通过矩阵变换来把三维物体转变为二维图象，进而在屏幕上显示出来。

    //为了指定当前操作的是何种矩阵，我们使用了函数glMatrixMode。 

    //我们可以移动、旋转观察点或者移动、旋转物体，使用的函数是glTranslate*和glRotate*。 

    //我们可以缩放物体，使用的函数是glScale*。 

    //我们可以定义可视空间，这个空间可以是“正投影”的（使用glOrtho或gluOrtho2D），

    //也可以是“透视投影”的（使用glFrustum或gluPerspective）。 

    //我们可以定义绘制到窗口的范围，使用的函数是glViewport。 

    //矩阵有自己的“堆栈”，方便进行保存和恢复。

    //这在绘制复杂图形时很有帮助。使用的函数是glPushMatrix和glPopMatrix。

}



void myDisplay3(void) 

{ 

    double FPS = CalFrequency();

    printf("FPS = %f\n", FPS);

    glEnable(GL_DEPTH_TEST); 

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glMatrixMode(GL_PROJECTION); 

    glLoadIdentity(); 

    gluPerspective(75, 1, 1, 400000000);

    glMatrixMode(GL_MODELVIEW); 

    glLoadIdentity(); 

    gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);

    // 绘制红色的“太阳” 

    glColor3f(1.0f, 0.0f, 0.0f); 

    glutSolidSphere(69600000, 20, 20); 

    // 绘制蓝色的“地球” 

    glColor3f(0.0f, 0.0f, 1.0f); 

    glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f); 

    glTranslatef(150000000, 0.0f, 0.0f); 

    glutSolidSphere(15945000, 20, 20); 

    // 绘制黄色的“月亮” 

    glColor3f(1.0f, 1.0f, 0.0f); 

    glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0f, 0.0f, -1.0f); 

    glTranslatef(38000000, 0.0f, 0.0f); 

    glutSolidSphere(4345000, 20, 20); 

    

    glFlush();

    glutSwapBuffers();



    //OpenGL动画和传统意义上的动画相似，都是把画面一幅一幅的呈现在观众面前。

    //一旦画面变换的速度快了，观众就会认为画面是连续的。 

    //双缓冲技术是一种在计算机图形中普遍采用的技术，绝大多数OpenGL实现都支持双缓冲技术。 

    //通常都是利用CPU空闲的时候绘制动画，但也可以有其它的选择。 

    //介绍了垂直同步的相关知识。 

    //介绍了一种简单的计算帧速（FPS）的方法。

}



void myIdle1(void) 

{ 

    /* 新的函数，在空闲时调用，作用是把日期往后移动一天并重新绘制，达到动画效果 */ 

    angle += 0.05f; 

    if( angle >= 360.0f ) 

        angle = 0.0f;

    myDisplay4(); 

}



void myIdle(void) 

{ 

    /* 新的函数，在空闲时调用，作用是把日期往后移动一天并重新绘制，达到动画效果 */ 

    ++day; 

    if( day >= 360 ) 

        day = 0; 

    myDisplay3(); 

}



//gl是基本函数库

//glu是gl的一些方便的和直观的高级应用

//这两个都和OS无关

//glut是和os打交道的库

//lut是一个系统无关的窗口系统，不用它就要用api或MFC画窗口，而glut窗口操作比较简单的，适合初学者或者编小型的程序

void init(void)

{

    glClearColor(1.0,1.0,1.0,0.0);

    //设置当前操作的矩阵

    glMatrixMode(GL_PROJECTION);



    //前把当前矩阵设置为单位矩阵。

    //glLoadIdentity();



    //将当前的可视空间设置为透视投影空间

    //glFrustum();



    //将当前的可视空间设置为正投影空间

    gluOrtho2D(0.0,200.0,0.0,150.0);



    //使用glViewport来定义视口



    //操作矩阵堆栈

    //当我们需要保存时，调用glPushMatrix函数。

    //当需要恢复最近一次的保存时，调用glPopMatrix函数。

}



void myDisplay(void) 

{ 

    double FPS = CalFrequency();

    printf("FPS = %f\n", FPS);

    glClear(GL_COLOR_BUFFER_BIT); 

    glColor3f(1.0,0.0,0.0);



    glPolygonMode(GL_FRONT, GL_FILL); // 设置正面为填充模式 

    glPolygonMode(GL_BACK, GL_LINE); // 设置反面为线形模式 

    glFrontFace(GL_CCW); // 设置逆时针方向为正面 



    glBegin(GL_POLYGON); // 按逆时针绘制一个正方形，在左下方

    glVertex2f(-10.5f, -10.5f); 

    glVertex2f(10.0f, -10.5f); 

    glVertex2f(10.0f, 10.0f); 

    glVertex2f(-10.5f, 10.0f); 

    glEnd(); 



    glBegin(GL_POLYGON); // 按顺时针绘制一个正方形，在右上方 

    glVertex2f(10.0f, 10.0f); 

    glVertex2f(10.0f, 15.0f); 

    glVertex2f(15.0f, 15.0f); 

    glVertex2f(15.0f, 10.0f); 

    glEnd(); 



    glFlush(); 

}



void myDisplay1(void) 

{ 

    static GLubyte Mask[128]; 

    FILE *fp; 

    fp = fopen("11.bmp", "rb"); 

    if( !fp ) 

        exit(0); 

    if( fseek(fp, -(int)sizeof(Mask), SEEK_END) ) 

        exit(0); 

    if( !fread(Mask, sizeof(Mask), 1, fp) ) 

        exit(0); 

    fclose(fp); 



    glClear(GL_COLOR_BUFFER_BIT); 

    glColor3f(1.0,0.0,0.0);



    glEnable(GL_POLYGON_STIPPLE);

    glPolygonStipple(Mask); 

    glRectf(0.0f, 0.0f, 50.0f, 50.0f); 

    // 在左下方绘制一个有镂空效果的正方形 

    glDisable(GL_POLYGON_STIPPLE); 



    //glRectf(50.0f, 50.0f, 100.0f, 100.0f); 

    // 在右上方绘制一个无镂空效果的正方形 

    glFlush(); 

}



void lineSegment(void)

{

    //清除。GL_COLOR_BUFFER_BIT表示清除颜色

    glClear(GL_COLOR_BUFFER_BIT);



    //指定顶点颜色

    glColor3f(1.0,0.0,0.0);

    

    //使用glNormal*函数则可以指定法线向量



    //光源是通过glLight*函数来设置

    //，OpenGL至少会支持8个光源，即GL_LIGHT0到GL_LIGHT7

    //，glEnable(GL_LIGHT0);可以开启第0号光源。使用glDisable函数则可以关闭光源。

    //光源的属性GL_AMBIENT、GL_DIFFUSE、GL_SPECULAR属性。这三个属性表示了光源所发出的光的反射特性（以及颜色）

    //GL_POSITION属性。表示光源所在的位置。

    //）GL_SPOT_DIRECTION、GL_SPOT_EXPONENT、GL_SPOT_CUTOFF属性。表示将光源作为聚光灯使用（这些属性只对位置性光源有效）



    //OpenGL默认是关闭光照处理的。

    //要打开光照处理功能，使用下面的语句： glEnable(GL_LIGHTING); 

    //要关闭光照处理功能，使用glDisable(GL_LIGHTING);即可。



    //材质则是通过glMaterial*函数来设置



    //glBegin支持参数

    //GL_POINTS点、GL_LINES线、

    //GL_LINE_STRIP不闭合多边形、

    //GL_LINE_LOOP闭合多边形、

    //GL_TRIANGLES三角形、

    //GL_TRIANGLE_STRIP、

    //GL_TRIANGLE_FAN

    //GL_POLYGON

    //GL_QUODS

    //GL_QUOD_STRIP

    

    //设置点的大小，单位为像素，默认为1.

    glPointSize(5.0f);

    glBegin(GL_POINTS); 

    glVertex2f(30.0f, 45.0f); 

    glVertex2f(78.0f, 54.0f); 

    glEnd();

    

    //设置线的宽度，与glPointSize用法类似

    glLineWidth(5.0f);

    //启动虚线模式

    glEnable(GL_LINE_STIPPLE);

    glLineStipple(2, 0x0F0F);

    glBegin(GL_LINES);

    glVertex2i(100,0);

    glVertex2i(0,50);

    glEnd();

    //关闭虚线模式

    glDisable(GL_LINE_STIPPLE);



    //可知坐标系原点在窗口的左下角

    int i; 

    int x = 100,y = 50;

    //glClear(GL_COLOR_BUFFER_BIT); 

    glBegin(GL_POLYGON); 

    for(i=0; i<n; ++i) 

        glVertex2f(x + R*cos(2*Pi/n*i),y + R*sin(2*Pi/n*i)); 

    glEnd();



    /*从三维的角度来看，一个多边形具有两个面。

    每一个面都可以设置不同的绘制方式：填充、只绘制边缘轮廓线、只绘制顶点，

    其中“填充”是默认的方式。可以为两个面分别设置不同的方式。*/ 



    //glPolygonMode(GL_FRONT, GL_FILL); 设置正面为填充方式 

    //glPolygonMode(GL_BACK, GL_LINE); 设置反面为边缘绘制方式 

    //glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); // 设置两面均为顶点绘制方式

    

    //一般约定为“顶点以逆时针顺序出现在屏幕上的面”为“正面”，另一个面即成为“反面”。

    //glFrontFace(GL_CCW); // 设置CCW方向为“正面”，CCW即CounterClockWise，逆时针 

    //glFrontFace(GL_CW); // 设置CW方向为“正面”，CW即ClockWise，顺时针



    //使用glEnable(GL_CULL_FACE);来启动剔除功能（使用glDisable(GL_CULL_FACE)可以关闭之）

    //使用glCullFace来进行剔除。参数可以是GL_FRONT，GL_BACK或者GL_FRONT_AND_BACK。



    //直线可以被画成虚线，而多边形则可以进行镂空。 

    //首先，使用glEnable(GL_POLYGON_STIPPLE);来启动镂空模式（使用glDisable(GL_POLYGON_STIPPLE)可以关闭之）。 

    //然后，使用glPolygonStipple来设置镂空的样式。



    //保证前面的OpenGL命令立即执行（而不是让它们在缓冲区中等待）。其作用跟fflush(stdout)类似。

    glFlush();

}



//argc 是指命令行输入参数的个数(以空白符分隔) argv存储了所有的命令行参数 

int main(int argc, char **argv)

{    

    //以glut 开头的函数都是GLUT工具包所提供的函数

    

    //对GLUT进行初始化，这个函数必须在其它的GLUT使用之前调用一次。

    glutInit(&argc,argv);



    //设置显示方式

    //GLUT_RGB表示使用RGB颜色,GLUT_INDEX表示使用索引颜色

    //GLUT_SINGLE表示使用单缓冲,GLUT_DOUBLE使用双缓冲

    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);



    //设置窗口在屏幕中的位置

    glutInitWindowPosition(100,100);



    //设置窗口的大小

    glutInitWindowSize(WIDTH,HEIGHT);



    //根据前面设置的信息创建窗口。参数将被作为窗口的标题。注意：窗口被创建后，并不立即显示到屏幕上。需要调用glutMainLoop才能看到窗口

    glutCreateWindow("测试");



    init();



    //设置一个函数，当需要进行画图时，这个函数就会被调用

    glutDisplayFunc(myDisplay4);



    glutIdleFunc(&myIdle1); // 新加入了这句,空闲时调用,实现动画效果



    glutMainLoop();



    return 0;

}