6.837 - Project #4

• Feel free to discuss problems and approaches to your project with others
• The design and code must be your own
• Don't use code from previous semesters
• Cite any models, images, ideas, or algorithms that you do not develop yourself
• Project is due before midnight of the day indicated
• A working version of your applet and source code must be linked to your course homepage
• All source code must also be submitted via Athena's turnin procedure
• Late projects will not be accepted
• Check this page frequently for updates and clarifications

• Extend your Martix3D.class to transform normals correctly
• Implement backface culling
• Support for a directional and an ambient light source (one of each)
• Per triangle shading with support for ambient and diffuse reflection (flat shading)
• Polygon clipping in z
• Extend your triangle routines to include Z-buffering

• Support for point light sources
• Support for an arbitrary number of light sources
• Add specular reflections
• Per vertex shading using Gouraud interpolation
• An interesting scene
• An interesting user interface

• You are welcome to use the edge-equation based rasterizer given in class instead of the one you implemented in Project #2
• You might want to read ahead on some topics (i.e. illumination and shading) since there is so little time between when the topics are covered and the project due date.

• Pipeline.java - updated parsing applet (with references to frustum, removed)
• Light.java - a class for the various types of lights
• Point3D.java - class for non-vertex 3D points
• Surface.java - a class for surface/material properties
• Vertex3D.java - a class representing a vertex with a normal
• ZRaster.java - an extension of the Raster class to include Z-buffering
• cube.obj - A colored cube with a floor
• cow.obj - A purple cow

In order to avoid confusion, I have given you a copy of the triangle code that I used in my own implementation of this project rather some other version. However, I've removed the code segments that you were asked to implement for this project. You should be able to compile the given Java files into a functional, albeit incomplete, version of the project. I have also decided to give you the code for z-buffering (this allowed me to verify that the disabled code did not introduce any bugs, consider it an early Thanksgiving present). You are welcome to use this code as a starting point for you own. However, if you do so I insist that you include comments in your code and on your project web page indicating that you did.

• Triangle.java - a triangle rasterizer
• Matrix3D.java - a matrix object

                // This code fragment replaces corresponding code
                // in the ReadInput method of the Pipeline applet
                if (st.sval.equals("f")) {
                    int faceTris = 0;
                    int v0 = (int) getNumber(st);
                    int v1 = (int) getNumber(st);
                    while (st.nextToken() == StreamTokenizer.TT_NUMBER) {
                        st.pushBack();
                        int v2 = (int) getNumber(st);
                        if (v2 == v0) continue;
                        if (triangles == triList.length) growList();
                        triList[triangles] = new Triangle(v0, v1, v2);
                        float nx = (vertList[v1].z - vertList[v0].z) * (vertList[v2].y - vertList[v1].y)
                                 - (vertList[v1].y - vertList[v0].y) * (vertList[v2].z - vertList[v1].z);
                        float ny = (vertList[v1].x - vertList[v0].x) * (vertList[v2].z - vertList[v1].z)
                                 - (vertList[v1].z - vertList[v0].z) * (vertList[v2].x - vertList[v1].x);
                        float nz = (vertList[v1].y - vertList[v0].y) * (vertList[v2].x - vertList[v1].x)
                                 - (vertList[v1].x - vertList[v0].x) * (vertList[v2].y - vertList[v1].y);
                        if (faceTris == 0) {
                            // the normal could be computed here instead if all
                            // facets are planar... I'll just play it safe
                            vertList[v0].addNormal(nx, ny, nz);
                            vertList[v1].addNormal(nx, ny, nz);
                        }
                        if (surfaces == 0) {
                            surfaceList[surfaces] = new Surface(0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 1.0f, 5.0f);
                            surfaces += 1;
                        }
                        triList[triangles].setSurface(surfaceList[surfaces-1]);
                        vertList[v2].addNormal(nx, ny, nz);
                        v1 = v2;
                        faceTris += 1;
                        triangles += 1;
                    }
                    st.pushBack();
                } else

        // This code fragment appears in the
        // init method of the Pipeline applet
        for (int i = 0; i < vertices; i++) {
            vertList[i].averageNormals();
        }