计算机图形学（OpengGl版） 实验（一）

版权声明：将来的你一定会感谢现在努力的你！！！！ https://blog.csdn.net/qq_37383726/article/details/83030613

结果展示：

#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <bits/stdc++.h>
using namespace std;

void myDisplay(void){
    glClearColor(0.0, 0, 0,0);  // 设置背景默认颜色
    glClear(GL_COLOR_BUFFER_BIT); // 清空当前可写的颜色缓冲，并设为默认值（和上一个函数一起起作用）
    // 一个矩形
    glColor3f( 1.0,  1.0, 0.0);
    glRectf  (-0.5, -0.5, 0.5, 0.5);
    // 一个三角形
    glBegin(GL_TRIANGLES);
        glColor3f(1.0, 0.0, 0.0); glVertex2f( 0.0,  1.0);
        glColor3f(0.0, 1.0, 0.0); glVertex2f( 0.8, -0.5);
        glColor3f(1.0, 0.0, 1.0); glVertex2f(-0.8, -0.5);
    glEnd();
    // 三个点
    glPointSize(3);  // 设置点 的大小
    glBegin(GL_POINTS);
        glColor3f(1.0, 0.0, 0.0); glVertex2f(-0.4, -0.4);
        glColor3f(1.0, 0.0, 0.0); glVertex2f( 0.0,  0.0);
        glColor3f(1.0, 0.0, 0.0); glVertex2f( 0.4,  0.4);
    glEnd();
    
    glFlush();   // 用于强制刷新缓冲，保证绘图命令立即被执行
}
int main(int argc, char *argv[]){
    glutInit(&argc, argv); // 来识别要用glut来控制
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE); // 设置显示的模式
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(500, 500);
    glutCreateWindow("图形学实验1.1");
    glutDisplayFunc(&myDisplay); // 调用显示函数
    glutMainLoop();
    return 0;
}

几点需要主要的

1. opengl 中画图形，都要调用glBegin() 和glEnd(), 并设置图形的形状。
2. 对于glColor3f()等设置颜色的函数来说，就是将当前画图的颜色状态转换到设置值，如果接下来不再重新设置，那么这个颜色将一直沿用到结束。
3. GLUT_RGB 是指定当前窗口的颜色模式为RGB
4. GLUT_SINGLE 和GLUT_DOUBLE 所对应都是存储每帧中的像素信息，对于动画来说，会设置为DOUBLE型，这样的话，一个用来显示当前正在显示的图像，另一个离线加载下一帧的信息，这样来回切换就会显示的更流畅。

结果显示：

#include <bits/stdc++.h>
#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
using namespace std;

const double PI = acos(-1.0);
struct Point{
    double x, y;
    Point(){}
    Point(double _x, double _y){
        x = _x; y = _y;
    }
};
void myDisplay(void){
    glClearColor(0.0, 0.0, 0,0);
    glClear(GL_COLOR_BUFFER_BIT);

    // 矩形
    glColor3f( 1.0,  1.0, 1.0);
    glRectf  (-0.8, -0.8, 0.8, 0.8);

    double rate = 0.8;
    // 大三角形
    glBegin(GL_TRIANGLES);
        glColor3f(0.0, 1.0, 0.0); glVertex2f(-1 * rate,  1 * rate);
        glColor3f(1.0, 1.0, 0.0); glVertex2f( 1 * rate,  1 * rate);
        glColor3f(1.0, 0.0, 0.0); glVertex2f( 0 * rate, -1 * rate);
    glEnd();

    // 圆
    int N = 100; // 精度
    double R = 0.62 * rate;
    glColor3f(1.0, 0.0, 1.0);
    glBegin(GL_POLYGON);
        for(int i = 0; i < N; i++) {
            glVertex2f(R * cos(2 * PI/ N * i), R * sin(2 * PI / N * i));
        }
    glEnd();

    // 五角星
    Point arr[5];
    arr[0] = Point(-0.5, -0.65);
    arr[1] = Point( 0.5, -0.65);
    arr[2] = Point( 0.7,  0.2);
    arr[3] = Point( 0.0,  0.7);
    arr[4] = Point(-0.7,  0.2);
    glColor3f(0, 0, 1);
    glLineWidth(1 );  // 设置线宽
    for(int i = 0; i < 5; i++){
        glBegin(GL_LINES);
            glVertex2f(arr[i].x, arr[i].y);
            int j = (i + 2) % 5;
            glVertex2f(arr[j].x, arr[j].y);
        glEnd();
    }

    // 小三角形
    Point a[3];
    a[0] = Point(0.7 , -0.7);
    a[1] = Point(0.6 , -0.7);
    a[2] = Point(0.65, -0.6);
    glColor3f(1, 0, 1);
    for(int i = -1; i <= 1; i += 2){
        glBegin(GL_POLYGON);
        for(int j = 0; j < 3; j++){
            glVertex2f(i * a[j].x, a[j].y);
        }
        glEnd();
        glColor3f(1.0, 0.7, 0.0);
    }
    glFlush();
}
int main(int argc, char *argv[]){
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(400, 400);
    glutCreateWindow("图形学实验1.2");
    glutDisplayFunc(&myDisplay);
    glutMainLoop();
    return 0;
}

几点需要注意的：

1. 通过这个实验我们应该可以意识到，对于我们想要画一个图形来说，一个图形 = 点集 + 颜色 + (周长 | 面积) ，这样 就可以描述所有的图形，当然画图形的时候也可以这样。
2. 这里需要强调一下GL_POLYGON图形的画法（被坑很多次，QAQ）
   一: 它是画一个封闭图形（多边形）并且颜色作用域是整个封闭图形一
   二: 它的点集要是按照顺时针给出，同时很重要的一点是这个图形还要是一个凸多边形，所以如果我们要画一个一般多边形，我们可以通过通过划分这个多变型为多个凸多边形

图形结果：

#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <bits/stdc++.h>
using namespace std;

struct Point{
    double x, y;
    Point(){}
    Point(double _x, double _y){
        x = _x; y = _y;
    }
    Point operator + (const Point &a) const{
        return Point(this->x + a.x, this->y + a.y);
    }
    Point operator / (const int &a) const{
        return Point(this->x / a, this->y / a);
    }
};

const double PI = acos(-1.0);

void setColor(int id){
    double r, g, b;
    if(id == 1) {r = 0.0; g = 0.0; b = 0.0;}
    if(id == 2) {r = 1.0; g = 1.0; b = 1.0;}
    if(id == 3) {r = 1.0; g = 0.0; b = 0.0;}
    if(id == 4) {r = 1.0, g = 1.0; b = 0.0;}
    glColor3f(r, g, b);
}
void dfs(Point a[], int id){
    if(id > 4) return ;
    setColor(id);
    glBegin(GL_POLYGON);
        for(int i = 0; i < 4; i++) glVertex2f(a[i].x, a[i].y);
    glEnd();
    Point t[4]; for(int i = 0; i < 4; i++) t[i] = (a[i] + a[(i + 1 ) % 4]) / 2;
    dfs(t, id + 1);
}
void setcolor(int id){
    double r, g, b;
    if(id == 0) {r = 1.0, g = 0.0, b = 0.0;}
    if(id == 1) {r = 0.0, g = 1.0, b = 0.0;}
    if(id == 2) {r = 0.0, g = 0.0, b = 1.0;}
    if(id == 3) {r = 1.0, g = 1.0, b = 0.0;}
    glColor3f(r, g, b);
}
void myDisplay(void){
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT);

    // 递归画矩形嵌套
    Point a[4];
    a[0] = Point(-0.5, -0.5);
    a[1] = Point( 0.5, -0.5);
    a[2] = Point( 0.5,  0.5);
    a[3] = Point(-0.5,  0.5);
    dfs(a, 1);

    // 通过旋转得到 四个三角形
    double r[4], t[4];
    r[1] = sqrt(2.0) / 2.0; t[1] = PI / 4.0;
    r[3] = 1.0;             t[3] = 0.0;
    r[2] = sqrt(2.0) / 2.0; t[2] = -PI / 4.0;
    for(int i = 0; i < 4; i++){
        setcolor(i);
        glBegin(GL_POLYGON);
            for(int j = 1; j <= 3; j++){
                glVertex2f(cos(t[j]) * r[j], sin(t[j]) * r[j]);
                t[j] += PI / 2;
            }
        glEnd();
    }
    glFlush();
}
int main(int argc, char *argv[]){
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(500, 500);
    glutCreateWindow("图形学实验1.3");
    glutDisplayFunc(&myDisplay);
    glutMainLoop();
    return 0;
}

注意:

1. 画图形的时候要多考虑 图形的特征，这样的话我们可以用旋转，平移，递归等各种方法来减少代码量，减少时间

总结 ：第一次的实验，主要是对opengl的熟悉，还有简单图形的处理。