计算机图形学6——3D scene roaming(三维场景漫游)

其他 2019-03-03 02:34:06 阅读次数: 0

核心代码有：
前进操作：

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

左旋转操作：

	void turn_left(void)
	{
		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=u.x*sin(turn_a)+n.x*cos(turn_a);
		n.y=u.y*sin(turn_a)+n.y*cos(turn_a);
		n.z=u.z*sin(turn_a)+n.z*cos(turn_a);
	}

完整代码如下：

// ====== Computer Graphics Experiment #8 ======
// |             3D scene roaming              |
// =============================================
//
// Requirement:
// (1) Implement translation and rotation of view reference frame
// (2) Change smooth shading to flat shading and observe the effects
// (3) Carefully read and understand the rest of the source code

#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_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 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+step*v.x;
	    P0.y=P0.y+step*v.y;
		P0.z=P0.z+step*v.z;
	}

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

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

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

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

	}

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

	void turn_left(void)
	{
		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=u.x*sin(turn_a)+n.x*cos(turn_a);
		n.y=u.y*sin(turn_a)+n.y*cos(turn_a);
		n.z=u.z*sin(turn_a)+n.z*cos(turn_a);
	}

	void turn_right(void)
	{
	    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=-u.x*sin(turn_a)+n.x*cos(turn_a);
		n.y=-u.y*sin(turn_a)+n.y*cos(turn_a);
		n.z=-u.z*sin(turn_a)+n.z*cos(turn_a);

	}

	void look_up(void)
	{
		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=-v.x*sin(pitch_a)+n.x*cos(pitch_a);
		n.y=-v.y*sin(pitch_a)+n.y*cos(pitch_a);
		n.z=-v.z*sin(pitch_a)+n.z*cos(pitch_a);
	}

	void look_down(void)
	{
        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=v.x*sin(pitch_a)+n.x*cos(pitch_a);
		n.y=v.y*sin(pitch_a)+n.y*cos(pitch_a);
		n.z=v.z*sin(pitch_a)+n.z*cos(pitch_a);
	}

	void roll_left(void)
	{
        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=-u.x*sin(roll_a)+v.x*cos(roll_a);
		v.y=-u.y*sin(roll_a)+v.y*cos(roll_a);
		v.z=-u.z*sin(roll_a)+v.z*cos(roll_a);
	}

	void roll_right(void)
	{
        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=u.x*sin(roll_a)+v.x*cos(roll_a);
		v.y=u.y*sin(roll_a)+v.y*cos(roll_a);
		v.z=u.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=(0+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.move_left();
			glutPostRedisplay(); break;
		case 'd'://move right
            view_frame.move_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 (500, 300);
	glutInitWindowPosition (50, 50);
	glutCreateWindow ("3D Scene Roaming");
	init();
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(special_key);
	glutMainLoop();
	return 0;
}

在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/qq_41856733/article/details/85038248
今日推荐
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
周排行
计算机组成与设计（七）—— 除法器
Integer Approximation(分治+枚举)
大话数据库索引
windows10系统JDK的配置及下载地址
mysql实现秒值转换中原六仔平台搭建
Codeforces Round #556 (Div. 1)
百练1064 网线主管
Codeforces 995F Cowmpany Cowmpensation
子集生成之增量构造法，位向量法，二进制法
ERROR: cmd.exe failed with args /c "/APK\gradle\rungradle.bat...
每日归档
更多
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022