GPU Programming EE Practice Midterm Examination

Transcription

1 Name Solution GPU Programming EE Practice Midterm Examination This practice exam has been made a little longer than the actual midterm is expected to be. Also, some questions are expected to be answered using references, whereas on the actual midterm all needed information will be provided. Alias Practice Exam Total (100 pts) Good Luck!

2 Problem 1: A scene contains a light at position L and a vertex at position V. The scene contains a plane which includes point P 0 and has normal n. The scene also contains a circle of radius r with the center at C, and with normal m. (a) Let P be the point on the plane where the vertex casts a shadow. Find an expression for P. This is a simple line/plane intercept problem. To find the shadow consider a line passing through L and V. Let P be the point where the line passes through the plane (assuming it does). P will be the shadow location if V is between L and P. Let LV be the vector from L to V. The parametric equation of the line through L and V is then P = V + tlv, where t is the parameter. If P is on the plane then PP 0 is orthogonal to the plane normal, n and so PP 0 n = 0. Substituting for P yields (V + t LV )P 0 n = 0 (P 0 V t LV ) n = 0 V P 0 n tlv n = 0 Substituting t in the line equation gives the possible shadow location: t = V P 0 n LV n V P = V + P 0 n LV. LV n (b) For what value of r will the shadow cast by V be exactly on the circle perimeter. Hint: Simple once the previous part solved. This is another line plane intercept problem. Find the point at which the line defined by the vertex and light intercepts the plane containing the circle, call that point A. Then r is just the distance between A and C. 2

3 Problem 2: A scene contains a moving sphere of radius r with center at S(t) = S 0 + tv, where t is the time, S 0 is the position at t = 0, and D is the velocity. The scene also contains a cube with which the sphere may collide. The cube center is at C, a side of the cube has length a, and the face normals are ±ˆn 1, ±ˆn 2, and ±ˆn 3. Hint: From that information we can determine that a point on one of the faces is C + a 2 ˆn 1, a point on one of the edges is C + a 2 ˆn 1 + a 2 ˆn 2 and one of the corners is C + a 2 ˆn 1 + a 2 ˆn 2 + a 2 ˆn 3. (a) Describe the three ways the sphere can collide with the cube. Each will require solving a different kind of geometric problem. The ball can collide with a face (sphere/plane collision), an edge (sphere/line collision), or a corner (sphere/point collision). The brute-force way to determine collision time is to find the collision time with each of the six faces, 12 edges, and four corners, and then use the smallest such time. (b) Write expressions for collision time with each type of element (assuming they do collide). Hint: One of these is a solution to a prior problem. Note: This problem is harder than I would ask on a real exam. On a real exam I might ask for expressions indicating how close the sphere is to each type of element at a particular time (with a distance of zero or perhaps less than r indicating contact). We need expressions for when the sphere will hit a plane (cube face), line (cube edge), and point (cube corner). The path of the center of the sphere forms the line S(t) = S 0 + td. Let Q be a point on a corner of the cube, Q = C + a 2 ˆn 1 + a 2 ˆn 2 + a 2 ˆn 3. The plane collision will be shown for the face containing Q and normal n 1. For the line collision it will be the edge touching Q and in direction n 1, and for the corner collision the point Q. At time t the sphere center will be at S(t), at the time of impact the sphere will be distance r from the plane, so we will solve the plane/line intercept problem for a plane moved distance r from the cube, that moves Q to Q p = Q+rˆn 1 ; the plane normal is still n 1. Using the solution to the line/plane intercept from the previous problem we find the collision time. t = S 0 Q p n 1 D n 1 For the corner collision we need to find the time the sphere is at distance r from a corner. This is equivalent to asking when the center of the sphere intercepts a sphere of radius r centered on Q. When S(t) is a distance r from Q then QS(t) = r, or QS(t) QS(t) = r 2. Substituting for S(t): Solving for t:. QS(t) QS(t) = r 2 (S 0 + td Q) (S 0 + td Q) = r 2 ( QS 0 + td) ( QS 0 + td) = r 2 QS 0 QS 0 + 2QS 0 td + t 2 D D = r 2 t = 2 QS 0 D ± (2QS 0 D) 2 4(D D)( QS 0 2D D QS 0 r 2 ) The sphere will collide with the corner if the discriminant is non-negative, that is (2QS 0 D) 2 4(D D)( QS 0 QS 0 r 2 ) 0. If it s positive there are two solutions, the one to use is either the smaller one, or the smaller non-negative positive one. 3 (1)

4 For an edge collision we need to find the time the sphere is at a distance r from the edge. The edge is on the line Q(u) = Q+un 1. Suppose D n 1 = 0. That would mean the closest point on the line to the sphere is fixed, so we could just use the line/sphere intercept time solution, (1). Find a new sphere velocity D in which the velocity component in the direction of n 1 is removed: D = D (D n 1 )n 1. It should be easy to verify that D n 1 = 0. Since only velocity in the direction of n 1 was removed from D spheres following S(t) = S 0 + td and S (t) = S 0 + td should be at distance r at the same time. So just solve (1) substituting D for D. (c) It s possible the sphere never collides with the cube. Show a computationally inexpensive way to test for this possibility. For this find the time of closest approach to either the center of the cube or a corner. If the time is based on the center then collision is impossible if the sphere center never comes closer than 3/4a + r. To test for that inexpensively evaluate argument to the square root in (1) but replace r with 3/4a + r and Q with C: (2CS 0 ) 2 4(D D)( CS 0 CS 0 ( 3/4a + r) 2 ) (2) If this quantity is negative the sphere cannot touch the cube, if its zero or positive it might hit the cube and so specific collisions must be tested for. Note that ( 3/4a+r) 2 can be precomputed, though quantities like S 0 are might be changed elsewhere in the simulation. 4

5 Problem 3: A scene contains a tray upon which are cups. On the next page is code that renders the scene using a Tray class and a Cup class. A tray object can hold multiple cups. Each object provides an array of vertices that describes its appearance (but not contained objects). So, for example, tray->vtx_array_pointer returns vertices that form a tray, but not the cups upon it. The vertices are in the object s own coordinate space. The location member gives the location of an object in its parent s coordinate space. So cup->location is a coordinate in the tray s coordinate space. See the code on the next page. (a) The code sets the correct modelview matrix for rendering the tray, but code for setting the modelview matrix for the cup is not finished. Finish it. The solution appears below. Note that the mtray transformation matrix is multiplied. pmatrix mcup = mtray * ptranslate(-cup->location) * cup->orientation; (b) Changing a transformation is relatively time consuming, especially when it s only done for a few vertices, as might be the case with the cup at the center of the loop nest. Show how to compute cup vertex coordinates for which the modelview matrix set for the tray is sufficient. That is, find a transformation matrix for the code below that will make the glloadtransposematrixf(mcup) call unnecessary (but the glloadtransposematrixf(mtray) will still be needed). pmatrix matrix = ptranslate(-cup->location) * cup->orientation; // SOLUTION \endsol \beginlit for( int i=0; i<cup->vtx_cnt; i++ ) cup->vtx_array_pointer_new[i] = matrix * cup->vtx_array_pointer[i]; (c) If the loop from the previous part were executed each time show_tray was called, execution would probably be slower despite the fact that the transformation matrix is not changed as often. Explain why. The GPU can perform the matrix multiplication faster than the CPU, so running the loop above might take more time than is saved by not having to change transformation matrices. 5

6 Problem 3, continued: The code for rendering tray and cups: void show_tray() { // Location of tray in world coordinate space. pcoor tray_location = tray->location(); // Matrix that rotates tray coordinates (in tray space) to correct // position in world coordinate space. pmatrix tray_orientation = tray->orientation(); // Note: modelview is the current modelview matrix, which maps // world coordinates to eye coordinates. glmatrixmode(gl_modelview); pmatrix mtray = modelview * ptranslate(-tray_location) * tray_orientation; glloadtransposematrixf(mtray); glvertexpointer(3,gl_float,0,tray->vtx_array_pointer); glenableclientstate(gl_vertex_array); gldrawarrays(gl_triangles,0,tray->vtx_cnt()); while ( Cup* cup = tray->contents_iterate() ) { // Render one cup that s on the tray. // Location of cup in tray coordinate space. pcoor location = cup->location; // A rotation matrix that will rotate the cup into the correct // position in tray coordinate space. pmatrix orientation = cup->orientation; glmatrixmode(gl_modelview); pmatrix mcup = ; // SOLUTION HERE. glloadtransposematrixf(mcup); } } glvertexpointer(3,gl_float,0,cup->vtx_array_pointer); glenableclientstate(gl_vertex_array); gldrawarrays(gl_triangles,0,cup->vtx_cnt()); 6

7 Problem 4: Write OpenGL code that renders a simple cup (a hollow cylinder with one end covered). The cup center is at the origin. The radius of the cup is 11 (in world space coordinates). The cup is upright (up is (0,1,0)), and has a height of 22. Include vertices and normals. Ignore colors and lighting. The code should be reasonably efficient. Solution appears below. const int sides = 10; const double delta_theta = 2 * M_PI / sides; // Cylinder glbegin(gl_quad_strip); for ( double theta = 0; theta <= two_pi; theta += delta_theta ) { const double cos_th = cos(theta); const double rcos_th = r * cos_th; const double sin_th = sin(theta); const double rsin_th = r * sin_th; pvect normal( cos_th, 0, sin_th ); glnormalf( cos_th, 0, sin_th ); glvertex3f( rcos_th, 0, rsin_th ); glvertex3f( rcos_th, height, rsin_th ); } glend(); // Circle glbegin(gl_triangle_fan); glnormalf(0,1,0); glvertex3f(0,0,0); for ( double theta = 0; theta <= two_pi; theta += delta_theta ) { const double cos_th = cos(theta); const double rcos_th = r * cos_th; const double sin_th = sin(theta); const double rsin_th = r * sin_th; glvertex3f( rcos_th, 0, rsin_th ); } glend(); 7

8 Problem 5: A scene contains a wall that has letters (forming some text) cut out of it. The wall itself is dark gray and behind the wall are light-colored objects, which you can see through the holes forming the letters. You are given a texture with the text (say, the EE 4702 syllabus) where the letters (the ink) are black and opaque (α = 1) and the background is transparent (any color, α = 0). The command glbindtexture(gl_texture_2d,texid_text); will bind this texture to a texture unit. Describe how to achieve this effect using a texture, the stencil buffer, and an alpha test. See section 4.1 of the OpenGL 3.0 specification for details on how the alpha and stencil test relate. If this weren t a practice exam more details would be given. Assume the code wall->render() will send wall vertices to OpenGL and other->render() will send vertices of other parts of scene to OpenGL. The solution appears below. In the first pass the stencil buffer is written with a 1 wherever there is ink. Ink is detected using the alpha test. If the fragment s alpha value is not 1 it fails the alpha test (and so the stencil buffer isn t written). The stencil test in pass 1 always fails (if its reached). The glstencilop tells OpenGL to replace the existing stencil value with our own when the stencil test fails (the other two arguments are for depth test fail and pass). The gltexenvi call tells OpenGL not to blend the texture with the wall, so we don t have to worry about the texel alpha values changing. In pass 2 the stencil test is set up to reject fragments if the stencil buffer is 1 (and so there will be no wall where there was ink). The glalphafunc command turns off the alpha test (which is normal) and gltexenvi specifies a typical texture blending function. Also a different texture is used, perhaps one that looks like concrete. // Pass 1: // Write a 1 in stencil buffer at "ink" locations, // ink is present if texel alpha value is 1. // glalphafunc(gl_equal,1.0); // Reject if alpha!= 1. glstencilfunc(gl_never,1,-1); // Stencil func fails, so pixel not written.. glstencilop(gl_replace,gl_keep,gl_keep); //..but replace stencil val w. 1. glbindtexture(gl_texture_2d,texid_text); // Use texture with text. gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE,GL_REPLACE); // No lighting. glenable(gl_texture_2d); wall->render(); // Pass 2: // Render wall wherever stencil value is not 1. // Use real wall texture, not the text. glalphafunc(gl_always,1.0); // Alpha test always passes. (Normal setting.) glstencilfunc(gl_notequal,1,-1); // Pass if stencil is not 1. glstencilop(gl_keep,gl_keep,gl_keep); // Don t change stencil buffer. gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE,GL_MODELVIEW); // Use lighting. glbindtexture(gl_texture_2d, some_other_texture_id); // Wall s real texture. wall->render(); 8

9 Problem 6: Determine the best lighting type (emissive, ambient, diffuse, specular) to use for each of the following situations, and explain your reason. (a) A triangle out in space illuminated only by a nearby star. Diffuse lighting, with only the quadratic attenuation set to a non-zero value. (b) A computer monitor screen (turned on, working properly). Emissive. (c) A glossy sphere. Specular. (d) A triangle in a room with white walls and many light sources. Ambient. 9

10 Problem 7: Answer each question below. (a) OpenGL defines several ways to combine texels with the lighted color to obtain the final color to write. Why does one need to combine a texel with a lighted color, why not just write the texel? Combining with the lighted color provides realistic lighting, for example, a darker appearance with distance or angle from light. (b) What is the advantage of using TRIANGLE_STRIPS over TRIANGLES? With triangle strips a vertex is shared by up to three triangles, so one avoids having to waste time duplicating calculations. 10