CS448A Final Project

Project Presentations

2:30	Compression Mike Houston, Kok-Wei Koh
2:45	Polygon Rasterization Jaeha Kim, Jung Ho Ahn
3:00	Unwired A Wireless Graphics Architecture Philipp Schloter, Pradeep Sen
3:15	Texture Caches for Multitexturing Francois Labonte, David Lie
3:30	Displacement Mapping Huat Chye Lim
3:45	Programatically Interpolated Curved PN Triangles Keith Ito
4:00	Break. Food and drinks will be served.
4:15	Exploring the Performance of the Reyes Rendering Pipeline on the Imagine Stream Processor. Brucek Khailany, Brian Towles
4:30	The Road to Renderman in Hardware Jonathan Ragan-Kelley, Ujval Kapasi
4:45	An Examination of Shadow-Generation Techniques Rahul Gupta, Ming Tam, Yar Woo
5:00	Evaluation of Shared and Hierarchical Caches in a Parallel Multi-texturing Rendering System Ken Mai
5:15	Compiling for Optimal Multipass Rendering Yi-Ren Ng
5:30	Persistent State in Programmable Shaders Andrew Robbins

Updates

Project Proposals

Purpose

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.

Schedule

• Project proposal due: Mon, Nov 5th.
• First progress report due: Mon, Nov 19th.
• Individual Meetings with Instructors: Week of Nov 19th.
• Second progress report due: Mon, Dec 3rd.
• Final paper and project due: Week of Dec 10th.

Project Proposal

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 been done.

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.

Suggested Topics

To get you started, here are some topics that we think deserve more research.

• Tangent-Space Shading 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 graphics pipeline.
• 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 instructions.
• Multipass Rendering. 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.
• Shadows. 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.
• Rasterization. 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 efficiently.
• Texture Caches. Evaluate the impact of multitexturing and dependent texturing on the texture cache. Extend the studies of Hakura and Gupta, Igehy et al.
• Compression. 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.
• Deferred Shading. 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 help performance.
• Benchmarking. 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 performance.
• 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)?
• Displacement Mapping. 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?

Grading

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!

Implementation

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 designs.