| Beginning 
                                Direct3D Game ProgrammingAuthor: Jonathan 
                                S. Harbour
 Publisher: Premier Press
 ISBN: 1-931841-25-X
 Purchasing: [Amazon.Com] 
                                [Fatbrain.Com] - RRP US$59.99
 Reviewed: 10th March 2002
 Front 
                                Cover Shot: Overview At 
                                the time of writing, I've only seen (And reviewed) 
                                two books specifically about DirectX/Gaming and 
                                Visual Basic - and if you've read the reviews 
                                (here and here) 
                                then you'll realise that whilst they aren't terrible 
                                books, they weren't that amazing either. So at 
                                first I didn't hold up much hope for this particular 
                                book - why was it going to be any better than 
                                the others? However, 
                                it's part of the successful "Premier Press 
                                Game Development Series", of which I've already 
                                seen (and been impressed by) 3 books from this 
                                series; so maybe there's hope for the VB game 
                                development book that we've all been waiting for! The 
                                book is a rather heavy piece of work - weighing 
                                in at 1100 pages (bigger than any of the other 
                                3 books I've reviewed). The 
                                Structure  The 
                                structure and formatting of the book follows a 
                                similiar pattern to the other books in the series. 
                                It's divided into 5 basic parts, and each of these 
                                is subdivided into several chapters (22 in total). 
                                The five parts look like this: 1. 
                                Introducing Visual Basic and DirectX2. The Nuts and Bolts of Game Development
 3. Advanced Game Programming
 4. Complete Game Projects
 5. Appendices
 This 
                                structure works very well - the first part sets 
                                the scene, gets the reader familiar with the playing 
                                field and the intentions of the book, the second 
                                works on using the Win32 API to put together some 
                                more solid examples before getting into the DirectX 
                                code. The 3rd part is where you "meet" 
                                DirectX, thus its quite a large part of the book. 
                                The 4th part is very good - packing 4 complete 
                                (albeit simple) games to learn from, a real bonus 
                                as far as this type of book is concerned. Content This 
                                is the all-important factor - content. As I've 
                                already stated, this is a big book, and it DOES 
                                make very good use of it as well. The book isn't 
                                particularly deep when it comes down to individual 
                                areas, instead it goes for a broad all-encompasing 
                                approach. This book really does cover pretty much 
                                all the bases as far as game development is concerned. Naturally, 
                                it covers all the areas of DirectX8, but surprisingly 
                                it also covers some legacy DirectDraw material, 
                                which could be of significant interest to some 
                                people. It also has a good basic coverage of Artificial 
                                Intelligence (Simulated Intelligence as the author 
                                calls it), in particular some fuzzy logic and 
                                genetic algorithms content. I think this is probably 
                                the first time I've seen an application of genetic 
                                algorithms in a pure VB context, even though it 
                                is a very simple coverage, its interesting nonetheless. 
                                The only weekness with regards to areas covered 
                                in this book is physics; I'm not very hot on physics 
                                myself, but I know how important physics is to 
                                any moderate complexity game engine, so even a 
                                basic coverage would be useful. As 
                                well as the game programming content there are 
                                some other real gems in this book. The introduction 
                                chapters really cover the ground well - discussing 
                                compilers, version differences and plenty of background 
                                history and theory - something I like alot. You 
                                could quite probably (although not advisable) 
                                pick up on the basics of this book with very little 
                                experience with the VB language (2-3 months maybe). 
                                 The 
                                book also has a chapter dedicated to code optimisation, 
                                whilst this could warrant a much larger section 
                                this goes over some really good material. Not 
                                that its revolutionary to many experience programmers, 
                                but it's perfect ammunition in the C++ vs VB wars 
                                that have a tendency to errupt every now and then 
                                (rather stupid in my opinion!); it makes a clear 
                                point - well written code can work very fast, 
                                and can make a good game. Using some basic tips 
                                and ideas you can go a long way with the language. There 
                                are some missing bits however, in particular I 
                                noticed a distinct lack of enumeration in many 
                                parts of the DirectX code, and there is no specific 
                                discussion of the topic (thus, a "newbie" 
                                to the subject may not even be aware of its existance). 
                                This in my opinion is a rather big failing - you 
                                can get a long way without enumeration, but when 
                                it comes to distributing a game/program it has 
                                a nasty tendency to bite you (hard). Even a short 
                                mention of its existance would have made me a 
                                bit happier :) The 
                                other odd thing I noticed is the rendering techniques 
                                used in the Direct3D code; whilst the method is 
                                perfectly functional (as demonstrated by working 
                                source code!), it is not a method I've ever seen 
                                used before - and not one that many people would 
                                usually use/teach. Basically, the author goes 
                                about rendering each triangle in a model (a cube 
                                for example) individually, and by wrapping pairs 
                                of triangles in class objects (CRectangle = 2 
                                triangles, the cube uses 6 "CRectangle" 
                                classes). Whilst I didn't get time to test it 
                                out, I'm guessing at a very noticable drop in 
                                speed should you implement that type of scene 
                                graph over a normal vertex buffer/array of ALL 
                                similiar pieces of geometry. It may well prove 
                                very confusing to a newbie to the world of DirectXGraphics 
                                if he/she implemented a "normal" detail 
                                game scene to find it running appallingly slow 
                                in comparison to other similiar projects. It 
                                would probably be quite advisable to use the two 
                                other books in the series dedicated to D3D/Special 
                                effects in conjunction with this book - use this 
                                book to get a basic grounding in how it works 
                                in Visual Basic, then learn it properly from one 
                                of the more advanced texts available. However, 
                                do you really want to buy 3 books to learn this?? The 
                                CD Backup The 
                                CD included with the book is of the same quality 
                                as the other books in the series - which is considerably 
                                better than many. There is a reasonable amount 
                                of trial/free software included on the CD, including 
                                the all-important DirectX8 SDK. The browser isn't 
                                the best one as far as the CD goes, but it is 
                                perfectly capable and looks pretty :) The 
                                basic software list for the CD is: Paintshop Pro 
                                7 trial, Cool Edit 200 trial (audio program), 
                                Mechwarrior 4 demo, Midtown Madness 2 demo, Motocross 
                                Madness 2 demo and Crimson Skies demo. The 4 demo's 
                                on the CD provide some entertainment value, but 
                                short of being adverts for microsoft games (yep, 
                                all by the same publisher) I dont see how they 
                                really fit into the context of the book... but 
                                well, if you're not interested in them they wont 
                                harm you in any way... In 
                                Conclusion Okay, 
                                I actually think that this book is the one the 
                                community has been waiting for. Even though I 
                                have found several flaws in it, they are far outweighed 
                                by the generally excellent coverage and content 
                                in the book. This book finally shows, in hard 
                                copy, that the Visual Basic language can, and 
                                should be taken seriously as a games/multimedia 
                                platform, sure, it aint commercial grade, but 
                                it is definitely time that it stopped being looked 
                                down upon as it has for the last 10 years!  Having 
                                been active in the community for several years 
                                now I believe that I have a good feel for how 
                                the community works, and the opinions of the general 
                                "population", and I think that this 
                                book does represent our community in the right 
                                way - and will hopefully bring new members into 
                                the fold. A 
                                quote taken from Andre LaMothe's introduction 
                                (letter from the series editor): "I never 
                                thought I would say this but the time has finally 
                                come that Visual Basic is a valid language to 
                                create high-speed 2D and 3D games", if he 
                                can come to that conclusion I think there is hope 
                                in this world for the community :) The 
                                only real issue is whether this book is advanced 
                                enough for you - I found this book to be a useful 
                                resource, with some good information in it, but 
                                I've already learnt and used pretty much everything 
                                discussed here. If you're fairly new to the scene 
                                then give this a good look over, but if you're 
                                looking for some specific coverage of key areas 
                                (in depth) then this may not be what you're looking 
                                for.  Oh, 
                                and one final note before I finish this review... 
                                the appendices include links/addresses for pretty 
                                much every VB gaming site on the planet, which 
                                is very useful indeed. BUT, why isn't my site 
                                / this site in the list, thats plain not fair 
                                (given the size and visitor throughput I'm getting!). 
                                This has happened in every single VB game programming 
                                book I've reviewed so far! I'm going to sulk 
                                now. Bottom 
                                Line: This book comes with my positive recommendation!   
                                
                                   
                                    | Good 
                                      Things | Bad 
                                      Things |   
                                    |  
                                      Well structured chapters and sections. |  
                                      Maybe too broad for some people, and will 
                                      require additional resources/research to 
                                      go much further. |   
                                    |  
                                      Very broad, covers pretty much all the bases 
                                      needed to get a foot-up into the community. |  
                                      Skips enumeration for the majority of DirectX 
                                      components - a big oversight in my opinion. |   
                                    |  
                                      Good formatting of key points, important 
                                      text etc... |  
                                      Some odd Direct3D rendering code used. |   
                                    |  
                                      Big - lots of content to read through. |  |   
                                    |  
                                      A pretty good CD with all the sample code. |  |   
                                    |  
                                      Good Appendices (except for not having my 
                                      site in the web-links list!!) |  |     |