Simulating rigid body dynamics traditionally requires knowledge of many different
facets of physics and mathematics. In such a simulation we must define the state
of the body at any given instance of the simulation. In order to accomplish this
we must calculate the following data:
- mass and moments of inertia
- position and velocity of every object
- rotational and angular force/momentum
- torque
- velocity and acceleration, linear and rotational
- numerical integrator
Flexible body dynamics calculate position, velocity, acceleration,
and force using particles, mass-springs, and a numerical integrator (this project
uses 4th order Runge-Kutta), to run the simulation. This requires much less
background of physics and mathematics. This is the idea of Dr. John McDonald's
paper "On Flexible Body Approximations of Rigid Body Dynamics." This project
attempts to construct the ideas proposed in this paper. Specifically, this project
simulates the dynamics of a toy top rotating, slowly loosing momentum, interacting
with boundaries in space, and eventually toppling over on its side.
[view the full project...]
Shadow map techniques are employed in computer graphics to improve visual realism.
The shadow map algorithm requires a two pass render of a scene. Once from the
light's perspective and a second from the camera's perspective. The render from the
light's perspective records the depth values from the light source to each object in
the scene. The depth values are written to a pbuffer, then stored in a texture
where it can later be sent to the fragment shader as a uniform sampler. When
rendering the scene from the camara's view, each screen pixel is transformed to light
coordinates where its z-value is compared to the value stored in the shadow map.
This compare operation is performed in the fragment shader using the shadow2DProj
function. If the pixel's z-value is higher than the depth value of the shadow map
then that pixel is in shadow. If the pixel's z-value is lower than the depth value
stored in the shadow map then the pixel is not in shadow.
One inherent side effect of shadow maps is a hard, aliased edge around the
shadow. Building soft edged shadows using percentage closer filtering and pixel shader
branching is a visual enhancement to the shadow map that employs optimization mechanisms
for calculating a soft penumbra region around a shadow where we previously had a hard,
aliased edge.
[view the full project...]
OORenderGL is a software rendering system. A skeleton framework was provided and
I implemented, using C++ and OpenGL, a rendering systems that encapsulates the following
fundamentals of graphics development:
- Faceted, Gouraud, and Phong shading
- Texture mapping, uv coordinates, mesh data structures
- Applying textures to a mesh using shape, entity, and mapaxis
- OpenGL texture mapping and filtering functions
- Box mapping, reflection mapping, light mapping, and environment maps
- OpenGL transformation pipeline
- Matrix operations for interactive display such as rotating, translating, and zoom
[view the full project...]
The Distributed Shared Memory client and server are fully implemented with
multicasting, multithreaded over UDP protocol. Multicasting realiability is built
into mdsmc using select with a timeout value. If timeout occurs mdsmc resends
reqeust to multicast groups until all servers reply. mdsmd is multithreaded, each
request occurs in its own thread. Race conditions are prevented by using mutex.
Mutex locks the entire table DSM table for new and delete requests, and locks the
respective table entry for read and write reqeusts. mdsmc sends all requests to
mcast group through the mcast socket specified by command line arguments. All
replies are received on a separate receive socket. mdsmd receives all requests
through mcast sockets specified by command line arguments. All replies are sent on
a separate unicast socket.
[view the full project...]
Alien Invaders is a space invaders / classic arcade style game composed in flash.
[view the full project...]