Computer Graphics Programming In OpenGL With JAVA 2nd Edition V. Scott Gordon PhD, John L. Clevenger PhD - Solutions

Discover a comprehensive collection of resources for "Computer Graphics Programming In OpenGL With JAVA 2nd Edition" by V. Scott Gordon PhD and John L. Clevenger PhD. Access the complete solutions manual and answers key to enhance your understanding of the textbook. Unlock step-by-step answers to the solved problems and explore detailed chapter solutions. Ideal for students, instructors, and enthusiasts, this repository includes a test bank and instructor manual to support your learning journey. Enjoy the convenience of online solutions and free download options, providing you with essential questions and answers in PDF format.

Convert Program 4.2, specifically the modified version with 100,000 cubes, to both anaglyph and side-by-side stereoscopy.Program 4.2Figure 4.8 Vertex Shader: #version 430 layout (location=0) in vec3 position; uniform mat4 v_matrix; uniform mat4 p_matrix; uniform float tf; out vec4 varyingColor; $void main(void) { float x = gl_InstanceID + +tf; float a = sin(.35*x) * 8.0; float b = sin(.52 * x) * 8.0;$
Modify Program 17.1 to try a variety of different values for the IOD. What range of values do you think works the best for this scene? What happens if the IOD is set too small? What do you observe as the IOD increases, and then what happens when the IOD is set too large?Program 17.1 Java/JOGL
In Program 4.1, the “view” matrix is defined in the display() function simply as the negative of the camera location:Replace this code with an implementation of the computation shown in Figure 3.13. This will allow you to position the camera by specifying a camera position and three orientation
Modify Program 4.4 to include a second “planet,” which is your custom 3D shape from Exercise 4.1. Make sure that your new “planet” is in a different orbit than the existing planet, so that they don’t collide.Exercise 4.1Modify Program 4.1 to replace the cube with some other simple 3D
In Program 9.2, add the ability to move the camera around with the mouse or keyboard. To do this, you will need to utilize the code you developed earlier in Exercise 4.2 for constructing a view matrix. You’ll also need to assign mouse or keyboard actions to functions that move the camera forward
Modify Program 4.1 to replace the cube with some other simple 3D shape of your own design. Be sure to properly specify the number of vertices in the glDrawArrays() command.Program 4.1 Java/JOGL Application import java.nio.*; import javax.swing.*; import java.lang.Math;
In Program 8.1, experiment with different settings for glPolygonOffset(), and observe the effects on shadow artifacts such as Peter Panning.Program 8.1 // Much is the same as we have seen before. New sections to support shadows are highlighted. // The imports necessary for lighting, etc., would be
Modify Program 2.5 to include the error-checking modules shown in Program 2.3. After you have that working, try inserting various errors into the shaders and observing both the resulting behavior and the error messages generated.Program 2.3Program 2.5 import com.jogamp.opengl.glu.GLU; private void
Modify Program 8.1 so that the light can be positioned by moving the mouse, similar to Exercise 7.1. You will probably notice that some lighting positions exhibit shadow artifacts, while others look fine.Program 8.1 // Much is the same as we have seen before. New sections to support shadows are
Modify Program 2.6 so that it calculates the amount of movement for the triangle based on elapsed time, rather than a constant amount as it is currently implemented. One approach for this is to get the current time from Java, and use it to calculate the elapsed time since the previous call to
Add animation to Program 8.1, such that either the objects or the light (or both) move around on their own—such as one revolving around the other. The shadow effects will be more pronounced if you add a ground plane to the scene, such as the one illustrated in Figure 8.14.Program 8.1Figure 8.14
Modify Program 2.5 so that the vertex shader includes one of the buildRotate() functions from Program 3.1 and applies it to the points comprising the triangle. This should cause the triangle to be rotated from its original orientation. You don’t need to animate the rotation.Program 2.5Program 3.1 $Vertex Shader #version 430 void main(void) { if (gl_VertexID == 0) gl_Position = vec4( 0.25, -0.25, 0.0,$
Modify Program 5.1 by adding the “noperspective” declaration to the texture coordinate vertex attributes, as described in Section 5.11. Then rerun the program and compare the output with the original. Is any perspective distortion evident?Program 5.1Section 5.11We have seen that as texture
Modify Program 2.5 so that it draws an isosceles triangle.Program 2.5 Vertex Shader #version 430 void main(void) { if (gl_VertexID== 0) gl_Position = vec4( 0.25, -0.25, 0.0, 1.0); else if (gl_VertexID == 1) gl_Position vec4(-0.25, -0.25, 0.0, 1.0); else gl_Position=vec4(0.25, 0.25, 0.0, $Vertex Shader #version 430 void main(void) { if (gl_VertexID == 0) gl_Position = vec4( 0.25, -0.25, 0.0,$
Modify Program 4.4 so that the “view” matrix is constructed using the “look-at” function. Then experiment with setting the “look-at” parameters to various locations, such as looking at the sun (in which case the scene should appear normal), looking at the planet, or looking at the
Learn the basics of how to use Terragen [TE16] to create a simple cube map. This generally entails making a “world” with the desired terrain and atmospheric patterns (in Terragen), and then positioning Terragen’s synthetic camera to save six images representing the front, back, right, left,
At the end of Section 3.4 we indicated that Euler angles can in some cases lead to undesirable artifacts. The most common is called “gimbal lock.” Describe gimbal lock, give an example, and explain why gimbal lock can cause problems.Section 3.4In graphics, matrices are typically used for
One way of avoiding the artifacts that can manifest when using Euler angles is to use quaternions. We didn’t study quaternions; however, JOML includes a Quaternionf class. Do some independent study on quaternions, and familiarize yourself with the related JOML Quaternionf class.
Propose a practical use for glCullFace(GL_FRONT_AND_BACK).
Replace the positional light in Program 7.2 with a “spot” light, as described in Section 7.2. Experiment with the settings for cutoff angle and falloff exponent, and observe the effects.Program 7.2Section 7.2There are many types of lights, each with different characteristics and requiring
Modify Program 7.2 so that it incorporates TWO positional lights, placed in different locations. The fragment shader will need to blend the diffuse and specular contributions of each of the lights. Try using a weighted sum, similar to the one shown in Section 7.6. You can also try simply adding
Modify Program 8.2 to replace the hardcoded values 0.001 in the lookup() function, with the more accurate values of 1.0/shadowbufferwidth and 1.0/shadowbufferheight. Observe to what degree this change makes a difference (or not) for various window sizes.Program 8.2 Fragment Shader #version 430 //
Modify Program 9.3 so that the object in the scene blends environment mapping with a texture. Use a weighted sum in the fragment shader, as described in Chapter 7.Program 9.3 public void display(GLAutoDrawable drawable) { // the code for drawing the cube map is unchanged. // the changes are all in
More sophisticated implementations of percentage closer filtering (PCF) take into account the relative distance between the light and the shadow versus the light and the occluder. Doing this can make soft shadows more realistic, by allowing their penumbra to change in size as the light moves closer
Draw labels on the six cube map image files to confirm that the correct oriention is being achieved. For example, you could draw axis labels on the images, such as the following:Also use your “labeled” cube map to verify that the reflections in the environment-mapped torus are being rendered
Experiment with Program 10.1 by modifying the settings and/or computations in the fragment shader and observing the results.Program 10.1 Vertex Shader #version 430 // same as Phong shading, but add this output vertex attribute: out vec3 original Vertex;
Using a paint program, generate your own height map and use it in Program 10.4. See if you can identify locations where detail is missing as the result of the vertex shader being unable to adequately sample the height map. You will probably find it useful to also texture the terrain with your
Add lighting to Program 10.4, so that the surface structure of the height-mapped terrain is further exposed.Program 10.4 #version 430 layout (location=0) in vec3 vertPos; layout (location=1) in vec2 texCoord; layout (location=2) in vec3 vertNormal; out vec2 tc; uniform mat4 mv_matrix; uniform mat4
Add shadow mapping to your code from Exercise 10.3 so that your height-mapped terrain casts shadows.Exercise 10.3 // variables and structs as in previous fragment shader, plus: // normal map // texture layout (binding=0) uniform sampler2D s0; layout (binding-1) uniform sampler2D s1;
A quadratic Bézier curve is limited to defining a curve that is wholly “concave” or “convex.” Describe (or draw) an example of a curve that bends in a manner that is neither wholly concave nor convex, and thus could not possibly be approximated by a quadratic Bézier curve.
Using a pen or pencil, draw an arbitrary set of four points on a piece of paper, number them from 1 to 4 in any order, and then try to draw an approximation of the cubic Bézier curve defined by those four ordered control points. Then rearrange the numbering of the control points (i.e., their
Modify Program 2.2 to add animation that causes the drawn point to grow and shrink, in a cycle. Hint: use the glPointSize() function, with a variable as the parameter.Program 2.2 (.....imports as before) public class Code extends JFrame implements GLEventListener { private int rendering
Convert Program 12.5, the tessellated moon surface, to both anaglyph and side-by-side stereoscopic rendering. Animate the camera movement so that it skims along and close to the moon surface.Program 12.5 Tessellation Control Shader void main(void) {float subdivisions = 16.0; // tunable constant
Modify Program 16.13 to build a scene with a transparent sphere and a transparent box, both of different colors. Include the vertical checkerboard plane behind them as a backdrop. Experiment with the color blending approaches described in Section 16.3.6. Which approach worked best in your
In Figure 16.28 (the center image), the Sugita/Takehashi blending of red and green produces black. Is this a reasonable result? If not, can you devise a workaround that doesn’t compromise other color blends?Figure 16.28 Program 16.16- Sugita/Takehashi blending I 0 X Program 16.16-Sugita/Takehashi
Repeat Exercise 7.1, but applied to Program 7.2. This should only require substituting the shaders for Phong shading into your solution to Exercise 7.1. The improvement from Gouraud to Phong shading should be even more apparent here, when the light is being moved around.Exercise 7.1Modify Program
Modify Program 7.1 so that the light can be positioned by moving the mouse. After doing this, move the mouse around and note the movement of the specular highlight and the appearance of the Gouraud shading artifacts. You may find it convenient to render a point (or small object) at the location of
Learn the basics of how to use Blender to create a 3D object of your own. To make full use of Blender with your OpenGL applications, you’ll want to learn how to use Blender’s UV-unwrapping tools to generate texture coordinates and an associated texture image. You can then export your object as
Modify your program from Exercise 6.1 so that the imported NASA shuttle object from Figure 6.16 also orbits the “sun.” You’ll want to experiment with the scale and rotation applied to the shuttle to make it look realistic.Figure 6.16Exercise 6.1Modify Program 4.4 so that the “sun,”
Modify Program 4.4 so that the “sun,” “planet,” and “moon” are textured spheres, such as the ones shown in Figure 4.11.Program 4.4Figure 4.11 private Matrix4fStack mvStack = new Matrix4fStack(5); public void display(GLAutoDrawable drawable) { // setup of background, depth buffer,
Using a simple “paint” program (such as Windows “Paint” or GIMP [GI16]), draw a freehand picture of your own design. Then use your image to texture the pyramid in Program 5.1.Program 5.1 JAVA/JOGL Application // the following additional imports will be necessary for the texture
Modify Program 4.4 so that the “sun,” “planet,” and “moon” are textured. You may continue to use the shapes already present, and you may use any texture you like. This will require you to build texture coordinates for the cube.Program 4.4 private Matrix4fStack mvStack = new
Modify Program 12.1 to experiment with various values for inner and outer tessellation levels and observing the resulting rendered mesh.Program 12.1 Java/JOGL application public int createShader Program (String vS, String tCS, String tES, String fS) { GL4 gl = (GL4) GLContext.getCurrentGL(); String
Test Program 12.5 with the layout specifier in the evaluation shader set to equal_spacing, and then to fractional_even_spacing, as described in Section 12.4. Observe the effects on the rendered surface as the camera moves. You should be able to observe popping artifacts in the first case, which are
Modify Program 12.4 to utilize a height map of your own design. Then add lighting and shadow mapping so that your tessellated terrain casts shadows. This is a complex exercise, because some of the code in the first and second shadow mapping passes will need to be moved to the evaluation
Modify Program 14.4 (the version including the modification in Figure 14.10 that produces a 3D cubed texture) so that it instead textures the Studio 522 dolphin. Then observe the results. Many people when first observing the result—such as that shown on the dragon, but also even on simpler
Modify Program 13.1 so that it moves each vertex slightly toward the center of its primitive triangle. The result should look similar to the exploded torus in Figure 13.5, but without the overall change in torus size.Program 13.1Figure 13.5 #version 430 layout (triangles) in; in vec3 varying Normal
Modify Program 13.4 to additionally render the original torus. That is, render both a lighted torus and the outgoing line segments (using a geometry shader) so that the “hair” looks like it is coming out of the torus.Program 13.4 layout (line_strip, max_vertices=2) out; void main(void) {vec3 $layout (line_strip, max_vertices=2) out; void main(void) {vec3 op0 = gl_in[0].gl_Position.xyz; // original$
Modify Program 14.2 to gradually decrease the alpha value of an object, causing it to progressively fade out and eventually disappear.Program 14.2 JOGL/Java application - in display() for rendering pyramid: gl.glEnable(GL_CULL_FACE); gl.glEnable(GL_BLEND); gl.glBlendFunc(GL_SRC_ALPHA,
Modify Program 13.2 so that it deletes every other primitive, or every fourth primitive (rather than every third primitive), and observe the effect on the resulting rendered torus. Also, try changing the dimensionality of the instantiated torus to a value that is not a multiple of three (such as $// inputs, outputs, and uniforms as before void main (void) { if (mod(gl_PrimitivelDIn,3) != 0 ) {for (int$
Modify Program 13.4 so that it produces outward-facing line segments with more than two vertices, arranged so as to make the line segments appear to bend slightly.Program 13.4 layout (line_strip, max_vertices=2) out; void main(void) {vec3 op0 = gl_in[0].gl_Position.xyz; // original triangle $layout (line_strip, max_vertices=2) out; void main(void) {vec3 op0 = gl_in[0].gl_Position.xyz; // original$
Modify Program 14.3 to clip the torus along the horizontal, creating a circular “trough.”Program 14.3 Java/JOGL application: public void display(GLAutoDrawable drawable) { ... flipLoc gl.glGetUniform Location (rendering Program, "flipNormal"); gl.glEnable(GL_CLIP_DISTANCEO); // normal drawing
Incorporate the logistic function (from Program 14.7) into the marble dragon from Program 14.5, and experiment with the settings to create more distinct veins.Program 14.5 Java/JOGL application: public void init(GLAutoDrawable drawable) { ... generate Noise(); noise Texture = load3D Texture(); //
The simple sine wave used to define the wood “rings” generate rings in which the light and dark areas are equal width. Experiment with modifications to the associated fillDataArray() function with the goal of making the dark rings narrower in width than the light rings. Then observe the effects
Modify Program 14.9 to incorporate the zooming, smoothing, turbulence, and logistic steps described in prior sections. Observe the changes in the resulting dissolve effect.Program 14.9 Java/JOGL application: float threshold = 0.0f; // gradually-increasing threshold for retaining/discarding
Add a flying object such as a bird or airplane (or even the NASA space shuttle model) flying overhead, above the top surface of the water. Then include it in the reflection off the top surface of the water when the camera is above the water’s surface and in the refraction through the top surface
Add an object moving underwater, such as a fish or submarine (or even the Studio 522 dolphin) below the top surface of the water. Then include it in the scene when the camera is below the top surface and in the refraction when the camera is above the top surface.
In Exercise 15.2 (above), if you haven’t done so already, add water caustics to the underwater object.Exercise 15.2Add an object moving underwater, such as a fish or submarine (or even the Studio 522 dolphin) below the top surface of the water. Then include it in the scene when the camera is
Modify the fragment shader in Program 15.8 so that the water caustics are also rendered when the camera is above the top surface as well. Do you think that the scene appears more realistic or less realistic with the caustics included in this case? If the latter, try to find a way to tune the
In Program 16.4, shadows can be very easily disabled by commenting out one particular line of code. Identify that line of code.Program 16.4 Compute Shader vec3 ads_phong_lighting (Ray r, Collision c) { // Compute the ambient contribution from the ambient and positional lights vec4 ambient = $Compute Shader vec3 ads_phong_lighting (Ray r, Collision c) { // Compute the ambient contribution from the$
Make the following simple changes to Program 16.5:(i) Move the box so that it is behind the sphere, but still visible,(ii) Change the background color from black to light blue, (iii) Modify the properties and position of the light source.Program 16.5 Compute Shader vec3 box_mins = vec3(-0.5, -0.5, $Collision intersect_box_object(Ray r) { // Compute the box's local-space to world-space transform matrices$
Make the following changes to Program 16.10:(i) Move the box so that it is in front of the sphere,(ii) Make the box transparent/refractive, and the sphere reflective,(iii) Move the checkerboard plane so that it is placed vertically behind the box and sphere. Try to place the objects so that both $vec3 raytrace(Ray r) { m if (c.object_index == 1) { // generate a secondary ray for the intersection with the$ $vec3 refracted_color; vec3 final_color; Ray ray; Collision collision; // holds the refracted color // final$
In Program 16.12, replace the blue roombox with the lake scene skybox. Don’t forget to disable lighting on the skybox.Program 16.12 Compute Shader struct Stack Element { int type; int depth; // type of ray ( 1 = reflected, 2 = refracted. Shadow rays are never pushed on stack) // depth of the $Compute Shader struct Stack Element { int type; int depth; // type of ray ( 1 = reflected, 2 = refracted.$ $vec3 refracted_color; vec3 final_color; Ray ray; Collision collision; // holds the refracted color // final$

Computer Graphics Programming In OpenGL With JAVA 2nd Edition V. Scott Gordon PhD, John L. Clevenger PhD - Solutions

Step by Step Answers