[175 points] The purpose of this assignment is to give you practice with shaders in OpenGL.

Transcription

1 CPSC 441 Computer Graphics Assignment 5 due 11/20/18 (11:59 p.m.) [175 points] The purpose of this assignment is to give you practice with shaders in OpenGL. Part 1: First, download and get the code itself to run. Below is a brief explanation of the source code; you will want to examine it yourself to ensure you understand it: You will not see any output when you first run your code. There are 3 files you will work with: o main.cpp is the main file. In this file, you will want to edit the sendattributes function (beginning line 181). You will want to fill in the information in this function. o vert.glsl is the vertex shader. You will be filling this in as part of the assignment. o frag.glsl is the pixel (fragment) shader. You will be filling this in as part of the assignment. First look at the overall structure of main.cpp. o There are several classes/functions/structs defined: A face (line 17) is a triangle it stores the indices of the 3 vertices making up the triangle. It also stores the texture coordinates and normal (note that texture coordinates are not required to be used). The objreader (line 27) is a function that will read in basic (not every).obj files, which is a common file format for storing models. It will store the vertices and faces in global vectors. The Program class (line 92) is a class used to define shader programs. It will be described below. The KeyCallbackFunc (line 319) is where you can fill in your code for responding to key presses. The WindowSizeCallbackFunc (line 324) is called if the window size changes. You may wish to put your code to change the view/projection matrix in this routine. o There are some global variables defined: The window, along with its width and height A vector of vertices and a vector of faces A sample_program (line 317). This will be the shader program that compiles and runs the vertex and pixel shaders. You will likely want to create other global programs to go with this. Look at the main function in main.cpp. This routine should now make sense to you: o The init routine (line 331) is called to initialize various parameters. This will be discussed below. o Then, there is a check to make sure you have the right number of command-line arguments. There should be either 1 or 2 arguments given: (the first being the.obj file, and the second being the optional texture).

2 o Next, there are two sample lines (THAT YOU WILL WANT TO DELETE EVENTUALLY) that set up a view matrix, mat with an initial view to the vertex shader (the senduniform command), and that sends per-vertex attributes (the sendattributes command). o Then, as long as it is not time to close the main window, the following happens repeatedly: The window is cleared. Notice that there are two bits used in the glclear command: one for the color buffer, one for the depth buffer. These are flags, combined with a bitwise or. This command clears out the current ( working ) image buffer and depth buffer. Then, display is called, which if you look at the display function (just above main), simply calls the display member function of the sample_program. This is defined in lines Next, the buffers are swapped. This will make the working image buffer the display image buffer (and the one that was being displayed is, for now, the working buffer). And, then we poll to see if any events occurred. Any events have their corresponding callback function called. Now look at the init function in main.cpp. o The first several lines just set up the window itself, using glfw (you will want to put your name in the window title), and initializing glew. o The glviewport command sets the area of the window to draw into (in this case, the whole window). o The glclearcolor sets the color that the window should be cleared to (in this case, white so, when glclear is called, the image buffer is set to all white). Note that you could change this to black (or some other color) if you wish. o The next two lines enable depth testing (i.e. they turn on Z-buffering) and texture mapping. o The next two lines register the callback functions to use when there is a keypress event or a window-size-change event. o Finally, the init command creates the sample_program using the vert.glsl and frag.glsl shaders. Note that you could create other, different Programs here, with different vertex and pixel shaders. Within the Program class, there are several key member functions. o Create is used to create a new shader program using the vertex and pixel shaders passed in as parameters (these are vert.glsl and frag.glsl in the example). You may want to look through the lines of create most (though probably not every line) should be something you can make sense of. o The sendattributes function will be a key one that you will fill in. It contains a data_buffer that will be used to store the triangle information (see the comments for the structure). It also has commands (lines ) so that, once you have filled in the data buffer, OpenGL will use that buffer information to send the vertices and normal on to the shader program. You will need to call sendattributes to send vertex attributes on to the shader.

3 o The senduniform functions (several overloaded versions are provided) are used to send uniform variables to the vertex shader. Uniform variables do not vary by vertex or over the triangle. You should use senduniform to send a variable of some type on to the shader programs you call senduniform and then within the shader program, you will need to declare a corresponding uniform variable. o The display function is called to display the current scene. Now look at the file vert.glsl. This is the vertex shader program. It is initially a simple program, that does the following: o The uniform designation refers to a variable that will be brought in identically to all versions of the shader program. In this case, that s the matrix (for handling view transformations). It is expecting you to send it a uniform mat4 (i.e. a 4x4 matrix) with the name mat o The attribute designation refers to variables that are set for each vertex. These will be different for each vertex. In this case, these are the position and normal, which were obtained from the data_buffer that was set in the main program (in the sendattributes member function). o The varying designation is a way to declare a variable that will be interpolated into the pixel shader. These variables should be set in the vertex shader, and then they are interpolated across the triangle, and can be accessed in the pixel shader. In this case, there are two such variables a 3D vector vnor and a 3D vector vpos. o The code itself just does two things. First, it sets the varying variables vnor and vpos to equal the Normal and Position that were passed in as vertex attributes: Nor andpos. vnor and vpos will be interpolated across the triangle and passed on to the pixel shader. Then, it sets gl_position to be the uniform matrix that was passed in, mat, times the 3D position of the vertex (the vertex attribute, Pos). That is, it is applying the transformation matrix to the point to get the final position. Finally look at the file frag.glsl. This is the pixel (fragment) shader. It is initially a simple program that does the following: o The varying designation refers to a value that is going to be interpolated across the triangle from the vertex data. In this case, since we set the vertex normal vnor to be varying in the vertex shader, the values set for each vertex by the vertex shader are interpolated to the individual pixel being processed by this fragment shader. o The uniform designation indicates a value that does not vary. In this case, there are two such attributes the position of a light, and the position of the eye. Note that these are not actually set in the program, currently: you will have to set them yourself. They are included here just for demonstration.

4 o The code itself sets the color of the pixel (fragment). This is done by assigning to the gl_fragcolor an RGBA value. In this case, the color of the pixel is set to be blue. Be sure to spend sufficient time reviewing the skeleton code that you understand how the various parts are working together. Part 2: From the skeleton code that was provided, you are to write a program that will read in a.obj file, and will render it using Phong shading. You will need to do the following, though the order in which you do them is up to you. You are strongly encouraged to use an iterative development process. That is try to make one small change at a time, and ensure it is working before you try to implement the next part of the program. If you try to do too many things at once, you will almost certainly have your program fail, and will have great difficulty debugging! For example, you might want to first ensure that you can create a single triangle and render it using the existing shaders before trying to modify shaders, read more data, etc. And, you should likely ensure you can perform Gouraud shading before you try implementing Phong shading. Specifically, here are the things you will need to do: You should set up an appropriate transformation matrix that allows you to see the model(s) that you load. This should take into account the view transformations that are needed. Note that you will need to pass this matrix on to the vertex shader e.g. the initial vert.glsl program is expecting a matrix mat to be provided, and the skeleton code does not yet do this. o Note: you might originally start with a fixed view, such as the one provided, but for full credit, your view should adjust to allow the whole.obj file to be viewed. You should read in a.obj file and use it for the triangles that you render. Note that a function to read a.obj file into vertex and face arrays is provided. You will need to read in the file, and then convert those vertices and faces into the data that will be passed to the shaders. Note that there is an outline in the sendattributes function that describes part of what needs to be done. o For setting normals, you can initially begin by setting the normal to be the normal of the triangle itself. Recall that you can find a triangle normal by taking the cross product of the vectors along two edges. This should be the default and should correspond to hitting the key 1. o For full credit, you should create a smoothly varying model by setting the vertex normal equal to the average of the normal of all the faces incident on that vertex. Note that this will make that vertex appear smooth, and there may be

5 some models where you want sharp edges so that a smooth vertex does not look correct. This should correspond to hitting the key 2. o Note (for bonus): in practice, the normals are provided WITHIN the.obj file itself. The basic reader provided here does not read in normals, but you may modify it to read in normals from the file. To do this you will need to read about the.obj file format and modify the reader (or write your own) to read in normal. This should correspond to hitting the key 3. Note that you will want to call sendattributes again each time the way to compute normal changes. You should add lights to your scene, and perform lighting calculations. In the end, you should have: o At least 3 point lights and ambient light in the scene. o Some sort of material property that includes ambient, diffuse, and specular material characteristics. It should be clear that these properties are set for the model. Your README file should state what your material parameters are. You should be able to use any of 4 different shader programs, by hitting the Q, W, E, and R keys. Specifically, the four shaders should be: o Q : Flat shading that colors the polygons a single color (based on calculating lighting at the center point or one vertex per triangle). Note that you will want to perform the color calculation itself in the main C++ program (rather than in the shaders) and pass in the color as a vertex attribute. o W : Gouraud Shading calculate color per vertex and interpolate colors to pixels. o E : Phong Shading calculate color per pixel by interpolating normals o R : Shader of your choice: Make an interesting shader that highlights something. Your grade here will be based on the complexity and interestingness of the shader (e.g. a blue shader is not interesting). Examples you might consider are silhouette shaders or toon shaders. Remember that when dealing with vectors, you want to ensure they are normalized in most cases. You should allow the user to: o Change the position of the model and/or the lights. Changing the model/lights should result in an obvious change in the diffuse and specular portions of the model. You should use the A and (if desired) S keys to make these changes; the way the model or lights change position is up to you, but it should be an obvious change as you press keys. o Change the direction of the view. Changing the view direction should change the specular effect but not the diffuse effect on the model. Use the Z and (if desired) X keys to change the view direction (e.g. rotate view around the center). Again, the specific way your key(s) move the view is up to you but it should be an obvious specular change as you move it. You should include in your README file the ways that you can vary the view and lighting and/or model.

6 For bonus credit: put in a falloff of the lighting and/or a spotlight effect of lighting. Document exactly what you have done in your readme file, and ensure that the effect of your improvements are obvious to a user. For bonus credit: read and display multiple.obj files at once, with different material properties for each. Document exactly what you have done in your readme file. Your program should still run with the default command line arguments, but you might take more arguments, for instance. Note that you will need to pass more information to the shader programs than what is in there now! Grading: [10 points].obj file is read in [10 points] Vertex normals are set at least from triangles (option 1 ) [15 points] Vertex normals are set by averaging triangles (option 2 ) [10 points] Basic view can render some object and see the geometry [15 points] View is set up to allow view of entire model that is read in. [15 points] Change of model and/or lighting is supported (options A and S ) [15 points] Change of view direction is supported (options Z and X ) [10 points] Lights are set up in the scene. [10 points] Material properties are set for the object. [20 points] Ambient, Diffuse, and Specular lighting are computed correctly in flat/gouraud/phong shaders [10 points] Flat Shader implemented correctly (option Q ) [10 points] Gouraud Shader implemented correctly (option W ) [10 points] Phong Shader implemented correctly (option E ) [15 points] New/interesting Shader implemented (option R ) [15 points] Bonus: vertex normals are read from.obj file (option 3 ) [15 points] Bonus: reading in multiple.obj files [15 points] Bonus: light falloff and spotlight effects (partial bonus for either)

7 Honors students: Alternative work You should modify the program as described above in order to bring in texture mapping. This involves several items: You will need to read texture coordinates in when you read in the.obj file. Alternatively (for less credit), you may set the texture coordinates manually. You will need to load in an image to use for texture mapping. You may use the.bmp reader provided earlier. You will need to change the data buffer to incorporate texture coordinates, in addition to position and normal of each vertex. You will need to use the texture color in your fragment calculation. You should use the texture color in place of the ambient and diffuse reflection coefficients (though you should scale the color appropriately for the ambient and diffuse terms). You should still use an externally set specular term per object, in this case. You do not have to do the following parts of the base assignment if you do texture mapping: - Ensuring the view takes into account the entire model - Changing view direction ( Z / X keys) Grading: Incorporating texture mapping is worth 50 points, and replaces the material properties set, basic view, view direction is set up to allow view of entire model, and change of view direction is supported portions of the grade. Honors students may do those other portions for a 20 point bonus. Non-honors students may include texture mapping as for a 20 point bonus.