A little while ago, I received a copy of Mobile 3D Graphics: Learning 3D Graphics with the Javaâ„¢ Micro Edition from Thomson Course Technology, a publisher of a variety of technology and graphics-related books. Being eager to delve into the subject myself and knowing that there two chapters of the book devoted to the use of Blender for mobile 3D applications, I was very interested in seeing what the author, Claus Höfele, had to offer on the subject. As it turns out, the answer is "quite a bit."
With 12 chapters and 4 appendices spanning 432 pages, this book is definitely not a light read. In fact, it is quite unique in that there are not very many books on the market right now that specifically cover 3D graphics in embedded devices. It is also not a book geared for pure novices. A strong foundation in math and in the fundamentals of object-oriented programming are essential to garnering the most utility from this book. That said, if you happen to be well-versed in Blender and interested in the more technical aspects of the 3D world, you will learn quite a bit about what goes on under the hood in nearly all 3D applications, Blender included.
Covering the Basics
The first part of the book (Chapters 1-3) serves as an overview for the concepts and tools covered throughout. Specifically, Höfele covers the Mobile 3D Graphics (M3G) API, the Java 2 Micro Edition (J2ME) programming environment, and how these things work on mobile devices, predominantly phones. You will write your obligatory "Hello world" MIDlet and learn a bit about testing and debugging your Java programs. This is quite an informative section, and very thorough. However, I think it might have been nice if he had gone into a bit more detail on developing on different platforms, particularly Macintosh and Linux. Granted, the focus of the book is more on the application environment than the programming environment, so I understand the reasoning here.
A Look Under the Hood
Chapters 4 through 8 really get into the nitty-gritty of embedded graphics programming, though, to be honest, many of the concepts and topics he covers are applicable in nearly all forms of graphics programming. There's a higher focus on optimizing/minimizing your usage of memory and processing power for embedded devices, of course, and Höfele discusses those topics at length when they are relevant. In this section, he covers rendering objects to the screen, moving them around, applying textures, simple compositing, and lighting a scene. He even gives a nice cheap environment map implementation. Again, all of this is within the context of the M3G API through Java, so being boned up on your object-oriented programming, linear algebra and coordinate systems is definitely helpful. Also, if you've ever wondered why we use quaternions for animating our rotations in Blender, Chapter 4 gives a pretty good explanation.
Advanced Topics and Blender
The last section of the book is devoted to more advanced topics such as scene graphs, the intricacies of the M3G format, and keyframed animation with objects, skinned meshes, and morph targets (shape keys in Blender). This is also the section that goes into the usage of Blender for creating graphics to be displayed on embedded devices. In particular, Höfele writes about exporting models and animations from Blender into the M3G format using an included python script. Also of particular interest are his recommendations of using the Poly Reducer script rather than the decimate modifier and the Triangles to Quads script rather than ALT+J.
The book gives a pretty good overview on using Blender and its interface, suitable for programmers wishing to get started in Blender, though perhaps not quite adequate for artists wishing to get started in embedded programming. This is forgivable, though, considering the fact that artists would presumable already be well-versed in creating 3D objects and would be reading this book more for the other parts. Chapter 12 is perhaps the most interesting chapter of the book as it walks you through creating a complete embedded program with an interactive robot animated with bones. It might have been nice to cover a bit about inverse kinematics (the robot is animated with forward kinematics only) or at least mention that IK might be too processor intensive for embedded devices. However, the coolness factor of seeing a robot that was made in Blender walking around on the screen of your mobile phone totally drowns that out. It's positively awesome.
The first 3 appendices serve as references for M3G as well as the MascotCapsule V3 and OpenGL ES API's. With the knowledge gained from the rest of the book, it's actually not too difficult to translate that to usage in other API's. Höfele does a nice job of walking you through some of the history of these API's and some potential pitfalls and differences when programming to these other interfaces. The final appendix is devoted to the contents of the included CD-ROM. This disc holds an impressive 337MB of content, including the source code to all of the samples in the book. The CD also includes a variety of tools including Blender 2.42a, Python, the Eclipse development environment, the Java Development Kit, and the M3G exporter script for Blender.
In short (too late, I know ;), I definitely recommend this book not only to people interested in learning about programming 3D graphics for embedded devices, but also for anyone who wants to learn about 3D graphics programming in general. The emphasis on embedded devices keeps the projects small and keeps the reader mindful of memory and processor resources. It also is great for artists who might wonder why their 3D tools work in seemingly peculiar ways. Not only does that help artists avoid these pitfalls, it also lets them use the tools more effectively.
Claus Höfele has done an excellent job in creating this resource for programmers and artists, and his use of Blender in his book makes it that much better. Mobile 3D Graphics: Learning 3D Graphics with the Javaâ„¢ Micro Edition is available through nearly all of the major online book retailers.