计算机图形学 实验二 三维模型读取与控制

目录

一、实验内容

二、具体内容

(在实验2.3的基础上进行修改)

1、OFF格式三维模型文件的读取

2、三维模型的旋转动画

3、键盘鼠标的交互

4、模型的修改

三、代码

---

一、实验内容

1. 读取实验提供的off格式三维模型，并对其赋色。利用鼠标和键盘的交互，控制动画效果，模型的颜色自己可以自行设置，好看就行。

二、具体内容

(在实验2.3的基础上进行修改)

1、OFF格式三维模型文件的读取

参考上机实验2.2的内容，完成对OFF格式三维模型文件的读取与显示，可改变物体的显示颜色，尽量特别，但不要太难看。

1）修改init()方法，读取OFF格式三维模型文件cow.off。

2）修改颜色：

在readoff()方法中：将坐标值(-1,1)映射到颜色值(0,1)

方法1：坐标值加1，除2（结果和实验给的类似）

方法2：坐标值取绝对值

（应该还不算难看）

2、三维模型的旋转动画

参考实验2.1中动画的生成方式，并结合实验2.3中对模型进行旋转变换的过程，生成旋转动画。

默认绕X轴旋转，每1000毫秒转一下rotateDelta角度。

定义相关变量：

在mian函数中定义相关操作：

3、键盘鼠标的交互

参考实验2.1中鼠标与键盘的交互，通过键盘设定选择绕x、y、z轴进行旋转，通过鼠标左右键控制动画的开始与暂停。

1）通过键盘设定选择绕x、y、z轴进行旋转：

在key_callback函数内增加增加如下代码，通过按"X"、"Y"、"Z"控制。

2）通过鼠标左右键控制动画的开始与暂停：

增加mouse_button_callback函数：

然后在main函数中绑定。

3）修改提示语：

4、模型的修改

参考以下代码，通过键盘设定可以在cow.off和cube.off之间切换。

清除顶点数组缓存：

glBindVertexArray(0);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

二维向量：

std::vector<std::vector<?>>

其他STL相关代码可以查阅C++ STL 教程 | 菜鸟教程 (runoob.com)

1）添加变量表示绘制的是牛还是方块：

2）修改init()函数：通过判断currentModel选择读取的文件：

3）在key_callback函数中添加如下代码：

通过按下"N"绘制牛，按下"M"绘制方块。

4）并修改相关提示语。

效果如下：

三、代码

1、main.cpp

#include "Angel.h"
#include "TriMesh.h"
#include <vector>
#include <string>
//#include "main.h"
using namespace std;

const int X_AXIS = 0;
const int Y_AXIS = 1;
const int Z_AXIS = 2;

const int TRANSFORM_SCALE = 0;
const int TRANSFORM_ROTATE = 1;
const int TRANSFORM_TRANSLATE = 2;

const double DELTA_DELTA = 0.3;		// Delta的变化率
const double DEFAULT_DELTA = 0.5;	// 默认的Delta值

double scaleDelta = DEFAULT_DELTA;
double rotateDelta = DEFAULT_DELTA;
double translateDelta = DEFAULT_DELTA;

glm::vec3 scaleTheta(1.0, 1.0, 1.0);		// 缩放控制变量
glm::vec3 rotateTheta(0.0, 0.0, 0.0);    // 旋转控制变量
glm::vec3 translateTheta(0.0, 0.0, 0.0);	// 平移控制变量

int currentTransform = TRANSFORM_ROTATE;	// 设置当前变换
int mainWindow;

//------------------------------------------------------------------------
bool isplaying = true;	// 动画状态
int rotationAxis = X_AXIS;	// 当前旋转轴，默认为 X 轴
int rotationTime = 1000;		// 每1000帧旋转一次

string currentModel ="cow";


struct openGLObject
{
	// 顶点数组对象
	GLuint vao;
	// 顶点缓存对象
	GLuint vbo;

	// 着色器程序
	GLuint program;
	// 着色器文件
	std::string vshader;
	std::string fshader;
	// 着色器变量
	GLuint pLocation;
	GLuint cLocation;
	GLuint matrixLocation;
	GLuint darkLocation;
};

openGLObject cube_object;

TriMesh* cube = new TriMesh();

void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	glViewport(0, 0, width, height);
}

void bindObjectAndData(TriMesh* mesh, openGLObject& object, const std::string& vshader, const std::string& fshader) {

	// 创建顶点数组对象
	glGenVertexArrays(1, &object.vao);  	// 分配1个顶点数组对象
	glBindVertexArray(object.vao);  	// 绑定顶点数组对象

	// 创建并初始化顶点缓存对象
	glGenBuffers(1, &object.vbo);
	glBindBuffer(GL_ARRAY_BUFFER, object.vbo);
	glBufferData(GL_ARRAY_BUFFER,
		mesh->getPoints().size() * sizeof(glm::vec3) + mesh->getColors().size() * sizeof(glm::vec3),
		NULL,
		GL_STATIC_DRAW);

	// @TODO: Task3-修改完TriMesh.cpp的代码成后再打开下面注释，否则程序会报错
	glBufferSubData(GL_ARRAY_BUFFER, 0, mesh->getPoints().size() * sizeof(glm::vec3), &mesh->getPoints()[0]);
	glBufferSubData(GL_ARRAY_BUFFER, mesh->getPoints().size() * sizeof(glm::vec3), mesh->getColors().size() * sizeof(glm::vec3), &mesh->getColors()[0]);

	object.vshader = vshader;
	object.fshader = fshader;
	object.program = InitShader(object.vshader.c_str(), object.fshader.c_str());

	// 从顶点着色器中初始化顶点的位置
	object.pLocation = glGetAttribLocation(object.program, "vPosition");
	glEnableVertexAttribArray(object.pLocation);
	glVertexAttribPointer(object.pLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));

	// 从顶点着色器中初始化顶点的颜色
	object.cLocation = glGetAttribLocation(object.program, "vColor");
	glEnableVertexAttribArray(object.cLocation);
	glVertexAttribPointer(object.cLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(mesh->getPoints().size() * sizeof(glm::vec3)));

	// 获得矩阵存储位置
	object.matrixLocation = glGetUniformLocation(object.program, "matrix");

}

void init()
{
	std::string vshader, fshader;
	// 读取着色器文件路径
	vshader = "shaders/vshader.glsl";
	fshader = "shaders/fshader.glsl";

	//cube->generateCube();
	//cube->readOff("./Models/cow.off");
	if (currentModel == "cow") {
		cube->readOff("./Models/cow.off");
	}
	else {
		cube->generateCube();
	}
	bindObjectAndData(cube, cube_object, vshader, fshader);

	// 设置背景色为黑色
	glClearColor(0.0, 0.0, 0.0, 1.0);
}

// 渲染函数
void display()
{
	// 清空颜色缓冲和深度缓冲
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glUseProgram(cube_object.program);

	glBindVertexArray(cube_object.vao);

	// 初始化变换矩阵  glm::mat4表示 4x4 矩阵
	glm::mat4 m(1.0, 0.0, 0.0, 0.0,
		0.0, 1.0, 0.0, 0.0,
		0.0, 0.0, 1.0, 0.0,
		0.0, 0.0, 0.0, 1.0);

	// @TODO: Task4-在此处修改函数，计算最终的变换矩阵
	// 调用函数传入三种变化的变化量，累加得到变化矩阵
	// 注意三种变化累加的顺序
	// 构建旋转矩阵
	glm::mat4 rotationMatrix = glm::rotate(glm::mat4(1.0), rotateTheta.x, glm::vec3(1.0, 0.0, 0.0))
		* glm::rotate(glm::mat4(1.0), rotateTheta.y, glm::vec3(0.0, 1.0, 0.0))
		* glm::rotate(glm::mat4(1.0), rotateTheta.z, glm::vec3(0.0, 0.0, 1.0));

	// 构建缩放矩阵
	glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0), glm::vec3(scaleTheta.x, scaleTheta.y, scaleTheta.z));

	// 构建平移矩阵
	glm::mat4 translateMatrix = glm::translate(glm::mat4(1.0), glm::vec3(translateTheta.x, translateTheta.y, translateTheta.z));

	// 按照平移、旋转、缩放的顺序相乘得到最终的变换矩阵
	m = translateMatrix * rotationMatrix * scaleMatrix;

	// 传递变换矩阵到着色器
	glUniformMatrix4fv(cube_object.matrixLocation, 1, GL_FALSE, glm::value_ptr(m));

	// 绘制立方体中的各个三角形
	glDrawArrays(GL_TRIANGLES, 0, cube->getPoints().size());
}

// 通过Delta值更新Theta
// axis 表示坐标轴，sign 表示增加或减少
// currentTransform 表示当前变换类型
void updateTheta(int axis, int sign) {
	switch (currentTransform) {
		// 根据变换类型，增加或减少某种变换的变化量
	case TRANSFORM_SCALE:
		//增加或减少缩放的 Theta 值
		scaleTheta[axis] += sign * scaleDelta;
		break;
	case TRANSFORM_ROTATE:
		//增加或减少旋转的 Theta 值
		rotateTheta[axis] += sign * rotateDelta;
		break;
	case TRANSFORM_TRANSLATE:
		//增加或减少平移的 Theta 值
		translateTheta[axis] += sign * translateDelta;
		break;
	}
}

// 复原Theta和Delta
void resetTheta()
{
	scaleTheta = glm::vec3(1.0, 1.0, 1.0);	//scaleTheta 表示缩放变换的角度
	rotateTheta = glm::vec3(0.0, 0.0, 0.0);
	translateTheta = glm::vec3(0.0, 0.0, 0.0);
	scaleDelta = DEFAULT_DELTA;				//缩放变换的单位变化量
	rotateDelta = DEFAULT_DELTA;
	translateDelta = DEFAULT_DELTA;
}

// 更新变化Delta值
void updateDelta(int sign)
{
	switch (currentTransform) {
		// 根据变化类型增加或减少每一次变化的单位变化量
	case TRANSFORM_SCALE:
		scaleDelta += sign * DELTA_DELTA;
		break;
	case TRANSFORM_ROTATE:
		rotateDelta += sign * DELTA_DELTA;
		break;
	case TRANSFORM_TRANSLATE:
		translateDelta += sign * DELTA_DELTA;
		break;
	}
}

void cleanData();

// 处理键盘输入的回调函数
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	switch (key)
	{
		// 退出。
	case GLFW_KEY_ESCAPE:
		if (action == GLFW_PRESS) glfwSetWindowShouldClose(window, GL_TRUE);
		break;
		// 1：缩放模式
	case GLFW_KEY_1:
		if (action == GLFW_PRESS) currentTransform = TRANSFORM_SCALE;
		break;
		// 2: 旋转模式
	case GLFW_KEY_2:
		if (action == GLFW_PRESS) currentTransform = TRANSFORM_ROTATE;
		break;
		// 3: 移动模式
	case GLFW_KEY_3:
		if (action == GLFW_PRESS) currentTransform = TRANSFORM_TRANSLATE;
		break;
		// 4: 绘制线。
	case GLFW_KEY_4:
		if (action == GLFW_PRESS) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		break;
		// 5: 绘制面。
	case GLFW_KEY_5:
		if (action == GLFW_PRESS) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		break;
		// Q: 增加 x。
	case GLFW_KEY_Q:
		if (action == GLFW_PRESS || action == GLFW_REPEAT) updateTheta(X_AXIS, 1);
		break;
		// A: 减少 x。
	case GLFW_KEY_A:
		if (action == GLFW_PRESS || action == GLFW_REPEAT) updateTheta(X_AXIS, -1);
		break;
		// W: 增加 y。
	case GLFW_KEY_W:
		if (action == GLFW_PRESS || action == GLFW_REPEAT) updateTheta(Y_AXIS, 1);
		break;
		// S: 减少 y。
	case GLFW_KEY_S:
		if (action == GLFW_PRESS || action == GLFW_REPEAT) updateTheta(Y_AXIS, -1);
		break;
		// E: 增加 z。
	case GLFW_KEY_E:
		if (action == GLFW_PRESS || action == GLFW_REPEAT) updateTheta(Z_AXIS, 1);
		break;
		// D: 减少 z。
	case GLFW_KEY_D:
		if (action == GLFW_PRESS || action == GLFW_REPEAT) updateTheta(Z_AXIS, -1);
		break;
		// R: 增加变化量。
	case GLFW_KEY_R:
		if (action == GLFW_PRESS) updateDelta(1);
		break;
		// F: 减少变化量。
	case GLFW_KEY_F:
		if (action == GLFW_PRESS) updateDelta(-1);
		break;
		// T: 所有值重置。
	case GLFW_KEY_T:
		if (action == GLFW_PRESS) resetTheta();
		break;
		//-------------------------------------------------------------------
		// 选择绕 X 轴旋转
	case GLFW_KEY_X:
		if (action == GLFW_PRESS) rotationAxis = X_AXIS;
		break;
		// 选择绕 Y 轴旋转
	case GLFW_KEY_Y:
		if (action == GLFW_PRESS) rotationAxis = Y_AXIS;
		break;
		// 选择绕 Z 轴旋转
	case GLFW_KEY_Z:
		if (action == GLFW_PRESS) rotationAxis = Z_AXIS;
		break;
		
    // N: 加载cow.off模型
    case GLFW_KEY_N:
        if (action == GLFW_PRESS) {
			glBindVertexArray(0);//清除顶点数组缓存
			glBindBuffer(GL_ARRAY_BUFFER, 0);
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
			currentModel = "cow";
			init();
        }
        break;
    // M: 加载cube模型
    case GLFW_KEY_M:
        if (action == GLFW_PRESS) {
			glBindVertexArray(0);//清除顶点数组缓存
			glBindBuffer(GL_ARRAY_BUFFER, 0);
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
			currentModel = "cube";
			init();
        }
        break;
	}

}

//-------------------------------------------------------------------------------
void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
{
	if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) {
		isplaying = true; // 左键按下，开始动画
	}
	if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
		isplaying = false; // 右键按下，暂停动画
	}
}


// 输出帮助信息
void printHelp() {
	printf("%s\n\n", "3D Transfomations");
	printf("Keyboard options:\n");
	printf("n: Draw cow\n");
	printf("m: Draw block\n");
	printf("left mouse button: start playing\n");
	printf("right mouse button: Pause playback\n");
	printf("x: Rotate around the X-axis\n");
	printf("y: Rotate around the Y-axis\n");
	printf("z: Rotate around the Z-axis\n");
	printf("The following are the operations previously used:\n");
	printf("1: Transform Scale\n");
	printf("2: Transform Rotate\n");
	printf("3: Transform Translate\n");
	printf("q: Increase x\n");
	printf("a: Decrease x\n");
	printf("w: Increase y\n");
	printf("s: Decrease y\n");
	printf("e: Increase z\n");
	printf("d: Decrease z\n");
	printf("r: Increase delta of currently selected transform\n");
	printf("f: Decrease delta of currently selected transform\n");
	printf("t: Reset all transformations and deltas\n");
}

// 清理数据
void cleanData() {
	cube->cleanData();

	// 释放内存
	delete cube;
	cube = NULL;

	// 删除绑定的对象
	glDeleteVertexArrays(1, &cube_object.vao);

	glDeleteBuffers(1, &cube_object.vbo);
	glDeleteProgram(cube_object.program);
}

int main(int argc, char** argv)
{
	// 初始化GLFW库，必须是应用程序调用的第一个GLFW函数
	glfwInit();

	// 配置GLFW
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
	//设置字符格式
    #pragma execution_character_set("GBK");
	GLFWwindow* window = glfwCreateWindow(600, 600, "homework", NULL, NULL);

	if (window == NULL) {
		std::cout << "Failed to create GLFW window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);
	glfwSetKeyCallback(window, key_callback);
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	// 调用任何OpenGL的函数之前初始化GLAD
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return -1;
	}

	init();
	// 输出帮助信息
	printHelp();
	// 启用深度测试
	glEnable(GL_DEPTH_TEST);

	//------------------------------------------------------------------------
	glfwSetMouseButtonCallback(window, mouse_button_callback); // 设置鼠标回调

	int flag = clock();
	while (!glfwWindowShouldClose(window))
	{
		display();

		// 交换颜色缓冲 以及 检查有没有触发什么事件（比如键盘输入、鼠标移动等）
		glfwSwapBuffers(window);
		glfwPollEvents();
		
		//--------------------------------------------------------------------------------
		//处理动画
		int now = clock();
		if (isplaying) {
			// 每1000帧旋转一定的角度
			if ((now - flag) >= rotationTime) {
				if (rotationAxis == X_AXIS) {
					rotateTheta.x += rotateDelta; // 沿X轴旋转
				}
				else if (rotationAxis == Y_AXIS) {
					rotateTheta.y += rotateDelta; // 沿Y轴旋转
				}
				else if (rotationAxis == Z_AXIS) {
					rotateTheta.z += rotateDelta; // 沿Z轴旋转
				}

				flag = now;
			}
		}
	}
	cleanData();

	return 0;
}

2、TriMesh.cpp

#include "TriMesh.h"


// 一些基础颜色
const glm::vec3 basic_colors[8] = {
    glm::vec3(1.0, 1.0, 1.0),	// White
    glm::vec3(1.0, 1.0, 0.0),	// Yellow
    glm::vec3(0.0, 1.0, 0.0),	// Green
    glm::vec3(0.0, 1.0, 1.0),	// Cyan
    glm::vec3(1.0, 0.0, 1.0),	// Magenta
    glm::vec3(1.0, 0.0, 0.0),	// Red
    glm::vec3(0.0, 0.0, 0.0),	// Black
    glm::vec3(0.0, 0.0, 1.0)		// Blue
};

// 立方体的各个点
const glm::vec3 cube_vertices[8] = {
    glm::vec3(-0.5, -0.5, -0.5),
    glm::vec3(0.5, -0.5, -0.5),
    glm::vec3(-0.5,  0.5, -0.5),
    glm::vec3(0.5,  0.5, -0.5),
    glm::vec3(-0.5, -0.5,  0.5),
    glm::vec3(0.5, -0.5,  0.5),
    glm::vec3(-0.5,  0.5,  0.5),
    glm::vec3(0.5,  0.5,  0.5)
};

TriMesh::TriMesh()
{
}

TriMesh::~TriMesh()
{
}

std::vector<glm::vec3> TriMesh::getVertexPositions()
{
    return vertex_positions;
}

std::vector<glm::vec3> TriMesh::getVertexColors()
{
    return vertex_colors;
}

std::vector<vec3i> TriMesh::getFaces()
{
    return faces;
}


std::vector<glm::vec3> TriMesh::getPoints()
{
    return points;
}

std::vector<glm::vec3> TriMesh::getColors()
{
    return colors;
}

void TriMesh::cleanData() {
    vertex_positions.clear();
    vertex_colors.clear();

    faces.clear();

    points.clear();
    colors.clear();

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

void TriMesh::storeFacesPoints() {

    // @TODO: Task-2修改此函数在points和colors容器中存储每个三角面片的各个点和颜色信息
    // 根据每个三角面片的顶点下标存储要传入GPU的数据
     // 清空points和colors容器  
    points.clear();
    colors.clear();

    // 遍历每个面  
    for (const auto& face : faces) {
        // 根据索引获取顶点的位置和颜色  
        unsigned int x = face.x;
        unsigned int y = face.y;
        unsigned int z = face.z;

        glm::vec3 pos1 = vertex_positions[x];
        glm::vec3 col1 = vertex_colors[x];
        glm::vec3 pos2 = vertex_positions[y];
        glm::vec3 col2 = vertex_colors[y];
        glm::vec3 pos3 = vertex_positions[z];
        glm::vec3 col3 = vertex_colors[z];

        // 将顶点位置和颜色添加到points和colors容器中  
        points.push_back(pos1);
        colors.push_back(col1);
        points.push_back(pos2);
        colors.push_back(col2);
        points.push_back(pos3);
        colors.push_back(col3);
    }

}

// 立方体生成12个三角形的顶点索引
void TriMesh::generateCube() {
    // 创建顶点前要先把那些vector清空
    cleanData();

    // @TODO: Task1-修改此函数，存储立方体的各个面信息
    // vertex_positions和vertex_colors先保存每个顶点的数据
    for (int i = 0; i < 8; ++i) {
        vertex_positions.push_back(cube_vertices[i]);
        // 这里简单使用基本颜色数组中的颜色，每个顶点按顺序分配颜色  
        vertex_colors.push_back(basic_colors[i % 8]);
    }
    // faces再记录每个面片上顶点的下标

    // 立方体12个面的顶点索引  
    // 每个面由两个三角形组成  
    faces.push_back(vec3i(1, 3, 7)); // 前面  
    faces.push_back(vec3i(1, 7, 5));
    faces.push_back(vec3i(0, 2, 6)); // 后面  
    faces.push_back(vec3i(0, 6, 4));
    faces.push_back(vec3i(2, 6, 7)); // 右面  
    faces.push_back(vec3i(2, 7, 3));
    faces.push_back(vec3i(0, 4, 5)); // 左面  
    faces.push_back(vec3i(0, 5, 1));
    faces.push_back(vec3i(4, 5, 7)); // 顶面  
    faces.push_back(vec3i(4, 7, 6));
    faces.push_back(vec3i(0, 1, 3)); // 底面  
    faces.push_back(vec3i(0, 3, 2));
    storeFacesPoints();
}



void TriMesh::readOff(const std::string& filename)
{
    // fin打开文件读取文件信息
    if (filename.empty())
    {
        return;
    }
    std::ifstream fin;
    fin.open(filename);
    if (!fin)
    {
        printf("File on error\n");
        return;
    }
    else
    {
        printf("File open success\n");
        cleanData();
        int nVertices, nFaces, nEdges;

        // 读取OFF字符串
        std::string str;
        fin >> str;
        // 读取文件中顶点数、面片数、边数
        fin >> nVertices >> nFaces >> nEdges;
        // 根据顶点数，循环读取每个顶点坐标
        for (int i = 0; i < nVertices; i++)
        {
            glm::vec3 tmp_node;
            fin >> tmp_node.x >> tmp_node.y >> tmp_node.z;
            vertex_positions.push_back(tmp_node);
            //vertex_colors.push_back(tmp_node);
            // 将坐标值([-1,1])映射到颜色值([0,1])
            /*
            //方法1：加1，除2（结果和实验给的一样）
                glm::vec3 color = (tmp_node + glm::vec3(1.0f)) * 0.5f;
             */
            //方法2：取坐标绝对值
            float a = tmp_node.x>0? tmp_node.x:-tmp_node.x;
            float b = tmp_node.y>0? tmp_node.y:-tmp_node.y;
            float g = tmp_node.z>0? tmp_node.z:-tmp_node.z;
            glm::vec3 color(a,b,g);

            vertex_colors.push_back(color);

        }
        // 根据面片数，循环读取每个面片信息，并用构建的vec3i结构体保存
        for (int i = 0; i < nFaces; i++)
        {
            int num, a, b, c;
            // num记录此面片由几个顶点构成，a、b、c为构成该面片顶点序号
            fin >> num >> a >> b >> c;
            faces.push_back(vec3i(a, b, c));
        }
    }
    fin.close();
    storeFacesPoints();
};