Nhom9-Detai11-nha-cap-4

BỘ CÔNG THƯỜNG TRƯỜNG ĐẠI HỌC
CÔNG NGHIỆP HÀ NỘI

BÀI TẬP NHĨM HỌC PHẦN ĐỒ HỌA MÁY
TÍNH
Đề tài : Mơ phỏng cảnh quan và hoạt động của các
thiết bị trong ngôi nhà cấp 4.
Giáo viên: Vũ Minh Yến
Nhóm: 9
Phạm Thành Đơ – 201960
Nguyễn Văn Hải – 201960
Nguyễn Văn Hậu – 201960
Hà Nội – Năm 2021


Mở đầu
Sự phát triển của khoa học, kĩ thuật, nghệ thuật, kinh doanh và công nghệ
luôn luôn phụ thuộc vào khả năng truyền đặt thông tin của chúng ta, hoặc thông
qua các bit dữ liệu lưu trữ trong microchip hoặc thơng báo giao tiếp bằng tiếng nói.
Câu châm ngơn từ xa xưa “Một hình ảnh có giá trị hơn cả vạn lời” hay “Trăm nghe
không bằng một thấy: cho thấy ý nghĩa rất lớn của hình ảnh trong việc truyền tải
thơng tin. Hình ảnh bao giơi cũng dược cảm nhận nhanh và dễ dàng hơn, đặc biệt là
trong trường hợp bất đồng về ngơn ngữ. Do đó khơng có gì ngạc nhiên khi mà ngay
từ khi xuất hiện máy tính, các nhà nghiên cưu đã cố gắng sử dụng nó để phát sinh
các hình ảnh trên màn hình. Trong suốt gần 50 năm pháp triển của máy tính, khả
năng phát sinh hình ảnh bằng máy tính của chúng ta đã đạt tới mức mà bây giờ hầu
như tất cả cacsc máy tính đều có khả năng đồ họa.
Đồ họa máy tính là một trong những lĩnh vực lí thú nhất và phát triển nhanh nhất
của tin học. Ngay từ khi xuất hiện, đồ họa máy tính đã có sức lơi cuốn mãnh liệt,
cuốn hút rất nhiều người ở nhiều lĩnh vực khác nhau như : khoa học , nghệ thuật,
kinh doanh, quản lí,... Tính hấp dẫn và đa dạng của đồ họa máy tính có thể được

minh họa rất trược quan thông qua việc khảo sát các ứng dụng của nó.
Và để hiểu rõ hơn về đồ họa máy tính chúng em đã tìm hiểu và hồn thành bài tập
lớn về đề tài: “Mô phỏng cảnh quan và hoạt động của cácthiết bị trong ngôi nhà cấp
4.”


Chương 1: Giới thiệu
1. Yêu cầu của đề tài
- Mô phỏng ngôi nhà cấp 4 và các đồ dùng nhà ngồi nhà như bàn,
ghế , tivi, kệ để tivi tủ sách ,... một số đồ dùng khác trong chương
trình.
- Mơ phỏng các hiệu ứng đồ dùng như kỹ thuật chuyện động, dịch
chuyển đồ vật, hiệu ứng ánh sách cùng màu sắc của đồ vật trong
chương trình.
- Thay đổi góc nhìn cho người dùng và cảnh quan bên trong ngôi
nhà.
2. Mô tả chức năng của chương trình :
- Sử dùng Ctrl + B để chạy chương trình.
- Khi nhấn phím B để quay đồ vật trong chương trình.
 Khi nhấn phím dùng chuột chọn đồ vật
 Đồ vật chỉ quay ngược chiều kim đồng hồ
- Các phím dùng để di chuyển đồ vật :
 X dùng để di chuyển sang phải
 Y dùng để di chuyển lên trên
 Z dùng để di chuyển sang trái
3. Vị dụ mơ hình chạy trong chương chình :
Dùng phím B để quay ngược kim đồng hồ đồ vật


Dùng phím X di chuyển đồ vật sang bên phải

Dùng phím Y đồ vật lên trên

Dùng phím Z đồ vật sang trái


Chương 2 : Các hàm trong chương trình
1. Các hàm cơ bản trong chương trình lập phương
Gọi các đỉnh và màu sắc của hình:
point4 points[NumPoints]; /* Danh sách các đỉnh của các tam giác cần vẽ*/
color4 colors[NumPoints]; /* Danh sách các màu tương ứng cho các đỉnh trên*/
point4 vertices[8]; /* Danh sách 8 đỉnh của hình lập phương*/
color4 vertex_colors[8]; /*Danh sách các màu tương ứng cho 8 đỉnh hình lập
phương*/

Hàm gán giá trị vị trí các đỉnh và gán màu sắc của khối hình
void initCube()
{
// Gán giá trị tọa độ vị trí cho các đỉnh của hình lập phương
vertices[0] = point4(-0.5, -0.5, 0.5, 1.0);
vertices[1] = point4(-0.5, 0.5, 0.5, 1.0);
vertices[2] = point4(0.5, 0.5, 0.5, 1.0);
vertices[3] = point4(0.5, -0.5, 0.5, 1.0);
vertices[4] = point4(-0.5, -0.5, -0.5, 1.0);
vertices[5] = point4(-0.5, 0.5, -0.5, 1.0);
vertices[6] = point4(0.5, 0.5, -0.5, 1.0);
vertices[7] = point4(0.5, -0.5, -0.5, 1.0);
// Gán giá trị màu sắc cho các đỉnh của hình
vertex_colors[0] = color4(0.0, 0.0, 0.0, 1.0);

vertex_colors[1] = color4(1.0, 0.0, 0.0, 1.0);
vertex_colors[2] = color4(1.0, 1.0, 0.0, 1.0);
vertex_colors[3] = color4(0.0, 1.0, 0.0, 1.0);
vertex_colors[4] = color4(0.0, 0.0, 1.0, 1.0);
vertex_colors[5] = color4(1.0, 0.0, 1.0, 1.0);
vertex_colors[6] = color4(1.0, 1.0, 1.0, 1.0);
vertex_colors[7] = color4(0.0, 1.0, 1.0, 1.0);
}

lập phương
// black
// red
// yellow
// green
// blue
// magenta
// white
// cyan

Hàm tạo khối hình lập phương
int Index = 0;
void quad(int a, int b, int c, int d) /*Tạo một mặt hình lập phương = 2 tam giác,
gán màu cho mỗi đỉnh tương ứng trong mảng colors*/
{
colors[Index] = vertex_colors[a]; points[Index] = vertices[a]; Index++;
colors[Index] = vertex_colors[b]; points[Index] = vertices[b]; Index++;
colors[Index] = vertex_colors[c]; points[Index] = vertices[c]; Index++;
colors[Index] = vertex_colors[a]; points[Index] = vertices[a]; Index++;
colors[Index] = vertex_colors[c]; points[Index] = vertices[c]; Index++;
colors[Index] = vertex_colors[d]; points[Index] = vertices[d]; Index++;

}

Hàm tạo hình học
void makeColorCube(void) /* Sinh ra 12 tam giác: 36 đỉnh, 36 màu*/
{
quad(1,
quad(2,
quad(3,
quad(6,
quad(4,
quad(5,

0,
3,
0,
5,
5,
4,

3,
7,
4,
1,
6,
0,

2);
6);

7);
2);
7);
1);

}
void generateGeometry( void )
{
initCube();
makeColorCube();
}

Hàm bộ đệm GPU
void initGPUBuffers( void )
{
// Tạo một VAO - vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Tạo và khởi tạo một buffer object
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points)+sizeof(colors), NULL,
GL_STATIC_DRAW );
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(points), points);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(points), sizeof(colors), colors);
}

Hàm thiết lập Setup và mà hình

void shaderSetup( void )
{
// Nạp các shader và sử dụng chương trình shader
program = InitShader( "vshader1.glsl", "fshader1.glsl" ); // hàm InitShader khai
báo trong Angel.h
glUseProgram( program );
// Khởi tạo thuộc tính vị trí đỉnh từ vertex shader
GLuint loc_vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( loc_vPosition );
glVertexAttribPointer(loc_vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0) );


GLuint loc_vColor = glGetAttribLocation(program, "vColor");
glEnableVertexAttribArray(loc_vColor);
glVertexAttribPointer(loc_vColor, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(sizeof(points)));
glClearColor( 1.0, 1.0, 1.0, 1.0 );
hình*/
}

/* Thiết lập màu trắng là màu xóa màn

void display( void )
{

}

glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
glDrawArrays( GL_TRIANGLES, 0, NumPoints ); /*Vẽ các tam giác*/

glutSwapBuffers();

Hàm gắn phím
void keyboard( unsigned char key, int x, int y )
{
// keyboard handler
switch ( key ) {
case 033:
exit(1);
break;
}

// 033 is Escape key octal value
// quit program

}

Hàm main
int main( int argc, char **argv )
{
// main function: program starts here
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE|GLUT_RGBA);
glutInitWindowSize( 640, 640 );
glutInitWindowPosition(100,150);
glutCreateWindow( "Drawing a Cube" );

glewInit();

generateGeometry( );

initGPUBuffers( );
shaderSetup( );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );

}

glutMainLoop();
return 0;


2. Hàm thiếp lập trong đề tài
Mơ hình quạt

Hàm tạo hình quạt
void canhquat(GLfloat l, GLfloat h)
{
instance = instance*Scale(l, h, l);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void thanquat(GLfloat l, GLfloat h,GLfloat w)
{
instance = instance*Scale(l, h, w);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void longquat(GLfloat l, GLfloat h, GLfloat w)
{
instance = instance *Scale(l, h, w);

glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
GLfloat ta[] = { 0,0,0,0 };
void canh()


{
instance = Identity();
instance = Translate(0.0f, 0.0f, 0.12f);
longquat(0.1f, 0.1f, 0.1f);
instance = RotateZ(240) * Translate(0.0f, 0.12f, 0.15f);
canhquat(0.02f, 0.15f);
instance = RotateZ(120) * Translate(0.0f, 0.12f, 0.15f);
canhquat(0.02f, 0.15f);
instance =RotateZ(360) * Translate(0.0f, 0.12f, 0.15f);
canhquat(0.02f, 0.15f);

}
void quat()
{
instance = Identity(); /*Sửa identity() trong mat.h thành Identity()*/
thanquat(0.1f, 0.1f, 0.2f);
instance = Translate(0.0f, 0.25f, -0.06f);
thanquat(0.05f, 0.5f,0.05f);
instance = Translate(0.0f, 0.55f, -0.02f);
thanquat(0.1f, 0.1f,0.2f);
}
void cua()
{

model_view = RotateY(ta[1])* RotateX(ta[2]);
quat();
model_view = model_view * Translate(0.0f, 0.55f, 0.0f) * RotateZ(ta[0]);
canh();
}

Mơ hình giường

Hàm tạo giường

void thangiuong()
{
mat4 instance;
//Chan ban
instance = Translate(-0.5 * (lg-wlg), -0.5 * hg, 0.5 * (wg - wlg)) * Scale(wlg,
hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);


glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(-0.5 * (lg - wlg), -0.5 * hg, -0.5 * (wg - wlg)) *
Scale(wlg, hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * (lg - wlg), -0.5 * hg, 0.5 * (wg - wlg)) * Scale(wlg,
hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);

glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * (lg - wlg), -0.5 * hg, -0.5 * (wg - wlg)) * Scale(wlg,
hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
//mat ban
instance = Scale(lg, tg, wg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
//vien giuong
instance = Translate( 0, -0.5 * 0.2, -0.5 *0.75) * Scale(lg, 0.2, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, -0.5 * 0.2, 0.5 * 0.75) * Scale(lg, 0.2, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * (lg - wlg+0.01), -0.5 * 0.2, 0.5 * 0) * Scale(wlg,
0.2, wg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(-0.5 * (lg - wlg + 0.01), -0.5 * 0.1, 0.5 * 0) * Scale(wlg,
0.4, wg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);

}
GLfloat h_nk = 0.15;
GLfloat xx = 0, yy = 0, zz = 0, a = 0, b = 0, c = 0, z_nk = 0;
void ban()
{
instance_giuong = Translate(xx, yy, zz) * RotateZ(c) * RotateY(b) *
RotateX(a);
thangiuong();
}

Mơ hình tủ


Hàm tạo tủ

GLfloat lt = 0.8, tt = 1, wt = 0.01;
GLfloat wlt = 0.2, ht = 0.4;
void thantu()
{
mat4 instance;

instance = Scale(lt, tt, wt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, 0.5 , -0.5 * wlt) * Scale(lt, wt, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, 0.5*0.5, -0.5 * wlt) * Scale(lt, wt, wlt);

glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, -0.5*0.8, -0.5 * wlt) * Scale(lt, wt, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, -0.5 * 0.4, -0.5 * wlt) * Scale(lt, wt, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);


wlt);

glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5*(tt-lt+0.1), 0.02 , -0.5 * wlt) * Scale((lt-0.3), wt,

glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);

instance = Translate(0.5* (lt-wt),0 , -0.5* wlt ) * Scale(wt, tt, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(-0.5 * (lt-wt ), 0 ,-0.5*wlt ) * Scale(wt, tt, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);

instance = Translate(-0.5 * wlt, 0.02, -0.5 * wlt) * Scale(wt, 0.45, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(-0.5 * wlt, 0.37, -0.5 * wlt) * Scale(wt, 0.25, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * 0.3, 0.37, -0.5 * wlt) * Scale(wt, 0.25, wlt);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
GLfloat h_nk = 0.15;
GLfloat xx = 0, yy = 0, zz = 0, a = 0, b = 0, c = 0, z_nk = 0;
void tu()
{
instance_giuong = Translate(xx, yy, zz) * RotateZ(c) * RotateY(b) *
RotateX(a);
thantu();
}

Mơ hình tivi cùng tủ kê tivi


Hàm tạo tivi cùng tủ để tivi

GLfloat lg = 0.8, tg= 0.01, wg= 0.2;
GLfloat wlg = 0.02, hg = 0.2;
void thangiuong()

{
mat4 instance;
//Chan ban
instance = Translate(-0.5 * (lg-wlg), -0.5 * hg, 0.5 * (wg - wlg)) * Scale(wlg,
hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(-0.5 * (lg - wlg), -0.5 * hg, -0.5 * (wg - wlg)) *
Scale(wlg, hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * (lg - wlg), -0.5 * hg, 0.5 * (wg - wlg)) * Scale(wlg,
hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * (lg - wlg), -0.5 * hg, -0.5 * (wg - wlg)) * Scale(wlg,
hg, wlg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);


//mat ban
instance = Scale(lg, tg, wg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);

instance = Translate(0.5 * (lg - wlg)*0, -0.5 * hg, 0) * Scale(lg, tg, wg);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0.5 * (lg - wlg) * 0, -0.5 * 0.1, 0) * Scale(0.01, 0.1,
0.2);

glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, -0.5 * hg+0.4, -0.5 * (wg - wlg)+0.1) * Scale(0.5,
0.3, 0.01);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, -0.5 * hg + 0.2, -0.5 * (wg - wlg) + 0.1) *
Scale(0.02, 0.1, 0.01);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
instance = Translate(0, -0.5 * hg +0.15, -0.5 * (wg - wlg) + 0.1) * Scale(0.2,
0.01, 0.05);
glUniformMatrix4fv(model_loc, 1, GL_TRUE, model * instance_giuong *
instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
GLfloat h_nk = 0.15;
GLfloat xx = 0, yy = 0, zz = 0, a = 0, b = 0, c = 0, z_nk = 0;
void ban()
{

instance_giuong = Translate(xx, yy, zz) * RotateZ(c) * RotateY(b) *
RotateX(a);
thangiuong();
}

Mơ hình tổng hợp của đề tài nhìn từ trên xuống


Hàm gồm các mơ hình

void nen(GLfloat l, GLfloat h, GLfloat r)
{
instance = instance*Scale(l, h, r);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void tuong(GLfloat l, GLfloat h, GLfloat r)
{
instance = instance * Scale(l, h, r);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void khungnha()
{
instance = Identity(); /*Sửa identity() trong mat.h thành Identity()*/
nen(0.5f, 0.02f, 0.4f);
instance = Translate(-0.14f, -0.1f, -0.1f);
tuong(0.2f, 0.2f, 0.02f);
instance = Translate(-0.14f, -0.2f, 0.01f);
tuong(0.2f, 0.01f, 0.2f);

instance = Translate(-0.05f, -0.1f, -0.01f);
tuong(0.01f, 0.2f, 0.2f);
instance = Translate(-0.24f, -0.1f, 0.01f);
tuong(0.01f, 0.2f, 0.2f);
instance = Translate(-0.14f, -0.1f, 0.1f);
tuong(0.2f, 0.2f, 0.02f);
}
void canhcua(GLfloat l, GLfloat h, GLfloat r)
{
instance = Scale(l, h, r);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);


glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void khungcua(GLfloat l, GLfloat h, GLfloat r, GLfloat x, GLfloat y, GLfloat z)
{
instance = Translate(x, y, z) * Scale(l, h, r);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void chotcua(GLfloat l, GLfloat h)
{
instance = Scale(l, h, l);
glUniformMatrix4fv(model_view_loc, 1, GL_TRUE, model_view * instance);
glDrawArrays(GL_TRIANGLES, 0, NumPoints);
}
void bocua()
{
instance = Identity(); /*Sửa identity() trong mat.h thành Identity()*/

canhcua(0.4f, 1.0f, 0.02f);
khungcua(0.02f, 1.0f, 0.02f, 0.2f, 0.0f, 0.0f);
khungcua(0.02f, 1.0f, 0.02f, -0.2f, 0.0f, 0.0f);
khungcua(0.4f, 0.02f, 0.02f, 0.0f, 0.52f, 0.0f);
khungcua(0.4f, 0.02f, 0.02f, 0.0f, -0.52f, 0.0f);
}

3. Hàm chỉnh góc ánh sáng trong mơ hình ( mặt 3 các mặt khác tương
tự theo công thức)
class mat3 {

vec3 _m[3];
public:
//
// --- Constructors and Destructors --//
mat3( const GLfloat d = GLfloat(1.0) ) // Create a diagonal matrix
{ _m[0].x = d; _m[1].y = d; _m[2].z = d; }
mat3( const vec3& a, const vec3& b, const vec3& c )
{ _m[0] = a; _m[1] = b; _m[2] = c; }
mat3( GLfloat m00, GLfloat m01, GLfloat m02,
GLfloat m10, GLfloat m11, GLfloat m12,
GLfloat m20, GLfloat m21, GLfloat m22 )
{
_m[0] = vec3( m00, m01, m02 );
_m[1] = vec3( m10, m11, m12 );
_m[2] = vec3( m20, m21, m22 );
}
mat3( const mat3& m )
{
if ( *this != m ) {

_m[0] = m._m[0];
_m[1] = m._m[1];
_m[2] = m._m[2];
}

}

//
// --- Indexing Operator --//
vec3& operator [] ( int i ) { return _m[i]; }
const vec3& operator [] ( int i ) const { return _m[i]; }
//
// --- (non-modifying) Arithmatic Operators --//
mat3 operator + ( const mat3& m ) const
{ return mat3( _m[0]+m[0], _m[1]+m[1], _m[2]+m[2] ); }
mat3 operator - ( const mat3& m ) const
{ return mat3( _m[0]-m[0], _m[1]-m[1], _m[2]-m[2] ); }
mat3 operator * ( const GLfloat s ) const
{ return mat3( s*_m[0], s*_m[1], s*_m[2] ); }
mat3 operator / ( const GLfloat s ) const {
#ifdef DEBUG
if ( std::fabs(s) < DivideByZeroTolerance ) {
std::cerr << "[" << __FILE__ << ":" << __LINE__ << "] "
<< "Division by zero" << std::endl;
return mat3();
}
#endif // DEBUG
GLfloat r = GLfloat(1.0) / s;

return *this * r;
}
friend mat3 operator * ( const GLfloat s, const mat3& m )
{ return m * s; }
mat3 operator * ( const mat3& m ) const {
mat3 a( 0.0 );
for ( int i = 0; i < 3; ++i ) {
for ( int j = 0; j < 3; ++j ) {
for ( int k = 0; k < 3; ++k ) {
a[i][j] += _m[i][k] * m[k][j];
}
}
}
}

return a;

//
// --- (modifying) Arithmetic Operators --//


mat3& operator += ( const mat3& m ) {
_m[0] += m[0]; _m[1] += m[1]; _m[2] += m[2];
return *this;
}
mat3& operator -= ( const mat3& m ) {
_m[0] -= m[0]; _m[1] -= m[1]; _m[2] -= m[2];
return *this;
}
mat3& operator *= ( const GLfloat s ) {

_m[0] *= s; _m[1] *= s; _m[2] *= s;
return *this;
}
mat3& operator *= ( const mat3& m ) {
mat3 a( 0.0 );
for ( int i = 0; i < 3; ++i ) {
for ( int j = 0; j < 3; ++j ) {
for ( int k = 0; k < 3; ++k ) {
a[i][j] += _m[i][k] * m[k][j];
}
}
}
}

return *this = a;

mat3& operator /= ( const GLfloat s ) {
#ifdef DEBUG
if ( std::fabs(s) < DivideByZeroTolerance ) {
std::cerr << "[" << __FILE__ << ":" << __LINE__ << "] "
<< "Division by zero" << std::endl;
return mat3();
}
#endif // DEBUG
GLfloat r = GLfloat(1.0) / s;
return *this *= r;
}
//
// --- Matrix / Vector operators --//
vec3 operator * ( const vec3& v ) const { // m * v

return vec3( _m[0][0]*v.x + _m[0][1]*v.y + _m[0][2]*v.z,
_m[1][0]*v.x + _m[1][1]*v.y + _m[1][2]*v.z,
_m[2][0]*v.x + _m[2][1]*v.y + _m[2][2]*v.z );
}
//
// --- Insertion and Extraction Operators --//
friend std::ostream& operator << ( std::ostream& os, const mat3& m ) {
return os << std::endl


<< m[0] << std::endl
<< m[1] << std::endl
<< m[2] << std::endl;
}
friend std::istream& operator >> ( std::istream& is, mat3& m )
{ return is >> m._m[0] >> m._m[1] >> m._m[2] ; }
//
// --- Conversion Operators --//
operator const GLfloat* () const
{ return static_cast<const GLfloat*>( &_m[0].x ); }
operator GLfloat* ()
{ return static_cast<GLfloat*>( &_m[0].x ); }
};
//
// --- Non-class mat3 Methods --//
inline
mat3 matrixCompMult( const mat3& A, const mat3& B ) {
return mat3( A[0][0]*B[0][0], A[0][1]*B[0][1], A[0][2]*B[0][2],
A[1][0]*B[1][0], A[1][1]*B[1][1], A[1][2]*B[1][2],
A[2][0]*B[2][0], A[2][1]*B[2][1], A[2][2]*B[2][2] );

}
inline
mat3 transpose( const mat3& A ) {
return mat3( A[0][0], A[1][0], A[2][0],
A[0][1], A[1][1], A[2][1],
A[0][2], A[1][2], A[2][2] );
}

4. Hàm giải thích
glDrawArrays: render primitives from array data (kết xuất nguyên thủy từ
dữ liệu mảng )
glutSwapBuffers : swaps the buffers of the current window if double
buffered(hoán đổi bộ đệm của cửa sổ hiện tại nếu bộ đệm kép)
glGenVertexArrays : generate vertex array object names ( tạo tên đối
tượng mảng đỉnh )
glBindVertexArray : bind a vertex array object ( ràng buộc một đối tượng
mảng đỉnh)
glGenBuffers : generate buffer object names ( tạo tên đối tượng đệm)
glBindBuffer : bind a named buffer object ( ràng buộc một đối tượng đệm
được đặt tên)
glBufferData, glNamedBufferData : creates and initializes a buffer
object's data store ( tạo và khởi tạo kho dữ liệu của đối tượng đệm )
glUseProgram : Installs a program object as part of current rendering


state ( Cài đặt một đối tượng chương trình như một phần của trạng thái kết xuất
hiện tại)
glEnableVertexAttribArray: Enable or disable a generic vertex attribute
array
glVertexAttribPointer : define an array of generic vertex attribute data

glutInit : Initialize OpenGLUT data structures.
glutInitDisplayMode : Set the window creation display mode.
glutInitWindowSize : Requests future windows to open at a given
width/height..
glutInitWindowPosition : Requests future windows to open at a given
position.
glutDisplayFunc : Sets the Display callback for the current window.
glutKeyboardFunc : Sets the Keyboard callback for the current window.
glutMainLoop : The standard GLUT event loop entry point.

Chương 3: Kết quả
1. Kết luận
Qua việc thực hiện nghiêm cứu đề tài “ Mô phỏng cảnh quan và hoạt
động của các thiết bị trong ngơi nhà cấp 4 “. Nhóm chúng em đã tìm hiểu
xâu về hơn về mơn đồ họa các khối hình và thuật tốn. Việc thực hiện đề
tài giúp cải thiệt tư duy cố hữu trong code thành sáng tạo hơn, cải thiện
tinh thần đồng đội.
Trong quá trình thực hiện đề tài có rất nhiều ý tưởng hay và độc đáo.
Nhưng do khả năng và kiến thức có hạn nên bài tập lớn của chúng em cịn
rất nhiều thiếu sót và lỗi. Tuy nhiên chúng em đã cố gắng xây dựng
chương trình nhóm chúng em đã cố gắng hết sức xây dựng đề tài hoàn
chỉnh.
Chúng em cảm ơn Cơ Vũ Minh Yến đã tận tình giảng dạy chúng em
trong mơn Đồ họa máy tính. Giúp đỡ chúng em trong q trình nghiên
cứu đề tài. Cơ chia sẻ những tài liệu cùng sự giảng giải nhiệt tình của cơ
2. Tài liệu tham khảo
: tìm kiếm các hàm trong chương trình
: thư viện trong chương trình
: thư viện trong chương trình
: thư viện trong chương trình

Edward Angel, Dave Shreiner. Interactive Computer Graphics. AddisonWesley, 6th Edition, 2012
Peter Shirley, Steve Marschner. Fundamentaks Of Computer Graphics. A
K Peters/CRC, 3 Edition, 2009
Brian Curless. Tập bài giảng môn Đồ họa máy tính của trường đại học
Washington, 2017.


Vũ Minh Yến, Vũ Đức Huy, Nguyễn Phương Nga. Giáo trình ĐHMT
trường ĐHCNHN. NBX Khoa học Kỹ thuật, 2015.