I am working not on a game itself, but in a more generic game engine, so i’m trying to find the methods that works the best in older hardware and also scale well.
First, i looked at Deferred Shading, which seems to be the most hyped method right now. Technically it looks like it’s superior to the others, as it scales the best… however some issues bothered me
- ambient/specular per pixel seem mainly limited to an intensity value, not a full color, given it needs more bandwidth for that.
- in several places and forums it says it’s still “not as fast”
Second, i looked at single-pass lighting, which at first glase it seems like an ideal situation, but them it seems it has several shortcomings like
- I have to keep track of which lights affect which objects, all the time
- I need to pre-render the shadowmaps, and that could overflow the vram
- if overdraw is high, it looks like this technique may slow down things
And Finally, i looked at multi-pass lighting, since several posts seem to indicate that current hardware is ideal for it, however it seems to have a few shortcomings, like…
- Is it really ok to render a complex object many times if light hits it? from what i can gather this is what modern videocards are good at, since shaders for this method should be super simple… but still…
- I guess the CPU will be little more busy asking the octree which objects are in the light’s area… can this get to be bad in modern games?
Well, that summarizes my doubts about my research… I’m sorry if this has been asked before, but i couldn’t find a good comparison of the advantages/disadvantages of each method.
there is no “simple” solution, that means there is also no “best way” on which you are on the safe side for every purpose (3d, topdown…) for every hardware generation.
The best thing for you to do, would be implementing “everything” (assuming you are a student and what to learn), get yourself experience.
once you have basics for each, you will find ways to mix/combine techniques and so on.
e.g crysis stores some stuff in screenspace as interim, but does not do classic deferred shading.
to combat overdraw you will have stumbled upon “z-pass first”.
if you want to make a versatile engine and support old hardware you might also want to think of the “art” you can produce for it. Ie. will you be able to make use of tons of textures per material… if not, do simple stuff, saves you time and means you get to the “game” making faster (or use engines around). And for the hardware that is faster, you could simply throw in more “simple objects” eventhough it isnt the optimum rendering them with that modern hardware, it doesnt hurt that bad either, unless you want to make a unreal/crysis game with tons of stuff going on and things to render.
If your goal is making an engine for tech education reasons, then go for experimenting with techniques yourself.
I would say “learning by doing” is an industry standard. Of course for each method/problems you will find certain solutions (e.g cascaded shadow maps,…) but in most cases you will have slight variations of techniques for your case.
No standard exists, what you really need to do is define what your needs will be for your application, and go from there. If you need a bunch of dynamic lights, all with interactive shadows, you can do it, but you will have to limit the geometric complexity of your scene.
If great lighting that doesn’t change a lot is needed, look into light mapping techniques that are still very popular. Do you need global illumination effects?
Tailoring a renderer to a project still has many advantages.