2 comments about Game Design Perspectives (with CD-ROM) (Advances in Computer Graphics and Game Development Series).

1. This is a nice book with some technical issues that could be better but still a nice book to have for any one interested or that has a career in game design. you should read this book and understand at least a nice outline of how to design a game. you should'nt buy this if you are just starting and have no clue how to design games it is a nice book to try for starters even though there is a chance they will not know what it is talking about.



2. This is a very good read, and offers a lot of good information for the budding game designer. There are lots of issues to ponder and the book certainly manages to raise some good ones. My only complaints about the book are the lack of strong examples for some key concepts (naming specific games, and perhaps detailing how said game illustrates the concept would be nice) and the fact that it is rather focused on the RPG and Adventure genres. For that reason I would highly recommend it to designers interested in those genres, but would caution those who are not interested in designing RPG/Adventure games.

5 comments about Foundations of 3D Graphics Programming: Using JOGL and Java3D.

1. I was on the waiting list to buy this book before it was released. I was expecting some good intermediate information on JOGL that was along the lines of implementation and Graphics architecture concepts. Boy was I dissapointed. This is a survey of OPENGL not particularly JOGL. This is the kind of book a professor would assign a freshmen programmer to read. They went to far into the details of the matrix mathematics behind the graphics library instead of practical implementation. Dont get me wrong knowing how things work is a must but dont sell yourself as anything more than a survey of graphics programming.



2. OpenGL is one of the most popular graphics languages around. And Java has some graphics capability, in 2d and 3d. But recently, JOGL has emerged. It is essentially a Java wrapper around the OpenGL routines, which are far richer than what comes with native Java.
   
   The book attempts two things. One is a teaching of 3d graphics. Involving the extensive maths, which is mostly matrix algebra. The other is how to accomplish this in Java, using Java3D and JOGL. The first is done fairly well. A good introduction to the most common graphics ideas, like hidden surface removal and transparency. It is unclear, though, how well the second task is done. Java3D seems simple enough. The coverage of JOGL does at least give you an understanding of common OpenGL routines that you'll probably need.



3. This book was theoretically written to be a introduction to OpenGL using the cross platform JOGL bindings. It fails to accomplish this task by providing incomplete instructions to get JOGL working, and extremely confusing convoluted example code. I am a professional computer programmer, and rarely have I come across such bad code. Furthermore, the algorithms discussed in this book are explained by confusing code rather than in words. To top it off, the author(s) must not be fluent in English. I had to read many sentences over several times in order to understand the poor English.



4. This book is of no avail to a student of computer graphics. Not only are the explanations in this book sorely incomplete, they are so poorly written that they require hours of careful examination to determine that they are incomplete. All throughout the book the author leads you on by making you think that you are about to be told something useful. You never are. Additionally, the code given in the book will often not compile or fail to execute properly. You will be very disappointed if you buy this book.



5. I had expected more focus on the word "Foundations", but the brief introduction to output primitives was sorely lacking. For instance, they cover, in detail, the Bresenham line-drawing algorithm, but they completely ignore the midpoint-circle drawing algorithm; it would have been nice to see a Java implementation of this.
   
   I was also disappointed that all of the code in the book is subclassed off of any previous code. This is OK in the first couple of examples, but, when one goes further through the text, it becomes difficult to determine just what methods they are calling in their code, and where they come from.
   
   So, in short, the book should not be used as one's sole introduction to the fundamentals of graphics programming, but it might serve as a good counterpart to learn some Java-specific implementations.

3 comments about Flash XML Applications: Use AS2 and AS3 to Create Photo Galleries, Menus, and Databases.

1. This book is well written and offers easy to follow steps that clearly explain how to create interactive xml based applications.
   
   It covers actionscript 2 & 3 as well as some related Flash components. The accompanying CD offers well constructed lessons that are easy to understand and work through.
   
   Thanks for a fantastic flash resource!
   
   Pierre



2. The first review must have been written by a friend of the author. On the contrary the book is NOT well written and is FAR from easy to follow. I do not want to be overly criticle because it is clear that much time and effort went into this book. It has a lot of good information that is very useful. I am not sure, however, whether i feel good or bad about the purchase. It has definately left me with a number of headaches.
   
   Right off the bat it is confusing. I am an advanced Flash user and although i understand most of what is documented the instruction itself is terrible. I am confident that the author has absolutely no teaching background. He almost NEVER indicates when to save a file or what to name it for that matter. Which is odd considering the entire book relies on the external, custom classes that you create when trying to follow along. You need to know WHAT to name them and WHEN to name them! Like i said, i am an advanced user and the lessons have me completely lost. You never quite know where to stop or begin with the next script. I am half way through the book and it just gets more frustrating to try and follow along. Because i am an advanced user, i am able to continue for the most part. The bottom line is that it is a difficult learning experience.
   
   Aside from the poor instructions i was able to pull some very valuable information from it, but it has been an excruciating experience. Not a bad resource to have available, but be prepared to take some Advil. It will rack your brain trying to follow along!
   
   -Shae



3. I would have to agree with the review from Shae Waters. While this book contains some very good and useful information it is definitely NOT for beginners. If you do not have a very strong understanding of XML and ActionScript you will be completely lost. I am not an "expert" in either, but I do have a pretty strong foundation in both and this book is still very difficult to work through. Many, many things are not explained adequately and the lessons are not anywhere detailed enough. It's very frustrating. A top notch editor should have been able to help shape this book into a resource that more people would be able to take advantage of. I fear most will abandon it before they get very far. I'm determined to make my way through it, but it is a struggle, not due to the material that is being covered, but how it is being presented.

5 comments about Introduction to 3D Game Programming with DirectX 9 (Wordware Game and Graphics Library).

1. I started DirectX programming recently. This book brings you upto speed very fast. It is well organized, written well, and is kept very simple. It's objective is to teach concepts and how to program specific concepts is C++. The examples and straightforward and illustrate whats in the text very well.
   
   Like all other reviewers, I should agree that the title of this book is misleading. There is very little, if any "Game development". The book is all about the basics of 3D drawing using drect X
   
   If you want to start programming DirectX over the weekend with some nice 3D graphics including textures, lights and terrains and even fireworks, this is the book for you. I highly recommend it.



2. I guess this book delivers what it promises, more or less. It effectively introduces you to directx. It devotes 20 or so pages to each of 20 or so topics (the dimensions of the book are real small though, so the page counts are somewhat misleading). By the end of the book you'll understand what directx is and what directx can do, but what I found is that there just isn't enough "meat" there to learn any part of directx well enough to do anything useful with this knowledge.



3. This review covers the first 13 chapters. It is a book that you will definitely learn from; however, beware that it is not written for users of C#. C# samples can be downloaded from the book's web site and I talk extensively about that in this review. This review is more a How-To than anything else - it documents my experience with the book and using the sample code from the book's web site. I am new to 3D game programming so I started out with giving myself a crash course in Linear Algebra (for this I studied the book, "3D Math Primer for Graphics and Game Development").
   
   In Part 1 the author could do a better job of explaining how a vector cross product is calculated. He refers to "formula (4)" which is a formula in final form (i.e. it does not show the steps). Furthermore, "formula (4)" comes seven pages after the first three formulas, so when you come to "(4)" (on page 13) you may have already forgotten about (1), (2) and (3) (which are on page 6) -- it is awkward. It should be highlighted and labeled as "FORMULA 4:" or something like that.
   
   In Part II, Chapter 1 (Direct3D Initialization), section 1.4.1 describes initializing a pointer to an IDirect3D9 interface as...
   IDirect3D9* _d3d9;
   however, in section 1.4.2 the code for checking the capabilities of the primary display adapter shows this code...
   d3d9->GetDeviceCaps...
   The underscore character is missing from the IDirect3D9 object. It should read...
   _d3d9->GetDeviceCaps
   
   The source code can be downloaded from http://www.moon-labs.com/ml_book_samples.htm. C# versions of the sample programs are available. The download instructions include a username/password but I was able to download the files without having to provide them. Should you be prompted for a username/password the author's instructions state, "The user name is exactly the second word on page 212 in the first paragraph of Chapter 13. The password is exactly the fourth word on page 213 in the first paragraph of section 13.1." Let's cut to the chase, its "terrain/heightmap" (without the quotation marks or forward slash).
   
   The code in the book is meant to be used in a C++ development environment. I use C# 2005 Express Edition therefore there wasn't anything I could do with the code in the book. When you open a sample code project (one from the C# versions available at the web site) in the C# 2005 Express Edition, a "Visual Studio Conversion Wizard" will prompt you to convert the project to the current edition's format. Just go ahead and click on "Finish." As I mentioned in a previous paragraph, there is a C# version of the sample programs provided on the web site.
   
   Beginning with Chapter 3's sample and in all of the samples I could not understand why the 'Window' parameter would not work the way I understood it to work. In Form1.cs, when a d3d object is instantiated with a 'true' instead of 'false' for the Window parameter (the 3rd parameter), nothing worked. This works...
   d3d = new D3DInit.D3DInit(800, 600, false, DeviceType.Hardware, ref device);
   but this does not...
   d3d = new D3DInit.D3DInit(800, 600, true, DeviceType.Hardware, ref device);
   
   I had trouble with the sample for Chapter 6 (Texturing). The problem was due to the sample program's inability to find the texture image. To fix it, all I had to do was change the source code to reflect the FULL path to the image file. I'll clarify... this is the original line 136 in D3DInit.cs...
   
   tex = Microsoft.DirectX.Direct3D.TextureLoader.FromFile(device, "dx5_logo.bmp");
   
   I modified it to...
   
   tex = Microsoft.DirectX.Direct3D.TextureLoader.FromFile(device, "D:\\david.emmith\\Books\\Intro to 3D Game Programming\\Part II CS\\Chapter6\\dx5_logo.bmp");
   (Note: Remember to escape backslashes in path names by making double-backslashes, otherwise you'll get an error.)
   
   The same problem occurred again in Chapter 7's sample.
   
   In Chapter 11's sample you may find a similar problem to the ones I described above for Chapter's 6 and 7. In Chapter 11 there is a line in D3DInit.cs (line #55) that reads...
   
   private string shipFilename = "bigship1.x";
   
   You may need to modify it to reflect the full path name.
   
   If you are writing your own app and using the .NET samples as a guide you may run into a few problems when you build the solution. You may see a "... has more than one entry point defined" error. This will happen if you have the following code in your Form1.cs file...
   
   [STAThread]
   static void Main()
   {
   Application.Run(new Form1());
   }
   
   There is no need to have those lines in your Form1.cs (or whatever filename you are using in place of Form1.cs). A Program.cs file should have automatically been created in your project (click on the 'Show All Files' icon in Solution Explorer). You can do one of two things to rectify this problem:
   (1) Comment out or delete the code shown above in your Form1.cs (or its equivalent) file.
   *** OR ***
   (2) Exclude Program.cs from your project (right click the Program.cs icon and select 'Exclude From Project').
   
   There is a similar situation in the D3DInit.cs file. There is no need to include the Dispose() method - it will already be in the D3DInit.Designer.cs file (this file, like Program.cs, is automatically created by the Visual C# IDE).
   
   Another problem you may encounter if you are trying to use the Esc key to terminate your DirectX app is the Esc key not working. To solve this problem open your Form1.Designer.cs file and add the following line at the end of the InitializeComponent() method...
   this.KeyUp += new System.Windows.Forms.KeyEventHandler(this.Form1_KeyUp);
   Then make sure you have this method in your Form1.cs file...
   
   private void Form1_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e)
   {
   d3d.CloseD3DInit();
   Close();
   }
   
   And of course your D3DInit.cs file should have the CloseD3DInit() method defined. If not it should look like this...
   
   public void CloseD3DInit()
   {
   displayThread.Abort();
   Close();
   }
   
   In Chapter 11, as I mentioned earlier, there is a reference to a file named bigship1.x which is provided in the sample project. This is a mesh file which is nothing more than a geometric description of an object - in this case, a spaceship. If you're like me and you want to workout your own example you would like to create your own mesh file and test it in your own application. To create a mesh of your own design you will need the aid of a program. DirectX uses the .x file format for its mesh files. Some of the more popular 3D design programs do not readily provide a method for turning their meshes into the .x format. I will describe as briefly as possible the steps I took to create a simple mesh, convert it to a .x file and use it in my own program. There is probably a better way but this is the way I did it.
   
   (1) Find a FREE 3D design program. I downloaded and installed two programs:
   
   (a) Maya 7.0 Personal Learning Edition
   
   (a.1) Can be found at the Autodesk web site.
   
   (b) Autodesk 3DS Max 9 (30-day trial)
   
   (b.1) Can be found at the Autodesk web site.
   I was more interested in 3DS Max because I have my eyes on some aircraft models I want to use and they were created in the .max file format. So this is the program I used to create a very simple model.
   
   (2) Create a model. I created a sphere with a green texture in 3DS Max. I won't go into the details of how I did that because it is not that difficult to figure out on your own. You may want to create something a little more 'elaborate' than a green sphere. Have at it.
   
   (3) Convert the model into an x-file. This sounds simple enough but try doing it on the cheap, i.e. $0.00.
   
   (a) If you want to pay for a conversion utility up front then check out two products from Okino Computer Graphics:
   
   (a.1) NuGraf
   
   (a.2) Polytrans (a simpler version of NuGraf)
   It should be noted that Robert Lansdale (lansd[at]okino.com) offered to do a one-time conversion for me. I emailed him my .max file and he sent me back a .x file. I had already done the conversion by the time he sent the file back but I certainly appreciated his kind gesture.
   
   (b) If your cheap like me you want to do this for free because afterall, you're just trying to learn how all this works. I contacted a 3D guru by the name of Chad Vernon. Chad was very helpful in pointing out a couple of free conversion tools:
   
   (b.1) kiloWatt X file Exporter
   
   (b.2) Pandasoft's Panda Xporter Tool
   
   (c) I used Panda Xporter. After you unzip the .zip file you have a file named PandaDirectXMaxExporter.dle. This is a 'plugin'. So what you need to do next is to make this file known to 3DS Max and the way you do that is place the file in 3DS Max's plugin folder. On my machine this folder is located at D:\Program Files\Autodesk\3ds Max 9\plugins. Now you are ready to convert your model to the .x file format.
   
   (d) Launch 3DS Max (close the Welcome Screen if it appears) and open your model file (File | Open Recent). The first time I did this with the Panda Xporter in place 3DS Max crashed. I removed the Xporter from the plugin folder and re-launched 3DS Max. It crashed again. I eventually got it to work and put the Xporter back in the plugin folder. 3DS Max did not crash after that. This remains a mystery. The problem appeared to have fixed itself.
   
   (e) Select File | Export. Click on the down arrow for 'Save as type' and choose Panda DirectX (*.X). Click in the 'File name' textbox and enter a file name without a file extension. Note where the file is being saved to. You will need to know the full path to your .x file when you create your own 3D app. Click on 'Save'.
   
   (f) In the 'PandaSoft DirectX Exporter' dialog, '3DS Max Objects' tab, uncheck 'Include Animation' if your object is not animated. In the 'XFile Settings' tab, the 'DX File Type' of either 'Text' or 'Binary' worked for me. I believe the default is text. Click 'OK'.
   
   (4) Create your own 3D app. Again, I am using Visual C# 2005 Express Edition. Use the C# samples provided at the book's web site to guide you. Remember, as I have pointed above, that there are some differences that come into play between the samples and what you create in a Visual Studio 2005 environment. Read through my earlier comments.
   
   I hope this helps. Now on to the review.
   
   In Chapter 12's sample, line #138 of D3DInit.cs needs the full path to dx5_logo.bmp. I described this same problem in earlier chapter reviews.
   
   In Chapter 13's sample, line #601 of D3DInit.cs refers to a temp.raw file. This file, as far as I can tell, is not included in the managed (.NET) sample files. So I came up with my own work around which I describe below...
   
   (1) Download Terragen which is a free terrain generation tool. Look for the link labeled, "Install Terragen v0.9.43 (1.6Mb)" in the download page. Now install Terragen.
   
   The following steps are for once you have launched Terragen.
   
   (2) Click on the 'Landscape' icon in Terragen and then click on the 'Generate Terrain' button.
   
   (3) Click on the 'Export' button.
   
   (4) In the 'Terrain Export' dialog click on the 'Export Method' dropdown listbox and choose 'Raw 8 bits'.
   
   (5) Click on the 'Select File and Save' button and choose the name for your .raw file and its location.
   
   Now that you have your own raw file you can insert the file's full pathname into the Chapter 13 sample.
   
   If you have found or already have Terragen .ter files you can convert them to .raw files with a little free utility named 'Terrify'.
   
   The book's web site has some additional information pertaining to Chapter 13. You can go to the Resources page and scroll down to 'Basic Terrain Rendering Part II'. The 'Download Code' link will give you a file named 'TexBlendTerrain.zip' which, according to my WinZip utility, is not a recognized Zip file. The links in 'Remark 2' do not work (they take you to some useless page).
   
   This is the extent of my review. This is a very good book but I wish it were geared towards .NET developers.



4. This is the best intro to Direct3d book I have. For the game programming aspect, it sucks, but there are so many books that tell you how to make a certain type of game (Premier Press come to mind).
   
   The first section is purely math! This surprised me since it's the only Direct3d book I have found that covered that much math.
   
   The reasons why I gave it 4 out of 5: could be better. It needs more complete sample code. I mean, there's sample code on his web page, but the sample code starts at chapter 9! However, the (incomplete) code before chapter 9 is pretty easy to follow. Whenever he omits a piece of information, it's minor details like
   
   int stuff[10] = { ... }; // fill stuff in with stuff
   
   The book provides a very detailed explanation on how Direct3d works. Sure, there are times where he puts "see the MSDN for this struct", but that's usually when there's not much explaining he could do that's not in the MSDN already. I like that it feels like the author took a good deal of time to figure out how to explain every topic. The information is incredibly clear.
   
   If you are like me and look at a bunch of DirectX books and just have no idea what the author(s) is talking about, you should try this book, especially if you have a good math background. And if this dude releases a book on DirectX 10, I'll definitely get it. If you know DirectX and are looking for a book on game programming, look for another book.



5. Recently i decided to get a little into Direct3D Programming. I had absolutely no background on 3D Programming, because i am developing Business Software on a daily basis. I reviewed a few other Books on the Thematic but stayed with this one - and it was a good decision, basically because of:
   
   *) It explains the Mathematics necessary for understanding the inner workings in a simple and easy understandable way. The last time i did Vector and Matrix Algebra was over ten years ago in school and i had no problems following.
   
   *) It explains the necessary Terms (like Vertices, Transformations) very detailed and also understandable.
   
   *) It does not use a Framework throughout the Book like others do. You are doing all the Stuff by yourself (ok, there is a little framework: The one which initializes a Win32 Window DirectX draws into...)
   
   *) It's not written in a Kiddy Beginner Style. You have to know the Language and how to use your Tools to follow.
   
   If you have a good understanding of C++ and want to join the Microsoft side of doing 3D Graphics this Book is for you.

5 comments about Visual Basic(r) Graphics Programming: Hands-On Applications and Advanced Color Development, 2nd Edition.

1. I am happy with my decision to buy this book, it has what I was looking for and even more than expected.

   Highly recomendable.




2. If you just HAVE to develop graphics apps in VB, this is your best bet.



3. This book is very close to perfection in covering topics of the graphics manipulation, which up to the current times was an option of C/C++ developers ( as far as availability of information and samples). It's good for novice and seasoned developers alike.



4. This is an excellent book. It covers many aspects of Computer Graphics including Vector Graphics, Raster Graphics, Animation, Curves and Surfaces, 2D and 3D Transformations, and Rendering. Each chapter comes with lots of sample code on the CD. The underlying mathematics are also nicely explained.
   
   I only wish their was a 3rd edition for VB.NET.



5. I'm not a VB programmer, but I was able to understand the theory in this book, and I could easily work through the code examples to translate them into Delphi and C#. It's very hard to find a book (for any programming language) that explains 3D graphics in simple terms, and with useful code examples. Even though this book is getting a little dated, this book will still be among my highest recommendations for years to come. The basic theory does not change, even though programming languages evolve.

3 comments about Introduction to 3D Graphics & Animation Using Maya (Graphics Series).

1. As you might guess from the title, this book is about designing 3D objects, rooms and areas, often used in the writing of gaming software using the Maya software system.
   
   The interesting aspect of the book is the way that it is written. Each chapter starts with a bit of theory which is followed by a tutorial. Thus you get a combined approach that I find works very well. Sometimes you read the theory and are left wondering just what he was talking about, and the tutorial shows you what he means. And conversely sometimes when you get lost in the tutorial having read the theory allows you to get yourself out of trouble.
   
   Make no mistake, 3D modelling is not easy. The amount of work involved to get the image you want is significant. A sophisticated software package such as Maya makes it easier, and completely understanding what Maya does is a big help. This book is a good one to help you get there.
   
   The book comes with a CD which includes all of the designs that the book describes. This way you can work with what the author has already done and see professional quality work. The CD also includes the Maya 7 Personal Learning Edition.



2. overall i think this book is great. if your into after effects or whatever else and have little knowledge of a true 3-dimensional software package but the ability to understand, buy this book. if you think 3d animation is neat and something you wouldnt mind learning, stop right now. Maya and most other 3d packages are not to be taken lightly. it takes a long time to learn the software and even longer to learn how to apply it. ive bought many other "maya" books by many other authors and the reason i really like this book is if your learning, it explains details about the little things that most other books skip past assuming you already know. dont cut yourself short, get the most out of each tool and start learning at the beginning.



3. This book is an introduction to 3D with Maya as the software package. This book provides plenty of discussion on general 3D topics including modeling (polygonal, NURB and organic), rendering, lighting, and character rigging. However, the majority of the pages are dedicated to hands on tutorials. The included CD has tutorial files, high resolution images and Alias Maya 7.0 Personal Learning Edition (PLE).
   
   Although this book covers a lot of good topics (especially a strong emphasis on clean geometry), the tutorials were too frustrating. The steps were very difficult and not just because of the subject material. The steps in the tutorials generally start out quite detailed, but they eventually get a little vaguer. I believe the idea of this approach is to allow you to finish part of the tutorial on you own. This approach works for some of the tutorials, however, most of the projects are just too large and complex. For example, the tutorials in the last chapters cover modeling, texturing and animating a complete Unreal 2004 compatible game character. Even though I was not able to complete all parts of this continuing project, I still learned quite a bit. The problem is, for a beginner level book, an arm or head would have accomplished the same with less aggravation. This book is simply not long enough to properly cover projects of this amount, size and difficulty. Maybe space limitations are another reason you are left to finish a lot of the tutorial steps on your own. Still, there are a few other reasons working through the book proved difficult. For one thing, the colorless photos in the book were pretty much useless. The high resolution images on the CD were a big help though. Sometimes these images were the only way to understand a given step. The book as a whole could have used more editing as it had plenty of mistakes. There were typos in the text such as repeated and missing words. Additionally, names for menu and dialog boxes differed a bit from the included version of Maya that I was using. Occasionally, a minor step was missing or an incorrect image was used (Check the CD for the correct images). There were also plenty of other little inconsistencies - many relating to layer and object naming.
   
   If you are able to get through all the chapters in this book, you will learn quite a bit about 3D modeling that does not just apply to Maya. Still, it would have been nice if some of the harder projects in this book provided more detailed and complete steps. Instead, you are left to complete much on your own, which is an approach that probably works better in a simpler subject area. For 3D modeling, the tutorials and topics are probably a bit too hard for a true beginner and it is supposed to be a beginner level book. In the end, this is just another Maya book that tries to cover too much material without committing to more pages.
   
   Rating: 3.5/5

2 comments about Complete Guide to Anime Techniques: Create Mesmerizing Manga-style Animation with Pencils, Paint, and Pixels.

1. Japanese animation is an influential media style with bright colors and dramatic entertainment value, and any who would draw or create anime characters would do well to begin with The Complete Guide to Anime Techniques, which surveys the basics of artwork, working with 3-D graphics, and more. From creating the script to storyboarding to distributing a finished movie, this moves beyond the usual focus on drawing to embrace the whole of anime, and is a top pick for any library where patrons favor anime discussions.
   
   Diane C. Donovan
   California Bookwatch



2. Pros:
   This is a beautifully illustrated guide to the terminology with examples of the production and techniques of Anime in the Japanese/Asian style. It is 'complete' in the sense it covers the vast majority of terms, forms of style and applications. It even includes a section on various softwares available (2006) and what to expect to pay for them by the 'free - $$$$$' rating. That is it in a nutshell. If you are expecting the essentials (ONLY) of how-to this is it.
   Cons:
   IF you are however looking for a guide to help you produce on desktop computer and are a beginner, and looking to do a barebones small studio production... There are better places for the fleshing out of 'How-To' in detail.
   Overall:
   The book is a tease, a pleasing tease, but just a tease. Keep it for referencing terms. And face facts, to do really professional Anime, you are going to have to PAY PAY PAY! SO save your dollars for the software for editing compositing and production... and sound recording and editing needs you will have. And if you have the money for that, you can then consider writing your own 'how-to'.
   P.S. Really didn't like the comment on page 41, "where a western artist may have a darker, grungier look for the clothes and expressions." I really felt that was uncalled for! Their main audience is future 'western artists'... just a thought.

3 comments about Jim Blinn Corner Dirty Pixels (Jim Blinn's Corner Series).

1. This volume covers the 2D end of the graphics making process - the proper treatment of pixels. Included, amongst others, is some signal processing tutorial, an examination of dithering, a look at the niceties of compositing. Each snack-sized piece is practical, but also attentive of the math and theoretical issues - a balance which Jim Blinn sets the standard for. This all means that if you write graphics software you can learn some neat things from this book that aren't available elsewhere.



2. This is an absolutely wonderful book. Readable, yet technical; quite funny in places, yet to the point; insightful, but no incomprehensible "head in the clouds" academic rambling (he rambles a bit, entertainingly and technically, but he explains everything so it's a pleasant experience instead of the deadly difficult reading some of the common graphics texts provide.)

   There are also some biographical interludes that aren't graphics, strictly speaking, but I found them eminently worth reading. Even if you don't, though, they only represent a very small fraction of the book and you can discount or skip them entirely without loss of technical detail, as they are in their own little isolated portions of the text.

   The book itself is a series of separate (but often related) ruminations on various subjects of a graphic nature; the only problem the book has is that it ended way too soon for me.

   I was entertained, enlightened, and I went *straight* to our source code and improved a number of things within hours of understanding what Blinn was telling me in more than one place. With immediate and MOST satisfying results, I can add.

   :-)

   The only problem this book can possibly said to have is that there are many areas of graphics, an admittedly very wide field, that Blinn says nothing about - and after seeing what he has to say on what he *does* talk about, one can only be left with a sense of loss that he doesn't (for example) write about textures here, or perhaps pick apart a few more taken for granted areas, which he does several times in this volume to great effect.

   If you write graphics code, you should own this. Buy it now. NOW!

   What are you doing still reading? BUY IT NOW!

   No, I don't know the guy, and I get no commission or other compensation.

   :-)




3. This is the second book in Jim Blinn's "Corner" series, and it has some good information in it, but I didn't think it was quite up to par with his first book. There are 3 articles on digital video issues that are essentially no longer relevant. Plus, the author has a couple of articles that basically act as memoirs of technical events in the distant past so that due to changes in technology, they are also of limited usefulness.
   Like the first book, it is not intended to be a computer graphics textbook. It is simply a set of articles that the author has written over the years, mainly from the late 80's to the mid 90's, on computer graphics topics. The author offers up mathematics as it is needed and pseudocode. I review the book by individual article:
   Chapter 1 The World's Largest Easter Egg and What Came Out of It
   The use of an interesting triangulation scheme to design a monumental sculpture of an easter egg is described. The triangulation method used to approximate the egg's surface is based on paper folding. The development of the program and its generalization to three dimensions are examined. The calculation of the three parts of the egg (a middle-barrel section and the two end caps) and some unsolved questions regarding this technique are discussed.
   Chapter 2 What We Need Around Here Is More Aliasing
   A brief tutorial is given on what aliasing means. Plots of some relevant functions are shown. Some of the conventional wisdom about aliasing and why that wisdom may not be so wise is explained. Aliasing is actually an image processing phenomenon involving the Fourier transform, convolution and the convolution theorem.
   Chapter 3 Return of the Jaggy
   The antialiasing problem of filtering out high frequencies before sampling is considered. The techniques examined are simple filters, box filters, the triangle or tent filter, Gaussian and similarly shaped filters, and the ideal filter. The use of subsampling and the effect of D/A converters are discussed.
   Chapter 4 How Many Different Curves Are There?
   A categorizaion of the types of shapes a homogeneous cubic can generate.
   Chapter 5 Dirty Pixels
   How to optimally encode intensity into an 8 bit pixel.
   Chapter 6 Cubic Curve Update
   The problem of cataloging all the shapes that can be generated by a cubic equation. In response to a letter commenting on an earlier column, he corrects an error in his listing of all the combinations of factorizations that could make degenerate curves, pointing out that all type 5's are really the same shape and all type 7's are really the same shape. He provides additional considerations on the possible shapes of nondegenerate curves.
   Chapter 7 Triage Tables
   The author considers the application of the principle of triage to computer graphics to speed up certain types of algorithms. He describes a very simple data structure that he has used to keep track of triage information in several situations. He applies his method to Warnock's algorithm and to a hidden-line-elimination problem.
   Chapter 8 The Wonderful World of Video
   An overview of video animation for computer graphics is given. Signal timing, color encoding, tape formats, tracking, genlocking, time code, editing, VTR communication, and software are covered. This article is somewhat outdated.
   Chapter 9 Uppers and Downers
   Notational schemes for vectors and matrices are addressed. Previous notation is reviewed and its deficiencies exposed. A new notation, borrowed from tensor analysis, is introduced. Using this notation, almost all of geometry is reduced to tensor multiplication.
   Chapter 10 Uppers and Downers, Part II
   The Feynman diagrams, which represent the product of tensors in diagram form as directed graphs, are described. In the diagrams, each tensor in the product is a node in the graph, each index is an arc, bound indices are arcs connecting the nodes, and free indices are dangling arcs. The epsilon-delta rule in diagram rotation is presented.
   Chapter 11 The World of Digital Video
   Digital video standards define byte-stream signal formats for transferring video over cables. The composite and component standards, two digital video standards that relate most closely to the NTSC broadcast standard, are discussed. The analog NTSC signal and the framework of digital video standards are reviewed. The horizontal timing, quantization, and TRS-ID used by the composite digital standard, and the vertical renaming, scan line timing, and pixel value quantizing used by the component digital standard are described. This is another article that is somewhat dated.
   Chapter 12 How I Spent My Summer Vacation 1976
   Reminiscences on Blinn's summer at NYIT in 1976. This is more of a humorous personal musing than it is instructive.
   Chapter 13 NTSC: Nice Technology, Super Color
   Lots of articles talk about the YIQ to RGB transform. Blinn shows how to simulate an image's appearance on a NTSC monitor using digital filtering techniques. Another dated article.
   Chapter 14 What's the Deal with the DCT?
   Talks about the discrete cosine transform and why it is superior to other transformation methods for image compression.
   Chapter 15 Quantization Error and Dithering
   Whenever you do any sort of image arithmetic, such as contrast enhancement or compositing, you get roundoff error. In fact, since the arithmetic is often done in only X-bit accuracy, sometimes the round-off error can be substantial. You get quantization error, on the other hand, whenever you go from an analog signal to a digital signal or whenever you go from a high color-resolution signal to a low resolution signal, say from 24 to 8 bits per pixel. The author considers both of these problems.
   Chapter 16 Compositing Theory
   Associating a pixel's color with its opacity is the basis for a compositing function that is simple, elegant, and general. However, there are more reasons than mere prettiness to store pixels this way. One of the most important anti-aliasing tools in computer graphics comes from a generalization of the simple act of storing a pixel into a frame buffer. It was most completely codified in a previous paper by Porter and Duff (1984), where they call it the over operator. The author shows a new way to derive the over operator and describes some implementation details that he has found useful.
   Chapter 17 Compositing - Practice
   The author discusses the practice of image compositing and in particular the Porter-Duff "over" operator. The author has found it most useful to provide "over" as an inplace operator; you have an image stored in a frame buffer and want to lay another image on top of it. Pixel representation, conversions, pixel arithmetic, 16-bit over 8-bit, 8-bit over 8-bit, and other 8-bit possibilities are discussed.
   Chapter 18 How to Attend a SIGGRAPH Conference
   Blinn is one of the few people who has been to the first 22 of the Siggraph annual conferences. In this article, he gives some historical nuggets and tips he has formulated over the years. He discusses time management, technical talks, panels, equipment shows, video shows, art shows, parties, name badges and the summer camp session. Due to the changes in presentation technology, this article looks old in places too.
   Chapter 19 Three Wrongs Make a Right
   When dealing with graphics operations that must be fast (like the inner loops of rendering algorithms), Blinn usually likes to do calculations with fixed-point arithmetic. The motivation for this discussion is the desire to do arithmetic on pixel values: red, green, blue, or alpha. He uses floating point as a testbed and as scaffolding to derive integer formulas. All final calculations take place using only integer arithmetic.
   Chapter 20 Fun with Premultiplied Alpha
   The computer graphics universe consists of pixels. Pixels, in turn, consist of components: red, green, blue, and the coverage or opacity value alpha. For various reasons it is convenient to store and process a given rgba quadruple with the rgb values already multiplied by a. This premultiplication has some other interesting implications which are discussed here.

No comments about Accelerated Silverlight 2 (Accelerated).

No comments about The Mathematica Programmer II.