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.

This is the second book in the new game engine development series by acclaimed author and engine developer, Eric Lengyel. Though it is not strictly necessary to read in order, it is basically one book cut into sections, so you may want to get the first one, as well as the upcoming continuations of the series, to get the most out of it.

I found Volume 2 of Foundations of Game Engine Development to be a solid resource and a compelling sequel to the first book. Please keep in mind that this is a foundation series, which builds a solid breadth of knowledge for building a 3d game engine. It is not a state-of-the-art cookbook, and much of the coverage is of techniques that are relatively old (say from 10 years ago or more). I would not say it’s a beginner’s book, it’s more of an intermediate level introduction. You will still need to be able to read the math and code snippets, though Lengyel does well explaining things.

I’ll give a brief survey of what’s in the 400 some odd pages (clocking in at twice the length of the first volume). The author dives into color science, gamma correction, coordinate spaces, and the basics of the graphics pipeline. Then he deals with projection matrices, really basic lighting models, normal and parallax mapping, as well as light sources and shadows (including stencil shadows, which I found interesting, despite being an antiquated technique). The next chapter focuses on visibility and occlusion and the book is worth reading for this chapter alone. Here we see polygon clipping, bounding volumes (spheres and boxes), frustum culling, portal systems, and occluders. This has got to be one of the best explanations of these methods I have seen in one text, the writing is clear and the diagrams are perfect. I especially like that the whole book is in color, and all the diagrams take advantage of this and are easy to understand. Finally, the book concludes with some “advanced” techniques, like decals, billboards, volumetric light, ambient occlusion, motion blur, and god rays. Gotta have those god rays.

I really enjoyed the whole book, and I found it to be helpful, even though I might have had some understanding of most of the topics already. Going in, you should know these are not state-of-the-art techniques, nor is it a shader code cookbook. For that you are better off with a GPU Pro or GPU Zen type of book. This is a foundations book, for people wishing to code their own game engine. There are not a whole lot of books that cover this topic, I have read most of them, and this is one of the best. Many books tie themselves to one API or framework version and are quickly obsolete. While here, in Foundations of Game Engine Development, you have tried and true methods that have been incorporated into practically any engine written in the last 10 – 15 years. The engine code is in C++, and the shader code is in a high level language, but the author thankfully does not mix in any API code so all the techniques are applicable to whatever API you prefer.

Overall this book is great, as long as you know what you are getting into. It’ll probably be mostly a refresher for game engine pros, though for people starting out I think this would be a godsend. I should preface this with saying I’m still not 100% sure writing your own engine today is a good idea. If you asked me honestly, I’d probably say use Unreal or Unity and call it a day. However, if you do want to go down this path, you really can’t go wrong with this series. Recommended.

Don’t judge a book by its cover. This is a blockbuster tour through WebGL, with many performance optimizations and considerations not commonly found in other texts. Like typical gems collections, each chapter is written by a different author and focuses on one aspect of WebGL coding. There is a lot of coverage here, and I found the authors’ expertise to be second to none. While maybe not apt as a beginner’s tutorial, I would definitely recommend getting this if you already have some WebGL chops and want to up your game.

WebGL Insights starts with some inspection of the back-end of WebGL in Mozilla’s implementation as well as how ANGLE fits into the picture. A chapter on Emscripten and mobile optimization. Engine design from several different authors. Deferred and HDR image-based lighting. Finally ending with visualization and user interaction. While not everything here was immediately relevant for gaming, I did find lots of little nuggets of information dispersed throughout.

So overall a stellar book. I was kind of put off by the cover, but the reviews looked good and I recognized some of the authors, so I picked it up. Definitely a great book for anyone interested in WebGL coding, especially since this text covers optimization techniques not found elsewhere. As it is more of an intermediate to advanced resource, I would recommend reading a beginner’s book first if you are just starting in WebGL. Otherwise, you should definitely grab this one, well worth it.

Of the top WebGL books I’ve read so far, I think I can say this one is the best. Not only is it well written, but it includes lots of detail about how rendering APIs work, 3d math, lighting concepts, and even some performance considerations at the end. It’s not a very long book, but it covers the fundamentals well. I also enjoyed that the author stuck to the base WebGL API and did not confuse matters with frameworks like Three.js. He did use some libraries, like glMatrix in particular, but this is fair as coding the math by scratch (while doable) is out of scope of the material presented.

There are quite a lot of topics covered, even for a somewhat smaller book. I read on a 10″ Android tablet and everything was formatted correctly and looked nice. The author first explains what a graphics API is and the graphics pipeline. Then he goes on to show differences with other APIs like DirectX and OpenGL, and dives into 3d mathematics briefly. He continues with WebGL concepts like drawing a triangle, debugging, transformations, handling lost context and updating, textures, basic lighting techniques, and caps off with some optimizations tips. While there is quite a lot that is not included, I found the coverage to be sufficient and I could tell the author knew what he was talking about.

Overall, I feel good about this book. Andreas Anyuru is a talented author and explains everything very well, it makes it look easy. You still might want to combine this with some of the other books available to get the full picture, but this would be great as a first entry point into WebGL.

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.