计算机图形学——OpenGL实现三维漫游（课堂备份）

最新推荐文章于 2022-02-24 23:22:48 发布
最新推荐文章于 2022-02-24 23:22:48 发布
阅读量1.4k 收藏 15
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42319367/article/details/85039258
版权

#include <windows.h>
#include <GL/glut.h>
#include <math.h>

#define PI 3.14159265

// 3D vector class
class CVector3D
{
public:
    float x, y, z;

    // Constructors
    CVector3D(void) {x=0.0; y=0.0; z=0.0;}
    CVector3D(float x0, float y0, float z0)
    {x=x0; y=y0; z=z0;}
};

// View reference frame class
class CViewFrame
{
public:
    float step; // step size
    float turn_a; // turn angle
    float pitch_a; // pitch angle
    float roll_a; // roll angle

    CVector3D P0; // View reference point
    CVector3D u; // unit vector in xv direction
    CVector3D v; // unit vector in yv direction
    CVector3D n; // unit vector in zv direction

    void move_up(void) 
    {
        P0.x=P0.x+v.x;
        P0.y=P0.y+v.y;
        P0.z=P0.z+v.z;
    }

    void move_down(void) 
    {
        P0.x=P0.x-v.x;
        P0.y=P0.y-v.y;
        P0.z=P0.z-v.z;
    }

    void move_left(void) 
    {
        P0.x=P0.x-u.x;
        P0.y=P0.y-u.y;
        P0.z=P0.z-u.z;
    }

    void move_right(void) 
    {
        P0.x=P0.x+u.x;
        P0.y=P0.y+u.y;
        P0.z=P0.z+u.z;
    }

    void move_forward(void) 
    {
        P0.x=P0.x-n.x;
        P0.y=P0.y-n.y;
        P0.z=P0.z-n.z;
    }

    void move_backward(void) 
    {
        P0.x=P0.x+n.x;
        P0.y=P0.y+n.y;
        P0.z=P0.z+n.z;    
    }

    void turn_left(void)
    {
        CVector3D temp;
        temp.x=u.x;
        temp.y=u.y;
        temp.z=u.z;
        u.x=u.x*cos(turn_a)-n.x*sin(turn_a);
        u.y=u.y*cos(turn_a)-n.y*sin(turn_a);
        u.z=u.z*cos(turn_a)-n.z*sin(turn_a);

        n.x=temp.x*sin(turn_a)+n.x*cos(turn_a);
        n.y=temp.y*sin(turn_a)+n.y*cos(turn_a);
        n.z=temp.z*sin(turn_a)+n.z*cos(turn_a);
    }

    void turn_right(void)
    {
        CVector3D temp;
        temp.x=u.x;
        temp.y=u.y;
        temp.z=u.z;

        u.x=u.x*cos(turn_a)+n.x*sin(turn_a);
        u.y=u.y*cos(turn_a)+n.y*sin(turn_a);
        u.z=u.z*cos(turn_a)+n.z*sin(turn_a);
        
        n.x=-temp.x*sin(turn_a)+n.x*cos(turn_a);
        n.y=-temp.y*sin(turn_a)+n.y*cos(turn_a);
        n.z=-temp.z*sin(turn_a)+n.z*cos(turn_a);
    }

    void look_up(void)
    {
        CVector3D temp;
        temp.x=v.x;
        temp.y=v.y;
        temp.z=v.z;

        v.x=v.x*cos(pitch_a)+n.x*sin(pitch_a);
        v.y=v.y*cos(pitch_a)+n.y*sin(pitch_a);
        v.z=v.z*cos(pitch_a)+n.z*sin(pitch_a);
        
        n.x=-temp.x*sin(pitch_a)+n.x*cos(pitch_a);
        n.y=-temp.y*sin(pitch_a)+n.y*cos(pitch_a);
        n.z=-temp.z*sin(pitch_a)+n.z*cos(pitch_a);    
    }

    void look_down(void)
    {
        CVector3D temp;
        temp.x=v.x;
        temp.y=v.y;
        temp.z=v.z;

        v.x=v.x*cos(pitch_a)-n.x*sin(pitch_a);
        v.y=v.y*cos(pitch_a)-n.y*sin(pitch_a);
        v.z=v.z*cos(pitch_a)-n.z*sin(pitch_a);
        
        n.x=temp.x*sin(pitch_a)+n.x*cos(pitch_a);
        n.y=temp.y*sin(pitch_a)+n.y*cos(pitch_a);
        n.z=temp.z*sin(pitch_a)+n.z*cos(pitch_a);    
    }

    void roll_left(void)
    {
        CVector3D temp;
        temp.x=u.x;
        temp.y=u.y;
        temp.z=u.z;

        u.x=u.x*cos(roll_a)+v.x*sin(roll_a);
        u.y=u.y*cos(roll_a)+v.y*sin(roll_a);
        u.z=u.z*cos(roll_a)+v.z*sin(roll_a);
        
        v.x=-temp.x*sin(roll_a)+v.x*cos(roll_a);
        v.y=-temp.y*sin(roll_a)+v.y*cos(roll_a);
        v.z=-temp.z*sin(roll_a)+v.z*cos(roll_a);

    }

    void roll_right(void)
    {
        CVector3D temp;
        temp.x=u.x;
        temp.y=u.y;
        temp.z=u.z;

        u.x=u.x*cos(roll_a)-v.x*sin(roll_a);
        u.y=u.y*cos(roll_a)-v.y*sin(roll_a);
        u.z=u.z*cos(roll_a)-v.z*sin(roll_a);
        
        v.x=temp.x*sin(roll_a)+v.x*cos(roll_a);
        v.y=temp.y*sin(roll_a)+v.y*cos(roll_a);
        v.z=temp.z*sin(roll_a)+v.z*cos(roll_a);
    }
};
 
CViewFrame view_frame;

// Initialization function
void init(void)
{
    static GLfloat light_ambient[] = { 0.01, 0.01, 0.01, 1.0 };
    static GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    static GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };

    glClearColor (0.0, 0.0, 0.0, 0.0);
    glShadeModel (GL_SMOOTH); // Set shading model

    // Set light source properties for light source #0
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);

    glEnable(GL_LIGHTING); // Enable lighting
    glEnable(GL_LIGHT0); // Enable light source #0
    glEnable(GL_DEPTH_TEST); // Enable depth buffer test
    glEnable(GL_NORMALIZE); // Enable auto normalization
    glEnable(GL_CULL_FACE); // Enable face culling

    // Set initial properties for view reference frame
    view_frame.P0=CVector3D(500.0, 0.0, 100.0);
    view_frame.u=CVector3D(0.0, 1.0, 0.0);
    view_frame.v=CVector3D(0.0, 0.0, 1.0);
    view_frame.n=CVector3D(1.0, 0.0, 0.0);
    view_frame.step=2;
    view_frame.turn_a=PI/18;
    view_frame.pitch_a=PI/18;
    view_frame.roll_a=PI/18;
}

// Function to draw chess board on xy plane
void draw_chess_board(float sx, float sy, float sz, int nx, int ny)
// sx, sy, sz: size of the chess board
// nx, ny: Number of chess grids in x and y direction
{
    static GLfloat mat1_color[] = { 0.8, 0.8, 0.8, 1.0 };
    static GLfloat mat2_color[] = { 0.2, 0.2, 0.2, 1.0 };
    int i, j, iflag, jflag;
    float x, y, dx, dy;
    float *pcolor;

    dx=sx/(float)nx;
    dy=sy/(float)ny;

    for (i=0; i<nx; ++i)
    {
        iflag=i%2;
        x=(i+0.5)*dx-0.5*sx;
        for (j=0; j<ny; ++j)
        {
            jflag=j%2;
            y=(j+0.5)*dy-0.5*sy;
            if (iflag==jflag) pcolor=mat1_color;
            else pcolor=mat2_color;
            glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, pcolor);
            glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pcolor);
            glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64.0);
            glPushMatrix();
                glTranslatef(x, y, 0.0);
                glScalef(dx, dy, sz);
                glutSolidCube(1.0);
            glPopMatrix();
        }
    }

}

// Function to draw chess pieces
void draw_chess_piece(float sx, float sy, float sz, int nx, int ny)
// sx, sy, sz: size of the chess board
// nx, ny: Number of chess grids in x and y direction
{
    static GLfloat mat_color[4][4] = {
        { 1.0, 0.0, 0.0, 1.0 }, 
        { 0.0, 1.0, 0.0, 1.0 },
        { 0.0, 0.0, 1.0, 1.0 },
        { 1.0, 1.0, 0.0, 1.0 }};
    float x, y, dx, dy, size;

    dx=sx/(float)nx;
    dy=sy/(float)ny;
    if (dx<dy) size=dx;
    else size=dy;

    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    // Draw a sphere
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_color[0]);  //一些属性的初始化，没能全部看懂
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_color[0]);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64.0);
    x=(1+0.5)*dx-0.5*sx;
    y=(2+0.5)*dy-0.5*sy;
    glPushMatrix();
        glTranslatef(x, y, 0.5*(sz+size));
        glutSolidSphere(0.5*size, 10, 10);
    glPopMatrix();

    // Draw a torus
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_color[1]);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_color[1]);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64.0);
    x=(1+0.5)*dx-0.5*sx;
    y=(0+0.5)*dy-0.5*sy;
    glPushMatrix();
        glTranslatef(x, y, 0.5*(sz+size));
        glRotatef(-90, 1.0, 0.0, 0.0);
        glutSolidTorus(0.1*size, 0.4*size, 10, 20);
    glPopMatrix();

    // Draw a cone
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_color[2]);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_color[2]);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64.0);
    x=(2+0.5)*dx-0.5*sx;
    y=(1+0.5)*dy-0.5*sy;
    glPushMatrix();
        glTranslatef(x, y, 0.5*sz);
        glutSolidCone(0.4*size, size, 10, 5);
    glPopMatrix();

    // Draw a rectangular solid
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_color[3]);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_color[3]);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64.0);
    x=(3+0.5)*dx-0.5*sx;
    y=(3+0.5)*dy-0.5*sy;
    glPushMatrix();
        glTranslatef(x, y, 0.5*(sz+0.9*size));
        glScalef(0.9*dx, 0.9*dy, 0.9*size);
        glutSolidCube(1.0);
    glPopMatrix();

    //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

// Display callback function
void display(void)
{
    static GLfloat light_pos[4]={200.0, 200.0, 200.0, 1.0};

    // Clear frame buffer and depth buffer
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glPushMatrix(); //Save current ModelView matrix

    // Set viewing transformation matrix
    CVector3D look_at;
    look_at.x=view_frame.P0.x-view_frame.n.x;
    look_at.y=view_frame.P0.y-view_frame.n.y;
    look_at.z=view_frame.P0.z-view_frame.n.z;
    gluLookAt(view_frame.P0.x, view_frame.P0.y, view_frame.P0.z,
        look_at.x, look_at.y, look_at.z,
        view_frame.v.x, view_frame.v.y, view_frame.v.z);

    // Set light source position
    glLightfv(GL_LIGHT0, GL_POSITION, light_pos);

    // Draw the scene
    draw_chess_board(400.0, 400.0, 40.0, 4, 4);
    draw_chess_piece(400.0, 400.0, 40.0, 4, 4);

    glPopMatrix(); //Restore ModelView matrix

    glutSwapBuffers(); // Swap front and back buffer
}

// Reshape callback function
void reshape (int w, int h)
{
    float wsize=500.0;

    // Set viewport as the entire program window
    glViewport (0, 0, w, h);

    // Set symmetric perspective projection
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    gluPerspective(60.0, (float)w/(float)h, 10.0, 100000.0);
    

    // Reset modelview transformation matrix to identity
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
}


// Keyboard callback function
void keyboard (unsigned char key, int x, int y)
{
    switch (key) 
    {
        case 27:
            exit(0); break;
        case 'w':
            view_frame.move_forward();
            glutPostRedisplay(); break;
        case 's'://move backward
            view_frame.move_backward();
            glutPostRedisplay(); break;
        case 'a'://move left
            view_frame.turn_left();
            glutPostRedisplay(); break;
        case 'd'://move right
           view_frame.turn_right();
            glutPostRedisplay(); break;
        case 'q'://roll left
           view_frame.roll_left();
            glutPostRedisplay(); break;
        case 'e'://roll right
            view_frame.roll_right();
            glutPostRedisplay(); break;
    }
}

// Special key callback function
void special_key(int key, int x, int y)
{
    switch (key) 
    {    
        case GLUT_KEY_LEFT:
            view_frame.turn_left();
            glutPostRedisplay(); break;
        case GLUT_KEY_RIGHT://turn right
            view_frame.turn_right();
            glutPostRedisplay(); break;
        case GLUT_KEY_UP://look up
            view_frame.look_up();
            glutPostRedisplay(); break;
        case GLUT_KEY_DOWN://look down
            view_frame.look_down();
            glutPostRedisplay(); break;
        case GLUT_KEY_PAGE_UP://move up
            view_frame.move_up();
            glutPostRedisplay(); break;
        case GLUT_KEY_PAGE_DOWN://move down
            view_frame.move_down();
            glutPostRedisplay(); break;
    }
}

// Main program
int main(int argc, char* argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize (1000,500);
    glutInitWindowPosition (0,0);
    glutCreateWindow ("3D Scene Roaming");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutSpecialFunc(special_key);
    glutMainLoop();
    return 0;
}
 

野犬1998
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
初学计算机图形学——OpenGL实现二维图形平移，旋转（不使用opengl自带的函数，齐次方程实现）
qq_42609193的博客
04-27 2579
要求：1.给定窗口中绘制坐标系 2.给定坐标系内绘制三角形 3.完成平移、旋转等变换后的三角形绘制 4.采用OpenGL绘制 代码： #include<windows.h> #include <GL/glut.h> #include <stdlib.h> #include<iostream> #include<cmath> #in...
OpenGL实验一：（简单动画——旋转的多边形）+详细代码
热门推荐
qq_40610760的博客
04-17 1万+
参考书籍：《计算机图形学及其实践教程》-----黄静（机械工业出版社）小白第一练实验目的：1.学习OpenGL的闲置函数，时间函数，简单动画功能。                 2.了解OpenGL裁剪窗口，视区，显示窗口的概念。*************************************************************************样本程序：旋转的多边形...
计算机图形学——实验一 VS+OpenGL绘图环境及基本图形绘制
加载中.......
02-24 5115
VS+OpenGL绘图环境及基本图形绘制 1、 熟悉OpenGL的主要功能； 2、 掌握OpenGL的绘图流程和原理； 3、 掌握OpenGL核心函数的使用； 4、 熟悉OpenGL基本图形元素的绘制函数。 二． 实验内容 1、 如预备知识所述，创建一个OpenGL工程，修改第一个程序中的Display()函数，如下： 该程序是在窗口中画两条线，分别用黄色和红色绘制。如上所述，OpenGL是一个状态机，glBegin(UINT State)可以设定如下状态： GL_POINTS 画点 GL_LINES 画线
win7 + vs2010下opengl开发环境
相信技术的力量
11-06 2521
glut下载地址: http://www.opengl.org/resources/libraries/glut/glutdlls37beta.zip   1. 把解压得到的glut.h放到"C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Include\gl"（与具体安装位置有关，应该是 安装目录\microsoft sdks\win
OpenGL-GLUT提供的9种实体对象绘制
学点什么好呢
09-19 642
#include <windows.h> #include <gl/gl.h> #include <gl/glu.h> #include <gl/glut.h> /* 需要旋转的变量*/ static GLfloat xRot = 0.0f; static GLfloat yRot = 0.0f; static int iShape = 1; ...
计算机图形学——基于MFC三维图形开发 孔令德版
03-06
在本资源中，"计算机图形学——基于MFC三维图形开发 孔令德版"，作者孔令德提供了一套针对MFC（Microsoft Foundation Classes）框架的三维图形编程教程，帮助学习者深入理解计算机图形学在实际应用中的实现方式。...
计算机图形学——opengl实现fbx模型导入
03-08
opengl实现fbx模型导入，有UV贴图
计算机图形学——基于OpenGL三维旋转 + 光照模型
05-28
计算机图形学是信息技术领域...通过这个上机实验，学习者不仅能了解OpenGL的基本用法，还能实践三维图形的创建和渲染，提升对计算机图形学的理解。在实际项目中，这些技能可以应用于游戏开发、虚拟现实、可视化等领域。
计算机图形学——基于OpenGL绘制三维图形
05-28
计算机图形学的作业，内含实验报告、源代码以及模型数据，供参考。
计算机图形学：OpenGL编程：三维图形.ppt
05-21
计算机图形学：OpenGL编程：三维图形.ppt
计算机图形学场景漫游
02-05
该作品是课程设计作品，通过合理运用计算机图形学相关知识—openGL数据库、基本几何图元绘制、二维观察变换、图形的几何变换、三维观察变换、纹理贴图、交互技术、场景漫游等完成了作品《冰雪奇缘》。
计算机图形学——太阳系漫游.rar
10-04
在屏幕上显示一个包含多个虚拟物体的虚拟场景，并且能响应用户的交互操作。 要求： （1）场景中的虚拟物体至少2 个有纹理贴图； （2）具有光照、阴影效果，光源的类型至少有2 种； （3）用户可交互实现视角切换完成对场景的任意角度浏览； （4）允许用户通过键盘或者鼠标实现对场景中至少两个物体进行交互控制 （例如移动，旋转，缩放等）。
3DWorld实现了3D漫游
06-16
NeHe，opengl，实现3d漫游的源程序1111111111111111
opengl的3d漫游迷宫源码
10-02
这个资源是在http://download.csdn.net/download/dnxyhwx/3793438的基础上做了一点点微不足道的修改，原项目的时间太过久远，这里使用了vs2015进行了重新的编译，修正了函数重定义的问题，保留了老学长的资源文件，非常好的资源是一份，欢迎交流和学习
OpenGL3D模型场景漫游
05-13
3D场景漫游、 树和水波纹、 键盘操纵漫游。 包含光照 贴图。
OpenGL(二)图形绘制之多边形面的绘制
爱拼才会赢
07-07 7296
本次通过绘制一个三角形来学习相关的知识。 #include #include #include #include #include //窗口的大小 GLsizei windowWidth; GLsizei windowHeight; //旋转角度参数 static GLfloat xRot = 0.0f; static GLfloat yRot = 0.0f; //确定多边形的绕
OpenGL（二）图形绘制之点线绘制
爱拼才会赢
07-03 6148
本次主要简单学习OpenGL中相关图形绘制的一些API。 以下程序主要是点的大小、直线线性和线宽绘制的示例。 #include #include #include #include #include //窗口的大小 GLsizei windowWidth; GLsizei windowHeight; void ReaderSc
图形学
weixin_30600503的博客
12-22 173
#include<gl/glut.h> #include<windows.h> #include<math.h> #include <stdio.h> #include <stdlib.h> GLfloat light_position1[]={0,28,-20,1.0}; GLfloat model_...
【Qt OpenGL教程】10：加载3D世界，并在其中漫游
cly116的博客
08-03 9965
这次教程中，我将教大家如何加载一个3D世界，并在3D世界中漫游。这相较于我们只能创造一个旋转的立方体或一群星星时有很大的进步了，当然这节课代码难度不低，但也不会很难，只要你跟着我慢慢一步一步来。
计算机图形学复习：三维旋转变换——绕X轴旋转
"该资源是河南大学计算机与信息工程学院苗茹教授的计算机图形学复习课件，主要涵盖了计算机图形学的重要章节，如二维和三维图形变换、观察、对象表示等，特别强调了期末复习的重点内容。" 在计算机图形学中，旋转...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值