The grading for programming assignments 5, 6 and 7 will be done at 6:00 pm on Thursday (10/29). Please make sure you have your latest stuff checked in before that.
Due: Thursday, November 5 (see the class late policy on the Syllabus)
Synopsis: You will add more advanced effects, such as advanced texturing, objects to your GraphicsTown project in order to try out the ideas discussed in class.
Learning Objectives:
The goal of this project is to give you experience creating implementing more advanced visual effects using interactive graphics tricks.
Evaluation: We will grade check/no check for turning a working version of the graphics town project that shows off the minimum required new features. We will give extra points for doing more than the minimum, or for creating particularly interesting things in the basic assignment.
Handin: You will use the course handin system (put this in your handin directory within the P9 directory). Note: even though you’ve turned in P8, turn in P9 as a complete and separate project – that means uploading a copy of the whole thing (including the framework code). Make sure that you turn in all files needed for your program to run by testing that your program runs correctly from the web server. You must also use Canvas handin – give a link to your program, and in the type in box, describe the new effects that you’ve added (tell us what objects to look at).
Description
By now you should be familiar with the Graphics Town Project, last week you had the first part, adding a few object to the framework, and the second part, adding textures. This week you will continue to add things – just this time, they’ll be fancier things.
Technically, you can add effects to the objects that you made last week – but the idea is that you keep adding more and more stuff so that the project becomes more and more interesting.
Here are some of the effects you might try (in rough order of complexity):
- Skybox
- Projector textures / Light Maps
- Decal texture (using multi-texture)
- Bump mapping (normal mapping) to make a surface look “non-smooth”
- Parallax mapping (relief mapping) – to make a surface look REALLY non-smooth
- Pre-Computed Environment map to make reflections / fancy lighting environment
- Dynamic Environment map to make reflections of the actual scene
- Shadow maps (and other tricks to make shadows)
The last two (dynamic environment maps and shadow maps) require implementing multi-pass – which will be tricky given the graphics town framework. But if you pull it off, you will be rewarded. But it will be hard. Really hard.
Doing environment maps with a pre-rendered environment (like a skybox) is a much more reasonable thing to try. If you choose to do a skybox, make sure you do it correctly (a box that moves with the camera, rather than one that is just far away).
To get a “check” you have to try 2 of these. Doing more, or trying harder ones, will get you a better grade.
We will test your program by running it from the CS web server, so you can serve image files from there. However, we recommend that you pack the image files into strings using the methods we have given you – this will make development on your local machine easier.
For this week, your evaluation is mainly us checking off that you’ve done the advanced effects. The overall coolness of your town (fancy objects, nice designs, interesting behaviors, …) will help towards you grade – but we will evaluate that once at the end of the project. (When we get to P10).
Again, turn in your program in the P9 handin directory. Then put a list of what you did on Canvas.
Coming Attractions
We’ll have one more week of GraphicsTown – next week is a “add more coolness” week – add whatever you want!
Last week, we learned about practical aspects of texturing. And we had our first phase of the Graphics Town Project.
This week, you’ll get to apply that knowledge of the practical aspects of texturing in the next phase of the Graphics Town Project. Oh, and there’s that exam thing.
So this week:
- For Monday, October 26 – There is reading 8. But realistically, we expect that you’ll spend most of your reading doing review. So, instead of a quiz, we’ve given you a practice midterm. Nothing to turn in. But we’ll see how much you’ve learned on Tuesday.
- For Tuesday, October 27th – There will be a lecture on advanced texturing. And the midterm exam in the evening, at 7:15pm in room 113 Psychology.
- For Thursday, October 29th – There will be a lecture on interactive rendering (more advanced texturing). Also, Programming Assignment 8 is due (textures in graphics town).
The Following week… You’ll be expected to actually read the stuff in Reading 8 (on advanced texturing) and to implement some of it in graphics town for Programming Assignment 9. We’ll have a lecture on shape modeling, and a lecture on Virtual Reality.
You can download the practice midterm via this link [PDF]
Please note:
- This practice midterm is designed to be more difficult than the actual exam.
- The types of questions seen in this midterm (some multiple choice, some short answers, some full questions) are indicative of the format of the actual exam.
- Some questions may venture a bit further than information you can find verbatim in your notes or reference materials. Some of the questions might require some extra thought, and intuition. Again, this is intentional in making this practice exam a bit more challenging than the exam itself. The questions in the actual exam will lean more towards concepts that directly follow from your readings and lectures.
- This practice test is not exhaustively vetted and pre-tested. Please understand that some questions might occasionally include slightly ambiguous wording.
- Although we tried to cover most topics that will be included in your exam, this practice test should not be construed as a reading list. Questions of the actual exam may, or may not be exactly on the same topics as the questions sampled for this practice test.
UPDATE: Sample solutions [PDF]. Please note that several of the questions may admit answers that are still correct and acceptable for full credit (except for the multiple-choice problems), albeit different than the answers given here.
Program 7 uses the new handin mechanism.
This requires both a link on Canvas as well as uploading your files to a server.
The link for Canvas was broken (but 22 people found it anyway). So for P7, if you didn’t send a Canvas link, it’s OK. (For P8, the Canvas link is important since you need to use the type-in box to tell us about your assignment).
If you’re not a CS student, you might not be familiar with using AFS and transferring files. (you may not even know that you have a CS account). We should have warned you to figure this stuff out before the deadline. But, if you are having trouble copying your files to the server, ask the TA for help – he can show you.
If you have trouble turning in your files, use the Canvas handin to say “I am having trouble turning in my files” – and then talk to the TA for help (on Monday). We’ll won’t consider things late if its because you had handin troubles.
For what it’s worth, I usually use “SecureFX” (a commercial file transfer program that the University has a license for in the Campus Software Library) on a Mac and Windows, and “WinSCP” on Windows. I find these easier than the built-in tools that the handin posting described, but others prefer the command line.
Your midterm exam is scheduled at 7:15pm-9:15pm, on Tuesday October 27th.
Location : Psychology Room #113
So there was another (very minor) change to the graphics town framework code. (the first one was the helicopter)
The change adds 1 important line – when the drawing state is defined, it also sets “camera” to be the camera matrix (the inverse of the view matrix). Of course, you didn’t need this (your objects could have gotten the camera by inverting the view matrix), but since the framework already had it, it’s easier to pass it.
There is a discussion of why this change is valuable on Piazza.
You don’t need to grab the new version – just add the one line in the draw loop (where it says “view:viewM,” add “camera:cameraM,”). The official version also sets this up in the “dummy” drawing state used for init, as well as adds a comment to the definition of drawing state.
If you want to understand indexed face sets and OBJ files (as described in class, and useful for the project), you might want to read Chapter 4 of Hart’s book (canvas link here). It’s not a required reading until after the midterm, but it has come up in class already.
We will have a pre-class help session tomorrow (Thursday 10/22) at 10:15am.
The best thing is, of course, to go back over the Course Calendar to remind yourself what you’ve read and what we’ve discussed. Remember to go to the Lecture Notes category of the web page to see the lecture notes from most of the lectures. Looking at last year’s list won’t be too helpful because we’ve gone in a different order (this year we did shaders first, where last year shaders were at the end).
Here is a list of topics we covered in class that we consider fair game on the exam:
- Raster vs. Vector
- Coordinate system concepts and transformations
- Linear algebra basics (vectors, matrices, dot and cross products, …)
- Homogeneous Coordinates
- Linear Transformations and their composition
- Hierarchical modeling
- The stages of 3D drawing and the pipeline
- Hidden surface removal (Z-Buffer and painters algorithm)
- Viewing and Projection (pinhole cameras, homogenous representations of projection, …)
- Rasterization and Barycentric Interpolation
- The hardware implementation of the pipeline and shader concepts
- The “standard” lighting model
- Textures (coordinates, sampling, …)
Here are some things we will not ask you:
- We may show you snippets of JavaScript code that call WebGL or HTML5 Canvas functions, but we won’t expect you to remember all the functions and what all their parameters are. However, if we show you a (common) function, you should be able to remember what it does (or what would happen if we removed a line of code).
- We may show you snippets of shader program code and ask you questions about it, but we don’t expect you to remember all the commands in the GLSL library. We may ask you to recognize key language features (like the different types of variables and swizzles).
- We won’t ask you about how twgl encapsulates and abstracts the graphics concepts from class.