Question

I have been working on an isometric minecraft-esque game engine for a strategy game I plan on making. As you can see, it really needs some lighting. It is difficult to distinguish between separate elevations because everything is the same shade. So my question is: can I shade just a specific section of a sprite? All of those blocks are just sprites, so if I shaded the entire image, it would shade the whole block.

Answer 1

Well, it depends on how you do your lighting.

Basically, sprites are just textured quads made of two triangles.

Traditional vertex based lighting (which is supported by the built-in but now deprecated functions) will just calculate the lighting for the 4 corners of that quad and everything else will be interpolated. This is quite fast but might result in the wrong lighting – especially with spot lights and big quads.

If you use directional lighting only, you might apply a normal map to your quads and thus influence lighting in a per-texel way, but that might still not be what you want.

The modern way would be to use shaders, i.e. the lighting is evaluated per-pixel. You’d then have to provide per-texel lighting information for your quad which is then used in the fragment/pixel shader.

Just to clarify, the meanings of some terms in this context:

• per-texel: per pixel in the texture, those value might be interpolated
• per-pixel: per output pixel, i.e. per screen pixel

Edit:

I just looked at your screenshot and it seems you’ll have to change the shade of sprite’s edges if the adjacent sprite is not on the same level. Assuming you already know which sprite edge should be visible (i.e. there’s a level change at that edge) you might just change the shading of the vertices that form that edge.

If you don’t use any lighting, you might just start setting the vertex color to white and to some darker color for the vertices that need shading. Then multiply your texture color with the vertex color which should result in darker edges.

Alternatively, if those level have different depths (i.e. different z values) you could use some shader for edge detection (e.g. some SSAO implementation).

Edit 2:

If you use plain old vertex lighting, applying weighted normals might help. Basically you calculate the weighted vertex normals from the normals of those triangles that share a vertex.

There are several methods doing this, one being to weight the faces based on the angle at that vertex. You could multiply the normals by those angles, add then together and finally normalize the resulting normal.

The result of that calculation might be something like this (ASCII art):

|       |         /
|_______|________/             
                 | /     |       |
                 |/______|_______| 

Lines pointing up are the normals, the bottom lines would be your sprites in a side view.