After I added a quick prototype of floor-casting, it was obvious the technique I’m familiar with (from the permadi tutorials) would be too slow for the android version. There is definitely a way to speed this up, but I’ve removed the floor casting for now until I come up with an alternative method that is faster.

Textured Walls

The big addition though is that I now have the ability to texture walls. Check out the screenshot!

Next Steps

Now, I need to modularize my code. It should be easy for someone to change the map (perhaps load it as a png/bmp) and it should also be easy to change the texture on each of the walls. Once the code is squared away, I plan to add sprite support. Then I’ll be ready for a Wolfenstein-like game.

I really wanted to make my raycast engine compatible with cell phones, but I also wanted to be able to play it on my own machine. Because of this, I decided to switch my raycast engine from QT over to the java based LibGDX. This allows me to run the same project on my desktop AND my Droid X phone. Seriously, LibGDX is great!

Progress update

I find the project to be moving a lot quicker now that I’m in JAVA and using the easy-to-use LibGDX. Checkout a screenshot of the current state below.

It features one joystick (on the android version) that allows you to move around a simple room.

Next steps

Next, I plan to implement floor and ceiling casting. Tutorial for the algorithm can be found at permadi.

Implementation

I created a View based on QGraphicsView. I then added a scene to this (inherited from QGraphicsScene) which contains 240 rectangles. Each rectangle represents a slice from the raycasting algorithm (one ray = one rectangle).

The math was from a tutorial I found online. It’s really a great source to getting started.

Results so far

So far, I have a rectangular room that renders a solid color for walls. You are able to rotate using the mouse right now, but there are still some bugs to fix!

Check out the source on github.

Now I need to figure out a way to make REAL money from developing games.

I work a lot with Virtual Reality equipment in my research. The most common is a Head Mounted Display (HMD). Unfortunately, there is no standard for a HMD. The HMD on my desk only works with Windows XP 32-bit, and only some of the time. Wouldn’t it be cool if there was some standard that all HMDs could follow so that it could work under Windows 7 and (ideally) Linux?

Something similar to what I’m thinking of has already been started for connecting 3D depth sensors to skeleton and gesture recognition (see OpenNI. OpenHMD.com is not registered with anyone. I see a great opportunity to start an open-source group. It’s sort of a niche idea right now, but this could allow the price of HMDs to decrease and make the group even bigger.

Idea 2 – Conversational Agent Droid App for Long Drives

I recently got back from a trip to Washington DC. I drove 9 hours there and 9 hours back straight through. The only thing that kept me awake after the 5 hour mark was a mixture of caffeine and conversation from my girlfriend. However, for people driving long distances without a passenger, they only have the unhealthy options of caffeine/sugar/snacking/loud music and at some point, that mixture can wear off.

Why don’t we create a simple conversational agent for the droid? The technology could be similar to previous research that my advisor has worked on before (see MARVE for a demo). The basic idea is to gather information from the internet (would could be handled, ideally, via 3G automatically) to give the virtual agent up-to-date jokes or movies facts. Then using simple voice recognition, the virtual agent could converse with the driver. One example in the youtube video for MARVE is the knock-knock joke. This could keep the driver engaged and awake.

Idea 3 – Windshield Projector

How cool would it be to use your whole car windshield, as a projection screen? Now you can remove the dash almost completely and have a bigger windshield which can use the lower space for MPH, RPM, and Temperature displays.

There is also rising research to reduce the number of accidents related to texting while driving. Voiceing technology originally conceived by Dr. Gilbert is one such approach. Their approach is to instead send short voice messages via the phone. Thus, the user could conceivably do everything without straying their eyes from the road.

My idea is to add an HDMI slot in the console of a car that has this projection technology. Now, you can plugin any phone that has a mini-HDMI port (for instance the Droid X) into the console and have a text message project directly on your windshield when you receive it. The one flaw in this: how would you reply to the text message? You would still have to look at your phone.

Conclusion

My mind is buzzing with ideas constantly. I’ll continue to post the ones I don’t expect to ever implement (although I would in a heartbeat if I had time or funding) in hopes that someone WILL take the idea and go with it. I simply think these products would be very cool and futuristic (and some of them practical :]). Seeing them implemented would be incredibly satisfying.

$140 gas both ways
+ $90 food
+ $10 transportation (subway tickets)
+ $18 iMax movie (Dinosaurs 3D)
————————————-
$258 total for 2 people

Tips and Tricks

Parking

Parking is incredibly expensive in Washington DC if you’re inexperienced. Many people advised me to park at a subway station that has long-term overnight parking (Shady Grove, Fraconia-springfield or Huntington terminal) and simply subway into the city. Since it was a weekend trip, however, we were able to park in the street for the entire trip. Weekend street parking is free and available in some areas from Friday at 7pm until Monday at 7am. We took advantage of this the whole time.

On Monday, we left early to eat and to check out the statue park and art gallery. We reached the statue park gates at 9:30am (before they opened) and managed to get a front row parking spot (I’m super proud of that)!

My sweet parking spot

Stuff to See

There is so much free stuff to do in DC. We checked out the Museum of Natural History, the Art Museum, the Statue Park, drove around Mount Vernon and went to the top of the George Washington Monument.

The George Washington Monument was definitely one of the highlights of the trip. If you line up at 7am at the ticket booth near the monument, you can get a timed ticket that allows you access to the top of the monument. On the geeky side, I’m thinking of using google street view to stitch all the images of the view together to create a really cool panorama experience.

Photos

There is so much more we can do in DC, so we’ll be back. Here are some of my favorite photos from the trip.

Skeletal Animation

I want to see a graphics library built on top of WebGL that supports rigged meshes. For instance, there was a blog post recently about combining the Kinect with WebGL, but there is currently no easy way to connect that skeletal information to a model for interactivity. In order to see Kinect games, training environments, etc… a skeletal library would be very useful.

Imagine if you will, logging on to a website called kinectworkoutonline.com. On this site you can select any one of many workout routines, in which a simple WebGL app loads and asks you to perform certain exercises. The kinect can then do some detection to see if you are working out correctly/make it fun. Further, it could be expanded so that other people can see how effectively/how long you worked out.

The target demographic for a site like that would be someone looking to get fit, but needs a little social nudge which you can’t necessarily get from a regular Kinect workout game (yet). Research is starting to show that society has a big impact on how much we choose to workout.

EDIT: Turns out glge has had support for skeletal animations for a year!

Virtual Human Library

Now, turn this skeletal support into a full blown virtual human (VH) library. Make it simple enough to use (like haptek was back when it was new). Allow the VH to smile, frown, wink, etc on command and even perform some simple gestures.

Allow this to be displayed on a transparent canvas and give it text-to-speech capabilities and you can have a VH that can give a tour of a website, or a web application easily and effectively (and for blind/sight-challenged people too).

One of the best displays of a virtual human I had when I was little was in the cut scenes from Return to Castle Wolfenstein. Striving for something like that to begin with would be very cool.

Discussion

Now we have a VH library, what else can we do with it? The possibilities grow exponentially. I would start with simple things like a VH webpage tour guide. As a graduate student, I could see a user study being done on that and (probably) getting published.

From a non-researcher standpoint, you could incorporate this library into an online video game (why not recreate Return to Castle Wolfenstein?).

Optimism

I’m certainly not an expert at WebGL. But, I’m going to make a valiant effort to start adding VH support to three.js (Maybe I can build off some code that was already started for it?).

I will stop there. If you have some other ideas on how a VH library addition could benefit WebGL, feel free to comment!

1. If Haptek Player is already running, press CTRL+Shift+ESC to bring up the Task Manager.
2. Find HapAXPlayer.exe (or iexplore.exe if running in a web browser) in the processes tab
3. Right-click the program and go to Set Affinity…
4. Uncheck all the CPUs except 1 of them
5. Enjoy Haptek running at normal speed!

Pre-requisites

You should already have the following:

• Microsoft Visual Studio (any recent version)
• OpenSceneGraph (and, at least, the ability to compile/run any OpenSceneGraph example)

Handling Dependencies

OsgAudio’s wiki mentions there are the following dependencies:

• OggVorbis
• OpenAL
• FreeALUT

Let’s handle Ogg and Vorbis first:

1. Create a folder to store all the dependency’s source code (I called it ‘source’)
2. Create another folder to store all the compiled source, which will be in the form of an SDK (I called it ‘bin’)
3. Navigate to OggVorbis and download libogg-x.x.xx.zip and libvorbis-x.x.xx.zip (found in the developer section).r
4. Extract both zip files to your ‘source’ folder.
5. Enter your libogg-x.x.xx directory and go into the ‘win32′ directory.
6. Go inside the directory corresponding to your version of Microsoft Visual Studio
7. Open libogg_dynamic.sln
8. Build the solution
9. Inside the ./libogg-x.x.xx/win32/VSxxx/ directory, there should now be a win32/release directory (if not, make sure to build the release version of the code)
10. Inside your ‘bin’ directory, create a folder called libogg. Inside this folder, create a ‘lib’ and an ‘include’ directory
11. Copy the libogg.lib and libogg.dll files from the win32/release directory into your new ‘bin/libogg/lib’ directory
12. Copy the ‘include’ folder from the libogg source folder and paste it to your newly created ‘bin/libogg’ directory

You can now build items that rely on the Ogg libraries. For example, let’s now build Vorbis:

1. Similarly, navigate to your libvorbis-x.x.x folder and go in the win32/ folder.
2. Open the dynamic solution and build the release version of libvorbis.

At this point, you WILL receive an error that ‘libogg.lib’ cannot be found. To fix this, do the following:

1. Open up the solution file (libvorbis_dynamic.sln)
2. In the top menu bar, navigate to ‘Tools->Options’
3. On the left of the options window, navigate to ‘Projects and Solutions->VC++ Directories’
4. On the right side, under ‘Show directories for:’ select ‘Library files’
5. Create a new entry by selecting an empty spot in the white textbox area. Type-in/browse to the ‘lib’ directory you created for libogg.
6. Now the same for ‘Include files’. Except type-in/browse to the include directory you copy/pasted for libogg.

After compiling libvorbis, create a folder in your ‘bin’ directory called ‘lib’ and copy libvorbis.dll, libvorbisfile.dll, libvorbis.lib and libvorbisfile.lib from the Win32/Release folder to the lib directory you created. As with libogg, copy the include folder to your bin/libvorbis directory.

GOOD! Now OggVorbis should be good to go. Let’s handle OpenAL and freeALUT.

1. Navigate to OpenAL’s download page
2. Install OpenAL (use OpenALInstaller) and it’s SDK (use OpenAL11CoreSDK).
3. The OpenAL SDK will default to your ‘Program Files’ folder, keep this in mind for later use
4. Back on the downloads page, click ALUT.
5. Download freealut-x.x.x-bin and extract it to the ‘bin’ folder you created

At this point, you should have 4 different directories in the dependency ‘bin’ folder that you created. If not, shoot me a comment and I might be able to help.

Finally, let’s build osgAudio.

Building osgAudio

1. Navigate to osgAudio’s download page and download osgAudio_xx_xx_xx.zip.
2. Extract it to the ‘source’ folder you created earlier
3. Rename the extracted folder to osgAudio_xx_xx_xx-PreCMAKE
4. Download/Install CMAKE if you haven’t already
5. Run CMAKE
6. Click ‘Browse Source’ and select the osgAudio_xx_xx_xx-PRECMAKE directory
7. Click ‘Browse Build’ and store it next to your other osgAudio folder but with a POSTCMAKE suffix ‘osgAudio_xx_xx_xx-POSTCMAKE’

At this point, when we run CMAKE (by clicking Configure), it will attempt to find the dependencies we compiled earlier. If it’s successful, we can then open up our osgAudio_xx_xx_xx-POSTCMAKE directory and build the solution it created. But, it likely failed.

Basically, for every RED box that appears in the settings list, you need to do something. As an example, here is a screencap of my settings:

osgAudio cmake settings

YAY! Now we have the solution file for osgAudio, but we STILL need to compile it!

1. Open up your osgAudio_xx_xx_xx-POSTCMAKE directory and double-click osgAudio.sln to open it in Microsoft Visual Studio.
2. If, for some reason, it complains about a missing library/include file. Navigate to Tools->Options and add the directory as we did with libogg and the other libraries.

After building the release version of osgAudio successfully, copy the lib and include folder from the source folder to the ‘bin’ folder you built earlier.

Your final directory listing SHOULD look something like this:

PHEW, that’s it!

Further Troubleshooting

I’m missing xxx.lib – Linker Error! Open up the solution file you are working with and go into Tools->Options. Then, on the left, navigate to ‘Projects and Solutions->VC++ Directories’. Use the interface to add your include and library directories (see screencap below):

If you are getting any other weird errors when building your own projects, you probably did not add the correct .lib files to link with. Fix this by doing the following:

1. Open up your solution file
2. On the top menu-bar, navigate to ‘Project->XX Properties’
3. In the listing on the left, navigate to ‘Configuration Properties->Linker->Input’
4. Under ‘Additional Dependencies’, add osgAudio.lib (for Release mode) or osgAudiod.lib (for Debug mode) as in the picture below

The Code

I won’t waste your time, here’s the source code.

package {
	import org.flixel.*;

	public class StarField extends FlxObject {
		public static const NUM_STARS:Number = 75;
		private var _stars:FlxGroup;

		/**
		 * @param	ang This is the angle that the starField will be rotating (in degrees)
		 * @param	speedMultiplier
		 */
		override public function StarField(ang:Number = 90, speedMultiplier:Number = 4):void {
			angle = ang;
			_stars = new FlxGroup();

			var radang:Number = angle * Math.PI / 180;
			var cosang:Number = Math.cos(radang);
			var sinang:Number = Math.sin(radang);

			for ( var i:int = 0; i < StarField.NUM_STARS; i++ ) {
				var str:FlxSprite = new FlxSprite(Math.random() * FlxG.width, Math.random() * FlxG.height);
				var vel:Number = Math.random() * -16 * speedMultiplier;

				// change the transparency of the star based on it's velocity
				var transp:uint = (Math.round(16 * (-vel / speedMultiplier) - 1) << 24);

				str.createGraphic(2, 2, 0x00ffffff | transp);
				str.velocity.x = cosang * vel;
				str.velocity.y = sinang * vel;
				_stars.add(str);
			}
		}

		/**
		 * Rotate the starField
		 * @param	howMuch Input the amount of rotation in degrees
		 */
		public function rotate(howMuch:Number = 1):void {
			angle += howMuch;

			var radang:Number = angle * Math.PI / 180;
			var cosang:Number = Math.cos(radang);
			var sinang:Number = Math.sin(radang);

			for ( var i:int = 0; i < StarField.NUM_STARS; i++ ) {
				var str:FlxSprite = _stars.members[i] as FlxSprite;

				FlxU.rotatePoint(str.velocity.x, str.velocity.y, 0, 0, howMuch, str.velocity);
			}
		}

		override public function update():void {
			_stars.update();

			for (var i:int = 0; i < _stars.members.length; i++) {
				var star:FlxSprite = _stars.members[i] as FlxSprite;
				if (star.x > FlxG.width) {
					star.x = 0;
				} else if (star.x < 0) {
					star.x = FlxG.width;
				}
				if (star.y > FlxG.height) {
					star.y = 0;
				} else if (star.y < 0) {
					star.y = FlxG.height;
				}

			}
		}

		override public function render():void {
			_stars.render();
		}
	}

}

Now to use it, simply add the following in one of your states:

private var sf:StarField = new StarField();

// state constructor
override public function StarState():void {
     this.add(sf);
}

Get the star field demo source code

I also used this star field class in my FIRST ever flash game. Face Defender.