Practical Rendering and Computation with Direct3D 11

I was thoroughly impressed by Practical Rendering and Computation with Direct3D 11 by Jason Zink. Microsoft’s Direct3D API is certainly not for beginners, and neither is this book. But, at the same time, the author does a great job of explaining the material in a way that is approachable. The book assumes you are already comfortable with C++, and doesn’t hold your hand with the syntax. This is great, since you really should have an understanding of C++ before jumping into 3D graphics programming. It’s also not the kind of book that expects you to type in long pages of example code into your computer. In fact, there are not really any complete examples listed in the book at all. Instead the author chooses to highlight specific API calls and explain how different techniques can be implemented using the GPU. This is in stark contrast to the last DirectX 11 book I read by Frank Luna. Luna’s text was great, don’t get me wrong. But it was very focused on producing functional demos to showcase certain effects (like shadow mapping or ambient occlusion). Instead Zink chooses to go totally knee-deep into the API itself and, as a reader, I came away much more confident that I understood the material. Just as an example, early on in the book there is a 100 page chapter just on resources. Most other tutorials would briefly show how to create a buffer, and then move on other stuff. Not here. In fact, the next 200 pages of the book is just about how the pipeline works. It’s really great, and rare to find such insight. Don’t be fooled, there is certainly code in these pages, and there are a few examples. The book covers some topics like deferred rendering, multi-threaded graphics, dynamic tessellation, and physics. What I liked about the examples is that only the bare minimum amount of code was shown. Just enough to understand the key concepts without getting bogged down with boiler-plate code. It also made reading along much nicer, without having to feel like you need to get up every 5 minutes and type something in on a PC. Plus, the source code for the examples, and the author’s engine, are available for free online. So no need to type either way. One thing I really enjoyed was the discussion on DirectCompute and on compute shaders. There are hardly any books covering DirectCompute, so it’s great to see so much space dedicated to the API. I am very interested in using this in my own engine, though it’s difficult to find information on the topic. Practical Rendering and Computation includes several chapters using compute shaders, for example to do image processing (blur). There was also a good amount of space given for tessellation. So if you are at all interested in these specific topics, it’s pretty much a no-brainer to get this book. One other thing. Mad props to Jason Zink for being available to the community. You’ll find him on the gamedev.net forums, even helping out newbies with their 3D questions. Much respect. All-in-all, this was quite an eye-opening read. I mean, after reading the Luna book and doing some online tutorials, I thought I knew about DirectX 11. Well, I knew something. But this book went much further than what I had previously seen on the topic. I would even recommend reading this *before* Frank Luna’s book, as I think that would flow a little better. Get the foundation solid, and then start learning how to code specific effects. Anyway, this book comes highly recommended by me if you are attempting to learn Direct3D.

This book starts out by covering the DX11 pipeline, resources, and associated DX11-specific features like multi-threaded rendering and tesselation in a way that's easy to understand. It then provides a number of concrete examples covering various rendering topics that specifically eschew the simple. Instead, they are well-explained implementations covering areas such as deferred rendering, tesselation-based terrain rendering, vertex skinning, and GPU particles, to name a few. If you're interested in any of the advanced topics the book covers, it pays for itself here as the combination of good explanation and implementation can be hard to find. Note the examples are implemented using the Hieroglyph3 engine available on Codeplex and I found this to work quite well. The engine structure maps closely enough to DX11 constructs that you're not fighting abstractions to see them clearly, yet streamlines them enough that you don't feel like you're missing the forest for the trees of API-related minutia. Indeed, I found the engine itself interesting enough that I would have purchased the book based soley on that criterion. Note finally the book does not advertise "beginning" in the title, and is not the only resource you'll want for learning the fundamentals. This is a good thing however because good books along those lines already exist and the pages are best spent elsewhere. I've personally used this book in conjunction with titles like "Introduction to 3D Game Programming with DirectX 10" and "Real-Time Rendering", and found them to complement each other nicely.

With it having been several years since I last worked with Direct3D (DX9), I wanted a book as a refresher in the DirectX way of doing things when I decided to return to computer graphics. What I got, was largely unspectacular. Practical rendering is by no means a poor book. It authors are Microsoft DirectX Most Valuable Professionals. This means the material presented is accurate and well written, but it fails on too many fronts to be considered great. The first half of the book is dedicated to explaining the Direct3D 11 Pipeline or at least it tries to. What you get is ultimately a regurgitation of the freely available DX documentation. The authors do little to actually explain the behind the scenes workings and I have a feeling if it is your first foray into DX you will be quickly lost. The one bit of explanation they routinely throw at you is through the use of images to explain concepts. This sounds excellent until you realize what it really means. You get images like a cube with six exploded sides demonstrating a cube map (which is sadly one of the better images) and my personal favorite, an image of a sphere in three different positions to demonstrate translations. This examples may sound petty, but if you read this book you will constantly roll your eyes at the ridiculousness of these listings. Code listings for the book's first half are no better. They are literally ripped from Microsoft's documentation and dumped on the page in an unremarkable matter. The book improves in it's second half with more concrete examples of the concepts. They are actually interesting reads and very well explained compared to the first half. Unfortunately, here is where the book's biggest problem comes in. The authors have elected to use Jason Zink's Hieroglyph 3 engine as the basis for all of their examples. While I'm certain Mr. Zink's engine is of a high quality, it is a huge mistake. The justification for it's use is so we as readers are not bogged down in minutia when it comes to initializing Direct3D and Win32. In practice, it fails to allow us experience in initializing Direct3D. This is a fairly important component of using the API and it's dismissal is absurd. You will be forced to return to the documentation of the DXSDK in order to find anything of use, unless you want to be locked into the Hieroglyph engine. The biggest problem with authors using their own engines is in the changes that occur over time. Including raw DX and Win32 code allows future use even through subsequent DXSDK changes with a minimal of rewriting. The Hieroglyph engine is already changing from the version when the book was published just a few short months ago. Nowhere is this more apparent than in the books appendix stating that the Boost libraries are required for building the engine. On the engines homepage, this dependency has already been removed. This isn't a big deal for now, but does speak to the rate at which libraries tend to change overtime. It is entirely possible in the future the engine will have changed so much it's usefulness will suffer. Because of the use of the Hieroglpyh engine, all of the examples focus on shader code and leave everything else up to the engine itself. This is not particularly useful when you want to learn how to code in D3D11 from the ground up. While the authors have presented a few useful chapters, the book fails to deliver consistently. If you are looking for anything other than a few shader code examples of trendy topics, you will have to look elsewhere. I recommend picking up Frank D. Luna's Direct3D 10 book to learn the fundamentals of DX programming. Afterward the Direct3D 11 documentation will be more than sufficient at highlighting the differences in the older and newer APIs. If you want the examples this book offers, I would suggest a GPU pro or ShaderX book as they are considerably heavier on content and will provide many more examples than this book provides. Again, it is not a bad book and if I were looking for strict documentation this would be high on my list. It's weakness however is in striking a balance between documentation like theory and cohesive examples of implementation.

This is a much needed book dedicated for the DirectX11 API, as it gives detailed description of rendering pipeline, shaders, resources and HLSL references. And the usage is more up to date compared with other books. However this is not a beginner tutorial. And the main focus is what those APIs are for, not how to use them. The sample code is not learner friendly either. Instead of having separate projects for each topic, the sample code is an amalgamation of all topics. So it is harder to find exactly the material in the book is applied.

After playing with Direct3D 11 for a while and being a convert from D3D9 I was still getting a bit of headaches. As it often turns out, the problem was between a keyboard and a chair. In my case the documentation provided by Microsoft, as well-done as it is, couldn't answer completely the very basic question - How to code modern graphics with this API using ALL its features. Then I found this book and it did the job. It filled the gaps in the whole picture. What I like the best is the amount of effort spent on freshly-introduced elements of D3D11. All in all, authors made it clear they want a reader to get to know API so well so that he could implement any idea on its own. Of course, it's not one book that makes you a master, that's practice. However one has to start somewhere. When you are looking for a well-paced guided walk through foundations that's the book I recommend. PS. I hope to see a part 2 of this book starting where this one ended.

I have only read the first 76 pages of this book thus far and have skimmed through the rest of it. I must say, this is the best book that I have seen on Direct3D. Whether you are just getting started with Direct3D (and have C++ programming experience) or if you are a very experienced implementer of D3D does not matter as this book will be a good fit for both types of audiences. It's well worth the money and will be a companion on my desk for as long as D3D 11 remains a viable API in the industry. I highly recommend this book. It's a must have tool for anyone seriously developing wtih this API.

The book is devoted to Direct3D and provides usable examples for using D3D in real-time rendering! It can not be used as tutorial, so if you want to program Direct3D 11.2 use: 1. VS 2013 3D templates 2. DirectX book from Frank Luna 3. This book

I really wanted to like it. It has some good content and I like what it tries to achieve. But I have to admit I am quite disappointed by it. 1) horrendous quality By print quality this is the worst book I ever purchased in the last years. And I have bought a ton of books. Mine seems to have print mistakes on the cover and the pages that would make sense to have colored syntax are barely readable because they chose to do greyscale prints. 2) content some goodies here and there and it has a good introduction, but also quite missing a thread or consistent through all the chapters. It feels like chapters stitched together and none of the authors had a holistic vision about this book. There is also quite some repetition and a lot of almost copied content from the official documentation / reference. It is not worth the steep price. Sadly it is still one of the better D3D books out there :(

This is a book that developers will like! But developers means developers. Some knowledge about coding in C/C++ and developing for Windows Applications might be helpfull. The provided homepage with the well documented library HIEROGLYPH3 shows an interresting approach how to handle the D3D11 APIs in a professional manner. For me it's not the beginning in Parallel Computing or some kind of "low level graphics coding" but the Authors of the book are giving more than just "a hand" to anybody who is interested in understanding and mastering the D3D11 APIs in detail. Many lacks in the known online documentation from MS are filled with informations and SOLUTIONS that can help You fast to dive deep into the possibillities that are provided with that D3D11 stuff (and more) covered in the book. A lot of well known samples, that any developer (or ongoing developer) can find about ATL/MFC dealing with D3D (for free at e.g. msdn) are provided at the homepage too. This helps to bring all the mass of given informations into the context of realistic development scenarios and practical (=professional) rendering and 3D coding. I'm happy 'couse it would have taken me several months(maybe years) to bring all that informations and "how to knowledge" - especially provided inside HIEROGLYPH3 - together. It means NOT a warning when I'm writing here: This is NOT a "hands on book!". If You've passed the tutorials and the typically "hands on time" that is needed to understand the basic concepts of 2D/3D programming and last but not least the very basics of D3D (no matter if D3D9/10 or OpenGL was Ya home) THIS book should lay on the table, next to Your keyboard, if You want to save (a lot of) time during the hard way climbing up the high mountain where the "Professionals" reside. A few thoughts at the end: I like the book. It saved a lot of my time making myself familiar with the new concepts DirectX 11 provides. I'm used to code in different environments (IDEs) on several hardware (e.g. NVIDIA or AMD). What a good book about the use of a library will never tell You is how to set up Your hardware and software. Both is under a permament change. It's up to anybody to solve this problems on his own, isnt't it? Stefan Reimann from Bavaria - Germany 4/7/2012

HLSLについて根本から丁寧に説明している本は少ない。アニメ文化の相違であろうか、CGは米国のほうがリアルであり、それを反映してCGソフト技術者の層と質は米国のほうが上のようだ。HLSLとCGをきちんと学ぶには良い本である。

Its a fantastic book that goes into details of the rendering pipeline. The Hieroglyph3 engine available on Codeplex provides outstanding examples of every aspect/topics covered in the book. I particularly enjoyed chapter 6 on the reflection interface, the detailed treatment of DirectX resources and the chapter on multi-threaded rendering. Great coding by Jason Zink.

Excellent book for learning and understand how Direct3D 11 works and how to use it. I am a newbie on graphics and DirectX programming, and maybe for some users this book could be difficult to read without a small background of 3D-graphics and object oriented programming... But the content of this book clears a lot of dark corners of the Direct3D programming up, especially if you do not have a solid understanding how the API works. The book could be divided into two parts, one form those want to know more about the base of the API (and also for those don't know nothing or quite nothing about Direct3D 11), and a second part about some intermediate and advanced topics and techniques that could be done with the last version of Direct3D. The first parte explains very clearly the fundamentals of Direct3D, starting with a small overview of the API itself, then explaining every single notion in the right order to understand how Direct3D works and how use it, from the resources (buffers and textures), to the rendering pipeline (showing every single stage, including high-level pipeline functions). It also teaches very well the two new most important additions since Direct3D 10.x: the tessellation pipeline and the computation pipeline. It also has a chapter about HLSL (High Level Shader Language) The second part is more about advanced topic, like multithreaded rendering, tessellation, deferred rendering and water simulation. These topics are approached to show the potential of Direct3D 11, so if you are searching traditional algorithm and basic render operation you should search elsewhere (the MSDN library could be a good point to start ' ). The book doesn't provide the traditional CD with the sources and the reference of the example, but the authors have preferred to provide a full , complete and free rendering library (under MIT license) available on its project website ([...] So if you are searching a book to learn and understood Direct3D 11 this book is for you. You will not found the traditional approach (or the approach of many books) where you have a lot of dummy example where you found "hey, this program draw a triangle and fill it with yellow... well, this line do this, this and this..., this is another thing, this other is just a pattern... oh yes here we have the 5 lines (of more than 350) that I will explain for this example"... With this book you will understand the Direct3D API in its rules better than all other book I have found around the web, and you will learn how use all this rules to do what you exactly have in mind.

The book isn't a "how to start being a game programmer" book - and that's a good thing. While promoting the code used as an "engine", placed live on a codeplex website, the book focuses on all the detail in DirectX 11. There's les of a feeling of story and progression, like most books of this nature - which aim to teach you to use specific frameworks and effects preferred by the author - it's partially a reference book, with very deep coverage of essential DirectX flags, values, functions and structures, and looks regularly at CPU and GPU registers to show how the workings tie together in DX11.