CSE581 Lab4

CSE581 Lab4 - Texture mapping, transparent surfaces, billboards, first-person view, and drop shadows

FINAL VERSION

OBJECTIVE:
This lab introduces you to even more complex shading techniques. Modify Lab 3 to include:

texture mapping using mipmapping
billboard with transparent pixels
translucent panel using stippling
using a first-person point of view
day/night lighting sets
drop shadow implemented as a decal

Sample lab4. Note that the menu is more extensive than what you need - you only need day/night and toggle the view. A 'reset' menu item is also handy (resets the model and camera to initial values).

SPECIFICATIONS:

Texture Mapping: Include at least two texture mapped walls using mipmapping. At least one of texture maps should be an image. The other can either be an image or a procedurally generated texture map. Use texture maps that create a reasonable visual environment such as mountains or other landscapes.
Billboard with transparency: A third texture mapped surfaces should be a billboard that always faces the vehicle (so you can see the billboard effect from above) and has transparent pixels. Use a texture map that creates a reasonable visual environment such as a tree. Either find your own image or use tree.ppm.
First-Person View: Put the camera on your vehicle looking in the direction that the vehicle faces. It doesn't have to actually be 'on' the vehicle - it has to be reasonably close to the vehicle and move and rotate with the vehicle so that it creates the impression of being on the vehicle. Toggle between the regular polar view and the first person view using a right menu button menu item.
Translucency: Use some type of translucent surface in your scene. Implement translucency using stippling.
Drop shadow: Implement a drop shadow for your vehicle using the stencil buffer and a black decal that moves and rotates with the vehicle. Use
```
      glEnable (GL_BLEND); 
      glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
```
with a black color that has the 4th component set to 0.5 for shadows.
Day/Night Light Sets: Using the right mouse button, allow the user to toggle between a day light set and a night light set. The day set should only have a directional light and should include the vehicle's drop shadow. The night set should have at least the 2 non-directional light sets from lab3, the headlight of the vehicle, no drop shadow, and no directional light. You don't need to have the lights individually selectable in the menu.

NOTES:

IMPORTANT NOTE: it is up to YOU to effectly show that you are satisfying the various requirements in your lab. The grader is NOT required to look at your code to check to determine that you satisfy requirements. If he can't tell by looking at your scene, for example, that you are using a transparent surface or a billboard, you won't get credit for it (at the grader's discretion).
Texture Mapping:
- Preprocessing:
  - Read in a texture (I recommend .raw or .ppm formats). PPM files usually have 3 lines: a line containing either P3 or P6; resolution of 2 ASCII numbers (e.g. 256 256); an ASCII number that is the maximum value (usually 255). PPM files will start with either a 'P3' (having values in ASCII) or 'P6' (having values in binary). There may also be a comment line that starts with a '#'. You don't need to write in a robust file parse - just write something that will read in the file that you're using. You need to read it into a byte array (e.g., char *data). For example, for an ASCII .ppm color file that contains no comment line,
```
   open(file)
   read in an ASCII line ('P3')
   read in two ASCII values, xres and yres (resolution, e.g., 256, 256)
   read in another ASCII value (e.g. max value = 255)
   k = 0;
   for i=0 to yres
     for j=0 to xres
       Read three ASCII integers from file: r,g,b
       data[k++] = r; 
       data[k++] = g; 
       data[k++] = b;
   close(file)
```
  - Procedurally generate a texture: Simply fill an array (e.g. data[]) with values of some interesting function and then proceed the same as if the values were read in from a file.
  - Allocate an OpenGL texture, select it, and set some parameters
```
    glGenTextures(1,&texture);
    glBindTexture(GL_TEXTURE_2D,texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
```
  - Make a mipmap
```
    gluBuild2DMipmaps(GL_TEXTURE_2D,3,xres,yres,GL_RGB,GL_UNSIGNED_BYTE,data);
```
- At rendering time
  - enable texturing and the texture environment
```
    glEnable(GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
```
  - if you're using more than one texture, you need to select (bind) the texture you're using.
```
    glBindTexture(GL_TEXTURE_2D,texture1);
```
  - set texture parameters as you draw the object, e.g.,
```
  glTexCoord2d(0.0,0.0); glVertex3f(-100.0,0.0,-100.0);
  ...
```
  - disable texturing
```
  glDisable(GL_TEXTURE_2D);
```
- Here are my mountain texture maps: mountains.ppm, mountainsFlipped.ppm
PPM files: There's lots of information on the web, such as
- http://local.wasp.uwa.edu.au/~pbourke/dataformats/ppm/.
Here are some ppm textures:
And there are lots of images on the web you can download and convert to ppp, such as http://free-textures.got3d.com/index.html.
First Person View: Compute a position (the cab position) and view direction to simulate the view of the driver and use it in the glLookAt command. This can be done a couple of different ways. Probably the easiest is to have routines that 1) return the vehicle's cab position in the scene, return the direction that the vehicle is oriented - so all you have to do is change the parameters in the LookAt command without changing where you issue the command:
```
   getModelCabPostion(&cx,&cy,&cz)
   getModelDirection(&dx,&dy,&dz)
   glLookAt(cx,cy,cz,cx+dx,cy+dy-0.05,cz+dz,0.0,1.0,0.0);
```
This has the first person view looking down at the road a little bit.
The direction vector is just the sine and cosine of the y-axis rotation of the vehicle for the x and z coordinates with y=0. The cab position would be computed using the model's position in the scene, the dimensions of the vehicle, and possibly the direction vector to calculate the position for the cab (the location of the operator of the vehicle) in the scene.
Billboard: A billboard is a 2D partially transparent, textured surface that always faces the vehicle. It's used when a 3D model is computationally expensive to display. For example, see http://www.flipcode.com/archives/Billboarding-Excerpt_From_iReal-Time_Renderingi_2E.shtml It is particularly effective in FP mode and the object is either far enough away (e.g., cloud, mountain, building) that it's rotation is not noticeable or it's an object that looks pretty much the same from most directions (tree, cloud). Use a partially transparent, textured billboard.
- To keep the billboard facing the vehicle:
  - Compute a vector from the billboard to the vehicle.
  - Use the vector to compute the y-axis rotation of the billboard to make the plane of the billboard perpendicular to the vector
  - rotate the billboard by that angle when rendering
- Read in a partially transparent texture for the billboard. By partially transparent, I don't mean the whole thing is partially transparent - I mean that some of the billboard is completely transparent and some is opaque. Find an image that is the picture of a tree or mountain and has white values for all non-tree pixels. As you read in color values, record an alpha value of 255 for all tree pixels and an alpha value of 0 for all non-tree pixels
```
   k = 0;
   for i=0 to yres
     for j=0 to xres
       Read three ASCII integers from file: r,g,b
       data[k++] = r; 
       data[k++] = g; 
       data[k++] = b;
       data[k++] = ((r+g+b) > 600) ? 0 : 255;
   close(file)
```
- Allocate alphas: Notice that, in the above pseudo-code, a pixel is now 4 bytes. You have to tell OpenGL that the 'data' is RGBA (not just RGB) and to build a texture that is 4 bytes (not 3).
```
    gluBuild2DMipmaps(GL_TEXTURE_2D,4,xres,yres,GL_RGBA,GL_UNSIGNED_BYTE,data);
```
- Here's one such texture map: tree.ppm
- Set both texturing and transparency for the quadrilateral you map the tree texture to:
```
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, treeTexture );
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

...draw quadrilateral with texture coordinates

glDisable( GL_TEXTURE_2D );
glDisable(GL_BLEND);
```

Translucency using Stippling:

Pre-define a halftone bitmap of, for example, 32x32 array of alternating bits

      GLubytehalftone[] = {
         0xAA,0xAA,0xAA,0xAA,0x55,0x55,0x55,0x55,
         ...

Enable polygon stipple and then draw the polygon:

      glEnable(GL_POLYGON_STIPPLE);
      glPolygonStipple(halftone);
      <draw polygon>
      glDisable(GL_POLYGON_STIPPLE);

NOTES:

There are on-line file conversion programs, e.g., http://www.online-utility.org
Remember textures have to have dimensions that are powers of 2
If you're having trouble with an image texture, first try a procedural texture (fill in the texture values with a short procedure - for example, make the left half red and the right half blue) to see if it's the texturing commands or the I/O that's the problem.
Remember the billboard texture is 4 bytes per pixel and this must be specificed in the appropriate OpenGL command; the 4th byte is opacity and can be set to full transparency when a certain color is recognized (see the pseuodo code in the lab 4 spec).

EXTRA CREDIT:

(0-5 pts) Do cylindrical or spherical texture mapping
(0-15 pts) Particularly interesting or complex scenes (above and beyond your lab3), at the grader's discretion.