Assignment 4 - 3D Transformations

CS4961 - Computer Graphics

Due March 23, 2001, 11:59 PM

NOTE: NEW DEADLINE

Overview

This project builds on your previous projects to implement line and polygon clipping in 3D. You will need to use your Bresenham line drawer as well as your polygon clipping algorithm for this project.

Project Requirements

The following are requirements for the project.

You must create a scene consisting of no less than two distinct 3-dimensional objects. One of these objects must be a cube. The other is your choice. (A 3-dimensional object must have height, width, and depth in all orientations.) You only need to draw the edges (wire-frame) of these objects.
You must allow the user to rotate, translate and scale these objects individually (changing one object does not change the other) relative to the object itself. This has several components:
- You must have some way of selecting which object is being transformed.
- You must be able to perform these transformations along (for translation and scaling) or around (for rotation) each of the object's three axes.
- Rotation should always be around the center of the object (or some reasonable point within the object if it is not obvious where the center should be). This is to say, the object's center should not change position due to rotation.
- Translation, scaling, and rotation must be around/along the specified axis no matter how that axis is currently oriented . For example: if the object's initial orientation relative to the user places the X-axis increasing to the right, the Y-axis increasing to the top of the screen, and the Z axis increasing towards the user, if the object is rotated around the Z axis by 90 degrees and then the object is translated along it's positive X axis, the object will move towards the top of the window since this is the direction of it's X axis after rotation. (The demo program demonstrates this.)
- There must be some way for the user to know how the axes orient. (For example, one could place marks in different colors to indicate the axes.) This way, the user can know how the object is going to move.
- Transformations must be cumulative. This is to say, each transformation may be seen as moving the object in some way. Subsequent transformations move the object relative to where the previous transformations placed it.
- You must allow incremental transformations. This is to say, the user must be able to increase or decrease the degree of transformation (be it rotation, translation, or scaling) without simply specifying a final degree. For example, the GLUI translation controls (section 4.2.13 in the GLUI manual) allow you to increase or decrease a value by dragging in one direction or another. (Again, if you are confused, this sort of control is demonstrated in the demo program.)
- DO NOT USE THE GLUI ROTATION CONTROL TO CONTROL ROTATIONS! It is incremental, and it's cool, but it lacks the precision I am looking for here. Plus I want you to do the matrix assembly. You will have opportunity to use it later.
You must be able to toggle between orthographic and perspective projection. The perspective projection should assume a 90 degree field of view in both directions. Both objects will be viewed using the same projection.

The following item is now optional in the assignment. Bonus points will be awarded for those who make visible progress towards getting it to work. (Visible meaning, something I can see on the screen.)

BONUS: You may create near, far, top, bottom, left, and right clipping planes. The user should be able to specify their coordinates (using a min-x, max-x, min-y, max-y, min-z, max-z method). In the orthographic projection, these clipping planes will form a rectangle. In the perspective projection, these clipping planes will form a truncated pyramid (frustum). You may use any reasonable method to allow the user to specify the clipping boundries. Clip the objects so they only exist within the confines of the clipping boundries. You should connect clipped edges. For example, if a corner of the cube was clipped, the clipped edges would be connected by a triangle.

Again, GL and GLUT both contain functions that will perform these functions. YOU MAY NOT USE THEM. All lines must be drawn using your Bresenham line drawer and must be drawn to the canvas as in your previous two assignments. In addition to the above requirements, include:

Documentation - Briefly explain what your program does and how to operate it. In addition, describe all data structures, major functions, and the program's flow of control.
User interface - The program should be controlled by user events and display to the screen. Any input from or output to the console window will not be considered for grading purposes.

Turn in all your code and documentation using submit (on CS machines) or handin on CADE machines. Your code will be tested using whatever environment you turn it in on (CS or CADE). Your code should be written in C/C++ and compile using gcc/g++. The project folder for submit and handin is named transformations. (submit cs4961 transformations file1 file2...)

To help make sure things are clear, I have included a demo program. It is compiled to run on the CADE Suns. It contains a single cube that can be rotated, translated and scaled. The axes are displayed by drawing an axis grid from the center of the cube through the appropriate faces. The red, green, and blue colors correspond to the X, Y, and Z axes respectively. The cube is drawn using the required perspective transform. You do not need to use the same interface, but will need your interface to do the same things (among others). PLEASE NOTE: this application implements a subset of the requirements for the project. It is your responsibility to get everything implemented. Send email to teach-cs4961@cs.utah.edu if you have questions.

Additional Notes

This section contains any additional notes regarding this project either due to questions raised by students or discoveries of my own. I will send messages to the class mailing list announcing any notes or clarifications, but this will contain a digest of all such info. These notes will never change what is required in the project, but may clarify some formerly ambiguous points and so should be checked semi-regularly.

It has been brought to my attention that some people are "centering" their objects at positions other than the center of the screen. (By centering, i mean that if one was looking at a cube in perpsective, the centered position would be where the back face appears centered in the front face.) This is almost never done in graphics because it distorts the image strangely - people expect things to diminish with depth in the direction they are looking, not off to the corner.
This said it is ok if your objects are centered at some place other than the center of the screen BUT BE SURE TO DOCUMENT WHERE THEY ARE CENTERED. I will expect certain distortions at certain places on the screen and if that isn't the case (and if I don't see documentation explaining why that isn't the case) you will lose points. Best thing would be to simply have both your objects "centered" in the center of the screen. (You can then translate them a bit initially so they don't overlap if that bothers you.) Otherwise, be sure to be very clear where they are centered or risk losing points.
This question has come up before:
> If I create two objects, should they both appear in the screen at the same
> time or I can toggle them(For example, by clicking pyramid button. I erase
> the cube then draw the pyramid and do the translation).
Both object must be visible at the same time.
EXTENSION
It seems like about half the class has asked me for an extension so far. Personally, I am not in favor, but I talked to a number of other TA's I know and they have all suggested I let you have some more time. Hence, you can have until the end of the day (midnight) on Friday to turn in your projects without penalty. I will update the web page momentarily.
Some people have had questions about the second object you need to draw for this project. My only requirement is that it must be 3 dimensional. (At least 4, non-coplaner points.) Creativity is always admired, but I don't require anything elaborate.
Your second object should not be a cube - you already have a cube in your scene. Do something else.
First, it has been pointed out to me that, in my program, when trying to scale the object, the scaling jumps as if it had been initialized to 0. It does this even when one initializes both the live variable and performs a set operation on the GLUI translation object. It appears that GLUI translation objects initialize themselves to 0 no matter what. As such, if you use Translation objects and your cube jumps when scaling for the first time, don't worry about it. Alternatively, GLUI spinners should have no such problems.
Second, due to how long it has taken me to get through all the projects from last time, the part of project 4 that uses clipping is now extra credit. You do not need to do this. I will update the web page momentarily.
Several people have said they have this problem:
> I can't seem to run the demo in the cade lab, it tells me I don't have
> "permission" to run it once I've downloaded it, any suggestions on what I
> could do to get it working?
The program downloads without the execute permission set. You need to set it yourself:
chmod u+x trans_demo
Then it should run.
Hint - 3/2/01
Before people end up spending too much time on this, I want to point out that your current Bresenham algorithm, the one that draws a line between a pair of 2D points, does not need any modification for this project despite the fact you will be drawing 3D lines. The key to remember is that you won't actually be drawing 3D lines - you will be drawing 2D lines that, due to the projection matrix, have been modified to look like they are situated in 3 dimensions.
If this confuses you, check the book's discussion of 3D modeling. I just don't want people spending hours trying to make Bresenham draw in 3D. This assignment will take enough time as it is.
Clarification - 3/1/01
> Would it be allowable to use the Weiler algorithm rather than the
> Sutherland-Hodgson algorithm for polygon clipping to avoid the degeneracy
> problem? It wasn't mentioned in the homework whether we were required to
> re-use this algorithm, or if we could 'branch out' a bit.
Go for it. For this assignment I don't really care what clipping algorithm you use as long as it actually performs line clipping. (To remind people, clipping occurs when you recalculate the end points of a line and then use these new endpoints to draw the line.)
One other clarification that I realized I left out of the assignment: I expect the polygon to be closed when clipped. For example, if a corner of the cube is cut off there should be a triangle connecting the three clipped edges at the point of clipping.
Another clarification: you are not required to draw the clipping box/frustum for this assignment. However, I recommend you include this ability as it can be useful for debugging purposes.
On CS Suns, GLUI causes the line initfuncCalled = -7676776 to be printed to the screen whenever the drawing window is reset. Aside from being annoying, this has no other detrimental effects and may be ignored.