Kelvin Sung

Ray tracing with the BSP tree

Publisher Summary In order to speed up the intersection calculation in ray-tracing programs, people have implemented divide-and-conquer strategies such as hierarchical bounding volumes and octrees. Uniform subdivision has also been used to speed up that calculation. Uniform subdivision is undesirable for applications where the objects may be unevenly distributed in space. This is because the amount of memory needed for uniform subdivision is proportional to the highest density of objects, rather than the total number. Hierarchical-bounding volumes can be difficult to implement effectively but can be used to good effect. Hierarchical space subdivision techniques do not suffer the memory problems of uniform subdivision and are also relatively easy to implement. This chapter discusses the best overall hierarchical subdivision technique currently known. There are two basic modules in a BSP tree intersection code. The first module builds the tree by recursively cutting the bounding box of all objects along a median spatial plane. The second module tracks a ray through the leaf nodes of the BSP tree checking for intersections. The BSP tree is built by InitBinTree( ) and Subdivide( ). RayTreeIntersect( ) is the actual tree walking traversal of the BSP tree following a ray.

Spatial-temporal antialiasing

A framework for discussing the motion blur image generation process is formulated. Previous work is studied in the context of this framework. Due to the implicit assumptions on low temporal frequencies in most motion blur algorithms, issues involved in large screen space movements and fast illumination changes in time have not been adequately addressed so far. A new approach that does not make these assumptions is introduced to solve the spatial-temporal geometric and shading aliasing problems separately. Based on newly developed adaptive algorithms in the spatial-temporal domain, an implementation of the new approach is developed to efficiently deliver high-quality motion blurred images in general computer graphics production environments.

Computer games and traditional CS courses

Integrating computer games into existing CS courses may help attract students to the field, but there are guidelines to be considered.

Game-themed programming assignments: the faculty perspective

We have designed and implemented game-themed programming assignment modules targeted specifically for adoption in existing introductory programming classes. These assignments are self-contained, so that faculty members with no background in graphics or gaming can selectively pick and choose a subset to combine with their own assignments in existing classes. This paper begins with a survey of previous results. Based on this survey, the paper summarizes the important considerations when designing materials for elective adoption. The paper then describes our design, implementation, and assessment efforts. Our result is a road map that guides faculty members in experimenting with game-themed programming assignments by incrementally adopting/customizing suitable materials for their classes.

Game-Themed Programming Assignment Modules: A Pathway for Gradual Integration of Gaming Context Into Existing Introductory Programming Courses

Despite the proven success of using computer video games as a context for teaching introductory programming (CS1/2) courses, barriers including the lack of adoptable materials, required background expertise (in graphics/games), and institutional acceptance still prevent interested faculty members from experimenting with this approach. Game-themed programming assignment (GTA) modules are designed specifically for these faculty members. The GTA modules are independent, and each is a self-contained game-like programming assignment that challenges students on concepts pertaining to a specific curriculum topic area. A faculty member can selectively pick and choose a subset of GTA modules to experiment with and gradually adopt the materials in his or her own classes. Each GTA module also includes a step-by-step tutorial guide that supports and encourages interested faculty to develop their own expertise and game-themed materials. This paper begins with a survey of previous results. Based on this survey, the paper summarizes the important considerations when designing materials for selective adoption. The paper then describes the design, implementation, and assessment of the GTA modules. The results from ongoing GTA workshops for CS1/2 faculty members and from a yearlong project in adopting the GTA modules in classes are then presented. In this case, the collected results verified that introductory programming concepts can be examined, practiced, and learned by means of GTA modules when neither the faculty nor the students involved have backgrounds in graphics or games. More importantly, these results demonstrated that it is straightforward to blend the GTA modules into existing classes with minimum alterations. In these ways, the GTA modules are excellent catalysts enabling faculty to begin exploring and developing their own expertise and materials to teach with games.

Experiencing aspects of games programming in an introductory computer graphics class

Our computer graphics (CG) programming class uses games development as a means to help students understand CG concepts. Many students mistakenly thought this CG class was a games programming class. We present a simple frame-work for discussing games programming classes. Based on the framework, the paper describes our efforts in integrating competencies associated with games programming into our CG programming class. Our results show that the resulting class maintains the integrity of the original CG class while allowing students to develop projects with more interesting games features.

Client-server based ray-tracer using ASTRA: an asynchronous RPC mechanism

Abstract A distributed ray tracer is implemented in a network of workstations using ASTRA, an asynchronous remote procedure call mechanism. The motivation of this work is to utilize the idle cycles available on workstations to speed up the execution of the ray tracing task. The application uses the client-server model with a central dispatcher as the client, sending ray tracing jobs to the servers which handle the actual ray tracing computations. A new job is given to a server that has completed its present job and successfully sent back the results. Performance tests are conducted on a group of homogeneous and heterogeneous workstations using different scene complexities and varying number of servers. Our results showed that for some of the databases, it is possible to achieve 64 times speedup with 85 servers. The paper discusses the ASTRA call primitives, the client and server parts of our distributed ray tracer program, and presents the results of the performance tests.

Recent Videogame Console Technologies

Instead of faster and more exotic systems, the latest videogame console technologies focus on human-computer interfaces that target a wider audience.

Teaching computer graphics without raster-level algorithms

Classical computer graphics textbooks (e.g. [1-4]) introduce the field by covering the details of raster-level algorithms. Many computer graphics educators have long recognized that depending on students’ backgrounds and needs (e.g. major vs non-major) [5,6] alternate approaches may be more appropriate [7-8]. With the recent advances in the field, advent of powerful hardware, and sophisticated APIs, the field of computer graphics has become much larger and richer. As educators, we must make tough decisions about what to include in a one semester/quarter class. This panel presents three distinct approaches to teaching introductory Computer Graphics without covering raster-level algorithms. These approaches are suitable for a wide-range of students with different backgrounds and needs. To ensure neutrality and balanced of viewpoints, the panel also discusses the merits of teaching raster-level algorithms and situations where the classical approach better aligns with and serves students’ needs.

Teaching introductory programming with popular board games

Games assignments are increasingly popular in computer science education. This paper advocates and analyzes the inclusion of board, card, and dice games as programming assignments in introductory programming courses (CS1/2). The simple interface and strategy-based play of these types of games complement the immersive multimedia and agility-based play of video games. The implementation of board, card, and dice games typically demands less background knowledge from the instructor and offers fewer opportunities for extraneous work by the students. The paper lists 32 specific games that are suitable for teaching the major topics in CS1/2 and discusses the implementation of some of these games and their successful use as programming projects.