Wer schon immer den heiligen Gral der 3-D-Computergrafik gesucht hat, wer schon immer wissen wollte, welche magischen Kräfte die so bunte Welt der Computerspiele im Innersten zusammenhalten, der wird hier seine Antwort finden. Ein zumindest angefangenes oder auch abgebrochenes Physik- bzw. Mathematikstudium sind dabei jedoch die Conditio sine qua non, um sich nicht in dem Labyrinth aus Formeln und Algorithmen zu verirren. Der akademische Hintergrund des Autors mit gleich zwei Ph.D.-Titeln in Informatik und Mathematik macht sich in der Stringenz und Klarheit deutlich bemerkbar und katapultiert das Buch auf ein selten hohes Niveau in diesem Genre.

Der Autor hat das Gebiet dabei so gründlich bearbeitet, dass das Buch eher als ein Referenzwerk zu betrachten ist, in dem man je nach Problemstellung stöbern kann und sicherlich fündig wird. Das Buch spannt dabei den Bogen von den grundlegenden geometrischen Problemstellungen wie Abstands- und Schnittpunktberechnungen und Bestimmung von Einhüllenden, die für das später erklärte Culling, Clipping und die Kollisionsabfrage wichtig sind, bis hin zu High-Level-Spezialeffekten wie Bump oder Environment Mapping, die allerdings etwas oberflächlicher gehalten sind.

Nach der überaus profunden Abhandlung der Grundlagen werden die Aspekte der Graphics Pipeline sowie des baumstrukturierten Szenemanagements untersucht und auch eine kompakte Abhandlung über parametrisierte Kurven und Oberflächen, die vor allem für die an Hauptspeicher armen aber leistungsstarken Spielkonsolen wichtig sind, präsentiert. Es schließen sich Themen wie Character Animation mit dem Problem der inversen Kinematik, die Reduktion des Detaillierungsgrades (LOD) bei weit entfernten Objekten und Landschaften und eine allgemeine Raumstrukturanalyse (BSP-Trees und Portals) an. Abgerundet wird das Ganze mit einigen hilfreichen Tipps und Tricks zur OOP und einer umfangreichen Formelsammlung für die Lösung häufig auftretender mathematischer Probleme.

Alle Beispiele sind auf der beiliegenden CD enthalten und zu einer ansehnlichen Engine zusammengefügt. Einziger Wermutstropfen ist die ob der Komplexität des Themas nicht ganz ausreichende grafische Dokumentation der oft schwierigen geometrischen Zusammenhänge. Insgesamt jedoch ein Buch, das sich an den begeisterten 3-D-Spieleentwickler wendet, der, mit dem geeigneten Rüstzeug ausgestattet und des Englischen mächtig, hier für lange Zeit nicht an seine Grenzen stoßen wird. Alexander Lucas

Computer gaming is far and away the fastest growing segment of the entertainment industry and game software runs on more PCs than word processors or web browsers. With ever more capable hardware available, increasing levels of physical realism are now attainable by designers of interactive 3D graphics.

Game Engine Design is the first book to describe at a professional level the software design and implementation required for physically-based modelling in graphics. The author offers in-depth examination of the algorithms that allow developers to model game environments, illustrating these methods with actual source code implementations that readers can modify for their own purpose. This is a landmark book for programmers working in game and simulation design, interactive 3D graphics, and real-time 3D graphics engines.

Now considered an essential reference in the game industry, "3D Game Engine Design" is the first book to go beyond basic descriptions of algorithms and accurately demonstrate the complex engineering process required to design and build a real-time graphics engine to support physical realism. Faster algorithms will always win out over faster processors and assembly-language optimization techniques. Implementing those algorithms, however, can be a challenge for even experienced programmers. This book provides rigorous explanations and derivations of all the essential concepts and techniques. Ideas are revealed step by step with numerous code examples and illustrations. Source code implementations are included on the companion CD-ROM to help you understand the full progression from idea, to algorithm, to working code. Since algorithms are not used in isolation, the source code for a complete engine is provided to bring crucial context to the implementations. This book and CD-ROM offer the most comprehensive professional reference available for the development of 3D game engines.

Designed for professionals working in game development, simulation, scientific visualization, or virtual worlds, it is written by a respected game engineer and designer of a leading commercial game engine. It thoroughly describes the algorithmsfully implemented in working codethat are the key to writing the fastest, most efficient code possible. It provides source code for Windows 95/98/NT/2000, Linux/Unix, and Macintosh platforms.

Reasons for creating this book.
A decade ago I made a decision to become a ’retread’ by switching from a career as a mathematician to one as a computer scientist. I have always been attracted to the beauty of mathematics and the practicality of computer science, but found a need to demonstrate the usefulness of both in real applications. What better way to do this than in the field of computer graphics! Geometry, algebra, numerical analysis, analytical reasoning, algorithm development, object-oriented programming, hands-on experience with hardware, and more, all wrapped up into one field.

Part of the math-to-cs conversion included learning about the world wide web and news groups. In particular, I discovered comp.graphics.algorithms and found it a place I liked to camp out. Realizing that a lot of folks had a lot of questions about taking ideas and translating them into source code, I started my Magic Software web site (originally hosted by the Computer Science department at the University of North Carolina at Chapel Hill, but now its own separate entity) and made available free source code that solved basic problems in computer graphics, image analysis, and numerical methods.

With the arrival of inexpensive 3D graphics hardware for the PC, the questions in comp.graphics.algorithms quickly became focused on how to solve problems that arise in building components of a game or game engine. This fact and my hiring by Numerical Design Limited to work on a game engine naturally led to my focusing on 3D real-time graphics.

The ultimate conclusion of the journey I started a decade ago is this book. It has been two years in the making and contains a significant amount of source code that I believe simultaneously illustrates the simplicity and complexity of creating a real-time graphics engine. I hope you enjoy reading this book as much as I have enjoyed writing it.

Wer schon immer den heiligen Gral der 3-D-Computergrafik gesucht hat, wer schon immer wissen wollte, welche magischen Kräfte die so bunte Welt der Computerspiele im Innersten zusammenhalten, der wird hier seine Antwort finden. Ein zumindest angefangenes oder auch abgebrochenes Physik- bzw. Mathematikstudium sind dabei jedoch die Conditio sine qua non, um sich nicht in dem Labyrinth aus Formeln und Algorithmen zu verirren. Der akademische Hintergrund des Autors mit gleich zwei Ph.D.-Titeln in Informatik und Mathematik macht sich in der Stringenz und Klarheit deutlich bemerkbar und katapultiert das Buch auf ein selten hohes Niveau in diesem Genre.

Der Autor hat das Gebiet dabei so gründlich bearbeitet, dass das Buch eher als ein Referenzwerk zu betrachten ist, in dem man je nach Problemstellung stöbern kann und sicherlich fündig wird. Das Buch spannt dabei den Bogen von den grundlegenden geometrischen Problemstellungen wie Abstands- und Schnittpunktberechnungen und Bestimmung von Einhüllenden, die für das später erklärte Culling, Clipping und die Kollisionsabfrage wichtig sind, bis hin zu High-Level-Spezialeffekten wie Bump oder Environment Mapping, die allerdings etwas oberflächlicher gehalten sind.

Nach der überaus profunden Abhandlung der Grundlagen werden die Aspekte der Graphics Pipeline sowie des baumstrukturierten Szenemanagements untersucht und auch eine kompakte Abhandlung über parametrisierte Kurven und Oberflächen, die vor allem für die an Hauptspeicher armen aber leistungsstarken Spielkonsolen wichtig sind, präsentiert. Es schließen sich Themen wie Character Animation mit dem Problem der inversen Kinematik, die Reduktion des Detaillierungsgrades (LOD) bei weit entfernten Objekten und Landschaften und eine allgemeine Raumstrukturanalyse (BSP-Trees und Portals) an. Abgerundet wird das Ganze mit einigen hilfreichen Tipps und Tricks zur OOP und einer umfangreichen Formelsammlung für die Lösung häufig auftretender mathematischer Probleme.

Alle Beispiele sind auf der beiliegenden CD enthalten und zu einer ansehnlichen Engine zusammengefügt. Einziger Wermutstropfen ist die ob der Komplexität des Themas nicht ganz ausreichende grafische Dokumentation der oft schwierigen geometrischen Zusammenhänge. Insgesamt jedoch ein Buch, das sich an den begeisterten 3-D-Spieleentwickler wendet, der, mit dem geeigneten Rüstzeug ausgestattet und des Englischen mächtig, hier für lange Zeit nicht an seine Grenzen stoßen wird. --Alexander Lucas

Aimed at the working C++ game developer, 3D Game Engine Design provides a tour of mathematical techniques for 3-D graphics and the source code used to implement them in state-of-the-art video game engines. If you work in the game industry (or would like to), this book will serve you well because it delivers excellent best practices for algorithms and programming techniques that will help your software keep up with the competition.

This text is a virtual encyclopaedia of expertise, based on the author’s own work and research in the gaming industry. It provides the mathematical notation, algorithms, and C++ code (on the accompanying CD-ROM) needed to build fast and maintainable game engines. Early sections start with the basics, with the math used to work with common 3-D objects (like spheres and boxes). Highlights include a high-powered review of quaternion algebra, the preferred way to transform 3-D data in many cases.

The chapters on graphics pipelines explain the math behind representing and rendering a 3-D world in 2-D with intervening effects like lighting, texture mapping and the like. A variety of current algorithms are provided for representing 3-D scenes, efficient picking (which allows a programmer to determine which object in a 3-D world has been selected) and collision detection (where objects collide virtually). In the game software of today, curves--rather than individual triangles or polygons--are often used to represent 3-D objects. Algorithms that are used to turn curves into rendered surfaces are also provided.

Later sections look at current thinking about animation techniques for characters (including key frames, inverse kinematics and skinning--in which digital skin is fitted over digital bone to create more realistic-looking movement). How to represent terrain inside virtual worlds is also explained. The book closes with excellent material on cutting-edge special effects like lens flare and projected shadows, which can add an extra level of realism to a video game. An appendix examines guidelines for designing object-oriented game software in C++.

Filled with mathematical insight and expert code that puts each principle or algorithm to work, 3-D Game Engine Design provides an expert view of what goes into building a state-of-the-art game engine. --Richard Dragan

Now considered an essential reference in the game industry, 3D Game Engine Design is the first book to go beyond basic descriptions of algorithms and accurately demonstrate the complex engineering process required to design and build a real-time graphics engine to support physical realism. Faster algorithms will always win out over faster processors and assembly-language optimization techniques. Implementing those algorithms, however, can be a challenge for even experienced programmers. This book provides rigorous explanations and derivations of all the essential concepts and techniques. Ideas are revealed step by step with numerous code examples and illustrations. Source code implementations are included on the companion CD-ROM to help you understand the full progression from idea, to algorithm, to working code. Since algorithms are not used in isolation, the source code for a complete engine is provided to bring crucial context to the implementations. This book and CD-ROM offer the most comprehensive professional reference available for the development of 3D game engines.

About the software:
Includes a CD-ROM with C++ source code implementations of all the algorithms covered in the text as well as source code for a complete game engine.The renderer layer of the engine is abstract and can work with whichever API is desired. An OpenGL-based renderer, DirectX8 (Direct3D), and a GLUT-based hardware renderer for either Windows or Linux, are included.

*Designed for professionals working in game development, simulation, scientific visualization, or virtual worlds.
*Written by a respected game engineer and designer of a leading commercial game engine.
*Thoroughly describes the algorithms-fully implemented in working code-that are the key to writing the fastest, most efficient code possible.
*Provides source code for Windows 95/98/NT/2000, Linux/Unix, and Macintosh platforms.

Aimed at the working Visual C++ game developer, 3D Game Engine Design provides a tour of mathematical techniques for 3-D graphics, and the source code that’s used to implement them in state-of-the-art video game engines. If you work in the game industry (or would like to), this book will serve you well, because it delivers excellent best practices for algorithms and programming techniques that’ll help your software keep up with the competition.

This text is a virtual encyclopedia of expertise that’s based on the author’s own work and research in the gaming industry. It provides the mathematical notation, algorithms, and C++ code (on the accompanying CD-ROM) that are needed to build fast and maintainable game engines. Early sections start with the basics, with the math that’s used to work with common 3-D objects (like spheres and boxes). Highlights include a high-powered review of quaternion algebra--in many cases, the preferred way to transform 3-D data.

The chapters on graphics pipelines explain the math that’s behind representing and rendering a 3-D world in 2-D with intervening effects like lighting and texture mapping. A variety of current algorithms are provided for representing 3-D scenes, efficient picking (which allows a programmer to determine the object in a 3-D world that has been selected), and collision detection (in which objects collide virtually). In the game software of today, curves--and not individual triangles or polygons--often are used to represent 3-D objects. Algorithms that are used to turn curves into rendered surfaces are provided, too.

Later sections look at the current thinking about animation techniques for characters (including key frames, inverse kinematics, and skinning (in which digital skin is fitted over digital bone to create more realistic-looking movement)). How to represent terrain inside virtual worlds also is explained. The book closes with excellent material on such cutting-edge special effects as lens flare and projected shadows, which can add an extra level of realism to a video game. An appendix examines guidelines for designing object-oriented game software in C++.

Filled with mathematical insight and expert code that puts each principle or algorithm to work, 3D Game Engine Design provides an expert view of what goes into building a state-of-the-art game engine. --Richard Dragan

Topics covered:

• Mathematical methods and sample source code for 3-D game development
• Geometrical transformations
• Coordinate systems
• Quaternions
• Euler angles
• Standard 3-D objects: spheres, oriented boxes, capsules, lozenges, cylinders, ellipsoids
• Distance methods for a variety of shapes
• Introduction to the graphics pipeline
• Model and world coordinates
• Projecting perspective
• Camera models
• Culling techniques
• Surface and vertex attributes
• Rasterizing
• Efficiency issues for clipping and lighting
• Hierarchical scene representation, using trees and scene graphs
• Picking algorithms for a variety of 3-D shapes
• Collision detection for static and dynamic graphical objects
• Oriented bounding-box (OBB) trees
• Basics of curves and special curves (including Bezier curves and various splines)
• Curves (generating surfaces from curves by using different techniques)
• Character animation, using keyframe animation and inverse kinematics
• Skinning
• Geometrical level of detail considerations
• Techniques for generating game terrain
• Spatial sorting and binary space partitioning (BSP)
• Special effects: lens flare, bump mapping, volumetric fogging, projected light and shadows, particle systems, morphing techniques
• C++ language features for effective object-oriented design
• Reference to the numerical methods required for game mathematics

"Virtually all the books on building 3D game engines cover the basics: here’s a polygon, here’s a transformation matrix, here’s a perspective projection, and so on. The problem is that you can’t make a professional quality game with just the basics. This leaves a large gap between you and your goal of creating a great game engine. With this book, Dave is launching a huge boulder into the gap, helping you scamper to your destination."
Eric Yiskis, Lead Programmer, Oddworld Inhabitants
3D Game Engine Design is the first book to go beyond basic descriptions of algorithms and accurately demonstrate the complex engineering process required to design and build a real-time graphics engine to support physical realism. Faster algorithms will always win out over faster processors and assembly-language optimization techniques. Implementing those algorithms, however, can be a challenge for even experienced programmers.
This book provides rigorous explanations and derivations of all the essential concepts and techniques. Ideas are revealed step by step with numerous code examples and illustrations. Source code implementations are included on the companion CD-ROM to help you understand the full progression from idea, to algorithm, to working code. Since algorithms are not used in isolation, the source code for a complete engine is provided to bring crucial context to the implementations. This book and CD-ROM offer the most comprehensive professional reference available for the development of 3D game engines.
Features:
* Designed for professionals working in game development, simulation, scientific visualization, or virtual worlds
* Written by a respected game engineer and designer of a leading commercial game engine
* Thoroughly describes the algorithms-fully implemented in working code-that are the key to writing the fastest, most efficient code possible
* Provides source code for Windows 95/98/NT/2000, Linux/Unix, and Macintosh platforms.
About the software:
Includes a CD-ROM with C++ source code implementations of all the algorithms covered in the text as well as source code for a complete game engine. Updates for the engine, new ports (such as for the Macintosh), FAQs, and additional material on real-time graphics can be found at Geometric Tools website http://www.geometrictools.com. The renderer layer of the engine is abstract and can work with whichever API is desired. An OpenGL-based renderer, DirectX8 (Direct3D), and a GLUT-based hardware renderer for either Windows or Linux are included.

Aimed at the working Visual C++ game developer, 3D Game Engine Design provides a tour of mathematical techniques for 3-D graphics, and the source code that’s used to implement them in state-of-the-art video game engines. If you work in the game industry (or would like to), this book will serve you well, because it delivers excellent best practices for algorithms and programming techniques that’ll help your software keep up with the competition.

This text is a virtual encyclopedia of expertise that’s based on the author’s own work and research in the gaming industry. It provides the mathematical notation, algorithms, and C++ code (on the accompanying CD-ROM) that are needed to build fast and maintainable game engines. Early sections start with the basics, with the math that’s used to work with common 3-D objects (like spheres and boxes). Highlights include a high-powered review of quaternion algebra--in many cases, the preferred way to transform 3-D data.

The chapters on graphics pipelines explain the math that’s behind representing and rendering a 3-D world in 2-D with intervening effects like lighting and texture mapping. A variety of current algorithms are provided for representing 3-D scenes, efficient picking (which allows a programmer to determine the object in a 3-D world that has been selected), and collision detection (in which objects collide virtually). In the game software of today, curves--and not individual triangles or polygons--often are used to represent 3-D objects. Algorithms that are used to turn curves into rendered surfaces are provided, too.

Later sections look at the current thinking about animation techniques for characters (including key frames, inverse kinematics, and skinning (in which digital skin is fitted over digital bone to create more realistic-looking movement)). How to represent terrain inside virtual worlds also is explained. The book closes with excellent material on such cutting-edge special effects as lens flare and projected shadows, which can add an extra level of realism to a video game. An appendix examines guidelines for designing object-oriented game software in C++.

Filled with mathematical insight and expert code that puts each principle or algorithm to work, 3D Game Engine Design provides an expert view of what goes into building a state-of-the-art game engine. --Richard Dragan

Topics covered:

• Mathematical methods and sample source code for 3-D game development
• Geometrical transformations
• Coordinate systems
• Quaternions
• Euler angles
• Standard 3-D objects: spheres, oriented boxes, capsules, lozenges, cylinders, ellipsoids
• Distance methods for a variety of shapes
• Introduction to the graphics pipeline
• Model and world coordinates
• Projecting perspective
• Camera models
• Culling techniques
• Surface and vertex attributes
• Rasterizing
• Efficiency issues for clipping and lighting
• Hierarchical scene representation, using trees and scene graphs
• Picking algorithms for a variety of 3-D shapes
• Collision detection for static and dynamic graphical objects
• Oriented bounding-box (OBB) trees
• Basics of curves and special curves (including Bezier curves and various splines)
• Curves (generating surfaces from curves by using different techniques)
• Character animation, using keyframe animation and inverse kinematics
• Skinning
• Geometrical level of detail considerations
• Techniques for generating game terrain
• Spatial sorting and binary space partitioning (BSP)
• Special effects: lens flare, bump mapping, volumetric fogging, projected light and shadows, particle systems, morphing techniques
• C++ language features for effective object-oriented design
• Reference to the numerical methods required for game mathematics

Now considered an essential reference in the game industry, 3D Game Engine Design is the first book to go beyond basic descriptions of algorithms and accurately demonstrate the complex engineering process required to design and build a real-time graphics engine to support physical realism. Faster algorithms will always win out over faster processors and assembly-language optimization techniques. Implementing those algorithms, however, can be a challenge for even experienced programmers.
This book provides rigorous explanations and derivations of all the essential concepts and techniques. Ideas are revealed step by step with numerous code examples and illustrations. Source code implementations are included on the companion CD-ROM to help you understand the full progression from idea, to algorithm, to working code. Since algorithms are not used in isolation, the source code for a complete engine is provided to bring crucial context to the implementations. This book and CD-ROM offer the most comprehensive professional reference available for the development of 3D game engines.

*Designed for professionals working in game development, simulation, scientific visualization, or virtual worlds.
*Written by a respected game engineer and designer of a leading commercial game engine.
*Thoroughly describes the algorithmsfully implemented in working codethat are the key to writing the fastest, most efficient code possible.
*Provides source code for Windows 95/98/NT/2000, Linux/Unix, and Macintosh platforms.

Ein Wälzer voller wunderbarer Algebra!

Ich muss schon sagen, dass ich etwas von der "Art" des Buches erschlagen wurde, als ich nach dem Auspacken zu Blättern anfing. Allerdings hatte ich es auf Anraten einiger kompetenter Personen bestellt, die ich nach einem Werk mit viel mathematischem Inhalt gefragt hatte. Demnach entspricht und entsprach dieses Buch genau meinen Vorstellungen.
Es ist aufgrund des hochmathematischen Stils etwas schwer lesbar und man braucht manchmal ein paar Anläufe um sich zurechtzufinden. Aber meiner Meinung nach ist es auch kein Werk zum "Lesen", sondern mehr zum Nachschlagen wenn man sich neue Anregungen für seinen Code holen will. Und Anregungen durch dieses Buch sind garantiert!
Man sollte sich allerdings auf dem Gebiet schon etwas auskennen. Für Neulinge im Bereich Programmieren und Mathematik ist das Buch definitiv nicht geeignet. Dort ist dringend zur Einsteigerliteratur zu raten, als sich in einem Formelberg zu verlieren, der einem auch sehr schnell den Spass verderben kann (wenn einem das nötige Hintergrundwissen fehlt).
Dennoch volle Punktzahl von mir.

Must have fuer 3D game engine developer

Der Titel trifft absolut zu. Jeder, der eine 3D game engine designen will, stoesst zwangslaeufig ueber alle Punkte, die in dem Buch beschrieben sind_ Geometrische Methoden, die Graphics Pipeline, Scene Graph Management, Picking, Collision Detection, Curves and Surfaces, Animation, Geometric Level of Detail, Terrain, Spatial Sorting (BSP, etc), Special Effects (lens flares, etc). Das Buch ist von einem Mathematiker geschrieben, Dave Eberly haelt Ph.Ds in Mathematik und Computer Science. Aber ich mag lieber Buecher die detailiert und genau sind, als schwammige Buecher, die die interessanten Teile uebergehen. Man kommt sowieso nicht an der Mathematik vorbei, wenn man 3D programmieren will. Fazit: absolute Kaufempfehlung fuer 3D game engine designer.

Must have for 3D engine developers

Der Titel trifft absolut zu: wer eine game engine designen will, stoesst zwangslaeufig ueber alle Punkte, die in dem Buch beschrieben sind_ Geometrische Methoden, die Graphics Pipeline, Scene Graph Management, Picking, Collision detection, Curves and Surfaces, Animation, Geometric Level of Detail, Terrain, Spatial Sorting (BSP etc), Special Effects (lens flares, etc). Das Buch ist mathematisch anspruchsvoll, Dave Eberly haelt Ph.D’s in Mathematik und Computer Science. Andererseits geht’s in der Computergraphik nicht ohne Maths, und lieber detailiert und vollstaendig als schwammig und unbrauchbar. Fazit: Das Buch ist absolut zu empfehlen und ein must have fuer 3D engine developers.

3D-Grafik auf hohem Niveau

Dave Eberly’s Buch beschreibt die Anwendung von Techniken der 3D-Grafik auf einem völlig anderen Niveau als andere Autoren. Das Thema ist nicht die Theorie der 3D-Grafik sondern das, was man damit machen kann. Sein Buch ist eine wahre Fundgrube für Algorithmen, die eigentlich fast alle 3D-Applikationen irgendwann benötigen. Hier habe ich zum ersten Mal das Thema "Szenengraf", den es ja in jeder 3D-Anwendung gibt, fachlich erläutert gesehen. Auch auf programmiertechnische Details geht der Autor ein und gibt nützliche Ratschläge, wie man objektorientiert und trotzdem effizient programmiert - auch für andere Anwendungen nützlich. Das Buch ist logisch aufgebaut und gut strukturiert. Gut gefällt mir auch die Zusammenstellung der verwendeten mathematischen Zeichen im Deckel, die vielleicht auch die Leute abschreckt, die nur ein Buch mit bunten Bildchen suchen. Des Weiteren ist positiv, dass der Autor auf seiner Webpage Errata und aktuellen Code seiner Engine anbietet.

Absolut nützlich

Also die Qualität des Buches wird dem recht hohen Preis absolut gerecht. Die Methoden und Funktionen die vom Autor behandelt werden, sind in der Praxis des Game Developing gängig und ersparen einem somit viel theoretische Vorarbeit. Die beigelegten Sourcecodes auf CD sind gut strukturiert und in sauberem C++ geschrieben. Leider ist die Nutzung einiger effizienter Algorithmen als ’restricted’ eingestuft.

Zusammenfassend ist dieses Buch für jeden seriösen 3D Programmierer eine absolute Bereicherung. Anfänger in 3D oder C++ sollten sich vor diesem Buch einleitende Lektüre besorgen!

A thorough book suitable for those undaunted of math

I expected a book that would discuss game engine design in a fairly straight-forward manner. A book that started off with a discussion of the basic principles, and then moved on to the complex details would have been easier to follow.

This book was not initially what I expected, due to the fact that it is very math-oriented. Within minutes of starting the book I was faced with mathematical proofs.

However, the book is very thorough, and covers a diverse range of topics. Included with the book is the WildMagic engine, which is an implementation of the material discussed in the book.

I would recommend it as a reference for somebody who is already familiar with game development, and who is not daunted by fairly complex math. I would caution beginners wanting to learn about game engine design to stay away.

Everything you need, and then some

This book gives you an excellent foundation upon which you can begin building a game engine. It covers all of the essentials (matrix algebra through artificial intelligence) wonderfully. It isn’t so much a cookbook that will show you, step-by-step how to build a game engine, it gives you all of the tools to do so though.

Poor pseudo-code

This book is fantastically comprehensive, though I bought it more for the CG algorithms than anything else.

My biggest gripe is with the pseudo-code. My C++ is not great, but I can get by - I found the code in general under-commented for a textbook. If you were writing software, it might be fine, but the purpose of the code is to explain the algorithms, and to work in concert with the text, which it does not. Furthermore, I found the text did not fill in the holes - I was left to try to figure out what Eberley was doing by going through the code. Possibly if I had read the whole thing through from cover to cover things would be clearer.

If you’re just looking for an algorithm reference, you could do better.

VERY VERY HIGHLY RECOMMENDED!!

Are you a professional or student working in game development? If you are, then this book is for you. Author David H. Eberly has done an outstanding job of writing a second edition of a book which focuses on the design of the scene graph management system and its associated rendering layer.

Eberly, begins this book by discussing the details of a rendering system, including transformations, camera models, culling and clipping, rastering, and issues regarding software versus hardware rendering and about specific graphics application programmer interfaces in use these days. In addition, the author discusses rendering from the perspective of actually writing all of the subsystems for a software renderer. He also takes a look at the essentials of organizing your data as a scene graph. Then, he focuses on specifically designed nodes and subsystems of the scene graph management system. The author then looks at some general concepts you see in attempting to have physical realism in a three-dimensional application. Next, he discusses a lot of mathematical detail for much of the source code you will find in Wild Magic. Then, he takes a brief look at the basic principles of object-oriented design and programming. The author continues by discussing memory management. Finally, he takes a look at a handful of sample shaders and the applications that use them.

This most excellent book is very much enhanced, describing the foundations for shader programming and how an engine can support it. Perhaps more importantly, the book is the most comprehensive reference available for the development of shader-based 3D graphics engines!

This book is not about "Game Engine Design"

This book is not about "Game Engine Design" -- it’s about algorithms that you may come across when writing a 3D game engine. There’s very little treatment of "engine design" in this book.

Even though the title is misleading, it’s still a great book if you’re looking for a reference on 3D game engine algorithms.

High caliber book (if you can follow the math)

I’m pretty good about leaving honest reviews of gaming books, giving 1 star to books with Andre LaMothe even being mentioned, giving 1 star to books written about how cool the author’s engine is over yours, giving 1 star to people with overinflated egos that need petted (which, btw, you will bump into more than once in the field of gaming since it has that "wow"-afying effect that attracts the people who need their egos polished, *cough* LaMothe *cough*).

This book is none of that. Upon opening the first pages, you can immediately tell this book is an entire course work full of information that is all very relevent to game engine design. The author does an extradionaire job to explain the concepts, not just how he did it (which won’t leave you with that annoying "now all praise for me I am super l337 gAm3 c0d3r" feeling like certain other books tend to do).

This book is a very well written book on anything even remotely close to game engine design. The level of conceptual detail is amazing, but it is quite math heavy (so beware if you aren’t good with math to begin with), but given that the process of game engine design is inheriently math heavy, there is no point in bashing this book too hard since, lets face it, if you can’t do the math you won’t get very far with making a 3d engine.

The thing I like about the book is that many differet functions, formulas, and concepts that are relavent to building a functioning 3d game are presented in some form or another in this book. It talks and feels like a CS book, and thats good sinec thats what most CS people feel comfortable with.

However, let me make sure that people realize, you need to be at least comfortable with C++ in order to get anything from this book. I would recommend at least up to a level of CS III (or equivalent) college course at the minimum (maybe less if you know C++). Also, an understanding of Linear Algebra is extremely helpful in game design, but thats hard to say since Linear Algebra is an upper level math course that most people will have to be in college before even having the opportunity to take (no offense to you youngins, but you might have to wait a few years before you understand whats going on).

There is another review on here that says that this book doesn’t cover networking or some of those other things, but still doesn’t make this book any less worthwhile.

Overall though, there are a few sections that I wish the author would have expanded on (especially the appendix 2 stuff - was some really good C++ problems I’ve bumped into myself). The next edition should be a definite winner, but for the time being I am very pleased with this book - highly recommended.

JW

Very math heavy, but still good

Reviewing this post I cannot change the rating, otherwise I would give it a 4 star rating.

This book contains many different functions, formulas, and concepts that are relavent to building a functioning 3d game. On the down side, it talks and feels like a math book, not so much a computer science book. That is fine since game engine design is inheritly math heavy, but also very bad because math formulas and derivations are fine, but *ONLY* with accompanying explanations written in plain english (which are lacking in several areas).

For example, trying to explain what formula is used to indicate what array index one would use to grab a quad tree in a quad tree array (as opposed to a linked list/tree structure), he starts off with writing "Given a..." - you can tell within the first two words, no, this is not how to explain what you’re doing. Something more along the lines of "To determine the index offset...", much better.

The chapter that I especially dislike is the terrain rendering chapter. I have yet to make up my mind what algorithm he is using (I think ROAM?), but the explanation in the book takes off at tangent pace from the start and leaves you wondering what he is getting at. Obviously, we’re going to render terrain, but the methodolgy of the deliverance of the information is simply... lets say for sake of argument, unfollowable. It is like a mad scientist wrote it.

One thing I definately liked was that he presents a lot of pseudo code for MANY of the problems he covers. This was exceptionally helpful, and fairly well done. More comments would be even better, but still as it stands is not bad.

However, let me make sure that people realize, you need to be at least comfortable with math AND programming in order to get anything from this book. I would recommend at least up to a level of CS III (or equivalent) college course at the minimum (maybe less if you know C++). Also, an understanding of Linear Algebra is extremely helpful.

There is another review on here that says that this book doesn’t cover networking or some of those other things, but I don’t feel that it makes this book any less worthwhile. Although, yes, it would be better if it did contain a networking chapter.

Overall though, there are a few sections that I wish the author would have expanded on (especially the appendix 2 stuff - was some really good C++ problems I’ve bumped into myself). The next edition should be an improvement, but for the time being I am fairly pleased with this book. Not neccessarily high on my recommendation list, but good enough to get information out of.

Eberly has a follow-up book entitled "Game Engine Architecture" where he goes on an overview of his Wild Magic engine. Fairly good book as well, a lot less math happy too (he even makes mention of the number one complaint of this book being its math heaviness).

JW

Very math heavy, but still good

Reviewing this post I cannot change the rating, otherwise I would give it a 4 star rating.

This book contains many different functions, formulas, and concepts that are relavent to building a functioning 3d game. On the down side, it talks and feels like a math book, not so much a computer science book. That is fine since game engine design is inheritly math heavy, but also very bad because math formulas and derivations are fine, but *ONLY* with accompanying explanations written in plain english (which are lacking in several areas).

For example, trying to explain what formula is used to indicate what array index one would use to grab a quad tree in a quad tree array (as opposed to a linked list/tree structure), he starts off with writing "Given a..." - you can tell within the first two words, no, this is not how to explain what you’re doing. Something more along the lines of "To determine the index offset...", much better.

The chapter that I especially dislike is the terrain rendering chapter. I have yet to make up my mind what algorithm he is using (I think ROAM?), but the explanation in the book takes off at tangent pace from the start and leaves you wondering what he is getting at. Obviously, we’re going to render terrain, but the methodolgy of the deliverance of the information is simply... lets say for sake of argument, unfollowable. It is like a mad scientist wrote it.

One thing I definately liked was that he presents a lot of pseudo code for MANY of the problems he covers. This was exceptionally helpful, and fairly well done. More comments would be even better, but still as it stands is not bad.

However, let me make sure that people realize, you need to be at least comfortable with math AND programming in order to get anything from this book. I would recommend at least up to a level of CS III (or equivalent) college course at the minimum (maybe less if you know C++). Also, an understanding of Linear Algebra is extremely helpful.

There is another review on here that says that this book doesn’t cover networking or some of those other things, but I don’t feel that it makes this book any less worthwhile. Although, yes, it would be better if it did contain a networking chapter.

Overall though, there are a few sections that I wish the author would have expanded on (especially the appendix 2 stuff - was some really good C++ problems I’ve bumped into myself). The next edition should be an improvement, but for the time being I am fairly pleased with this book. Not neccessarily high on my recommendation list, but good enough to get information out of.

Eberly has a follow-up book entitled "Game Engine Architecture" where he goes on an overview of his Wild Magic engine. Fairly good book as well, a lot less math happy too (he even makes mention of the number one complaint of this book being its math heaviness).

JW

Good, but not what you might expect

I read this a few years ago, and have referred back to it many times, but I only recently realized that I neglected to write a review of it.

This book is well-written and contains a lot of useful information. The author is one of the few people qualified to write a book of this nature, and he has done an admirable job. That said, the title is pretty misleading, since the book has very little to say about the design of a game engine. Instead, it focuses on implementation details and the math involved with them. Topics covered include geometrical methods, the graphics pipeline, tree-based scene graphics, intersections, collision detection, curves and surfaces, animation, terrain, spatial sorting (quad/octrees, portals, BSPs), special effects, object-oriented infrastructure, and numerical methods. The author doesn’t gloss over anything, providing detailed mathematical derivations of how things work.

Unfortunately, the math is so heavy that unless you’re already pretty familiar with the subject matter, you’ll probably have a hard time with the book. Therefore, I think that the target audience is much smaller that the group that would be attracted by the title.

If you’re involved in game engine development or just want to deepen your knowledge, I think you’ll appreciate the fact that the author doesn’t pull any punches. Otherwise, you’ll probably be more interested in the author’s new book 3D Game Engine Architecture, which was recently released.

Good, but not what you might expect

I read this a few years ago, and have referred back to it many times, but I only recently realized that I neglected to write a review of it.

This book is well-written and contains a lot of useful information. The author is one of the few people qualified to write a book of this nature, and he has done an admirable job. That said, the title is pretty misleading, since the book has very little to say about the design of a game engine. Instead, it focuses on implementation details and the math involved with them. Topics covered include geometrical methods, the graphics pipeline, tree-based scene graphics, intersections, collision detection, curves and surfaces, animation, terrain, spatial sorting (quad/octrees, portals, BSPs), special effects, object-oriented infrastructure, and numerical methods. The author doesn’t gloss over anything, providing detailed mathematical derivations of how things work.

Unfortunately, the math is so heavy that unless you’re already pretty familiar with the subject matter, you’ll probably have a hard time with the book. Therefore, I think that the target audience is much smaller that the group that would be attracted by the title.

If you’re involved in game engine development or just want to deepen your knowledge, I think you’ll appreciate the fact that the author doesn’t pull any punches. Otherwise, you’ll probably be more interested in the author’s new book 3D Game Engine Architecture, which was recently released.

Book Review

I have spent the past four years studying game development and have read many books on the subject. The technologies utilized in game development are extensive but most can be grouped into a small list, which is rendering, animation, modeling, collision detection, collision response, artificial intelligence, audio processing, input management and network communication. This book only contains technologies related to rendering, animation, and collision detection.

Eberly gives an in-depth look to game development and provides adequate solutions to every problem introduced. He does not cover every possible way each problem could be solved nor does he spend a lot of time introducing and defining each problem. Instead he assumes the reader has a general understanding of the problem and gives a quick review followed by one or two detailed solutions using the most common techniques. Eberly’s writing style makes it easy to follow the accumulation of segments to the final solution. His math notation on the other hand was confusing at times. A few places he supplemented words with mathematical notation and allowed the math to do the explaining, which made it seem like he was unable to put it into words.

I have found this book to be very useful and have added it to my reference library of game development, but I would not recommend this book to someone just starting to study game development. For a reader to glean anything of use out of this book he would have to be experienced in object oriented programming, have a basic understanding of 3D rendering technologies and have a working knowledge of calculus and linear algebra.

Book Review

I have spent the past four years studying game development and have read many books on the subject. The technologies utilized in game development are extensive but most can be grouped into a small list, which is rendering, animation, modeling, collision detection, collision response, artificial intelligence, audio processing, input management and network communication. This book only contains technologies related to rendering, animation, and collision detection.

Eberly gives an in-depth look to game development and provides adequate solutions to every problem introduced. He does not cover every possible way each problem could be solved nor does he spend a lot of time introducing and defining each problem. Instead he assumes the reader has a general understanding of the problem and gives a quick review followed by one or two detailed solutions using the most common techniques. Eberly’s writing style makes it easy to follow the accumulation of segments to the final solution. His math notation on the other hand was confusing at times. A few places he supplemented words with mathematical notation and allowed the math to do the explaining, which made it seem like he was unable to put it into words.

I have found this book to be very useful and have added it to my reference library of game development, but I would not recommend this book to someone just starting to study game development. For a reader to glean anything of use out of this book he would have to be experienced in object oriented programming, have a basic understanding of 3D rendering technologies and have a working knowledge of calculus and linear algebra.

Not for the faint of heart

Let there be no doubt that Mr. Eberly is an expert on the subjects presented in this book. Unfortunately - and it pains me to make this statement - he is a terrible instructor. After spending countless hours studying the text and the accompanying source code, I have regrettably come to the conclusion that he is more interested in showcasing his knowledge than actually explaining the material.

It is imperative for a programmer interested in this book to realize that it demands an extreme familiarity with linear algebra. Even the most basic fundamentals of 3D programming are explained in strict mathematical notation. When looking at an equation, if you are unable to immediately visualize the C/C++ representation you are in for a long, difficult read and an even longer integration process.

There is, however, a great deal of value in the abstract theory section of the book. I do not feel, however, that those sections alone are worth the cover price.

Because of the wealth of information contained in both the text and source code, I can’t in good conscience give this book a bad review. Unfortunately, this is no casual read. Personally, I believe that the level of education one needs to fully utilize the information presented contradicts the need for this book entirely.

Not for the faint of heart

Let there be no doubt that Mr. Eberly is an expert on the subjects presented in this book. Unfortunately - and it pains me to make this statement - he is a terrible instructor. After spending countless hours studying the text and the accompanying source code, I have regrettably come to the conclusion that he is more interested in showcasing his knowledge than actually explaining the material.

It is imperative for a programmer interested in this book to realize that it demands an extreme familiarity with linear algebra. Even the most basic fundamentals of 3D programming are explained in strict mathematical notation. When looking at an equation, if you are unable to immediately visualize the C/C++ representation you are in for a long, difficult read and an even longer integration process.

There is, however, a great deal of value in the abstract theory section of the book. I do not feel, however, that those sections alone are worth the cover price.

Because of the wealth of information contained in both the text and source code, I can’t in good conscience give this book a bad review. Unfortunately, this is no casual read. Personally, I believe that the level of education one needs to fully utilize the information presented contradicts the need for this book entirely.

Full of math, gives strong basis. NOT for beginners

Gives the mathematics that build a 3d graphics engine. Some chapters could have gone deeper (like animation), others are really good (curves and terrain generation). But if you are looking for a book that will build your application from vertices to AI, that’s not the book you need. For example, 3d collision detection focuses on the mathematics to find where and when a box intersects, let’s say, a lozenge but not on organizing the CD procedures.
But definitely a must have if you want to get deeper in CG and game programming.

Full of math, gives strong basis. NOT for beginners

Gives the mathematics that build a 3d graphics engine. Some chapters could have gone deeper (like animation), others are really good (curves and terrain generation). But if you are looking for a book that will build your application from vertices to AI, that’s not the book you need. For example, 3d collision detection focuses on the mathematics to find where and when a box intersects, let’s say, a lozenge but not on organizing the CD procedures.
But definitely a must have if you want to get deeper in CG and game programming.