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

I just purchased the Kindle ebook version of this, right after I read the preview which was of David Buck's glowing foreword. David Buck, of course, is _the_ DKB who co-authored POV-Ray. So, look. I use Ubuntu because I am a programmer who REFUSES to use Windows. And my pet peeve with Kindle ebooks is that I have to read them by browsing Amazon's Cloud reader with a Linux compatible browser. But ... ANY book which David Buck recommends is a book I want to buy. And, so far, I have not been disappointed. From the first page, this book has that K&R "C Programming Language" vibe which inspired me to teach myself C, and which latter inspired me to teach myself C++ from reading Strustrup's EXCELLENT book. BUY THIS BOOK. You will NOT regret it.

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. )

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!

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.

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.

Decent book that I've been trying to get the free time to work through.It uses Cucumber SW which is both annoying to download and learn but essential to learning the SW engineer techniques taught in this book. If you're not interested in learning and installing Cucumber I'd recommend you skip this book. It was a bit of a mystery what to download as far as Cucumber goes too.

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.

This is a great introduction to building a Ray Tracer. The test driven approach gives you confidence along the way that your code is correct.

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.

I disliked the overuse of test cases. It took days of writing writing test cases to get to the point where I had a program that could render a sphere using Phong shading. Implementing the remaining test cases in the book and finishing the ray tracer would have taken 3-4 weeks by my estimation. I would have preferred it if the author had simply presented working, tested code and used the space he devoted to test cases to expanding the explanations. All in all, I was disappointed by this book. I abandoned the book at chapter 5.

This is one of the best books I've ever read. It's just amazing, entertaining, didactic and fun.To the people here saying that there are many tests... Well, it says right on the cover. Also you don't need to implement all of them. For example, you don't need to implement the tests for the cofactor, submatrices, determinant, etc. to prove that you can invert a matrix. Just test that you can invert some matrices, be pragmatic, you're a programmer!

In diesem Buch wird der Leser in Form von Tests herausgefordert, gewisse Funktionen zu programmieren. Die Wahl der Programmiersprache und die genaue Umsetzung werden dabei offen gelassen. Nach und nach wird das Programm so erweitert. Durch die Tests wird sichergestellt, dass der geschriebene Code korrekt funktioniert und der Leser bereits nach kurzer Zeit einfache Bilder erzeugen kann. Schrittweise wird dann diese Basis mit diversen Features erweitert, bis am Schluss sogar komplexe 3D-Figuren aus .obj Dateien geladen und in Szenen verwendet werden können.Wer auf Probleme stösst, kann sich im offiziellen Forum melden. Andere Leser, sowie der Autor Jamis Buck persönlich, bieten dort ihre Hilfe an. Ebenfalls sind einige kostenlose Bonuskaptiel vorhanden, welche in der gewohnten Art die Implementierung einiger Zusatzfunktionen beschreiben.Mit diesem Buch ist die erfolgreiche Programmierung eines einfachen Ray Tracers beinahe garantiert.

Sehr gutes Buch wenn man neu im Thema Rendering ist. Die Tests helfen einem sein Programm richtig zu schreiben. Allerdings sollte man einiges wissen in Software Engineering und der zu verwendeten Programmiersprache mitbringen (Die Sprache wählt man selber). Gegen Ende werden die Tests etwas viel und es viel Durchhaltevermögen gefragt auch jeden Test zu implementieren (Jede Entscheidung die man triff und vom Buch abweicht, stellt dort einen Fallstrick da) aber es lohnt sich, denn die Fehlversuche kann sich zum Teil komplex darstellen.Ich habe den beschriebenen raytracer in C++ geschrieben und templates verwendet wo es nur ging. Dies stellte sich besonders bei der Tupel Klasse als recht komplex da. Es war notwendig Variadic templates mit Bereichs-Einschränkung über std::enable_if zz implementieren. Nur so war es möglich konstruktoren mit genau N (Template Argument) Parametern zu schreiben.