This is Cyberpunk: TECHNOLUST Kickstarter Campaign Live

technolustNow this is my kind of game: a cyberpunk first-person adventure set in a dystopian future. Native Oculus Rift support. A NSFW TRON poster (though I bet they will take that out). This just looks too awesome for words. I backed the Kickstarter for $50 bucks, but I’m willing to up the ante later in the campaign if necessary. Really anyone with an Oculus Rift, or that plans to buy a Rift, should throw some money down on this project. Of all the things I’ve played in VR, I think this is my favorite. And I’ve played a LOT. Get on this.

Review: OGRE 3D 1.7 Application Development Cookbook

OGRE Cookbook

OGRE 3D 1.7 Application Development Cookbook by Ilya Grinblat & Alex Peterson was, I guess, what it advertised itself as; a quick cookbook of recipes using OGRE. What is was not was a good inspection of the OGRE engine itself. Really what the book amounted to was a series of short chapters, each tackling a specific programming problem. While there is nothing wrong with that, I felt like the book did not dig deep enough into the actual OGRE software and instead focused on other libraries or APIs you could combine with OGRE.

First of all, this book was heavy into MFC; nearly every chapter relied on it. I am not going to open a debate about MFC as I’m sure it will be heated. What I will say is that MFC is not supported on the free versions of Visual Studio (which is what I use) and obviously won’t work on Linux or Mac, or on mobile platforms, etc. It seems very short-sighted, and somewhat ugly, to take a great cross-platform, open-source tool and then marry it to Microsoft’s proprietary API. This also restricts the user-base significantly as now only Windows users with professional versions of Visual Studio can even run any of the samples. Huge loss here.

Aside from the MFC issue, there are actually some interesting tidbits found in the text. They show how to do basic mouse and keyboard input and move onto voice input and text-to-speech. There’s coverage of creating manual objects and using billboards, working with XML files, using lights and particle effects, scripted movement, animation, some effects like mirrors and video textures, and manipulating objects. So, yes, it does discuss a lot of key topics when working with OGRE, and from a cursory look this would seem just like what a beginner to the engine would need. However, I think the instruction would have been a lot better had they not relied on MFC.

Overall not a particularly long book, and the price was not bad for the Kindle e-book. Seeing as there are not very many books dedicated the OGRE, this is probably still worth getting if you are exploring the engine. That said, the other OGRE books I’ve read were much stronger in terms of actually focusing on the engine API itself and in a cross-platform manner.

Review: Learning C# by Developing Games with Unity 3D Beginner’s Guide

Learning C# with Unity

Honestly I’m not sure why I bothered with this book. It’s not that it was a bad read per se, but it’s really for stark beginners. Learning C# by Developing Games with Unity 3D by Terry Norton is really for people that have little or no experience with programming. Meaning if you don’t know what a ‘variable’ or a ‘method’ is then this book will probably be helpful. It’s really intended for artists using Unity who want to add some scripting skill to their knowledge. If you are already a capable programmer (in C# or not) then this book will probably not be that helpful.

Personally I’ve been programming in many languages for years, however I’ve only really dabbled with C#. So I figured this book could be a good refresher. Unfortunately it is on such a basic level that it doesn’t really cover the features that make C# unique. If you have any programming experience the text will seem remedial. Some of the topics in the book include: variables, functions/methods, classes, and dot syntax. The main example project covers creating a state machine to handle switching between different screens. In actuality, this is a good introduction to programming though it doesn’t teach you nearly enough to be able to start creating a complete game in Unity. However, it is called a ‘beginner’s guide’ so it’s not like it was mislabeled.

Learning C# by Developing Games with Unity 3D comes in at just under 300 pages, so it is not a long read. I think I finished it up in less than a week. So I’m not terribly upset about taking my time to check this out. To the book’s credit, I did learn one new trick: how to have a component act as a singleton, so I did gain something. I do think if you are an artist with no previous programming knowledge, this could be a great intro into the field. However, to get anything serious done you will still need some other books to take you to the next level. Overall not a bad book, but if you’ve already be coding for any period of time you can probably skip it.

Review: Blender Foundations: The Essential Guide to Learning Blender 2.6

Blender Foundations

Blender Foundations: The Essential Guide to Learning Blender 2.6 by Roland Hess is one book I purchased nearly 2 years ago, started and never finished reading. Finally I decided to go back and finish it, as it’s been bugging me for a while. I have to say, this is a fine piece of text. It really takes you from knowing nothing about the software, to feeling somewhat knowledgeable on the topic.

The book is not especially long at around 400 pages, but there is a good amount of information between the covers. It goes over the basics of modeling with Blender, all the important hot-keys, basic navigation, and all that. The scene you create is not super fancy, but includes a lot of good stuff: handling different materials, lighting and shadowing, glass rendering, cloth and soft-body physics, character animation, etc. Some of the basic items are created from scratch (like a table and chair) however the character model is given to you later in the book. Still not maybe *everything* you could possibly know about Blender, but it does say “Foundation” and “Essential” in the title, and I feel it lives up to the name.

In terms of Blender itself, after reading the book and going through many of the exercises, I have a new-found respect for the software. Initially I expected it to be a cheap (well, free) version of Max or Maya, but I think it can stand on it’s own. While I mostly learned Maya in school, it never felt quite natural to me and I always seemed to favor 3DS Max. Since spending more time working with Blender and learning the hot-keys it seems like a really capable package. It might even like it better then the big guys. Sure, it may not have all the bells and whistles of something like Maya, but that doesn’t mean you still can’t accomplish some amazing things with the program. And, of course, it’s free and open-source which counts for a lot.

Overall I liked the book and the author’s writing style and think it’s a great introduction to a powerful piece of software.

Review: Game Engine Design and Implementation by Alan Thorn

Game Engine Design

Alan Thorn’s Game Engine Design and Implementation was quite an interesting read. Overall I thought it was good, but the book struggles at times to find it’s audience. On one hand, it covers a lot of great topics and there are some good code snippets to be found. On the other hand, it seems to jump around between APIs and frameworks and never really culminates with a complete engine. Even so, engine development is no breeze and any help in this area is much appreciated.

The text begins with the basics: downloading Visual Studio or Code::Blocks and configuring a development environment. It shows you how to create and call a DLL. Some brief coverage of the STL. All useful stuff. Then it moves on to some basic engine features, like logging errors and handling exceptions. Again a great place to start. It continues with a resource manager based on XML. Then a 2D scene manager and renderer using SDL. Supporting sound and music with the BASS library. Processing input with OIS. Then a renderer with DirectX 10. Great stuff. Then in the next chapter it throws out everything you just learned and jumps to working with OGRE. Don’t get me wrong, OGRE is a great API. But it seems strange for a book titled “Game Engine Design and Implementation” to use an off-the-shelf library and not code the, erm, implementation themselves. The book follows up with coverage of Bullet physics and ends with a brief overview of DX Studio, which is an all-in-one game engine solution.

While each chapter alone is very interesting and informative, I feel like the book as a whole lost it’s focus somewhere and the engine that you think you are creating at the beginning of the book never materializes. I almost feel bad, it’s like the author started with one premise of creating an engine from scratch, and then gives up half-way. I even agree that using pre-built tools are a good idea in many cases, and most people don’t want to re-invent SDL or OGRE or whatever. But there are other books that focus on these engines and frameworks. People picking up a book like “Game Engine Design and Implementation” probably are more interested in rolling their own engine.

That said, I still feel like the book was a worthwhile read and I did learn a little bit about some stuff and found it useful. Going in I had read the reviews on Amazon, and I knew the author was going to jump around with different libraries. Had I not known this I may have been more upset. As is, Alan Thorn is a competent writer and clearly knows a thing or two about game engines. I guess I just wish there was more of a focus on creating something cohesive and original and not just a jumble of introductions into different APIs. However, if you are on a journey (like me) of creating a 3D game engine you will need as much ammo has possible and this book certainly has a place in the arsenal. Just not the first place.

Innovative Augmented & Virtual Reality Glasses on Kickstarter

cast_ar

Looks like the VR/AR crowd-funding freight-train is not slowing down one bit. The latest success story being castAR, a set of stereo 3D augmented reality glasses from ex-Valve engineers. At first I was not all that excited about the project, seeing as I am more of a VR buff than for AR. However, this project looks too interesting to pass up.

Basically the device is based around a set of active-shutter 3D glasses. The trick is that instead of looking at a monitor, there are dual 720P projectors mounted on the frames which project the images onto a surface. This surface happens to be a retro-reflective canvas, basically bouncing the images straight back to your eyes. Combined with head-tracking, the glasses can provide a realistic 3D sandbox in which to play in.

Even better, there will be AR/VR clip-ons that allow for a more traditional head-mounted experience. They claim the VR model will have a 90 degree field of view, which actually sounds pretty good (if maybe still a bit shy of the Rift). It all sounds very ambitious, but really amazing if they pull this off right. I’ve backed it.

Review: More Effective C++

MoreEffectiveC

I decided to break from my 3D game engine book marathon and go to something more fundamental. More Effective C++ by Scott Meyers is one of those books I have  had on my wishlist for years but just hadn’t got around to reading yet.  I had read the original book  Effective C++ some years ago, and this sequel very much follows the same form. Though slightly dated now, it does cover a good amount of C++ design considerations that will show up in almost any decently complex C++ application.

The book covers a lot of OOP (object oriented programming) concepts and designs, and also a lot of the trouble you can get into using C++ without fully understanding what you are doing. Some of the coverage includes how to use abstract base classes and virtual functions. Specifically Meyers talks about memory management issues with construction and destruction, temporary objects, passing by value versus pointer/reference, and overloading copy/assignment constructors. He also discusses problems with using exceptions, explains how to write a smart pointer class (which is now obsolete with C++11, but still good to understand the implementation), using proxy objects, how to do lazy evaluation, and some various odds and ends.

Overall I found this to be a great text and very helpful, especially the discussion on inheritance and abstract base classes. If you really want to understand C++, warts and all, this should be a required text. However, please read the original title first, as it covers some more fundamental concepts than in the second text. Recommended.

 

Review: Getting Started with UDK

Getting Started w UDK

Right off the bat, I knew this was not going to be an in-depth resource. The book weighs in and a light 120 pages, though the title does say “getting started” so I least they were upfront about it. That said, I did find the book useful and feel it was a good intro text for people unfamiliar with UDK.

Getting Started with UDK by John P. Doran explains how to create a simple tower defense type game using the Epic UDK (Unreal Development Kit). UDK is a free version of the popular Unreal Engine 3, and is targeted toward indie developers. Though the software itself can be downloaded for free, there are various rules in the license as to how content created with the engine can be used. For example, there is a revenue sharing model if you make over a certain amount. Even so, it’s still a great piece of software and certainly a good deal at this price (who can beat free?).

Anyway, this book has only 4 chapters that take you through creating a game. It started with using CSG (constructive solid geometry) to block out a simple level. We use the editor to add various items to the map, like spawn-points for the enemies. Then it moves onto using Kismet, the built-in visual programming language, to add logic to the game. In this part we create some rules, for example, deducting life when the enemies reach the base. We also create some towers that shoot missiles at the enemies. Next we build a GUI and HUD using Flash and Scaleform, and finally cook and package the game for distribution.

I have been meaning to learn more about UDK for a while now, both for work and for my own personal benefit. Mainly, though, since I am working on my own engine I want to make sure I have a firm understanding of what’s out there so I know how to improve upon it. UDK seems very powerful, and it’s fun to play around with an engine that comes with a ton of AAA assets from the start. Working with the engine certainly gives me some ideas, and shows me some things that could be innovated on. I will certainly want to learn more, as I feel this book barely scratches the surface.

However, there were some parts I did not like. Namely, in the first section on Kismet the author skips a crucial step (connecting one node to another). Without this step, the code does not work all (but doesn’t produce any errors either) and the reader is left to wonder if they made a mistake. Thankfully the images in the book show the correct setup, so if you look closely you can figure this out. Even so, this seems like a huge oversight and it’s really sad when authors make careless mistakes like this. Maybe even worse is that almost none of the Kismet logic is explained at all. In the later part of the book there is one part where you are setting up Kismet code for maybe 30 minutes straight, following steps in the book, but without any sort of guidance or explanation. You do eventually get something that works, but with little knowledge of what you are doing in the process. Granted, much of it is self explanatory, but it really should be explained in some fashion.

All in all, this is not a horrible introductory text. If you are already familiar with UDK, you can probably skip this book, but for new-comers this may be an approachable resource. I still don’t feel like I understand even a fraction of the engine, but I do feel at least a bit more confident in moving to a more in-depth book. In addition, the Kindle e-book was a cheap $9.99, so I can’t complain on the price. For the most part, the formatting was good and the images were decent quality, in-color, and zoomable. On the downside, some of the Actionscript code was a little difficult to read due to the word-wrap, but this is a problem across-the-board with programming e-books. Anyway, for $10 this is a great bang-for-your-buck, even at the rather brief 120 pages. I did end up with a functional game at the end, and that counts for a lot.

Review: Freedom™ by Daniel Suarez

Freedom

Personally I hate spoilers, so I will keep this brief. Freedom™ is the sequel to the best-selling book Daemon by Daniel Suarez. If you haven’t read the original, you should go do that now. It’s great.

The premise of the first book is that of a famous game developer that dies, and spawns an AI that goes rouge and starts killing people. It then follows the investigation into the Daemon and the people that try to stop it. The whole thing is an action-packed ride, and is especially fun for anyone into computers or gaming as there are several scenes with hacking and bringing gaming concepts into real-life. There is also a science-fiction element with augmented reality glasses, autonomous robots and things of that nature. Top notch.

This second book, Freedom™, picks up where the first book left off. I don’t really want to explain further as I feel that would give away too much of the first book (if you haven’t read it). That said, I did enjoy this sequel. Granted, it was not as gripping as the original (but what sequel is?). There is a lot of action, but I feel some of the suspense of the first book was lost. However it was still enjoyable and worth reading.

Review: Mathematics for 3D Game Programming and Computer Graphics

3D Math

Mathematics for 3D Game Programming and Computer Graphics by Eric Lengyel is one of those books I have literally been eyeing for years and just never got around to reading. If you are not familiar, Eric Lengyel is the creator of the C4 Engine, and also the author of various game development books. He is well regarded in the community, so I assumed this was a must read title. After reading it, I still agree; it’s an excellent source of knowledge.

The book covers the basic stuff you would expect from a 3D math book: vectors, matrices, quaternions, intersections between various types of geometry, visibility, etc. Great, so the bases are covered. Lengyel goes a bit further, though, and discusses other topics that are very important in computer graphics. For example: lighting and shadowing, decals, curved surfaces, and physics (including fluid and cloth simulation). So a decent amount of topics are covered, but the chapters are still brief enough to finish each in one sitting.

While there are some implementation examples, the text is pretty light on the code. The code that is here is mostly based around OpenGL, however the concepts should still translate to DirectX. Not a huge issue. When needed, he does show code samples, but most of the copy is dedicated to math discussion and the equations.

Granted, some of the equations and proofs were dense and hard to follow. This was made worse by the fact that I was reading this on the Kindle, and the equations were made up of small images you couldn’t zoom in on. Having said that, I still understood most of the concepts, but there were a few times I felt overwhelmed. I can’t really fault the author for that, since his written explanations were all very clear and concise. It’s just some of the content is deep and complex, so be prepared.

All in all, I found this to be a great resource and you can never know enough math in this field. Unfortunately, I will still probably have to look up some of the equations online or in other books due to the low quality of the images in the e-book. But this is a minor complaint compared to the amount of information backed in this title. I would recommend this.