Unreal Development Kit Game Design Cookbook [Book Review]


UDK has emerged into a very powerful and complete development environment for game developers and designers. UDK is heavily rich in tools and designed to be customizable. UDK has gone through monthly increments of beta versions and each version gives you lot of feedback on the UDK integrated tool set. For designers, especially the beginners and just started designers, UDK may become cumbersome after some time. It’s because UDK’s development is very short and each iteration brings in new set feature and re-organizes these overall the development environment. Author presents this book in extension to the Unreal development Kit beginner’s guide by Richard Moore, filling in the missing pieces of puzzle. The book is a complete package of information and game developers or designers would like to read this. Guaranteed satisfaction throughout the book, and increasing throughput of developers in a serious business. The recipes presented with extra fine details to improve developing opportunities with UDK, by experimentation with the concepts presented.

The whole book has an excellent flow of topics with step by step guidance to every recipe and its effect in the environment. Advanced and core topics such as lighting, materials, visual scripting with Kismet, flash and scalerform UI, Skeleton animation and Physics asset. In short there are lots of advanced topics covered in this book as separate  chapters.

In my honest opinion this book is the first of its kind that also refers to other online tutorials, Yes! You will find the URL’s that lead to you the forums and tutorial sites to help escape from the bookish information. In addition to this, I will recommend to read the Unreal development Kit Beginner’s Guide by Richard Moore side by side.

Overall, the book gives you authentic information and is latest to this date. Get your hands on this book, grab a copy now to avail the knowledge and chance to explore the UDK in depth. This book is worth reading and suitable for returning as well as beginner designers in UDK.

Grab the copy from multiple locations, primary being Packt’s Publishing Ltd.

GPUToaster rates 10/10.

[Book Review] Android 3.0 Animations


Honeycomb enable Acer Iconia

Android is the next popular OS for current generation mobiles or more correctly the smart-phones. Smart-phones are no more a professional device. The devices have now become feature full, harbors a hard processing power, RAM, permanent storage and larger screens providing you the ease to handle day to day work. Moreover, smart phones are now slowly capturing the hearts of the gaming world. Smart phones not only provide good processing power and run-time memory, they do render a strong graphics display. Applications rich in User Interface with animations and Games utilize the underlying hardware’s full horse power to render themselves. These animations add spice to the Android applications and provide nice gesture to the user. Android Framework offers animation framework which enable android developers an ease to create custom animations and tweens.”


Android 3.0 Animations

Author Alex Shaw
Pages 304
Publisher Packt Publishing Ltd.
Rating 8/10
ISBN 978-1849515283
About the Book “Bring your Android applications to life with stunning animations” 

 About the Author

Alex Shaw has been an Android fan boy since Android 1.5 arrived, and he began developing software for it almost immediately. He has presented at DroidCon in Berlin and London, and written applications for business, academia, and pleasure. An alumnus of The University of Edinburgh, he has kept close business and social ties with the Scottish geek scene. His consulting company, Glastonbridge Software Limited, provides development resources to the Edinburgh software industry. He has written a music composing application for the platform also known as the Synthulator which uses an extensible DSP engine. Working with Dan Stowell, he helped bringing the expressive power of  the SuperCollider(more about SuperCollider servers here) server to Android, and hopes it will spearhead a new era in embedded music creation.

 About the Book

Android 3.0 Animations authored by Alex Shaw was published on November, 2011 by Packt Publishers under ISBN 978-1849515283. The book introduces you to the animation framework of the Android SDK. The book gives you a good overview of the topics such as introduction to basic animation techniques in Android 3.0, using Frame animations, Tweening and Android animators, effects of different animation properties and tweening pages, extending tween animations and creating specialized classes for tweens, 3D visual techniques such as showing depth and rotations using transformations, creating surfaces for 2D animations, creating live wallpapers and a nice theoretical chapter on good practices & style.
The book is available in ePub, Hardback and ebook format from Packt’s site. The Packt book page contains sample chapters and table of contents. Premium members are given access to the complete source code of this book. Any kind of errata info can also be found here. For more information on purchase, please visit Packt’s site.

Lets Animate!

To learn animation you must first really know how animation is done. Animation tools provide you lots of option to build your animation. The first chapter serves a great start and introduces general animation techniques that are mostly used in developing animated applications. The first few topics will introduce you to the frame animation with the help of an Android example and tweening techniques. With Honeycomb or Android 3.0, a view can be animated by changing some parameters with respect to frames. These are governed by certain entry points or the Animators. Android provides a specialized “Surface” to draw and control your frames on them to provide high performance animation. Author presents a simple example to illustrate the need of the “Surface”. Chapter ends with introduction to the 3D animation.  The source code of the examples can be downloaded from the Packt’s website.
The second chapter extends the traditional frame animation. The book presents a famous stick-man example to illustrate the technique. The whole animation can be done just by creating a XML using Android’s animation list. There are specialized XML elements which makes your animation scene drawable. The same are explained properly as expected. Animations are not only at build time, but Android makes it possible to modify them on runtime and programatically. Stuttering animations don’t look good, fading between frames makes the animation more realistic. Overall nice and simple examples are provided which are easy to follow.
Third Chapter deals with the second basic animation technique known as the Tween. Tween is something which has a start point and an endpoint. Tween’s start and end point can contain multiple translation points, which are defined by Translate XML element. There are multiple types of Tween and can be combined to create complex animations. The whole chapter explains the making of Tower of Hanoi and the block movements. The chapter later discusses and explains different kinds of animation tween’s, the order of the tween’s and an infinite tween. Half of the chapter only shows you the animation with single block. Author then switches to multiple sized blocks similar to that of Tower of Hanoi. Animation events are also discussed and gives you a nice introduction. There are different kind of interpolators that make the animations more realistic. Android makes it possible just by setting interpolator type in the layout XML. The last topic deals with these interpolators provided by Android.The next chapter focuses on animation properties and page animation. Page animation is possible using a viewflipper widget. This widget enable flipping between pages as the name suggests. Basically it gives you the ability to turn pages, i.e. you can either move forward or move backwards. Later author introduce you to the ObjectAnimators which are new to Android 3.0. Topics covered within this section shows you to the usage of ValueAnimator with an example of a bouncing ball. The chapter ends with the discussion and usage of interpolators that are used to provide a smooth rhythm too the animation just like tween interpolators.The next chapter is a continuation of the previous chapter and before jumping on to this chapter, you must read the previous one. The chapter discusses advanced animation techniques. In android 3.0 animations more than variable can be assigned animations and they can interact too perform some complex animations. This chapter presents you the multi-variable animation technique with an example of Orrery (Its a mechanical thing, reminds me of  Tomb Raider) along with animation between objects with a TypeEvaluator. In later section, author discusses applying Keyframes, fragments and different Interpolators available in android 3.0.
2D animation is not enough unless it has a depth in it. With Android animation, you can define your objects depth, sometimes known as the z-ordering. Z-axis is the third axis that is pointing inside your screen and hence providing you an illusion of depth. In this chapter, you will learn how a 3D jig-saw is made using the android.graphics API and example for Jig-saw piece swapping. Depth can provide first level of 3 Dimensional effect, but what if two object at different depth overlap each other? It won’t look realistic. Shadows bring in startling effects. The example of Jig-saw will show you how shadowing is used in android animation. Along with shadows, you will also learn about setting focus on objects and depth effects. Last topic of this chapter will introduce to the 3D rotations along individual axes, 3D transformations with Camera, etc.
In Chapter 7, high performance animation techniques with surface and game loops is discussed. These techniques are generally used in rendering game graphics. The whole chapter will show you different surface animations to create realistic bubbles. Chapter discusses SurfaceHolders, Canvas locking and unlocking, SurfaceHolder callbacks, and its life cycle. Overall chapter explains advanced techniques in simple language. This chapter is highly recommended for developers who are looking into entering gaming industries.
Chapter 8 is one of the most exciting chapter included in this book. This chapter will teach you how to create live wallpapers using android 3.0. Topics include creating wallpapers from scratch, registering with android.service. WALLPAPER_SERVICE, wallpaper service events, adding events to enable interaction with live wallpapers, using live wallpaper preferences to control wallpaper functions and storing these preferences to preserve settings. Each and every step is wonderfully explained with nice code snippets.
Android offers a number of features that can be efficiently used for developing catchy applications. Even-though the smartphones have evolved, they have limited resources and bad programming can cause extra CPU cycles and resource consumption which may drain out the battery and reduce the life. Chapter 9 focuses upon various do’s and dont’s that a developer should keep in mind while developing applications for scarce resources. The chapter is self explaining and I am glad that this chapter would prove a great eye opener for amateur programmers. Topics included in this chapter include, realization of unoptimized or excessive animation used in the application, Reducing power usage, Measuring Power usage with Tools such as PowerTutor, idetifying key areas that are power hogging, tracing the hidden or possible bugs and fixing them, etc.

The Extra Stuff

The best IDE available for Android till date is the Eclipse. Though the book source code are Eclipse compatible, author doesn’t bar you from using any other IDE. One of such excellent IDE’s is IntelliJ IDEA.
This IDE has an inbuilt support for Android and is easy to use and very light weight. You can find more about this IDE at the IntelliJ site.
Secondly, while developing with android 3.0, you will experience a significant performance slow down with the default emulator. Please do not upgrade you hardware for this. 😉 The reason behind this performance difference is the emulator uses an unoptimized OpenGL|ES implementation used for generating the catchy graphics. You can find more about this in Android developer forums. If you want to attempt yourself for improving performance then you might want to configure your android emulator to contain a 1024MB of RAM.
To further improve the performance, downgrade your screen size to smaller resolution.


  1. This book is perfect for beginners and author has maintained that approach through out this book.
  2. Learning curve is smooth. You will not regret reading this book.
  3. “One example per chapter!” This feature is consistent through out the book. A complete example is explained per chapter introducing to different concepts as you go along.
  4. Pop quiz is adequate, recalls most of the concepts.
  5. Related API calls are explained in tabular format with description and signature.
  6. Each example is compiled with a “What just happened” section to explain the working of the code.
  7. Code examples are highlighted and explained as expected.
  8. The book introduces to the game loop and 3D transformations and rotations. Some user may find it useful while planning their  career in mobile games.


  1. I completely disagree that the reader should have a previous knowledge of Android. Although the basics are not covered in this book, but author has explained the topics in such a way that a novice programmer can pick up quickly.
  2. First chapter examples and codes might confuse at first but keep in mind they are the basics.
  3. Although Android.gpraphics API is introduced but a small introduction to OpenGL|ES would have made the later topics more exciting.

Tone of the Book

Author uses a very friendly, class room type and clear unambiguous approach while teaching the reader. Author made the reading amusing with technical jokes! So enjoy reading the book.

Concluding Thoughts

Android 3.0 Animation is little late and people are already talking about Andorid 4.0. But, On the brighter side, not many smartphones carry 3.0/4.0, so the time is good to gear up with new animation techniques.

Android animation techniques add intuitive user experience and Android 3.0 inhibits re-inventing the wheels. Stunning animation is now at your fingers.

This book is recommended for developers planning to start their career in games and interactive applications. If you know Java and XML, you are good to go with android animation.

Individual rating for this book:



CONTENT* 10/10
RELEVANCE TO THE Android 3.0 Animation* 10/10
MISC FEATURE – Pop Quiz* 9.0/10

Overall Rating for the book


* higher is Better. ** Lower is better.

GPUToaster rates this book 8.0/10.

This book is available from the publishers site, Packt as well as from the major sites such as Amazon, Barnes and Nobel.

Android 3.0 Animation by Packt Publishing Ltd.

[Book Review] Xcode 4 iOS Development Beginner’s Guide


“Apple has always been covertly operating while the leaders of technology were sweating to convince the world with their inventions. On one fine day, Apple finally opened the gates to reveal a mysterious remarkable piece of technology that mesmerized the world, which never expected, which never saw, and would have never thought of. The first multi-touch fluid user-interface gesture built for the iPhone and later for the iPod. This is the same famous Apple line of portable media players which soon became the market leader after its launch. iPod was not only capable of playing music and videos, but games too. Later launch of iPhone took by storm. In 2007, Steve Jobs realized that developers could create applications that will act as native apps for these devices. The same year Apple announced the SDK for the mass developers around the world. Powered by the iOS which is derived from the Apple Mac OS X, specially designed for Apple embedded hardware, got thousands of apps in few months and later this number went to lakhs in few years. Building applications was never easier on a Mac, when XCode took the developers to the next level. XCode is a suite of tools that assist the complete nurturing of the developers and development cycle. The ‘weird looking language’, also best known as the Objective-C is in the heart of this toolset. XCode has gone 4 major version changes, latest being the 4.2. This book will take you to the roller-coaster ride of the new features of XCode 4.”


Xcode 4 iOS Development Beginner’s Guide

Author Steven F. Daniel
Pages 432
Publisher Packt Publishing Ltd.
Rating 8.5/10
ISBN 978-1849691307
About the Book “Use the powerful XCode 4 suite of tools to build applications for the iPhone and iPad from scratch”

About the Author

Steven F. Daniel has been developing desktop and web-based applications for more than 13 years for a number of companies, in various sectors. He was also a member of the SQL Server Special Interest Group (SQLSIG) and the Java Community. Daniel owns and is founder of GenieSoft Studios, a software development company based in Melbourne, Victoria, that currently develops games and business applications for the iOS, Android, and Windows platforms.

He also co-founded SoftMpire Pty Ltd., a company that focused primarily on developing business applications for the iOS and Android

Xcode 4 iOS  Development Beginner’s Guide happens to be his first effort in writing and authoring book. Before we begin exploring, being the first book, Author has shown great effort designing this book.

About the Book

‘Xcode 4 iOS  Development Beginner’s Guide’ was published in August, 2011 by Packt Publishers under the ISBN 978-1849691307. The book covers lots of necessary information to glue your hands on to the XCode Environment. The chapters includes number of topics from introducing to the tool, such as introduction to XCode4, IDE Workspace, IB or the Interface builder (UI Drag and Drop), with good examples and theory for XCode libraries, designing Apps with MVC approach, and Multi-touch. Familiarizes with developer tools i.e. debugging and inbuilt source control, and finally optimizing apps and deployment on iOS enabled devices.

The book’s web-page is maintained by the Packt Publishers. The page contains sample chapters, table of contents, and errata info. The book can be purchased in PDF and hard-back forms. Exclusive source code and resource access is only for Packt premium members. For more information on the purchase, please visit the Packt Publishers Page. The book’s preface is short, precise and gives a complete overview of the contents of the book.

Chapter Quality

First Chapter is all about introduction to the XCode and a compatible Mac version. Since the release of the iPhone in 2007 there have been large number of Apple owners and this has lured maximum developers to build application for them. If you are completely new to XCode and interested in developing applications then this chapter would be a good kick-start. To begin with XCode, author presumes that XCode 4.x is installed on a Mac machine. If you don’t have one, then you might want to skip this review and don’t buy the book! :). Mac is not like windows and won’t install on most machines unless tweaked ;). XCode is very much downloadable and free from Apple’s developer site and definitely, you want to grab a copy ASAP. As of now, there is an updated version 4.2 of XCode is available, which is only compatible with Mac OS X 10.7 Lion. However, the topics covered and explained in this book doesn’t change much. Further, this chapter gives reader a nice insight of the iOS architecture, explains how each layer is organized into frameworks, explains the Cocoa framework and Cocoa touch. There is a very short introduction to Objective-C, which is not very catchy. The chapter finally ends with overview of XCode tools and new features of version 4.

XCode 4 interface is completely different from the previous versions. Second chapter proves beneficial as it introduces the reader to various IDE workspace areas such as Navigator Area for project and files, Editing Area for writing code, Utility Area for properties, and Debugger Area and Libraries such as File Templates, code snippets and Object library. To familiarize with any environment, one needs to try it. There are few sample projects that reader can create, compile and launch (in a iPhone emulator) to get the feel of development on this environment. Later reader will explore more on the Unified navigation toolbar, workspace elements for assistance in programming, and finally setting preferences for XCode environment. Truthfully, if you have worked on any IDE such as Visual Studio (the most famous of all) or may be Netbeans/Eclipse, XCode interface won’t differ much and more or likely is similar, the only difference lies in the look and feel.

Transition to XCode 4

A good IDE makes life easier for developers and XCode is one of them. IB or the Interface Builder of XCode is a visual tool that enables the user to design an interface for devices such as iPAD and iPOD, by dragging and dropping views on to the window. This tool is comparable to any design tool that follow WYSIWYG (pronounced: Weesiwyg). Chapter 3 is all about this design tool and contains topic such as creating First GUI application with explanation of the basic application life cycle (this is must for device applications to perform better), View with Auto-rotate interface (Accelerometer input), attaching events to object for user interaction like button click and message display, repositioning controls such as on-screen keyboards that change according to the objects and orientation of the device, document based applications to view or write text, and then saving into files. The chapter is well organised, contains enough screenshots and code snippets to ensure the reader’s smooth pickup speed.

At the heart of iOS architecture, resides the Cocoa framework that provides the shared resources such as dynamic library references, image files, header files to the application whenever needed. Cocoa framework is comparable to the .NET/JRE that provides runtime references like DLL/JAR for their respective applications. Chapter 4 lists down framework names, (or the namespaces for better understanding) that are used predominantly. There are hands-on examples to create database applications that uses SQLite (data centric applications) very similar to SQL adapter classes in .NET and Java,  demo applications using AV (Audio-Video) framework for managing audio and video content,  GPS application for Geo-awareness, and lastly a task for the reader to modify existing demo application. This chapter is a good introduction to the framework namespaces and, good for programming references.

Developing iOS application requires reader to be aware of MVC architecture. Chapter 5 serves a resource for iOS MVC architecture and contains good explanation of the pattern, followed by a pizza order application where all the MVC concepts are shown as examples.   This chapter also introduces the Table-views, adding controls to the view and reposition or resize them. It also covers how to use components such as Switches, Sliders, Segmented Controls, ScrollingViews, WebViews, Controls, ScrollingViews, WebViews, Scrolling Views, Web Views, Pickers, Date Pickers, Custom Pickers using Interface Builder or IB. To control any of these view controllers, a control object is bound using outlets and actions, which is again same as any delegates, listeners , in short, events. If the user is aware of any major languages this would seem very easy. Chapter 5 would serve a good reference point for developing serious applications since it covers lots of important concepts and techniques.

Chapter 6 is more or less an extension of chapter 5. This chapter mainly focuses on interacting with users and alerting them with the application status in case of errors or some notifications. In my opinion this chapter should have been integrated with chapter 5, a separate chapter was not at all required.

Apple’s Multitouch technology by detecting finger gestures is evolutionary. In Apple devices screen is the only interface with which a user can communicate to the device application. Chapter 7 begins with a very brief explanation of the Multi-touch architecture followed by examples to attach UI events for taps, swipe to change color, and zooming effect using pinch gesture. Apple gestures can also be produced using tilting or shaking, which is governed by an on-chip accelerometer. Examples includes the shake and motion effect to detect change in motions, creating applications that can switch to landscape or portrait view depending on the device’s orientation change. The topics covered here only forms the basis of the iOS development and very much explained in beginner’s guide fashion. Do remember that the multi-touch is a hardware feature that cannot be emulated. Overall flow of the chapter is acceptable.

Writing codes without mistakes!………………that is something impossible to believe. XCode environment comes with set of tools to debug iOS application and trace them down efficiently. XCode 4 debugger has been modified to sophistically monitors the running code and reports information line-by-line. XCode contains a wide variety of debugging tools that provides assistance to the iOS developers and this chapter contains a real good explanation for each of them. Topics covered such as classic debugging, LLVM debugging to highlight erroneous lines while typing in code, the new improved in-editor debugging tools, scheme editor for device or emulator based debugging, static analyzer to scan and automatically fix syntax errors, advanced functions like detecting an memory leak, and orphaned/uninitialized objects/variables. The last two topics of this chapter is about intellisense and disable code suggestions, which are more or less editor features and should have been covered in initial chapters.

Version control is an important aspect of team development as it keeps track of the whole development process. With XCode 4.0, the version editor control is now a part of the development environment.  In Chapter 9: “Source Code Management with the Version Editor“, reader will get acquainted with the subversion systems by creating local subversion and repositories. This subversion control is almost similar to other systems such as Tortoise SVN, CVS, and the most popular Team Foundation Server. This chapter is pretty much informative and recommended for professional or serious XCode developers.

The next chapter runs the reader through inbuilt facilities that can be effectively used for measuring application performance. XCode comes with an “Instrument” which can be used to collect information about the application over time. Topics include introduction to the Instrument tool, designing an application to use this tool and profiling it, adding and configuring instruments for trace, and new instruments in XCode 4. As the new instruments are little advanced topic, beginner’s guide wont suffice and author has only provided very little information about each instrument, which is understandable.

Last chapter deals with deployment of application to the app store. Author has provided good amount of steps from getting iTunes premium membership to uploading the application to the Apple app store.


  1. Very smooth flow and transition of topics from basic to advanced.
  2. Quite impressive usage of informative (Usage of arrows and boxes to highlight areas of an image) images and codes through out the book.
  3. Every example is explained in step by step manner following the beginner’s approach, followed by a detail information in “What just happened” section.
  4. While explaining a feature, author has compared XCode  to other analogous development environments.
  5. References and links are provided wherever required keeping the context clean and unambiguous.
  6. Excellently providing useful introduction to OOPS, MVC Architecture, and accelerometers or gyroscope.


  1. “Pop Quiz” section is poorly designed and not at all impressive.
  2. There are certain chapters that have been presented separately, which was basically not required.
  3. Intellisense and preferences topics in chapter 7 are misplaced.

Language and Tone

Author has used class room approach to convey the working behind each concept with the usage of simple words without exaggerating the topics.

Concluding Words

Making iOS apps on Mac was never so easier, thanks to Apple’s extensive R&D on XCode development environment, and with version 4.0 comes a whole new package of feature set. Daniel’s first attempt to author this book is amazing and would be a good start for beginner’s. I found the book very, informative, and simple to follow. If you are experienced in one or more IDE’s, then this book would be very lucid.

Some part of the code snippets mentioned in the book may confuse at times, make sure you have the source code with you, available at Packt’s site. iOS development requires you to be acquainted with Objective-C. Unfortunately, this book won’t teach you Objective-C, as it requires a dedicated book. For learning objective-c language grab Programming in Objective-C by Stephen G. Kochan.

Finally, this book is a nice informative book for XCode 4 IDE only. There are other useful resources at Apple’s developer site which will be a helpful reference while reading this book.

Here are the individual ratings of each component that I chose to review this title:



CONTENT* 10/10
MISC FEATURE – Pop Quiz* 8/10

Overall Rating for the book


* higher is Better. ** Lower is better.

GPUToaster rates this book 8.5/10.

This book is available from the publishers site, Packt as well as from the major sites such as AmazonBarnes and Nobel.

Xcode 4 iOS Development Beginner's Guide

Xcode 4 iOS Development Beginner's Guide Full-fills most of the expectations, recommended reading for beginner's.

[Book Review] OpenGL 4.0 Shading Language Cookbook

Heaven Benchmark - OpenGL Rendering Mode

“Modern hardware’s have completely superseded the fixed functionality (FFP) with programmability in complex graphics processing areas such as vertex, fragment and geometry processing. The Shading Language has been designed to allow application programmers to take control of this pipeline (GPU Rendering Pipeline) to produce desired results. In graphics processing hardware terms these independently compilable units are called shader units, and the language is known as the Shading Language. Shader program is a set of two or more shaders that are compiled and linked together. Shaders are part of major graphics API as such as DirectX and OpenGL. The OpenGL Shading Language, widely known as GLSL as defined by the ARB of OpenGL, is based on ANSI C that is capable of doing vector and matrix operations, typical operations in 3D graphics. Shaders are a hot topic and 3D game developers/researchers have shown that they can be put into some powerful use to produce remarkable scene effects and with increased performance. Shaders were widely used in GPGPU early to CUDA and OpenCL as they are capable of accessing GPU processing power. OpenGL 4.00 is the latest major revision, announced on March, 2011 to give a hard competition to DirectX 11 providing extensions for geometry tessellation, 64-bit double precision float point, addition of Sampler objects, instanced arrays and timer query. This book presents these topics with nice examples and in-depth explanation.”


OpenGL 4.0 Shading Language Cookbook

Author David Wolff
Pages 340
Publisher Packt Publishing Ltd.
Rating 9.5/10
ISBN 978-1849514767
About the Book “Over 60 highly focused, practical recipes to maximize your use of the OpenGL Shading Language”

The Author

David Wolff is an associate professor in the Computer Science and Computer Engineering Department at Pacific Lutheran University (PLU). He received his PhD in Physics from Oregon State University. He has a passion for computer graphics and the intersection between art and science. He has been teaching computer graphics to undergraduates at PLU for over 10 years, using OpenGL. (This information has been taken directly from the book)

At RateMyProfessor.com, Prof. David Wolff has been rated a 4 out of 5 and the following comments has been given by the students:

“Comment 1: Intro to Computer Graphics focuses on RealTime graphics using openGL. This is Wolff’s area of expertise & a GREAT class to take from him. His passion shows through in the class. If you’re interested in 3D graphics or realtime sim this is a great class. Linear Algebra is a pre-req but basic knowledge of vector and matrix math is really what is key

Comment 2: Prof. Wolffe is the coolest. very clear concrete examples, and clear work expectations. If you’re willing to do a little work, then you will be rewarded for it in spades….”

Unfortunately, the book contains only small intro about David Wolff and not much information is available on the internet. I will probably do a nasty Google scan and update this section at the later time. 🙂

Brief Introduction

‘OpenGL 4.0 Shading Language Cookbook’ was published in July, 2011 by Packt Publishers under the ISBN 978-1849514767. The book covers OpenGL Shading Language core profile 4 and its coupling with the modern hardware, especially, NVIDIA GeForce 400 & 500 series and ATI Radeon HD 5000 & 6000 series. The chapters included are on choosing libraries for GLSL programming, the basic shading technique, Lighting, Shading Effects, and optimizations, using textures in GLSL, image processing and screen spacing techniques, Using geometry and Tessellation shaders, rendering advanced shadows with AA and Ambient occlusion, Noise effect with shaders and animation & particles. The book’s web-page is maintained by the Packt Publishers. The page contains sample chapters, table of contents, and errata info. The book can be purchased in PDF and hard-back forms. Exclusive source code and resource access is only for Packt premium members. For more information on the purchase, please visit the Packt Publishers Page. The book’s preface is short, precise and gives an ultimate overview of the contents of the book. The preface mentions the conventions used in the book.

Not for every living creature…

Caution! GLSL is an advanced topic. Author presumes that you understand 3D and its operations such as 3D transformation, normalizations, coordinate systems and projections at a primitive level.

GPUToaster mandates that the reader is aware of GPU technologies, brief understanding of major Graphics API such as DirectX and OpenGL, Basic OpenGL programming (at the least hands-on with OpenGL FFP), understanding of GPU pipeline processors such as fragment and vertex shaders or the Unified Shader Architecture, must know different OpenGL versions and extensions, must be hands-on with one IDE such as Visual Studio (as the visual studio is the major developing environment) and setting programming environment with GLSL such as linking DLL’s and libraries, must know basic C/C++ programming, must have a NVIDIA (400/500 Series)/AMD ATI adeon (HD 5000/6000 series) GPU installed either in single or SLI/Crossfire mode, Must know specific driver versions that will expose the GLSL extensions and has installed the same (For specific driver version kindly ID your GPU and search on the respective GPU vendor site), and last but not the least – a great passion for 3D programming. It also recommended that the reader understands and ready to solve Mathematics.

Considering you have set up the proper environment either on Windows / Linux/ Mac, you are good to go further and discover the GLSL 4.0 core profile.

Chapter Tour

Considering that you are all set to get dirty with GLSL, the first chapter gives an excellent introduction to the OpenGL Shading language, Core profile compatibility with new hardware architectures, explains the deprecation model that started from core profile 3.0. The chapter gives you a complete insight on the GLEW and GLM libraries that are used to access the GL extensions and core mathematical support designed especially for GLSL respectively. Good examples are given to integrate GLM in your program. Furthermore, author takes you to the in-depth step-by-step tour of how GLSL programs work, which includes writing vertex and fragment shaders, determining GLSL version, compiling the shader, linking the shader and finally deleting the context. This chapter also explains VBO to send the data for processing per vertex with a complete program, uniform variables for infrequently changing data that are suited for transformations and projections. The overall chapter has a smooth transition from topic to topic. I observed no jump; author has been focusing on the chapter’s objective to briefly introduce the GLSL and its programming techniques. Readers will find this chapter a bit time-consuming for the first time, but believe me this chapter is a must-read for GLSL beginners.

The second chapter starts with showing the complete architectural working of Vertex and Fragment shader pipelines of OpenGL. The near most exclusive content includes the replication of the FF using GLSL 4.0. The chapter covers the standard ambient, diffuse, and specular (ADS/Phong) shading algorithm, the implementation of two-sided rendering, and flat shading along with the functions, subroutines and use of discard keyword to generate an effect where the fragment shaders are haulted for writing onto buffer. This chapter is designed for those who are beginners with GLSL (assuming OpenGL previous experience) and also those who have previously worked on previous GLSL profiles. The chapter present’s algorithms to form the basis of the GLSL programming. For the new learners, this is the perfectly recommended chapter. Additionally, the new learners are presented with mathematical explanations and beautifully narrating the effects using highly detailed schematic diagrams before presenting the program to avoid confusion.

The following chapter introduces the reader to produce shading effects such as spotlights, fogs, cartoon style shading, multiple light sources, realistic effect with per-fragment shading, shading efficiency improvement using half-way vectors and directional light sources. The chapter actually extends the previous chapter with advanced techniques and emphases on lighting optimizations. Author has also presented the allowed constants for desired effects in a tabular form. The values and its effects are presented in a tabular form for good understandability. This chapter is recommended too for the GLSL beginners. In short, both the chapters are perfectly designed for the GLSL beginners. These chapters are guaranteed to provide ultimate satisfaction to the readers, especially GLSL beginners. Author uses the same approach that has been followed in the previous chapter.

The fourth chapter shows the importance of textures and how shader opens a huge range of possibilities with shading parameters, displacement maps, normal vectors, or other vertex data. The chapter starts with basic application of 2D color textures via sampler variables, alpha maps for transparency (emphasis on discard keyword), normal maps for creating bumps and wrinkles to the texture (or the faking technique), reflections and refractions with cube maps, technique of image based lighting, texture projection on 3D objects and RTT. The chapter contains full of important techniques that are frequently used in games and designing game engines.

The fifth chapter focuses on the image processing such as edge detection, Gaussian blur, bloom effect, gamma correction and screen space techniques such as MSAA & deferred shading. This is an exclusive chapter that is prepared for both games and computer vision field.

Geometry and Tessellation Shaders are the two new additions to the OpenGL API and hence the 4.0 profile. The chapter starts by explaining the extended shader pipeline that is specific to the newer hardware with full ‘4.0’ support. The chapter covers point sprites with geometry shader, drawing a wireframe and silhouette lines on a shaded mesh, Tessellating a Curve (Bezier Curve), 2D Quad, 3D Surface, and Tessellation based on depth. Chapter 6 is one more interesting chapter that begins with new topics gradually by giving the reader the simplest examples first and then moving to the more advanced concepts.

Realism is achieved with detailed scene effects and the shadows. With shadows, the overall lighting looks realistic. The chapter shows recipes for shadow mapping, Anti-Aliased shadows with PCF (Percentage closer filtering), soft shadows with random sampling, prebaked AO.

Sometimes too smooth surfaces produce unrealistic effects; introducing noise to the surfaces can simulate the imperfections of real surfaces. Chapter 8 deals with various ‘Noise’ introduction methods such as using ‘libnoise’ library (such as Perlin Noise), and using noise textures. Using these techniques readers will be able to learn how to create cloud like effect, wood grain effect, disintegration effect, paint spatter, and night-vision effect.

As shaders provide access to the GPU’s massively parallel architecture, they can be used for vertex transformations in the animations. Chapter 9 (Final Chapter) makes use of the ‘transform feedback’ feature that got introduced with OpenGL 3.2. The recipes include animating a surface with vertex displacement, Particle fountain, particle system with transform feedback and using instanced particles, fire particles, and finally smoke particles.


  1. Excellent introduction to GLSL programs.
  2. Clear and verbose explanation of code throughout the book.
  3. Flow charts are included for representing the effect.
  4. Algorithms presented by the author are very detailed.
  5. Very consistent flow of the GLSL techniques and the author has achieved a pure cookbook style of description.
  6. The author has presented outstanding and impressive content within second and third chapters (Advantageous for GLSL Beginners).
  7. All topics are outrageously well-researched and designed for a cookbook.
  8. Every shader example is explained in great details in “How to do it,” “How it works” and “There is more” sections. Linking topics have been mentioned in “See Also” section right, after “There is more” section.


  1. Programs included with this book are completely in QT.

Tone of the Book

The author shows his expertise not only with the content of this book but the highly professional explanation of the topics with clear distinction of theory and application.

The Final Verdict

Graphics hardware has emerged dramatically advanced and continues to do so. OpenGL shading language is the first (& only) cross platform open standard designed language and is the industry standard. With OpenGL and GLSL, applications perform better, achieving stunning graphics effects by using the capabilities of both the visual processing unit and the central processing unit. The book is designed for both beginners and experienced developers and artists. I have read OpenGL shading language books before by Randy Rost, and believe me this book is one of its kind. Author is veteran in the computer graphics field, and the content of the book is exactly what today’s GLSL developers need i.e. the GLSL capability, changing Modern GPU’s, closeness to natural phenomenon and real-life industry-standard applications.

Author has displayed his efforts in a pure cookbook style suitable for a variety of audience with graphics background. However, the source code included with this book is presented purely in QT. But reader need not worry as the GLSL code is completely separated out from the rendering code. I will try to present Visual Studio solutions that can be downloaded from the GPUToaster Download Area. Keep an eye on that section for updates.
Additionally, I would recommend you to refer GLSL specification, online GLSL tutorials and algorithm research papers for improved understanding.

Recommended reading : Ozone3D.net. Download GeeXLab 0.3 (a GLSL Tool)

To rate this book, I have compiled final rating depending on the following components:



CONTENT* 10/10
RELEVANCE TO THE OpenGL Shading Language* 10/10

Overall Rating for the book


* higher is Better. ** Lower is better.

GPUToaster Rates this book 9.5/10.

OpenGL 4.0 Shading Language Cookbook

"Go Ahead" and "Buy", Meets all expectations!

[Book Review] Unreal Development Kit 3 – Beginner’s Guide

Exclusive Post

Double kill! Multi kill! Mega Kill! ULTRA KILL!!! M-M-M-MONSTER KILL! With LUDACRIS KILL! And H O L Y S H I T! Coming after Monster Kill (or Killing Spree)” – These phrases from Unreal Tournament, from the “UT announcer-The god of the Arena!”, which was used as awards for getting 6 or more kills in a short amount of time without dying/spawning. Unreal Tournament (UT) was one of the most advanced multi-shooter FPS game released after the Quake, which was essentially designed for death-matches. UT is extremely known for its bot AI. In the year 1996, Quake was the first game to announce the online death-match game mode but then UT took the whole gaming experience to the next level with its AI and graphics. Powered by the world’s best game engine, Unreal tournament emerged as a successful arena game that scored an average review of 94%. Tim Sweeny, the architect of the Unreal Engine, started developing games in his parent’s basement with ZZT which drove the early growth of the company known as the EPIC Games. UDK is the most successful game engine that has survived this massively emerging 3D technology. Today Unreal Engine is a tough competitor to the top industry game engines. It features an unmatched flexible and modular architecture that most of the Game Engines lack as a whole. The game engine not only provides fantastic real life and a natural scenic effect, Unreal Engine also extends its support to the select SoC’s (System-on-Chip) such as the iPhone, iPad and iPod.


Unreal Development Kit 3-Beginner’s Guide

Author Richard J. Moore
Pages 244
Publisher Packt Publishing Ltd.
Rating 6/10
ISBN 978-1849690522
About the Book “A fun, quick, step-by-step guide to level design and creating your own game world”

“Unreal Development Kit 3 Beginners Guide” is the first edition that primarily focuses on the UDK 3.0. The book was published by Packt Publishers on August 2011. The guide introduces to the UDK 3.0 environment with topics chosen with a great taste. The topics include Level Design, UDK environment navigation and menu system, Lighting effects, UDK basic game elements, animating the game elements, Terrain, Game play elements, Events and flow graphs and Materials.

The book’s web-page is maintained by the Packt Publishers. The page contains sample chapters, table of contents, and errata info. The book can be purchased in PDF and hard-back forms. For more information on the purchase, please visit the Packt Publishers Page.

The Author

Author Richard J. Moore, graduated from the Hull school of art and design, as a video game designer. He has worked on projects extending his creativity by designing web templates, logos, brochures, business cards, web banners, animated graphics, and e-mail marketing campaigns. In 3D art, his passion includes creating and designing environments, texturing and high resolution rendering, and conceptual drawings. The Author showcased his work and secured a position in top three during the Platform Expo’s 2011 – Hulls video game expo. At leisure, he reviews games for an online magazine. Author has a strong belief that 2011 is the start of the new era for game designers. Lastly, he possess extensive experience in designing 3D environments with UDK.

The Book and the UDK

The book starts with a clear UDK introduction and the installation. Book’s preface is adequate for setting up the PC/system with good detailed system requirements to run UDK as expected. The preface also mentions the conventions that are used in the book chapters. Author has not mentioned any specific version of the UDK being used. For UDK beginners, please remember that 3.0 in UDK is the major iteration of the Unreal Engine and the UDK. UDK thereafter has been entered into the Beta release channel. Each specific beta version is stamped with the month name. Mostly, the releases will have same basic functionality. For this book review, August’s release was used, which incorporates few significant changes. If you are a core designer or you are planning to develop commercial games, then you must use the 64-bit version of the editor as 64-bit will enable developing of game levels with huge number of textures. This is possible as 64-bit is capable of addressing memory more than 4 GB. UDK also supports in-editor DirectX 11 for newer GPUs.

Unreal Engine has powered more than 50 games, until now and more releases are planned for future. This is the same Toolset that has powered some of the all-time-hit games Gears of War, Infinity Blade, Medal Of Honor, Batman : Arkham City, Bioshock and Mass Effect. Even the upcoming Frostbite Engine is based on the Unreal Engine 3 which has powered the Medal Of Honor 2010 and Battlefield 3 (Released this month).

UDK Powered List of Games [Complete]

Unreal Development Environment
Infinity blafe for iOS
Unreal Tournament
Unreal Engine Rendering Exteriors and complex environment geometry

Before you start…

Author expects no previous experience on level designing. The book is purely designed for aspiring game developers so that they could create their own game levels, maps, worlds, and environments. Furthermore, if you are completely new to the 3D technology author welcomes you to learn this awesome tool.

Chapter Tour

The book starts with introducing the UDK 3.0 and helps in setting up the development environment as expected. As mentioned in the previous section, there is no specific beta version specified. It’s definitely a good idea to download the latest beta version so that you are in sync with the UDK technology and stable updates. The first chapter is a must-read chapter for novice readers as it contains vital information to use UDK appropriately. Author follows a very tender approach in explaining the UDK folder structure and then by switching to the UDK UI environment. This chapter introduces to the Content Browser or the asset browser which is the heart of the UDK. There is a small but enough info on BSP brushes, which are largely used in the games for performance and other in-built geometry/brush builder. It also introduces to the UDK viewports that are used for visualizing the scene from four common angles. If you are familiar with 3DS Max/Maya/XSI environment, then UDK environment is nothing new except UDK specific window options.

The second chapter takes the reader to the UDK viewports for action. A very good explanation for creating CSG (Constructive Solid Geometry) which allows you to create complex geometry often can be seen in CAD applications. Author has given exact steps with screenshots to assist the reader for performing drawing operations. This chapter is little interesting as author lets you use the builder brush to create rooms, placing lights, player spawn point, a hallway to connect second room and finally applying textures and materials, adding bots to the level using the in-game command line. This requires some manual work, which may be time – consuming and the brush tool may not be handy for the first time. While following the chapters, novice readers may find certain screen shots misleading as there are changes in the newer versions. If the reader encounters any kind of uncertainty in following the tutorials, it is recommended to refer an online resource or a video tutorial or use Unreal forum to answer your queries. Rest of the chapter will be a fun that is definitely assured.

UDK uses different lighting mechanisms to render as light maps for CSG surfaces and static meshes to reflect light of objects. This chapter is quite interesting as the reader will learn UDK light component properties that are tactically used in commercial games to produce realistic effects. UDK allows you to create and add as many lights you want to. Note that, too many lights may hamper the overall level performance. Since dynamically lighting the environment causes a performance drop as the engine constantly calculates the lighting functions. To overcome this issue UDK features something known as the Unreal Lightmass (Swarm Agent), which is the high-quality static global illumination solver in Unreal Engine 3 and is one of the utilities in UDK with extreme computational needs. Even on an 8-core system, rebuilding lighting for a large or complex level can take enough time that iteration performance can suffer. Keeping user aware of this tool is necessary because this application will keep on popping up when a build action happens. Unfortunately, Author has failed to provide this information. In layman’s term, the swarm agent simply bakes the lighting effects into the map as material rather than calculating it dynamically. These materials are then stored in the level map package.

Chapter 4 shows the reader to how to use the inbuilt particle editor and other effects such as Fog, water, height, etc. The chapter begins with an in-depth and clear introduction of the particle tool. In this chapter, the first particle effect presents the smoke effect tutorial. New users may find it difficult to follow the flow graph which is used to create the initial material for the particle. For instance, a node labeled as ‘2’ is a constant node and a value of 2 is assigned to it. Importing and assigning textures is another confusing operation. It is recommended to use the content browser for importing textures and then by selecting the texture which was just imported, & then add a texture node by right clicking in the flow-graph area. As there is no resource files available for smoke in new UDK 3.0 updates, reader may have to download textures from the internet or download it from the GPUToaster Resource area. Later in this chapter, there is a brief info to add fogs and creating surfaces. One more interesting part of this chapter is to add a water volume and then make it swimmable.

Chapter 5 provides guidance in adding animation to the objects which are imported into the map. The tutorials include basic and UT style elevator/door animation, continuous looping and rotating animation and attaching an object to other objects. The whole animation is governed by the flow-graphs. These flow-graphs can be created and accessed by opening the Unreal Kismet. Kismet is a gameplay scripting tool for the Unreal Engine 3. It enables level designers to create scripts in Unreal Script for gameplay events using a visual interface. This chapter is a satisfying chapter as it introduces how the flow graphs work with the map elements. The explanation is gradual, clear and author has not jumped between the topics.

The next chapter takes the reader out to the open world – Terrain. The chapter will show how to create a terrain and add material and lighting to it. It also gives a very brief intro to the terrain brush tool. The chapter topics are well defined but unfortunately, the information presented here is not adequate enough.

The following chapters bring in the most enthralling stuff. This chapter will let you add Unreal Tournament game elements that are already present in the UDK package, to the level so far you have designed. These include map naming convention (UDK recognizes these conventions and sets prerequisites for the map), Player and bot spawn point, pickups such as health vial, weapons and weapon factory, jump pads, teleporters, adding flag base, vehicle factory, assigning paths to bot for AI and bot discovery. At the end, the level will be completely playable in UT style. Cut scenes (using movable cameras and define paths) and text notifications are also vital part of the game level designing. With UT event designer – Kismet, the job becomes easy. It uses the flow graphs to extend the node functionality. The chapter gives a good outline over the flow graph controls for basic construction of the scenes. UDK Kismet supports thousands of visual scripting nodes, which have not been covered such as adding Physics, Custom Shaders, etc. This is understandable as UT kismet alone requires a complete cookbook.

The final chapter deals with the Materials for the game environment. This chapter covers all the aspects of creating a material from a texture, adding metal effect, normal maps, specular highlights to the material. This is done using the UDK material editor. Once the material is created, the effects can be attached using flow graphs. Do not get confused between material flow graphs and Kismet, as UDK scripting is a very powerful tool that enables a developer to customize every element in the environment.

The Appendix of the book contains the quiz answers.


  1. The topics covered in this book are well chosen for a complete in-depth focus on the Unreal Engine and the development environment.
  2. The book contains adequate screenshots for explaining the topics.
  3. The most statements in the book follow point approach rather than a theory/paragraph approach. This allows a smooth transition of tutorial steps without mixing one another.
  4. Flow of the book is designed keeping the beginners approach in mind.
  5. Explanation of every example is given in a different section which is docked at the end of each topic. This helps explain the whole process that the reader has just performed in the UDK.


  1. Chapter 4, 5, and 6 are poorly designed and encompasses inadequate information that was least expected. It is recommended to follow UDK training sites such as 3dmotive.com, which will help assist learning and development.
  2. At the end of each topic there is a “Quiz”. I found the quiz questions very predictive, easy and short. Some chapters contain only a single question. Expecting an exclusive content in future edition.
  3. In the “Applying lighting Effect” chapter, there are certain parameters that are not explained properly. Novice readers may find this difficult to figure out. For example, light functions(Explanation: Which are mathematical representations of how lights illuminate the scene). To find more about component parameters, there is a very extensive description on the UDK tutorial site.
  4. While explaining flow graphs, every single important node should have been explained with a real-life example. Reader may get confused while adding a ‘Lerp’ to the flow graph, which actually means Linear Interpolation.
  5. The topic “Foliage layers” is confusing and placement of this topic seems to be context-less.
  6. Terrain chapter should have been in more details. This chapter lacks important contents such as adding vegetation and mountain, Rain effect, ambient lighting, night effect or time of the day.
  7. Chapter 8 explains deprecated feature – UIScenes (The old UI) that has been removed long back and has been replaced by Scaleform advanced UI system.

    Sacleform UI for UDK

  8. The second most essential chapter “Material” is the last chapter. In my opinion, this chapter should have been placed before digging into the flow-graphs.

Tone of the Book

The tone of the book is quite open and communicates you in a class-room style manner. The explanation of the book energizes the reader to explore the UDK more and more.

The Final Verdict

Unreal Engine and UDK have come a long way and has emerged as a very successful game engine technology. UDK is one the most flexible engine where the developers can integrate lots of third party API’s to make their game better in every sense. This guide will introduce and glue your hands on UDK environment since the Author, Richard J. Moore has chosen great topics for this edition, and the chapter flow is completely designed in a “Beginner’s guide” way. With little R&D and patience, I could create a level just like Unreal Tournament Deathmatch level, reminded me of my early days. Watch this video:

Unfortunately, author has failed to provide certain necessary information vital to the feature discussion. Because of some unexplained content, the book may create additional confusion.

The book requires a total revamp as there are certain things presumed to be done by the reader. Besides author explains few topics that do not fully comply with the UDK’s actual working.

To learn UDK, I would suggest you to read blogs, watch online tutorials and UDK site itself for improved understanding. I have compiled a final rating based on the following table:






* higher is Better. ** Lower is better.

GPUToaster rates this book 6/10.

Unreal Development Kit 3 - Beginner's Guide

This book is available from the publishers site, Packt as well as from all major sites such as AmazonBarnes and Nobel.

Unreal Development Kit 3 - Beginner's Guide does not fully meet GPUToaster's expectation.