I finally got around to posting a video of the current progress. So far the project is going quite swimmingly, if I do say so myself. One thing I want to say is that I am amazed on the sheer power of the GPU’s geometry shader. I had no idea it was able to generate so many vertices at such interactive speeds. Each of the blades that are rendered is being generated procedurally in the geometry shader given only root positions, which is passed in the vertex buffer. Currently I render about 40,000 blades of grass at a solid FPS of 50FPS.

The swaying of the grass is being modeled by simple oscillators such as sine and cosine. There currently is no interaction that the player can have with the grass. However, my next step is to allow the user to affect the wind conditions of the scene. The wind condition vectors will be modeled using Navier-Stokes equations. Hopefully it comes out as cool as I see it in my mind’s eye. Stay tuned.

Grass is the most prevalent form of vegetation on the Earth’s surface. Thus, it is an essential element in rendering realistic outdoor scenes. But due to the geometric complexity of grass, rendering it realistically in real-time can be difficult and computationally expensive. Furthermore, to produce life-like representations of grass requires faithful physical simulations of movement provided by wind currents.

Ticking away are the moments that make up my final months in graduate school. And as my academic career winds to a conclusion,  I’ve been working hard and coding away at my master’s thesis project. My master’s thesis is all about discovering and implementing an algorithm to render luscious grass in real-time. My ultimate goal is to have hyper-realistic fields grass all over the place and all up in yo’ face!

Above is a screenshot I took of the current state of my project. It looks quite groovy so far, but my journey has just begun.

And if I ever see you internet folks in real-life, remind me to give you a high-five! You are all wonderful people.

[ Play Wasabi at ArmorGames! ]

The number of CPU cycles required to calculate a square root is dozens of times more expensive than that is required to execute a simple math operation. A basic 3D engine can have tens-of-thousands of square root operations per update, so any opportunity to approximate the square root will save you a good number of frame rates.

The code below approximates 1/sqrt(x) using only multiplication and bit-shift operations. This code was heavily used in the Quake II engine:

float InvSqrt(float x)
{
   float xhalf = 0.5f * x;
   int i = *(int*)&x;
   i = 0x5f3759d5 - (i >>; 1);
   x = *(float*)&i;
   x = x*(1.5f - xhalf*x*x);
   return x;
}

For those who are mathematically curious: The code above approximates the inverse square root by using Newton’s method.

[ Reference ]

In games that use rhythm as its core mechanic, the most important aspect is detecting if the user executes a certain action in the correct position in time. For example, in games such as DDR, the user must step on positional arrows at certain intervals in the musical sequence in order for the game to register the input as a successful action.

In this post, I will depart some knowledge that I learned while creating a rhythm game that will hopefully help you in your journey of making a beat-tastic love adventure!

First and foremost, it definitely helps (but is not required) to have some musical background. If you haven’t had any experience, you might want to brush up on some of the musical terminology.

BPM (Beats Per Minute)

Regardless if you use a full-length song or a small sound-loop, the most important aspect of any song is calculating its BPM. If the song’s BPM is not provided, the two things that you need to calculate the BPM is the length (in seconds) and the number of beats in the song/loop. Then, to calculate the BPM, you simply use the formula:

BPM = (num beats in song) * 60 / (num secs in song)

The BPM provides a foundation on which you can start testing for user inputs.

Break It Down

In the general case, we can assume that our song is in 4/4 time (also known as common time). What 4/4 means is that the song uses four quarter-note beats per bar.

What you want to do next is figure out how accurate you want your input to be.  Using eighth note seems to provide enough accuracy for most sequences. But depending on how complicated you want your player’s input sequence to be, you might want to go all the way to sixteeth or sixty-fourth if you plan to really punish your players with Yngwie Malmsteen-style arpeggios.

Below is a depiction of how a whole note is broken down.

Musical note values

Register Correct Beats

Now, you want to create a cool button sequence that you want players to press when the song is playing. What you want to do is store all the notes in the song that you want the user to hit in an array.

For example, say thatI have a funky, 1-bar drum-loop. And say when the then song is playing, I want to user to press down on a button every first, second, and third beat in the loop.

If I am using sixteenth notes as my input sequence’s precision, I would create an array like this:

Array beats = [ 4, 8, 12 ]; // 1st, 2nd, 3rd quarter note

So for each quarter note, there are four sixteenth notes.  The array above suggests that we want to detect the first, second and third sixteenth-note of each bar, so we multiply each value (quarter note) by four to get its corresponding value in sixteenth notes.

Detecting User Input

Now that you have your input sequence laid out, you can start detecting if players correctly pressed your sequence in time.

Every time the user hits a button, you must calculate which note (or which sixteenth note in our funk drum-loop example) the input corresponds to. To calculate that, you must know when, in the local time of the song, the button was pressed. What I mean by local time is the current time in the song that your game state is currently at. Say your song loop is only 10 seconds long but the game has elapsed a total time of 14 seconds. That means the local time of the song loop is 14-10=4 seconds.

To calculate the note position given the local time in the song, you can use this formula:

nth sixteenth-note = (time in secs in song) * BPM * (1/60) * (num_vals _per_beat)

In my example, we are using sixteenth notes. Say I have a local-time of 1.5 seconds of a song with 50 BPM. Since there are 4 sixteenth notes per beat, we can calculate the nth sixteenth note:

// BPM = 50, secs = 4, num_vals_per_beat = 4
nth sixteenth-note = (1.5) * 50 * (1/60) * (4) = 5

That means we were at the 5th sixteenth note in the song/loop. Since there is no 5 in our array [4, 8, 12], that means that the user did not press the button at the correct position in time according to what we set as our input sequence.

Go Easy, Bro

We can assume that the user will not press the input button at the exact moment in time that corresponds to your beat sequence (virtually impossible). So, what I did to remedy that is to give an acceptable buffer which provides the user a range of time such that if the user presses the button within this buffer, the game will register the input as correct. For example, if the user presses the button within 0.5 beats of the target beat, the input would register as a success.

So there you have it, a way to structure your code to provide a framework for rhythm games. Now go make some sweet, musical lovin’.

So I’ve been furiously coding away in my underwater lab. And now, I feel that Wasabi is at a good state in which it can be released out to the public in hopes to receive some critically delicious feedback.

I consider the game to be in alpha right now, which means it still needs alot of balancing and tweaking to do to make the fun truly shine like a star!!!

Anyhow, I hope you enjoy my interpretation of how the sushi business works in the real-world. I tried to be as accurate as possible. Also, feel free to leave me some feedback in any colour you like.

[ Play Wasabi ]

It has been a fun experience. And during the development process, Funkbot has been features on several sites:

• Pixel Prospector
• Fuxter (Russian)
• SuperLevel (German)

However, there are still some desyncing issues if you start doing something else while in the game (like browsing the web). Not exactly sure how to fix that, but if you stay in the game from start to finish, the music and the beat should be in sync.

Anyhow, it is time to move on to bigger and more delicious things. Hope y’all enjoy!

[ Play Funkbot3000 ]

In C++ code, one would derive singleton classes from a singletons template. Doing this prevents the coder from polluting your global space with nasty variables. (Also, the compiler does not guarantee the order that globals or statics are instantiated.)

Although Actionscript does not have templating functionality like C++, you can still make your desired class a singleton by simply adding a few functions:

package com.example
{
	public class SpriteManager
	{
		public function SpriteManager()
		{;}
 
		// Singleton methods
		//
		private static var _instance:SpriteManager = null;
		public static function CreateInst():void { _instance = new SpriteManager(); }
		public static function Get():SpriteManager { return _instance; }
		public static function InstExists():Boolean { return _instance != null; }
		public static function DestroyInst():void { _instance = null; }
	}
 
}

As you can see, you use a private static var _instance to hold the single instance of the class. The CreateInst() function creates a the single instance of that particular class:

SpriteManager.CreateInst();

You access the class by calling Get(). For example, if I wanted to fetch the instance of the SpriteManager, I call:

var manager:SpriteManager = SpriteManager.Get();

And there you go, a simple Actionscript 3 singleton class for the win. And on a related matter, there is a Playboy bunny named Sasha Singleton.

I’ve always been interested in rhythm games. But oftentimes, I feel that music takes a backseat to gameplay. And rightly so since most games focus on providing gameplay that merely uses music as support for building the ambiance or to convey emotion to the player.

However, once in a while, a game is developed which mend music and gameplay in innovative and fun ways that it makes you wonder about the vast possibilities of game design. Games such as DDR, Rockband, Parappa the Rappa and Rhythm Tengoku are all prime examples of games that were able to creatively integrate music and rhythm into its core gameplay to fully immerse the player in the music.

I am currently developing this Flash game on the side in hopes to learn more about using rhythm-based game mechanics. It’s called FunkBot3000, and it is game about funky robots which are fueled by the power of music. I am currently not sure on how much time I can devote to this project because of my busy academic schedule. But  I’ll try my best to bring it to some playable state.

[ Play FunkBot3000 ]

Although DirectX10 (Direct3D10) already has functionality that allows users to load images directly, it might not be enough. For example, DirectX is unable to load some image types such as TARGA (.tga) files. And if you are writing a OpenGL & DirectX10 dual-renderer, you might want unite both renderers under a common image library API. Plus, DevIL has a lot of great functionality, and you want to take full advantage of it. Below, I provided the code to load an image given the filename.

#include <IL/il.h>
#include <string>
#include <assert.h>
 
// Use this macro to verify if D3D10 function succeeded
#define HV(x) if(!SUCCEEDED(x)) MessageBox(NULL, #x, "HRESULT fail", MB_OK)
 
// Creates a shader resource view given a filepath & D3D10 device
//	@filePath - String of the file path of the image file
//	@pDevice - Pointer to the D3D10 device
ID3D10ShaderResourceView* MakeSRV( const std::string& filePath, ID3D10Device* pDevice )
{
	// Will be filled and returned
	ID3D10ShaderResourceView* pSRV = NULL;
 
	// Load image from DevIL
	ILuint idImage;
	ilGenImages( 1, &idImage );
	ilBindImage( idImage );
	ilLoadImage( filePath.c_str() );
	assert ( IL_NO_ERROR == ilGetError() );
 
	// Fetch dimensions of image
	int width = ilGetInteger( IL_IMAGE_WIDTH );
	int height = ilGetInteger( IL_IMAGE_HEIGHT );
 
	// Load the data
	ilConvertImage( IL_RGBA,IL_UNSIGNED_BYTE );
	unsigned char * pData = ilGetData();
 
	// Build the texture header descriptor
	D3D10_TEXTURE2D_DESC descTex;
	descTex.Width = width;
	descTex.Height = height;
	descTex.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	descTex.Usage = D3D10_USAGE_DEFAULT;
	descTex.BindFlags = D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET;
	descTex.CPUAccessFlags = 0;
	descTex.MipLevels = 1;
	descTex.ArraySize = 1;
	descTex.SampleDesc.Count = 1;
	descTex.SampleDesc.Quality = 0;
	descTex.MiscFlags = D3D10_RESOURCE_MISC_GENERATE_MIPS;
 
	// Resource data descriptor
	D3D10_SUBRESOURCE_DATA data ;
	memset( &data, 0, sizeof(D3D10_SUBRESOURCE_DATA));
	data.pSysMem = pData;
	data.SysMemPitch = 4 * width;
 
	// Create the 2d texture from data
	ID3D10Texture2D * pTexture = NULL;
	HV( pDevice->CreateTexture2D( &descTex, &data, &pTexture ));
 
	// Create resource view descriptor
	D3D10_SHADER_RESOURCE_VIEW_DESC srvDesc;
	srvDesc.Format = descTex.Format;
	srvDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
	srvDesc.Texture2D.MostDetailedMip = 0;
	srvDesc.Texture2D.MipLevels = D3D10_RESOURCE_MISC_GENERATE_MIPS ;
 
	// Create the shader resource view
	HV( pDevice->CreateShaderResourceView( pTexture, &srvDesc, &pSRV ));
 
	// Delete from IL buffer after image loaded correctly
	ilDeleteImages( 1, &idImage );
	idImage = 0;
 
	return pSRV;
}

There you have it. Let me know if you got any woes getting it to work. Thanks to my bud Manny for helping with the code.