CS448A Final Project
You have 10 minutes for your presentation followed by 5 minutes of
questions. Please email the TA if you have a scheduling conflict.
GLSim OpenGL implemenation and GLTrace now available.
The purpose of the final project is to investigate in more depth
the design and implementations of graphics architectures.
The research project should be done in groups of two (although
you may work independently if you wish); larger groups are
possible although the project should be much more ambitious.
This is meant to be a research project, and the work should
be novel, creative and of high quality.
The final deliverable will be a 8-12 page paper written
as a conference paper submission.
- Project proposal due: Mon, Nov 5th.
- First progress report due: Mon, Nov 19th.
- Individual Meetings with Instructors: Week of Nov
- Second progress report due: Mon, Dec 3rd.
- Final paper and project due: Week of Dec 10th.
As a first step you should write a one page project proposal.
The project proposal should be in the form of a web page. To
submit the project proposal, send the url to
cs448a@graphics This is due Monday, Nov 5th
The proposal should
motivate the problem you are attacking and why it is interesting,
state the goal of your project,
identify the key technical challenges you will face,
and outline your technical approach.
If you plan on collaborating with others,
identify your partners and
briefly describe how each person's piece relates
to the others.
Provide references to previous work and survey what has already
We will provide feedback as to
whether we think your idea is reasonable,
and also try to offer some technical guidance,
e.g. additional papers you might be interested in reading.
To get you started, here are some topics that we think deserve
Develop a system for doing tangent-space or object-space shading. This method
tesselates geometric primitives and stores positions, normals and texture
coordinates in the framebuffer. This information is then transferred to
texture memory. Then either programmable shading or multipass shading
algorithms are run in texture space. The result is a texture map containing
the final color. Finally, the final color texture map is warped into
screen-space and rendered.
REYES Graphics Pipeline.
Modify the graphics pipeline to use a Reyes-like algorithm. That is.
introduce a tesselation stage before vertex processing to convert
triangles into microtriangles. Compare the Reyes pipeline to the traditional
Vertex and Fragment Programs.
Evaluate the current NVIDIA and ATI vertex and fragment
instruction sets. Propose new instructions and identify key issues in
extending the instruction set.
Extend the reference OpenGL implementation to have a vertex and fragment
program emulator and compare different algorithms using the new
Compare in general the idea of using multiple-simple passes
to a single-complex pass for programmable shading. See
the SIGGRAPH 2000 paper by Peercy et al and the SIGGRAPH
2001 paper by Proudfoot et al for background on these two approaches.
Compare and evaluate different shadow algorithms for the graphics pipeline.
The two major candidates these days are shadow volumes implemented using
stencil planes and shadow-buffers.
Compare different rasterization designs. What rasterizer is optimized
for small polygons, what rasterizer is optimized for large polygons?
Design an architecture that handles both large and small polygons
Evaluate the impact of multitexturing and dependent texturing on the
texture cache. Extend the studies of Hakura and Gupta, Igehy et al.
Analyze the usefulness of compression to minimize
bandwidth within the graphics pipeline. This includes framebuffer
compression, texture compression, Z compression, and geometry
compression. Explore the existing methods with cost/performance
tradeoffs and suggest possible algorithms. Backup your argument with
actual scene data.
Implement a deferred shading algorithm within the
graphics pipeline where the z buffer is rendered first (possibly at a
different resolution than the framebuffer) and pixels are shaded in a
second pass. Explain the tradeoffs between deferred shading and
traditional rendering and provide examples of when it can and cannot
Write an application which benchmarks all aspects of
todays modern graphics hardware. This includes, fill rate, tranform
rate, input rate, texture bandwith, raster vs transform limit
crossover point, buffering between raster and transform, fragment
stamp size, texture cache performance, vertex cache
Real-Time Tone Mapping. The 2000 SIGGRAPH paper by Peercy et al.
proposed hardware support for a float-point fragment pipeline and a
floating-point framebuffer. With a floating-point pipeline, it
would be possible to render using physically-correct light
intensities. However, CRT displays can only display a small range
of intensities, so a tone-mapping step would be required to map the
high-dynamic-range rendered image to the lower-dynamic-range
displayed image. What tone-mapping algorithms would be appropriate
for real-time use? Would new hardware capabilities be needed to
support these algorithms? What performance could be expected?
Out-of-order Fragment Rendering. The OpenGL specification requires
that fragments be composited (i.e. blended) into the framebuffer as
if they were rendered in the order specified by the application
(usually indirectly specified via triangle order). But it might be
useful to allow fragments to complete out of order in some cases --
e.g. when two fragments don't overlap, and the first one has a miss
in the texture cache. How could you guarantee OpenGL-correct
rendering in this situation, while still allowing most fragments to
complete out of order? What HW design would you use? What
performance would you expect (you would probably need to simulate
texture-cache behavior and your algorithm's behavior)?
Investigate displacement mapping architectures. Enhance the graphics pipeline
to allow displacement mapped triangles.
Anisotropic Texture Filtering. Investigate anisotropic filtering algorithms. Compare existing
algorithms. Can you improve on these algorithms?
The final project will count 3/4 (or more, if based on our
judgement, we consider the project truly outstanding)
towards your final grade in the course.
We will consider strongly the
novelty of the idea (if it's never been done before,
you get lots of credit),
the methodology you employ in doing the research, and
your technical skill in implementing the idea,
A high grade is roughly equivalent to a recomendation from us that
you continue to pursue your work and submit it to a conference
Mega-lines of code does not make a project good.
You are permitted to work in small groups, but each person
will be graded individually. A good group project is a system
consisting of a collection of well defined subsystems.
Each subsystem should be the responsibility of one person
and be clearly identified as their project. A good criteria for whether you
should work in a group is whether the system as a whole is
greater than the sum of its parts!
We will provide you with a OpenGL tracing program to record and playback
OpenGL scenes and will provide some example scenes. For projects which
require modification of the graphics pipeline, we will provide a straightforward
software implementation of OpenGL which you are free to modify. With these
tools, you should be able to playback OpenGL traces through your modified
pipelines to ensure correctness and evaluate the effectiveness of your