Sams has always published solid content, and this book does not disappoint. In fact, I think one of the first game development books I read some 20 odd years ago was from Sams. This text on Unreal Engine 4 is comprehensive and worth reading (even if it is a few years old).

Here the authors cover many important topics, like installing Unreal, working with the gameplay framework, understanding coordinates, units, and transformations. Static mesh actors, lighting and using materials. Audio. Landscapes, world building, and particle effects. Skeletal meshes, cinematics, physics, visual scripting (including level Blueprints and classes), key events, UI, packaging your game and mobile optimizations. By the end of the book you’ll have a simple asteroid shooter demo to play.

All in all, there is a lot of content in the 24 chapters and around 500 pages. I found the discussion on customizing the game mode and player controller to be particularly helpful and not widely covered in other books. The chapters on working with skeletal meshes and cinematics were also nice.

I was never bored, and each chapter felt engaging and useful without being too long. Though the book is a tad older, most of the concepts still seemed relevant, though I did not test the code and wouldn’t be surprised if a few things have changed. But it’s a solid resource and worth reading.

Blueprints Visual Scripting for Unreal Engine is a great little book. Clocking in at just 190 pages, it is a quick read but packed with practical information. Brenden Sewell does a good job of introducing game development concepts in a series of chapters which build upon the same project, culminating in a nice (if somewhat simple) demo at the end.

Inside this book, the author discusses the basics of using Blueprints, customizing the character controller, creating UI elements, working with branching and conditional statements, simple enemy AI, implementing game states, as well as building and publishing your game. Certainly not an exhaustive list, but a good range of popular topics you will need to make a game with Unreal Engine.

I found the chapters on AI to be especially compelling. They were clearly explained and very functional. The way the chapters all build upon one another was also a plus, and made the learning practical.

Overall an enjoyable book and a good introduction to using Blueprints visual scripting in UE4. The text uses the Unreal default art assets, so the demo you create is not particularly fresh in terms of the design, but if you want to learn visual coding, this is a great place to start.

Rachel Cordone’s Unreal Engine 4 Game Development Quick Start Guide is the perfect book for people with some programming chops, or users of other engines (like Unity), that want to get up to speed quickly with Unreal. I really liked how the author does not waste time explaining basic things (like what functions or variables are) and jumps to the practical steps for getting things working. Unreal experience is not required at all, though you should have some foundation of how programming works to get the most out of the text.

Most of the book is using Blueprints, the built-in visual scripting language of UE4. I’m a huge fan of Blueprints, and visual scripting in general, and you can accomplish many things, even a whole game, without touching C++. However, Rachel does show how to use C++ and interface with Blueprints code (very handy). Within the book, the author explains each step along the way to accomplish various things, along with screenshots of the Blueprints, making everything easy to follow.

Some of the topics covered include: the basics of navigating the editor, using variables, functions, events, and creating a Blueprint from scratch. Adding C++ to a Blueprint project. Creating menus and HUDs with UMG, animation, scripting AI, multiplayer, and optimization. Definitely not an exhaustive list, but a good range of information to get a feel for how powerful Unreal is and how to quickly start working with it.

So far, I’ve only read maybe a couple other Unreal books, but I think I can say this is the best I’ve seen. While some other books are longer and more in depth, as this one only clocks in at just under 200 pages, I feel like the brevity helps keep things focused. While you’re not creating Grand Theft Auto here, the simple demo built in the book is functional and teaches the basics of how you would make a game in Unreal.

This is a case where the title of the book is very apt and honest. This is a “quick start” guide for game developers not familiar with Unreal Engine 4, but maybe that have experience with Unity or some other engine or framework. I think if you are a complete beginner, you might want to read up on basic programming concepts first, though the book is simple enough you could probably just jump in if you really wanted. For people with experience elsewhere, this is perfect to get up to speed with Unreal fast. I can’t recommend this book enough.

Understanding ECMAScript 6 delivers exactly what the subtitle proclaims, the definitive guide for JavaScript developers. While I have been working with Javascript for years now (and particularly ECMAScript when I was developing for Flash) I hadn’t really kept up with the recent developments. JavaScript always seemed to be missing important OOP concepts like classes or inheritance, and the ways to “fake” them with objects always seemed like a hack to me. Thankfully, ECMAScript 6 (or, rather, ECMAScript 2015) addresses these concerns and build JavaScript into a much more elegant language than ever before. If you want to get up to speed with the latest and greatest, I can’t think of a better resource than this book.

Nicholas C. Zakas does a great job here of showing all the new functionality in ECMAScript, and also how it compares to the older standard. The chapters in the book delve into block bindings, strings and regular expressions, functions, destructuring, symbols, sets and maps, iterators and generators, classes, promises, proxies, and modules. Each code example is self-contained, and the author shows a number of samples for each concept, making it easier to understand step by step. He even starts with how it was done in ES5, so you can see familiar concepts transformed into their modern equivalents. I learned quite a lot here from this text, and feel like I’m ready to start coding in ES6, even though this was the first book I read on the topic. It’s that good.

One thing to note, this is not an introduction to JavaScript. The author assumes you are already proficient at the intermediate to advanced level, and does not waste time trying to explain the fundamentals. If you are just starting out, this book will probably be too advanced and confusing, you should have a good handle on JS first before embarking here.

Overall, I think this is a premiere quality resource to go on your shelf (or digital library, if you buy the e-book version). The Kindle version looked particularly good on my tablet, and the text and code were formatted well. At around 350 pages, the book is not super long but manages to explain everything in vivid detail. I could tell Zakas had a full understanding of what he was teaching, and each example was clear and to the point. Some of the later chapters (the one on proxies, in specific) were a little obscure, but I liked that he went the extra mile to cover everything. Honestly, I’ve read a ton of programming books, and this is one of the best. Well worth picking up if you even have the slightest interest in coding modern JavaScript.

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.

Game Engine Gems 2 is the second book in a series from editor Eric Lengyel, one of the premiere game engine developers in the scene. I read the first book and I will say this second volume is even better in my opinion. There are a vast number of topics covered, and I found the depth in most of them to be thorough, considering that this is a gem collection and not a full book. Inside there are 31 chapters, each from a different author, and a lot of ground is covered. Chapters include: bounding boxes, volumetric clouds, night vision, deferred shading, OpenGL tricks, stereo 3d, web browser 3d, object-oriented design, networked games, GPGPU cloth physics, bit hacks, memory management, multi-threading, and more. Each section was given about 10 to 20 pages, but the authors were concise and were able to explain the concepts well in the short space. I very much enjoyed the wide span of content and I feel this is a text I will look back upon for reference in my own development.

While some of the topics were a bit over my head, I did find most of the book to be digestible and relevant. The text would be most apt for people developing their own engines, especially in C++. A few of the early chapters could likely be applied to commercial engines (for example, the sections on volumetric clouds or night-vision shaders) but the the vast majority of the book is focused on more lower-level engine work. I liked that stereoscopic 3d was covered in a few chapters, and the depth was greater than in the first book. The chapters on multi-threading were also very helpful, even though this is admittedly a confusing area for me (I bet I’m not alone). And the section for bit hacks was pretty interesting, which showed some tricks like how to test the sign of a number without branching. Overall, I think this is an awesome book and feel it was somehow overlooked. I would recommend this to any engine developer. Also bought the 3rd book in the series, and I’m looking forward to see how that stacks up.