UPDATES:

• Remember, your assignment is to make a Sphere scan converter (ie. a Sphere class with the minimum interface methods). The test code is only a test, which we still want to see on your web page. So you shouldn't modify it. We could use your Sphere.class file in our own test program.
• If you make any additional applets (including modified versions of the test applet) include them on your web page, but we still want to see the three test applets.
• Your applet size should be 400 by 400.
• The Sphere class has been updated below reflecting the code promised in class regarding setLightDir used by Prof. McMillan.

Ground Rules:

• Feel free to discuss assignments and your approach 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
• Assignment is due before midnight of the day indicated
• A working version of your applet and source code must be linked to your course home page.  
• You must test to make sure your applet is runnable by following links from the students link off the course webpage.
• All source code must also be submitted via Athena's turnin procedure
• Check this page frequently for updates and clarifications

In this assignment you will write a scan converter for 2-D sphere primitives. Your Sphere object must implement a Drawable interface, which means that spheres must rendered themselves into objects of the Raster class (as given in lecture).

Here are some definitions and background information that you will find useful for the project.



• We assume that all spheres are projected orthographically. This means that an entire hemisphere of each sphere is visible, and its silhouette is circular. Thus, the boundary discriminator for a sphere (the equivalent of edge equations for a triangle) is given by:
  
  
  δ = r² - (x - x₀)² - (y - y₀)²
  
  Where the screen coordinate of the sphere's center is given by (x₀, y₀) and the screen-space radius is r. As with our triangle rasterizer, this discriminator is positive for all pixels in the interior, zero on the boundary, and negative on the exterior of the sphere, as illustrated in the figure below.
  
  
  
  
  
  
• A single color (r, g, b), with component values in the range of 0 to 255, will be specified for each sphere. This color must be interpolated within the sphere such that the brightest point does not exceed (r, g, b) and the dimmest point is not less than (r/2, g/2, b/2). Your goal is to make the shading of your spheres appear as realistic as possible.

• Your sphere scan converter must handle floating-point x0, y0, and r parameters.
• At a minimum, your sphere object must implement the following interface methods:
  

  
  public class Sphere implements Drawable {
    protected static float lx, ly, lz;
  
    public Sphere( );
    public Sphere(float x, float y, float radius, int fillColor);
    public static void setLightDir(float x, float y, float z) {
      float t = 1.0f/(float) Math.sqrt(x*x + y*y + z*z);
      lx = x*t;
      ly = y*t;
      lz = z*t;
    }
    public void Draw(Raster raster);
  }
  

• You must include an in-depth discussion of your color interpolation method on the web page that includes your applet.
• By default, the brightest point on your Sphere rasterizer must be in the silhouette's center.
• Your rasterizer will be judged on its performance as well as its accuracy.
• You must demonstrate your rasterizer using the supplied driver applet and models (use a separate applet instance for each model).
• You should make each applet's width=400 and height=400
• You should put all three applets in ONE web page as shown in class (along with your in-depth discussion).

We suggest that you get a flat-shaded version of your rasterizer working first, before attempting to add any color interpolation methods. You should consider, and hopefully discuss, the tradeoffs between rendering accuracy and rendering performance.

Your setLightDir( ) method need not do anything. You will only need to implement it if you choose to support varying the position of the sphere's "bright spot" (optional). Note that it is a static class, this means that it will generally pertain to all objects of a given class, instead of a particular instance. Static methods can be invoked using the class name instead of an object instance (For example: Sphere.setLightDir(0.0f, 0.0f, 0.1f)). Your Sphere class can also have static variables that are available to all class instances.

• Add support for varying the position of the sphere's "bright spot"
• Create an interesting model (.dat file) using sphere primitives (please)
• Implement the rasterizer's inner-loops using fixed-point arithmetic
• Add transparency to your sphere's (you must be able to turn it off)
• Write a more interesting driver applet (you must include it in addition to the supplied)

Here is the source code to a driver program and supporting file that you can use for testing your Sphere rasterizer.


SphereTest.java    // simple driver applet with timing and variable lights
Drawable.java      // a required interface
Raster.java           // our old friend
test.dat                 // a test file with 5 spheres
cow.dat                // another test file (and new friend)
teapot.dat             // yet another test file

For reference, shown below are renderings from my implementation of a sphere rasterizer:



test.dat


cow.dat


teapot.dat