CS 445/645: Introduction to Computer Graphics

Goal: Environment Maps

URL: http://www.cs.virginia.edu/~gfx/Courses/2001/Intro.fall01/Exercises/assignment4-2.htm

Assigned: Thursday, November 15, 2001

Due: Wednesday, November 28, 2001 at midnight

• There are plenty of good OpenGL demos on the web. Many can be found at
       http://www.opengl.org/developers/code/tutorials.html
  Make sure you make a note in your README if you use code from any of these tutorials in your assignment.
• We continue to use OpenGL (http://www.opengl.org). The OpenGL Red Book is available here:
    http://fly.cc.fer.hr/~unreal/theredbook/

UPDATE: Tunnel Cube Face Textures for your cube map.

UPDATE: Adobe Cube Face Textures for your cube map.

UPDATE: Code to solve for alpha and extrapolate an intersection point that will yield correct texture coordinates is now available.

Synopsis: The goal of this two part assignment is to generate three-dimensional models with interesting color and texturing. In the first part, you used a program called Teddy http://www.mtl.t.u-tokyo.ac.jp/~takeo/teddy/teddy.htm to create a three-dimensional model. You used Teddy to save a model in OBJ format. Hopefully, your part one code successfully read this model and allowed you to view it in an OpenGL/Glut window. If not, the quickest way I suggest to get up and running is to use Nate Robins's code http://www.xmission.com/~nate/smooth.html.

In part two of the assignment, we will add environment mapping using multipass textures and alpha blending.

Specifics: As in assignment 4, part 1, your program must accept a filename (ex: foo.obj) as a command line argument. The program must then read the .obj file and create the GL polygons that represent the model. You may use the model you generated with Teddy or you may use another one you find someplace. Nothing too trivial, though.

We want the model to look good, so compute vertex normals. Position at least three lights in the scene to nicely illuminate the model. Include in your README a brief description of the light types you selected and your decisions regarding position/direction.

We will develop a robust way to describe the rotation of the world, quaternions. This topic will be discussed in class, though there are plenty of tutorials on line. Your system must use quaternions to represent the rotation of the world and to support the interaction with the mouse. The entire world, including the cube, lights, and model should move. Conceptually, you are moving the camera. As in assignment 3, the left button of the mouse will be used to control rotations and the right button of the mouse will be used to control zooming.  The texture on your model should change to reflect the changing position of the camera.

The OBJ model you load will be enclosed in a six-sided box that you can create using GL_POLYGONs. Pick a size for the box that produces the most dramatic texturing effect. Each of the six sides will have a texture map attached to its inside face. You can hardcode the textures you use and I suggest using a texture loader like you did for assignment 4 part 1.

You can find images to use as textures in many places. Many web sites include sample textures. Images you've already scanned will work too. If you want to capture a particular image, Cliff will have access to a digital camera and he will be able help you grab images during his office hours. 

Your model should be texture mapped to look like it is reflecting the textures from the walls of the cube, an environment map. To achieve this effect, you will have to compute texture coordinates for each vertex. You can evaluate the texture coordinates by computing the intersection between a vector cast from each vertex (in the direction of the reflection vector based on the vertex normal and the vector to the camera) and the cube sides. Some of these texture coordinate mappings will be straightforward, whereas others will not. For example, how do you handle a polygon with vertices that project onto two or three different sides of the cube?

In order to work with polygons that reflect onto multiple faces of your bounding cube, you will use multitexturing/multipass rendering and alpha blending.  The SGI O2's do not support multitexturing, whereas many of the machines you folks use at home do.  To give you all the fullest capability to have fun with this, you can develop at home and skip the SGI compile stage of the turnin.  I encourage the use of multitexturing (as a useful real-world skill) but it's not required.  Cliff will probably send mail to the class with instructions that will simplify his grading of your assignments.  

Page 410 of the Red Book describes a way to clamp a texture and use its border for texture coordinates greater or less than 1.0 and 0.0 respectively.  Create a border with an alpha value of 0 for each texture.  Make sure you enable blending (Red Book, Chapter 6) with glEnable (GL_BLEND).  We'll discuss this in class.

Points:

• 5 pts - Generate vertex normals and lighting so as to produce a good-looking model.
• 5 pts - Create the polygonal sides of the cube and texture map them.
• 10 pts - Create the quaternion respresentation of the world rotation and mouse control.
• 30 pts - Environment mapping and texturing of model.

Turning in the assignment:

• Write a README file with your login, your name, what you did, and anything you'd like us to notice or know about your demo.
• Deposit the README and all files required to compile and run you code in the following directory:
       /courses/cs/445_brogan/Students/<username>/Exercise4-2

Collaboration: You may talk with one another about your projects, but one should not take written records during the collaboration. Your recollection of the concepts should be the product of the collaboration. Similarly, no side-by-side coding.  You can look for code on the web to help with this, but reference any code you use or learn from in your README so I know the difference between what you did and what someone else did.

Image editing:  The SGI's provide some handy image editing/conversion tools that can be found in ~dcb8j/Gfx/Tools/bin (note that the standard file format for SGI is called .rgb or .sgi):

• addborder inimage borderimage outimage:  surrounds the input image with the border image. The four
  quadrants of the border image are placed at the four corners of the input image, and the edges are extended to connect the corners surrounding the border image.
• add inimage1 inimage2 outimage: add takes inimage1 and inimage2's intensities and adds them together and
  stores the result in outimage. If the sum is greater than 255 the result is set to 255.
• addframe inimage outimage [width [r g b]]: adds a constant width border to a monochrome or color image. The
  default width is 1 pixel, and the default color is black.
• addnoise inmage outimage noiseimage mag: adds noise from the noise image to the input image. The noise image tiles the input image. The magnitude of the noise is scaled by a floating point magnitude mag. It's range is [0.0 ... 1.0]. 0.0 adds no noise into outimage, while 1.0 add alot of noise. Typicaly randimg is used to create a noise pattern (histeq can also be used).
• assemble nx ny outimage imgfiles...: assembles an nx by ny array of smaller images. The catch here is that all images being assembled have to have the same x/y dimensions. The nx by ny array works like this: nx is the number of images that are
  going to be sitting side by side in the horizontal direction, and ny is the number of images side by side in the vertical direction. Order imgfiles so that the first image will be the one sitting in the bottom left-hand corner of outimage, with the second sitting either above it or to its right. If fewer than nx times ny images are given on the command line, the last image is used repeatedly.
• imrotate [options] infilename outfilename: reads each image in the input file, rotates it, image file formats may be different.
• ipaste img - view an SGI image
• imgworks img - an SGI image editor
• imgcopy [-fformat] [-tdata_type] [-Oorder] [-pw,h,z,c] [-ow,h,z,c][-sw,h,z,c] [-corientation] [-Ccolor_model] [-Pcompression_type] [-qcompression_quality] [-mminimum_value] [-Mmaximum_value] [-h] [-D] [-n#colors] [-a] infile [:index] [#format] [%format_args] outfile [#format] [%format_args]: make a copy of infile and call it outfile and perform formatting operations during the copying.  For example imgcopy foo.tiff foo.rgb will create a copy of foo in the SGI format, rgb.  You can also convert to and from GIF, JPG, JPEG, TIFF...  This function also supports cutting a portion out of an image and resizing.
• izoom inimage outimage xscale yscale [-i -b -t -q -m or -g] [-w blurfactor]: izoom magnifies or shrinks an image with or without filtering. xscale and yscale are floating point scale factors. The filtering method is one pass, uses 2-d convolution, and is optimized by integer arithmetic and precomputation of filter coefficients. Normally izoom uses a triangle filter kernel in both x and y directions.
  
  The -i (impulse) option causes izoom to do no filtering as the image is resized. The -b (box) option causes izoom to use a box as the filter kernel. The -t (triangle) option is the default. The -q (quadratic) option indicates that a quadratic function should be used as the filter kernel. The -m option uses a Mitchell kernel and the -g option uses a Gaussian kernel. The -w blurfactor option specifies the width of the reconstruction filter. This will effect how blurry the resulting image is. If you want more blur use a larger number. The default value is 1.0.
• mult inimage1 inimage2 outimage: multiplies two images. The value 255 is used to represent 1.0 while
  0 represents 0.0.
• nullimg outimage xsize ysize [zsize]: makes a black image that is xsize pixels by ysize pixels. To
  make an RGB black image make the third argument zsize equal 3.
• sub inimage1 inimage2 outimage: subtracts two images. This caculates 128+(inimage2-inimage1).
• xv - a general image viewer and editor