计算机图形学OpenGL实验——实现三维空间、视野方向转换

最新推荐文章于 2023-05-15 09:24:10 发布
最新推荐文章于 2023-05-15 09:24:10 发布
阅读量8.4k 收藏 169
点赞数 23
文章标签： 图形学 opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43576525/article/details/104569531
版权

计算机图形学实验，用OpenGL实现三维空间，绘制三维房间、家具、房屋建筑等。

用到的OpenGL 函数

 glColor3f(blue); //设置颜色
 glutSolidCube(size);//绘制正方体
 glVertex3f(x, y, z);//设置点坐标
 glLightfv(a,b,c);	//设置光源			
 glTranslatef(x, y, z`)`;//平移函数
 glScalef(x, y, z); //放大/缩小函数
 glRotatef(angle, x, y, z);//绕轴旋转函数
 glutSolidSphere(radius, slices, stacks);//绘制球体

glBegin(图形类型) 与 glEnd(void)
在glBegin(arg)的参数部分选择要绘制的图形类型； 在glBegin()与glEnd()之间添加坐标点。比如绘制三角形，就选择glBegin()的参数为GL_TRIANGLES, glVertex3f(x, y, z)添加三角形三个顶点的坐标，末尾加上glEnd().这种代码绘制的图形一般是一个三维空间中的平面图形。

	glBegin(GL_TRIANGLES);
	glVertex3f(x1, y1, z1);
	glVertex3f(x2, y2, z2);
	glVertex3f(x3, y3, z3);
	glEnd();

glPushMatrix() 与 glPopMatrix()
在glPushMatrix() 与 glPopMatrix() 之间添加绘制基本平面图形，通过组合、平移、放大缩小就能轻易的实现复杂三维视图。

比如： 用glutSolidCube(1)；绘制一个边长为一个单位的立方体，这个立方体的中心坐标为(t0, 0, 0);

进行平移、放大：

glPushMatrix();
glTranslatef(1, 2, 3)
glScalef(1,1,3);
glPopMatrix();

这样立方体的中心位置的坐标变成了(1,2,3)，而且长宽高分别变成了1,1,3个单位长度。

代码

//地板黑白纹理

//产生纹理
void makeCheckImages(void)
{
    int i, j, c;
    for (i = 0; i < checkImageHeight; i++) {
        for(j = 0; j < checkImageWidth; j++) {
            c = (((( i & 0x8) == 0) ^ ((j & 0x8)) == 0)) * 255;
            if(c == 255)
            {
                checkImage[i][j][0] = (GLubyte) 180;
                checkImage[i][j][1] = (GLubyte) 180;
                checkImage[i][j][2] = (GLubyte) 180;
                checkImage[i][j][3] = (GLubyte) 255;
            }
            else
            {
                checkImage[i][j][0] = (GLubyte) c;
                checkImage[i][j][1] = (GLubyte) c;
                checkImage[i][j][2] = (GLubyte) c;
                checkImage[i][j][3] = (GLubyte) 255;
            }
        }
    }
}

//机器人

void people(void)
{
    glColor3f(blue);
    glutSolidCube(2);           //身体

    glColor3f(white);
    glPushMatrix();             //头
    glTranslatef(0, 1.5, 0);
    glutSolidCube(1);
    glPopMatrix();

    glColor3f(black);
    glLineWidth(3);
    glBegin(GL_LINES);
    glVertex3f(-0.2 ,1.75, 0.52);
    glVertex3f(-0.3 ,1.75, 0.52);
    glVertex3f( 0.2 ,1.75, 0.52);
    glVertex3f( 0.3 ,1.75, 0.52);
    glVertex3f( 0.1 ,1.25, 0.52);
    glVertex3f(-0.1 ,1.25, 0.52);
    glEnd();
    glLineWidth(1);

    glColor3f(brown);
    glPushMatrix();             //腿
    glTranslatef(-0.7, -2.25, 0);
    glScalef(0.5, 2.5, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0.7, -2.25, 0);
    glScalef(0.5, 2.5, 0.5);
    glutSolidCube(1);
    glPopMatrix();
    //手
    glPushMatrix();
    glTranslatef(0, 0.25, 0);

    glPushMatrix();
    glTranslatef(-1.25, 0, 0);
    glScalef(1, 0.5, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glRotated(pep_agl, 1, 0, 0);
    glTranslatef(-1.75, -0.75, 0);
    glScalef(0.5, 2, 0.5);
    glutSolidCube(1);
    glPopMatrix();


    glPushMatrix();
    glTranslatef(1.25, 0, 0);
    glScalef(1, 0.5, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glRotated(-1 * pep_agl, 1, 0, 0);
    glTranslatef( 1.75, -0.75, 0);
    glScalef(0.5, 2, 0.5);
    glutSolidCube(1);
    glPopMatrix();
    
    glPopMatrix();
}
void draw_people(void){
    glPushMatrix();
    glTranslatef(4, -6.5, -5);
    people();
    glPopMatrix();
}

//绘制树木

void draw_tree(void)
{
    glPushMatrix();
    glScalef(0.2, 0.2, 0.15);
    glTranslatef(120, -60, -450);
    //树干
    glColor3f(brown);
    constract(60,10,390,15,70,15);
    build();
    //树叶
    glColor3f(hgreen);
    glTranslatef(60,70,400);
    glutSolidSphere(25.0, 20, 20);  //球1
    glTranslatef(20,0,0);
    glutSolidSphere(25.0, 20, 20);  //球2
    glTranslatef(-10,0,-10);
    glutSolidSphere(25.0, 20, 20);  //球3
    glTranslatef(0,0,20);
    glutSolidSphere(25.0, 20, 20);  //球4
    glTranslatef(0,10,-10);
    glutSolidSphere(25.0, 20, 20);  //球4
    glPopMatrix();
}

//草坪路

void draw_road(int x)
{
    glColor3f(brown);
    for (int i = 0; i < x; ++i) {
        glPushMatrix();
        glTranslatef(0, 0, i * 5);
        constract(-5, -10, 0, 10, 0.1, 3.5);
        build();
        glPopMatrix();
    }
}

//NUAA教学楼

void NUAA(void)
{
    glMaterialfv(GL_FRONT, GL_AMBIENT, matWhite);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matWhite);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);

    glPushMatrix();
    glTranslatef(0, 0, 150);
    glRotated(180, 0, 1, 0);
    glColor3f(brown);
    constract(-15, 20, 0, 30,  70, -30);
    build();

    glColor3f(hgray);
    constract(-35, -10,  0, 70, 30, -30);
    build();

    glColor4f(white, 0.35);
    for (int i = 0; i < 9; ++i) {
        glPushMatrix();
        glTranslatef(0, 7 * i, 0);
        constract(-12, 21, 0.2, 10, 6, -0.2);
        build();
        constract(2, 21, 0.2, 10, 6, -0.2);
        build();
        glPopMatrix();
    }

    glColor4f(white, 0.35);
    constract(-30, -5, 0.2, 25, 20, -0.2);
    build();
    constract( 5, -5, 0.2, 25, 20, -0.2);
    build();

    glPushMatrix();
    glTranslatef(-13, 84, 0.1);
    glScalef(0.04, 0.05, 2);
    glColor3f(red);
    glLineWidth(5);
    glutStrokeCharacter(GLUT_STROKE_ROMAN, 'N');
    glutStrokeCharacter(GLUT_STROKE_ROMAN, ' ');
    glutStrokeCharacter(GLUT_STROKE_ROMAN, 'U');
    glutStrokeCharacter(GLUT_STROKE_ROMAN, ' ');
    glutStrokeCharacter(GLUT_STROKE_ROMAN, 'A');
    glutStrokeCharacter(GLUT_STROKE_ROMAN, ' ');
    glutStrokeCharacter(GLUT_STROKE_ROMAN, 'A');
    glLineWidth(1);
    glPopMatrix();

    glPopMatrix();
}

//房子

void house(void)
{
    glMaterialfv(GL_FRONT, GL_AMBIENT, matWhite);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matWhite);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);

    glPushMatrix();
    glColor3f(brown);
    constract(-15, -10, 0, 30,  70, -30);
    build();
    glColor4f(white, 0.35);
    for (int i = 0; i < 9; ++i) {
        glPushMatrix();
        glTranslatef(0, 7 * i, 0);
        constract(-12, -9, 0.2, 10, 6, -0.2);
        build();
        constract(  2, -9, 0.2, 10, 6, -0.2);
        build();
        glPopMatrix();
    }
    glPopMatrix();
}

//太阳

//太阳
    glPushMatrix();
    glColor3f(gold);
    glTranslatef(0, 95, 0);
    glutSolidSphere(5.0, 20, 20);
    glPopMatrix();

//柜子

//柜子
void draw_closet(void)
{
    glColor3f(1, 0.6, 0.3);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matBrown);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matBrown);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);

    glPushMatrix();
    glTranslatef(16, -3, -16);
    glScalef( 4, 14, 4);
    glPushMatrix();
    glutSolidCube(1);
    glColor3f(black);
    glLineWidth(2);
    glBegin(GL_LINES);
    glVertex3f(-0.5, 0.5, 0.51);
    glVertex3f( 0.5, 0.5, 0.51);
    glVertex3f( 0  , 0.5, 0.51);
    glVertex3f( 0  ,-0.5, 0.51);
    glVertex3f(-0.5,-0.5, 0.51);
    glVertex3f( 0.5,-0.5, 0.51);
    glVertex3f(-0.25, 0.05, 0.51);
    glVertex3f(-0.25, 0.1, 0.51);
    glVertex3f( 0.25, 0.1, 0.51);
    glVertex3f( 0.25, 0.05, 0.51);
    glEnd();
    glPopMatrix();
    glLineWidth(1);
    glPopMatrix();
}

//花瓶

//花瓶
void draw_vase(void)
{
    glPushMatrix();
    glTranslatef(16, -5.5, -7);
    glPushMatrix();
    glScalef(0.1, 0.1, 0.1);
    glTranslatef(-40, 0 ,0);
    draw_tree();
    glPopMatrix();

    glPushMatrix();
    glScalef(1, 1, 0.75);
    glTranslatef(0.21, -0.75, -0.55);
    glColor3f(blue);
    constract(-1, -1, 0, 1, 1, -1);
    build();
    glPopMatrix();

    glPopMatrix();
}

//房间内部墙壁

//墙
void draw_wall(void)
{
    GLfloat x = 19;
    GLfloat y = 10;
    GLfloat z = 20;
    //glColor3f(1.0, 1.0, 1.0);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matWhite);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matWhite);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    glBegin(GL_QUADS);					//back wall
    glColor3f(hgreen);
    glVertex3f( x, y, -z);
    glVertex3f(-x, y, -z);
    //glColor3f(0.0, 1.0, 0.0);
    glVertex3f(-x,-y, -z);
    glVertex3f( x,-y, -z);
    glEnd();

    //top wall
    glColor3f(gray);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matRed);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matRed);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    glBegin(GL_QUADS);
    glVertex3f( x, y, -z);
    glVertex3f( x, y,  0);
    glVertex3f(-x, y,  0);
    glVertex3f(-x, y, -z);
    glEnd();

    //left wall
    glMaterialfv(GL_FRONT, GL_AMBIENT, matGreen);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matGreen);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    glBegin(GL_QUADS);
    glColor3f(green);
    glVertex3f(-x, y, -z);
    glVertex3f(-x, y,  0);
    glColor3f(1, 1, 0);
    glVertex3f(-x,-y,  0);
    glVertex3f(-x,-y, -z);
    glEnd();

    //base wall
    glEnable(GL_TEXTURE_2D);//纹理
    glColor3f(0, 0, 1);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matBlue);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matBlue);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    glBegin(GL_QUADS);
    glTexCoord2f(0.0, 0.0); glVertex3f(-x,-y, -z);
    glTexCoord2f(0.0, 1.0); glVertex3f(-x,-y,  0);
    glTexCoord2f(1.0, 1.0); glVertex3f( x,-y,  0);
    glTexCoord2f(1.0, 0.0); glVertex3f( x,-y, -z);
    glEnd();
    glDisable(GL_TEXTURE_2D);

    //right wall
    glMaterialfv(GL_FRONT, GL_AMBIENT, matYellow);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matYellow);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    glBegin(GL_QUADS);
    glColor3f(1, 1, 0);
    glVertex3f( x,-y, -z);
    glVertex3f( x,-y,  0);
    glColor3f(0, 1, 0);
    glVertex3f( x, y,  0);
    glVertex3f( x, y, -z);
    glEnd();
}

//床

//床
void draw_bed(void)
{
    GLfloat x = 6;
    GLfloat y1 = -7.5;
    GLfloat y2 = -5;
    GLfloat z1 = -19.9;
    GLfloat z2 = -5;
    //床头
    glBegin(GL_QUADS);
    glColor3f(0.f,0.54f,0.5f);
    glVertex3f(x, y2, z1);
    glVertex3f(-x, y2,z1);
    glVertex3f(-x, y1,z1);
    glVertex3f(x, y1, z1);
    glEnd();

    //床身
    glBegin(GL_QUADS);
    glColor3f(1.f,0.54f,0.5f);
    glVertex3f(x, y1, z1);
    glVertex3f(-x, y1,z1);
    glVertex3f(-x, y1,z2);
    glVertex3f(x, y1, z2);
    glEnd();

    glBegin(GL_QUADS);
    glColor3f(1.f,0.54f,0.5f);
    glVertex3f(-x, y1, z1);
    glVertex3f(-x, -8.99,z1);
    glVertex3f(-x, -8.99,z2);
    glVertex3f(-x, y1, z2);
    glEnd();

    glBegin(GL_QUADS);
    glColor3f(1.f,0.54f,0.5f);
    glVertex3f(x, y1, z1);
    glVertex3f(x, -8.99,z1);
    glVertex3f(x, -8.99,z2);
    glVertex3f(x, y1, z2);
    glEnd();

    glBegin(GL_QUADS);
    glColor3f(1.f,0.54f,0.5f);
    glVertex3f(-x, y1,z2);
    glVertex3f(x, y1, z2);
    glVertex3f(x, -8.99, z2);
    glVertex3f(-x, -8.99,z2);
    glEnd();

    //枕头
    glBegin(GL_QUADS);
    glColor3f(1.0f,0.84f,0.5f);
    glVertex3f(x-0.5, -7, z1+0.5);
    glVertex3f(0.5, -7,z1+0.5);
    glVertex3f(0.5, -7,-17);
    glVertex3f(x-0.5, -7,-17);
    glEnd();

    glBegin(GL_QUADS);
    glColor3f(1.0f,0.84f,0.5f);
    glVertex3f(0.5, -7,-17);
    glVertex3f(x-0.5, -7,-17);
    glVertex3f(x-0.5, y1,-17);
    glVertex3f(0.5, y1,-17);
    glEnd();

    glBegin(GL_QUADS);
    glColor3f(1.0f,0.84f,0.5f);
    glVertex3f(-x+0.5, -7, z1+0.5);
    glVertex3f(-0.5, -7,z1+0.5);
    glVertex3f(-0.5, -7,-17);
    glVertex3f(-x+0.5, -7,-17);
    glEnd();

    glBegin(GL_QUADS);
    glColor3f(1.0f,0.84f,0.5f);
    glVertex3f(-0.5, -7,-17);
    glVertex3f(-x+0.5, -7,-17);
    glVertex3f(-x+0.5, y1,-17);
    glVertex3f(-0.5, y1,-17);
    glEnd();

    //被子
    glPushMatrix();
    glTranslatef(0, -7.49, -10.5);
    glScalef(2 * x, 0.1, 11);
    glutSolidCube(1);
    glPopMatrix();

}

//吊灯

//吊灯
void draw_light(void)
{
    glPushMatrix();					//Celling Light
    glColor3f(1, 1, 0);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matYellow);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matYellow);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    if(aCeilingLight) glMaterialfv(GL_FRONT, GL_EMISSION, matYellow);
    glTranslatef(0,8.99,-10);
    glRotatef(90, 1, 0, 0);
    glutSolidCone(1,1,16,16);
    glPopMatrix();
}

//椅子

//椅子
void draw_seat(void)
{
    glColor3f(1, 0.6, 0.3);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matBrown);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matBrown);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);

    glPushMatrix();
    glTranslatef(13.5 - seat_dis, -9, -5);
    glScalef(0.8, 0.8, 0.8);
    //凳子腿
    glPushMatrix();
    glTranslatef(-1, 0, -1);
    glRotatef(-90, 1, 0, 0);
    gluCylinder(obj, 0.2, 0.2, 2.5, 10, 10);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(1, 0, -1);
    glRotatef(-90, 1, 0, 0);
    gluCylinder(obj, 0.2, 0.2, 2.5, 10, 10);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-1, 0, 1);
    glRotatef(-90, 1, 0, 0);
    gluCylinder(obj, 0.2, 0.2, 2.5, 10, 10);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(1, 0, 1);
    glRotatef(-90, 1, 0, 0);
    gluCylinder(obj, 0.2, 0.2, 2.5, 10, 10);
    glPopMatrix();

    //凳子面
    glPushMatrix();
    glTranslatef(0, 2.5, 0);
    glScalef( 3, 0.5, 3);
    glutSolidCube(1);
    glPopMatrix();

    glPopMatrix();
}

//时钟

//钟
void draw_clock(void)
{
    glColor3f(1, 0.6, 0.3);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matYellow);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matYellow);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    glPushMatrix();
    glTranslatef(0, 4, -19.0);
    glScalef(0.75, 0.75, 1);
    //圆盘
    gluDisk(obj, 2.2, 2.5, 20, 4);
    //时针
    glLineWidth(2);
    glBegin(GL_LINES);
    glVertex3f(2.0 * cos(clock_agl1 * Pi / 180), 2.0 * sin(clock_agl1 * Pi / 180), 0);
    glVertex3f(0, 0, 0);
    glVertex3f(0, 0, 0);
    glVertex3f(1, 0, 0);
    glVertex3f(0, 0, 0);
    glVertex3f(1 * cos(clock_agl2 * Pi / 180), 1.5 * sin(clock_agl2 * Pi / 180), 0);
    glColor3f(black);
    glVertex3f(0, 1.9, 0);
    glVertex3f(0, 2.2, 0);
    glVertex3f(1.9, 0, 0);
    glVertex3f(2.2, 0, 0);
    glVertex3f(0, -1.9, 0);
    glVertex3f(0, -2.2, 0);
    glVertex3f(-1.9, 0, 0);
    glVertex3f(-2.2, 0, 0);
    glEnd();
    glLineWidth(1);
    glColor3f(0.25, 0.25, 0.25);
    gluDisk(obj, 0, 2.2, 20, 4);
    glPopMatrix();
}

//日历

//日历
void draw_canlender(void)
{
    glPushMatrix();
    glTranslatef(-10, 3, -19.9);

    glColor3f(0.98, 0.625, 0.12);
    glBegin(GL_QUADS);
    glVertex3f(-2, 2, -0.01);
    glVertex3f(2, 2, -0.01);
    glVertex3f(2, -2, -0.01);
    glVertex3f(-2, -2, -0.01);
    glEnd();

    //画五角星
    glColor3f(1.0, 0.0, 0.0);
    GLfloat m=2.0f;   //设边长为2
    StarDisplay(m);

    glColor3f(0.6, 0.4, 0.12);
    glBegin(GL_QUADS);
    glVertex3f(2, -2, -0.01);
    glVertex3f(-2, -2, -0.01);
    glVertex3f(-2, -4, -0.01);
    glVertex3f(2, -4, -0.01);
    glEnd();

    glColor3f(0.0, 0.0, 0.0);
    glBegin(GL_LINES);
    glVertex3f(-1.8, -2.1, 0);
    glVertex3f(1.8, -2.1, 0);
    glVertex3f(-1.8, -2.6, 0);
    glVertex3f(1.8, -2.6, 0);
    glVertex3f(-1.8, -3.1, 0);
    glVertex3f(1.8, -3.1, 0);
    glVertex3f(-1.8, -3.6, 0);
    glVertex3f(1.8, -3.6, 0);
    glEnd();

    glPopMatrix();
}

//窗户

//窗户
void draw_window(void)
{
    glPushMatrix();
    glTranslatef(0, 0, 5);
    glScalef(1, 1.2, 1.5);

    glBegin(GL_QUADS);
    glColor4f(1.0, 1.0, 1.0, 0.1);
    glVertex3f(-18.99, 4, -12);
    glVertex3f(-18.99, 4,  -8);
    glVertex3f(-18.99, 8,  -8);
    glColor4f(0.0, 0.0, 0.4, 0.1);
    glVertex3f(-18.99, 8, -12);

    glColor4f(1.0, 1.0, 1.0, 0.1);
    glVertex3f(-20.1, 4, -12);
    glVertex3f(-20.1, 4,  -8);
    glVertex3f(-20.1, 8,  -8);
    glColor4f(0.0, 0.0, 0.4, 0.1);
    glVertex3f(-20.1, 8, -12);
    glEnd();
    glLineWidth(4);
    glColor3f(0.6f, 0.4f, 0.12f);

    glBegin(GL_LINES);
    glVertex3f(-18.98f, 6, -12);
    glVertex3f(-18.98f, 6, -8 );
    glVertex3f(-18.98f, 8, -10);
    glVertex3f(-18.98f, 4, -10);
    glEnd();
    glLineWidth(1);
    glPopMatrix();

}

//桌子和茶壶

//桌子和茶壶
void draw_desk(void)
{
    glColor3f(1, 0.6, 0.3);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matBrown);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matBrown);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);

    glPushMatrix();
    glTranslatef(-14, -7.5, -5);
    glScalef(2.0, 4.0, 1.5);
    //桌腿
    glPushMatrix();
    glTranslatef(-1, 0, -1);
    glScalef(0.2, 1.3, 0.2);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(1, 0, -1);
    glScalef(0.2, 1.3, 0.2);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-1, 0, 1);
    glScalef(0.2, 1.3, 0.2);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(1, 0, 1);
    glScalef(0.2, 1.3, 0.2);
    glutSolidCube(1);
    glPopMatrix();

    //面
    glPushMatrix();
    glTranslatef(0, 0.65, 0);
    glScalef( 2.5, 0.1, 2.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();				//Teapot
    glColor3f(0,1,1);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matWhite);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matWhite);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matWhite);
    glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    //glScalef(tea_scal, tea_scal, tea_scal);
    glTranslatef(0.2, 0.93 + tea_high, 0);
    glRotatef(-100, 0, 1, 0);
    glutSolidTeapot(0.25 * tea_scal);
    glPopMatrix();

    //杯子
    glColor3f(0,1,1);
    glPushMatrix();
    glTranslatef(0.28, 0.82, 1);
    glRotated(90, 1, 0 ,0);
    gluCylinder(obj,0.22, 0.12, 0.11, 20, 20);
    glPopMatrix();

    glPopMatrix();
}

//电视

//电视
void draw_tv(void)
{
    glPushMatrix();
    glTranslatef(18, 0, -5);

    //电视机/电脑
    glPushMatrix();
    glTranslatef(0, 0, -2);
    glScalef( 0.3, 4, 6);
    glColor3f(0.0, 0.0, 0.0);
    glutSolidCube(1);
    glLineWidth(4);
    glColor3f(0.0, 0.0, 1.0);
    glutWireCube(1);
    glLineWidth(1);
    glPopMatrix();

    glPopMatrix();

    //电视桌
    glPushMatrix();

    glTranslatef(17.0, -8.8, -3);
    glScalef(0.9, 0.6, 0.7);

    glColor3f(1, 0.6, 0.3);
    glPushMatrix();
    glTranslatef(0, 0, -10);
    glScalef( 4, 4, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0, 0, 0);
    glScalef( 4, 4, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0, 2.25, -5);
    glScalef( 4, 0.5, 10.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0, 8.25, -5);
    glScalef( 4, 0.5, 10.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0, 5.25, -10);
    glScalef( 4, 6, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0, 5.25, -5);
    glScalef( 4, 6, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0, 5.25, 0);
    glScalef( 4, 6, 0.5);
    glutSolidCube(1);
    glPopMatrix();

    if(tv_open){
        glPushMatrix();
        glTranslatef(0.8, 12, -9.5);
        glScalef(0.001, 0.05, 0.02);
        glRotated(-90, 0, 1, 0);
        glColor3f(red);
        glutStrokeCharacter(GLUT_STROKE_ROMAN, 'H');
        glutStrokeCharacter(GLUT_STROKE_ROMAN, 'E');
        glutStrokeCharacter(GLUT_STROKE_ROMAN, 'L');
        glutStrokeCharacter(GLUT_STROKE_ROMAN, 'L');
        glutStrokeCharacter(GLUT_STROKE_ROMAN, 'O');
        glPopMatrix();
    }
    glPopMatrix();

}

//台灯

//台灯
void draw_taideng(void)
{
    glPushMatrix();
    glTranslatef(10, -5, -17);

    glPushMatrix();
    glColor3f(1, 0, 1);
    glMaterialfv(GL_FRONT, GL_AMBIENT, matBrown);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, matBrown);
    glMaterialfv(GL_FRONT, GL_SPECULAR, matBlack);
    glMaterialfv(GL_FRONT, GL_SHININESS, matBlack);
    glMaterialfv(GL_FRONT, GL_EMISSION, matBlack);
    if(Light2)
        glMaterialfv(GL_FRONT, GL_EMISSION, matBrown);
    //glTranslatef(0,8.99,-10);
    glRotatef(-90, 1, 0, 0);
    glutSolidCone(1.5,2,16,16);
    glPopMatrix();


    glPushMatrix();
    glTranslatef(0, -3.6, 0);
    glScalef(3.0, 3, 3.0);
    glColor3f(1, 0.6, 0.3);
    glutSolidCube(1);
    glPopMatrix();

    glColor3f(0.0, 0.0, 0.0);
    glPushMatrix();
    glTranslatef(0, -2, 0.0);
    glRotatef(-90, 1, 0, 0);
    gluCylinder(obj, 0.4, 0.2, 2.99, 40, 40);
    glPopMatrix();

    glLineWidth(2);
    glColor3f(0.0, 0.0, 0.0);
    glBegin(GL_LINE_STRIP);
    glVertex3f(-1.48, -2.2, 1.51);
    glVertex3f(-0.1, -2.2, 1.51);
    glVertex3f(-0.1, -5, 1.51);
    glVertex3f(-1.48,-5, 1.51);
    glEnd();
    glBegin(GL_LINE_STRIP);
    glVertex3f(1.48, -2.2, 1.51);
    glVertex3f(0.1, -2.2, 1.51);
    glVertex3f(0.1, -5, 1.51);
    glVertex3f(1.48,-5, 1.51);
    glEnd();

    glLineWidth(10);
    glBegin(GL_POINTS);
    glVertex3f(0.75, -3.5, 1.51);
    glVertex3f(-0.75, -3.5, 1.51);
    glEnd();

    glLineWidth(1);

    glPopMatrix();
}

//视角左转、右转函数

void turn_left(void)
{
    int x = 0;
    x = dir();

    if(x == 1)
    {
        eobj[2] = eye[2];     //left
        eobj[0] = eye[0] - 1;
    }
    else if(x == 2)
    {                        //right
        eobj[2] = eye[2];
        eobj[0] = eye[0] + 1;
    }
    else if(x == 3)
    {
        eobj[0] = eye[0];        //back
        eobj[2] = eye[2] + 1;
    }
    else if(x == 4)
    {
        eobj[0] = eye[0];        //forward
        eobj[2] = eye[2] - 1;
    }
}

void turn_right(void)
{
    int x = 0;
    x = dir();

    if(x == 1)
    {
        eobj[2] = eye[2];
        eobj[0] = eye[0] + 1;
    }
    else if(x == 2)
    {
        eobj[2] = eye[2];     //left
        eobj[0] = eye[0] - 1;
    }
    else if(x == 3)
    {
        eobj[0] = eye[0];        //forward
        eobj[2] = eye[2] - 1;
    }
    else if(x == 4)
    {
        eobj[0] = eye[0];        //back
        eobj[2] = eye[2] + 1;
    }
}
void reshape(int w, int h) // Resize the GL Window. w=width, h=height
{
    if (h == 0) h = 1;
    WinWidth = w;
    WinHeight = h;

    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    gluPerspective(60,(GLfloat)w/(GLfloat)h,1.0,100.0);
    gluLookAt( eye[0], eye[1], eye[2], eobj[0], eobj[1], eobj[2], 0.0, 1.0, 0.0);
}
void keyboard(unsigned char key, int x, int y) // Handle the keyboard events here
{
    switch (key)
    {
        case'\033'://press 'esc' to quit
            exit(0);
            break;
        case'1':
            Light0 = !Light0;
            printf("Press key '1'.\n");
            break;
        case'2':
            Light1 = !Light1;
            printf("Press key '2'.\n");
            break;
        case'3':
            Light2 = !Light2;
            printf("Press key '3'.\n");
            break;
        case '4':
            if(bookdis == 0)
                bookdis = 4;
            else bookdis = 0;
            break;
        case '5':
            printf("Press key '5'.\n");
            if(tea_high == 0)
                tea_high = 1;
            else tea_high = 0;
            break;
        case '6':
            printf("Press key '6'.\n");
            if(tea_scal == 1)
                tea_scal += 0.5;
            else if(tea_scal == 1.5)
                tea_scal = 2;
            else
                tea_scal =1;
            break;
        case'7':
            aMice = !aMice;
            printf("Press key '7'.\n");
            break;
        case '8':
            tv_open = !tv_open;
            printf("Press key '8'.\n");
            break;
        case '9':
            pep_retot = !pep_retot;
            printf("Press key '8'.\n");
            break;
        case '0':
            if(seat_dis == 0){
                seat_dis = 2;
            }
            else{
                seat_dis = 0;
            }
            printf("Press key '8'.\n");
            break;
        case 'o':
            printf("Press key '0'.\n");
            door_open = !door_open;
            break;
        case 'a':
            printf("Press key 'a'.\n");
            turn_left();
            break;
        case 'd':
            printf("Press key 'd'.\n");
            turn_right();
            break;
        case 'w':
            printf("Press key 'w'.\n");
            eye[1] += 1;
            eobj[1] += 1;
            break;
        case 's':
            printf("Press key 'w'.\n");
            eye[1] -= 1;
            eobj[1] -= 1;
            break;
        case 'b':
            printf("Press key 'b'.\n");
            eye[0] = eobj[0] = 0;
            eye[1] = eobj[1] = 0;
            eye[2] = 17.3;
            eobj[2] = 16.3;
            break;
    }
}

//视角前后左右移动函数

void move_left(void)
{
    int x = 0;
    x = dir();

    if(x == 1)
    {
        eye[0] -= 1;
        eobj[0] -= 1;
    }
    else if(x == 2)
    {
        eye[0] += 1;
        eobj[0] += 1;
    }
    else if(x == 3)
    {
        eye[2] += 1;
        eobj[2] += 1;
    }
    else if(x == 4)
    {
        eye[2] -= 1;
        eobj[2] -= 1;
    }
}

void move_right(void)
{
    int x = 0;
    x = dir();

    if(x == 1)
    {
        eye[0] += 1;
        eobj[0] += 1;
    }
    else if(x == 2)
    {
        eye[0] -= 1;
        eobj[0] -= 1;
    }
    else if(x == 3)
    {
        eye[2] -= 1;
        eobj[2] -= 1;
    }
    else if(x == 4)
    {
        eye[2] += 1;
        eobj[2] += 1;
    }
}

void move_forward(void)
{
    int x = 0;
    x = dir();

    if(x == 1)
    {
        eye[2] -= 1;
        eobj[2] -= 1;
    }
    else if(x == 2)
    {
        eye[2] += 1;
        eobj[2] += 1;
    }
    else if(x == 3)
    {
        eye[0] -= 1;
        eobj[0] -= 1;
    }
    else if(x == 4)
    {
        eye[0] += 1;
        eobj[0] += 1;
    }
}

void move_back(void)
{
    int x = 0;
    x = dir();

    if(x == 1)
    {
        printf("1");
        eye[2] += 1;
        eobj[2] += 1;
    }
    else if(x == 2)
    {
        eye[2] -= 1;
        eobj[2] -= 1;
    }
    else if(x == 3)
    {
        eye[0] += 1;
        eobj[0] += 1;
    }
    else if(x == 4)
    {
        eye[0] -= 1;
        eobj[0] -= 1;
    }
}

void specialkey(int key, int x, int y)
{
    switch (key)
    {
        case GLUT_KEY_LEFT:
            move_left();
            printf("left\n");
            break;

        case GLUT_KEY_RIGHT:
            move_right();
            printf("right\n");
            break;

        case GLUT_KEY_UP:
            printf("forward\n");
            move_forward();
            break;

        case GLUT_KEY_DOWN:
            printf("back\n");
            move_back();
            break;

        default:
            break;
    }
    reshape(WinWidth, WinHeight);
    glutPostRedisplay();
}

//主函数

void init(void) // All Setup For OpenGL Goes Here
{
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_COLOR_MATERIAL);
    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
    //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
    glEnable(GL_NORMALIZE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    //鍒涘缓绾圭悊
    makeCheckImages();
    glPixelStorei(GL_UNPACK_ALIGNMENT,1);

    glGenTextures(1, &texName);
    glBindTexture(GL_TEXTURE_2D, texName);

    //瀹氫箟绾圭悊
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
                 checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
    //鎺у埗婊ゆ尝
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

}

void display(void) // Here's Where We Do All The Drawing
{
    // TODO:
    // Place light source here
    setLight0(Light0);
    setLight1(Light1);
    setLight2(Light2);
    setLight3(Light3);

    obj = gluNewQuadric();

    // TODO:
    // Draw walls and objects here
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);//绾圭悊鏄犲皠鏂瑰紡


    draw_wall();
    draw_bed();
    draw_closet();
    draw_light();
    draw_seat();
    draw_clock();
    draw_canlender();
    draw_window();
    draw_tv();
    draw_bookdesk();
    draw_mouse();
    draw_desk();
    draw_taideng();
    draw_vase();
    out_house();
    draw_people();

    // TODO:
    // Add animation here

    glFlush();
    glutSwapBuffers();

}
void idle(void)
{
    if(!aMice){
        if(aMiceEyeBigger){
            aMiceEyeScale += 0.2;
            if(aMiceEyeScale >= 3) aMiceEyeBigger = false;
        }else{
            aMiceEyeScale -= 0.2;
            if(aMiceEyeScale <= 0) aMiceEyeBigger = true;
        }
        aMiceTrans[0] = aMiceTrans[1] = aMiceTrans[2] = 0;
    }else{
        aMiceEyeScale = 1;
        aMiceTrans[2] += 0.05;
        if(aMiceTrans[2] < 10)
            aMiceTrans[0] += 0.2;
        else
            aMiceTrans[0] -= 0.2;
        if(aMiceTrans[2] > 25)
            aMiceTrans[0] = aMiceTrans[1] = aMiceTrans[2] = 0;
    }

    if(!door_open) {
        if(door_dis > 0)
            door_dis -= 0.05;
    }
    else{
        if(door_dis <20)
            door_dis += 0.05;
    }

    clock_agl1 -= 0.008;
    if(clock_agl1 == 90) {
        clock_agl2 -= 6;
    }

    if(pep_retot) {
        pep_agl = pep_agl + pep_r;
        if(pep_agl > 60) {
            pep_r = -1;
        }
        if(pep_agl < -60) {
            pep_r = 1;
        }
    }
    else {
        pep_agl = -45;
        pep_r = 1;
    }
    reshape(WinWidth, WinHeight);
    //Sleep(0.01);
    glutPostRedisplay();
}
int main(int argc, char** argv)
{

    /*Initialization of GLUT Library */
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);

    /*Create a window with title specified */
    glutInitWindowSize(950, 500);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Assignment 1");

    init();	/*not GLUT call, initialize several parameters */

    /*Register different CALLBACK function for GLUT to response
    with different events, e.g. window sizing, mouse click or
    keyboard stroke */
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutSpecialFunc(specialkey);
    glutIdleFunc(idle);

    /*Enter the GLUT event processing loop which never returns.
    it will call different registered CALLBACK according
    to different events. */
    glutMainLoop();
    return 0;
}

运行效果

//房子外部
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
//房间内部
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//灯光
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
//房子左边建筑
在这里插入图片描述

在这里插入图片描述
//房子右边建筑
在这里插入图片描述
//正前方往前走
在这里插入图片描述
在这里插入图片描述

不醉不会
关注
  • 23
    点赞
  • 踩
  • 169
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
OpenGL画花瓶，可以填充，选择颜色等
12-15
OpenGL画花瓶，可以填充，选择颜色等，适合opengl小型作业，当然自己也可以改进一下，1234567890
OpenGL 立体房子模拟
05-28
OpenGL 立体房子模拟 OpenGL 立体房子模拟 通过鼠标操作
openGL期末大作业——行走的机器人
06-26
openGL期末大作业——行走的机器人
计算机图形学（一）——opengl实现三维立方体添加纹理光照与材质、键盘鼠标控制平移旋转和放大缩小
诶你爱我吗的博客
12-27 8010
1.实验要求： 用OpenGL和C语言编写一个带纹理和材质的一个立方体的交互式程序。 1)要求生成一个在立方体，并在立方体的六个面上并分别实现不同的纹理映射和材质。纹理的类型为BMP图片纹理，材质类型可以自己设计。例如，三个面上实现纹理映射的头像和生活照，另外三个面上实现材质(金属、塑料等)。 2)可以利用鼠标和键盘进行交互，实现该立方体的旋转、平移和缩放。 2.实验效果图如下： 正常情况下 加...
使用OpenGL函数库实现的一个三维庭院
热门推荐
qq_31895943的博客
04-18 2万+
使用OpenGL函数库实现的一个三维庭院 源代码参考自：《OpenGL 房子》 本文章的源码链接：https://github.com/AhiGan/Yard_OpenGL 实验要求 绘制一个具有真实感的三维场景，其中至少含有2个三维物体，具有光照、纹理效果，可实现交互式的场景漫游，可以使用WebGL、OpenGL或其他函数库，要求独立完成从建模、变换、光照、面绘制算法、纹理映...
计算机图形学 使用OpenGL的场景建模
weixin_43757333的博客
02-25 7550
本文基于OpenGl，实现了简单的阴影、光照、纹理、相机视角变换和人物动画。
计算机图形学——实验二 OpenGL中的图形绘制
软肋.的博客
05-15 401
计算机图形学——实验二 OpenGL中的图形绘制。
深圳大学计算机图形学期末大作业——OpenGL glfw库实现简单的Minecraft游戏
AnakinRM的博客
02-28 1万+
目录 1. OBJ文件读取 2. 物体渲染与纹理着色。 3. 相机变换的实现 4. 光照与阴影的实现 5. 阴影设计 6. 层级建模 7.添加动画 8. 交互 1.视角移动 2. 鼠标左右键添加删除物体 3. 选择移动、添加的物体 4. 光源位置改变 5. 层级建模交互 9. 其余功能 1. 视角跟随机器人模式 2. 光标制作 1. OBJ文件读取...
计算机图形学期末答辩作业——opengl室内简单场景设计(可键盘交互、可视角漫游、有纹理贴图、实现光照)
hry1999的博客
07-13 9140
一、项目说明 这个opengl场景设计是我们的计算机图形学课程期末答辩大作业。此项目实现了一个简单的室内场景设计，此场景由沙发、茶几、桌子、水壶、地板、墙壁等元素构成，其中地板与墙壁采取了纹理贴图，并可使用键盘实现与场景的交互，可以实现视角漫游、物体旋转，控制光照等功能。另外，此场景设计简单，代码简洁，共使用430多行代码便实现了简单的场景设计与基本操作，并且每一句代码都有非常详细的注释，相信就算是一点opengl基础没有也可通过学习本项目轻松入门。 二、运行说明 1、电脑版本：win10 2、运行软件：V
计算机图形学实验三 图形的变换1
qq_52497285的博客
04-23 938
，
opengl绘制花瓶演示
04-29
这是一个3D花瓶（有影子）的演示程序，在程序中可以多角度观察一个花瓶，可以漫游视角。
计算机图形学 OpenGL实验源码+实验文档
12-05
实验一 OpenGL+GLUT开发平台搭建 5 小实验1： 开发环境设置 5 小实验2： 控制窗口位置和大小 6 小实验3：默认的可视化范围 6 小实验4：自定义可视化范围 7 小实验5： 几何对象变形的原因 8 小实验6： 视口坐标系及视口定义 8 小实验7：动态调整长宽比例，保证几何对象不变形 9 实验二 动画和交互 10 小实验1： 单缓冲动画技术 10 小实验2： 双缓冲动画技术 11 小实验3：键盘控制 13 小实验4：鼠标控制【试着单击鼠标左键或者右键，试着按下鼠标左键后再移动】 14 实验三 几何变换、观察变换、三维对象 16 小实验1：二维几何变换 16 小实验2：建模观察（MODELVIEW）矩阵堆栈 17 小实验3：正平行投影1 19 小实验4：正平行投影2 19 小实验5：正平行投影3 20 小实验6：透射投影1 21 小实验6：透射投影2 22 小实验7：三维对象 24 实验四 光照模型和纹理映射 26 小实验1：光照模型1----OpenGL简单光照效果的关键步骤。 26 小实验2：光照模型2----光源位置的问题 28 小实验3：光照模型3----光源位置的问题 31 小实验4：光照模型4----光源位置的问题 33 小实验5：光照模型5----光源位置的问题 35 小实验6：光照模型6----光源位置的问题 38 小实验7：光照模型7----光源位置的动态变化 40 小实验8：光照模型8----光源位置的动态变化 43 小实验9：光照模型9---光源位置的动态变化 45 小实验10：光照模型10---聚光灯效果模拟 48 小实验11：光照模型11---多光源效果模拟 50 小实验12：光照效果和雾效果的结合 53 小实验13：纹理映射初步—掌握OpenGL纹理映射的一般步骤 56 小实验13：纹理映射—纹理坐标的自动生成（基于参数的曲面映射） 59 小实验14：纹理映射—纹理坐标的自动生成（基于参考面距离） 61
计算机图形大作业opengl-物联网.rar
05-25
借鉴了一位博主的林中小屋，运用opengl函数画的一个小屋（包含源代码），visio studio运行，本人运行没问题，如果下载之后有问题可以私戳我
OPENGL 作品 花儿
12-06
用OPENGL画的花儿，很有感觉，很不一样
山东大学计算机图形学OpenGL三维迷宫的创建及走迷宫过程中的交互功能的实现
04-26
三维迷宫的创建及走迷宫过程中的交互功能的实现。掌握可交互的OpenGL应用程序的开发设计的方法,掌握系统处理鼠标和键盘事件的编程方法,掌握OpenGL应用程序的拾取机制,掌握并学会利用OpenGL开发场景漫游程序的编程...
计算机图形学：OpenGL编程：三维图形.ppt
05-21
计算机图形学：OpenGL编程：三维图形.ppt
计算机图形学——opengl实现fbx模型导入
03-08
opengl实现fbx模型导入，有UV贴图
计算机图形学实验完整代码opengl.rar
12-13
计算机图形学实验完整代码opengl.rar
计算机图形学实验-基于OpenGL实现椭圆 Bresenham 算法和橡皮筋交互技术
12-23
基于C++ OpenGL/GLUT 实现的，橡皮筋式椭圆交互绘制，包含鼠标和键盘交互，以及菜单创建，可供计算机图形学实验参考。
计算机图形学opengl实验8茶壶光照加提高
最新发布
11-10
计算机图形学中，OpenGL是一个常用的图形处理库，可以用来进行各种图形渲染和图形处理操作。在OpenGL实验8中，茶壶光照是一个常见的实验内容，通过增加光照效果可以提高茶壶的真实感和视觉效果。 在实验8中，我们需要进行以下几个步骤来实现茶壶的光照加强： 1. 设置光源：在OpenGL中，光源通常使用GL_LIGHT来表示。我们需要设置光源的位置、颜色和强度等参数。可以使用glLightfv函数来设置光源的属性。 2. 设置材质和光照模型：茶壶的外观效果由材质和光照模型共同决定。我们可以通过使用glMaterial函数来设置茶壶的材质属性，如漫反射、镜面反射等。使用glLightModel函数来设置光照模型。 3. 启用光照：在渲染茶壶之前，我们需要启用光照功能。可以使用glEnable函数来启用光照。 4. 绘制茶壶：可以使用glutSolidTeapot函数来绘制一个简单的茶壶。绘制茶壶时，光照会根据设置的光源和材质属性进行实时计算。 通过以上步骤，我们可以在OpenGL实验8中对茶壶的光照进行加强，并提高茶壶的真实感和视觉效果。可以根据实际需求，调整光源的位置和属性，以及材质的属性，来达到理想的光照效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值