CSE581 AU11 Lab5

CSE581 Lab5 - Texture mapping, billboards, first-person view, and picture-in-picture

DRAFT

OBJECTIVE:
This lab introduces you to more complex shading techniques, interactive control, and animation.

Modify Lab 4 to include:

texture mapping using mipmapping
billboard with transparent pixels
using a first-person point of view with view direction control
implement picture-in-picture
shoot a projectile with a resulting explosion

Global view, showing billboards and textures	First person view, with top-down picture-in-picture
Projectile (blue cube) shot and inflight	Part way through explosion

SPECIFICATIONS:

Make a visually interesting environment: Use decals to make some roads or a track in the environment. Use texture maps on outside walls that represent an environment. Use billboards that make sense in the environment.
Texture Mapping:
Include at least three texture mapped walls using mipmapping. At least twoe of texture maps should be images. 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. See below for texture maps that you can use. You are encouraged to use texture maps that you find on the internet or generate yourself but are not required to use any other than the ones provided. Write code that will read in a .ppm file (see below).
Billboard with transparency:
An additional type of texture mapped surface 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 global view and the first person view using a right menu button menu item. When in first-person mode, Use the left button mouse movement to control the view direction relative to the direction the car is traveling.
Picture-in-Picture:
Toggle picture-in-picture (PiP) mode using a right menu button menu item. When in PiP mode, After displaying the scene in the full user-interface window, display it again using a top-down view in a small (e.g. 150x150) viewport in the upper right corner of the user-interface window.
Shooting a projectile and explosion with the 'f' key
- If in global view, shoot in direction that car is facing.
- If in first person view, shoot in direction of view.
- When fired, set its initial position, p, and velocity vector, v
- Add speed of car to speed of projectile
- Choose speed of projectile and elevation of shot that is visually reasonable

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 have at least 3 headerlines: 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). In addition, they often have a second line that is a comment line; comment lines begine with a "# '.
    PPM files will start with either a 'P3' (having values in ASCII) or 'P6' (having values after the header lines in binary).
    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_REPLACE);
```
  - Because 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);
```
- Sample textures
  Here are my mountain texture maps: Here are some ppm textures:
PPM files: There's lots of information on the web, such as
- http://local.wasp.uwa.edu.au/~pbourke/dataformats/ppm/.
And there are lots of images on the web you can download and convert to .ppm, 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.
In first person mode, the initial view direction in x and z is the direction the car is going. If you place the location of the view on top of the car, You might make the y direction a bit negative so the view sees some of the ground. In this mode, the left button mouse movement is to rotate this view direction left-right and up-down at reasonable rates.
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);

Picture-in-Picture
After drawing the scene as usual, draw the Picture in Picture by:
- clearing the depth buffer
- loading identity into the ModelView matrix
- issuing a LookAt command with the observer overhead looking down
- drawing the scene again
It might help to create a 'displayEnvironment' procedure that draws all of the geometry, but doesn't set the view. That way you can call it twice.

Projecile

for a suggestion, use a status variable to keep whether the projectile
1. doesn't exist
2. is in flight
3. is exploding
Initialize it to 'NONEXISTENT', when 'f' is pressed, set it to 'INFLIGHT'; when it lands (y<0), set it to 'EXPLODING'; after the set number of exploding frames, set it to 'NONEXISTENT'

Each display, process the projectile by:

if (status == INFLIGHT) 
   v' = v + (0.0,-9.8,0.0)*dt
   p = p + (1/2)*(v'+v)*dt
   v = v'
   draw cube at p
   if (py < 0) 
      status = EXPLODING
      explode_i = 0
else if (status == EXPLODING) 
   if (explode_i < explode_n)
      s = explode_i/explode_n
      draw exploding textured quad at p, facing car, scaled by s
      explode_i++
   else
      status = NONEXISTENT

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 condition is recognized, such as sum of r, g and b exceed a threshold.

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.
(0-5) make an interesting projectile and have it oriented according to the direction of travel
(0-10) use sound in your animation (e.g. OpenAL)