WebGL Programming Guide is the first WebGL book that I can fully recommend. The authors stick to straight WebGL code (no libraries like Three.js) and explain everything in full detail. Since they focus more on the API than anything else, most of the samples are simple things like colored triangles or spinning cubes, but that is fine to learn the basics. I liked how sometimes they would show things not to do, and what would happen, which helps with understanding the concepts.

In the book, which is around 500 pages long, Kouichi Matsuda and Rodger Lea cover many important topics including: WebGL initialization, drawing a point, a triangle with transformation, basic animation, color and texture, the GLSL language, cameras, lighting, and a shorter chapter at the end with techniques for fog, shadows, alpha blending, etc. Really a great roster for anyone looking to learn WebGL. Much appreciated are some of the tricks they show, like how to pick 3d objects with the mouse, or how to render off-screen objects to a texture, useful for shadowing or other effects. There is even a chapter detailing how to write an OBJ model importer, perfect for someone not wanting to rely on 3rd party libraries.

I especially liked how detailed the book can become, for example when explaining the differences between right and left-handed coordinate systems. Something that can be confusing to 3d novices but the authors here did a great job. They also use beginner friendly terminology for certain things, like calling depth buffering “hidden surface removal”, which was odd at first until I remembered someone new to 3d may not understand what a depth buffer is without prior knowledge. In the book, many parts of the API are listed out in charts, such as the built-in functions/variables for GLSL, function signatures for the GL context (which explan the errors you may get and return values, etc.). A very competent look at the API.

The book was well written and I did not see any obvious errors (though I did not attempt to run any of the code). Thankfully, they make the code available on the book’s website for anyone wishing to run it themselves and pick it apart. It’s honestly hard to find fault with the text. This is a great look into WebGL and a key point in your journey as a WebGL programmer. Not to be missed.

WebGL: Up and Running by Tony Parisi is a competent first introduction to 3d on the web, and the author does seem to know what he’s talking about. The book is not long, but manages to cover a variety of topics, even the source code for a complete game (simple as it may be). The chapters include: introduction to the WebGL API, setting up Three.js, rendering a mesh, animation, interaction, integrating 2d and 3d, and a game example. I would say the coverage is thin, but adequate for people starting out. The example racing game at the end was nice, and the author shows the full Javascript and HTML code, which was appreciated.

Overall, I’d say the book was decent but there are a few faults. Namely, that the book is called “WebGL: Up and Running” but there is actually very little WebGL API code in these pages. The first chapter shows some, but after that it’s all using Three.js. Don’t get me wrong, Three.js is a useful library, but I would preferred to see how to do these things using the straight API. Furthermore, the author uses his own framework built on top of Three.js, obscuring some of the core concepts. Granted, his framework looks good, but it means a good amount of the code examples in the book will not work unless you are using that framework (and I would guess you are not). That said, I still found the book helpful even if I would have preferred a more low-level survey.

I think the target audience for this book is people with web development experience but not necessarily game developers. The book does assume you know some Javascript and looks at things at the higher level, useful if you just want to embed a 3d model in a website for example. For more serious game developers, or people wanting the learn, I feel that the coverage is too cursory, and really only scratches the surface. Rather than “WebGL: Up and Running” it should have been called “Three.js: Up and Running” as that is what it is (ignoring the custom framework added on top of Three.js). Experienced developers looking to create their own engine won’t find the low-level details, and for beginners there is not really much 3d math so you won’t learn the basics here either. In this way, it’s a more practical book. Meaning if you just want to get some 3d “up and running” then this will get you there, you just may not understand why it works. But the book is well written and may be useful as a light entry into the field.

I’m a bit conflicted about this book. While there is a lot of good material here, I feel like there were many inconsistencies with the coding style and some errors or confusing explanations that deter from the gems inside. It’s also heavily geared toward complete beginners, making it somewhat of a numbing read for intermediate to advanced programmers. But I still found some reasons to like it, so please read on.

Each chapter or gem covered one focused aspect of WebGL coding. For example: creating a canvas and initializing WebGL, the graphics pipeline and shaders, some basic vector and matrix math, 3d transformations, drawing a triangle, texturing, model loading, mouse + keyboard interactions, a 3d camera, lighting, and collision detection. There is also a short chapter at the end for 2d games, but the bulk of the book is just 3d. So a decent amount of topics here, and some good fundamentals. Much appreciated too that that the author is using straight WebGL API code and not relying on 3rd party libraries.

So what is my issue here? Well, Greg Sidelnikov goes to great lengths to tell the reader that things are easy (and they may or may not be, depending on your skill level) but he could have rather displayed simple samples to illustrate the points. For instance, in the chapter on matrix math he spends about 10 pages of filler trying to sell the idea that matrices are easy, and that he doesn’t want to have long mathematical proofs in the book. However, just saying matrix math is easy doesn’t cut it. I understand the sentiment, but it just wastes time and doesn’t actually make the math easier. Later in the book he does show some examples, but he should have just removed the motivational filler and cut to the chase. I can also understand how this could be beneficial to a complete novice, but I think it does more harm than good, as at some point you actually have to have the knowledge of how things work.

My other issue is that the coding style is very inconsistent. I don’t know if this was just lack of effort or lack of understanding. For example, he shows fragment shader code like this:

gl_FragColor = color * vec4(rgb[0], rgb[1], rgb[2], 1) * texture2D(image, vec2(texture.s, texture.t));

First off, why is the rgb variable indexed like an array and the texture indexed by property? Or why not let GLSL cast these automatically? Or why create a new vec2 for texture, when texture is already a vec2? This makes no sense. The above line could be simplified into the code below, which is much more readable.

gl_FragColor = color * vec4(rgb, 1) * texture2D(image, texture);

This is just one case, but it makes me feel like the author might not have a full understanding of the code and/or copied code from various tutorials and Frankenstein’d it together. There are also less egregious problems, like inconsistent coding style, capitalization, etc. Just little things that make me question the text, like naming the shaders “smooth.vs” and “smooth.frag”. Why not use the common “vert” and “frag” extensions? Or “vs” and “fs”, if he wanted? Having two different naming conventions just looks sloppy. Or when he says an identity matrix consists of all ones, completely false information.

All that said, the book was not completely bad. One thing that was exceptional was the first chapter on 3d, he wrote a simple star-field simulation without WebGL, which was a great introduction to 3d. It’s good to understand the concepts of 3d in a simple software case before jumping into GPU programming, so this was great. Also the fact that he was using straight WebGL and not 3rd party libraries, good for learning the basics. And the WebGL API code itself was explained in a simple manner.

There were some good parts, sure, but finishing the book felt like a chore. I try to finish books that I start, and I’m sometimes surprised, but mostly my first impression is correct. The cover looked amateur, and I could tell it was self-published, but I was willing to give it a chance. While I did learn some things, I’d have to say that overall it was not great. I think especially for intermediate to advanced programmers, there is no reason to read this book. For total beginners, or maybe web developers without OpenGL knowledge, it may be useful but I’d probably still recommend starting elsewhere with a more reputable source. There are some gems here for people willing to dig, but all the little errors and inconsistencies make the final product not hold up.

So, as of this writing, I have read all 5 books available on Amazon on the Vulkan API and I would say that Vulkan Cookbook is one of the better resources out there. The format of the book is similar to other “cookbooks” you may have seen, with each recipe essentially describing one technique in a stand-alone fashion. Meaning the steps for each one will list fundamentals, like creating a logical device and all the other prerequisites, so you can easily refer back to one chapter when it’s time to implement a particular feature. I would personally recommend reading the text from front-to-back, as I think it’s a better way to learn, but you could certainly jump around and still not miss much (assuming you already have some understanding of Vulkan). Author Pawel Lapinski does a great job of showing real code for each recipe and only shows what is actually necessary for a technique. Unlike some other books, this isn’t a dry listing of the API documentation, rather the author shows practical usage of the API with some brief explanation. For this type of text, I think this works great and I imagine it would be very helpful to refer back to when it comes time to implement into your project.

Among the chapters, Lapinski covers: instances and devices, image presentation, command buffers and synchronization, resources and memory, descriptor sets, render passes and framebuffers, shaders, graphics and compute pipelines, command recording and drawing, along with some additional chapters at the end for more general graphics programming concepts like loading textures and 3d models, lighting and shadowing, and cubemapping. Each chapter itself is then broken down into smaller recipes, that could be something like “enumerating available physical devices” to “submitting a command buffer to a queue”. This is really quite a good mix of topics, and, at 700 pages, adequate coverage is given to the most commonly used parts of the Vulkan API. Having already worked through some tutorials online, and read a few other books on Vulkan, most of the topics here were things I had some familiarity toward already, but I still found the reading helpful.

Due to the tactical nature of the text, I would recommend the book for more intermediate to advanced programmers. While the author does a great job of explaining the specific steps needed to do particular actions in Vulkan, it may be helpful to at least understand some of the big picture before diving in here. I might even say this is the best book on the market today for Vulkan, though I’d probably also recommend reading it after one of the others available. It may be helpful to start with a Hello World type app in Vulkan, in which case you could first follow the awesome tutorial over at vulkan-tutorial.com, or get Kenwright’s Vulkan Graphics API: in 20 Minutes, which was a little rough but still a cheap and quick way to obtain an overview of the API. For beginners, or maybe people that want to start at a more basic level, Introduction to Computer Graphics and the Vulkan API (also by Kenwright) may be a more comfortable spot to jump in at. And the other books out there were good in their own right, though some of them didn’t move past simple function/structure documentation.

One thing I really wish is that someone could make a Vulkan book on the level of Frank Luna’s DirectX series. Luna is able to show many practical graphics programming techniques in one book, and in the end you’ll have a handful of pretty sweet demos to showcase. Though Kenwright attempts this, I still haven’t seen this really accomplished yet for Vulkan. While the end chapters of Vulkan Cookbook do dip into this territory with shadow mapping and post processing, it would be nice to see an entire book written like this. However, given that Vulkan is a relatively new API, it’s probably more useful to start with the basics, and hope that competent readers can port techniques from other APIs once they have a feeling for how things work.

Keep in mind, Vulkan is an advanced and complex topic, and a single book won’t teach you everything you need to know. While many of the Vulkan books out today have seemed to release to mixed reviews, I feel that all of them have been helpful. Even reading the same topics explained by different authors can help with knowledge understanding and retention. And there are also some unique things in each book, so I would fully recommend reading them all if you’re really serious about getting into Vulkan. I realize there are some advanced coders that can study the documentation and hit the ground running, but I find the “guided tour” offered from books to be more conducive to learning for me personally. Your opinion my differ, but I’d have to say that you can’t really go wrong with Vulkan Cookbook by Pawel Lapinski. Recommended.

Introduction to Computer Graphics and the Vulkan API by Kenwright is exactly what the title implies, an approachable introduction to the Vulkan API and graphics programming in general. This book succeeds in the places where some other books on the market fail, by showing straight-forward code examples, explaining graphics concepts simply, and not assuming you are already a graphics guru. While the quality of the text may fall short of Frank Luna’s work, this is definitely aspiring to be that kind of book, in stark contrast to some other texts which just list structure declarations and barely move past what you find in the API documentation. This is very much a practical book, and lots of source code is shown, not only for initializing Vulkan but also including the full shader code for each example. For beginners to Vulkan, I’d definitely say this is the first book to buy.

So what exactly does Kenwright’s intro book cover? The text starts with some brief background into Vulkan (though it strangely omits mentioning AMD’s contribution with Mantle), then it goes into basic 3d math with vectors, matrices, and quaternions. It explains different transformation spaces, initializing Vulkan, texturing, lighting, geometry shaders, cube maps, fog, normal and parallax mapping, instancing, tessellation, and caps off the book with shadowing. Really most of the fundamental topics are covered, and the explanations are straight-forward and digestible for a beginner (well, at least as much as something as complex as the Vulkan API in C++ can be). The math sections were more of a cursory overview, this is certainly not a math book, so it will be a light refresher for most and an adequate introduction for a beginner. The sections on texturing and lighting were also pretty basic but solid as an intro. I especially liked the geometry shader chapter, as not a lot of books cover this and I found the code examples enlightening. The chapter on tessellation was also nice, something I haven’t seen in other Vulkan books. Some of the technique chapters were short, like with cube maps and fog, but it explained the concepts decently and, as an introduction book, this was enough. Overall a solid mix of topics and with lots of code shown this is a great example text.

While I do usually prefer to read my books digitally, this item was only available as a paperback. That said, the quality of the book is great. Every page is printed in full color, and even the source code has syntax coloring, which greatly helps the readability. It’s also only 220 pages, so a fairly short read, but still managed to cover the basics. Of course, at that length, it’s not as in-depth with the actual Vulkan API spec as some of the other books on the market. It shows only enough to illustrate the concepts and get the code running. This is actually fine, as lots of the feedback of the existing material was that it was dry. This book certainly feels more engaging than what I’ve seen so far.

Kenwright did a great job with this book, and I’d certainly recommend it (especially for people just getting started with graphics programming in Vulkan). His previous Vulkan book, Vulkan Graphics API: in 20 Minutes, also came recommended by me but this one is way better. I can tell there was an editor here, or at least more effort given, as the text reads much better with proper use of the English language. However, I did find some careless mistakes in the text, such as saying a vector’s w component should be 1 (it’s really 0), or explaining a technique to set depth writing off, but then showing code with it set to true. I’m not going to penalize the author too hard here and, to be fair, the majority of programming books typically print with some mistakes. However, it does make me weary of attempting to copy any of the code line for line without more research. As I’ve mentioned before, I don’t type in or test code in books, so I can’t verify if they work. I use the books as concept references and when it comes to coding I will visit more trusted sites to get math equations, or consult the API docs. Not the end of the world, but it could confuse a novice unnecessarily.

All-in-all I would say this is a solid book. People seemed to want a more practical text on Vulkan, and I think this fits the bill. It’s certainly marketed as an introduction text, and the title holds true. The audience here is likely people with some C++ experience, but maybe not much knowledge of graphics programming. Or people with some graphics experience in other APIs, like OpenGL or DirectX, that want to get involved with Vulkan. I think it’s important to have beginner-friendly books, and this is a worthy addition to the library. Graphics experts may find the book to be too much at the novice level, but it could still be useful as a light introduction. Especially if you are deciding if you want to use Vulkan in your project and aren’t sure, I think the practical nature of this book is more helpful than some of the more technical resources available. I know some people suggest beginners start with OpenGL before delving into lower-level APIs, but I disagree. Learning Vulkan gives you a more accurate understanding of how graphics processing works, and the API will only become more ubiquitous in the coming years. While setting up Vulkan initially can be daunting, I think it’s a worthwhile excursion, and this is the best introduction I’ve seen so far. Recommended.

Jeremy Birn’s Digital Lighting and Rendering is a masterful treatise on digital lighting and, in my opinion, a must have on your bookshelf if you’re a 3d artist. While the text is clearly aimed at pre-rendered art, for example in animated movies or live-action effects, most of the concepts are fundamental enough to apply to lighting real-time scenes in games, or even more traditional art mediums. I found the pace to be good, and lots of important areas are covered. The chapter list includes lighting design, shadows and occlusion, environments and architecture, characters, cameras, composition, the science of color, rendering algorithms, textures, layers, production pipelines, and an appendix for getting a job in the industry. Though there are lots of books that cover specific topics or software packages (such as modeling in Maya), it’s more difficult to find higher-level books that focus on the fundamentals. Of course, it’s important to understand the tools you are using, but without a solid foundation you will likely end up making avoidable mistakes.

My interest is definitely in real-time rendering, so many of the topics were not directly relevant. However, I do have some experience with pre-rendered content creation, mostly noticeably during my time in art school, and some of the topics here were even beyond what I learned getting a 4 year degree. I will say that the material would be most apt for people doing film, and the book is certainly catering to that audience. However, in my case, I find a lot of the real-time books to be too narrowly focused on the algorithms and maths and not enough time is spent telling you how to use those methods to produce quality art. So I like looking at other sources to get a different perspective. Even in games there is some crossover, for example in cut-scenes or making promotional images, so the knowledge can still be useful. All-in-all I enjoyed the book and I would highly recommend it to any current or aspiring 3d artist.

Although the Vulkan API has been available for about a year now, it was just at the tail end of 2016 that we started to see books published on the topic. For me personally, I prefer learning from books over just reading documentation, and Vulkan Programming Guide is a fine effort. At 480 pages, it is a comfortable length, and manages to hit on a lot of major elements in the API. It is by no means comprehensive, as most of the coverage just shows function or structure prototypes (something you can likely find in the online docs) but there is at least some explanation of what each function does. I found useful the explanation of device limits (such as the maximum frame buffer size, number of bytes in a push constant, etc.) and how to query them, as I have not seen this touched in other texts. Sellers also does a great job of introducing synchronization concepts in one of the later chapters. This is absolutely essential for proper multi-threading, and I have not seen this in other books (at this depth). There is some discussion here and there to performance characteristics. Maybe not enough, but the author does attempt to give guidance on how expensive a particular call could be, or when it might hurt performance. Overall the book was solid. This will be my 3rd Vulkan book, along with a number of tutorials, and I felt there was relevant info gleaned from the text.

Vulkan Programming Guide has 13 chapters, each focusing on a key aspect of the Vulkan API. Inside these chapters are: a high-level overview of Vulkan itself, memory and resources, queues and commands, memory barriers and buffers, presentation, shaders and pipelines, graphics pipelines, drawing, geometry processing, fragment processing, synchronization, queries, and multipass rendering. Not a bad mix of topics. I don’t think anything major was left out, however, some of the coverage could be more fleshed out. While there was great detail on some things. For example, showing SPIR-V disassembly code, other topics were only given a cursory look. In particular, there is very little source code in the book. While the author goes to great lengths to show structure and function prototypes, there isn’t a whole lot of code showing actual usage. While it’s debatable if this is necessary, I would find more code examples to be useful. To be fair, the code that is shown looks good, there just needs to be more it.

All in all, I feel the book is solid and, considering Vulkan is relatively new and there aren’t that many texts available, it’s not a bad choice. One thing to note: I would recommend you start with Learning Vulkan by Parminder Singh. Learning Vulkan is a much more approachable resource, and I found it a little easier to follow. While Vulkan Programming Guide is more in-depth in many cases (in terms of the API spec itself), Learning Vulkan has a lot more C++ sample code, and may be more useful in that respect. In any case, I would buy both books because there are unique advantages in each one. Could Vulkan Programming Guide be improved? Sure. But it’s not a bad book and if you are getting into learning Vulkan today you’ll really need any and every resource you can get your hands on, and this should certainly be on your shelf.

Learning Vulkan by Parminder Singh is an excellent foray into the Vulkan graphics API and quite a competent book. The text is a reasonable 466 pages, and packs a lot in there. Singh covers all the basics of using Vulkan and goes into great detail at each step of the way. Not only is there actual C++ code shown (a lot of it), but he explains each API call and what objects to pass it, a breakdown of each object structure and what it does, what’s valid (or invalid) for data you can put in, and so forth. I have not read the official Vulkan Programming Guide yet (that’s coming next) so I’m not able to compare them here. However, this book is an absolute treasure trove of information, and presented with clear context, not just a copy and paste of API docs.

While the book is not particularly long, the author does manage to cover a good amount of ground. Of the topics included are: getting started with the LunarG SDK, initializing the API, debugging, command buffers and memory management, allocating image resources and the swapchain, buffers, render passes, framebuffers, working with SPIR-V shaders, pipelines and pipeline state management, descriptors and push constants, and finally drawing a textured polygon. I’m still getting acquainted with Vulkan myself, but this does seem to touch on all the fundamental topics to get started with the API. It really seems like Parminder Singh knows what he is talking about and feel I learned a lot finishing this text.

One thing to keep in mind, this is not really a book about graphics programming techniques, but rather a survey of the API. Meaning, unlike Frank Luna’s DirectX books, you won’t have any cool demos to showcase at the end. Through the whole book you’re basically just working with the initialization of the Vulkan API, though you do end up with a colored triangle and finally a textured cube. This is honestly fine, and just what is needed at this point in the life of Vulkan. Flashy demos are cool, sure, but once you have the fundamentals down, it shouldn’t be hard to apply that knowledge, or port techniques from other APIs.

I will note, however, that I wish there was more discussion into the performance cost or characteristics of parts of the Vulkan API. For example, sometimes there are multiple ways to perform an action (like with uniform buffers or push constants getting data into a shader) and there wasn’t much explanation as to when to do one thing over the other. This is not a huge concern, as there are lots of articles online covering these types of things and it seems the book is there to get you familiar with the concepts and data structures to allow you to do your own research later. Certainly, I still have a lot of questions but I can’t imagine a more thorough book as an introduction to this relatively new API.

Some familiarity with older graphics APIs will probably help, but I don’t think it’s absolutely needed. In my opinion, if you are wanting to learn graphics programming today, you might as well just jump into Vulkan (or DirectX12, if you prefer) as the industry will quickly adopt these new, lower-level APIs and you will be setting yourself up for the future. Do understand, though, that Vulkan is extremely verbose and needs something like 1,000 lines of code just to get a triangle on the screen. So stark beginners may be put off by that complexity. And you should definitely have good working knowledge of C++ before getting into this. With that in mind, however, I think that Learning Vulkan by Parminder Singh is a great place to start to delve into this exciting new world of Vulkan. Well worth reading.

Vulkan Graphics API: in 20 Minutes is a short, no-nonsense, introduction to the Vulkan graphics API. Though the title of the book says “20 minutes,” I believe I spent somewhere between 1 and 2 hours to finish it (though I admittedly read pretty slow). This is the type of book I wish there were more of: something short and sweet as a brief intro to get your feet wet. I feel many programming books can be daunting at 600+ pages, so it’s nice to find something you can complete in one or two sittings.

So what is actually covered in this little book? Basically it shows the basics of how to initialize the Vulkan renderer and draw a triangle on the screen. The author does not use any additional libraries, so it’s only showing the Vulkan API itself and some boilerplate Win32 code for opening a window. Though I had already been reading about Vulkan previously, and didn’t find any new material here, I could see this as a decent first step in learning the API.

To be honest,  Kenwright does not really provide any deep explanation of the concepts presented. It’s basically just showing some of the common function calls and the structure to set things up. You could easily find similar code online (at various sources) for displaying a triangle in Vulkan.  Even so, I still think the text holds value and may be more accessible than some of the larger (and more costly) Vulkan books that do provide more detail. This is sort of something that would be useful if you’ve really never worked with the API before and just want to see how the code looks and if it’s something you’re interested in prior to researching further.

All in all, I can’t really fault  Vulkan Graphics API: in 20 Minutes too much. While there were a couple typos and odd use of the English language, overall the book was concise and coherent. It provided a cursory look at a new, exciting, graphics API and it did with with a meager time and money investment on behalf of the reader. While you can find basically the same material online for free, I still personally enjoy learning from books and think the format may click for some people better. It only really scratches the surface, but as a short “first intro” book it’s not bad.

Essential Mathematics for Games and Interactive Applications by James M. Van Verth and Lars M. Bishop is a quality math book if I ever saw one.  Strangely, the first edition came out in 2004 but the book was kind of off my radar until recently.  This third edition was published in 2015 and seems very current. The authors here do a great job of explaining the material properly. I felt like they created a great foundation for learning these complex ideas and I appreciated the  quality and readability of the code  samples.

The book starts with an overview of computer number representations, and goes into detail with the IEEE 754 floating-point standard. At first I assumed this was unnecessary detail, but actually it’s pretty useful to understand and a good base to build on. They continue with vectors and points, linear transformations and matrices, affine transformations,  orientation (including matrices, Euler angles, axis-angle, and quaternions),  and interpolation (linear and curved). In the next section they transition to more graphic oriented topics such as: viewing and projection, geometry and programmable shading, lighting, rasterization, then a random chapter on… random numbers, and finish off with intersection testing  and rigid-body dynamics.

Just looking at the table of contents is sometimes not enough to get a feel for the quality of the text, so I will reveal  more. The beginning parts are really exactly what you’d expect for a game math book. The basics of vectors, matrices, quaternions, etc. are the bread and butter for a 3D programmer. The coverage here is solid and great for a beginner. Advanced readers  may not find any surprises, but it’s still a good refresher.  The interpolation chapter I found interesting, especially the detail into different types of curves and splines .  This could be immediately useful for coding  a skinned character or animating a camera in a game.  Viewing and projection were given adequate coverage and are essential to anyone wishing to code a graphics engine themselves.  The next chapter was particularly long and explained the programmable shader pipeline to great effect.  The authors explained everything from color representation, vertex attributes, drawing geometry, fixed-function versus programmable, vertex and fragment shaders (aka pixel shaders), and texture mapping. Really a great introduction for anyone wanting to learn to code shaders themselves.  Then they  move onto lighting and go into the basic types (point, spot, directional, and ambient), surface materials, per-vertex and per-fragment lighting, combining with textures, and a few small sections of more advanced topics like normal mapping, physically based lighting, HDR, and deferred shading.

Next up is rasterization, which was an awesome chapter that explained (in epic detail) how rasterizers work which I feel does help when you know what’s going on behind the scenes. I don’t know of many other books that explain this part of the pipeline so well, so this was much appreciated. The random number chapter was also quite informative. It’s easy to just call a function that spits out a number and not actually understand what’s happening.  I found this  portion of the book to be a nice surprise. Intersection testing was covered near the end, and  it was one of the longer chapters. Almost anything you could think of was here: finding distances from lines and points, sphere/ray/plane intersections, axis-aligned bounding boxes (AABBs), swept spheres, object-oriented boxes, triangle intersection, and a simple collision system. Finally the book closes with a chapter on rigid-body dynamics. I actually purchased my copy mostly for the rigid-body material and I felt I learned a few useful things. Of course, it was only one chapter but some of the explanation was better than whole books I’ve read on physics. Certainly it gave me a few things to research further, and I appreciate that.

Overall I would say that  Essential Mathematics for Games and Interactive Applications is an almost flawless textbook. I may be a great place to start for a beginner, and even intermediate to advanced readers may learn a thing or two. Some of the other game math books I recommend I read so long ago it’s hard to make a direct comparison. But this title is certainly up there with the best. I would wholeheartedly recommend.