Karl Hillesland

Velocity-based modeling of physical interactions in dense crowds

We present an interactive algorithm to model physics-based interactions in dense crowds. Our approach is capable of modeling both physical forces and interactions between agents and obstacles, while also allowing the agents to anticipate and avoid upcoming collisions during local navigation. We combine velocity-based collision-avoidance algorithms with external physical forces. The overall formulation produces various effects of forces acting on agents and crowds, including balance recovery motion and force propagation through the crowd. We further extend our method to model more complex behaviors involving social and cultural rules. We use finite-state machines to specify a series of behaviors and demonstrate our approach on many complex scenarios. Our algorithm can simulate a few thousand agents at interactive rates and can generate many emergent behaviors.

Simulation and rendering for millions of grass blades

We provide detailed simulated response for individual blades of grass in fields of millions of blades. The field is divided into tiles whose blade data are instanced from a small patch of blades on the GPU to limit memory and bandwidth requirements. We only instantiate simulation state and compute simulation for tiles interacting with objects. The simulation does not stop immediately when objects leave the tile but with a smooth transition to the original GPU-instanced state. Grass motion is solved with collision, length, bending and twisting constraints. Global animation from wind is still handled through conventional, procedural methods in the vertex shader. Our method is also compatible with a rendering level-of-detail (LOD) system. With 128 objects moving in a field with over a million blades of grass, the frame rate is less than 20 ms, with only a few milliseconds of that time for simulation.

A space-efficient and hardware-friendly implementation of Ptex

We introduce a method to pack Ptex per-face texture data that is both space-efficient and hardware-friendly. Recently presented real-time implementations of Ptex have been wasteful with space and required a storage cost many times higher than the size of the original texture data. Our method packs multiple levels of Ptex data together, and requires only around 8% increase in storage for our test textures. Additionally, because of efficient data packing, our method wastes less space than a typical texture atlas, which requires buffer regions to be added between the separate charts within the texture.

GPU compute for graphics

Modern GPUs support more flexible programming models through systems such as DirectCompute, OpenGL compute, OpenCL, and CUDA. Although much has been made of GPGPU programming, this course focuses on the application of compute on GPUs for graphics in particular. We will start with a brief overview of the underlying GPU architectures for compute. We will then discuss how the languages are constructed to help take advantage of these architectures and what the differences are. Since the focus is on application to graphics, we will discuss interoperability with graphics APIs and performance implications. We will also address issues related to choosing between compute and other programmable graphics stages such as pixel or fragment shaders, as well as how to interact with these other graphics pipeline stages. Finally, we will discuss instances where compute has been used specifically for graphics. The attendee will leave the course with a basic understanding of where they can make use of compute to accelerate or extend graphics applications.

OpenGL and DirectX

OpenGL and DirectX are different APIs for what is typically the same hardware. This course leverages the fact that if you know one of the two, you can quickly learn the other, including advanced features introduced in DirectX 11.1, OpenGL 4.3 and OpenGL ES 3.0. We will explore the similarities and differences between the APIs. This will allow someone familiar with one of the APIs to see what the other API has to offer and what they need to know to use it. It will also offer a different point of view on the same underlying hardware, and shed some light on the drivers. We will only be focusing on core OpenGL, and more specifically the approaches that resemble whats done in DirectX, such as immutable textures. This not only makes it easier to move between the APIs, but results in a focus on performant use. For DirectX we will focus on DirectX 11, including parts of 11.1 where it has converged with OpenGL and OpenGL ES in its approach.

Compute for graphics

Modern GPUs support more flexible programming models through systems such as DirectCompute, OpenCL, and CUDA. Although much has been made of GPGPU programming, this course focuses on the application of compute on GPUs for graphics in particular. We will start with a brief overview of the underlying GPU architectures for compute. We will then discuss how the languages are constructed to help take advantage of these architectures and what the differences are. Since this the focus is on application to graphics, we will discuss interoperability with graphics APIs and performance implications. We will also address issues related to choosing between compute and other programmable graphics stages such as pixel or fragment shaders, as well as how to interact with these other graphics pipeline stages. Finally, we will discuss instances where compute has been used specifically for graphics. The attendee will leave the course with a basic understanding of where they can make use of compute to accelerate or extend graphics applications.