Developed as part of a Department of Defense Multidisciplinary University Research Initiative (MURI) for Cybersecurity Situational Awareness with collaboration between UC Santa Barbara, UC Berkeley, and Georgia Tech, Network Security Realm is a plugin-based 3D visualization tool for cybersecurity situational awareness developed for use in the UCSB AlloSphere, a three story tall immersive spherical display. NSRealm manages a 'space' that can be populated with datasets and network topologies, as well as various static geometric entities. Plugins are then written to augment and annotate the networks that are being visualized in the system. These plugins may be widely applicable to a variety of networks and datasets, or they can be specifically tailored for visualizing specific datasets on specific networks. NSRealm provides an interface for these plugins to be loaded and managed so that the user may enable or disable various aspects of the visualization. Plugins may also render their visualization to their own plugin spaces, which are given viewports on the screen that the user can select and maximize in order to navigate and interact with them.

NSRealm is implemented using OpenGL and C++ using various technologies such as GLFW, an OpenGL windowing toolkit providing gamepad and quad buffered stereo support and MySQL Connector for providing access to datasets stores in SQL databases. NSRealm features stereoscopic 3D, High-Definition Range (HDR) rendering, and provides viewports into concurrent spaces that are controlled by dynamically loaded plugins. Various techniques with viewports and framebuffer objects (FBOs) are used to lay out these spaces, resize and manipulate them. NSRealm also supports a surround view mode, tailored specifically for the AlloSphere, that renders a front and back 360 degree view from the camera with certain constraints based on the physical setup of the AlloSphere. A particular warping strategy is utilized using FBOs and cubemaps in order to maximize the immersiveness of the experience.

The DUI2 Engine is a fully featured game engine and environment. "DUI" loosely stands for "Don't Update/Update/Input Stack", the initial concepts around which the engine is structured. This involves a collection of entities that update each frame, entities that do not update, and a stack of input control sets. The engine started under the name DUI using a single threaded model, was shortly renamed TrIS with three explicit tiers for updated entities, and evolved into DUI2 under a new experimental multi-threaded paradigm. Features of the DUI2 Engine include:

• Massively threaded. Each game entity runs in it's own thread, uses a dedicated Lua virtual machine, and communicates using message passing. This ensures maximum parallelization for multi-core machines, and is designed to take advantage of future developments and trends in CPU technology.
• Uses the LX Engine for 3D, Sound and Input - custom built engines running on top of Direct3D 9, OpenAL, and DirectInput.
• Integrated ODE physics engine provides fast and powerful rigid body physics for any game running under DUI2.
• Provides a Lua scripting environment for each game entity, with a full set of controls for every aspect of the 3D, Sound and Input capabilities of the system.
• Works with the full set of development tools written for use with the LX Engine, including World Editor, a modular and portable level editor, LXM Editor, a 3D model metadata and parameter editing tool, LXC Manager, a package management tool, and more.

AIDemo2 ( before the inclusion of the ODE physics engine ) was a testbed for the DUI2 Engine. On quad core machines, DUI2 has shown to be stable up to 250 kernel threads, prior to any potential profiling and optimization. The massively threaded structure of the environment allows each logical entity to be disjoint - no entity can disrupt or corrupt another, and each can crash both independently and gracefully in the case of error. For development, as entities can be loaded from scripts dynamically, debugging or tweaking of scripts can be done on the fly by simply reloading the entity without even restarting the game.

The DUI2 Engine is currently being used to develop From Dusk into Twilight, which aims to be my first game. Development of an initial alpha of the game implementing almost all of the gameplay mechanics and simple AI enemies took less than a week using this system. The future of the engine looks bright and has plenty of room to expand and grow. Future developments would involve the integration of a networking component, further developing of the graphics engine, alternate threading profiles, and optimization.

The LX Engine is a fully-featured suite of 3D, Sound and Input engines targeted for use in game development. The overall design is highly object oriented, and is clean, minimal, and easy to use. It's comprised of four main cores - LXRenderer, LXSound, LXInput and LXLibrary, the common math and library class used by each of the engines and available for use by the application as well. Each engine is an interface - the application will use a series of header files and link to a static library; code in which will load a DLL that contains the implementation of the engine. As no API-specific code exists in any of the interfaces to LX Engine's cores, the LX Engine is completely API-independent. Redistrobution on different platforms would require only a rewriting of the underlying engine targetting that platform. This abstraction of the application from it's 3D, Sound and Input devices allows for great potential in portability, be it for PC, Mac, Linux or game console. Multiple file formats have been designed for use with the LX Engine, such as the .lxm, .lxf, .lxc and .lxu files.

LXRenderer

LXRenderer provides a simple, powerful and flexible interface for loading, positioning, and animating models in 3D space. Working with the engine to accomplish tasks such as changing resolution, enabling or disabling shadows, etc., are all done with a single function call. Moreover, all rendering is handled internally by the engine - all the application needs to do is to specify the parameters of the 3D objects in the world, and the engine will take care of rendering, lighting, shading and shadowing them, all with a single function call - Render() - by the application. It's core features include:

• Multithreaded - models and textures will load in the background, efficiently managed internally.
• Built in support of single texturing, multi-texturing, or bump mapping as well as shading using nDotL lighting, shadow mapping, or alpha-shadow mapping can all be enabled and applied globally with a single function call, and all handled internally.
• Post-processing effects can be managed on a high level, and require little fuss to modify and apply.
• Completely dynamic lighting - no precomputed light maps. All light and shadows are computed in real-time for true next-generation visuals.
• Supports Shader Model 1.1, 2.0 and 3.0, switchable with a single function call, and settable upon initialization.
• Custom Shaders can be applied to objects in the scene, allowing full customization for per-application needs.

LXSound

LXSound provides a similar interface to a platform's audio system. The loading, playing and managing of sound resources is similarly made simple and easy to use. LXSound allows you to efficiently place the listener and various audio objects into your 3D scene, and efficiently updates it's internal configuration of sources relative to the sensitivity of the human ear. The most exciting part of LXSound is it's music system - a threaded streaming audio system allows the application to transition between different musical tracks with explicit orchestrated bridges between key points along the track. This allows the composer to change the music being played on a higher level than simply fading one track out and fading in a new one - the composer can explicitly set bridges between tracks that LXSound will automatically traverse. The features of the engine are thus:

• Efficiently managed loading and playing of many sound effects in 3D or stereo modes.
• Flexible system of blockers and occluders allows you to control the feel of your sound effects in advanced ways.
• Revolutionary, threaded, streaming music system allows for a new way for games to truly match the music to the action, and immerse the player into the game world.

LXInput

LXInput also provides a high level, object oriented abstraction from the target platform's input system. Aside from being fast, straightforward and efficient, the primary feature of LXInput is the ability of register multiple input sets with the system, and one of which can be marked as 'active' at any time. This allows you to have, for instance, in a game setting, a set of key bindings for the game, menu and submenus, and can allow one to switch functionality in a quick and high level manner.

• Fast, intuitive and straightforward input management system.
• Object oriented using call back "event" classes.
• Flexible and customizable input set system provides many solutions to an application's needs.
• Supports keyboard, mouse, joysticks and XBox 360 controller through the XInput API.

LXLibrary

LXLibrary provides a fast, flexible and powerful API independent standard library for 3D linear algebra, as well as providing additional data structures used within the LXEngine, also available for use by the application.

• Provides flexible implementations of vectors, matricies, rays, quaternions, Axis-Aligned/Oriented bounding boxes, planes and more.
• Useful data structures such as a thread-safe queue, scatter vector and thread-safe scatter vector are available in LX Library

LX File Formats

Numerous custom file types are used through the LX Engine.

• .lxc - LX Container. A format that allows many smaller files such as textures, models, sounds, scripts, compiled textures, etc. to be placed in a single file, yet retaining speed in lookup and read time. LXC support is built directly into the LX Engine, allowing an entire game's content to exist in a single file.
• .lxm - LX Model. Combining vertex, index, animation, position and collision data into a single file, LXM files efficiently pool together all the information necessary for rendering and animating an object in a 3D scene.
• .lxf - LX Font. LXF files contain font data for height, width, unicode information and more, alongside a specially prepared font texture for use by LXRenderer.
• .lxu - LX Music. LXU files contain the graph data necessary to the traversal and streaming of the multi-track music system featured in LXSound.

LXExhibition is a technical demonstration and test suite for LXRenderer. As the first deployment of LXRenderer in a demanding environment, LXExhibition does well to show off the graphical ability of the LX Engine. The darkened scene consists of three pillars holding aloft a ball of water, the surface sheeting off to the bottom. Three strong, retractable light sources surround the water ball, as well as a wide track systems circling the scene. Carts travel along this track, carrying a lantern, spewing smoke, and being illuminated by the spotlights at each checkpoint.

• 32 models and textures are used in the demonstration, populating the scene with 98 objects dynamically lit by 17 light sources.
• Specular reflections using per-pixel phong shading as well as bump mapped texturing is used throughout the scene.
• Shadow mapping is used to cast dynamic shadows from the track posts.

Click here for download page.

Building upon LXExhibition, LXExhibition2 is more than a new demonstration scene - it is a fully featured game environment. Utilizing the entirety of the LX Engine, paired with Lua scripting via the DUI Engine and it's 300+ provided bindings, LXExhibition2 is a true test of the LX Engine in a real game environment. As a flexible and demanding test suite, LXExhibition2 will be constantly update over LX Engine's development, becoming increasingly striking at each step.

Similar to LXExhibition, LXExhibition2 features a central water ball and track system. The water ball is here held aloft by a girder system decending from the sky, lit by three lights on the inside of the structure. Lying below the water now streaming off the ball is an aqueduct system, depositing the water into a pool in a concrete structure upon a grassy hill amidst a vast valley. The track system is now built upon machinery which allows it to rise into the air. The carts themselves are more distinct in their mechanical structure, and feature a flickering incandescent bulb as opposed to a lantern.

• With 105 unique models and texture, the scene is populated by 86 objects, dynamically lit by up to 19 sources of light.
• Featuring a night and day cycle, LXExhibition2 presents a wide variety of colors and lighting conditions.

Click here for download page.

World Editor is an exceptionally flexible and modular level editor environment for use in developing 3D games. World Editor uses the LX Engine in conjunction with Lua and the TrIS Engine.

The core of World Editor is the ability to spawn, position, orient and delete entities. Each entity is defined as a Lua script. The flexibility of World Editor is based on it's simplicity - World Editor has no part in deciding exactly how the entities will initialize, present, or reposition themselves. There is no set rule for even how an entity will spawn and present itself in the scene. The entities have full control over a set of C++ bindings provided to the Lua environment - the same bindings provided to World Editor's main cores, allowing entities potentially full control over the editor environment. World Editor also presents an interface by which certain values can be provided as parameters to an entity created in the scene - the types of desired values are defined by the entity.

An entity, for example, can load specific models and textures for use in-editor, as opposed to the full detail model that will be used in the main game. An entity can load custom shaders to display useful data, choose to draw bounding boxes, etc. Want an entity to display an on-screen menu when selected? No problem - write that functionality directly into the entity's script as well, using globally available HUD and mouse binding systems provided by World Editor for such an occurance. Want to extend the base functionality of World Editor for a specific game? No problem - write an entity that will initialize the appropriate components and spawn it into the scene, overriding the original components if necessary. World Editor is extraordinarily flexible and modifiable for any game development purpose.

TranslatAR is an augmented reality translation system developed for the Nokia N900. I worked on this projected along with Steffen Gauglitz, Victor Fragoso, and Jim Kleban. Our application uses the video camera on the device to capture strings of text using the Tesseract OCR engine. These strings of text are run through Google translate and placed on top of the original text in the video feed using augmented reality. The result is that the user can look through their phone ( the "magic lens" paradigm ) and view all of the text in their environment in their own language.

Although this is an open problem many people have worked on, our system was developed in six weeks using freely available / open source components, and is functional - our application ( while not ready for commercial distribution ) accomplishes all of the goals we set out to accomplish - the text can be captured and translated and the target text can be tracked and augmented with a text string.

Click here to read the paper for TranslatAR.

Contested Earth is a multiplayer browser game developed in a course focusing on scalable web services. In uses Ruby on Rails and Google Maps to create a game in which players control grid squares on a map of Earth, train and build units to deploy and position, and build various defensive and offensive structures to fortify their territory. Players can then attempt to take over land and complete for local and global high score lists. Players can try to control their hometown and compete against other players from their neighborhood!

Features of the game that were planned but we didn't get around to implement are social networking features and using real-world population density as a basis for weighting and scoring each of the game map's 2.6 billion grid squares. I worked on this project with Arvin Faruque, Svetlin Bostandjiev, Soo-Hwan Park, David Belotti, and Xin Mao.

You can read a more in-depth description of our project here

CircuitBoard was developed for a graduate course final project on Sketch Based Systems in Fall of 2008. Work continued into the beginning of 2009, when our work was presented at the International Conference on Intelligent User Interfaces (IUI) workshop on Sketch Recognition in February 2009 at Sanibel Island, Florida.

CircuitBoard allows the user to sketch digital logic circuits onto a clean, unobstructed writing surface. Sketched logic gates and wires are automatically detected and wired up into a circuit, allowing the user to simulate and interact with the logic design they have been drafting. While conventional CAD applications for doing digital logic design are overly complex - intimidating users back to a sheet of paper or whiteboard - CircuitBoard aims to provide a means of designing logic circuits with a computer in a manner that is natural and intuitive, augmenting the freedom of expression supplied by a traditional pen and paper or whiteboard with tools that can be valuable for the development process.

In the future, we would like to add more functionality to CircuitBoard such as the ability to export a design to Verilog code, and provide a method of defining and labeling a custom circuit that could be reinstantiated in future designs. More details on our implementation as well as a download link can be found at the project website linked below.

Click here for project website.

Compartment DJ is an application for Google Android that allows a user to remotely control a music playlist running on a remote computer. When a user is playing music from their desktop they're tied down to their computer in order to control it - changing tracks, adjusting the volume, queueing songs, etc. This can be difficult in certain situations - the host of a party or other social event who is also in charge of the music, played on their desktop computer, would need to walk all the way back to their mouse and keyboard to be able to interact with the playlist. Depending on the density of the crowd, this could be quite difficult.

This application is designed to work with Foobar2k running the Foobar Control Server plugin. The application communicates with the server over Telnet and is able to change to previous/next tracks, choose a random track, seek with a song, adjust the volume, pause/play/start playback, browse the playlist, and manage a queue of tracks to be played. for instance a party or social even with many people, where the person controlling the music will need to stay at the computer in order to monitor it, adjust the volume, change tracks, etc.

Our project, Cyborg Mail Messaging for Android (CMMA), is an application for Google Android developed in conjunction with Callwave in order to create a client application for their voicemail transcription service. Although our project was for a class, we worked together with Callwave and employed agile development practices over the course of two quarters in order to develop a polished application allowing them to extend their business and enable the ability for customers to receive text transcriptions of their emails on their mobile phone. Our application took advantage of the Android platform, tying into local contacts and web browser / email composition / map apps in order to be able to better interact with your voicemail messages.

We submitted our application to the first Android Developer Challenge and placed in the top 25% of all applications submitted to the contest. I worked on this project with Siwei Zhu, Thorsteinn Johannesson, Albert Winberg, and Alan Baker.

The website for our project can be found here.

AIDemo2 is a playable demonstration program and game and is a successor to the original AIDemo written in late 2005. While the original AIDemo focuses on a simple artificial intelligence system, AIDemo2 features it's underlying game environment - a general purpose, massively threaded game environment. While games struggle to realize a multi-threaded approach, AIDemo2 runs every entity within the scene on it's own thread. Every character running on the battlefield - every bullet whizzing through the air - runs on it's own thread.

AIDemo was chosen to exemplify a massively threaded environment due to the ability to easily distribute a thread to each actor in the scene, and to also have the potential to showcase many threads running concurrently with little to no problem. AIDemo2 successfully runs at times with over 200 threads active and running. While AIDemo used extremely simple Direct3D commands, AIDemo2 makes full use of the LX Engine - presented in full 3D using custom models and materials, sound effects and a musical track. AIDemo2 is also a playable game - control any lifeform on the battlefield to dodge bullets and take out the enemy.

Click here for download page.

Implementing a system by which fast and efficient AI could be realized, this demo program uses Direct3D to draw the demonstration's graphics, as well as a new system of drawing text which would be later used in the LX Engine. AIDemo features humans versus aliens in an eternal struggle for dominance over the black game window. Adding hundreds of players to the scene results in no slowdown, due to the efficient time management of the AI.

Using a system of statistics including bravery, intelligence and others, units can shoot, dodge, patrol and talk. They can become panicked if shot unexpectedly, and end up running uncontrollably in fear, before recomposing themselves. If unintelligent, they can overlook the presence of enemies in the midst of battle. If intelligent, they will employ better tactics and dodge faster.

Click here for download page.

As a course-long project for Computer Science 50, Jerc is an IRC client written in Java. Although it's primary feature was communication through RSA public key encryption, this part of the project was never completed. It's features include:

• All chat data is handled as HTML, and can be customized on a global or per-channel basis with CSS stylesheets.
• Chatlogs can be set to automatically log in several different manners.
• Supports downloading of files through the DCC protocol.
• Preloaded with addresses for many common IRC servers.

Click here for download page.

LXM Editor is a tool with which one can editor and manage LXM files. It allows a user to preview, edit, merge, weight, paint and overall modify the parameters of a 3D model. While LXM Editor is not a 3D modelling program, it allows the user to edit other information regarding 3D models aside from individual vertex position information.

• View an overview of LXM data, and preview the model in point or wireframe mode. Alternatively, temporarily save and load the model in the LX Engine with a given material and customizable lighting environments.
• Edit collision data for the model, with any given amount of Axis-Aligned or Oriented bounding boxes.
• Can rotate, flip, mirror and reverse the winding of vertex data.
• Import and mix sets of texture coordinate data.
• Paint vertex colors, bone assignments, bone weights and texture weights.
• Setup and manage skeletal data by creating a hierarchy and positioning joints.
• Manage and import positions and animations from appropriate .lxm or .x files.

LXC Manager manages LX Container, or LXC files. Inspired by certain games that contain many dependencies in a minimal amount of files ( as opposed to complex trees of thousands of files, LXC files are designed to encapsulate arbitrary files into a single structure. LXC Manager allows a user to compile, expand, and save these files to disk. Items can be removed or added to LXC files, or the contents extracted to a given folder. A simple, yet solid tool, it also was my first implementation of drag-and-drop using Swing.

My website/blog has evolved over the years to incorporate many new things. From a humble start as a series of HTML files I would edit and reupload, The Charhut would later run under custom Perl code to manage news updates and history in conjunction with a Java application written to upload news updates to the site via FTP. The image gallery of the site also used Perl, as well as the message box on the right side of the main page.

In 2009, Charhut moved to Ruby on Rails based webhosting. The entire site was rewritten in Rails and uses an entirely custom blog, comments, picture gallery and administration system.

Even more development is expected to be made in the future.