The Ray Tracer Challenge: A Test-Driven Guide to Your First 3D Renderer (Pragmatic Bookshelf)

The book is awesome! It starts with the basic stuff, gets you to render images quickly and, mostly importantly, explains why you're spending time on implementing a particular piece of code. The book's tests-first approach pays off quickly. It keeps the bug count low and gives you the confidence that the math, shading and intersection code is solid and you can continue to build on top of it. The book's code is mostly pseudocode that is trivial to translate into whatever implementation language you pick. The language really doesn't matter. I used JavaScript and added multi-process rendering to speed things up. I might go back to this book in the future and use C. There are no rendering libraries, no OpenGL/DirectX/Vulkan code and custom book library code to deal with. You write everything from first principles. The images are by default rendered into a memory object and saved to disk in PPM format. I added PNG support because it was easy after implementing the book's PPM functionality. One thing the author does well is he guides you through the details until the point where he can take the training wheels off and you can implement features by yourself. I highly recommend this book to anyone interested in computer graphics. It really is an excellent book!

I've had this book for a couple years now, and thanks to the COVID pandemic, finally got around to read/implement it. The explanations are clear and to the point. There's loads of unit tests given so you can do Test Driven Development, which is a godsend since graphics programming is very error proned. There is just enough theory and lots of pseudo code to help you along the way. The pacing of the book is also very good, each section starts with basic theory then there's unit test and then some pseudo code that you can implement . I can't recommend this enough. The book is programming language agnostic, I did mine in Rust, but the pseudo code can be translated to any programming paradigm.

I previously bought Jamis' book on Mazes and enjoyed that, so this seemed like a great idea -- I was starting a new job, and needed a project to force myself to learn a new programming language as a result. This book isn't programming language specific -- don't expect guidance setting up your editor or IDE of choice here. What you do get, however -- a guided tour thru the process, background, and math involved in building a ray tracing application with the added bonus of being able to incorporate unit tests into your development following the examples given in the book. I've gone thru the book once so far using Python ( a language I was already familiar with ) -- now I'm working my way thru again using C#. I'd recommend this to anyone looking for practice programming projects (either in a familiar language, or as a tool to help master a new one. )

This book is good, it has test that are easy to follow and independent of programming language are easy to implement. I personally used GLSL within another language for this ray tracer. My only issue with the book was that values larger than 1 and less than 0 were often not addressed. In my case this often led to semantic and visual bugs that were hard to find and fix. I was always able to do so with vigorous following of their test, which is a positive. That being said, I think a book that focuses on test first programming should take the time to handle edge cases that involve things as common as this.

Highly recommended, this is most educational book I have read in the last... 5-10 years? A typical chapter will include some descriptions of a ray tracer concept, pseudo code illustrating core parts of the algorithm, a minimal test case example, and then a bunch of test cases assigned for you to finish. These test cases you have to write and then implement are where you prove you really understand what's going on with each ray tracer concept. I suggest you stick with it no matter how long it takes and don't skip ahead, this experience was invaluable. I learned a lot about ray tracing while going through this and came out with a really cool library I can use to render graphics in lots of different ways. It took me at least a year, some parts were very challenging beyond the ray tracing (like how to manage and refactor this growing codebase one chapter at a time), but in the end it all worked out nicely :) This book sets the bar very high for other Pragmatic Bookshelf titles to live up to. I was stuck at least twice and browsing through the forums for this book gave invaluable clues, I recommend to check it out. There are also interesting discussions there for ways to optimize the raytracing logic and implement cool new features. Another review claims that Cucumber test suite is required to use this book, it is certainly not. Examples for test cases are given as short pseudocode Cucumber files, which you can translate into other languages or test frameworks.

The test driven approach of this book is excellent. The book is easy to read, explanations are crystal clear, and if you need help you can use the book's forum. You can build your own ray tracer from scratch bit by bit, step by step and it will be totally covered by tests. It's really exciting feel the accomplishment every time your tests pass and see the results of your effort in an image (a picture is worth a thousand words). You don't have to be a math wizard to fully understand the book. What are you waiting for?, buy your copy of this book and prepare to have a lot of fun.

Great book. I did struggle in a few spots. When doing the tests it is good to know the many WILL fail until you read the solution presented pages later. Read ahead.

And as a plus you will dive into Cucumber as a testing framework. If you want a deeper dive into the underlying math, this is probably not for you. But if you want to see a project come together and build momentum, this is a fun read.

Un bon livre à l'approche intéressante, aux explications claires, aux schémas très réussis... qui aurait pu être tout bonnement excellent s'il n'avait eu les deux défauts suivants : - L'approche "test-driven" aurait pu, et dû, être optionnelle. Libre à chacun de vouloir implémenter tous les tests, seulement certains, ou encore n'en implémenter aucun. Si vous décidez de ne pas suivre cette approche, vous aurez à faire de la gymnastique pour vous adapter et suivre le bouquin tel quel malgré tout. Ces tests, détaillés au caractère près, prennent de la place pour quelque chose qui aurait été pourtant capital, cf point suivant. - L'implémentation des calculs mathématiques devrait être plus mise en avant. Si l'implémentation concrète va dépendre du langage utilisé et des méthodes de design propres à chacun, rien n'aurait empêché d'utiliser du pseudo-code ou encore des exemples dans un ou plusieurs langages. Après tout, les tests ne sont-ils pas présentés dans un langage précis choisi par l'auteur ? Certaines opérations mathématiques sont décrites avec des mots, là où un exemple en pseudo-code aurait été bien plus parlant. Je reste satisfait de cet achat et de cette lecture pour l'instant, mais de mon expérience suivre les étapes dans l'ordre est plus fastidieux que si le bouquin avait été structuré sous la forme explications/schémas, puis implémentation, puis propositions de tests.

Se você gosta de programar e tem interesse em Ray Tracing, eu recomendo bastante esse livro. Ele não dá muito detalhe sobre a parte matemática do Ray Tracing, mas sim em como implementá-lo em um linguagem de programação qualquer.

Bom Livro para quem gosta de um desafio divertido e para quem gosta de programar c

I bought this book on the 31st May and it sat on my desk for a few weeks whilst wrapping up other work. On the 2nd July I made my first first commit and I've spent almost all my free time up until the start of August working through it. I originally intended to blog a sort of mini-series as I progressed, but that went out of the window after the first commit - I was utterly enthralled by the challenge and didn't stop for such mundane tasks as writing blog posts! Even tearing away enough free time to write this review has been challenging, although I mostly wrote it whilst waiting for scenes to render and animations build. I am very glad I bought this book - I have never read anything quite like it. The way it was presented means I was never truly floundering, and it quietly taught me without me realising. I've always had trouble reading linear algebra but I've noticed that I'm now finding it easier to read some formulae. I've still got a way to go with that sort of stuff, but I'm definitely improving. I did have some problems - several times I didn't notice that the result of a square root was supposed to be negated and wondering why my tests were failing. On occasion I simply didn't read instructions properly and implemented something almost, but not quite, right. And of course, I spent a lot of time trying to make SpecFlow fit how I have traditionally tested. But it was pretty much all user error... I didn't spot any mistakes in the book or run into insurmountable issues. I do wish there were a few more reference YAML files though, that would mean I could compare images I generate with those in the book to make sure I really had things working correctly, not to mentioning actually defining correct camera and lighting properties is more challenging that you might think. In short, I found this book fun. Really, really fun. It reminded me why I became a programmer in the first place. It also had the unexpected side effect of making me realise that I've been burning out for a while now doing the same old same old. I didn't expect a technical book to make me think about life choices! I also can't stress enough how awesome the test driven format of the book is. It was quite something to implement a few tests, and just like that you have another amazing piece of rendering functionality. Even though I've reached the end of book, this isn't the end of the story. At the time of writing this review, Jamis has also published 3 bonus chapters on the forums, one for creating bounding boxes, another for soft shadows and the third for texture mapping. I really can't wait to get that last one implemented! Some of the (low poly!) OBJ files I've tested also reference external materials and supporting these should be straightforward enough.

Super, man kann gut folgen, Fortschritte sind schnell merkbar und alles baut sinnvoll aufeinander auf.