Month 8: DirectX & Software Architecture

I just got done with my eight month here at Full Sail. This month I had DirectX and Software Architecture. DirectX was hard but we learned a great deal. In Software Arch we began looking at whole systems and how to plan out our code. It seems as though the heat is being turned up from here on out and now the classes will get really intense.


In DirectX we learned to use the computer’s devices directly. Wendy taught us to implement sound, graphics and input. We learned how to get input from controllers, render mesh and terrain with lighting using shaders. The class was pretty difficult compared to our past classes but in turn we learned a lot more from the mistakes we made. Remembering physics and linear algebra will help out a lot. The midterm and finals are difficult but it’s important not to get discouraged. I came to realize that some of the things I was doing wrong came from the same mistakes so I learned to check a few things first whenever something went awry. Now I always ask myself “Is the syntax right?” “Is it spelled correctly?” “Is it being called?” and “What is it filled with? (Garbage? Null?)” whenever I start debugging.

In Software Arch Frosty taught us design patterns and how to make UML diagrams. We used Visual Paradigm to make UML diagrams such as class, sequence and case. We also learned design patterns like Singleton, Composite and Factory Method. We implemented these in lab by applying them to game code. We also learned about the different ways of developing a game like Waterfall, eXtreme and SCRUM.

Memento Design Pattern

Design patterns, when dealing with software architecture, utilize the different principles of object oriented programming such as abstraction, encapsulation and inheritance to solve design and structural problems and create more efficient code. One such pattern is Memento, and it can be a very useful one when applied to game design.


The memento pattern allows us to take a snapshot of an object and pass it off to another object for later reference. This is usually accomplished with three objects, the originator, the caregiver and the memento. The originator is the object which has the data we would like to save. The caregiver is the object acting on the originator and receives the snapshot of the originator. The memento is the black box between them which actually is the copy of the data.

To visualize this pattern better let’s compare it to backing up work which you are currently working on. In this example, the originator is the current file which has the data which needs to be backed up before it can be changed. The caregiver is you, the user, the one who will receive the duplicate and then continue to work and make changes to the original. The memento is the backup itself, a snapshot of the file, unaltered, ready to be reopened when need be.

The memento pattern utilizes encapsulation but can break it by accessing class variables directly with a memento class that is a friend of the caretaker or originator. It also utilizes abstraction and reusability by giving us a snapshot of an object at runtime. We can respond to a variety of situations depending on this data. This method is good for utilizing features similar to undo and redo, where reverting to a previous instance is desirable. It can also be used for simulations that require less randomness and more response to hard data.

In games this pattern can be used to implement saving the game by obtaining a memento containing the necessary data to reload the game from a specific point. Another method it can also be used for, in conjunction with the command pattern, is to stack commands and perform sets of actions the same way more than once. It can be used for memory and puzzle games to remember guesses and positions as well as combo counting.

When it comes to games, design patterns can be used in a variety of different ways, sometimes not in the same exact way as they were originally intended for. However this is what makes them a great asset in that we can pick, choose, mix and match what is right for a specific situation and put our own spin on it. So experiment with design patterns like memento and don’t feel bad if the first few times you can’t find a good way to use it. Learn from implementations but more importantly learn from trying and making mistakes.

Red Dead Redemption

To meet some of the developers who worked on this title would have remained just a dream for me. However, these great guys came back to the school that taught them so much to give students like me hope and advice. They touched on a variety of subjects, no stone left unturned. They talked about their influences movies, books and games. They talked about the issues they faced and how it’s impossible to make a perfect game. They also talked about how they deal with the long hours and the methods they use to relax.


They talked about the features and how they had to cut back on many ideas. The physical area of the game was just a quarter of their initial scope! They also mentioned how some of the best features just come about on a whim, like the beginning draw in multiplayer deathmatch. They talked about the benefits and struggles of using Rockstar’s internal engine, RAGE.

However most importantly they talked about how they were in our shoes just a few years ago. Some of them were friends and were able to vouch for each other when it came to their interview. But no matter how each individual got their opportunity to work at Rockstar their message was the same. Networking is the most important skill you can develop, and you should start sharpening it at school. They said no matter how much they work and argue about code at the end of the day they are doing what they love and can still go grab a beer with each other after work.

Month 7: 3D Content Creation & Windows Programming 2

Last month I had 3D Content Creation with Josh Fox and Windows Programming 2 with Chuck Rainey. We continue to learn new things everyday. In 3DCC we got a taste of the Artist's struggle when creating assets for games. In WP2 we learned how to make tools, such as tile editors, to help us create games.

3DCC started out with us learning the content pipeline and basic animation terms. We then got first hand experiance designing models with Maya and levels with Unreal Editor. These tools were very complex but we got a good grasp on their basics from modeling to animation to lighting to texturing. We even coded an exporter to get models from Maya mesh files.

We shifted gears in WP2. Where in WP1 we were focused on Windows based games, in WP2 we were more focused on creating tool to help in the development process. It was a nice change of pace from all the games and simulations we have been writing. It gave us a chance to learn a new skill and to create good self-made tools to have in our programming belts. We utilized the Windows Forms in order to do this and even made our own custom controls like a graphics panel and tool window.