Basic Renderer

A "renderer" is a collection of algorithms that takes as its input a {@link renderer.scene.Scene} data structure and produces as its output a {@link renderer.framebuffer.FrameBuffer} data structure.

{@code
                           Renderer
                       +--------------+
       Scene           |              |         FrameBuffer
       data     ====>  |  Rendering   |  ====>     data
     structure         |  algorithms  |          structure
                       |              |
                       +--------------+
}

A {@link renderer.scene.Scene} data structure contains information that describes a "virtual scene" that we want to take a "picture" of. The renderer is kind of like a digital camera and the {@link renderer.framebuffer.FrameBuffer} is the camera's film. The renderer takes (calculates) a picture of the Scene and stores the picture in the FrameBuffer data structure. The FrameBuffer holds the pixel information that describes the picture of the scene.

The rendering algorithms can be implemented in hardware (a graphics card or GPU) or in software. In this class we will write a software renderer using the Java programming language.

Our software renderer is made up of four "packages" of Java classes. Each package is contained in its own directory. The name of the directory is the name of the package.

The first package is the collection of input data structures. This is called the {@link renderer.scene} package. The data structure files in the scene package are:

• Scene.java
• Camera.java
• Position.java
• Vector.java
• Model.java
• Primitive.java
• LineSegment.java
• Point.java
• Vertex.java

The {@link renderer.scene.primitives.Primitive}, {@link renderer.scene.primitives.LineSegment}, and {@link renderer.scene.primitives.Point} classes are in a sub-package called "primitives".

The second package is the output data structure. It is called the {@link renderer.framebuffer} package and contains the file

• FrameBuffer.java.

The third package is a collection of algorithms that manipulate the data structures from the other two packages. This package is called the {@link renderer.pipeline} package. The algorithm files are:

• Pipeline.java
• Model2Camera.java
• Projection.java
• Viewport.java
• Rasterize.java
• Rasterize_Clip_AntiAlias_Line.java
• Rasterize_Clip_Point.java

The fourth package is a library of geometric models. This package is called the {@link renderer.models_L} package. It contains a number of files for geometric shapes such as {@link renderer.models_L.Sphere}, {@link renderer.models_L.Cylinder}, {@link renderer.models_L.Cube}, {@link renderer.models_L.Cone}, {@link renderer.models_L.Pyramid}, {@link renderer.models_L.Tetrahedron}, {@link renderer.models_L.Dodecahedron}, and mathematical curves and surfaces.

There is also a fifth package, a collection of client programs that use the renderer. These files are in a folder called clients_r1.

Data Structures

Here is a brief description of the data structures from the {@link renderer.scene} and {@link renderer.framebuffer} packages.

• A {@link renderer.scene.Scene} object has a {@link renderer.scene.Camera} object and a {@link java.util.List} of {@link renderer.scene.Model} objects.
• A {@link renderer.scene.Camera} object has boolean which determines if the camera is a perspective camera or an orthographic camera.
• A {@link renderer.scene.Position} object has a {@link renderer.scene.Vector} object and a {@link renderer.scene.Model} object.
• A {@link renderer.scene.Vector} object has three doubles, the x, y, z coordinates of a vector in 3-dimensional space. A {@link renderer.scene.Vector} represents a location in 3-dimensional space, the location of the {@link renderer.scene.Model} that is in a {@link renderer.scene.Position} with the {@link renderer.scene.Vector}.
• A {@link renderer.scene.Model} object has a {@link java.util.List} of {@link renderer.scene.Vertex} objects, a LIst of {@link java.awt.Color} objects, and a {@link java.util.List} of {@link renderer.scene.primitives.LineSegment} objects.
• A {@link renderer.scene.Vertex} object has three doubles, the x, y, z coordinates of a point in 3-dimensional space.
• A {@link java.awt.Color} object represents the red, green, can blue components of a color. We will use Java's built in {@link java.awt.Color} class.
• A {@link renderer.scene.primitives.Primitive} object is either a {@link renderer.scene.primitives.LineSegment} object or a {@link renderer.scene.primitives.Point} object.
• A {@link renderer.scene.primitives.LineSegment} object has a list of two integers. The two integers are indices into the {@link renderer.scene.Model}'s list of vertices. This lets a {@link renderer.scene.primitives.LineSegment} object represent the two endpoints of a line segment in 3-dimensional space.
• A {@link renderer.scene.primitives.LineSegment} object has two Lists of two integers each. The two integers in the first list are indices into the {@link renderer.scene.Model}'s List of vertices. This lets a {@link renderer.scene.primitives.LineSegment} object represent the two endpoints of a line segment in 3-dimensional space. The two integers in the second list are indices into the {@link renderer.scene.Model}'s List of colors, one color for each endpoint of the line segment.
• A {@link renderer.scene.primitives.Point} object has three integer values. The first integer is an index into the {@link renderer.scene.Model}'s List of vertices. This lets a {@link renderer.scene.primitives.Point} object represent a single point in 3-dimensional space. The second integer is an index into the {@link renderer.scene.Model}'s List of Colors. The third integer is the "diameter" of the point, which lets the {@link renderer.scene.primitives.Point} be visually represented by a block of pixels.
• A {@link renderer.framebuffer.FrameBuffer} object represents a two-dimensional array of pixel data. Pixel data represents the red, green, and blue {@link java.awt.Color} of each pixel in the image that the render produces. The {@link renderer.framebuffer.FrameBuffer} also defines a sub-array of pixel data called a {@link renderer.framebuffer.FrameBuffer.Viewport}.

Renderer

Here is a brief overview of how the rendering algorithms process a {@link renderer.scene.Scene} data structure to produce the pixels that fill in a {@link renderer.framebuffer.FrameBuffer.Viewport} within a {@link renderer.framebuffer.FrameBuffer} object.

First of all, remember that:

• A {@link renderer.scene.Scene} object contains a {@link renderer.scene.Camera} and a List of {@link renderer.scene.Position} objects.
• A {@link renderer.scene.Position} object is a {@link renderer.scene.Vector} object and a {@link renderer.scene.Model} object.
• A {@link renderer.scene.Model} object contains lists of {@link renderer.scene.Vertex}, {@link java.awt.Color}, and {@link renderer.scene.primitives.Primitive} objects.
• A {@link renderer.scene.Vertex} object contains the three coordinates of a point in the model.
• A Color object represents the color that we want to give to a {@link renderer.scene.Vertex}.
• A {@link renderer.scene.primitives.LineSegment} object contains the indices of two {@link renderer.scene.Vertex} and two {@link java.awt.Color} objects.
• A {@link renderer.scene.primitives.Point} object contains an index for each of a {@link renderer.scene.Vertex} and a {@link java.awt.Color} object.

The main job of the renderer is to "draw" in the {@link renderer.framebuffer.FrameBuffer}'s {@link renderer.framebuffer.FrameBuffer.Viewport} appropriate pixels for each {@link renderer.scene.primitives.LineSegment} (or {@link renderer.scene.primitives.Point}) in each {@link renderer.scene.Model} from the {@link renderer.scene.Scene}. The "appropriate pixels" are the pixels "seen" by the {@link renderer.scene.Camera}. At its top level, the renderer iterates through the {@link renderer.scene.Scene} object's list of {@link renderer.scene.Position} objects, and for each {@link renderer.scene.Model} object the renderer iterates through the {@link renderer.scene.Model} object's list of {@link renderer.scene.primitives.Primitive} objects. When the renderer has drilled down to a {@link renderer.scene.primitives.LineSegment} (or {@link renderer.scene.primitives.Point}) object, then it can render the line segment (or point) into the framebuffer's viewport.

The renderer does its work on a {@link renderer.scene.Model} object in a "pipeline" of stages. This simple renderer has just four pipeline stages. The stages that a {@link renderer.scene.Model} object passes through in this renderer are:

1. transformation of the model's vertices from model space to camera space,
2. projection of the model's vertices from camera space to the image-plane,
3. transformation of the model's vertices from image-plane to pixel-plane,
4. rasterizer of the model's primitives into a Viewport.

Here is another way to summarize the four pipeline stages.

1. Place each vertex from a model in front of the camera (using the model's translation vector).
2. Project each vertex onto the camera's two-dimensional image-plane (using the mathematical projection formulas).
3. Transform each projected vertex to a pixel in the viewport (actually, a logical pixel in the pixel-plane).
4. For each primitive (line segment of point) from the model, determine which pixels in the viewport (actually, logical pixels in the pixel-plane) are in that primitive.

To understand the algorithms used in the rendering process, we need to trace through the rendering pipeline what happens to each {@link renderer.scene.Vertex} and {@link renderer.scene.primitives.Primitive} object from a {@link renderer.scene.Model}.

Start with a {@link renderer.scene.Model}'s list of vertices.

{@code
       v_0 ... v_n     A Model's list of Vertex objects
          \   /
           \ /
            |
            | model coordinates (of v_0 ... v_n)
            |
        +-------+
        |       |
        |   P1  |    Model-to-camera transformation (of the vertices)
        |       |
        +-------+
            |
            | camera coordinates (of v_0 ... v_n)
            |
        +-------+
        |       |
        |   P2  |    Projection transformation (of the vertices)
        |       |
        +-------+
            |
            | image-plane coordinates (of v_0 ... v_n)
            |
        +-------+
        |       |
        |   P3  |    Viewport transformation (of the vertices)
        |       |
        +-------+
            |
            | pixel-plane coordinates (of v_0 ... v_n)
            |
           / \
          /   \
         /     \
        |   P4  |    Rasterization, clipping & anti-aliasing (of each line segment)
         \     /
          \   /
           \ /
            |
            |  shaded pixels (for each clipped, anti-aliased line segment)
            |
           \|/
    FrameBuffer.ViewPort
}