Skip navigation


warning: Creating default object from empty value in /var/www/vhosts/ on line 33.


After nearly five years of development, Polytron’s Fez has been released on Xbox Live Arcade for 800 MSP. The winner of this year’s IGF Grand Prize Award, Fez is a non-linear puzzle platformer where you can rotate the camera to reveal the world’s third dimension. The game features a soundtrack by Rich “Disasterpeace” Vreeland, which will be released on April 20th but is available for pre-order.

TIGdb: Entry for Fez

Fez, by Polytron
Screenshot taken from playXBLA.

Your rating: None

Today's collection of independent game links includes more indie game previews, a couple of development updates, the usual round-up of interviews with developers from around the 'net. (image source)

Gamasutra: The Solitary Creativity of Pixel
"An extensive interview with Cave Story developer Daisuke 'Pixel' Amaya, in which he expounds on his inspirations, creative philosophy, and the thoughts and feelings which lead him to develop the 2004 indie game."

Experimental Gameplay Project: Disintegrate in July
"While last month's theme was about combining multiple elements in new and delightful ways, this month's is about reducing said elements to nothing. Your challenge for July 2011, developers, is to make a game around the theme: Disintegrate."

GameSetWatch: New Comic-based Game From Daniel Benmergui
"Benmergui just unveiled his next game, Storyteller, which he says is his most ambitious project yet. It's essentially a storytelling puzzle videogame based on comics, and is designed to be more gamey than Today I Die and memorable multi-ending title I Wish I Were the Moon."

Polarcade: Simon Stafsnes Andersen from D-Pad Studio Interviewed
"Norwegian D-Pad Studio is an award-winning game company who is currently working on their first big game, Owlboy. Polarcade decided to get in touch with Simon Stafnes Andersen, one of company's founders, and ask him about their past, present and future."

Indie Games Channel: Robin Arnott on Deep Sea, Sensory Deprivation
"Deep Sea is a horror game that takes place in total darkness in an aquatic setting. That pitch-black darkness is achieved through the mask, with the game taking place entirely through audio cues. Robin Arnott was happy to share more information about Deep Sea, the importance of sound design, and his overall experience at this year's E3."

Gamasutra: Mojang's Scrolls To Follow Minecraft Launch Strategy
"At the Gamasutra-attended Gamelab 2011 in Barcelona, Spain, Mojang Specification's Daniel Kaplan dropped a few new details about the future of its hit online game Minecraft, and the studio's next project, Scrolls, which was revealed at the last GDC."

Indie Games Channel: Super Meat Boy dev discusses next game
"Super Meat Boy developer Team Meat is already working away on its next game, which the indie describes as being of a more experimental and ambitious design than its breakout hit."

Gamasutra: 15 iPhone Game Observations, Before and After
"I spent a lot of time playing iPhone/iPad games to do some research as I dipped into iPhone game development. When I got a lot more familiar with the App Store's nuances and what other games are doing in general, I wrote up 15 observations to mull over as an iPhone game developer."

Experimental Gameplay Project: Mashup Roundup
"This month's mix of mashups made for many intriguing mixtures. Often when this kind of combining and reworking goes on some very interesting gameplay can emerge, and that was no exception for this month. Let's check out what's brewing in these 11 games."

Leukocyt Blog: Interview with Supergiant Games
"Supergiant Games is a small indie studio based in California, and Bastion is their first title. Greg Kasavin, the Creative Director at Supergiant Games, and Jen Zee, the artist behind Bastion's art direction, answered a few of our questions about their upcoming action RPG for the XBLA."

Your rating: None

What I needed and wanted was easy and simple: to load a 3d object (geometry + some materials and textures) at runtime, using just a URL as parameter. The only solution seemed to write my own importer.

Basically, I had the choice between Collada and Wavefornt OBJ. I would choose OBJ any time of the day because it's a simple, concise plain-text format, while Collada is bloated and is XML-based.

It's not that I hate XML (although I'm not a big fan either) but in order to parse XML you need to include a pretty weighty DLL in your *.unity3d file, around 850Kb, which in this case (and in many others) defeats the purpose. Still, it's good to know that it possible, and there are situations when it's ok to use it. If you want to learn more about Unity3D and XML there's a awesome article on this topic by Paul Tondeur.

It turned out that while it's not rocket science to write an OBJ importer, it's not exactly banal either. I spent a few days coding it so I thought I'll share this with everyone - maybe someone will make good use of it.

Here's a package with the source code (v1.1) (or a version that works in Unity 3 (v 1.2)), along with a simple scene demonstrating how it works. In fact it couldn't be simpler. All you have to do is to create an instance of the OBJ class and start a coroutine to load the contents, like this:


  1. string path = "http://www.everyday3d/unity3d/obj/monkey.obj";
  2. OBJ obj = new OBJ();
  3. StartCoroutine(obj.Load(path));

Supported features

  • Vertex, normals and UV data
  • Multiple objects per file
  • Vertex groups and multiple materials per object
  • MTL files, diffuse and specular materials
  • Basic textures

And it's all at a cost of ~12Kb extra added to your final file!

Your rating: None

Just as I was thinking about an interesting demo to play with drawing functions in Unity3D, Mrdoob published his Harmony drawing tool made with HTML5/Canvas. It looks really cool, so I though how about doing this in 3D? I only had to figure out how to draw lines.

I did some research and below I present 3 different solutions. You can grab the source of the examples discussed below here.

Drawing lines with Line Renderer [demo]

When it comes to lines, the first thing you'll bump into in the Unity3D API is the Line Renderer component. As the name suggests, it is used to draw lines so it seems the right tool for the job. Lines in this case are defined by 2 or more points (segments), a material and a width.

It has an important limitation: the line must be continuous. So if you need two lines, you need two renderers. The other problem is that the Line Renderer acts very strangely when new points are added dynamically. The width of the line does not seem to render correctly. It's either buggy or just wasn't designed for such use. Because of these limitations I had to create a separate Line Renderer for each tiny bit of line I'm drawing.

It was easy to implement, but not very fast since I end up spawning lots of GameObjects each with a LineRenderer attached. It seems to be the only option if you don't have Unity3D Pro though.

Drawing lines as a mesh using Graphics [demo]

The Graphics class allows to draw a mesh directly without the overhead of creating game objects and components to hold it. It runs much faster than Line Renderer, but you need to create the lines yourself. This is a bit more difficult but also gives you total control of the lines - their color, material, width and orientation.

Since meshes are composed of surfaces rather than lines or points, in 3D space a line is best rendered as a very thin quad. A quad is described with 4 vertices, and usually you'll only have the start and end points and a width. Based on this data you can compute a line like this:


  1. Vector3 normal = Vector3.Cross(start, end);
  2. Vector3 side = Vector3.Cross(normal, end-start);
  3. side.Normalize();
  4. Vector3 a = start + side * (lineWidth / 2);
  5. Vector3 b = start + side * (lineWidth / -2);
  6. Vector3 c = end + side * (lineWidth / 2);
  7. Vector3 d = end + side * (lineWidth / -2);

First, you get the normal of the plane on which both start and end vectors lie. This will be the plane on which the line-quad will located. The cross product of the normal and of the difference between end and start vectors gives you the side vector (the "thin" side of the quad). You need to normalize it to make it a unit vector. Finally calculate all 4 points of the rectangle by adding the side vector multiplied by half width to both start and end points in both directions. In the source code all this happens in MakeQuad and AddLine methods, so take a look in there.

It wasn't easy to implement, but once I was there it runs pretty fast.

Direct drawing with GL [demo]

No fast is fast enough! Instead of leaving this topic and live happily with the Graphics solution, I kept searching for something even better. And I found the GL class. GL is used to "issue rendering commands similar to OpenGL's immediate mode". This sounds like fast, doesn't it? It is!

Being much easier to implement that the Graphics solution it is a clear winner for me, the only drawback being that you don't have much control over the appearance of the lines. You can't set a width and perspective does not apply (i.e. lines that are far behind look exactly the same as those that are close to the camera).


For massive & dynamic line drawing LineRenderer is not the best solution, but it is the only one available in Unity free version. It can surely be useful to draw limited amounts of static lines and this is probably what it was made for. If you do have Unity3D Pro, the solution with Graphics is reasonable and very flexible but if it is performance you're after choose GL.

Your rating: None