[janus]

(Click for video; DivX 6.0, ~4MB)
Anybody interested in seeing an article that explains the techniques used in this video? I've been thinking about writing a nice detailed article on doing 2D lighting, but now that I've implemented this normal mapping technique (that as far as I can tell, has only been used in 2D by one other person), I think it's definitely worth documenting it so other people can use it. :)

A short laundry list of the techniques and primitives used in this video:
Normal mapping
Convolution filtering (gaussian blur, specifically)
Alpha masking
Gradient polygon rendering
Radial gradients
Offscreen surface rendering/render-to-texture (this particular video was recorded running in OpenGL, though the algorithms also work fine in software, albeit slower)
Lightmap rendering
Raycasting

And of course, if you have questions (or suggestions!) you can just post them here too. :)

[Ninkazu]

Hell ya that'd be great.

[Gooseman]

Woah that video is cool! I'd love to know how it was done, even if it doesn't help me replicate it in any way, shape or form.

[bay]

perhaps the beginning to a game/graphix programming book career?

.02$

[Adam]

Mucho grande swank. I coudn't even clone your old lightining engine well enough so how am i meant to do this? :P
_________________
https://numbatlogic.com

[Verious]

Whoa! That video was well worth the DivX codec install. I'de love to know how you achieved those lighting and physics effects. I really like how the objects cast shadows and how objects react to the explosions.

I'm definately interested in the article.

[RuneLancer]

That looks incredible! Although, hate to burst your bubble, it's not 2D. It's rendered using a 2D projection with a 3D API (OpenGL.) A lil' less impressive, because true 2D would require (most likely; unless someone came up with a really stunning algorithm) per-pixel calculations to acheive an effect like this. Heavy, especially without the use of a pixel shader to speed up the operations.

Unless everything's rendered to a texture and OpenGL's just used to get things onscreen. ;) Then, well, forget what I said: that's definately impressive.

Nevertheless, it's a very impressive application of normal mapping and calculated shadows. Objects cast very realistic shadows and, quite frankly, it's a lot more than I could come up with. I'd love to know how to pulled it off (and what specs the demo ran on.) Great work!
_________________
Endless Saga
An OpenGL RPG in the making. Now with new hosting!

[janus]

[bay]

[Ren]

Very neat demo. I wouldn't read the article (i'm not a code-phile really), but I love the way it looks, great stuff.

[RuneLancer]

Nice. :)

So you basically did some interpolation and whatnot here and there to keep down the amount of pixels to calculate? That brings me back, heh... Reminds me of a raycaster I wrote for a college course (realtime! In those days, it was something rather new and PCs had a hard time keeping up with a full-screen retrace every frame.)

Little trick I had that may or may not apply to your situation was to cast a ray. When it'd hit an object, I'd do whatever (calculate the color/texture, etc..) Next ray, I'd start MUCH closer to the object (a few pixels away from where the previous one hit). This cut down tremendously on the amount of time spent casting rays in the scene. How I did this was based on a few assumptions and precalculated stuff: first of all, an object fit within a sphere of 'x' size and didn't have any awkward angles jutting out crazily (so the surface was smooth.) Second, I kept a "map" of how distant objects were from the viewpoint so I would know when a ray would intersect something and when I'd have to start calculating the ray from scratch.

Eh, I suck at explaining. Picture this: you have 5 spheres (traditional raytracer objects :P ) As you move around, you keep a list of vectors indicating the distance of the object, its size (as in, the smallest sphere that could contain the object's radius), and its relative position to the viewpoint (another vector.) When casting a ray, a very rough approximation is made to see if any of the 5 spheres are in the way. If not, the ray isn't traced (since it would be guaranteed not to hit an object.) If there's a sphere in the way, however, an approximation is made to determine how close is "close enough" without being "inside" the object (using the radius of its bounding sphere) and the tracing begins from there.

I'm guessing you raytrace to figure out if light hits an object or not. Making a rough calculation to see which range from the lightsource doesn't hit a sprite could allow you to skip a chunk of rays and go straight to the drawing phase. Or to figure out which ones DO hit an object and just skip straight to figuring out the object's outline.

Dunno if it's of any help. That was 2 years ago, and the only recent code I've written involving lighting is lazy 3D lighting done by the graphic card for me. :P
_________________
Endless Saga
An OpenGL RPG in the making. Now with new hosting!

[tcaudilllg]

Those are amazing shadows. Good work.

[Terry]

How much work is involved in doing something like this? There's a section of my game that would really benifit from a lighting effect like this. At the moment, I'm using an animated 2D lightmap with tiles blended on top of the regular one, which doesn't compare...

Well, I'm very definitly interested in a tutorial like that.
_________________
http://www.distractionware.com

[BadMrBox]

Can you put together a movie with the pink and yellow effects? Or rather, a exe? Would very much like run around in a room blowing things up.
I like your stuff :)
_________________

[Verious]

Janus:

Have you made any progress on the creation of an article/tutorial describing the lighting techniques used in your engine/video?