So I've been trying to learn my way around the most popular, modern techniques for game-graphics / realtime-rendering. I considered myself pretty knowledgeable at OpenGL back when immediate mode was still popular, but after returning to OpenGL recently, I've had to learn a lot of new concepts.
I've learned about and implemented:
Shaders
Principles of VBOs and their interaction with Shaders
GPU Skinning.
Programming Lighting Calculations in Shaders
Shadow Maps and Cascaded Shadow Maps.
It seems that deferred shading/shadows are now the method of choice so I feel it is in my best interest to build a graphics pipeline using this system.
My two dilemmas are:
1. Does it make sense for me to pursue a deferred rendering system at this point (given my experience, etc.)
2. Should I continue learning from scattered papers and tutorials on the web or should I purchase a comprehensive textbook on modern OpenGL techniques?
In either case, I am finding it surprisingly difficult to find both textbooks and online articles that explain deferred shading and shadows in detail.
Advice, or suggested reading would be appreciated.
Deferred rendering in OpenGL: whether or not and where I should learn
I would say it's a useful exercise. There's still plenty of validity to the technique. I see the future of graphics techniques for engines being a myriad of approaches mixed together. Deferred is obviously an awesome technique for many lights on opaque surfaces. But many deferred renderers have a sort of traditional forward renderer stuffed inside to do translucent objects as well. As far as where to learn this stuff, I spent most of my time piecing together tiny articles talking about techniques, but in the end, how you implement it might be entirely dependent on the scope of the engine/game being developed. For instance, the battlefield 3 engine has buffers specific to terrain info storage, where my engine wants to accommodate both ground/space based games so I can't count on this info being there. In the end, I sincerely recommend you piece through some code. Feel free to look at mine as I've already done a lot of what was mentioned, but it's really up to you to discover your own techniques. 
https://github.com/p...rerDeferred.cpp
https://github.com/p...rerDeferred.cpp
Author
Thank you for your response, PaloDeQueso!
Can you link me to some of the articles or tutorials you used to learn about deferred rendering?
Can you link me to some of the articles or tutorials you used to learn about deferred rendering?
I have a game that was based on forward rendering, and decided to go for deferred shading. For me, it worked very well to do it step-by-step. The way I did it was:
The layout now looks as follows:
Full source code is available at https://github.com/larspensjo/ephenation-client.
- Render into a color buffer (FBO) instead of the screen, and then add a second pass that rendered to the screen.
- Gradually setup a few more textures for G-data, and extend the second phase with post processing.
- There are lots of intersting things you can do with deferred shading, and you can now radually test them out.
- After a while, I had monster sized deferred shader, and I decided to split it into several smaller stages.
- In that split, I found interesting possibilities for optimization (e.g. tiled rendering). This is where it all started to shine.
- It now turned out to be possible to have a master control function that selects, as needed, from the available deferred shaders, to get the final result. This makes it easier to adapt to systems with various levels of hardware support, and adapt the game to various scenarios.
The layout now looks as follows:
Full source code is available at https://github.com/larspensjo/ephenation-client.
Heres a good article thats among one of those i found very useful when I implemented my deferred rendering engine: http://www.beyond3d.com/content/articles/19/1
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
