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.

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.