Latest Entries »

Results obtained with the system for real-time rendering of time-varying volumetric data (animated voxels) I developed as part of my dissertation for my M.Sc. in Computer Science in Interactive Entertainment Technology. View aligned cut-planes are used to sample the data volume using texture coordinates calculated dynamically depending on the orientation of the volume relative to the camera. Rendering of large datasets that require streaming from external storage is accelerated taking advantage of GPU supported fast volume compression/decompression. The system was developed in C++, with GLUT/OpenGL and Cg for the shader programs.

Advertisements

Multithreaded implementation of a CPU-based fluid simulation system that allows interactive frame rates up to 512×512 grid resolutions in a current (2010) standard PC. The simulation is based on the application of the Navier-Stokes fluid dynamics equations for calculating the evolution of the velocity field over the fluid and other quantities carried by it like the density of suspended particles. An unconditionally stable method is used to solve the equations that allows arbitrarily large time steps in the simulation. Improvements over the original algorithm have been implemented covering the simulation of internal moving boundaries of any shape, application of vorticity confinement forces to recover details lost due to numerical dissipation and parallelization of the most expensive steps of the algorithm. The system was developed using C++ and GLUT/OpenGL. This is my paper explaining the system in detail: Real-Time Interactive Smoke Simulation

Demo developed in XNA with the following features implemented in HLSL:

  • Multiple point and spot light sources dynamically configurable
  • Lambertian and Phong-Blinn illumination models
  • Vertex shader that computes the position of vertices and their normals on the fly (magic carpet)
  • Shadow mapping with PCF
  • Dynamic reflection mapping
  • Bloom post-process effect
  • Tangent space normal mapping

These other videos show in more detail my work with height maps and normal mapping.

Demo of my rigid body system, built on the particle system, that implements the following features:

  • Rigid body state update: position and orientation (using quaternions)
  • Broad phase collision detection with axis aligned bounding boxes using the sweep and prune technique described in I-COLLIDE – An Interactive and Exact Collision Detection System for Large-Scale Enviroments.
  • Narrow phase collision detection with GJK and some optimizations like transformation of one of the bodies to the space of the other or hill climbing of geometry to find supporting vertices
  • Impulse–based collision response using backtracking with the half-step method to find the collision time

The system was implemented with C++, GLUT/OpenGL and the CML math library.

This is a demo of my particle system implementation showing the following features:

  • Global forces: gravity and drag
  • Per object forces: springs and force fields
  • Several integration methods: Euler, Midpoint and Runge-Kutta 4
  • Multiple configurable particle sources: with parameters like direction, cone, emission rate and coefficients of restitution and friction
  • Collision detection and response with planes

The system was implemented with C++, GLUT/OpenGL and the CML math library.

Minigame where the player has to stop the black dots (lice) running up his body by shooting at them before they reach his head. The player wears a rigid array of fiducial markers on his chest that is captured using a web-cam and used to determine his relative position and orientation in real time. Computer generated images for lice and background plane are overlaid on the real image seamlessly as the player moves. A Wiimote is used to aim pointing at the computer screen. The game was developed in C# with XNA 3.1 as gaming framework, Goblin XNA as augmented reality framework, ALVAR for fiducial marker tracking and WiimoteLib for interacting with the Wii Remote.

fiducial markers

Minigame where the player controls the position of his spaceship moving his head and aims and shoots with the Wii Remote controller (Wiimote). User movement is recorded through a web-cam and analysed using face tracking based on recognition of Haar-like features. The Wiimote built-in infrared camera uses an infrared LED positioned on top of the sreen to calculate the aiming direction. The game was developed in C# with XNA 3.0 as gaming framework, Emgu CV -a .Net wrapper for OpenCV- as computer vision library and WiimoteLib to interface with the Wiimote.

Implementation of some of the steering behaviours defined in Steering Behaviors For Autonomous Characters using OpenSteer library. The following behaviours were developed: Arrival, Wandering, Leader Following, Containment, Flow Field Following, Path Following and Obstacle Avoidance. A* pathfinding algorithm with variable terrain cost was implemented and combined with Path Following to navigate maps.

Application to detect the boundaries and orientation of a road lane analysing video taken from a car. Line edges are obtained using Canny edge detection and then rays are casted to find the corners of the quadrilateral. Contour following is used to produce the right margin of the lane and the road direction is obtained calculating the area between this line and the linear approximation given by the quadrilateral. The system was implemented in C++ with OpenCV.

Partial remake of Space Invaders developed in XNA to practice distributed programming. Features an amazing title screen and massive multiplayer up to 4 players with client-server architecture. Lidgren library was used for networking.