C++ TriangleMesh::LoadFile方法代码示例

//Program entry point.
//argc is a count of the number of arguments (including the filename of the program).
//argv is a pointer to each c-style string.
int main(int argc, char **argv)
{

	atexit(cleanup);
	cout << "Computer Graphics Assignment 1 Demo Program" << endl;

	if (argc >  1)
	{
		geom.LoadFile(argv[1]);
	}
	else
	{
		cerr << "Usage:" << endl;
		cerr << argv[0] << " <filename> " << endl;
		exit(1);
	}
	geom.CalculateNormals();

	//initialise OpenGL
	GLFWwindow* window = initialiseGL();

	//create framebuffers
	glGenFramebuffers(1, &frameBuffer);
	glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
	renderTarget = setupTextureGL(NULL, 800, 600, GL_RGBA);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTarget, 0);
	//depth/stencil buffer
	glGenTextures(1, &depthStencil);
	glBindTexture(GL_TEXTURE_2D, depthStencil);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, depthStencil, 0);

	GLenum err = GL_NO_ERROR;
	while ((err = glGetError()) != GL_NO_ERROR)
	{
		printf("%d\n", err);
	}
	//load and compile the shaders
	GLuint objectVertexShader = loadVertexShaderGL("vertex.glsl");
	GLuint objectFragmentShader = loadFragmentShaderGL("fragment.glsl");
	objectShaderProgram = makeShaderProgramGL(objectVertexShader, objectFragmentShader);

	GLuint screenVertexShader = loadVertexShaderGL("postvertex.glsl");
	GLuint screenFragmentShader = loadFragmentShaderGL("postfragment.glsl");
	screenShaderProgram = makeShaderProgramGL(screenVertexShader, screenFragmentShader);

	//transfer the geometry to the GPU
	glGenVertexArrays(1, &objectVertexArray);
	glBindVertexArray(objectVertexArray);
	//create buffers we will use
	glGenBuffers(1, &objectVertexBuffer);
	glGenBuffers(1, &objectElementBuffer);
	glGenBuffers(1, &objectNormBuffer);
	//get geometry vertices, normals and edge lists
	vector <glm::vec3> vert = geom.Vertices();
	vector <glm::vec3> norm = geom.Norms();
	//vector <glm::vec2> uv=geom.UVs();
	vector <Triangle> tri = geom.Triangles();
	//transfer to GPU
	//data for each vertex
	glBindBuffer(GL_ARRAY_BUFFER, objectVertexBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * vert.size(), &vert[0], GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, objectNormBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * norm.size(), &norm[0], GL_STATIC_DRAW);
	//element array (triangles)
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, objectElementBuffer);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, tri.size() * 3 * sizeof(unsigned int), &tri[0], GL_STATIC_DRAW);

	//setup for postprocessing
	glGenVertexArrays(1, &screenVertexArray);
	glBindVertexArray(screenVertexArray);
	//create buffers we will use
	glGenBuffers(1, &screenVertexBuffer);
	glGenBuffers(1, &screenElementBuffer);
	//data for each vertex
	glBindBuffer(GL_ARRAY_BUFFER, screenVertexBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * 4, &screenVertex[0], GL_STATIC_DRAW);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, screenElementBuffer);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2 * 3 * sizeof(GLuint), &screenTri[0], GL_STATIC_DRAW);

	//load the texture
	readTexture();
	texture = setupTextureGL(tex, 256, 256, GL_RGB);


	//main loop
	while (!glfwWindowShouldClose(window))
	{
		DemoDisplay();
		glfwSwapBuffers(window);
		glfwPollEvents();
	}
	glfwTerminate();
//.........这里部分代码省略.........

int main(int argc, char **argv) {
	atexit(cleanup);
    // parse arguments
    char *model_path = NULL;
    char *vertexshader_path = NULL;
    char *fragmentshader_path = NULL;
    char *texture_path = NULL;
    bool use_smoothed_normals;
    if (argc >= 6) {
        texture_path = argv[5];
        useTexture = 1;
    }
	if (argc >= 5) {
        model_path = argv[1];
        vertexshader_path = argv[2];
        fragmentshader_path = argv[3];
        use_smoothed_normals = *argv[4] != '0';
	} else {
        std::cerr << "Usage:" << std::endl;
        std::cerr << argv[0]
             << " <model::path> "
             << " <vertex-shader::path> "
             << " <fragment-shader::path> "
             << " <smooth-normals::{0,1}>"
             << " (<texture::path>)"
             << std::endl;
		exit(1);
	}
	// initialise OpenGL
	glutInit(&argc, argv);
	glutInitWindowSize(windowX, windowY);
	glutCreateWindow("CG-CW1");
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
    glEnable(GL_DEPTH_TEST);
    // set display and keyboard callbacks
	glutDisplayFunc(display_handler);
    glutKeyboardFunc(keyboard_handler);
	// initialise the OpenGL Extension Wrangler library for VBOs
	GLenum err = glewInit();
	if (err != GLEW_OK){
        std::cerr << "Error!" << std::endl;
		exit(1);
	}
	if (!GLEW_VERSION_2_1) {
        std::cerr << "Error 2.1!" << std::endl;
		exit(1);
	}
	// create shader, prepare data for OpenGL
    trig.LoadFile(model_path);
	shader.Init(vertexshader_path, fragmentshader_path);
    setup_texture(texture_path, &textureID);
	setup_vertex_position_buffer_object();
	setup_vertex_uv_buffer_object();
    setup_vertex_normal_buffer_object(use_smoothed_normals);
	// set up camera and object transformation matrices
	projectionMatrix = get_default_projectionMatrix();
	viewMatrix = get_default_viewMatrix();
	modelMatrix = get_default_modelMatrix();
    normalMatrix = get_default_normalMatrix();
	glutMainLoop();
}