This stuff is really fascinating. Does anyone have any recommended reading or general advice as to how to learn more about game/graphical engine implementation? I mean, from the ground up. (I'm a CS undergrad and the closest we've gotten to learning about this has been the computational geometry chapter in CLRS, but that was a mildly esoteric introduction to everything that is possible in this field.)
I read Jason Gregory's "Game Engine Architecture" cover-to-cover and I'd highly recommend it for someone new to the industry who's interested in learning about game development. Gregory is a developer at Naughty Dog (Uncharted series).
Indeed. Having been in the game industry for close to a decade now (apropos of this thread, my first job was at Epic Games as an engine programmer working on UE2 and UE3), I can't say I personally learned a lot from Gregory's book (outside of some tidbits on character animation, where the book is especially strong), but I can say that it's the best book on the subject I've read.
An older book like Eberly's 3D Game Engine Design was more a loosely knit compendium of theory and algorithms. Eberly's more recent 3D Game Engine Architecture is closer to Gregory's in intent. Unfortunately, it's more a reflection of the idiosyncrasies of the author and his personal code base than an investigation of game engines as developed and used in the industry.
I've also heard good things about Mike McShaffry's Game Coding Complete. McShaffry is a game industry veteran, so he knows what he's talking about. However, it seems to be targeted at rank beginners, so a lot of the material might not be very useful to you.
Below that tier, of course, you have an endless array of how-to books written by incompetents. The worst is the "here's my shitty homebrewed codebase" variety.
For rendering in games, you'll need a separate book. Real-Time Rendering is the canonical reference. The first and second editions were my favorites. The third edition added a lot of information on recent techniques but at the expense of reading too much like an annotated bibliography, skating from topic to topic while rarely going into enough detail to be useful and often listing several alternative solutions to a given problem without comparing their relative merits and trade-offs. The first editions flowed more like textbooks and were thus better suited as introductions. Some of that might be hindsight bias on my part; I'm curious what others think who first learned the subject from the third edition.
I also want to give a shout-out to Christer Ericson's Real-Time Collision Detection book. It's full of clear explanations and practical, hard-earned knowledge that you can't get anywhere else. Plus, the accompanying code is robust and well written, a far cry from the usual crap that either straight-up doesn't work or is inextricably entangled with a massive code base (I'm looking at you, Eberly!).
It seems that each time I come back and read your comment, you've added a new recommendation. Awesome!
That Real-Time Collision Detection book sounds particularly interesting to me. I had resigned myself to just using Bullet in the toy engine I'm working on since I couldn't find any good resources on the subject. I'll check that out!
The only book you're missing is the one that explains how to get your foot in the door ;)
Game Engine Architecture and Real-Time Collision Detection were both prescribed material in my games technology course (done as a double major with CS). Cool to hear that they're recommended by industry folk :) Gregory's book is especially good and taught me a lot. +1!
While people mentioned NeHe, and it's where I started years ago, it's widely outdated. Here's one that helps you get started with modern GPU rendering concepts in OpenGL.
On the flip-side, if you're interested in rendering realistic scenes that appear physically accurate but aren't suitable for real-time rendering (useful for movies, ads, etc.), Physically Based Rendering (aka PBRT) by Pharr and Humphreys should be your go to book.
NeHe's OpenGL tutorials used to be a good (although now kind of outdated) starting point. Shaders didn't use to exist back then. But still a good start:
A game engine is much more complex than a graphics engine.
Maybe somebody can point to guides for creating physics/sound engines and AI/gameplay stuff as well?
When I started learning I spent a lot of time reading NeHe tutorials. But modern OpenGL feels so far removed from those tutorials that it feels like learning a completely different API.
The best tutorials I've found for modern OpenGL is "Learning Modern 3D Graphics Programming" by Jason McKesson. The only problem I have with these tutorials is that there aren't enough! http://www.arcsynthesis.org/gltut/
I really appreciate all of the responses and have already put many of the recommended texts on my wishlist. (And I just bought Game Engine Architecture as well, too bad you didn't post an Amazon affiliate link for yourself!) But I just wanted to point out that since this tutorial is free, I immediately checked it out, and I am absolutely blown away. This will certainly keep me busy until GEA arrives! Thanks so much, it looks to be a great starting point for learning more.
Edit: I also wanted to point out that in the author's preface, he discusses what he considers the downside to most introductory texts and tutorials in 3D graphics programming - presenting "fixed functionality" that allows newcomers to more quickly use the tools at hand by abstracting much of the foundational information away.
While this is certainly useful for experienced developers learning a new derivative technology on top of what they already know, I have always found this approach for introductory stuff frustrating. At the end of the day I may come away pseudo-understanding a "higher level" concept, but ultimately much has been abstracted away and I am left ignorant and, as the author says, "Programming thus becomes akin to magical rituals: you put certain bits of code before other bits, and everything seems to work."
I wish I knew of more texts like this for other fields where over or premature abstraction could endanger comprehension. (For example, I know I would like to see a similar approach taken to other complex topics, like networking.)
Hey, glad I was able to give you some useful information! If you ever find yourself in Toronto, say, for an indie game jam (http://www.tojam.ca/home/default.asp hint hint), you can buy me a beer ;)
If you're looking for something lower level, the book you probably want is the white book - Computer Graphics: Principles and Practice. I have the 2nd edition from 1992, which is the still the standard intro graphics textbook for many CS departments. Though Amazon says there will be a 3rd edition coming out at the end of this year!
Another highly recommended book (also recommended in another comment here) is Real-Time Rendering, but I've only used bits and pieces from this one, so I don't know how good it is for folks just starting out. Still probably one you'll want to add to your shelf if you continue on in the field.
Oh, and also also, head over to YouTube with some snacks and a drink, sit down, and watch the weekly Overgrowth game developer videos from Wolfire Games. It's both inspirational to see what other people are doing, and a great demo of concepts that you'll read about in GEA, such as animation blending: http://www.youtube.com/playlist?list=PLA17B3FAA1DA374F3&...
Although, when I go through the code, it feels more like a copy of the (legendary) Red Book. Missing vector/pixel (or fragment in GL-speak) shaders as well.
If you want to know all of the math and functions involved in pushing individual pixels to the screen and building something along the lines of a Quake 2-level engine in software, this book is a pretty good introduction to it all:
Note that this is the type of programming now implemented in hardware GPUs, and in libraries such as DirectX and OpenGL. If you were to write a modern game, you would do it on top of one of these hardware-accelerated libraries, and you wouldn't be writing this type of code in software anymore. But if you really want to learn how to do these things from the "ground up", this book can help you build that foundation
It might be worthwhile to take a look at certain types of game engine architectures.
Since modularity is one of the keypoints of how this editor/game engine work so well together, it's probably a good idea to have some idea of how to structure game components to lessen the 'ball of mud' feeling.
