Customer Reviews

Beginning Math and Physics for Game Programmers

5 star:		(3)
4 star:		(1)
3 star:		(2)
2 star:		(3)
1 star:		(1)

 

 

The previous reviewer on this book must be a genius. I meen, he could even read the title, "Advanced C++ and Code Optimization." Oh, wait, that's not what it says, it says "Beginning Math and Physics for Game Programmers." As an AI programmer for the last 10 years who came into the industry without any college level courses, I never studied math and physics in school, and most books that that claim to be physics books for game programmers read like calculas text books. I was very pleased to find this book assumed nothing about a persons level of math in a schooling environment, an explained in very good detail how to start learning a new area of programming. The previous reviewer asks "why would game programmers need a book about basic math and physics?" Well maybee they are'nt game programmers yet? "It's not just the code, her math is just as bad. She uses degrees instead of just sticking to radians." Most people that are just starting out don't understand radians or the need for them. That's why it is simplified using degrees. Again, the key word here is "Beginning." This book is not geared towards people who are industry level programmers. If you want a book where you can steal code out of to use in your game, search the internet, there is plenty of free code out there. By the way, if game programmers don't need beginning physics and math, and you're such an awsome game programmer, why did YOU by the book?

I had read some of the reviews for this book and they focus on parts where almost all books have human errors, code or math examples, but the explaination of the theory is very well reviewed. This book is very well organized and explains very well the topics. This book is a very good book for begginers on games physics and math, its not a book for learning math, physics or programming, and by reading the reviews of the book you'll see what I meant, seems a lot of people misundestood the book title.

Although I'm not a game designer, I picked this up because I think it's important to read books outside my everyday work. I'm glad I did! This excellent book brings together a lot of material in just over 400 pages, and the author deserves a lot of credit for making the subject matter easy to understand without talking down to the reader. The author does a good job covering the subject matter, although the shortness of the book prevents an in-depth treatment of the dense subjects. It is a good primer for any aspiring game programmer.
The book is split largely along subject lines: math first, physics second, it being impossible to program the physics of an object if the math is not understood. One of my favorite things was included in this book: chapter exercises, along with the answers. I get a lot more out of a book when I can do problems and check on my answers. I found the software on the cd useful, despite not being a C++ programmer, it helped me concretely visualize what happens when you use certain techniques.
This book will be useful for a long time to come, because the math and physics discussed are the fundamental building blocks behind realistic game play. I will keep this book on my reference shelf for the math alone, it is a good refresher for basic algebra, trig, and calculus. Word of advice: if you don't understand this book, game programming is not for you.

This book was my textbook for a class. The book is well written and the author explains the concepts pretty well, my biggest problem is the errors. A lot of the answers in the back of the book are wrong. Since this was for a class we focused on the problems that did not have answers in the back of the book, but when you are trying to work through one of them as an example it can be difficult. We found at least 2 every week. Since I had a teacher it was not a big deal, but for those who are buying this book to study on their own it could be a bigger problem. I've seen other reviewers mark this up to human error, but when you are writing a book to educate you have to try to cut out errors like this and if it was maybe one or two fine, but there are a few.

The book can't be pointed as bad or good, the title tells everything, like the author says in the Introduction this book isnt the last one you should read for this field, its just a starting point, anyway I found it simple and you need to know some math and physics to get it all clear, besides that you have 6 nice demos with full code you can study and run for better understanding. Who wants to get a simple and clear basic concepts should get the book, others may prefer most complete titles.

This book is, in my opinion, the essential read for anyone who wishes to start working with game programming. The explanations of concepts and mathematical principles are in plain English and often complimented with an example. While often many game programming books dive too deeply and quickly into technical or mathematical concepts this book attempts all time to keep the reader informed and strives to make the content as accessible as possible.

Also this book is a great reference for formula and maths review for even the seasoned programmer.

First on the good points. This book is great for beginner games programmers who lacked the mathematical and physics knowledge. The lessons were simple and easy to understand.

The bad points? Glaring errors everywhere. For example, the question would ask you what A + B in the diagram is when the diagram only shows F + G. Another one, the diagram shows [7,2] and the questions ask you things concerning [7,3]. This was supposedly meant to be for beginners, but with glaring errors such as this all over, it makes it an obstacle such to get down to learning the basics.

It would have been a great book for beginners like me if I hadn't later figure out that those simple problems I was trying to solve were actually printing errors.

I bought this book hoping it would explain some of the math related to games, like vectors, quaternions, matrixes etc. and operations with them, the reason I chose this book was that I wanted one which didn't present advanced math in the first chapters.

The book fails at explaining anything at all and it doesn't just start at a WAY to basic level (I wouldn't have been surprised if the author explained multiplication).

In the chapter about trigenometry the author tries to apply what you have learned with an example of an flying arrow, (s)he doesn't even tell why it is like that just that if the arrow is shooten 50 units some way the shadow will be 25 units away from the shooter.

At first I thought it may be better later, but when the author says the following:
"Anything from a char, which can hold values from -128 and 127, to an unsigned long, which can hold values between 0 and 18,446,744,073,709,551,616 (or 2 to the power of 64)"
Here are two problems, first it is up to the compiler to choose whether char is signed or unsigned, this means it can also go from: 0-255, but the biggest mistake is to say that a long is 64 bit! How many bits a long is isn't defined in the standard and on most current compilers(MSVC++ 2003 .NET included) sizeof(long) is 32 bit.

I can't comment on the physics, matrixes etc. since I put down this book when I came to the chapter about vectors since it was just SO bad, this is why it didn't get 1 star.

For people want an alternative I recommend 3D Math Primer for Graphics and Game Development.

I was looking for a book with Math and Physics formulas and explenation how to use them in game programming. I saw this book and took a glance in it in the book store and it looked verry nice.
But it have been a big disappointment. The first two thirds of it is either verry simple (points and lines) or "strange" stuff like 3D rotation. If you are intrested in 3D game programming you proberbly don't buy a book for beginners. Also the structure of the book is verry wothless, it takes time to find what you are looking for.
I wold not recomend this if you are choosing between this book and another. I'll give it 2 two stars, and thats a high grade for it.

Stay away from this book. Look at the title, why would game programmers need a book about basic math and physics? If you need futher convincing let me just paste some code from the book:

bool ColBetweenSpheres(sphere &S1, sphere &S2)
{
return (pow(S2.center[0] - S1.center[0], 2) + pow(S2.center[1] - S1.center[1], 2) + pow(S2.center[2] - S1.center[2], 2)) < pow(S1.radius + S2.radius, 2));
}
// not const safe, uses pow instead of squaring both sides

float distance2D(float *P1, float *P2)
{
// Calculate our distance and return it
return (float)sqrt(pow(P2[0] - P1[0], 2) + pow(P2[1] - P1[1], 2);
}
// not const safe, uses pow instead of squaring, uses sqrt instead of sqrtf, doesn't use her vector struct

float *find2DMidPoint(float *P1, float *P2)
{
// Allocate enough memory to our pointer
float *temp = new float[2];

// Calculate our midpoint
temp[0] = (P1[0] + P2[0]) / 2.0f;
temp[1] = (P1[1] + P2[1]) / 2.0f;

// Return our answer
return temp;
}
// not const safe, allocates 2 floats from the heap instead of returning her 2d vector struct

float *find3DMidPoint(float *P1, float *P2)
{
// Allocate enough memory to our pointer
float *temp = new float[3];

// Calculate our midpoint
temp[0] = (P1[0] + P2[0]) / 2.0f;
temp[1] = (P1[1] + P2[1]) / 2.0f;
temp[2] = (P1[2] + P2[2]) / 2.0f;

// Return our answer
return temp;
}
// same as above but instead of taking a vector struct so 1 function is overloaded on types she creates a function with a different name

2Dvector_comp_PolarToCompConversion(2Dvector_polar vec)
{
// A temporary variable which will hold our answer
2Dvector_comp temp;

// Fill in our values
temp.x = mag * cos(dir * PI / 180);
temp.y = mag * sin(dir * PI / 180);

// Return our answer
return temp;
}
// no return value of this function, she has to fill in a temp struct because she doesn't use constructors so instead of a one line function it's many lines

I'm not making this stuff up and I'm not just selecting the most questionable code. The whole book is filled with code as bad as this. She constantly redefines functions in every section (stick to one vector class and use it throughout the book) and never uses operator overloading (and makes all the members private with no accessors for some reason) so it makes me wonder why she didn't just stick to C.

It's not just the code, her math is just as bad. She uses degrees instead of just sticking to radians (so there are conversions between the two everywhere) and her vector notation uses the very lame Ai + Bj + Ck form instead of a more compact form.

(...)