National Geographic has recently announced their winners for The Best Science Photography of the year. Above is the picture taken by Sung Hoon Kang at the biology department of Harvard University. Not only did it win National Geographics’s contest, but was selected as the best photograph in the 2009 International Science and Engineering Visualization Challenge. Quite stunning. In fact, all the runner ups that were selected are quite awesome to look at as well.

[Link]

For those of you who do not know, Dock Phillip Ellis, Jr was a Major League Baseball player who pitched for the Pittsburgh Pirates. He is best remembered for the claim that he threw a no-hitter in 1970 while under the influence of LSD. In this video, Dock Ellis recalls what happened that day. Quite amusing.

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.

Here’s a video I captured of a recent class project which emphasized replacing OpenGL’s fixed-function pipeline with custom vertex and fragment shaders. I used low-level assembly ARB language to implement this.

This box shows several shader techniques such as bump-maps, height map parallax, specular highlight and attenuation.

Developers, who are unfamiliar and passionate, band together and combine their prowess in creating a game. There is no fee required to participate. All you need is your laptop and a love for making games. Ah, what a beautiful idea.

Having been surrounded with game developers every single day for about half a year, I have come to realize that they are exactly my type of people. Smart, analytical, weird, zaney, eccentric, genius, technical and passionate are all adjectives that can be used to describe the majority of game developers. You place them all in a room and their brains will sync-up to dump something creative and wonderful onto your computer screen.

I had an absolutely wonderful experience, one that will never fade in memory. However, I was initially hesitant to go. Given that most commercial games nowadays take years to develop, what can a small team of amateurs developers possibly create in 48 hours?

[Play Our GGJ Game]

Here are some things that I have learned from my experience in this year’s Global Game Jam:

Create a Core Gameplay Mechanic
If you analyze any great game, you will notice that if you strip off all the polish of the game,what is left behind is the basic core mechanic that serves as the foundation of the entire game. Given that this year’s theme was deception, we settled on having a stealth mechanic. You had to get from point A to point B by deceiving the enemy. And with simple, well-implemented AI, you can have the player feel the tension of being detected, and that is fun.

Just find one simple core mechanic that is fun and milk it for all it’s worth. There will not be alot of time for polish, so all that is shown to the player will be the bare bones of your game.  Thus, you better make sure that the basic gameplay is strong enough to support itself.

Don’t Overscope, Don’t Be Lame
In such a limited time frame, it is absolutely essential that you do not overscope your feature set. It’s so easy to want to build an epic game, but you forget that you only have less than 0.001% of the number of man-hours required to create a full game.

In terms of choosing an engine to use as the technical foundation of your game, make sure you find one that is flexible and high-level enough to allow you to jump right into coding. Given such a limited time-frame, programmers want to be coding games, not engines, so make sure your engine supports all the basic functionality that allows you to display entities and to have them moving around in the screen. We chose flixel because we believed that it provided all the functionality that our game needed. Some hardcore team went straight up C++/OpenGL from scratch (File->NewProject), and that is silly.

Version Control
Version control software such as SVN is absolutely essential in order to streamline your workflow. This method allows all developers to sync up all their codebase and assets into one hub which can be accessed by your entire team. If you prefer passing a USB around to everyone in your crew every time you want to make a change, well, you’re dumb.

Sound
Having sound brings life to your game. Without sound, games feel flat and it becomes impossible for players to immerse themselves into your game. Make sure to find a song that is interesting/dynamic enough to loop without annoying the player. And if you are looking for a great tool to create sound effects, consider DrPetter’s SFXR.

Conclusion
To do something I love with others who share the same passion has not only made this weekend an awesome weekend, it has made it one of the grooviest weekends ever. So if you have the stamina and the passion for games, I highly recommend that you participate in next year’s Global Game Jam.

Alex Roman has created an absolutely stunning CGI piece illustrating architecture art from a photographic point of view where main subjects are already-built spaces. Sometimes in an abstract way. Sometimes surreal. It’s absolutely brilliant.

The Corporate Adventures of Mr. Mask is a game about a deceptive spy named Mr. Mask who endeavors to take down a corporation. To accomplish this daunting task, he must sneak past body guards with Fu-Manchu beards to get to the final sumo-wrestling boss. It’s quite badass.

This game is a Flash game which uses the flixel framework and it is hosted at: http://globalgamejam.org/2010/mr-mask.

During the development process, my friend Loren over at MutualDestruction hosted a blog which documented our 48 hour experience.

Anyhow, try it out and vote up if you like it.

Play it here! (Flash)

Above is a little test app I’ve created to show the deliciousness of the mass-spring damper system (also known as a harmonic oscillator). Move your mouse anywhere inside the box and it’ll swing the ball accordingly to emulate real mass-spring physics.

In this post, I will briefly explain how you can add a mass-spring damper system into your own engine to simulate cool swinging action.

Source code (Actionscript 3.0): [ MassSpringDamper.as ]

A mass-spring damper is a system where there exists a mass attached at the end of  a spring. The forces that are involved in this system are the forces generated by compression/relaxation of the spring and, of course, gravity.

Using the F=ma approach, the acceleration gained from the mass-spring is:

a = ( -cv – k(x – xo) ) / m

Where m is mass of the object, v is velocity, (x-xo) is the distance between the end of spring and the mass, c is the friction constant and k is the spring constant.

In order to prevent your system from accumulating errors and blowing up, we will try to avoid using the classic forward euler integration method. Instead, we use the safer approach, the symplectic integration method. If you didn’t understand this last part, it’s okay. Just remember that systems like these can easily accumulate errors and just go completely nuts if you don’t take special care.

Anyhow, the source code is attached. Enjoy.