Reddit reviews Real-Time Rendering, Third Edition
We found 41 Reddit comments about Real-Time Rendering, Third Edition. Here are the top ones, ranked by their Reddit score.
NewMint ConditionDispatch same day for order received before 12 noonGuaranteed packagingNo quibbles returns
You have a long journey ahead of you, but here goes :D
Beginner
C++ Primer: One of the better introductory books.
The C++ Standard Template Library: A Tutorial and Reference: Goes over the standard template library in fantastic detail, a must if you're going to be spending a lot of time writing C++.
The C++ Programming Language: Now that you have a good idea of how C++ is used, it's time to go over it again. TCPPL is written by the language's creator and is intended as an introductory book for experienced programmers. That said I think it's best read once you're already comfortable with the language so that you can full appreciate his nuggets of wisdom.
Intermediate
Modern C++ Design: Covers how to write reusable C++ code and common design patterns. You can definitely have started game programming by the time you read this book, however it's definitely something you should have on your reading list.
C++ Templates: Touches on some similar material as Modern C++ Design, but will help you get to grips with C++ Template programming and how to write reusable code.
Effective C++: Practical advise about C++ do's and dont's. Again, this isn't mandatory knowledge for gamedev, but it's advice is definitely invaluable.
Design Patterns: Teaches you commonly used design patterns. Especially useful if you're working as part of a team as it gives you a common set of names for design patterns.
Advanced
C++ Concurrency in Action: Don't be put off by the fact I've put this as an "advanced" topic, it's more that you will get more benefit out of knowing the other subjects first. Concurrency in C++11 is pretty easy and this book is a fantastic guide for learning how its done.
Graphics Programming
OpenGL: A surprisingly well written specification in that it's pretty easy to understand! While it's probably not the best resource for learning OpenGL, it's definitely worth looking at. [edit: Mix it in with Open.gl and arcsynthesis's tutorials for practical examples and you're off to a good start!]
OpenGL Superbible: The OpenGL superbible is one of the best ways to learn modern OpenGL. Sadly this isn't saying much, in fact the only other book appears to be the "Orange Book", however my sources indicate that is terrible. So you're just going to have suck it up and learn from the OGL Superbible![edit: in retrospect, just stick to free tutorials I've linked above. You'll learn more from them, and be less confused by what is 3rd party code supplied by the book. Substitute the "rendering" techniques you would learn from a 3d book with a good 3d math book and realtime rendering (links below)]Essential Mathematics for Game Programmers or 3D Math Primer for Graphics and Game Development: 3D programming involves a lot of math, these books cover topics that OpenGL/DirectX books tend to rush over.
Realtime Rendering: A graphics library independent explanation of a number of modern graphical techniques, very useful with teaching you inventive ways to use your newly found 3d graphical talents!
Also for books I really liked Real Time Rendering as in introduction to 3D
You're going to need a lot of the same setup as you would if you were making a game, I think.
Have you seen the ogldev tutorials? They're pretty comprehensive and take you through building a lot of visual effects from the ground up. You'll need to cross-reference with other materials though because some topics on graphics you'll need to know the fundamentals on (like how relative coordinate spaces/scene graphs work conceptually).
Graphics development is hard, and requires a lot of study and conceptual understanding outside of just API usage. I've been picking up OpenGL/Gfx programming for about a year and I'm probably only a beginner-intermediate at this point.
I recommend:
http://www.amazon.com/Real-Time-Rendering-Third-Edition-Akenine-Moller/dp/1568814240
This book is really, really good.
Jason Gregory - 3D Game Engine Architecture is a great book although it does focus on C++, but the majority of the content is language independent and more concerned with architecture rather than implementation details.
And as noted before, Real-Time Rendering is a must-have.
I taught myself bits in high school with "C++ for Everyone". Despite its rating, I thought it was good 'cause it has exercises, and I did a lot of them. Works really well for laying foundations. I didn't go through the whole book though, and knowing the language is only part of the battle. You need to know about algorithms and data structures as well. For graphics, trees seem really useful (Binary space partitioning, quadtrees, octrees etc).
After university started, I read parts of "C++ Primer", which was when the language really started making sense to me. You'll get more than enough time to learn the required amount of C++ by next fall, but CG is heavy in math and algorithms. If your CS minor didn't go over them (much), my old algorithms prof wrote a free book specifically for that course.
For using OpenGL, I skimmed the first parts of "OpenGL SuperBible". For general graphics, I've heard good things about "Mathematics for 3D Game Programming and Computer Graphics", and "Real-Time Rendering".
Careful with C++. It may deceptively look like Java, but honestly, trying to write good idiomatic C++ after years of Java took a major paradigm shift
Despite what you mentioned, anyone interested in real-time graphics, or computer graphics in general should have:
http://www.realtimerendering.com
https://www.amazon.com/Real-Time-Rendering-Third-Tomas-Akenine-Moller/dp/1568814240/ref=sr_1_1?ie=UTF8&qid=1494968752&sr=8-1&keywords=real+time+rendering
It was updated in 2008. Not cutting edge, but many of today's core ideas are covered well. But, if you want cutting edge, you read SIGGRAPH papers, blogs, or the like. RR is more of a reference. It'll be hard to find a published book that goes into a detailed area of real-time computer graphics.
Hey RJAG. We don't always see eye to eye but you seem to be one of the more level headed guys around here! I almost always appreciate your posts -- they usually have an interesting perspective to them -- even if they aren't well received. I probably should pay more attention to them! But enough of how reddit tends to shoot the messenger and ignore the message.
You're right -- a lot of material is total crap. Out-of-date, not explained well, piss-poor naming, poor architecture, etc.
Warning:
I first started doing professional game dev back in 1995, so I am extremely biased. I've seen the fad of programming languages, toolkits, libraries, etc., come and go. I think Boost's 1,109 lines for a simple CRC is over-engineered C++ crap compared to the ~30 lines of C/C++ you actually need to solve the real problem.
With the
#include <disclaimer.h>out of the way ... ;-)The best authors I have found are (aside from Jason obviously):
The first few guys are all old-skool hard-core developers. The younger crowd doesn't like them since newer game devs usually spend more time arguing over pointless subjects such as the "proper" C++ pointer to use. Good game developers are more interesting in practical and pragmatic engineering tradeoffs then worrying about theoretical "perfection."
Speaking of Design Patterns, Christer Ericson recently said:
> Design Patterns are spoonfed material for brainless programmers incapable of independent thought, who will be resolved to produced code as mediocre as the design patterns they use to create it."
And to some degree I would agree with that.
i.e. You'll notice this sub likes to waste time arguing over "proper architecture" such as Entity Component System
My view is: IF your data, code, and model match this problem, then go ahead and use them. However keep in mind that rarely does the real-world exactly match some theoretical problem set. At the end of the day all you care about is shipping -- not being some academic writing theoretical "perfect" architecture -- whatever that is supposed to mean.
Hope this helps!
Real Time Rendering?
Programming is one thing, game programming is another. Get a good handle of the basics first. Build some small tools and get a feel for developing with C#.
After you feel comfortable there (so a solid understanding of design paradigms, efficient development, classes/variables/interfaces, composition over inheritance, etc) then move onto game specific development. I would recommend grabbing some graphics books (I personally can't recommend Real Time Rendering highly enough) and maybe a few basic math books covering linear algebra. Understanding AABBs will also help for more games that involve moving components. Learn to sweep test and test for collisions.
Stay away from writing your own tech when possible. If you want physics in your game (by physics I mean real physics that can't be created by AABBs) then grab an existing library like Box2D and use that. I use Shoebox for creating sprite sheets.
In terms of frameworks, I've been using MonoGame but there are others (libGDX is a great one, obviously there's Unity which is a full engine but I'm not a fan of it for anything other than prototyping).
Basically, take your time. Build things that are realistic for your skill level (don't go off thinking that a Skyrim clone is a good place to start). Think up a basic idea of something small... then cut it in half (because I can guarantee you it'll still be too big in scope).
I'm always a fan of seeing people learning to develop games! Good luck!
It depends a bit on what areas you're interested in. For interactive graphics you'll likely do OpenGL or DirectX or such.
Non real-time graphics usually means ray tracing or some variant like photon mapping where you want to produce physically correct images, with flexibility depending on your art direction e.g. Big Hero 6. With ray tracing you're essentially simulating how light interacts in the scene.
Here's some useful books/links for real time graphics:
Here's some for ray tracing:
For general math topics I also recently picked up Mathematics for 3D Game Programming and Computer Graphics which looks very good, though I haven't gone through it as thoroughly.
As mentioned already /r/GraphicsProgramming is a good subreddit, there's also /r/opengl for OpenGL questions.
If you're planning on pursuing this as a career, there are tons of incredible opportunities for people experienced with lower-level 3D APIs. Making your own engine serves as a fantastic learning experience, and would be a huge investment in your future.
Below are some of my favorite books/resources right now that may help you along the way. These might not be immediately useful to you right now, depending on where you're at, but together they have more than enough knowledge for you to go far in 3D Computer Graphics.
Other than Real Time Rendering which /u/horsman has mentioned above, I would also recommend:
===
As for learning math, I find it's easier for me to learn math while working on a project. Pick up a good vector / matrix math book, and write a software renderer. You'll get up to scratch with the necessary math in no time once you've put it to practical use.
==
As for a list of awesome sites, just take a look here: http://www.realtimerendering.com/portal.html
Keep in mind that 99% of video games are developed using a game engine. For 3-D games the primary game engines are Unity and Unreal. Those engines may use OpenGL under the hood, but they give you much easier-to-understand high-level abstractions for working with 3-D objects. OpenGL is extremely low-level.
There are many concepts that are important to know either way, though - such as using a matrix to represent a 3-D transformation. For that, I'd recommend a textbook on computer graphics like Real-Time Rendering.
The best way is to understand the graphics pipeline, what all stages are there, how your geometry data flows through the pipeline and what fixed pipeline does for you. Then you will start appreciating the programmable pipeline more.
If you're serious about understanding the core of Computer Graphics, get Real Time Rendering.
You can read first few pages for free at Amazon where they give a good introduction to the graphics pipeline.
Game Engine Architecture provides an excellent overview of how game engines work, from the ground up, in a way that's fairly accessible—that is, I understood most of what I was reading despite not having any experience programming at that level.
Also good:
Real Time Rendering
Real Time Collision Detection
I'm working on a large OpenGL tutorial site that is specifically aimed at beginners trying to learn modern OpenGL with clear samples and easy-to-understand sections. It's not finished yet but should provide a good resource for getting started and getting a hang of shaders. Take a look at www.learnopengl.com and see if it's something that suits your needs :)
Also, take a look at:
Real-Time Rendering: great book on modern OpenGL with a focus on shaders (although not specifically aimed at complete beginners).
Open.gl: good resource for starting modern OpenGL. Easy-to-understand.
Arcsynthesis tuts: very extensive OpenGL tutorial that goes into much more detail, making it more rewarding, but also more complicated for beginners.
in case you are confused, Real Time Rendering being referred to in the post is the title of the book, as well as the name of the sub-domain. Dense read, but it's still one of the best books out there (and a new edition comes out summer!).
Some books I enjoyed:
The Algorithm Design Manual by Steve S. Skiena, $61.15
Real Time Rendering, 3rd. Edition by Tomas Akenine-Moller, Eric Haines, Natty Hoffman, $71.20
Structure and Interpretation of Computer Programs, by Hal Abelson's, Jerry Sussman and Julie Sussman, Free
Clean Code by Robert C. Martin, $37.85
I can't tell exactly what you want to improve upon. If you just want better intersection algorithms/code, look at:
http://www.amazon.com/Introduction-tracing-Kaufmann-Computer-Graphics/dp/0122861604
http://www.amazon.com/Real-Time-Rendering-Third-Tomas-Akenine-Moller/dp/1568814240
The real performance gains in ray tracing, though, are parallelization and reducing the number of intersections tests that need to be done at all.
Parallelization is trivial.
For reducing intersection tests, you're best bet is some kind of space partitioning algorithm, like an octtree, k-d tree, or grid. It's not very hard either. The main idea is to pre-process the input into a grid-like data structure and do intersection testing by "walking" along the ray, through the cells. In each cell, do an intersection test with each object in that cell. Find the closest hit, and bail out. Traversing the grid is super easy and a lot faster than intersection testing. And (ideally) grid cells have very few objects, so the number of intersection tests is cut down a bunch, too.
The original paper for that technique, if you can find it, is this: http://portal.acm.org/citation.cfm?id=95111
I ordered these for our company library, based on recommendations for/from other programmers (of all levels).
ISBN | Title
---|---
978-1568814247 | Real-time Rendering
0321486811 | Compilers: Principles, Techniques, and Tools (2nd Edition)
1482250926 or 0123742978 | Essential Mathematics for Games and Interactive Applications, Third Edition 3rd Edition
978-1482264616 | GPU Pro 6: Advanced Rendering Techniques
1466560010 | Game Engine Architecture, Second Edition
978-1482243567 | Multithreading for Visual Effects
978-0123750792 | Physically Based Rendering: From Theory To Implementation
I have this book. I haven't even begun to scratch the surface of its contents but it's worth its weight in information. Link here: Real-Time Rendering, Third Edition
Game Engine:
Game Engine Architecture by Jason Gregory, best you can get.
Game Coding Complete by Mike McShaffry. The book goes over the whole of making a game from start to finish, so it's a great way to learn the interaction the engine has with the gameplay code. Though, I admit I also am not a particular fan of his coding style, but have found ways around it. The boost library adds some complexity that makes the code more terse. The 4th edition made a point of not using it after many met with some difficulty with it in the 3rd edition. The book also uses DXUT to abstract the DirectX functionality necessary to render things on screen. Although that is one approach, I found that getting DXUT set up properly can be somewhat of a pain, and the abstraction hides really interesting details about the whole task of 3D rendering. You have a strong background in graphics, so you will probably be better served by more direct access to the DirectX API calls. This leads into my suggestion for Introduction to 3D Game Programming with DirectX10 (or DirectX11).
C++:
C++ Pocket Reference by Kyle Loudon
I remember reading that it takes years if not decades to become a master at C++. You have a lot of C++ experience, so you might be better served by a small reference book than a large textbook. I like having this around to reference the features that I use less often. Example:
namespace
{
//code here
}
is an unnamed namespace, which is a preferred method for declaring functions or variables with file scope. You don't see this too often in sample textbook code, but it will crop up from time to time in samples from other programmers on the web. It's $10 or so, and I find it faster and handier than standard online documentation.
Math:
You have a solid graphics background, but just in case you need good references for math:
3D Math Primer
Mathematics for 3D Game Programming
Also, really advanced lighting techniques stretch into the field of Multivariate Calculus. Calculus: Early Transcendentals Chapters >= 11 fall in that field.
Rendering:
Introduction to 3D Game Programming with DirectX10 by Frank. D. Luna.
You should probably get the DirectX11 version when it is available, not because it's newer, not because DirectX10 is obsolete (it's not yet), but because the new DirectX11 book has a chapter on animation. The directX 10 book sorely lacks it. But your solid graphics background may make this obsolete for you.
3D Game Engine Architecture (with Wild Magic) by David H. Eberly is a good book with a lot of parallels to Game Engine Architecture, but focuses much more on the 3D rendering portion of the engine, so you get a better depth of knowledge for rendering in the context of a game engine. I haven't had a chance to read much of this one, so I can't be sure of how useful it is just yet. I also haven't had the pleasure of obtaining its sister book 3D Game Engine Design.
Given your strong graphics background, you will probably want to go past the basics and get to the really nifty stuff. Real-Time Rendering, Third Edition by Tomas Akenine-Moller, Eric Haines, Naty Hoffman is a good book of the more advanced techniques, so you might look there for material to push your graphics knowledge boundaries.
Software Engineering:
I don't have a good book to suggest for this topic, so hopefully another redditor will follow up on this.
If you haven't already, be sure to read about software engineering. It teaches you how to design a process for development, the stages involved, effective methodologies for making and tracking progress, and all sorts of information on things that make programming and software development easier. Not all of it will be useful if you are a one man team, because software engineering is a discipline created around teams, but much of it still applies and will help you stay on track, know when you've been derailed, and help you make decisions that get you back on. Also, patterns. Patterns are great.
Note: I would not suggest Software Engineering for Game Developers. It's an ok book, but I've seen better, the structure doesn't seem to flow well (for me at least), and it seems to be missing some important topics, like user stories, Rational Unified Process, or Feature-Driven Development (I think Mojang does this, but I don't know for sure). Maybe those topics aren't very important for game development directly, but I've always found user stories to be useful.
Software Engineering in general will prove to be a useful field when you are developing your engine, and even more so if you have a team. Take a look at This article to get small taste of what Software Engineering is about.
Why so many books?
Game Engines are a collection of different systems and subsystems used in making games. Each system has its own background, perspective, concepts, and can be referred to from multiple angles. I like Game Engine Architecture's structure for showing an engine as a whole. Luna's DirectX10 book has a better Timer class. The DirectX book also has better explanations of the low-level rendering processes than Coding Complete or Engine Architecture. Engine Architecture and Game Coding Complete touch on Software Engineering, but not in great depth, which is important for team development. So I find that Game Coding Complete and Game Engine Architecture are your go to books, but in some cases only provide a surface layer understanding of some system, which isn't enough to implement your own engine on. The other books are listed here because I feel they provide a valuable supplement and more in depth explanations that will be useful when developing your engine.
tldr: What Valken and SpooderW said.
On the topic of XNA, anyone know a good XNA book? I have XNA Unleashed 3.0, but it's somewhat out of date to the new XNA 4.0. The best looking up-to-date one seems to be Learning XNA 4.0: Game Development for the PC, Xbox 360, and Windows Phone 7 . I have the 3.0 version of this book, and it's well done.
*****
Source: Doing an Independent Study in Game Engine Development. I asked this same question months ago, did my research, got most of the books listed here, and omitted ones that didn't have much usefulness. Thought I would share my research, hope you find it useful.
This site has some basic tutorials on OpenGL. I've also heard that this book provides a good solid overview without drowning you in minutia. Finally, if you really want to get into graphics, make sure you have a firm grasp of Linear Algebra.
part of being a scientist is reviewing a wide range of references - you might be expecting a bit much from one online source. let me suggest this one and this one, and especially this one are going to have the general graphics pipeline explanation chapters that you're looking for. if $$$ is a problem (and it is for most of us with these texts), perhaps you can insist that your local library gets them?
you can also pick up some good ideas by visiting course pages for some of the more well-known university graphics programmes - some of them have slides online, otherwise check out their reading lists - these guys are the best in the world at teaching graphics. read what they read.
http://www.cs.cornell.edu/Courses/cs465/2007fa/
http://graphics.stanford.edu/courses/
http://www.cs.utah.edu/research/areas/graphics/
http://www.cis.upenn.edu/~badler/courses/cis560.html
but i suspect, your best bet for this sort of stuff is actually Eric Haines' online course, which has a free version. it uses webgl but the main concepts are exactly the same as desktop gl and it's really very good https://www.udacity.com/course/cs291
also, interesting side note - Myers-Briggs has been widely discredited. it's actually based on Jung's germanic mysticism, which comes from ancient European magic. earth/air/wind/fire, alchemy, the four humours, the four personality components etc. etc. not a drop of science in it, but employers insist on you doing it.
My bad, I meant the second major in game dev*. I think you're better off just taking maths and learning the physics + maths required for engine development (realtime and 3d rendering). Also, I recommend picking up this book: https://www.amazon.com/Real-Time-Rendering-Third-Tomas-Akenine-Moller/dp/1568814240 but it requires knowledge of linear algebra (which shouldn't be too hard to learn, but it definitely will take a while).
Best of luck :)
Real Time Rendering was recommended to me by a few professional graphics devs when I asked them the same question. This is NOT a light read, and it won't tell you how to use a specific API (DirectX, OpenGL), but it will give you the foundations to better understand an entire graphics pipeline and the various techniques used.
Other posters have mentioned starting with a software rasterizer. I'd highly suggest this as it helped me a lot when I had to do a very small one in college. There is a more recent version that is likely better(haven't looked yet), but this is the book we used and it can be picked up for dirt cheep!
Look into the primitives offered by OpenGL:
http://www.opengl.org/wiki/Primitive
Any geometry you want to render has to be represented using those primitives. So you could produce a wireframe by using line strips. The set of points where x = x1 is a line strip, the set of points where x = x2 is another line strip, and so on until x = xn. Then do the same with y held constant at each value on its domain (not a very good explanation, but hopefully you get the gist of it). A surface would have to be represented using triangles - more difficult than wireframes, but there are books like Real-Time Rendering that discuss techniques for subdividing surfaces. If you aren't adamant about implementing that yourself, I'm sure you could find free libraries that can do this for you.
Also in the OpenGL Common Mistakes - Triple buffering it's said :
"You cannot control whether a driver does triple buffering. You could try to implement it yourself using a FBO. But if the driver is already doing triple buffering, your code will only turn it into quadruple buffering. Which is usually overkill."
So basically you can't even implement triple buffering in OpenGL, you need to rely on the capability of the GPU driver.
Not that it should help much anyway. From Real-Time Rendering, Third Edition :
"The drawback of triple buffering is that the latency increases up to one entire frame."
I would start with the book Real-Time Rendering. It's pretty much the book on graphics programming. I don't think there's a single graphics programmer at my company who doesn't own a copy.
I'd combine that with the code samples that come with the DirectX SDK. I personally found the DX10 samples to be better learning material than the DX11 samples (which tended to be less beginner-oriented). Your mileage may vary.
Finally, if you have access to an existing code base, a great way to learn things is to just start modifying existing shaders. This frees you from needing to deal with the API calls, etc and lets you get right to learning how shaders work.
http://www.amazon.com/Real-Time-Rendering-Third-Edition-Akenine-Moller/dp/1568814240
I don't believe in short cuts
You didn't post a question, so it's difficult to know what exactly you want. If you just need to implement space partitioning with a BSP tree, read the good old BSP FAQ
If you need more general graphics background, check out:
If you have more questions, please be more specific. I might help you with more resources.
Practical D3D Rendering and Computation
Distills the API quite well and explains a lot of pitfalls with creating buffers and the pipeline usage. I'm working on just reading it so I'm familiar with D3D 11+ even though I don't use it day to day.
Real-time Rendering 3rd edition
Another fantastic reference for graphics with a more theoretical look at things, explains TONS of modern techniques and even older ones such as rasterization on CPU, etc.
I haven't really made anything that's screenshot worthy yet. I'm almost done with the world editor so when I get that done I'll finally be able to show off some stuff.
As far as tutorials your probably not going to find anything that's specific to 2d. I mostly do 3d graphics programming so most of my shader knowledge comes from doing that, almost anything you do in 3d translates pretty easily to 2d.
Here are some good books I've read on shaders:
Amazon link to Real-Time Rendering
You could look at 3d graphics programming, threading or distributed programming.
Or webGL, HTML5,CSS, JS
WebGL Programming Guide
OpenGL Programming Guide
Real-Time Rendering
The Art of Multiprocessor Programming
Beej's Guide to Network Programming
Thanks a lot! I actually have that first book bookmarked but I forgot to put it on the list.
I'm leaning closer and closer to purchasing a copy of The Art of Game Design: A Book of Lenses and it's one I'm actually really curious about.
On Game Physics Pearls - I peeked into the first few pages and it looks like something that I will pick up once I have a bit of experience in that area...does that sound about right or would you say it could cater to beginners fairly well?
Game Physics seems like it may be a bit more beginner-friendly but you are right about it not being a tutorial, which is kind of important for me at this step. I'm definitely bookmarking this until I know a bit more on the subject, though. I'll be taking a Physics course next September so it may be a good time to look at it after that!
Real-Time Shadows looks very interesting but I'm unsure to the difficulty level of it to a beginner. It sounds like I need to brush up on my math after three years of not using it very often at all.
Thanks a lot for the suggestions!
*I'll be taking a course on Linear Algebra here in the coming semesters, but that book does sound like a good introduction along with how it works within 3D programming. I'll keep a look-out on that for a while; do you think it would be very worthwhile to read that before something like Real-Time Rendering?
Check out Real-time Rendering, 3rd ed.
If you're really serious about getting into 3D-programming with DirectX I recommend getting a good book. A quick search on Amazon will get you the most common ones.
As for online resources my favorite is braynzarsoft.
EDIT:
My favorite books on DirectX:
Introduction to 3D Game Programming with DirectX 11
Practical Rendering and Computation with Direct3D 11
Real-Time Rendering
Real Time Rendering, but I'll probably need another week or two to get through that, it's a bit of a tome.
Very well-written and interesting, though.
OK, so right now I have three books in question (priority in that order):
What do you think?