- Interpreter: working and parsing commands. You should have it
parsing
**all**commands, even those that are not yet implemented and exist only as stub procedures, but I will accept an "obviously extendible" parser that works correctly on all fully implemented commands. - Correct screen allocation and deallocation: any dynamic memory allocated with a SCREEN command should be properly deallocated as part of the next SCREEN command.
- Put_Pixel (with clipping) at screen pixel level. You should be able to call this routine with any integer values for X and Y, and have it put the even color into the appropriate element of the screen array if Odd(X)=Odd(Y), and put the odd color if Odd(X)<>Odd(Y). Any values of X and Y outside the screen area should be clipped.
- Bresenham line routine for any two integer coordinates <X1,Y1> to <X2,Y2>, calling the Put_Pixel routine successfully.
- WINDOW and VIEWPORT commands. Must handle cases where values are reversed in the WINDOW coordinates (X1 > X2, or Y1 > Y2). Must correctly map any point from world space onto viewport space.
- PIXEL, MOVE_TO, and LINE_TO commands, at world level. Must
correctly translate and plot lines and points from world space to viewport
space, and call the appropriate pixel-level graphics routines (even if
you don't get wide lines working, a call to LINE_TO must at the
*very least*translate the endpoints to viewport space and call the Bresenham line drawing routine). - PROCEDURE, END, and CALL must work correctly.
- COLOR, EVEN, and ODD must set the correct colors. I would reluctantly accept a minimal version that uses a single color instead of even and odd, but it is so easy to do the even and odd colors that there really isn't any good reason to leave them out.
- At least one of the two following items must work, preferably both:
- SAVE_24 must work, to create final bitmaps.
- VIEW must work, or alternatively must be able to plot the image on screen at end of Little Language run.

All options beyond the minimum that you managed to implement will be considered for additional credit. I will check off on my list those features that you implemented and could successfully demonstrate to me as operational, including (in rough order of complexity) simple geometric operators (rectangle, circle, ellipse), polygon fills (including user fills, line fills, and filled circles, ellipses, and rectangles), flood fills, Bezier curves, fonts, and dithering, etc.

This is what I expect turned in for your projects, when you submit them on Monday at the exam:

- A printed copy of your source code
- A Mac or PC formatted diskette containing a copy of your source (preferably in PC format)
- The diskette must also contain copies of the 24 bit
`.BMP`files produced by your program.

- An executable copy of your program on the diskette that I can run
- A "User Manual": some form of quick reference (on disk and printed) so I know how to run and test your program.

These are the topics that I expect you to think about. The exam will be a subset.

- Basic 3D operations
- 3D transformation matrices
- Translation
- Rotation (three types: one each for X, Y, Z)
- Scaling
- Perspective and orthographic projection

- Basic ray-casting and synthetic camera models (vectors)
- 3D orthographic projection (i.e., 3D without synthetic camera or perspective, just using sine and cosine)

- 3D transformation matrices
- Stereo 3D
- Stereopticon slides (tilting eye angle for each image, deciding whether to paint for diverged eyes or crossed eyes)
- Red-Blue stereo in same image (gray scale images, one where gray in one is mapped to red, other mapped to blue, then images averaged)
- Random dot stereogram (basic ideas, not algorithms)

- Shading models (basic ideas)
- Flat vs. Specular Reflection
- Flat Shading (setting color intensity by calculating angle between surface normal and vector from light source)
- Phong Shading (Cos^N(of that same angle))
- Gouraud Shading (linear intensity interpolation, pp736-737)

- Hidden Surface elimination
- Back-face elimination (check angle between surface normal and vector from eye, if angle > 90 degrees then don't paint face because it is tipped away from you)
- Polygon clipping (project 3D polygons onto 2D plane and clip, but problem exists when polygons mutually overlap)
- Painter's algorithm (paint back to front, paint over stuff in back)
- Z-buffer (pixel contains color plus depth information)

- Computational Geometry (general concepts)
- Delaunay Triangulations (basic idea about circumcircles)
- Convex Hulls
- In 2D, what are they, how might they be generated?
- How might they be used in 3D for helping with shadows?

- Star Polygons (from the demo I showed in class)

Back to CS32 Page

Back to Dr. Bill's Home Page