Jetzt eintauschen
und EUR 3,32 Gutschein erhalten
Eintausch
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Tricks of the 3D Game Programming Gurus, w. CD-ROM: Advanced 3D Graphics and Rasterization (Other Sams) [Englisch] [Taschenbuch]

Andre LaMothe
4.3 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)

Erhältlich bei diesen Anbietern.



Kurzbeschreibung

28. Februar 2003 Other Sams
The most advanced coverage of 3D game programming that teaches real 3D engine building to the intermediate to advanced game programmer. *Win32 Programming and DirectX Foundation 7.0 as well as Advanced Mathematics Including Quaternions. *2D and 3D Graphics and Algorithms and 3D Projections and Camera Manipulation. *Wireframe and Solid Rendering and Lighting and Texture Mapping. *Advanced Visibility Algorithms as well as 3D Animation Techniques. Today is the greatest time in history to be in the game business. We now have the technology to create games that look real! Sony's Playstation II, XBOX, and Game Cube are cool! But, all this technology isn't easy or trivial to understand it takes really hard work and lots of Red Bull. The difficulty level of game programming has definitely been cranked up these days in relation to the skill set needed to make games. Andre LaMothe's follow-up book to Tricks of the Windows Game Programming Gurus is the one to read for the latest in 3D game programming. When readers are finished with this book, they will be able to create a full 3D, texture-mapped, lit video game for the PC with a software rasterizer they can write themselves.Moreover, they will understand the underlying principles of 3D graphics and be able to better understand and utilize 3D hardware today and in the future. Andre LaMothe is the world's best-selling game programming author. His titles include the original work that started it: Tricks of the Windows Game Programming Gurus. He has been programming for over 24 years and holds degrees in mathematics, computer science, and electrical engineering. LaMothe is not only a successful author, but a successful businessman as well. His gaming network, Xtreme Games LLC, spans 269 companies and claims the title of worlds largest virtual game company.

Produktinformation

  • Taschenbuch: 1728 Seiten
  • Verlag: Sams; Auflage: Pap/Cdr (28. Februar 2003)
  • Sprache: Englisch
  • ISBN-10: 0672318350
  • ISBN-13: 978-0672318351
  • Größe und/oder Gewicht: 23,1 x 19,3 x 7,9 cm
  • Durchschnittliche Kundenbewertung: 4.3 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 188.607 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Amazon.de

To be an ordinary programmer is one thing: You need only learn how to interact with the computer on its own terms, creating buttons and combo boxes that have no significance away from the screen. To be a game programmer--particularly one that writes games with environments that appear three-dimensional to their players--is something else entirely. Such work requires that the flat screen simulate the real world, complete with light, shading, texture, gravity, and momentum. It's all quite complicated. Tricks of the 3D Game Programming Gurus helps its readers make great progress in creating 3D worlds and the action that goes on in them.

That this large, dense book manages to explain how to design and implement a 3D game while neither glossing over too many details nor swamping the reader with trivia is a credit to author André LaMothe. He opens by showing (and explaining) the C++ source code of a simple but full-fledged 3D spaceflight shooter game--a real boost to the reader's confidence. From there, he explains the complicated geometric concepts and mathematics that underlie realistic games (always with an eye toward software algorithms) and shows how to use the many APIs and libraries (including Microsoft DirectX 9.0) that make the world-builder's job easier. Make no mistake: Designing and building convincing games with 3D visuals and behaviors that convincingly approximate real-world physics is hard work. In this book, LaMothe helps you get it done and enjoy the process. --David Wall

Topics covered: How to design and build 3D worlds and the goings-on within them. Aside from mathematics and geometry, this book focuses on wireframe models, shading, rendering, and animation. Microsoft DirectX 9.0 gets special attention.

Synopsis

The most advanced coverage of 3D game programming that teaches real 3D engine building to the intermediate to advanced game programmer. *Win32 Programming and DirectX Foundation 7.0 as well as Advanced Mathematics Including Quaternions. *2D and 3D Graphics and Algorithms and 3D Projections and Camera Manipulation. *Wireframe and Solid Rendering and Lighting and Texture Mapping. *Advanced Visibility Algorithms as well as 3D Animation Techniques. Today is the greatest time in history to be in the game business. We now have the technology to create games that look real! Sony's Playstation II, XBOX, and Game Cube are cool! But, all this technology isn't easy or trivial to understand it takes really hard work and lots of Red Bull. The difficulty level of game programming has definitely been cranked up these days in relation to the skill set needed to make games. Andre LaMothe's follow-up book to Tricks of the Windows Game Programming Gurus is the one to read for the latest in 3D game programming. When readers are finished with this book, they will be able to create a full 3D, texture-mapped, lit video game for the PC with a software rasterizer they can write themselves.Moreover, they will understand the underlying principles of 3D graphics and be able to better understand and utilize 3D hardware today and in the future.

Andre LaMothe is the world's best-selling game programming author. His titles include the original work that started it: Tricks of the Windows Game Programming Gurus. He has been programming for over 24 years and holds degrees in mathematics, computer science, and electrical engineering. LaMothe is not only a successful author, but a successful businessman as well. His gaming network, Xtreme Games LLC, spans 269 companies and claims the title of worlds largest virtual game company.


Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

4 Sterne
0
2 Sterne
0
1 Sterne
0
4.3 von 5 Sternen
4.3 von 5 Sternen
Die hilfreichsten Kundenrezensionen
4 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Top Buch 4. Oktober 2005
Von Ein Kunde
Format:Taschenbuch
Ich schreibe diese Rezension eigentlich nur, da ich mit der Durchschnittsbewertung von 3 Sternen (da nur eine Bewertung) nicht einverstanden bin.
Andre LaMothe beschreibt in diesem Buch die grundlegenden Techniken, um ein 3D-Spiel der Generation Quake+ zu schreiben. Er benutzt dazu KEINE 3D-API wie Direct3D oder OpenGL, sondern schreibt alles selbst von Hand (in C). Man muss also dazu sagen, dass man den Code quasi zum Großteil wegschmeißen kann. Er dient einzig und allein dem tieferen Verständnis (mit LaMothes Worten: Eine API-Funktion kann jeder aufrufen).
Hat man sich durch diesen Wälzers durchgekämpft, ist man in der Lage einen eigenen Software Renderer zu schreiben (man muss lediglich Zugriff auf die Pixel des Bildschirms haben) und hat viele der grundlegenden Techniken heutiger 3D-Engines verstanden.
Weiterführende Techniken, welche z.B. Hardwarebeschleunigung voraussetzen, wird man in diesem Buch jedoch nicht finden.
Dafür reichen selbst 1600 Seiten nicht aus.
Für ein besseres Verständnis welche Arbeit einem durch heutige Grafikkarten und entsprechende APIs eigentlich abgenommen wird und wie man alles von Hand programmieren könnte ist dieses Buch jedoch allemal gut, zumal es sehr unterhaltsam geschrieben ist.
Fazit: Cooles Buch von einem coolen Autor.
Man kann das erworbene Wissen zwar meistens nicht direkt anwenden, durch das tiefere Verständnis der dahinter liegenden Techniken fällt es allerdings leicht sich weiterführende Themen anzueignen oder den Umgang mit einer Bibliothek zu erlernen.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Exzellentes Buch!! 5. Oktober 2006
Format:Taschenbuch
Dass der Autor wirklich Ahnung hat von dem, was er da schreibt, wird schon nach kurzer Zeit des Lesens deutlich.

Es wird alles besprochen, was zum Schreiben einer eigenen 3D-Engine nötig ist, dass heißt man bedient sich keiner API, die für einen die Projektion/Shading/usw. übernimmt, sondern implementiert diese Funktionen per Hand, mit dem Ziel eine 3D-Engine wirklich zu verstehen, anstatt blind irgendwelche API-Funktionen aufzurufen.

Zitat: "[...]this book is NOT going to teach you how to use 3D APIs like Direct3D or OpenGL - they are cool, but if you really want to understand 3D, you need to understand how to write Direct3D or OpenGL yourself-and that's what I'm after" (S.494)

ABER: DirectX wird benutzt, um schnellen Zugriff auf die Grafikkarte zu bekommen. Die Mathematik und Grafik wird NICHT DirectX überlassen, sondern den im Buch entwickelten Funktionen und Algorithmen.

UND: Die erstellten Funktionen werden in Bibliotheken hinterlegt, sodass man sie komfortabler nutzen kann. Dabei werden die (Sound-/Input-/2D-Grafik-)Bibliotheken aus dem ersten Buch ("Tricks of the Windows Game Programming Gurus. Fundamentals of 2d and 3d Game Programming.") verwendet, aber ausführlich besprochen, sodass man damit klar kommt, auch wenn man Buch Nummer Eins nicht gelesen hat.

Positiv:

- lockerer, cooler Schreibstil

- Vermittlung von Spezialwissen ( Bsp.: Kleine Einführung in FPU-Inline-Assembler-Programmierung für schnelle Fließkommazahloperationen und Code-Optimierung )

- Sehr hohes Lehrpotential(!!
Lesen Sie weiter... ›
War diese Rezension für Sie hilfreich?
5 von 11 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen die neue Referenz - 27. Juli 2003
Von Ein Kunde
Format:Taschenbuch
Ich habe das Vorgängerbuch "The Tricks of the Windows Game Programming" auch gelesen und fand es sehr gut. An dem hervorragenden und gut verständlichen Schreibstil des Autors hat sich gottseidank nichts geändert. Das einzig ärgerliche ist, das die Engine aus Buch 1 wiederbelebt und "nur" um 3D Features angereichert wird.
Ein ausführliches Mathe/Geometrie Kapitel schafft die Grundlagen für die nun folgenden Kapitel. Das Level ist hierbei zwar fordernd, aber für Kollegstufler (>=12 Klasse) oder für jeden der sich mit Matrizen und Vektoren beschäftigt hat bewältigbar.
Zwar basieren die basis-Funktionen auf DirectX, dass Buch erklärt die 3D Grundlagen wie Texturing, Mip-Mapping, Lighting, Culling, etc. jedoch so, das im Buche ein eigener (!) Software-Renderer/Rastersizer entwickelt wird. Die Engine kann somit sehr leicht auf konkrete 3D-APIs wie OpenGL/DirectX anwenden.
Sehr gut ist auch das Kapitel über Indoor/Outdoor Engines. BSP-Trees und Octrees werden sehr ausführlich behandelt, auch auf Portal-Engines wird eingegangen.
Zusammenfassend:
Alle aktuellen Tehmen zur 3D Spieleprogrammierung werden behandelt. Gut wäre es gewesen, vorhandene Implementation des DirectX-SDKs zu benutzen, jedoch ist dies nicht der Focus des Buches, da der Leser selbst lernen soll wie er vorhandene Grafikschmankerl einer Engine entwickelt.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.5 von 5 Sternen  73 Rezensionen
25 von 25 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Author Comments 25. Juli 2003
Von necron - Veröffentlicht auf Amazon.com
Format:Taschenbuch
I want to make it clear to all that are potentially buying this book. Tricks II is about SOFTWARE algorithms and rasterization. There is NO coverage of Direct3D, OpenGL, etc. If you're interested in learning about APIs then this is the wrong place. If you're interested in learning about HOW TO DO IT from plotting a pixel to Quake II technology then this book will show the way. I can say that there is nothing like this on the market, and probably never will be. The amount of time needed to illustrate multiple 3D engines, and technologies, build the demos, and try and make it fun, and engaging is simply too time consuming. I wrote this book for myself, when I was learning 3D graphics all I had was the BIBLE "Computer Graphics - Principles and Practice" which is fantastic, but lacks implementation, and practical examples. Thus, my goal for Tricks II was to re-create the algorithmic and mathematical vigor of Principles, but with a more grounded, and practical approach with real-time considerations. I personally guarantee you won't be dissapointed, the demos are very cool, and good starting points for a number of games types from; space, indoor, water, road, and fighting -- But, once again, if you want to learn boring APIs and not understand the fundamentals of 3D graphics, then don't look here! :)
Andre'
13 von 13 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A Must-Have for 3D Game Programmers 16. Juli 2003
Von mittens - Veröffentlicht auf Amazon.com
Format:Taschenbuch
Simply put, this book is amazing. I'm a 3D game programmer myself, even written a couple books on the matter (*cough* Focus on 3D Terrain Programming *cough*). I've read just about every major book on 3D graphics and a heck of a lot of books on game programming, and I can safely say that this is THE best of both worlds. I've never seen a book this thorough before in my life. Andre, who I know from personal experiences as a great guy, really shows his incredible knowledge of 3D graphics, and even game programming in general. It's nice to be able to read through an explanation and think "wow, this guy definately knows his stuff inside and out".
Absolutely great work. I know it was a long time in the writing, but, from my point of view at least, it was very much worth it. Don't listen to the nay-sayers that throw this book off the mark due to it's lack of using Direct3D or OpenGL. This book teaches you what's most important about 3D graphics: THE THEORY! How are you supposed to program 3D games by solely knowing how a 3D API function changes a scene? You can't. You not only need to know how the function changes the scene, but WHY it works the way it does and, some times, how it can be improved.
If you're a beginner lost in a 3D void, this is definately the book for you. However, it's almost more important to note that if you're an intermediate programmer who has EVER wondered about the "why" behind 3D graphics, then this book is also definately for you. Just buy it.
9 von 9 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen How to write a software renderer in one volume, amazing. 12. September 2003
Von Amazon Customer - Veröffentlicht auf Amazon.com
Format:Taschenbuch
As others have said, this book teaches you how to write a realtime software renderer. This is an amazing enough achievement--there is a LOT of information here. And unlike the SUPER MEGA DIRECT3D AWESOME PROGRAMMING sort of book that seems to come out every month, this is stuff that is useful over the long term, not just until the next API revision. There's no other current book I know of that teaches this--ever since 3d acceleration got on the scene every single book on game graphics programming seems to have been on how to use whichever API. The great things about Lamothe's book have been plentifully written about in other reviews on here, so I won't dwell on that much. Suffice to say, if you want to learn an API, don't bother with this. If you want to learn how 3D graphics actually work, this is the book you need.
I do have a few problems with this book, though. LaMothe's writing style can get gratingly casual, and he's not nearly as funny as he seems to think he is. I'm not asking for an ultra-dry computer science textbook here, but the constant cheesy humor does get kind of tiring. LaMothe's coding style is ugly and haphazard (largely a personal judgement, I realize) and he uses very little in the way of C++ features, even in places where they would make things a lot more natural (again, personal preference). Finally, he spends far too much time explaining his own APIs, information that would really have been better off on the included CD, saving valuable pages for more rendering knowledge.
So, overall, a wonderful and useful book, with a few rough spots. I hope there'll be a second edition.
11 von 12 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Very good books by LaMothe 17. Oktober 2004
Von G Fuller - Veröffentlicht auf Amazon.com
Format:Taschenbuch
Another in what, a series spanning over a decade now. LaMothe brings up subject matter in a way others merely glean over. This time he takes what you learned from the previous book, Tricks of the Windows Game Programming Gurus, and gets into 16-bit color, real 3D issues and solutions, a large section on math and geometry derivations, model formats and loading issues, presentation, AI, sound and a host of other nuances that you'll run into during game design and implementation phases.

HOWEVER: I thought it would benefit readers to repeat an important aspect of this book.

This book is the SECOND book on this subject. The FIRST book; Tricks of the Windows Game Programming Gurus, contains the build up of the base library he uses and adds to. If you can't scan through the first chapter of this second book, you need to understand this. He makes it perfectly clear that this book will not break down the library he uses from the first book. The source is of course contained on the CD with this book, so you can do the lookup yourself. But if you are looking for the book to get started, get the first one. AFTER you've read the first one and have an intimate grasp of it, move on to this one. The techniques and subsequent additions he makes to the original library will be more than a bit confusing if you haven't read these books in sequence and don't understand what he's doing. If you've already done other reading on DirectX or made a simple DirectX window or fullscreen then you won't feel so lost. I believe this reiterates what the previous reviews stated. This is not a flights-of-fancy beginners book. That's the purpose of the first book.

This is the problem you will find with a lot of other "beginner's" books. Their first book is written and talks about the authors library which is already written. With LaMothe, he wrote them in order with the true beginner in mind.

You MUST have a very good understanding of C at the least, C++ would give you the best basis to read and implement his code. I say this because this engine is completely software driven and uses DirectX 7.0. It compiles fine with 9.0 because MS still includes the interfaces for DX 7.0. If you don't know what that means then you need the first book.

If you are expecting to have an engine that does what the latest commercial engines do, don't. The graphics pipeline he uses is software. But you will know more than enough about the basics of an entire 3D engine pipeline along with the peripheral engines; AI, Physics, Sound, Input, when you're done that you'll be ready to look at other available engines in a whole new light.

I'm not a fan of his writing style nor his sense of humor. I'm the guy who likes tech manuals. Once you get past the unneeded pages of his tangents and humorous anecdotes you will find some of the best information available on the foundations used in designing and implementing a workable 3D engine. If any of the information above, such as "pipeline" and "interfaces" doesn't makes sense, this book will overwhelm you from chapter 1. Get the first one. It's big, It's green, It's the HOW-TO of getting DirectX and Windows to work together to make a black DirectX window. Once you're there and understand how you got there, this book will take you into advanced subject matter.

I recommend this book highly if you've read the first. And even though the book title says Adv. 3D Graphics and Rasterization (the process of presenting a scene on the screen), LaMothe shows you the other things that go into a real game engine. This book does deal with advanced geometric mathematics, so have the relevant resources available when you get lost. He'll only hold your hand if you can stand on your own two feet in this department, it's not a math book.
11 von 12 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Excellent and approachable 3D engine tutorial 13. Mai 2004
Von J. Jessup - Veröffentlicht auf Amazon.com
Format:Taschenbuch
In his latest book, "Tricks of the 3D Game Programming Gurus," Andr? LaMothe develops a 3D software engine by adding new functionally sequentially through each successive chapter. The book is a little over 1600 pages, comes with a companion CD and retails for $59.99.
Writing a graphics engine in software may not seem all that sophisticated, but it is an excellent way to approach computer graphics. By having to write specific functions that are typically abstracted by a platform specific API (i.e. DirectX), LaMothe focuses on the underlying theory and provides the reader a conceptual framework that is easily adapted to various targets as need arises.
While this book is the second volume in the Tricks series, having read the first book is not essential. To handle the 2D graphics, audio, and input, LaMothe starts off with the engine developed from the first book with DirectX 7 - and builds the 3D software engine on top of it (through the course of the subsequent chapters).
The first section introduces DirectX, the basic game structure, and the previous library's functional interface. In order to maximize time (and pages) building the new 3D engine, LaMothe abstracts the DirectX and Win32 code by encapsulating the computer interface to a set of three libraries to handle window construction, input, and audio. The book adequately describes the basic foundations necessary to use DirectX and Win32 without dwelling on many of the specifics. The main objective is getting to the 3D portion of the book and a "black box" approach is best for the platform specific wrapper code.
The second section begins with linear algebra and trigonometry. The math section spans over one hundred pages and forms the basis of the math library described in the subsequent chapter. Having most of the fundamental groundwork in place, LaMothe begins to develop the pipeline for the 3D engine. From the local to world transform to projection, the sub-steps necessary for rasterization are well detailed and described. In order to read external model data, several functions are developed to parse the output of the modeling tools included on the companion CD. By the end of the section, the engine is able to render in wire-frame.
After having the basic engine in place, the book really takes off. LaMothe starts the third section of the book adding critical enhancements: lighting, texture mapping, clipping, and a depth buffer. Starting with the mathematical background, each topic is thoroughly explored then the functional changes to the engine API are presented. LaMothe writes in a clear and sometimes too familiar fashion. The book reads as though LaMothe is speaking directly to you while transcribing his thoughts to the page.
In the final section of the book, LaMothe tackles several advanced graphics topics: perspective texture mapping, spatial partitioning, shadows, and animation. The visibility chapter is particularly strong with an in-depth look at Binary Space Partitions (BSP trees) and various other portal techniques. The engine code and examples are well commented and makes it easy to jump back and forth from the book to the source code.
The companion CD is as robust as the book. It contains a bevy of additional resources - nearly 600 MB including all the source code covered in the text (with pre-compiled executables), the book's appendices, twenty five articles from various authors on everything from Artificial Intelligence to Pentium optimization, source code to Quake, and trial versions of some helpful game development tools, like Sound Forge and Paint Shop Pro, and the DirectX 9 SDK. The modeling tools are a very nice touch and add to the completeness of the overall text.
Simply put, this is a thoroughly satisfying book. While LaMothe's approach in developing the engine is sound, understand that he makes design choices throughout the book to specifically make a fast software engine (i.e. no shaders, no complex light models, lookup tables, etc.). The theory behind his choice in approach is the valuable part of the book and the engine is just a practical demonstration. A reader looking to develop their own engine or understand the details behind the scenes when using an API like DirectX will truly appreciate the effort LaMothe has undertaken.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar